Traffic aus mehreren Regionen bereitstellen

Um Nutzern weltweit schneller Antworten liefern zu können, müssen Dienste in mehreren Regionen bereitgestellt und die Nutzer zur nächstgelegenen Region weitergeleitet werden.

Da Cloud Run-Dienste in einzelnen Regionen bereitgestellt werden, müssen Sie einen externen Application Load Balancer konfigurieren, um Ihre Nutzer zu verschiedenen Regionen Ihres Dienstes weiterzuleiten.

In dieser Anleitung erfahren Sie, wie Sie einen externen Application Load Balancer mit einer Domain konfigurieren, die mit einem verwalteten TLS-Zertifikat geschützt wird und auf eine globale Anycast-IP-Adresse verweist. Über diese Adresse werden die Nutzer zum nächsten Google-Rechenzentrum weitergeleitet, in dem Ihr Dienst bereitgestellt ist.

Die in dieser Anleitung beschriebene Architektur leitet Anfragen nicht automatisch an eine andere Region weiter, wenn ein regionaler Cloud Run-Dienst nicht mehr reagiert oder Fehler zurückgibt. Wenn Sie die Verfügbarkeit Ihres multiregionalen Dienstes erhöhen möchten, können Sie die Ausreißererkennung konfigurieren, um fehlerhafte Cloud Run-Dienste anhand ihrer HTTP-Fehlerrate zu identifizieren und einige Anfragen an eine andere Region weiterzuleiten.

Load-Balancer erstellen

Zum Erstellen eines externen Load Balancers müssen verschiedene Netzwerkressourcen erstellt und miteinander verbunden werden:

Befehlszeile

Reservieren Sie eine statische IP-Adresse, damit Sie Ihre DNS-Einträge bei der Neuerstellung des Load-Balancers nicht aktualisieren müssen.
```
gcloud compute addresses create --global SERVICE_IP
```
Ersetzen Sie im obigen Befehl SERVICE_IP durch einen Namen für die IP-Adressressource (z. B. myservice-ip).
Diese IP-Adresse ist eine globale Anycast-IPv4-Adresse, über die eine Weiterleitung an das Google-Rechenzentrum oder an den Point of Presence erfolgt, der den Besuchern am nächsten liegt.
Erstellen Sie einen Back-End-Dienst.
```
gcloud compute backend-services create --global BACKEND_NAME
```
Ersetzen Sie im obigen Befehl BACKEND_NAME durch einen Namen, den Sie dem Back-End-Dienst geben möchten (z. B. myservice-backend).
Erstellen Sie eine URL-Zuordnung.
```
gcloud compute url-maps create URLMAP_NAME --default-service=BACKEND_NAME
```
Ersetzen Sie URLMAP_NAME durch den Namen, den Sie der URL-Zuordnung zuweisen möchten (z. B. myservice-urlmap).
Erstellen Sie für Ihre Domain ein verwaltetes TLS-Zertifikat, um HTTPS-Traffic bereitzustellen. Ersetzen Sie example.com durch Ihren Domainnamen.
```
gcloud compute ssl-certificates create CERT_NAME \
  --domains=example.com
```
Ersetzen Sie CERT_NAME durch den Namen, den das verwaltete SSL-Zertifikat haben soll (z. B. myservice-cert).
Erstellen Sie einen HTTPS-Ziel-Proxy.
```
gcloud compute target-https-proxies create HTTPS_PROXY_NAME \
  --ssl-certificates=CERT_NAME \
  --url-map=URLMAP_NAME
```
Ersetzen Sie HTTPS_PROXY_NAME durch den Namen, den Sie dem HTTPS-Ziel-Proxy geben möchten (z. B. myservice-https).
Erstellen Sie eine Weiterleitungsregel, um die von Ihnen erstellten Netzwerkressourcen mit der IP-Adresse zu verbinden.
```
gcloud compute forwarding-rules create --global FORWARDING_RULE_NAME \
  --target-https-proxy=HTTPS_PROXY_NAME \
  --address=SERVICE_IP \
  --ports=443
```
Ersetzen Sie FORWARDING_RULE_NAME durch den Namen der Ressource für die Weiterleitungsregel, die Sie erstellen möchten (z. B. myservice-lb).

Terraform

Alternativ zu den in diesem Abschnitt beschriebenen Schritten können Sie das Terraform-Modul für globale HTTP-Load-Balancer verwenden.

Fügen Sie der Terraform-Datei Folgendes hinzu (z. B. main.tf):

Konfigurieren Sie die IP-Adresse:

resource "google_compute_global_address" "lb_default" {
  provider = google-beta
  name     = "myservice-service-ip"

  # Use an explicit depends_on clause to wait until API is enabled
  depends_on = [
    google_project_service.compute_api
  ]
}
output "load_balancer_ip_addr" {
  value = google_compute_global_address.lb_default.address
}

Der IP-Adressressourcenname wird als myservice-service-ip konfiguriert. Sie können das in Ihren eigenen Wert ändern. Diese IP-Adresse ist eine globale Anycast-IPv4-Adresse, über die eine Weiterleitung an das Google-Rechenzentrum oder an den Point of Presence erfolgt, der den Besuchern am nächsten liegt.

Erstellen und konfigurieren Sie den Backend-Dienst:

resource "google_compute_backend_service" "lb_default" {
  provider              = google-beta
  name                  = "myservice-backend"
  load_balancing_scheme = "EXTERNAL_MANAGED"

  backend {
    group = google_compute_region_network_endpoint_group.lb_default[0].id
  }

  backend {
    group = google_compute_region_network_endpoint_group.lb_default[1].id
  }

  # Use an explicit depends_on clause to wait until API is enabled
  depends_on = [
    google_project_service.compute_api,
  ]
}

Diese Ressource konfiguriert den Backend-Dienst sodas er myservice-backend heißt. Sie können das in Ihren eigenen Wert ändern.

URL-Zuordnung konfigurieren

resource "google_compute_url_map" "lb_default" {
  provider        = google-beta
  name            = "myservice-lb-urlmap"
  default_service = google_compute_backend_service.lb_default.id

  path_matcher {
    name            = "allpaths"
    default_service = google_compute_backend_service.lb_default.id
    route_rules {
      priority = 1
      url_redirect {
        https_redirect         = true
        redirect_response_code = "MOVED_PERMANENTLY_DEFAULT"
      }
    }
  }
}

Verbindet die Backend-Dienstressource (myservice-backend) mit der neuen URL-Zuordnungsressource (myservice-lb-urlmap). Sie können diese Werte in Ihre eigenen ändern.

Erstellen Sie für Ihre Domain ein verwaltetes TLS-Zertifikat, um HTTPS-Traffic bereitzustellen. Ersetzen Sie example.com durch Ihren Domainnamen in der Ressource google_compute_managed_ssl_certificate:

resource "google_compute_managed_ssl_certificate" "lb_default" {
  provider = google-beta
  name     = "myservice-ssl-cert"

  managed {
    domains = ["example.com"]
  }
}

Konfigurieren Sie den HTTPS-Proxy:

resource "google_compute_target_https_proxy" "lb_default" {
  provider = google-beta
  name     = "myservice-https-proxy"
  url_map  = google_compute_url_map.lb_default.id
  ssl_certificates = [
    google_compute_managed_ssl_certificate.lb_default.name
  ]
  depends_on = [
    google_compute_managed_ssl_certificate.lb_default
  ]
}

Erstellt die Ressource google_compute_target_https_proxy mit dem Zielnamen myservice-https-proxy und verbindet das zuvor erstellte TLS-Zertifikat (myservice-ssl-cert) und die URL-Zuordnungsressourcen (myservice-lb-urlmap). Sie können diese Werte in Ihre eigenen ändern.

Weiterleitungsregel konfigurieren

resource "google_compute_global_forwarding_rule" "lb_default" {
  provider              = google-beta
  name                  = "myservice-lb-fr"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  target                = google_compute_target_https_proxy.lb_default.id
  ip_address            = google_compute_global_address.lb_default.id
  port_range            = "443"
  depends_on            = [google_compute_target_https_proxy.lb_default]
}

Erstellt die Ressource google_compute_global_forwarding_rule mit dem Zielnamen myservice-https-proxy und verbindet das zuvor erstellte HTTPS-Proxy-Ziel (myservice-https-proxy) und die IP-Adressressource (myservice-service-ip). Sie können diese Werte in Ihre eigenen ändern.

Wenden Sie diese Konfiguration an:

Führen Sie die Schritte in den folgenden Abschnitten aus, um Ihre Terraform-Konfiguration auf ein Google Cloud-Projekt anzuwenden.

Cloud Shell vorbereiten
1. Rufen Sie Cloud Shell auf.
2. Legen Sie das Google Cloud-Standardprojekt fest, auf das Sie Ihre Terraform-Konfigurationen anwenden möchten.
  
  Sie müssen diesen Befehl nur einmal pro Projekt und in jedem beliebigen Verzeichnis ausführen.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
  Umgebungsvariablen werden überschrieben, wenn Sie in der Terraform-Konfigurationsdatei explizite Werte festlegen.
Verzeichnis vorbereiten

Jede Terraform-Konfigurationsdatei muss ein eigenes Verzeichnis haben (auch als Stammmodul bezeichnet).
1. Erstellen Sie in Cloud Shell ein Verzeichnis und eine neue Datei in diesem Verzeichnis. Der Dateiname muss die Erweiterung .tf haben, z. B. main.tf. In dieser Anleitung wird die Datei als main.tf bezeichnet.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
2. Wenn Sie einer Anleitung folgen, können Sie den Beispielcode in jedem Abschnitt oder Schritt kopieren.
  
  Kopieren Sie den Beispielcode in das neu erstellte main.tf.
  
  Kopieren Sie optional den Code aus GitHub. Dies wird empfohlen, wenn das Terraform-Snippet Teil einer End-to-End-Lösung ist.
3. Prüfen und ändern Sie die Beispielparameter, die auf Ihre Umgebung angewendet werden sollen.
4. Speichern Sie die Änderungen.
5. Initialisieren Sie Terraform. Dies ist nur einmal für jedes Verzeichnis erforderlich.
```
terraform init
```
  Fügen Sie optional die Option -upgrade ein, um die neueste Google-Anbieterversion zu verwenden:
```
terraform init -upgrade
```
Änderungen anwenden
1. Prüfen Sie die Konfiguration und prüfen Sie, ob die Ressourcen, die Terraform erstellen oder aktualisieren wird, Ihren Erwartungen entsprechen:
```
terraform plan
```
  Korrigieren Sie die Konfiguration nach Bedarf.
2. Wenden Sie die Terraform-Konfiguration an. Führen Sie dazu den folgenden Befehl aus und geben Sie yes an der Eingabeaufforderung ein:
```
terraform apply
```
  Warten Sie, bis Terraform die Meldung „Apply complete“ anzeigt.
3. Öffnen Sie Ihr Google Cloud-Projekt, um die Ergebnisse aufzurufen. Rufen Sie in der Google Cloud Console Ihre Ressourcen in der Benutzeroberfläche auf, um sicherzustellen, dass Terraform sie erstellt oder aktualisiert hat.
Hinweis: Bei Terraform-Beispielen wird in der Regel davon ausgegangen, dass die erforderlichen APIs in Ihrem Google Cloud-Projekt aktiviert sind.

In mehreren Regionen bereitstellen

Stellen Sie den Dienst in den verfügbaren Cloud Run-Regionen bereit. Zur Vereinfachung der Verwaltung können Sie für mehrere Regionen denselben Dienstnamen verwenden.

Befehlszeile

Wählen Sie Regionen aus, in denen Sie den Dienst verfügbar machen möchten.
Stellen Sie Ihren Cloud Run-Dienst in einzelnen Regionen bereit.
```
gcloud run deploy SERVICE_NAME \
--allow-unauthenticated \
--image=IMAGE_URL \
--region=REGION
```
Ersetzen Sie die folgenden Variablen:
- REGION durch eine der Regionen, in denen Sie die Bereitstellung vornehmen möchten.
- SERVICE_NAME durch den Namen des Dienstes. Durch Verwendung eines einzigen Dienstnamens für mehrere Regionen lassen sich Bereitstellungen in mehreren Regionen leichter im Blick behalten.
- IMAGE_URL durch einen Verweis auf das Container-Image, z. B. us-docker.pkg.dev/cloudrun/container/hello:latest. Wenn Sie Artifact Registry verwenden, muss das Repository REPO_NAME bereits erstellt sein. Die URL hat die Form LOCATION-docker.pkg.dev/PROJECT_ID/REPO_NAME/PATH:TAG.
Wiederholen Sie den vorherigen Schritt für jede Region.

Terraform

Konfiguriert einen Dienst für jede in der Variable run_regions angegebene Region.

resource "google_cloud_run_v2_service" "run_default" {
  provider = google-beta
  count    = length(local.run_regions)
  name     = "myservice-run-app-${local.run_regions[count.index]}"
  location = local.run_regions[count.index]

  template {
    containers {
      image = "us-docker.pkg.dev/cloudrun/container/hello"
    }
  }

  # Use an explicit depends_on clause to wait until API is enabled
  depends_on = [
    google_project_service.run_api
  ]
}

Führt eine Schleife durch alle Regionen aus, die in der Variable run_regions angegeben sind, und benennt jeden neuen Dienst so: myservice-run-app-${var.run_regions[count.index]}. Die Definition des Dienststandortes wird in ähnlicher Weise angewandt. Ersetzen Sie das Standard-Image us-docker.pkg.dev/cloudrun/container/hello" durch Ihr eigenes Image.

Cloud Run-Standorte

Cloud Run ist regional. Die Infrastruktur, in der die Cloud Run-Dienste ausgeführt werden, befindet sich demnach in einer bestimmten Region. Aufgrund der Verwaltung durch Google sind die Anwendungen in allen Zonen innerhalb dieser Region redundant verfügbar.

Bei der Auswahl der Region, in der Ihre Cloud Run-Dienste ausgeführt werden, ist vorrangig, dass die Anforderungen hinsichtlich Latenz, Verfügbarkeit oder Langlebigkeit erfüllt werden. Sie können im Allgemeinen die Region auswählen, die Ihren Nutzern am nächsten liegt, aber Sie sollten den Standort der anderen Google Cloud-Produkte berücksichtigen, die von Ihrem Cloud Run-Dienst verwendet werden. Die gemeinsame Nutzung von Google Cloud-Produkten an mehreren Standorten kann sich auf die Latenz und die Kosten des Dienstes auswirken.

Cloud Run ist in diesen Regionen verfügbar:

Unterliegt Preisstufe 1

asia-east1 (Taiwan)
asia-northeast1 (Tokio)
asia-northeast2 (Osaka)
europe-north1 (Finnland) Niedriger CO₂-Wert
europe-southwest1 (Madrid)
europe-west1 (Belgien) Niedriger CO₂-Ausstoß
europe-west4 (Niederlande)
europe-west8 (Mailand)
europe-west9 (Paris) Niedriger CO₂-Ausstoß
me-west1 (Tel Aviv)
us-central1 (Iowa) Niedriger CO₂-Ausstoß
us-east1 (South Carolina)
us-east4 (Northern Virginia)
us-east5 (Columbus)
us-south1 (Dallas)
us-west1 (Oregon) Niedriger CO₂-Ausstoß

Unterliegt Preisstufe 2

africa-south1 (Johannesburg)
asia-east2 (Hongkong)
asia-northeast3 (Seoul, Südkorea)
asia-southeast1 (Singapur)
asia-southeast2 (Jakarta)
asia-south1 (Mumbai, Indien)
asia-south2 (Delhi, Indien)
australia-southeast1 (Sydney)
australia-southeast2 (Melbourne)
europe-central2 (Warschau, Polen)
europe-west10 (Berlin)
europe-west12 (Turin)
europe-west2 (London, Vereinigtes Königreich) Niedriger CO₂-Ausstoß
europe-west3 (Frankfurt, Deutschland) Niedriger CO₂-Wert
europe-west6 (Zürich, Schweiz) Niedriger CO₂-Ausstoß
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montreal) Niedriger CO₂-Ausstoß
northamerica-northeast2 (Toronto) Niedriger CO₂-Ausstoß
southamerica-east1 (Sao Paulo, Brasilien) Niedriger CO₂-Ausstoß
southamerica-west1 (Santiago, Chile) Niedriger CO₂-Ausstoß
us-west2 (Los Angeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Wenn Sie bereits einen Cloud Run-Dienst erstellt haben, können Sie dessen Region im Cloud Run-Dashboard der Google Cloud Console aufrufen.

Regionale Netzwerk-Endpunktgruppen konfigurieren

Für jede Region, in der Sie im vorherigen Schritt eine Bereitstellung vorgenommen haben, müssen Sie serverlose Netzwerk-Endpunktgruppen (NEGs) erstellen und diese dem Backend-Dienst hinzufügen. Gehen Sie dazu folgendermaßen vor:

Befehlszeile

Erstellen Sie eine Netzwerk-Endpunktgruppe für den Cloud Run-Dienst in REGION:
```
gcloud compute network-endpoint-groups create NEG_NAME \
            --region=REGION \
            --network-endpoint-type=SERVERLESS \
            --cloud-run-service=SERVICE_NAME
```
Ersetzen Sie im obigen Befehl Folgendes:
- NEG_NAME durch den Namen der Netzwerk-Endpunktgruppenressource (z. B. „myservice-neg-uscentral1“)
- REGION durch die [region][Standort], in der Ihr Dienst bereitgestellt wird.
- SERVICE_NAME durch den Namen des Dienstes.

Fügen Sie dem Backend-Dienst die Netzwerk-Endpunktgruppe hinzu:

gcloud compute backend-services add-backend --global BACKEND_NAME \
          --network-endpoint-group-region=REGION \
          --network-endpoint-group=NEG_NAME

Geben Sie den Namen für NEG_NAME an, den Sie im vorherigen Schritt für die Region festgelegt haben.

Wiederholen Sie diese Schritte für jede Region.

Terraform

Konfigurieren Sie eine Netzwerk-Endpunktgruppe mit dem Namen myservice-neg für den Cloud Run-Dienst für jede Region, die in der Variable run_regions angegeben ist:

resource "google_compute_region_network_endpoint_group" "lb_default" {
  provider              = google-beta
  count                 = length(local.run_regions)
  name                  = "myservice-neg"
  network_endpoint_type = "SERVERLESS"
  region                = local.run_regions[count.index]
  cloud_run {
    service = google_cloud_run_v2_service.run_default[count.index].name
  }
}

Konfigurieren Sie einen Backend-Dienst, um die Netzwerk-Endpunktgruppe (myservice-neg) anzuhängen:

resource "google_compute_backend_service" "lb_default" {
  provider              = google-beta
  name                  = "myservice-backend"
  load_balancing_scheme = "EXTERNAL_MANAGED"

  backend {
    group = google_compute_region_network_endpoint_group.lb_default[0].id
  }

  backend {
    group = google_compute_region_network_endpoint_group.lb_default[1].id
  }

  # Use an explicit depends_on clause to wait until API is enabled
  depends_on = [
    google_project_service.compute_api,
  ]
}

DNS-Einträge in Ihrer Domain konfigurieren

Damit der Domainname auf die von Ihnen erstellte Weiterleitungsregel verweist, müssen Sie die DNS-Einträge mit der von Ihnen erstellten IP-Adresse aktualisieren.

Führen Sie den folgenden Befehl aus, um die reservierte IP-Adresse des Load-Balancers zu ermitteln:
```
  gcloud compute addresses describe --global SERVICE_IP --format='value(address)'
```
Ersetzen Sie SERVICE_IP durch den Namen der zuvor erstellten IP-Adresse. Mit diesem Befehl wird die IP-Adresse in der Ausgabe angegeben.
Aktualisieren Sie die DNS-Einträge Ihrer Domain. Fügen Sie dazu einen A-Eintrag mit dieser IP-Adresse hinzu.

Benutzerdefinierte Zielgruppe bei Verwendung authentifizierter Dienste konfigurieren

Authentifizierte Dienste sind durch IAM geschützt. Solche Cloud Run-Dienste erfordern eine Clientauthentifizierung, die den vorgesehenen Empfänger einer Anfrage zum Zeitpunkt der Erstellung von Anmeldedaten deklariert (die Zielgruppe).

Das Ziel ist in der Regel die vollständige URL des Zieldienstes, die für Cloud Run-Dienste standardmäßig eine generierte URL ist, die auf run.app endet. In einer multiregionalen Bereitstellung ist es jedoch nicht möglich, dass ein Client im Voraus weiß, an welchen regionalen Dienst eine Anfrage weitergeleitet wird. Konfigurieren Sie Ihren Dienst für eine multiregionale Bereitstellung so, dass benutzerdefinierte Zielgruppen verwendet werden.

Auf Bereitstellung des Load-Balancers warten

Nachdem Sie die Domain mit der IP-Adresse des Load-Balancers konfiguriert haben, müssen Sie etwas warten, bis die DNS-Einträge übernommen werden. Ebenso dauert es eine gewisse Zeit, bis das verwaltete TLS-Zertifikat für Ihre Domain ausgestellt wurde und bereit ist, HTTPS-Traffic weltweit bereitzustellen.

Es kann bis zu 30 Minuten dauern, bis der Load-Balancer Traffic bereitstellt.

Anschließend können Sie testweise die Website über die URL mit dem Präfix https:// aufrufen.

Status bestätigen

So prüfen Sie den Status der Weitergabe von DNS-Einträgen mit dem dig-Befehlszeilentool:
```
dig A +short example.com
```
Die Ausgabe sollte die IP-Adresse enthalten, die Sie in Ihren DNS-Einträgen konfiguriert haben.
Führen Sie folgenden Befehl aus, um den Status der Ausstellung Ihres verwalteten Zertifikats zu prüfen:
```
gcloud compute ssl-certificates describe CERT_NAME
```
Ersetzen Sie CERT_NAME durch den Namen, den Sie zuvor für die SSL-Zertifikatsressource ausgewählt haben.

Die Ausgabe sollte eine Zeile mit status: ACTIVE enthalten.

HTTP-zu-HTTPS-Weiterleitung einrichten

Standardmäßig verarbeitet eine Weiterleitungsregel nur ein einzelnes Protokoll, sodass bei Anfragen an Ihre http://-Endpunkte die Meldung „404 Nicht gefunden“ angezeigt wird. Wenn Anfragen an Ihre http://-URLs zum https://-Protokoll weitergeleitet werden sollen, müssen Sie mithilfe der folgenden Anleitung eine zusätzliche URL-Zuordnung und eine Weiterleitungsregel erstellen:

Befehlszeile

Erstellen Sie eine URL-Zuordnung mit einer Weiterleitungsregel.

gcloud compute url-maps import HTTP_URLMAP_NAME \
          --global \
          --source /dev/stdin <<EOF
        name: HTTP_URLMAP_NAME
        defaultUrlRedirect:
          redirectResponseCode: MOVED_PERMANENTLY_DEFAULT
          httpsRedirect: True
        EOF

Ersetzen Sie dabei HTTP_URLMAP_NAME durch den Namen der URL-Zuordnungsressource, die Sie erstellen möchten, z. B. myservice-httpredirect.

Erstellen Sie einen HTTP-Ziel-Proxy mit der URL-Zuordnung.
```
gcloud compute target-http-proxies create HTTP_PROXY_NAME \
          --url-map=HTTP_URLMAP_NAME
```
Ersetzen Sie dabei HTTP_PROXY_NAME durch den Namen des HTTP-Ziel-Proxys, den Sie erstellen möchten, z. B. myservice-http.

Erstellen Sie eine Weiterleitungsregel auf Port 80 mit derselben reservierten IP-Adresse.

gcloud compute forwarding-rules create --global HTTP_FORWARDING_RULE_NAME \
          --target-http-proxy=HTTP_PROXY_NAME \
          --address=SERVICE_IP \
          --ports=80 \

Ersetzen Sie dabei HTTP_FORWARDING_RULE_NAME durch den Namen der neuen Weiterleitungsregel, die Sie erstellen möchten, z. B. myservice-httplb.

Terraform

Erstellen Sie eine URL-Zuordnungsressource mit einer Weiterleitungsregel.

resource "google_compute_url_map" "https_default" {
  provider = google-beta
  name     = "myservice-https-urlmap"

  default_url_redirect {
    redirect_response_code = "MOVED_PERMANENTLY_DEFAULT"
    https_redirect         = true
    strip_query            = false
  }
}

Erstellen Sie einen HTTP-Ziel-Proxy mit der neu erstellten URL-Zuordnungsressource (myservice-https-urlmap):

resource "google_compute_target_http_proxy" "https_default" {
  provider = google-beta
  name     = "myservice-http-proxy"
  url_map  = google_compute_url_map.https_default.id

  depends_on = [
    google_compute_url_map.https_default
  ]
}

Erstellen Sie eine Weiterleitungsregel auf Port 80 mit derselben reservierten IP-Adressen-Ressource (myservice-http-proxy).

resource "google_compute_global_forwarding_rule" "https_default" {
  provider   = google-beta
  name       = "myservice-https-fr"
  target     = google_compute_target_http_proxy.https_default.id
  ip_address = google_compute_global_address.lb_default.id
  port_range = "80"
  depends_on = [google_compute_target_http_proxy.https_default]
}

Authentifizierte Pub/Sub-Push-Abos mit Bereitstellung in mehreren Regionen verwenden

Ein Pub/Sub-Dienst sendet standardmäßig Nachrichten an Push-Endpunkte in derselben Google Cloud-Region, in der der Pub/Sub-Dienst die Nachrichten speichert. Eine Behelfslösung für dieses Verhalten finden Sie unter Authentifiziertes Pub/Sub-Push-Abo mit einer multiregionalen Cloud Run-Bereitstellung verwenden.

Traffic aus mehreren Regionen bereitstellen

Load-Balancer erstellen

Befehlszeile

Terraform

Cloud Shell vorbereiten

Verzeichnis vorbereiten

Änderungen anwenden

In mehreren Regionen bereitstellen

Befehlszeile

Terraform

Cloud Run-Standorte

Unterliegt Preisstufe 1

Unterliegt Preisstufe 2

Regionale Netzwerk-Endpunktgruppen konfigurieren

Befehlszeile

Terraform

DNS-Einträge in Ihrer Domain konfigurieren

Benutzerdefinierte Zielgruppe bei Verwendung authentifizierter Dienste konfigurieren

Auf Bereitstellung des Load-Balancers warten

Status bestätigen

HTTP-zu-HTTPS-Weiterleitung einrichten

Befehlszeile

Terraform

Authentifizierte Pub/Sub-Push-Abos mit Bereitstellung in mehreren Regionen verwenden