NoSQL-Clientserver

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Architektur

Der NoSQL-Clientserver konfiguriert und erstellt zwei Compute Engine-Instanzen:

  • Server: führt MongoDB aus.
  • Client: Führt eine benutzerdefinierte Go-Anwendung aus, die mit MongoDB spricht und dann eine API freigibt, in der Sie Daten aus MongoDB nutzen.

Jetzt starten

Klicken Sie auf den folgenden Link, um eine Kopie des Quellcodes in Cloud Shell zu erhalten. Dort wird mit einem einzigen Befehl eine funktionierende Kopie der Anwendung in Ihrem Projekt erstellt.

In Cloud Shell öffnen

Quellcode auf GitHub ansehen


Komponenten des NoSQL-Clientservers

Die NoSQL-Clientserver-Architektur nutzt ein einziges Produkt. Im Folgenden werden das Produkt sowie weitere Informationen hervorgehoben, darunter Links zu ähnlichen Videos, Produktdokumentationen und interaktiven Schritt-für-Schritt-Anleitungen.
Video Docs Schritt-für-Schritt-Anleitungen
Compute Engine Compute Engine ist die virtuelle Technologie von Google Cloud. Damit können Sie viele verschiedene VM-Konfigurationen erstellen, die sich an die Form Ihrer Computing-Anforderungen anpassen.

Skripts

Das Installationsskript verwendet eine ausführbare Datei, die in go und den Terraform-Befehlszeilentools geschrieben wurde, um ein leeres Projekt zu übernehmen und die Anwendung darin zu installieren. Die Ausgabe sollte eine funktionierende Anwendung und eine URL für die IP-Adresse des Load-Balancings sein.

./main.tf

Dienste aktivieren

Google Cloud-Dienste sind in einem Projekt standardmäßig deaktiviert. Zur Verwendung einer dieser Lösungen müssen wir Folgendes aktivieren:

  • Compute Engine – virtuelle Maschinen und Netzwerke
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
}

Firewallregel erstellen

Es wird eine Regel erstellt, die Port 80 für die Firewall öffnet und dann auf jede Maschine mit dem Label http-server anwendet.

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"]
}

Serverinstanz erstellen

Stellt eine VM zusammen, die als Server fungiert und MongoDB bereitstellt

# 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]
}

Clientinstanz erstellen

Inbetriebnahme einer VM, die als Client fungiert und Daten aus MongoDB nutzt

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]
}

Fazit

Nach der Ausführung sollten Sie nun eine Client Server API mit MongoDB haben, die auf zwei Compute Engine-Instanzen ausgeführt wird. Außerdem sollten Sie den gesamten Code haben, um diese Lösung an Ihre Umgebung anzupassen.