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

ID da região

O REGION_ID é um código abreviado que o Google atribui com base na região que você selecionou ao criar o aplicativo. O código não corresponde a um país ou estado, ainda que alguns IDs de região sejam semelhantes aos códigos de país e estado geralmente usados. Para apps criados após fevereiro de 2020, o REGION_ID.r está incluído nos URLs do App Engine. Para apps existentes criados antes dessa data, o ID da região é opcional no URL.

Saiba mais sobre IDs de região.

Neste guia, você verá como configurar um novo endpoint público para seu aplicativo do App Engine usando o Cloud Load Balancing.

Com o Cloud Load Balancing, você configura o endpoint do domínio personalizado como um serviço de front-end e o aplicativo do App Engine como um serviço de back-end usando um grupo de endpoints de rede (NEG, na sigla em inglês) sem servidor. O tráfego para o endpoint do serviço de front-end do Cloud Load Balancing é roteado da mesma forma que antes, incluindo todas as regras de roteamento definidas no arquivo dispatch.yaml do app.

O diagrama a seguir descreve as mudanças no app:

Usar um domínio personalizado do App Engine e transferir as solicitações recebidas para um serviço de front-end do Cloud Load Balancing que distribui solicitações para o serviço de back-end do App Engine.

Ao migrar para o Cloud Load Balancing, você ganha muito mais flexibilidade no processamento do tráfego ao alcançar seu domínio, como a exibição de conteúdo estático do Cloud Storage ou a adição de serviços em execução em outras plataformas de computação, como o Cloud. Run e Google Kubernetes Engine.

Você também recebe acesso aos principais recursos do Google Cloud que não estão disponíveis no App Engine, incluindo:

Google Cloud Armor, para maior segurança com proteção avançada contra DDoS, controles de acesso baseados em IP e localização, regras de firewall de aplicativos da Web e muito mais
Cloud CDN, para entrega de conteúdo em cache
Políticas de SSL, para gerenciar quais recursos de SSL e versões de TLS seu app aceitará

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

Verificar se você tem as permissões necessárias
Criar um certificado gerenciado pelo Google
Configurar o Cloud Load Balancing
Testar o balanceador de carga
Como conectar seu domínio ao balanceador de carga
Excluir o mapeamento de domínios personalizados do App Engine
Configurar o controle de entrada para permitir acesso apenas pelo Cloud Load Balancing

Antes de começar

Ter um aplicativo do App Engine com um domínio personalizado definido nas configurações do App Engine.

Configurar permissões

Para seguir este guia, você precisa criar um certificado gerenciado pelo Google, um NEG sem servidor e um balanceador de carga HTTP(S) externo em um projeto. É necessário ser um proprietário ou editor do projeto ou ter os seguintes papéis do IAM:

Tarefa	Papel necessário
Criar um certificado SSL gerenciado pelo Google usando o Gerenciador de certificados	Proprietário do Gerenciador de certificados ou Editor do Gerenciador de certificados e Administrador do balanceador de carga do Compute
Atualizar registros DNS para o domínio personalizado	Administrador do Cloud DNS, se estiver usando o Cloud DNS como solução de DNS Se você estiver usando outro provedor de DNS, precisará de permissões para adicionar e atualizar os registros DNS do domínio personalizado.
Criar balanceador de carga e componentes de rede	Administrador de rede do Compute
Criar e modificar NEGs	Administrador da instância do Compute
Criar e modificar certificados SSL	Administrador de segurança do Compute
Excluir domínios personalizados nas configurações do App Engine	Papel de administrador do App Engine ou um papel que contém a permissão `appengine.applications.update`.

criar um certificado SSL gerenciado pelo Google

Um certificado SSL gerenciado pelo Google (também conhecido como certificado TLS na documentação) permite que o Google Cloud receba, gerencie e renove os certificados automaticamente. Para migrar para o front-end do Cloud Load Balancing sem causar inatividade no serviço atual do App Engine, use o Gerenciador de certificados para criar uma autorização DNS e seu certificado gerenciado pelo Google.

A documentação do Cloud Load Balancing tem instruções semelhantes para criar um certificado SSL gerenciado pelo Google, mas as instruções usam a autorização do balanceador de carga, que requer inatividade para o app. Serviço de mecanismo que pode levar várias horas. Para mais informações, consulte Autorização de domínio para certificados gerenciados pelo Google.

Para evitar a inatividade do app, siga as etapas nesta página.

Criar DnsAuthorization

Crie a autorização DNS no Gerenciador de certificados executando os seguintes comandos:
```
gcloud certificate-manager dns-authorizations create AUTHORIZATION_NAME \
    --domain="DOMAIN_NAME"
gcloud certificate-manager dns-authorizations describe AUTHORIZATION_NAME
```
Substitua:
- AUTHORIZATION_NAME é um nome exclusivo que descreve essa autorização DNS.
- DOMAIN_NAME é o nome de domínio personalizado do App Engine para o qual você está criando a autorização DNS.
Anote o CNAME retornado pelo comando gcloud. Você precisa usá-lo para atualizar seu registro DNS nas etapas a seguir.

Adicionar o registro CNAME à configuração de DNS

Se você estiver usando o Cloud DNS ou outra solução de DNS de terceiros, siga as instruções apropriadas para seu caso de uso:

Cloud DNS

Ao criar uma autorização de DNS, o comando gcloud retorna o registro CNAME correspondente. Você precisa adicionar esse registro CNAME à sua configuração DNS na zona DNS do domínio de destino da seguinte maneira:

Inicie a transação do registro DNS:
```
gcloud dns record-sets transaction start --zone="DNS_ZONE_NAME"
```
Substitua DNS_ZONE_NAME pelo nome da zona de DNS pública. Se você estiver usando o Google Cloud para gerenciar seu domínio e receber tráfego para ele, você já terá criado uma zona de DNS pública. Para ver sua zona de DNS pública, consulte Listar e descrever zonas gerenciadas.
Adicione o registro 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:
- CNAME_RECORD é o valor total do registro CNAME retornado pelo comando gcloud que criou a autorização DNS correspondente.
- DOMAIN_NAME é o nome de domínio personalizado do App Engine. Você precisa incluir o ponto final após o nome de domínio de destino.
- DNS_ZONE_NAME é o nome da zona de DNS de destino anterior.
Execute a transação do registro DNS para salvar as alterações:
```
gcloud dns record-sets transaction execute --zone="DNS_ZONE_NAME"
```
Substitua DNS_ZONE_NAME pelo nome da zona DNS de destino anterior.

Outra solução de DNS

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

Criar um certificado gerenciado pelo Google que faça referência à autorização DNS

Para criar um certificado gerenciado pelo Google que faça referência à autorização DNS criada nas etapas anteriores, execute os seguintes comandos:

Crie um certificado gerenciado pelo Google:
```
gcloud certificate-manager certificates create CERTIFICATE_NAME \
--domains=DOMAIN_NAME --dns-authorizations=AUTHORIZATION_NAME
```
Substitua:
- CERTIFICATE_NAME é um nome exclusivo que descreve o certificado.
- DOMAIN_NAME é o nome de 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 a seguir para verificar se o próprio certificado está ativo antes de implantá-lo no balanceador de carga. Pode levar várias horas para que o estado do certificado mude para ACTIVE.

gcloud certificate-manager certificates describe CERTIFICATE_NAME

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

O gcloud retorna uma resposta semelhante a esta:

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 ferramenta gcloud retornar uma saída diferente, consulte Solução de problemas do Gerenciador de certificados.

Criar um CertificateMap

Criar um CertificateMap:
```
gcloud certificate-manager maps create CERTIFICATE_MAP_NAME
```
Substitua CERTIFICATE_MAP_NAME pelo nome exclusivo que descreve o mapa de certificado.
Crie uma entrada de mapa de certificado e a associe ao seu certificado e ao mapa de certificado anterior:
```
gcloud certificate-manager maps entries create CERTIFICATE_MAP_ENTRY_NAME \
    --map=CERTIFICATE_MAP_NAME \
    --certificates=CERTIFICATE_NAME \
    --set-primary
```
Substitua:
- CERTIFICATE_MAP_ENTRY_NAME é um nome exclusivo que descreve a entrada desse mapa de certificado.
- CERTIFICATE_MAP_NAME é o nome do mapa de certificado ao qual esta entrada do mapa de certificado está anexada.
- CERTIFICATE_NAME é o nome do certificado que você quer associar a essa entrada do mapa de certificados.
É possível anexar a sinalização --set-primary para garantir que o certificado seja usado como o padrão se um nome de domínio não for especificado.
Verificar se o mapa de certificados está ativo.

Use o comando a seguir para verificar se a entrada do mapa de certificados está ativa antes de anexar o mapa de certificado correspondente ao proxy de destino:
```
gcloud certificate-manager maps entries describe CERTIFICATE_MAP_ENTRY_NAME \
    --map=CERTIFICATE_MAP_NAME
```
Substitua:
- CERTIFICATE_MAP_ENTRY_NAME é o nome da entrada do mapa de certificado anterior.
- CERTIFICATE_MAP_NAME é o nome do mapa de certificado ao qual esta entrada do mapa de certificado está anexada.
O gcloud retorna uma resposta semelhante a esta:
```
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 como usar o Gerenciador de certificados, consulte Como funciona o Gerenciador de certificados.

Configurar o Cloud Load Balancing

Depois de receber um certificado gerenciado pelo Google, é possível substituir seu domínio personalizado do App Engine por um serviço de front-end do Cloud Load Balancing.

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

Como distribuir tráfego para um aplicativo do App Engine

As regras de encaminhamento roteiam as solicitações recebidas de endereços IP externos e solicitações diretas para o proxy HTTPS de destino. Os balanceadores de carga HTTPS usam mapas de URL para direcionar solicitações ao serviço de back-end, que contém um NEG sem servidor para o serviço do App Engine.

Reservar um endereço IP externo

Antes de configurar o Cloud Load Balancing, é necessário configurar um endereço IP externo estático global para que os usuários possam acessar o balanceador de carga.

Console

Acesse a página Endereços IP externos no Console do Google Cloud.

Acessar Endereços IP externos
Clique em Reservar endereço estático para reservar um endereço IPv4.
Atribua um Nome para o endereço estático, por exemplo, appengine-external-ip.
Defina o Nível da rede como Premium.
Defina Versão IP como IPv4.
Defina 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 serem criados.

Anote o endereço IPv4 que foi reservado:

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

Configurar o serviço de back-end do App Engine

Um grupo de endpoints de rede (NEG, na sigla em inglês) é usado para especificar um grupo de endpoints de 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. Em seguida, configure o serviço de back-end, as regras de roteamento e o serviço de front-end no Cloud Load Balancing.

Crie um NEG sem servidor para seu aplicativo do App Engine:
```
gcloud compute network-endpoint-groups create APP_ENGINE_NEG \
--network-endpoint-type=serverless \
--app-engine-app \
--region=APP_ENGINE_REGION
```
Substitua:
- APP_ENGINE_NEG é o nome do grupo de endpoints da rede.
- APP_ENGINE_REGION é a região que foi definida no App Engine.
É possível anexar a sinalização --app-engine-app acima para usar o roteamento padrão, em vez de direcionar para um serviço específico do App Engine. Usar o roteamento padrão significa que as solicitações serão enviadas para o serviço padrão (https://PROJECT_ID.REGION_ID.r.appspot.com) e seguirão todas as regras de roteamento que definidos no arquivo dispatch.yaml. Esse é o mesmo comportamento que os domínios personalizados configurados com o 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 ser criado.

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:
- APP_ENGINE_BACKEND é o nome do serviço de back-end anterior.
- APP_ENGINE_NEG é o nome do grupo de endpoints da rede.
- APP_ENGINE_REGION é a região definida no App Engine.
Crie um mapa de URL para encaminhar solicitações recebidas para o serviço de back-end :
```
gcloud compute url-maps create URL_MAP_NAME \
      --default-service APP_ENGINE_BACKEND
```
Substitua:
- URL_MAP_NAME é um nome exclusivo para o recurso de mapa de URL que define o mapeamento de URLs para os serviços de back-end.
- APP_ENGINE_BACKEND é o nome do serviço de back-end anterior.
Crie um proxy de destino HTTPS para encaminhar solicitações ao mapa de URLs.
```
gcloud compute target-https-proxies create TARGET_HTTPS_PROXY_NAME \
      --certificate-map=CERTIFICATE_MAP_NAME \
      --url-map=URL_MAP_NAME
```
Substitua:
- TARGET_HTTPS_PROXY_NAME é um nome exclusivo que você escolhe para descrever seu proxy HTTPS.
- CERTIFICATE_MAP_NAME é o nome do mapa de certificado que faz referência à entrada do mapa de certificado e ao certificado associado.
- URL_MAP_NAME é o nome do mapa de URL anterior.
Crie uma regra de encaminhamento para encaminhar as solicitações recebidas 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:
- HTTPS_FORWARDING_RULE_NAME é um nome exclusivo que descreve a regra de encaminhamento para direcionar o tráfego da rede para o proxy HTTPS.
- TARGET_HTTPS_PROXY_NAME é o nome do proxy HTTPS anterior.
- EXTERNAL_IP é o nome do endereço IPv4 que foi criado anteriormente.

Testar o balanceador de carga

Agora que o balanceador de carga foi configurado, comece a enviar tráfego para o endereço IP dele para testes antes de migrar o domínio.

Acesse a página Balanceamento de carga no Console do Google Cloud.
Acesse balanceamento de carga
Clique no balanceador de carga que você acabou de criar.
Anote o Endereço IP do balanceador de carga.
Para um balanceador de carga HTTPS, é possível testar seu balanceador de carga usando um navegador da Web acessando 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 você estiver usando um certificado gerenciado pelo Google, confirme se seucertificado éACTIVE e que amapa de certificado éACTIVE (em inglês).
- Caso você tenha usado um certificado autoassinado durante o teste, o navegador exibirá um aviso. Você precisa permitir que o navegador aceite um certificado autoassinado. Clique no aviso para ver a página real.
Para mais opções de configuração, consulte Configurar um balanceador de carga HTTP(S) externo global com plataformas sem servidor.

Como conectar seu domínio ao balanceador de carga

Após a criação do balanceador de carga, anote o endereço IP associado a ele, por exemplo, 30.90.80.100. Para apontar seu domínio para o balanceador de carga, crie um registro A usando o serviço de registro de domínio. Se você adicionou vários domínios ao certificado SSL, adicione um registro A para cada um deles, todos apontando para o endereço IP do balanceador de carga. Por exemplo, para criar registros 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 você usa o Cloud DNS como provedor de DNS, consulte Adicionar, modificar e excluir registros.

Excluir o mapeamento de domínio personalizado do App Engine

No console do Google Cloud:

Acesse a guia Domínios personalizados da página Configurações do App Engine.

Acesse "Domínios personalizados"
Selecione o nome de domínio personalizado e clique em Excluir.

Se preferir, use comandos da gcloud ou a API Admin para excluir o domínio personalizado.

Configurar o controle de entrada para permitir acesso apenas pelo Cloud Load Balancing

Depois de testar seu balanceador de carga, recomendamos atualizar seu aplicativo do App Engine para aceitar o tráfego somente do Cloud Load Balancing. Para saber como definir internal-and-cloud-load-balancing controles de entrada, consulte Configurações de entrada.