Esta página foi traduzida pela API Cloud Translation.

Migre um domínio personalizado do App Engine para o Cloud Load Balancing

ID da região

O REGION_ID é um código abreviado que a Google atribui com base na região que seleciona quando cria a sua app. O código não corresponde a um país ou uma província, embora alguns IDs de regiões possam parecer semelhantes aos códigos de países e províncias usados frequentemente. Para apps criadas após fevereiro de 2020, REGION_ID.r está incluído nos URLs do App Engine. Para apps existentes criadas antes desta data, o ID da região é opcional no URL.

Saiba mais acerca dos IDs de regiões.

Este guia aborda a forma de configurar um novo ponto final público para a sua app do App Engine através do Cloud Load Balancing.

Com o Cloud Load Balancing, configura o ponto final do domínio personalizado como um serviço de front-end e configura a app do App Engine como um serviço de back-end através de um grupo de pontos finais da rede (NEG) sem servidor. O tráfego para o ponto final do serviço de front-end do Cloud Load Balancing é encaminhado da mesma forma que antes, incluindo todas as regras de encaminhamento que definir no ficheiro dispatch.yaml da sua app.

O diagrama seguinte descreve as alterações à sua app:

Aceitar um domínio personalizado do App Engine e transferir os pedidos recebidos para um serviço de front-end do Cloud Load Balancing que distribui os pedidos para o serviço de back-end do App Engine.

Ao migrar para o Cloud Load Balancing, ganha significativamente mais flexibilidade na forma como o tráfego é processado quando chega ao seu domínio, como publicar conteúdo estático a partir do Cloud Storage ou adicionar serviços executados noutras plataformas de computação, como o Cloud Run e o Google Kubernetes Engine.

Também tem acesso a Google Cloud capacidades importantes que não estão disponíveis no App Engine, incluindo:

Google Cloud Armor, para uma segurança melhorada com proteção avançada contra DDoS, controlos de acesso baseados em IP e localização geográfica, regras de firewall de aplicação Web e muito mais
Cloud CDN para o fornecimento de conteúdo em cache
Políticas SSL para gerir que funcionalidades SSL e versões TLS a sua app vai aceitar

Este guia aborda as instruções de configuração para transferir pedidos recebidos do seu serviço do App Engine com um domínio personalizado para um serviço de front-end do Cloud Load Balancing:

Certifique-se de que tem as autorizações necessárias
Crie um certificado gerido pela Google
Configure o Cloud Load Balancing
Teste o balanceador de carga
Associe o seu domínio ao equilibrador de carga
Elimine o mapeamento do domínio personalizado do App Engine
Configure o controlo de entrada para permitir apenas o acesso através do Cloud Load Balancing

Antes de começar

Ter uma app do App Engine com um domínio personalizado configurado nas definições do App Engine.

Configure autorizações

Para seguir este guia, tem de criar um certificado gerido pela Google, um NEG sem servidor e um balanceador de carga HTTP(S) externo num projeto. Deve ser proprietário ou editor do projeto, ou ter as seguintes funções do IAM:

Tarefa	Função necessária
Crie um certificado SSL gerido pela Google através do Gestor de certificados	Proprietário do Gestor de certificados ou Editor do Gestor de certificados e Administrador do balanceador de carga do Compute
Atualize os registos de DNS do domínio personalizado	Administrador do Cloud DNS se usar o Cloud DNS como solução de DNS. Se usar outro fornecedor DNS, precisa de autorizações para adicionar e atualizar os registos de DNS do domínio personalizado.
Crie um balanceador de carga e componentes de rede	Administrador de rede de Calcular
Crie e modifique NEGs	Administrador de instâncias do Compute
Crie e modifique certificados SSL	Administrador de segurança de computação
Elimine domínios personalizados nas definições do App Engine	Função de administrador do App Engine ou uma função que contenha a autorização `appengine.applications.update`.

Crie um certificado SSL gerido pela Google

Um certificado SSL gerido pela Google (também conhecido como certificado TLS na documentação) permite-lhe Google Cloud obter, gerir e renovar certificados automaticamente. Para migrar para o front-end do Cloud Load Balancing sem provocar tempo de inatividade para o seu serviço do App Engine existente, tem de usar o gestor de certificados para criar a autorização de DNS e o seu certificado gerido pela Google.

Tenha em atenção que a documentação do Cloud Load Balancing tem instruções semelhantes para criar um certificado SSL gerido pela Google, mas as instruções aí usam a autorização do equilibrador de carga, que requer tempo de inatividade para o seu serviço do App Engine que pode durar até várias horas. Para mais informações, consulte o artigo Autorização de domínio para certificados geridos pela Google.

Para evitar o tempo de inatividade da sua app, siga os passos indicados nesta página.

Crie uma autorização de DNS

Execute os seguintes comandos para criar a autorização de DNS no Gestor de certificados:
```
gcloud certificate-manager dns-authorizations create AUTHORIZATION_NAME \
    --domain="DOMAIN_NAME"
gcloud certificate-manager dns-authorizations describe AUTHORIZATION_NAME
```
Substitua o seguinte:
- AUTHORIZATION_NAME é um nome exclusivo que descreve esta autorização de DNS.
- DOMAIN_NAME é o nome do domínio personalizado do App Engine para o qual está a criar esta autorização de DNS.
Tome nota do CNAME devolvido pelo comando gcloud. Tem de o usar para atualizar o seu registo de DNS nos passos seguintes.

Adicione o registo CNAME à configuração do DNS

Consoante esteja a usar o Cloud DNS ou outra solução de DNS de terceiros, siga as instruções adequadas ao seu exemplo de utilização:

Cloud DNS

Quando cria uma autorização de DNS, o comando gcloud devolve o registo CNAME correspondente. Tem de adicionar este registo CNAME à configuração do DNS na zona de DNS do domínio de destino da seguinte forma:

Inicie a transação do registo DNS:
```
gcloud dns record-sets transaction start --zone="DNS_ZONE_NAME"
```
Substitua DNS_ZONE_NAME pelo nome da zona de DNS pública. Se estiver a usar o Google Cloud para gerir o seu domínio e receber tráfego para esse domínio, já criou uma zona de DNS pública. Para ver a sua zona DNS pública, consulte o artigo Liste e descreva zonas geridas.
Adicione o registo CNAME à zona DNS de destino:
```
gcloud dns record-sets transaction add CNAME_RECORD \
  --name="_acme-challenge.DOMAIN_NAME." \
  --ttl="30" \
  --type="CNAME" \
  --zone="DNS_ZONE_NAME"
```
Substitua o seguinte:
- CNAME_RECORD é o valor total do registo CNAME devolvido pelo comando gcloud que criou a autorização de DNS correspondente.
- DOMAIN_NAME é o nome do domínio personalizado do App Engine. Tem de incluir o ponto final após o nome do domínio de destino.
- DNS_ZONE_NAME é o nome da zona DNS de destino de anteriormente.
Execute a transação do registo DNS para guardar as alterações:
```
gcloud dns record-sets transaction execute --zone="DNS_ZONE_NAME"
```
Substitua DNS_ZONE_NAME pelo nome da zona DNS de destino indicado anteriormente.

Outra solução de DNS

Adicione um registo CNAME à configuração do DNS do seu domínio, usando o nome (anfitrião) (_acme-challenge.DOMAIN_NAME) e os campos de dados da secção anterior. Consulte a documentação da sua solução de DNS de terceiros.

Crie um certificado gerido pela Google que faça referência à autorização de DNS

Para criar um certificado gerido pela Google que referencie a autorização de DNS que criou nos passos anteriores, execute os seguintes comandos:

Crie um certificado gerido pela Google:
```
gcloud certificate-manager certificates create CERTIFICATE_NAME \
--domains=DOMAIN_NAME --dns-authorizations=AUTHORIZATION_NAME
```
Substitua o seguinte:
- CERTIFICATE_NAME é um nome exclusivo que descreve o certificado.
- DOMAIN_NAME é o nome do domínio personalizado do App Engine.
- AUTHORIZATION_NAME é o nome da autorização de DNS criada anteriormente.

Verifique se o certificado está ativo.

Use o comando seguinte para verificar se o próprio certificado está ativo antes de o implementar no equilibrador de carga. Tenha em atenção que o estado do certificado pode demorar várias horas a mudar para ACTIVE.

gcloud certificate-manager certificates describe CERTIFICATE_NAME

Substitua CERTIFICATE_NAME pelo nome do certificado gerido pela Google que foi criado anteriormente.

A ferramenta gcloud devolve um resultado semelhante ao seguinte:

certificatePem: myPEM
createTime: '2021-10-20T12:19:53.370778666Z'
expireTime: '2022-05-07T05:03:49Z'
managed:
  authorizationAttemptInfo:
  - domain: example.com
    state: AUTHORIZED
  dnsAuthorizations:
  - projects/my-project/locations/global/dnsAuthorizations/myAuth
  domains:
  - example.com
  state: ACTIVE
name: projects/myProject/locations/global/certificates/myCert
scope: myScope
sanDnsnames:
- example.com
updateTime: '2021-10-20T12:19:55.083385630Z'

Se a gcloudferramenta devolver um resultado diferente, consulte o artigo Resolução de problemas do Gestor de certificados.

Crie um mapa de certificados

Crie um mapa de certificados:
```
gcloud certificate-manager maps create CERTIFICATE_MAP_NAME
```
Substitua CERTIFICATE_MAP_NAME por um nome exclusivo que descreva o mapeamento de certificados.
Crie uma entrada de mapeamento de certificados e associe-a ao certificado e ao mapeamento de certificados que criou anteriormente:
```
gcloud certificate-manager maps entries create CERTIFICATE_MAP_ENTRY_NAME \
    --map=CERTIFICATE_MAP_NAME \
    --certificates=CERTIFICATE_NAME \
    --set-primary
```
Substitua o seguinte:
- CERTIFICATE_MAP_ENTRY_NAME é um nome exclusivo que descreve esta entrada do mapa de certificados.
- CERTIFICATE_MAP_NAME é o nome do mapa de certificados ao qual esta entrada do mapa de certificados está anexada.
- CERTIFICATE_NAME é o nome do certificado que quer associar a esta entrada do mapa de certificados.
Pode anexar a flag --set-primary para garantir que o certificado é usado como o certificado predefinido se não for especificado um nome de domínio.
Verifique se o mapeamento de certificados está ativo.

Use o seguinte comando para verificar se a entrada do mapa de certificados está ativa antes de anexar o respetivo mapa de certificados ao proxy de destino:
```
gcloud certificate-manager maps entries describe CERTIFICATE_MAP_ENTRY_NAME \
    --map=CERTIFICATE_MAP_NAME
```
Substitua o seguinte:
- CERTIFICATE_MAP_ENTRY_NAME é o nome da entrada do mapa de certificados de anteriormente.
- CERTIFICATE_MAP_NAME é o nome do mapeamento de certificados ao qual esta entrada de mapeamento de certificados está anexada.
A ferramenta gcloud devolve um resultado semelhante ao seguinte:
```
createTime: '2021-09-06T10:01:56.229472109Z'
name: projects/my-project/locations/global/certificateMaps/myCertMap/certificateMapEntries/myCertMapEntry
state: ACTIVE
updateTime: '2021-09-06T10:01:58.277031787Z'
```

Para mais informações sobre a utilização do gestor de certificados, consulte o artigo Como funciona o gestor de certificados.

Configure o Cloud Load Balancing

Depois de ter um certificado gerido pela Google, pode substituir o seu domínio personalizado do App Engine por um serviço de frontend do Cloud Load Balancing.

O diagrama seguinte mostra um balanceador de carga HTTPS com um único serviço de back-end e NEG sem servidor.

Distribuir tráfego para uma app do App Engine

As regras de encaminhamento encaminham os pedidos recebidos de endereços IP externos e direcionam os pedidos para o proxy HTTPS de destino. Os equilibradores de carga HTTPS usam mapas de URLs para direcionar pedidos para o serviço de back-end, que contém um NEG sem servidor para o serviço do App Engine.

Reserve um endereço IP externo

Antes de configurar o Cloud Load Balancing, tem de configurar um endereço IP externo estático global para que os utilizadores possam aceder ao seu balanceador de carga.

Consola

Aceda à página Endereços IP externos na Google Cloud consola.

Aceda a Endereços IP externos
Clique em Reservar endereço estático para reservar um endereço IPv4.
Atribua um Nome ao endereço estático, por exemplo, appengine-external-ip.
Defina o nível da rede como Premium.
Defina a versão do IP como IPv4.
Defina o Tipo como Global.
Clique em Reservar.

gcloud

Crie uma reserva de endereço IP externo:

gcloud compute addresses create EXTERNAL_IP \
    --network-tier=PREMIUM \
    --ip-version=IPV4 \
    --global

EXTERNAL_IP é o nome dos endereços a criar.

Tome nota do endereço IPv4 que foi reservado:

gcloud compute addresses describe EXTERNAL_IP \
    --format="get(address)" \
    --global

Configure o serviço de back-end para o App Engine

Um grupo de pontos finais da rede (NEG) é usado para especificar um grupo de pontos finais do back-end para um balanceador de carga. Para especificar um back-end que aponte para um serviço do App Engine, configure o NEG sem servidor e, em seguida, configure o serviço de back-end, as regras de encaminhamento e o serviço de front-end no Cloud Load Balancing.

Crie um NEG sem servidor para a sua app do App Engine:
```
gcloud compute network-endpoint-groups create APP_ENGINE_NEG \
--network-endpoint-type=serverless \
--app-engine-app \
--region=APP_ENGINE_REGION
```
Substitua o seguinte:
- APP_ENGINE_NEG é o nome do grupo de pontos finais de rede.
- APP_ENGINE_REGION é a região que foi definida no App Engine.
Pode anexar a flag --app-engine-app acima para usar o encaminhamento predefinido, em vez de direcionar para um serviço do App Engine específico. A utilização do encaminhamento predefinido significa que os pedidos são enviados para o serviço predefinido (https://PROJECT_ID.REGION_ID.r.appspot.com) e, caso contrário, segue todas as regras de encaminhamento que definir no ficheiro dispatch.yaml. Este é o mesmo comportamento que os domínios personalizados configurados através do App Engine.

Crie o serviço de back-end:

gcloud compute backend-services create APP_ENGINE_BACKEND \
  --global \
  --load-balancing-scheme=EXTERNAL_MANAGED

Substitua APP_ENGINE_BACKEND pelo nome do serviço de back-end a criar.

Adicione o NEG sem servidor ao serviço de back-end do App Engine:
```
gcloud compute backend-services add-backend APP_ENGINE_BACKEND \
--global --network-endpoint-group=APP_ENGINE_NEG \
--network-endpoint-group-region=APP_ENGINE_REGION
```
Substitua o seguinte:
- APP_ENGINE_BACKEND é o nome do serviço de back-end de anteriormente.
- APP_ENGINE_NEG é o nome do grupo de pontos finais da rede.
- APP_ENGINE_REGION é a região que foi definida no App Engine.
Crie um mapa de URLs para encaminhar pedidos recebidos para o serviço de back-end:
```
gcloud compute url-maps create URL_MAP_NAME \
      --default-service APP_ENGINE_BACKEND
```
Substitua o seguinte:
- URL_MAP_NAME é um nome exclusivo para o recurso de mapa de URLs que define o mapeamento de URLs para serviços de back-end.
- APP_ENGINE_BACKEND é o nome do serviço de back-end de anteriormente.
Crie um proxy HTTPS de destino para encaminhar pedidos para o seu mapa de URLs:
```
gcloud compute target-https-proxies create TARGET_HTTPS_PROXY_NAME \
      --certificate-map=CERTIFICATE_MAP_NAME \
      --url-map=URL_MAP_NAME
```
Substitua o seguinte:
- TARGET_HTTPS_PROXY_NAME é um nome exclusivo que escolhe para descrever o seu proxy HTTPS.
- CERTIFICATE_MAP_NAME é o nome do mapeamento de certificados que faz referência à entrada do mapeamento de certificados e ao respetivo certificado associado.
- URL_MAP_NAME é o nome do mapa de URLs de anteriormente.
Crie uma regra de encaminhamento para encaminhar pedidos recebidos para o proxy:
```
gcloud compute forwarding-rules create HTTPS_FORWARDING_RULE_NAME \
      --load-balancing-scheme=EXTERNAL_MANAGED \
      --network-tier=PREMIUM \
      --address=EXTERNAL_IP \
      --target-https-proxy=TARGET_HTTPS_PROXY_NAME \
      --global \
      --ports=443
```
Substitua o seguinte:
- HTTPS_FORWARDING_RULE_NAME é um nome exclusivo que descreve a regra de encaminhamento para direcionar o tráfego de rede para o proxy HTTPS.
- TARGET_HTTPS_PROXY_NAME é um nome do proxy HTTPS de anteriormente.
- EXTERNAL_IP é o nome do endereço IPv4 que foi criado anteriormente.

Teste o balanceador de carga

Agora que configurou o equilibrador de carga, pode começar a enviar tráfego para o endereço IP do equilibrador de carga para testes antes de migrar o domínio.

Aceda à página Equilíbrio de carga na Google Cloud consola.
Aceda a Balanceamento de carga
Clique no balanceador de carga que acabou de criar.
Tome nota do endereço IP do balanceador de carga.
Para um balanceador de carga HTTPS, pode testá-lo através de um navegador de Internet acedendo a https://IP_ADDRESS. Substitua IP_ADDRESS pelo endereço IP do balanceador de carga, por exemplo, 30.90.80.100.
- Se isso não funcionar e estiver a usar um certificado gerido pela Google, confirme que o seu certificado está ACTIVE, e que o mapeamento de certificados está ACTIVE.
- Se usar um certificado autoassinado para testes, o navegador apresenta um aviso. Tem de instruir explicitamente o navegador para aceitar um certificado autossinado. Clique no aviso para ver a página real.
Para ver mais opções de configuração, consulte o artigo Configure um balanceador de carga HTTP(S) externo global com plataformas sem servidor.

Associe o seu domínio ao balanceador de carga

Após a criação do balanceador de carga, tome nota do endereço IP associado ao balanceador de carga, por exemplo, 30.90.80.100. Para direcionar o seu domínio para o equilibrador de carga, crie um registo A através do serviço de registo de domínios. Se adicionou vários domínios ao seu certificado SSL, tem de adicionar um registo A para cada um, todos a apontar para o endereço IP do equilibrador de carga. Por exemplo, para criar registos A para www.example.com e example.com, use o seguinte:

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Se usar o Cloud DNS como fornecedor de DNS, consulte o artigo Adicione, modifique e elimine registos.

Elimine o mapeamento do domínio personalizado do App Engine

Na Google Cloud consola:

Aceda ao separador Domínios personalizados da página Definições do App Engine.

Aceda a Domínios personalizados
Selecione o nome do domínio personalizado e clique em Eliminar.

Em alternativa, pode usar comandos gcloud ou a API Admin para eliminar o domínio personalizado.

Configure o controlo de entrada para permitir apenas o acesso através do Cloud Load Balancing

Depois de testar o balanceador de carga, recomendamos que atualize a app do App Engine para aceitar tráfego apenas do Cloud Load Balancing. Para saber como configurar os controlos de entrada internal-and-cloud-load-balancing, consulte as definições de entrada.