Server client NoSQL

Il server client NoSQL configurerà e creerà due istanze Compute Engine:

• Server, che eseguirà MongoDB
• Client: eseguirà un'applicazione Go personalizzata che comunica con MongoDB e poi espone un'API in cui consumi i dati di MongoDB

---

Inizia

Fai clic sul seguente link per una copia del codice sorgente in Cloud Shell. Una volta lì, un singolo comando avvierà una copia funzionante dell'applicazione nel tuo progetto.

Punto chiave: facendo clic sul link seguente si aprirà una sessione Cloud Shell e verrà scaricato il codice da GitHub. Dovrai autorizzare l'esecuzione di DeployStack. Non verranno intraprese azioni fino a quando non lo farai.

Visualizza il codice sorgente su GitHub

---

Componenti del server client NoSQL

L'architettura client server NoSQL utilizza un prodotto chiave. Di seguito viene messo in evidenza il prodotto, insieme a ulteriori informazioni, inclusi link a video correlati, documentazione del prodotto e walkthrough interattivi.

			Video	Documenti	Procedure dettagliate
	Compute Engine	Compute Engine è la tecnologia virtuale di Google Cloud. Con questo strumento puoi avviare molte configurazioni diverse di VM per adattarle alle tue esigenze di calcolo.

---

Script

Lo script di installazione utilizza un file eseguibile scritto in go e negli strumenti CLI di Terraform per prendere un progetto vuoto e installarvi l'applicazione. L'output deve essere un'applicazione funzionante e un URL per l'indirizzo IP del bilanciamento del carico.

Nota: di seguito è riportata una suddivisione dei comandi eseguiti durante il deployment del server client NoSQL. Non è necessario eseguire ogni comando singolarmente. Fai clic sul pulsante Apri in Cloud Shell nella sezione Inizia e poi esegui tutti i comandi.

./main.tf

Attiva i servizi

I servizi Google Cloud sono disabilitati in un progetto per impostazione predefinita. Per utilizzare una qualsiasi delle soluzioni riportate di seguito, dobbiamo attivare quanto segue:

• Compute Engine: macchine virtuali e reti

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
}

Crea regola firewall

Crea una regola che apra la porta 80 sul firewall e poi la applichi a qualsiasi computer etichettato come 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"]
}

Crea istanza di server

Avvia una VM che fungerà da server e servirà 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]
}

Crea istanza client

Avvia una VM che fungerà da client e consumerà i dati da 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]
}

---

Conclusione

Al termine dell'esecuzione, dovresti avere un'API client server che utilizza MongoDB in esecuzione su due istanze Compute Engine. Inoltre, dovresti disporre di tutto il codice necessario per modificare o estendere questa soluzione in base al tuo ambiente.