Traffic aus mehreren Regionen bereitstellen

gcloud-CLI

1. Reservieren Sie eine statische IP-Adresse, damit Sie Ihre DNS-Einträge bei der Neuerstellung Ihres 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.

2. 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).

3. 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).

4. 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).

5. Erstellen Sie einen Ziel-HTTPS-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).

6. 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):

1. 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.

2. 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.

3. 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.

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

5. 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.

6. 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.

7. 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.

gcloud-CLI

1. 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 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.

2. 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.

3. Wiederholen Sie die vorherigen Schritte für jede Region.

Terraform

1. 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
     }
   }

2. 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,
     ]
   }

gcloud-CLI

1. 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.

2. 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.

3. 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

1. 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
     }
   }

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

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