Serveur client NoSQL

Architecture

Le serveur client NoSQL configure et crée deux instances Compute Engine:

  • Server (Serveur) : exécutera MongoDB.
  • Client : qui exécute une application Go personnalisée qui communique avec MongoDB, puis expose une API dans laquelle vous consommez les données de MongoDB

Commencer

Cliquez sur le lien suivant pour copier le code source dans Cloud Shell. Une seule commande permet alors de lancer une copie de travail de l'application dans votre projet.

Ouvrir dans Cloud Shell

Afficher le code source sur GitHub


Composants du serveur client NoSQL

L'architecture du serveur client NoSQL utilise un produit clé. La section suivante présente ce produit, ainsi que d'autres informations, y compris des liens vers des vidéos associées, de la documentation produit et des tutoriels interactifs.
Vidéo Docs Tutoriels
Compute Engine Compute Engine est la technologie virtuelle de Google Cloud. Vous pouvez ainsi lancer de nombreuses configurations de VM différentes pour répondre à vos besoins informatiques.

Scripts

Le script d'installation utilise un exécutable écrit dans go et les outils de la CLI Terraform pour prendre un projet vide et y installer l'application. Le résultat doit correspondre à une application fonctionnelle et à une URL pour l'adresse IP de l'équilibrage de charge.

./main.tf

Activer les services

Les services Google Cloud sont désactivés par défaut dans les projets. Pour utiliser l'une de ces solutions, nous devons activer les éléments suivants:

  • Compute Engine : machines virtuelles et mise en réseau
variable "gcp_service_list" {
    description = "The list of apis necessary for the project"
    type        = list(string)
    default = [
        "compute.googleapis.com",
    ]
}

resource "google_project_service" "all" {
  for_each                   = toset(var.gcp_service_list)
  project                    = var.project_number
  service                    = each.key
  disable_dependent_services = false
  disable_on_destroy         = false
}

Créer une règle de pare-feu

Crée une règle qui ouvre le port 80 sur le pare-feu et l'applique à toute machine étiquetée http-server

resource "google_compute_firewall" "default-allow-http" {
  name    = "deploystack-allow-http"
  project = var.project_number
  network = "projects/${var.project_id}/global/networks/default"

  allow {
    protocol = "tcp"
    ports    = ["80"]
  }

  source_ranges = ["0.0.0.0/0"]

  target_tags = ["http-server"]
}

Créer une instance de serveur

Il lance une VM qui agira en tant que serveur et diffusera MongoDB.

# Create Instances
resource "google_compute_instance" "server" {
  name         = "server"
  zone         = var.zone
  project      = var.project_id
  machine_type = "e2-standard-2"
  tags         = ["http-server"]

  boot_disk {
    auto_delete = true
    device_name = "server"
    initialize_params {
      image = "family/ubuntu-1804-lts"
      size  = 10
      type  = "pd-standard"
    }
  }

  network_interface {
    network = "default"
    access_config {
      // Ephemeral public IP
    }
  }

  metadata_startup_script = <<SCRIPT
    apt-get update
    apt-get install -y mongodb
    service mongodb stop
    sed -i 's/bind_ip = 127.0.0.1/bind_ip = 0.0.0.0/' /etc/mongodb.conf
    iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 27017
    service mongodb start
  SCRIPT
  depends_on              = [google_project_service.all]
}

Créer une instance client

Il lance une VM qui agira en tant que client et consommera les données de MongoDB.

resource "google_compute_instance" "client" {
  name         = "client"
  zone         = var.zone
  project      = var.project_id
  machine_type = "e2-standard-2"
  tags         = ["http-server", "https-server"]

  boot_disk {
    auto_delete = true
    device_name = "client"
    initialize_params {
      image = "family/ubuntu-1804-lts"
      size  = 10
      type  = "pd-standard"
    }
  }

  network_interface {
    network = "default"

    access_config {
      // Ephemeral public IP
    }
  }

  metadata_startup_script = <<SCRIPT
    add-apt-repository ppa:longsleep/golang-backports -y && \
    apt update -y && \
    apt install golang-go -y
    mkdir /modcache
    mkdir /go
    mkdir /app && cd /app
    curl https://raw.githubusercontent.com/GoogleCloudPlatform/golang-samples/main/compute/quickstart/compute_quickstart_sample.go --output main.go
    go mod init exec
    GOPATH=/go GOMODCACHE=/modcache GOCACHE=/modcache go mod tidy
    GOPATH=/go GOMODCACHE=/modcache GOCACHE=/modcache go get -u
    sed -i 's/mongoport = "80"/mongoport = "27017"/' /app/main.go
    echo "GOPATH=/go GOMODCACHE=/modcache GOCACHE=/modcache HOST=${google_compute_instance.server.network_interface.0.network_ip} go run main.go"
    GOPATH=/go GOMODCACHE=/modcache GOCACHE=/modcache HOST=${google_compute_instance.server.network_interface.0.network_ip} go run main.go &
  SCRIPT

  depends_on = [google_project_service.all]
}

Conclusion

Une fois l'exécution terminée, vous devez disposer d'une API de serveur client utilisant MongoDB en cours d'exécution sur deux instances Compute Engine. De plus, vous devez disposer de tout le code nécessaire pour modifier ou étendre cette solution afin de l'adapter à votre environnement.