Questa pagina è stata tradotta dall'API Cloud Translation.

Indirizza il traffico da più regioni

Per restituire risposte più rapide agli utenti di tutto il mondo, devi eseguire il deployment dei servizi in più aree geografiche e indirizzare gli utenti all'area geografica più vicina.

Poiché il deployment dei servizi Cloud Run è eseguito in singole aree geografiche, devi configurare un bilanciatore del carico HTTP(S) esterno per instradare i tuoi utenti a diverse aree geografiche del tuo servizio.

Questa guida mostra come configurare un bilanciatore del carico HTTP(S) esterno con un dominio protetto con un certificato TLS gestito che punta a un indirizzo IP anycast globale, che indirizza gli utenti al data center di Google più vicino in cui è stato eseguito il deployment del servizio.

Crea un bilanciatore del carico

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

Riga di comando

Prenota un indirizzo IP statico per 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 indirizzo IP (ad es. myservice-ip).
Questo indirizzo IP è un indirizzo IPv4 globale anycast che indirizza al data center di Google o al punto di presenza più vicino ai tuoi visitatori.
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).
Crea una mappa URL
```
gcloud compute url-maps create URLMAP_NAME --default-service=BACKEND_NAME
```
Sostituisci URLMAP_NAME con un nome che vuoi assegnare alla mappa URL (ad esempio myservice-urlmap).
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 per il certificato SSL gestito (ad esempio myservice-cert).
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 esempio myservice-https).
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 esempio 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 file Terraform (ad esempio: main.tf):

Configura l'indirizzo IP:

run/multi_regions/main.tf

Visualizza su GitHub Feedback
```
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 su myservice-service-ip. Puoi modificare questo valore con il tuo valore. Questo indirizzo IP è un indirizzo IPv4 anycast globale che indirizza al data center di Google o al punto di presenza più vicino ai tuoi visitatori.

Crea e configura il servizio di backend:

run/multi_regions/main.tf

Visualizza su GitHub Feedback

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 da nominare myservice-backend. Puoi modificare questo valore con il tuo valore.

Configura la mappa URL:

run/multi_regions/main.tf

Visualizza su GitHub Feedback

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 di servizio di backend (myservice-backend) alla nuova risorsa mappa URL (myservice-lb-urlmap). Puoi modificarla come preferisci.

Crea un certificato TLS gestito per il tuo dominio per gestire il traffico HTTPS:

Sostituisci example.com con il tuo nome di dominio:

run/multi_regions/main.tf

Visualizza su GitHub Feedback

variable "domain_name" {
  type    = string
  default = "example.com"
}

variable "run_regions" {
  type    = list(string)
  default = ["us-central1", "europe-west1"]
}

Aggiungi il tuo nome di dominio a una nuova risorsa google_compute_managed_ssl_certificate:

run/multi_regions/main.tf

Visualizza su GitHub Feedback

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

  managed {
    domains = [var.domain_name]
  }
}

Configura il proxy HTTPS:

run/multi_regions/main.tf

Visualizza su GitHub Feedback

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 una risorsa google_compute_target_https_proxy con nome destinazione myservice-https-proxy e connette il certificato TLS creato in precedenza (myservice-ssl-cert) e le risorse di mappatura degli URL (myservice-lb-urlmap). Puoi modificarle come preferisci.

Configura la regola di forwarding:

run/multi_regions/main.tf

Visualizza su GitHub Feedback

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 una risorsa google_compute_global_forwarding_rule con nome destinazione myservice-https-proxy e collega la destinazione proxy HTTPS creata in precedenza (myservice-https-proxy) e la risorsa indirizzo IP (myservice-service-ip). Puoi modificarle come preferisci.

Applica questa configurazione:

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

Preparare Cloud Shell
1. Avvia Cloud Shell.
2. Imposta il progetto Google Cloud predefinito a cui vuoi applicare le tue configurazioni Terraform.
  
  Questo comando deve essere eseguito una sola volta per progetto e può essere eseguito in qualsiasi directory.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
  Le variabili di ambiente vengono sostituite se imposti valori espliciti nel file di configurazione Terraform.
Prepara la directory

Ogni file di configurazione Terraform deve avere una propria directory (nota anche come modulo root).
1. In Cloud Shell, crea una directory e un nuovo file al suo interno. Il nome file deve avere l'estensione .tf, ad esempio main.tf. In questo tutorial viene denominato main.tf il file.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
2. Se segui un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.
  
  Copia il codice campione nella proprietà main.tf appena creata.
  
  In via facoltativa, copia il codice da GitHub. Questo metodo è consigliato quando 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. Dovrai 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 aggiorni corrispondano alle tue aspettative:
```
terraform plan
```
  Apporta le modifiche 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 "Applica completato".
3. Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle tue risorse nell'interfaccia utente per assicurarti che Terraform le abbia create o aggiornate.
Nota: gli esempi di Terraform in genere presuppongono che le API richieste siano abilitate nel tuo progetto Google Cloud.

Esegui il deployment in più regioni

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

Riga di comando

Scegli le regioni in cui vuoi rendere disponibile il servizio.
Esegui il deployment del tuo servizio Cloud Run in singole regioni.
```
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 il nome del tuo servizio. L'utilizzo dello stesso nome di servizio in più regioni semplifica il monitoraggio dei deployment su più aree geografiche.
- IMAGE_URL con un riferimento all'immagine container, ad esempio, us-docker.pkg.dev/cloudrun/container/hello:latest
Ripeti il passaggio precedente per ogni regione.

Terraform

Configura un servizio per ogni regione specificata nella variabile run_regions.

run/multi_regions/main.tf

Visualizza su GitHub Feedback

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

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

  traffic {
    percent         = 100
    latest_revision = true
  }

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

Loop di tutti i paesi specificati nella variabile run_regions, con il nome di ogni nuovo servizio, ad esempio: 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 una tua.

Località di Cloud Run

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

Soddisfare i requisiti di latenza, disponibilità o durabilità sono i fattori principali per selezionare la regione in cui vengono eseguiti i servizi Cloud Run. In genere, puoi selezionare l'area geografica più vicina ai tuoi utenti, ma dovresti prendere in considerazione la località degli altri prodotti Google Cloud utilizzati dal servizio Cloud Run. L'utilizzo combinato dei prodotti Google Cloud in più località può influire sulla latenza e sul costo del servizio.

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

asia-east1 (Taiwan)
asia-northeast1 (Tokyo)
asia-northeast2 (Osaka)
europe-north1 (Finlandia) Bassi livelli di CO₂
europe-southwest1 (Madrid) CO basso₂
europe-west1 (Belgio) CO basso₂
europe-west4 (Paesi Bassi)
europe-west8 (Milano)
europe-west9 (Parigi) CO basso₂
me-west1 (Tel Aviv)
us-central1 (Iowa) CO basso2
us-east1 (Carolina del Sud)
us-east4 (Virginia del Nord)
us-east5 (Columbus)
us-south1 (Dallas)
us-west1 (Oregon) Bassi livelli di CO₂

Soggetto ai prezzi di Livello 2

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-west12 (Torino)
europe-west2 (Londra, Regno Unito)
europe-west3 (Francoforte, Germania)
europe-west6 (Zurigo, Svizzera) CO basso2
me-central1 (Doha)
northamerica-northeast1 (Montreal) CO basso₂
northamerica-northeast2 (Toronto) CO basso₂
southamerica-east1 (San Paolo, Brasile) CO bassa₂
southamerica-west1 (Santiago, Cile)
us-west2 (Los Angeles)
us-west3 (Salina, città del lago)
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 backend a livello di regione

Per ogni area geografica in cui hai eseguito il deployment nel passaggio precedente, devi creare gruppi di endpoint di rete serverless (NEG) e aggiungerli al servizio di backend, seguendo queste istruzioni:

Riga di comando

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 viene eseguito il deployment del servizio.
- SERVICE_NAME il nome del tuo servizio.

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 il NEG_NAME creato nel passaggio precedente per la regione.

Ripeti i passaggi precedenti per ogni regione.

Terraform

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

run/multi_regions/main.tf

Visualizza su GitHub Feedback

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

Configura un servizio di backend per collegare il gruppo di endpoint di rete (myservice-neg):

run/multi_regions/main.tf

Visualizza su GitHub Feedback

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

Configurare i record DNS nel tuo dominio

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

Trova l'indirizzo IP riservato del bilanciatore del carico eseguendo:
```
  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 stampa l'indirizzo IP nell'output.
Aggiorna i record DNS del tuo dominio aggiungendo un record A con questo indirizzo IP.

Configura il segmento di pubblico personalizzato se utilizzi servizi autenticati

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

In genere, il pubblico è l'URL completo del servizio di destinazione. Per impostazione predefinita, per i servizi Cloud Run è generato un URL che termina con run.app. Tuttavia, in un deployment multiregionale, un client non può sapere in anticipo a quale servizio regionale verrà instradata una richiesta. Quindi, per un deployment multiregione, configura il servizio in modo da utilizzare segmenti di pubblico personalizzati.

Attendi che venga eseguito 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 per la propagazione dei record DNS. 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, prova ad accedere all'URL del tuo sito web con il prefisso https://.

Verifica stato

Per controllare lo stato della propagazione dei record DNS, utilizzando l'utilità a riga di comando dig:
```
dig A +short example.com
```
L'output dovrebbe mostrare l'indirizzo IP che hai configurato nei record DNS.
Controlla lo stato dell'emissione del certificato gestito, quindi 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, pertanto le richieste agli endpoint http:// rispondono con un codice di errore 404: Not Found. Se hai bisogno che gli URL http:// vengano reindirizzati al protocollo https://, devi creare una mappa URL aggiuntiva e una regola di forwarding, seguendo le seguenti istruzioni:

Riga di comando

Creare 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 esempio myservice-httpredirect).

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

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

Crea una risorsa mappa URL con una regola di reindirizzamento:

run/multi_regions/main.tf

Visualizza su GitHub Feedback

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

Crea un proxy HTTP di destinazione con la risorsa della mappa URL appena creata (myservice-https-urlmap):

run/multi_regions/main.tf

Visualizza su GitHub Feedback

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

Crea una regola di forwarding sulla porta 80 con la stessa risorsa riservata basata su indirizzo IP (myservice-http-proxy):

run/multi_regions/main.tf

Visualizza su GitHub Feedback

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

Utilizza sottoscrizioni push autenticate Pub/Sub con deployment a più aree geografiche

Per impostazione predefinita, un servizio Pub/Sub recapita i messaggi negli endpoint push nella stessa regione Google Cloud in cui il servizio Pub/Sub archivia i messaggi. Per una soluzione alternativa, consulta l'articolo sull'utilizzo di una sottoscrizione push Pub/Sub autenticata con un deployment Cloud Run a più aree geografiche.

Indirizza il traffico da più regioni

Crea un bilanciatore del carico

Riga di comando

Terraform

Preparare Cloud Shell

Prepara la directory

Applica le modifiche

Esegui il deployment in più regioni

Riga di comando

Terraform

Località di Cloud Run

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

Configura backend a livello di regione

Riga di comando

Terraform

Configurare i record DNS nel tuo dominio

Configura il segmento di pubblico personalizzato se utilizzi servizi autenticati

Attendi che venga eseguito il provisioning del bilanciatore del carico

Verifica stato

Configurazione del reindirizzamento da HTTP a HTTPS

Riga di comando

Terraform

Utilizza sottoscrizioni push autenticate Pub/Sub con deployment a più aree geografiche