Veicular tráfego de várias regiões

Para dar respostas mais rápidas a usuários de todo o mundo, implante serviços em várias regiões e encaminhe esses usuários para a região mais próxima. A implantação em várias regiões oferece baixa latência e maior disponibilidade em caso de interrupções regionais.

Como os serviços do Cloud Run são implantados em regiões individuais, é necessário implantar o serviço em várias regiões e configurar o balanceamento de carga global para ele.

Implantar o serviço em várias regiões

É possível implantar o mesmo serviço em várias regiões usando um dos seguintes métodos:

• Repita as etapas para fazer a implantação em uma única região.
• Implante um serviço multirregional.

Implantar um serviço multirregional

Preview — Multi-region service

This feature is subject to the "Pre-GA Offerings Terms" in the General Service Terms section of the Service Specific Terms. Pre-GA features are available "as is" and might have limited support. For more information, see the launch stage descriptions.

Esta seção mostra como implantar e configurar um serviço multirregional usando um único comando da CLI gcloud ou um arquivo YAML.

gcloud

• Para criar e implantar um serviço multirregional, execute o comando gcloud beta run deploy usando a flag --regions:

  gcloud beta run deploy SERVICE_NAME \
    --image=IMAGE_URL \
    --regions=REGIONS

  Substitua:

  • SERVICE_NAME: o nome do serviço multirregional que você quer implantar.
  • IMAGE_URL: uma referência à imagem de contêiner, por exemplo, us-docker.pkg.dev/cloudrun/container/hello:latest.
  • REGIONS: a lista de várias regiões para fazer a implantação. Por exemplo, us-central1,asia-east1.

YAML

1. Crie o arquivo YAML para seu serviço usando o atributo run.googleapis.com/regions para definir as várias regiões em que você quer implantar o serviço:

   apiVersion: serving.knative.dev/v1
   kind: Service
   metadata:
     name: SERVICE_NAME
     annotations:
       run.googleapis.com/launch-stage: BETA
       run.googleapis.com/regions: REGIONS
   spec:
     template:
       spec:
         containers:
         - image: IMAGE_URL

   Substitua:

   • SERVICE_NAME: o nome do serviço multirregional que você quer implantar.
   • REGIONS: a lista de várias regiões que você quer atualizar. Por exemplo, us-central1,asia-east1.
   • IMAGE_URL: uma referência à imagem de contêiner, por exemplo, us-docker.pkg.dev/cloudrun/container/hello:latest.

2. Crie o serviço usando o seguinte comando:

   gcloud beta run multi-region-services replace service.yaml

Atualizar um serviço multirregional

Observação: não é possível modificar serviços regionais individuais após a implantação. Eles são recursos somente leitura.

Esta seção mostra como adicionar ou remover regiões de um serviço multirregional usando um único comando da gcloud CLI ou um arquivo YAML.

gcloud

Para adicionar ou remover regiões de um serviço multirregional, execute o comando gcloud beta run multi-region-services update.

• Para adicionar o serviço multirregional a outras regiões, use a flag --add-regions:

  gcloud beta run multi-region-services update SERVICE_NAME \
    --add-regions=REGIONS

• Para remover o serviço multirregional de uma ou mais regiões, use a flag --remove-regions:

  gcloud beta run multi-region-services update SERVICE_NAME \
    --remove-regions=REGIONS

  Substitua:

  • SERVICE_NAME: o nome do serviço multirregional que você quer atualizar.
  • REGIONS: as regiões para adicionar ou remover o serviço. Por exemplo, us-central1,asia-east1.

YAML

1. Para atualizar um serviço multirregional, faça o download da configuração YAML:

   gcloud beta run multi-region-services describe SERVICE_NAME --format export > service.yaml

2. Atualize o atributo run.googleapis.com/regions para adicionar ou remover a lista de regiões em que você quer implantar o serviço:

   apiVersion: serving.knative.dev/v1
   kind: Service
   metadata:
     name: SERVICE_NAME
     annotations:
       run.googleapis.com/launch-stage: BETA
       run.googleapis.com/regions: REGIONS

   Substitua:

   • SERVICE_NAME: o nome do serviço multirregional que você quer implantar.
   • REGIONS: a nova lista de várias regiões para implantar a revisão do serviço.

3. Atualize o serviço usando o seguinte comando:

   gcloud beta run multi-region-services replace service.yaml

Excluir um serviço multirregional

Observação: não é possível modificar serviços regionais individuais após a implantação. Eles são recursos somente leitura.

• Para excluir um serviço multirregional, execute o comando gcloud beta run multi-region-services delete:

  gcloud beta run multi-region-services delete SERVICE_NAME

  Substitua SERVICE_NAME pelo nome do serviço multirregional que você quer excluir.

Configurar o balanceamento de carga global

Este guia mostra como configurar um balanceador de carga de aplicativo externo com um domínio protegido por um certificado TLS gerenciado que aponta para um endereço IP anycast global, que direciona os usuários para o data center do Google mais próximo com o serviço implantado.

A arquitetura descrita nas seções a seguir não encaminha automaticamente solicitações para uma região diferente quando um serviço regional do Cloud Run deixa de responder ou retorna erros. Para aumentar a disponibilidade do serviço multirregional, configure a detecção de outliers para identificar serviços não íntegros do Cloud Run com base na taxa de erros HTTP e divergir algumas solicitações para outro. região.

Criar um balanceador de carga

A criação de um balanceador de carga de aplicativo externo envolve a criação de vários recursos de rede e a conexão deles:

CLI da gcloud

1. Reserve um endereço IP estático para não precisar atualizar seus registros DNS ao recriar seu balanceador de carga.

   gcloud compute addresses create --global SERVICE_IP

   No comando acima, substitua SERVICE_IP por um nome para o recurso de endereço IP (por exemplo, myservice-ip).

   Por exemplo, é um endereço IPv4 anycast global que encaminha para o data center do Google ou para o ponto de presença mais próximo dos visitantes.

2. Crie um serviço de back-end.

   gcloud compute backend-services create --global BACKEND_NAME

   No comando acima, substitua BACKEND_NAME pelo nome que você quer fornecer ao serviço de back-end (por exemplo, myservice-backend).

3. Crie um mapa de URLs.

   gcloud compute url-maps create URLMAP_NAME --default-service=BACKEND_NAME

   Substitua URLMAP_NAME pelo nome que você quer dar ao mapa de URLs (por exemplo, myservice-urlmap).

4. Crie um certificado TLS gerenciado para seu domínio para exibir o tráfego HTTPS. (Substitua example.com pelo nome do seu domínio.)

   gcloud compute ssl-certificates create CERT_NAME \
     --domains=example.com

   Substitua CERT_NAME pelo nome que você quer dar ao certificado SSL gerenciado (por exemplo, myservice-cert).

5. Crie um proxy de destino HTTPS.

   gcloud compute target-https-proxies create HTTPS_PROXY_NAME \
     --ssl-certificates=CERT_NAME \
     --url-map=URLMAP_NAME

   Substitua HTTPS_PROXY_NAME pelo nome que você quer fornecer ao proxy de destino HTTPS (por exemplo, myservice-https).

6. Crie uma regra de encaminhamento que conecte os recursos de rede que você criou ao endereço IP.

   gcloud compute forwarding-rules create --global FORWARDING_RULE_NAME \
     --target-https-proxy=HTTPS_PROXY_NAME \
     --address=SERVICE_IP \
     --ports=443

   Substitua FORWARDING_RULE_NAME pelo nome do recurso de regra de encaminhamento que você quer criar (por exemplo, myservice-lb).

Terraform

Como alternativa às etapas descritas nesta seção, é possível usar o módulo de balanceador de carga HTTP global do Terraform.

Adicione o seguinte ao arquivo do Terraform (por exemplo, main.tf):

1. Configure o endereço 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 o nome do recurso de endereço IP como myservice-service-ip. É possível mudar isso para seu próprio valor. Esse endereço IP é um endereço IPv4 anycast global que faz o encaminhamento para o data center do Google ou o ponto de presença mais próximo dos visitantes.

2. Crie e configure o serviço de back-end:

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

   Este recurso configura o serviço de back-end como myservice-backend. É possível mudar isso para seu próprio valor.

3. Configure o mapa de 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"
         }
       }
     }
   }

   Conecta o recurso do serviço de back-end (myservice-backend) ao novo recurso de mapa de URL (myservice-lb-urlmap). É possível mudar para seus próprios valores.

4. Crie um certificado TLS gerenciado para seu domínio para disponibilizar o tráfego HTTPS. Substitua example.com pelo seu nome de domínio no recurso 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. Configure o 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
     ]
   }

   Cria o recurso google_compute_target_https_proxy com o nome de destino myservice-https-proxy e conecta o certificado TLS criado anteriormente (myservice-ssl-cert) e os recursos de mapeamento de URL (myservice-lb-urlmap). É possível mudar para seus próprios valores.

6. Configure a regra de encaminhamento:

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

   Cria o recurso google_compute_global_forwarding_rule com o nome de destino myservice-https-proxy e conecta o destino do proxy HTTPS criado anteriormente (myservice-https-proxy) e o recurso de endereço IP (myservice-service-ip). É possível mudar para seus próprios valores.

7. Aplicar esta configuração:

   Para aplicar a configuração do Terraform em um projeto do Google Cloud, conclua as etapas nas seções a seguir.

   Preparar o Cloud Shell

   1. Inicie o Cloud Shell.

   2. Defina o projeto padrão do Google Cloud em que você quer aplicar as configurações do Terraform.

      Você só precisa executar esse comando uma vez por projeto, e ele pode ser executado em qualquer diretório.

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID

      As variáveis de ambiente serão substituídas se você definir valores explícitos no arquivo de configuração do Terraform.

   Preparar o diretório

   Cada arquivo de configuração do Terraform precisa ter o próprio diretório, também chamado de módulo raiz.

   1. No Cloud Shell, crie um diretório e um novo arquivo dentro dele. O nome do arquivo precisa ter a extensão .tf, por exemplo, main.tf. Neste tutorial, o arquivo é chamado de main.tf.

      mkdir DIRECTORY && cd DIRECTORY && touch main.tf

   2. Se você estiver seguindo um tutorial, poderá copiar o exemplo de código em cada seção ou etapa.

      Copie o exemplo de código no main.tf recém-criado.

      Se preferir, copie o código do GitHub. Isso é recomendado quando o snippet do Terraform faz parte de uma solução de ponta a ponta.

   3. Revise e modifique os parâmetros de amostra para aplicar ao seu ambiente.
   4. Salve as alterações.
   5. Inicialize o Terraform. Você só precisa fazer isso uma vez por diretório.

      terraform init

      Opcionalmente, para usar a versão mais recente do provedor do Google, inclua a opção -upgrade:

      terraform init -upgrade

   Aplique as alterações

   1. Revise a configuração e verifique se os recursos que o Terraform vai criar ou atualizar correspondem às suas expectativas:

      terraform plan

      Faça as correções necessárias na configuração.

   2. Para aplicar a configuração do Terraform, execute o comando a seguir e digite yes no prompt:

      terraform apply

      Aguarde até que o Terraform exiba a mensagem "Apply complete!".

   3. Abra seu projeto do Google Cloud para ver os resultados. No console do Google Cloud, navegue até seus recursos na IU para verificar se foram criados ou atualizados pelo Terraform.
   Observação: as amostras do Terraform geralmente presumem que as APIs necessárias estejam ativadas no projeto do Google Cloud.

Configurar grupos de endpoints de rede regionais

Para cada região implantada na etapa anterior, você precisa criar grupos de endpoints de rede sem servidor (NEGs) e adicioná-los ao serviço de back-end seguindo estas instruções:

CLI da gcloud

1. Crie um grupo de endpoints de rede para o serviço Cloud Run em REGION:

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

   Substitua:

   • NEG_NAME pelo nome do recurso de grupo de endpoints da rede. (por exemplo, "myservice-neg-uscentral1")
   • REGION pela região em que o serviço foi implantado;
   • SERVICE_NAME pelo nome do serviço;

2. Adicione o grupo de endpoints da rede ao serviço de back-end:

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

   Especifique o NEG_NAME que você criou na etapa anterior para a região.

3. Repita as etapas anteriores para cada região.

Terraform

1. Configure um grupo de endpoints da rede com o nome myservice-neg para o serviço do Cloud Run em cada região especificada na variável 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. Configure um serviço de back-end para anexar o grupo de endpoints da rede (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,
     ]
   }

Configurar registros DNS no seu domínio

Para apontar o nome de domínio para a regra de encaminhamento criada, atualize os registros DNS com o endereço IP criado.

1. Encontre o endereço IP reservado do balanceador de carga executando o seguinte comando:

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

   Substitua SERVICE_IP pelo nome do endereço IP criado anteriormente. Esse comando imprime o endereço IP na saída.

2. Atualize os registros DNS do seu domínio adicionando um registro A a esse endereço IP.

Configurar o público-alvo personalizado se estiver usando serviços autenticados

Os serviços autenticados são protegidos pelo IAM. Esses serviços do Cloud Run exigem autenticação de cliente que declara o destinatário pretendido de uma solicitação no momento da geração de credenciais (o público-alvo).

Geralmente, o público é o URL completo do serviço de destino que, por padrão, é um URL gerado com final run.app nos serviços do Cloud Run. No entanto, em uma implantação multirregional, um cliente não pode saber com antecedência para qual serviço regional uma solicitação será encaminhada. Portanto, para uma implantação multirregional, configure seu serviço para usar públicos-alvo personalizados.

Aguardar o provisionamento do balanceador de carga

Depois de configurar o domínio com o endereço IP do balanceador de carga, aguarde até que os registros DNS sejam propagados. Da mesma forma, aguarde até que o certificado TLS gerenciado seja emitido para seu domínio e esteja pronto para começar a disponibilizar o tráfego HTTPS globalmente.

Pode levar até 30 minutos para que o balanceador de carga comece a disponibilizar o tráfego.

Quando ele estiver pronto, acesse o URL do site com o prefixo https:// para fazer um teste.

Verificar o status

1. Para verificar o status da propagação de registros DNS, use o utilitário de linha de comando dig:

   dig A +short example.com

   A saída mostra o endereço IP configurado nos registros DNS.

2. Para verificar o status da emissão do certificado gerenciado, execute o seguinte comando:

   gcloud compute ssl-certificates describe CERT_NAME

   Substitua CERT_NAME pelo nome escolhido anteriormente para o recurso de certificado SSL.

   A saída mostra uma linha contendo status: ACTIVE.

Configurar o redirecionamento HTTP para HTTPS

Observação: a criação de regras de encaminhamento adicionais está sujeita a cobrança. Consulte os preços do balanceador de carga.

Por padrão, uma regra de encaminhamento só processa um único protocolo. Portanto, as solicitações feitas aos endpoints http:// respondem com 404 Não encontrado. Se você precisar que as solicitações para os URLs http:// sejam redirecionadas para o protocolo https://, crie um mapa de URL adicional e uma regra de encaminhamento seguindo estas instruções:

CLI da gcloud

1. Crie um mapa de URL com uma regra de redirecionamento.

   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

   Substitua HTTP_URLMAP_NAME pelo nome do recurso de mapa de URL que você vai criar (por exemplo, myservice-httpredirect).

2. Crie um proxy HTTP de destino com o mapa de URL.

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

   Substitua HTTP_PROXY_NAME pelo nome do proxy HTTP de destino que você vai criar (por exemplo, myservice-http).

3. Crie uma regra de encaminhamento na porta 80 com o mesmo endereço IP reservado.

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

   Substitua HTTP_FORWARDING_RULE_NAME pelo nome da nova regra de encaminhamento que você vai criar (por exemplo, myservice-httplb).

Terraform

1. Crie um mapa de URL com uma regra de redirecionamento:

   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. Crie um proxy HTTP de destino com o recurso de mapa de URL recém-criado (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. Crie uma regra de encaminhamento na porta 80 com o mesmo endereço IP reservado (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]
   }

Observação: assim como acontece com a regra de encaminhamento HTTPS, a criação da regra de encaminhamento adicional pode levar algum tempo. Quando tudo estiver pronto, vai ser possível acessar o aplicativo por http:// e ele vai fazer o redirecionamento para o URL https:// com um código de status 301 "Movido Permanentemente".

Usar assinaturas de push do Pub/Sub autenticadas com implantação em várias regiões

Por padrão, um serviço do Pub/Sub entrega mensagens para endpoints de push na mesma Google Cloud região em que o serviço do Pub/Sub armazena as mensagens. Para uma solução alternativa para esse comportamento, consulte Como usar uma assinatura de push do Pub/Sub autenticada com uma implantação de várias regiões do Cloud Run.

Configurar um failover manual

Para configurar manualmente o failover do tráfego para uma região saudável, modifique o mapa de URL do balanceador de carga de aplicativo externo global.

1. Para atualizar o mapa de URL do balanceador de carga de aplicativo externo global, remova o NEG do serviço de back-end usando a flag --global:

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

   Substitua:

   • BACKEND_NAME: o nome do serviço de back-end.
   • NEG_NAME: o nome do recurso de grupo de endpoints da rede, por exemplo, myservice-neg-uscentral1.
   • REGION: a região em que o NEG foi criado e de onde você quer remover o serviço. Por exemplo, us-central1,asia-east1.

2. Para confirmar que uma região saudável está veiculando tráfego, acesse https://<domain-name>.