Gestisci il traffico da più regioni

Per fornire risposte più rapide agli utenti in tutto il mondo, devi eseguire il deployment dei servizi in più regioni e instradare gli utenti alla regione più vicina.

Poiché il deployment dei servizi Cloud Run viene eseguito in singole regioni, devi configurare un bilanciatore del carico delle applicazioni esterno per instradare gli utenti a diverse regioni del tuo servizio.

Questa guida mostra come configurare un bilanciatore del carico delle applicazioni esterno con un dominio protetto con un certificato TLS gestito che rimanda a un indirizzo IP anycast globale, che instrada gli utenti al data center Google più vicino in cui è stato eseguito il deployment del tuo servizio.

L'architettura descritta in questa guida non instrada automaticamente le richieste a un'altra regione quando un servizio Cloud Run a livello di regione non risponde o inizia a restituire errori. Per aumentare la disponibilità del tuo servizio multiregionale, puoi configurare il rilevamento di outlier per identificare i servizi Cloud Run in stato non integro in base alla percentuale di errori HTTP e trasferire alcune richieste a un'altra regione.

Crea un bilanciatore del carico

La creazione di un bilanciatore del carico esterno prevede la creazione di diverse risorse di networking e la loro connessione:

Riga di comando

  1. Prenotare un indirizzo IP statico in modo da non dover aggiornare i record DNS quando ricrei il bilanciatore del carico.
    gcloud compute addresses create --global SERVICE_IP
    Nel comando riportato sopra, sostituisci SERVICE_IP con un nome per la risorsa dell'indirizzo IP (ad es. myservice-ip).

    Questo indirizzo IP è un indirizzo IPv4 anycast globale che instrada al data center Google o al punto di presenza più vicino ai tuoi visitatori.

  2. Crea un servizio di backend.
    gcloud compute backend-services create --global BACKEND_NAME

    Nel comando riportato sopra, sostituisci BACKEND_NAME con un nome che vuoi assegnare al servizio di backend (ad esempio myservice-backend).

  3. Crea una mappa URL
    gcloud compute url-maps create URLMAP_NAME --default-service=BACKEND_NAME

    Sostituisci URLMAP_NAME con il nome che vuoi assegnare alla mappa URL (ad es. myservice-urlmap).

  4. Crea un certificato TLS gestito per il tuo dominio per gestire il traffico HTTPS. Sostituisci example.com con il tuo nome di dominio.
    gcloud compute ssl-certificates create CERT_NAME \
      --domains=example.com

    Sostituisci CERT_NAME con il nome che vuoi assegnare al certificato SSL gestito (ad esempio, myservice-cert).

  5. Creare un proxy HTTPS di destinazione.
    gcloud compute target-https-proxies create HTTPS_PROXY_NAME \
      --ssl-certificates=CERT_NAME \
      --url-map=URLMAP_NAME

    Sostituisci HTTPS_PROXY_NAME con il nome che vuoi assegnare al proxy HTTPS di destinazione (ad es. myservice-https).

  6. Creare una regola di forwarding che colleghi le risorse di networking create all'indirizzo IP.
    gcloud compute forwarding-rules create --global FORWARDING_RULE_NAME \
      --target-https-proxy=HTTPS_PROXY_NAME \
      --address=SERVICE_IP \
      --ports=443

    Sostituisci FORWARDING_RULE_NAME con il nome della risorsa della regola di forwarding che vuoi creare (ad es. myservice-lb).

Terraform

In alternativa ai passaggi descritti in questa sezione, puoi utilizzare il modulo Terraform del bilanciatore del carico HTTP globale.

Aggiungi quanto segue al tuo file Terraform (ad esempio main.tf):

  1. Configura l'indirizzo IP:

    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
    }

    Configura il nome della risorsa del tuo indirizzo IP in modo che sia myservice-service-ip. Puoi modificarlo inserendo il tuo valore. Questo indirizzo IP è un indirizzo IPv4 anycast globale che instrada al data center Google o al punto di presenza più vicino ai tuoi visitatori.

  2. Crea e configura il servizio di backend:

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

    Questa risorsa configura il servizio di backend in modo che venga denominato myservice-backend. Puoi modificarlo inserendo il tuo valore.

  3. Configura la mappa URL:

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

    Connette la risorsa del servizio di backend (myservice-backend) alla nuova risorsa della mappa URL (myservice-lb-urlmap). Puoi modificarli utilizzando i tuoi valori.

  4. Crea un certificato TLS gestito per il tuo dominio per gestire il traffico HTTPS. Sostituisci example.com con il tuo nome di dominio nella risorsa 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. Configura il proxy HTTPS:

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

    Crea la risorsa google_compute_target_https_proxy con il nome della destinazione myservice-https-proxy e connette il certificato TLS (myservice-ssl-cert) e le risorse di mappatura degli URL (myservice-lb-urlmap) create in precedenza. Puoi modificarle con i tuoi valori.

  6. Configura la regola di forwarding:

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

    Crea la risorsa google_compute_global_forwarding_rule con nome di destinazione myservice-https-proxy e connette la risorsa di destinazione del proxy HTTPS (myservice-https-proxy) e la risorsa indirizzo IP (myservice-service-ip) create in precedenza. Puoi modificarle con i tuoi valori.

  7. Applica questa configurazione:

    Per applicare la configurazione Terraform in un progetto Google Cloud, completa i passaggi nelle sezioni seguenti.

    prepara Cloud Shell

    1. Avvia Cloud Shell.
    2. Imposta il progetto Google Cloud predefinito a cui vuoi applicare le configurazioni Terraform.

      Devi eseguire questo comando una sola volta per progetto e puoi eseguirlo in qualsiasi directory.

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID

      Se imposti valori espliciti nel file di configurazione Terraform, le variabili di ambiente vengono sostituite.

    Prepara la directory

    Ogni file di configurazione Terraform deve avere una propria directory (detta anche modulo principale).

    1. In Cloud Shell, crea una directory e un nuovo file al suo interno. Il nome del file deve avere l'estensione .tf, ad esempio main.tf. In questo tutorial, il file è indicato come main.tf.
      mkdir DIRECTORY && cd DIRECTORY && touch main.tf
    2. Se stai seguendo un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.

      Copia il codice campione nel file main.tf appena creato.

      Se vuoi, copia il codice da GitHub. Questa opzione è consigliata se lo snippet Terraform fa parte di una soluzione end-to-end.

    3. Esamina e modifica i parametri di esempio da applicare al tuo ambiente.
    4. Salva le modifiche.
    5. Inizializza Terraform. Devi eseguire questa operazione una sola volta per directory.
      terraform init

      Facoltativamente, per utilizzare la versione più recente del provider Google, includi l'opzione -upgrade:

      terraform init -upgrade

    Applica le modifiche

    1. Rivedi la configurazione e verifica che le risorse che Terraform creerà o aggiornerà corrispondano alle tue aspettative:
      terraform plan

      Apporta le correzioni necessarie alla configurazione.

    2. Applica la configurazione Terraform eseguendo il comando seguente e inserendo yes al prompt:
      terraform apply

      Attendi finché Terraform non visualizza il messaggio "Applicazione completata".

    3. Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nell'interfaccia utente per assicurarti che Terraform le abbia create o aggiornate.

Esegui il deployment in più regioni

Esegui il deployment del tuo servizio nelle regioni di Cloud Run disponibili. Per facilitare la gestione, puoi utilizzare lo stesso nome di servizio in più aree geografiche.

Riga di comando

  1. Scegli le regioni in cui vuoi rendere disponibile il servizio.
  2. Eseguire il deployment del servizio Cloud Run in singole regioni.
  3. gcloud run deploy SERVICE_NAME \
    --allow-unauthenticated \
    --image=IMAGE_URL \
    --region=REGION

    Sostituisci le seguenti variabili:

    • REGION con una delle regioni in cui vuoi eseguire il deployment.
    • SERVICE_NAME con il nome del servizio. Utilizzare lo stesso nome di servizio in più regioni semplifica il monitoraggio dei deployment in più regioni.
    • IMAGE_URL con un riferimento all'immagine container, ad esempio us-docker.pkg.dev/cloudrun/container/hello:latest. Se utilizzi Artifact Registry, è necessario già creare il repository REPO_NAME. L'URL ha la forma REGION-docker.pkg.dev/PROJECT_ID/REPO_NAME/PATH:TAG
  4. Ripeti il passaggio precedente per ogni regione.

Terraform

Configura un servizio per ogni regione specificata nella variabile run_regions.

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

Esegue il loop di tutte le regioni specificate nella variabile run_regions e assegna a ogni nuovo servizio il nome seguente: myservice-run-app-${var.run_regions[count.index]}. La definizione della località del servizio viene applicata in modo simile. Sostituisci l'immagine predefinita us-docker.pkg.dev/cloudrun/container/hello" con la tua.

Località di Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura che esegue i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google per essere disponibile in modo ridondante in tutte le zone all'interno di quella regione.

Soddisfare i requisiti di latenza, disponibilità o durabilità sono fattori principali per selezionare la regione in cui vengono eseguiti i servizi Cloud Run. In genere, puoi selezionare la regione più vicina ai tuoi utenti, ma ti consigliamo di considerare la località degli altri prodotti Google Cloud utilizzati dal tuo servizio Cloud Run. L'utilizzo combinato di prodotti Google Cloud in più località può influire sulla latenza e sui costi del tuo servizio.

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

  • africa-south1 (Johannesburg)
  • asia-east2 (Hong Kong)
  • asia-northeast3 (Seul, Corea del Sud)
  • asia-southeast1 (Singapore)
  • asia-southeast2 (Giacarta)
  • asia-south1 (Mumbai, India)
  • asia-south2 (Delhi, India)
  • australia-southeast1 (Sydney)
  • australia-southeast2 (Melbourne)
  • europe-central2 (Varsavia, Polonia)
  • europe-west10 (Berlino)
  • europe-west12 (Torino)
  • europe-west2 (Londra, Regno Unito) icona foglia A basse emissioni di CO2
  • europe-west3 (Francoforte, Germania) icona foglia A basse emissioni di CO2
  • europe-west6 (Zurigo, Svizzera) icona foglia A basse emissioni di CO2
  • me-central1 (Doha)
  • me-central2 (Dammam)
  • northamerica-northeast1 (Montreal) icona foglia A basse emissioni di CO2
  • northamerica-northeast2 (Toronto) icona foglia A basse emissioni di CO2
  • southamerica-east1 (San Paolo, Brasile) icona foglia A basse emissioni di CO2
  • southamerica-west1 (Santiago, Cile) icona foglia A basse emissioni di CO2
  • us-west2 (Los Angeles)
  • us-west3 (Salt Lake City)
  • us-west4 (Las Vegas)

Se hai già creato un servizio Cloud Run, puoi visualizzare la regione nella dashboard di Cloud Run nella console Google Cloud.

Configura gruppi di endpoint di rete a livello di regione

Per ogni regione in cui hai eseguito il deployment nel passaggio precedente, devi creare gruppi di endpoint di rete serverless (NEG) e aggiungerli al servizio di backend, utilizzando le seguenti istruzioni:

Riga di comando

  1. Crea un gruppo di endpoint di rete per il servizio Cloud Run in REGION:

    gcloud compute network-endpoint-groups create NEG_NAME \
                --region=REGION \
                --network-endpoint-type=SERVERLESS \
                --cloud-run-service=SERVICE_NAME

    Nel comando riportato sopra, sostituisci:

    • NEG_NAME con il nome della risorsa del gruppo di endpoint di rete. (ad es. "myservice-neg-uscentral1")
    • REGION con [region][loc] in cui è stato eseguito il deployment del servizio.
    • SERVICE_NAME con il nome del servizio.
  2. Aggiungi il gruppo di endpoint di rete al servizio di backend:

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

    Specifica l'entità NEG_NAME che hai creato nel passaggio precedente per la regione.

  3. Ripeti i passaggi precedenti per ogni regione.

Terraform

  1. Configura un gruppo di endpoint di rete con il nome myservice-neg per il servizio Cloud Run per ogni regione specificata nella variabile run_regions:

    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. Configura un servizio di backend per collegare il gruppo di endpoint di rete (myservice-neg):

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

Configura i record DNS nel tuo dominio

Per puntare il tuo nome di dominio alla regola di forwarding che hai creato, devi aggiornare i suoi record DNS con l'indirizzo IP che hai creato.

  1. Per trovare l'indirizzo IP riservato del bilanciatore del carico, esegui:

      gcloud compute addresses describe --global SERVICE_IP --format='value(address)'

    Sostituisci SERVICE_IP con il nome dell'indirizzo IP che hai creato in precedenza. Questo comando stamperà l'indirizzo IP nell'output.

  2. Aggiorna i record DNS del tuo dominio aggiungendo un record A con questo indirizzo IP.

Configura un segmento di pubblico personalizzato se utilizzi servizi autenticati

I servizi autenticati sono protetti da IAM. Questi servizi Cloud Run richiedono l'autenticazione client che dichiari il destinatario previsto di una richiesta al momento della generazione delle credenziali (il pubblico).

Il pubblico corrisponde in genere all'URL completo del servizio di destinazione, che per impostazione predefinita per i servizi Cloud Run è un URL generato che termina con run.app. Tuttavia, in un deployment multiregionale, un client non può sapere in anticipo a quale servizio a livello di regione verrà instradata una richiesta. Quindi, per un deployment su più regioni, configura il tuo servizio in modo che utilizzi segmenti di pubblico personalizzati.

Attendi il provisioning del bilanciatore del carico

Dopo aver configurato il dominio con l'indirizzo IP del bilanciatore del carico, devi attendere un po' di tempo prima che i record DNS si propaghino. Analogamente, devi attendere un po' di tempo prima che il certificato TLS gestito venga emesso per il tuo dominio e sia pronto per iniziare a gestire il traffico HTTPS a livello globale.

Potrebbero essere necessari fino a 30 minuti prima che il bilanciatore del carico inizi a gestire il traffico.

Quando è pronto, visita l'URL del tuo sito web con il prefisso https:// per provarlo.

Verifica stato

  1. Per verificare lo stato della propagazione del record DNS, utilizza l'utilità a riga di comando dig:

    dig A +short example.com

    L'output dovrebbe mostrare l'indirizzo IP configurato nei record DNS.

  2. Controlla lo stato dell'emissione del certificato gestito, esegui:

    gcloud compute ssl-certificates describe CERT_NAME

    Sostituisci CERT_NAME con il nome che hai scelto in precedenza per la risorsa del certificato SSL.

    L'output dovrebbe mostrare una riga contenente status: ACTIVE.

Configurazione del reindirizzamento da HTTP a HTTPS

Per impostazione predefinita, una regola di forwarding gestisce un solo protocollo e, di conseguenza, le richieste ai tuoi endpoint http:// risponderanno con il messaggio 404 - Non trovato. Se hai bisogno che le richieste ai tuoi URL http:// vengano reindirizzate al protocollo https://, devi creare una mappa URL aggiuntiva e una regola di forwarding seguendo le istruzioni riportate di seguito:

Riga di comando

  1. Crea una mappa URL con una regola di reindirizzamento.

    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

    Sostituisci HTTP_URLMAP_NAME con il nome della risorsa mappa URL che creerai (ad es. myservice-httpredirect).

  2. Crea un proxy HTTP di destinazione con la mappa URL.

    gcloud compute target-http-proxies create HTTP_PROXY_NAME \
              --url-map=HTTP_URLMAP_NAME

    Sostituisci HTTP_PROXY_NAME con il nome del proxy HTTP di destinazione che creerai (ad es. myservice-http).

  3. Crea una regola di forwarding sulla porta 80 con lo stesso indirizzo IP riservato.

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

    Sostituisci HTTP_FORWARDING_RULE_NAME con il nome della nuova regola di forwarding che creerai (ad es. myservice-httplb).

Terraform

  1. Crea una risorsa mappa URL con una regola di reindirizzamento:

    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. Crea un proxy HTTP di destinazione con la risorsa mappa URL appena creata (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. Crea una regola di forwarding sulla porta 80 con la stessa risorsa dell'indirizzo IP riservato (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]
    }

Usa sottoscrizioni push Pub/Sub autenticate con deployment in più regioni

Per impostazione predefinita, un servizio Pub/Sub recapita messaggi agli endpoint push nella stessa regione di Google Cloud in cui il servizio Pub/Sub archivia i messaggi. Per una soluzione alternativa a questo comportamento, consulta l'articolo Utilizzare un abbonamento push Pub/Sub autenticato con un deployment di Cloud Run in più regioni.