Cette page a été traduite par l'API Cloud Translation.

Client-serveur NoSQL

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

Serveur : qui exécutera MongoDB
Client : exécute une application Go personnalisée qui communique avec MongoDB, puis expose une API à partir de laquelle vous consommez des données MongoDB.

Premiers pas

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

Afficher le code source sur GitHub

Composants du serveur client NoSQL

L'architecture client-serveur NoSQL utilise un produit clé. Le produit est mis en avant, avec des informations supplémentaires, y compris des liens vers des vidéos, des documentations et des tutoriels interactifs associés.

			Vidéo	Documentation	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 de calcul.

Scripts

Le script d'installation utilise un exécutable écrit en go et des outils de la CLI Terraform pour prendre un projet vide et y installer l'application. La sortie doit être une application fonctionnelle et une URL pour l'adresse IP d'équilibrage de charge.

`./main.tf`

Activer les services

Les services Google Cloud sont désactivés par défaut dans un projet. Pour utiliser l'une des solutions ci-dessous, 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, puis l'applique à toute machine associée au libellé 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

Lance une VM qui servira de serveur et hébergera 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 cliente

Lance une VM qui jouera le rôle de client et consommera des données à partir 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 devriez disposer d'une API client-serveur utilisant MongoDB sur deux instances Compute Engine. Vous devez également disposer de tout le code nécessaire pour modifier ou étendre cette solution en fonction de votre environnement.