Esta página foi traduzida pela API Cloud Translation.

Introdução ao balanceamento de carga para o gateway de API

Neste tutorial, mostramos como criar um balanceador de carga de aplicativo externo global para encaminhar solicitações ao gateway de API. O processo de configuração segue as mesmas etapas usadas para configurar a integração do balanceador de carga de aplicativo externo global com outros produtos sem servidor, como o Cloud Run, as funções do Cloud Run e o App Engine.

Embora um balanceador de carga não seja necessário para o funcionamento do API Gateway, ele permite que o gateway aproveite os benefícios de um balanceador de carga. Por exemplo, o uso de um balanceador de carga de aplicativo externo global com o API Gateway permite:

Use domínios personalizados.
Usar o Google Cloud Armor como um serviço de segurança de rede.
Gerencie o balanceamento de carga eficiente entre gateways em vários locais.
Implementar o gerenciamento de tráfego avançado.

Antes de começar

Faça o download e instale a CLI do Google Cloud, caso ainda não tenha feito isso.
Fazer o download da gcloud CLI
Atualize os componentesgcloud:
```
gcloud components update
```
Siga o Guia de início rápido do Gateway de API para implantar um serviço do Cloud Run e criar um gateway que aponte para esse serviço.
Configurar permissões.
Adicione um recurso de certificado SSL.

Implantar um serviço do Cloud Run e uma instância de gateway de API

Neste tutorial, você vai implantar um "hello-world" serviço para o Cloud Run, criar um gateway que encaminha para o serviço do Cloud Run e configurar um balanceador de carga de aplicativo externo global para encaminhar solicitações a um domínio personalizado.

Embora este tutorial use o Cloud Run como o serviço de back-end para o gateway de API, estas etapas também se aplicam a todos os serviços de back-end compatíveis com o gateway de API.

Após a conclusão do guia de início rápido do gateway de API, você terá um URL de gateway implantado que aponta para o serviço do Cloud Run.

Configurar permissões

Neste tutorial, você vai criar um grupo de endpoints de rede (NEG) sem servidor e um balanceador de carga de aplicativo externo global em um projeto do Cloud. Isso requer um papel de proprietário ou editor do projeto ou os seguintes papéis de IAM do Compute Engine:

Tarefa	Papel necessário
Criar balanceador de carga e componentes de rede	Administrador de rede
Criar e modificar NEGs	Administrador da instância do Compute
Criar e modificar certificados SSL	Administrador de segurança

É possível criar um recurso de certificado SSL

Para criar um balanceador de carga de aplicativo externo global, um recurso de certificado SSL precisa ser adicionado ao front-end do balanceador de carga. Crie um recurso de certificado SSL usando um certificado SSL gerenciado pelo Google ou um certificado SSL autogerenciado.

Certificados gerenciados pelo Google. O uso de certificados gerenciados pelo Google é recomendado porque o Google Cloud recebe, gerencia e renova esses certificados automaticamente. Para criar um certificado gerenciado pelo Google, você precisa ter um domínio e os registros DNS desse domínio para que o certificado seja provisionado. Se você ainda não tiver um domínio, será possível conseguir um no Google Domains. Além disso, será necessário atualizar o registro DNS A do domínio para apontar para o endereço IP do balanceador de carga criado em uma etapa posterior. Para instruções detalhadas, consulte Como usar certificados gerenciados pelo Google.
Certificados autoassinados. Se você não quiser configurar um domínio agora, use um certificado SSL autoassinado para testes.

Este exemplo pressupõe que você já criou um recurso de certificado SSL.

Se você quiser testar esse processo sem criar um recurso de certificado SSL (ou um domínio conforme exigido pelos certificados gerenciados pelo Google), ainda será possível usar as instruções nesta página para configurar uma carga HTTP.

Criar o balanceador de carga de aplicativo externo global

Crie um NEG sem servidor para o gateway de API.

Um grupo de endpoints de rede (NEG) especifica um grupo de endpoints de back-end para um balanceador de carga. Um NEG sem servidor é um back-end que aponta para um serviço como o gateway de API, conforme mostrado na figura a seguir:

Para criar um NEG sem servidor para seu gateway, execute o seguinte comando, em que:
- SERVERLESS_NEG_NAME é o nome do NEG sem servidor a ser criado;
- GATEWAY_ID especifica o nome do gateway.
- REGION_ID é a região de implantação do NEG sem servidor (deve corresponder à região do gateway).
```
gcloud beta compute network-endpoint-groups create SERVERLESS_NEG_NAME \
  --region=REGION_ID \
  --network-endpoint-type=serverless \
  --serverless-deployment-platform=apigateway.googleapis.com \
  --serverless-deployment-resource=GATEWAY_ID
```
Exemplo:
```
gcloud beta compute network-endpoint-groups create api-gateway-serverless-neg \
  --region=us-central1 \
  --network-endpoint-type=serverless \
  --serverless-deployment-platform=apigateway.googleapis.com \
  --serverless-deployment-resource=my-gateway
```
Crie um serviço de back-end para definir como o balanceador de carga de aplicativo externo global distribui o tráfego.

A configuração do serviço de back-end contém um conjunto de valores, como o protocolo usado para se conectar aos back-ends, várias configurações de distribuição e sessão, verificações de integridade e tempos limite, conforme mostrado na figura a seguir:

Para criar um serviço de back-end, execute o seguinte comando:
```
gcloud compute backend-services create BACKEND_SERVICE_NAME --global
```
em que BACKEND_SERVICE_NAME é o nome do novo serviço de back-end.

Exemplo:
```
gcloud compute backend-services create api-gateway-backend-service --global
```
Para adicionar o NEG sem servidor como um back-end ao serviço de back-end, execute o seguinte comando, em que:
- BACKEND_SERVICE_NAME: o nome do seu serviço de back-end.
- SERVERLESS_NEG_NAME é o nome do NEG sem servidor criado na etapa anterior;
- REGION_ID é a região de implantação do NEG sem servidor (deve corresponder à região do gateway).
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --global \
  --network-endpoint-group=SERVERLESS_NEG_NAME \
  --network-endpoint-group-region=REGION_ID
```
Exemplo:
```
gcloud compute backend-services add-backend api-gateway-backend-service \
  --global \
  --network-endpoint-group=api-gateway-serverless-neg \
  --network-endpoint-group-region=us-central1
```
Crie um mapa de URLs para fazer o roteamento das solicitações recebidas ao serviço de back-end, conforme mostrado na figura abaixo:

Para criar o mapa de URL, execute o seguinte comando, em que:
- URL_MAP_NAME é o nome do mapa de URL a ser criado.
- BACKEND_SERVICE_NAME: o nome do seu serviço de back-end.
```
gcloud compute url-maps create URL_MAP_NAME \
  --default-service BACKEND_SERVICE_NAME
```
Exemplo:
```
gcloud compute url-maps create api-gateway-url-map \
  --default-service api-gateway-backend-service
```
Este mapa de URL de exemplo segmenta apenas um serviço de back-end que representa um único gateway, portanto, regras de host ou correspondências de caminho não são necessárias. Se você tiver mais de um serviço de back-end, poderá usar regras de host para direcionar solicitações para serviços diferentes com base no nome do host. Use correspondências de caminho para direcionar solicitações para serviços diferentes com base no caminho da solicitação.

Exemplo:
```
gcloud compute url-maps add-path-matcher api-gateway-url-map \
  --path-matcher-name=my-pm2  \
  --default-service=my-host-default-backend \
  --path-rules="/video=video-service,/video/*=video-service" \
  --new-hosts my-hosts.com
```
```
gcloud compute url-maps add-host-rule api-gateway-url-map \
  --hosts=my-app-domain \
  --path-matcher-name=my-app-path-matcher
```
Para saber mais sobre as regras de host e as correspondências de caminho, consulte a documentação Mapa de URL.
Crie um certificado SSL para seu proxy de destino, conforme mostrado na figura abaixo:

Para criar um balanceador de carga de aplicativo externo global, é necessário um recurso de certificado SSL para o proxy de destino HTTP(S). É possível criar um recurso de certificado SSL usando um certificado SSL gerenciado pelo Google ou um certificado SSL autogerenciado. Recomendamos o uso de certificados gerenciados pelo Google. Se você estiver testando esse processo sem um recurso de certificado SSL e quiser configurar um balanceador de carga HTTP, pule esta etapa.

Para criar um certificado gerenciado pelo Google, você precisa ter um domínio. Se você não tiver um domínio, poderá usar um certificado SSL autoassinado para teste.

Para criar um recurso de certificado SSL gerenciado pelo Google:
```
gcloud compute ssl-certificates create SSL_CERTIFICATE_NAME \
  --domains DOMAIN
```
Para criar um recurso de certificado SSL autogerenciado:
```
gcloud compute ssl-certificates create SSL_CERTIFICATE_NAME \
  --certificate CRT_FILE_PATH \
  --private-key KEY_FILE_PATH
```
Crie um proxy HTTP(S) de destino para encaminhar solicitações ao mapa de URLs, conforme mostrado na figura abaixo:

Para criar o proxy de destino, use o seguinte comando, em que:
- TARGET_HTTPS_PROXY_NAME é o nome do proxy HTTP(S) de destino a ser criado.
- URL_MAP_NAME é o nome do mapa de URL criado em uma etapa anterior.
- Opcional: SSL_CERT_NAME é o nome do certificado SSL criado.
```
gcloud compute target-https-proxies create TARGET_HTTPS_PROXY_NAME \
  --ssl-certificates=SSL_CERT_NAME \
  --url-map=URL_MAP_NAME
```
Exemplo:
```
gcloud compute target-https-proxies create api-gateway-https-proxy \
  --ssl-certificates=hello-cert \
  --url-map=api-gateway-url-map
```
Como mencionado anteriormente, é possível criar um balanceador de carga HTTP sem criar um recurso de certificado SSL. Para fazer isso, use o seguinte comando:
```
gcloud compute target-http-proxies create TARGET_HTTP_PROXY_NAME \
      --url-map=URL_MAP_NAME
```
Exemplo:
```
gcloud compute target-http-proxies create api-gateway-http-proxy \
  --url-map=api-gateway-url-map
```
Os comandos subsequentes para proxies HTTP precisam ser modificados para acomodar a flag --target-http-proxy e TARGET_HTTP_PROXY_NAME para as contrapartes HTTP(S).
Crie uma regra de encaminhamento para encaminhar as solicitações recebidas para o proxy, conforme mostrado na figura a seguir:

Use o comando a seguir para criar a regra de encaminhamento, em que:
- HTTPS_FORWARDING_RULE_NAME é o nome da regra a ser criada;
- TARGET_HTTPS_PROXY_NAME é o nome do proxy de destino HTTP(S).
```
gcloud compute forwarding-rules create HTTPS_FORWARDING_RULE_NAME \
  --target-https-proxy=TARGET_HTTPS_PROXY_NAME \
  --global \
  --ports=443
```
Exemplo:
```
gcloud compute forwarding-rules create my-fw \
  --target-https-proxy=api-gateway-https-proxy \
  --global \
  --ports=443
```

Atualizar registros DNS com o endereço IP do balanceador de carga

Se você tiver um domínio personalizado, esta etapa será necessária para definir as configurações de DNS do seu domínio de modo que elas apontem para o novo endereço IP do serviço. Isso também será necessário se você tiver criado um balanceador de carga de aplicativo externo global com um certificado gerenciado pelo Google (que requer um domínio). Recomenda-se alocar e usar um endereço IP estático quando usado com DNS. As instruções específicas para esta etapa dependem do seu provedor de DNS.

Para enviar tráfego ao balanceador de carga, o registro DNS do seu domínio (neste tutorial, my-app-domain) precisa apontar para os endereços IP do balanceador de carga.

Para encontrar o endereço IP da regra de encaminhamento global, use este comando:
```
gcloud compute forwarding-rules list
```
Atualize o registro DNS A ou AAAA do seu domínio para que aponte para o endereço IP do balanceador de carga, de modo que o tráfego enviado para o URL de domínio personalizado existente seja roteado por meio do balanceador de carga. O DNS pode levar alguns segundos ou várias horas para propagar essa alteração no servidor DNS.
Teste para confirmar se o gateway está recebendo tráfego usando curl ou acessando o URL no navegador. Por exemplo: https://my-app-domain

Após o teste, você verá a resposta gerada pelo serviço do Cloud Run. Por exemplo, pode ser uma página HTML "Hello World" ou outra resposta esperada gerada diretamente pelo serviço de back-end. Isso significa que a solicitação está passando pelo balanceador de carga, e o serviço de back-end está instruindo o balanceador de carga a enviá-lo para o gateway.

Testar a configuração do balanceador de carga

Agora que você configurou o balanceador de carga, é possível começar a enviar tráfego para o endereço IP dele.

Para encontrar o endereço IP da regra de encaminhamento global, use o seguinte comando:

gcloud compute forwarding-rules list

Use o comando curl para testar a resposta dos diversos URLs dos serviços. Exemplo:

curl https://HOST_URL/hello/

curl https://HOST_URL

Use o console do Cloud do gateway de API para verificar se as solicitações estão chegando aos serviços corretos.

Parabéns! Você configurou o balanceador de carga de aplicativo externo global para o gateway de API^PREVIEW.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste guia de início rápido, exclua os recursos do Cloud Load Balancing criados. Se esses recursos foram criados no próprio projeto, exclua todo o projeto. Caso contrário, exclua os recursos individualmente.

Exclua o projeto

Execute o comando a seguir, substituindo project_id pelo ID do projeto:

gcloud projects delete PROJECT_ID

Excluir recursos individuais

Exclua cada componente no balanceador de carga:

Exclua as regras de encaminhamento:

gcloud compute forwarding-rules delete HTTPS_FORWARDING_RULE_NAME --global

Exclua os endereços IP externos globais:

gcloud compute addresses delete IP_ADDRESSES --global

Exclua o proxy de destino:

gcloud compute target-https-proxies delete TARGET_HTTP_PROXY_NAME

Exclua o mapa de URL:

gcloud compute url-maps delete URL_MAP_NAME

Exclua os serviços de back-end:

gcloud compute backend-services delete BACKEND_SERVICE_NAME --global

(Opcional) Exclua o certificado SSL

gcloud compute ssl-certificates delete SSL_CERTIFICATE_NAME

Exclua o NEG sem servidor:

gcloud compute network-endpoint-groups delete SERVERLESS_NEG_NAME --region=REGION