Eine minimale Einrichtung für einen Hochverfügbarkeitsdienst mit Cloud Run

In diesem Blog-Beitrag erkläre ich, was erforderlich ist, um einen Webdienst einzurichten, der in mehreren GCP-Regionen läuft.
Die wichtigsten Gründe für die Bereitstellung Ihres Dienstes in mehr als einer Region sind:

• Verarbeiten Sie Ausfälle einzelner Regionen, damit Ihre Anwendung hochverfügbar ist.
• Leiten Sie den Datenverkehr in die nächstgelegene Region um, damit Ihre Nutzer schnellere Ladezeiten erleben.

Cloud Run Bereitstellungen erstellen

Ein Cloud Run-Dienst lebt nur in einer einzigen Region. Für eine Einrichtung mit mehreren Regionen müssen wir also denselben Container in mehreren Regionen bereitstellen.
Da wir zum Glück eine Terraform for_each -Schleife verwenden, erfordert dies keine allzu große zusätzliche Konfiguration:

locals {
  locations = ["europe-west4", "europe-west1"]
}

resource "google_cloud_run_service" "service" {
  for_each = toset(local.locations)

  name     = "service-${each.key}"
  location = each.key

  ...
}

Ich empfehle, den Namen der Region im Namen des Cloud Run-Dienstes zu verwenden, damit Sie sie leicht finden können und die Einzigartigkeit gewährleistet ist.

Wir verwenden local.locations, um die Regionen zu definieren, in denen wir bereitstellen möchten, damit wir diese Konfiguration in anderen Ressourcen wiederverwenden können.

Lastausgleich am Eingang einrichten

Standardmäßig gibt Cloud Run einem Dienst eine öffentlich zugängliche .run.app URL.
Diese verweist jedoch auf einen einzigen Cloud Run-Dienst, und für ein Set mit mehreren Regionen benötigen wir mehrere Dienste.
Dazu müssen wir einen Global Load Balancer erstellen, der Serverless Network Endpoint Groups (NEGs) als Backend verwendet.
Diese NEGs leiten den Datenverkehr dann an die Cloud Run-Instanzen weiter. Lassen Sie uns die benötigte Ressource für unseren Ingress-Stack einrichten:

resource "google_compute_global_address" "ip" {
  name = "service-ip"
}

resource "google_compute_region_network_endpoint_group" "neg" {
  for_each = toset(local.locations)

  name                  = "neg-${each.key}"
  network_endpoint_type = "SERVERLESS"
  region                = each.key

  cloud_run {
    service = google_cloud_run_service.service[each.key].name
  }
}

resource "google_compute_backend_service" "backend" {
  name     = "backend"
  protocol = "HTTP"

  dynamic "backend" {
    for_each = toset(local.locations)

    content {
      group = google_compute_region_network_endpoint_group.neg[backend.key].id
    }
  }
}

resource "google_compute_url_map" "url_map" {
  name            = "url-map"
  default_service = google_compute_backend_service.backend.id
}

resource "google_compute_target_http_proxy" "http_proxy" {
  name    = "http-proxy"
  url_map = google_compute_url_map.url_map.id
}

resource "google_compute_global_forwarding_rule" "frontend" {
  name       = "frontend"
  target     = google_compute_target_http_proxy.http_proxy.id
  port_range = "80"
  ip_address = google_compute_global_address.ip.address
}

Beachten Sie, dass wir local.locations wiederverwenden, um die regionalen Ressourcen zu erstellen.

Allerdings kann noch niemand unseren Dienst aufrufen, denn wir müssen GCP mitteilen, dass es sich um einen öffentlichen Dienst handelt, der von jedem aufgerufen werden kann:

data "google_iam_policy" "noauth" {
  binding {
    role    = "roles/run.invoker"
    members = ["allUsers"]
  }
}

resource "google_cloud_run_service_iam_policy" "noauth" {
  for_each = toset(local.locations)

  service     = google_cloud_run_service.service[each.key].name
  location    = google_cloud_run_service.service[each.key].location
  policy_data = data.google_iam_policy.noauth.policy_data
}

Einsetzen und Aufrufen des Dienstes

Fügen wir eine Ausgabe für die statische IP-Adresse hinzu, damit wir wissen, was wir nach der Bereitstellung aufrufen müssen:

output "static_ip" {
  value = google_compute_global_address.ip.address
}

Führen Sie nun terraform apply aus, um alles bereitzustellen und zu überprüfen, ob der "Hello World"-Container zurückgegeben wird (z. B. mit curl $(terraform output --raw static_ip)). Die Google Cloud Console bietet auch einen schönen visuellen Überblick darüber, wie die Anfragen weitergeleitet werden: Jetzt wissen Sie, wie Sie Google Cloud Run-Dienste in mehreren Regionen einsetzen können. Probieren Sie es mit PrivateBin aus!

Bonus: Aktivieren Sie Cloud CDN für noch schnellere Ladezeiten

Um zu verhindern, dass statische Assets von Ihrem Container ausgeliefert werden, können Sie Cloud CDN aktivieren, damit diese automatisch von den Edge-Standorten des Cloud-Speichers und nicht vom Container selbst ausgeliefert werden.
Cloud CDN erkennt automatisch, bei welchen Routen es sich um statische Ressourcen handelt, aber Sie können diese Konfiguration auch manuell überschreiben. Fügen Sie einfach das Flag enable_cnd zur Backend-Service-Ressource hinzu:

resource "google_compute_backend_service" "backend" {
  name       = "backend"
  protocol   = "HTTP"
  enable_cdn = true

  ...
}

Fazit

Standardmäßig kann ein einzelner Cloud Run-Dienst nur in einer Region bereitgestellt werden.
Durch die Verwendung eines globalen Load Balancers können wir einen Cloud Run-Dienst in mehreren Regionen bereitstellen, um hohe Verfügbarkeit und niedrige Latenzzeiten zu erreichen.
Mit der for_each Schleifenfunktion von Terraform ist dies sehr einfach einzurichten.