Questa pagina è stata tradotta dall'API Cloud Translation.

Gestisci il traffico da più regioni

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

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

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

L'architettura descritta in questa guida non instrada automaticamente le richieste in un'altra regione quando un servizio Cloud Run a livello di regione non risponde o inizia a restituire errori. Per aumentare la disponibilità dei tuoi in più regioni, puoi configurare il rilevamento outlier per identificare uno stato non integro Cloud Run in base al tasso di errore HTTP e divergono alcuni a un'altra regione.

Crea un bilanciatore del carico

La creazione di un bilanciatore del carico esterno prevede la creazione di diverse risorse di rete e il loro collegamento:

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 precedente, sostituisci SERVICE_IP con un nome per l'IP risorsa di indirizzo (ad es. myservice-ip).
Questo indirizzo IP è un indirizzo IPv4 anycast globale che instrada al server il data center o il punto di presenza più vicino ai tuoi visitatori.
Crea un servizio di backend.
```
gcloud compute backend-services create --global BACKEND_NAME
```
Nel comando precedente, sostituisci BACKEND_NAME con il nome che vuoi usare al servizio di backend (ad es. myservice-backend).
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).
Crea un certificato TLS gestito per il tuo dominio per la pubblicazione su HTTPS per via del traffico. 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 che venga gestito SSL (ad es. myservice-cert).
Crea 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).
Crea una regola di inoltro che colleghi le risorse di rete che hai creato 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 dell'inoltro risorsa della regola 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 file Terraform (ad esempio main.tf):

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 dell'indirizzo IP su myservice-service-ip. Puoi modificare questo valore in base alle tue esigenze. Questo indirizzo IP è un indirizzo IPv4 anycast globale che indirizza al data center o al punto di presenza di Google più vicino ai tuoi visitatori.

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 con il nome myservice-backend. Puoi modificare questo valore impostandolo sul tuo valore.

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 modificare questi valori impostandoli su tutti i tuoi valori.

Crea un certificato TLS gestito per il tuo dominio per pubblicare 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"]
  }
}

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 di destinazione myservice-https-proxy e connette il certificato TLS (myservice-ssl-cert) e le risorse di mappatura URL (myservice-lb-urlmap) creati in precedenza. Puoi modificare questi valori impostandoli su tutti i tuoi valori.

Configura la regola di inoltro:

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 il nome di destinazione myservice-https-proxy e collega il target del proxy HTTPS (myservice-https-proxy) e la risorsa indirizzo IP (myservice-service-ip) creati in precedenza. Puoi sostituirli con i tuoi valori.

Applica questa configurazione:

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

Prepara Cloud Shell
1. Avvia Cloud Shell.
2. Imposta il progetto Google Cloud predefinito dove vuoi applicare le configurazioni Terraform.
  
  Devi eseguire questo comando una sola volta per progetto e puoi farlo in qualsiasi directory.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
  Le variabili di ambiente vengono sostituite se imposti valori espliciti nel file di configurazione di Terraform.
Prepara la directory

Ogni file di configurazione Terraform deve avere una directory dedicata (inoltre chiamato modulo principale).
1. In Cloud Shell, crea una directory e un nuovo all'interno di quella directory. Il nome file deve avere l'estensione .tf, ad esempio main.tf. In questo tutorial, il file è denominato main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
2. Se stai seguendo un tutorial, puoi copiare il codice di esempio in ogni sezione o passaggio.
  
  Copia il codice di esempio nel file main.tf appena creato.
  
  Se vuoi, copia il codice da GitHub. Questa opzione è consigliata 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. Devi eseguire questa operazione una sola volta per directory.
```
terraform init
```
  Facoltativamente, per utilizzare la versione più recente del provider Google, includi -upgrade :
```
terraform init -upgrade
```
Applica le modifiche
1. Rivedi la configurazione e verifica che le risorse che Terraform sta per creare o aggiornare corrispondano alle tue aspettative:
```
terraform plan
```
  Apporta le correzioni necessarie alla configurazione.
2. Applica la configurazione di Terraform eseguendo il seguente comando e inserendo yes al prompt:
```
terraform apply
```
  Attendi che Terraform mostri il messaggio "Applicazione completata".
3. Apri il tuo progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nella UI per assicurarti create o aggiornate da Terraform.
Nota: in genere i sample di Terraform presuppongono che le API richieste siano attivate nel progetto Google Cloud.

Esegui il deployment in più regioni

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

Riga di comando

Scegli le regioni in cui vuoi rendere disponibile il tuo servizio.
Esegui il deployment del 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 con il nome del tuo servizio. L'utilizzo dello stesso nome di servizio in più regioni semplifica il monitoraggio dei deployment multi-regione.
- IMAGE_URL con un riferimento all'immagine del container, ad esempio us-docker.pkg.dev/cloudrun/container/hello:latest. Se utilizzi Artifact Registry, il repository REPO_NAME deve essere già creati. L'URL ha la forma LOCATION-docker.pkg.dev/PROJECT_ID/REPO_NAME/PATH:TAG
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]

  deletion_protection = false # set to "true" in production

  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 in tutte le regioni specificate nella variabile run_regions e assegna a ogni nuovo servizio un nome simile: 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 immagine.

Località Cloud Run

Cloud Run è un servizio 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 da essere disponibile in modo ridondante in tutte le zone all'interno della regione.

Soddisfare i requisiti di latenza, disponibilità o durabilità è fondamentale i fattori necessari per selezionare la regione in cui vengono eseguiti i servizi Cloud Run. In genere puoi selezionare la regione più vicina ai tuoi utenti, ma devi prendere in considerazione la posizione 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 regioni seguenti:

Soggetto ai prezzi di Livello 1

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

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) A basse emissioni di CO₂
europe-west12 (Torino)
europe-west2 (Londra, Regno Unito) Bassi livelli di CO₂
europe-west3 (Francoforte, Germania) Bassi livelli di CO₂
europe-west6 (Zurigo, Svizzera) A basse emissioni di CO₂
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montreal) A basse emissioni di CO₂
northamerica-northeast2 (Toronto) Bassi livelli di CO₂
southamerica-east1 (San Paolo, Brasile) Bassi livelli di CO₂
southamerica-west1 (Santiago, Cile) A basse emissioni di CO₂
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.

Configurare i 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

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

Ripeti i passaggi precedenti per ogni regione.

Terraform

Configura un gruppo di endpoint di rete denominato 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
  }
}

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 sul tuo dominio

Per puntare il tuo nome di dominio alla regola di forwarding che hai creato, devi aggiornare i propri 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 stamperà 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 client che dichiara il destinatario previsto di una richiesta al momento della generazione delle credenziali (il pubblico).

Il pubblico è in genere l'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, non è possibile per un client sapere in anticipo a quale servizio regionale verrà instradata la richiesta. Pertanto, per un deployment multi-regione, configura il servizio in modo da utilizzare 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 per la propagazione dei record DNS. Analogamente, devi attendere un po' di tempo affinché il certificato TLS gestito venga emesso per il tuo dominio e sia pronto per iniziare a pubblicare il traffico HTTPS a livello globale.

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

Una volta completata la procedura, visita l'URL del tuo sito web con il prefisso https:// per provarlo.

Verifica stato

Per controllare 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.
Per controllare lo stato dell'emissione dei certificati gestiti, esegui:
```
gcloud compute ssl-certificates describe CERT_NAME
```
Sostituisci CERT_NAME con il nome che hai scelto in precedenza 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 inoltro gestisce un solo protocollo e, di conseguenza, alle richieste agli endpoint http:// verrà risposto con 404 - Non trovato. Se è necessario reindirizzare le richieste ai tuoi URL http:// al protocollo https://, devi creare un'altra mappa URL e una regola di inoltro, seguendo le istruzioni riportate di seguito:

Riga di comando

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 della mappa URL che creerai (ad es. myservice-httpredirect).

Creare 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:

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

Crea una regola di inoltro sulla porta 80 con la stessa risorsa 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]
}

Utilizzare gli abbonamenti push Pub/Sub autenticati con il deployment multiregione

Per impostazione predefinita, un servizio Pub/Sub recapita i messaggi per eseguire il push degli endpoint nella stessa regione Google Cloud in cui il servizio Pub/Sub archivia messaggi. Per una soluzione alternativa a questo comportamento, consulta Utilizzo di una sottoscrizione push di Pub/Sub autenticata con un deployment Cloud Run in più regioni.

Gestisci il traffico da più regioni

Crea un bilanciatore del carico

Riga di comando

Terraform

Prepara Cloud Shell

Prepara la directory

Applica le modifiche

Esegui il deployment in più regioni

Riga di comando

Terraform

Località Cloud Run

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

Configurare i gruppi di endpoint di rete a livello di regione

Riga di comando

Terraform

Configura i record DNS sul tuo dominio

Configura il segmento di pubblico personalizzato se utilizzi servizi autenticati

Attendi il provisioning del bilanciatore del carico

Verifica stato

Configurazione del reindirizzamento da HTTP a HTTPS

Riga di comando

Terraform

Utilizzare gli abbonamenti push Pub/Sub autenticati con il deployment multiregione