Configurar o gRPC do Cloud Endpoints para o Cloud Run for Anthos com ESPv2

Configurar o gRPC do Cloud Endpoints para o Cloud Run for Anthos com ESPv2

OpenAPI | gRPC

Nesta página, mostramos como configurar o Cloud Endpoints para o Cloud Run for Anthos. O Endpoints usa o Extensible Service Proxy V2 (ESPv2) como um gateway de API. Para fornecer gerenciamento de API para o Cloud Run for Anthos, implante o contêiner pré-construído ESPv2 no Cloud Run for Anthos em execução em um cluster do GKE.

Com essa configuração, o ESPv2 intercepta todas as solicitações e executa as verificações necessárias, como a autenticação, antes de invocar o serviço. Quando o serviço responde, a telemetria é coletada e relatada pelo ESPv2.

Para uma visão geral do Endpoints, consulte Sobre o Endpoints e Arquitetura do Endpoints.

Lista de tarefas

Ao seguir o tutorial, use a lista de tarefas abaixo. Todas as tarefas são necessárias para concluir este tutorial.

1. Crie um projeto do Google Cloud e, se você não tiver implantado seu próprio Cloud Run for Anthos, implante um serviço de amostra. Consulte Antes de começar.

2. Crie um cluster do GKE com o Cloud Run for Anthos ativado.

3. Implante uma amostra de gRPC do serviço do Cloud Run for Anthos.

4. Crie um documento de configuração da API gRPC que descreva sua API do Endpoints e configure as rotas para o serviço do Cloud Run for Anthos. Consulte Como configurar o Endpoints.

5. Implante o documento de configuração da API gRPC para criar um serviço gerenciado. Consulte Como implantar a configuração do Endpoints.

6. Crie uma nova imagem do Docker do ESPv2 com a configuração do serviço do Endpoints. Consulte Como criar uma nova imagem do ESPv2.

7. Implante a nova imagem ESPv2 do Cloud Run for Anthos. Consulte Como implantar a imagem ESPv2 Beta do Cloud Run.

8. Crie um mapeamento de domínio para o serviço ESPv2 do Cloud Run for Anthos.

9. Teste sua configuração em Como enviar uma solicitação para a API.

10. Rastrear a atividade para seus serviços. Consulte Como rastrear a atividade da API.

11. Limpeza.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

• Cloud Run for Anthos
• Endpoints

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

4. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

5. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

6. Anote o ID do projeto, porque ele será necessário mais tarde. No restante desta página, esse ID do projeto é chamado de ESP_PROJECT_ID.
7. Faça o download e instale a CLI gcloud.

Como configurar a linha de comando gcloud

Para configurar a CLI gcloud no Cloud Run for Anthos for Anthos:

1. Verifique se a CLI gcloud está autorizada a acessar seus dados e serviços.

   1. Faça login.

      gcloud auth login

   2. Na nova guia do navegador que é aberta, escolha uma conta que tenha o papel de Editor ou Proprietário no projeto do Google Cloud que você criou para implantar o ESPv2 no Cloud Run.

2. Atualize os componentes do gcloud instalados:

   gcloud components update

3. Defina a plataforma como gke e defina a configuração de projeto padrão de gcloud para a que você acabou de criar:

   gcloud config set run/platform gke
   gcloud config set project ESP_PROJECT_ID

   Substitua ESP_PROJECT_ID pelo ID do projeto que você criou.

4. Defina a zona que você quer para o novo cluster. É possível usar qualquer zona compatível com o GKE, por exemplo:

   gcloud config set compute/zone ZONE

   Substitua ZONE pela sua zona. Por exemplo, use us-central1-a. É possível usar qualquer zona compatível com o GKE.

5. Ative as APIs a seguir no projeto, que são necessárias para criar um cluster e um contêiner no Google Container Registry:

   gcloud services enable container.googleapis.com containerregistry.googleapis.com cloudbuild.googleapis.com

Como criar um cluster do GKE com o Cloud Run for Anthos ativado

Para criar um cluster e ativá-lo no Cloud Run para Anthos no Google Cloud:

1. Crie um cluster novo usando o comando:

   gcloud container clusters create CLUSTER_NAME \
     --addons=HttpLoadBalancing,CloudRun \
     --machine-type=n1-standard-4 \
     --num-nodes=3

   Substitua CLUSTER_NAME pelo nome do cluster.

   Observação: o tamanho mínimo do cluster é de três nós, e o tipo mínimo de máquina é n1-standard-4 neste exemplo.

   Embora estas instruções não ativem o escalonamento automático de cluster para redimensionar clusters para demanda, o Cloud Run for Anthos no Google Cloud escalona automaticamente as instâncias no cluster.

2. Aguarde a conclusão da criação do cluster. Durante o processo de criação, você verá mensagens semelhantes a estas:

   Creating cluster CLUSTER_NAME...done.
   Created [https://container.googleapis.com/v1/projects/ESP_PROJECT_ID/zones/ZONE/clusters/CLUSTER_NAME].

   A saída também mostra a versão do cluster na coluna NODE_VERSION da saída. Por exemplo, 1.15.11-gke.1 ou 1.14.10-gke.27. Anote a versão do cluster para uso posterior neste documento.

3. Defina os padrões de gcloud para usar o novo cluster e o local do cluster para evitar a necessidade de especificá-los ao usar a CLI gcloud:

   gcloud config set run/cluster CLUSTER_NAME
   gcloud config set run/cluster_location ZONE

4. Use o seguinte comando para consultar os detalhes do novo cluster:

   gcloud container clusters describe CLUSTER_NAME

5. Use o seguinte comando para buscar as credenciais do seu cluster:

   gcloud container clusters get-credentials CLUSTER_NAME

Como implantar um serviço gRPC de amostra do Cloud Run

Para implantar o contêiner de amostra do Cloud Run for Anthos "grpc-bookstore" no cluster que você acabou de criar:

1. Siga as etapas no Guia de início rápido do gRPC em Python para instalar o gRPC e as ferramentas dele.

2. Esta amostra do servidor gRPC contém uma imagem do Docker pré-criada para o "grpc-bookstore service" do Python: gcr.io/endpointsv2/python-grpc-bookstore-server:2. Use o seguinte comando para implantar "grpc-bookstore" no cluster:

   gcloud run deploy GRPC_SERVICE \
     --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2 \
     --platform=gke \
    --connectivity=internal \
     --use-http2

   Observe que você o especificou como um serviço interno para que não possa ser acessado externamente.

   Substitua GRPC_SERVICE pelo nome do serviço. Exemplo:

   gcloud run deploy grpc-bookstore \
     --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2 \
     --platform=gke \
     --connectivity=internal \
     --use-http2

   Quando terminar, a seguinte mensagem será exibida:

   Service [grpc-bookstore] revision [grpc-bookstore-00001-nuk] has been deployed and is serving 100 percent of traffic at http://grpc-bookstore.default.svc.cluster.local

   Quando você cria um serviço interno, o GKE cria um nome DNS (grpc-bookstore.default.svc.cluster.local neste exemplo) que só pode ser resolvido para solicitações originadas no próprio cluster, não para solicitações externas. Não é possível acessar esse DNS externamente no cluster. Consulte Serviços do Cloud Run para saber mais.

3. Para verificar se o serviço está funcionando corretamente, implante um pod com a mesma imagem do Docker no cluster. A imagem contém o código do cliente gRPC para "grpc-bookstore" que você pode usar para testar o serviço interno.

   1. Use o seguinte comando kubectl para implantar um pod no mesmo cluster que você implantou acima:

      kubectl run grpc --generator=run-pod/v1 \
        --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2

      Esta imagem contém o script bookstore_client.py, que pode ser usado para fazer solicitações de clientes de dentro do cluster.

      Observação: para versões mais recentes do kubectl, o comando pode emitir o seguinte aviso:

      Flag --generator has been deprecated, has no effect and will be removed in the future".

      Você pode ignorar esse aviso.

   2. Receba o nome do pod "grpc-bookstore" criado no cluster quando você implantou a imagem do Docker na etapa anterior:

      kubectl get pods

      Você verá a saída no formulário:

      NAME   READY    STATUS    RESTARTS   AGE
      grpc   1/1      Running   0          23h

      Em que grp é o nome do pod "grpc-bookstore". Certifique-se de que o Status do pod esteja Em execução antes de continuar.

   3. Use o seguinte comando para fazer uma solicitação de cliente ao serviço "grpc-bookstore":

      kubectl exec grpc -ti -- python3 bookstore_client.py \
        --host grpc-bookstore.default.svc.cluster.local --port=80

      Esse comando executa o script bookstore_client.py internamente no cluster para fazer uma solicitação gRPC ao serviço "gRPC-BOOK" no nome do host grpc-bookstore.default.svc.cluster.local.

      Se tudo estiver funcionando corretamente, você verá uma resposta no formulário:

      ListShelves: shelves {
        id: 1
        theme: "Fiction"
      }
      shelves {
        id: 2
        theme: "Fantasy"
      }

Como configurar o Endpoints

Você precisa ter uma especificação da API gRPC que descreva a superfície do seu serviço de back-end e todos os requisitos de autenticação.

Sobre a configuração do campo de nome da especificação da API gRPC

No campo name da especificação da API gRPC, especifique o nome do serviço do Endpoints usado para acessar o serviço do Cloud Run for Anthos. O nome do serviço do Endpoints está na forma de um nome de domínio:

API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog

Como o nome do serviço do Endpoints corresponde a um nome de domínio, o nome precisa seguir estas regras:

• Precisa conter apenas letras minúsculas, números, pontos ou traços.
• Não pode começar com um traço.
• Não pode conter um sublinhado.

Exemplo:

grpc-boostore-api.endpoints.ESP_PROJECT_ID.cloud.goog

Como criar a especificação da API gRPC

A amostra bookstore-grpc contém os arquivos necessários para fazer cópias locais e configurações.

1. Crie um novo diretório para a especificação da API gRPC, como my-anthos-grpc. Em seguida, acesse o diretório.

2. Clone o repositório git em que o código do cliente gRPC está hospedado no novo diretório:

   git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

3. Altere o diretório de trabalho:

   cd python-docs-samples/endpoints/bookstore-grpc/

   Esse diretório contém o arquivo bookstore.proto. Esse arquivo define a API do serviço Bookstore.

4. Crie um arquivo descritor protobuf autocontido a partir do seu arquivo de serviço .proto:

   1. Crie o diretório generated_pb2 no seu diretório de trabalho.

   2. Crie o arquivo de descritor, api_descriptor.pb, usando o compilador de buffers de protocolo protoc. Execute o seguinte comando no diretório que contém bookstore.proto:

      python3 -m grpc_tools.protoc \
      --include_imports \
      --include_source_info \
      --proto_path=. \
      --descriptor_set_out=api_descriptor.pb \
      --python_out=generated_pb2 \
      --grpc_python_out=generated_pb2 \
      bookstore.proto

   No comando anterior, --proto_path está definido como o diretório de trabalho atual. No ambiente da versão do gRPC, caso você use um diretório diferente para arquivos de entrada .proto, mude --proto_path para que o compilador pesquise o diretório em que salvou bookstore.proto.

5. Modifique o arquivo api_config_anthos.yaml no seu diretório de trabalho atual (o mesmo que contém bookstore.proto) para adicionar o seguinte conteúdo:

   type: google.api.Service
   config_version: 3
   #
   # Name of the service configuration.
   #
   name: API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
   #
   # API title to appear in the user interface (Google Cloud console).
   #
   title: Bookstore gRPC API In Cloud Run Anthors
   apis:
   - name: endpoints.examples.bookstore.Bookstore
   #
   # Create a DNS record to map your service name to IP address
   #
   endpoints:
     - name: API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
       target: IP_ADDRESS
   #
   # Specify the backend address to route to
   #
   backend:
     rules:
       - selector: "*"
         address: grpc://GRPC_SERVICE.default.svc.cluster.local
         disable_auth: true
   #
   # API usage restrictions.
   #
   usage:
     rules:
     # ListShelves methods can be called without an API Key.
     - selector: endpoints.examples.bookstore.Bookstore.ListShelves
       allow_unregistered_calls: true

   O recuo é importante para o formato yaml.

6. No campo name, especifique o nome de domínio da API Endpoints usada para acessar o serviço do Cloud Run for Anthos, no formato:

   API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog

   Exemplo:

   grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog

7. A seção endpoints registra uma entrada DNS para o serviço do Endpoints no domínio cloud.goog, no formato:

   endpoints:
     - name: API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
       target: IP_ADDRESS

   Observação: se você tiver seu próprio mapeamento de domínio definido para o cluster, omita essa etapa. Consulte Como configurar o DNS no domínio cloud.goog para mais informações.

   IP_ADDRESS é o IP do serviço istio-ingress do cluster. Para determinar esse endereço IP:

   1. Acesse a página do Google Kubernetes Engine no console do Cloud:

      Acessar o Google Kubernetes Engine

   2. Clique em Serviços e entrada no painel de navegação esquerdo para exibir uma lista de serviços.

   3. Se a versão do cluster for 1.15.3-gke.19 ou superior, 1.14.3-gke.12 ou superior, ou 1.13.10-gke.8 ou superior, role para baixo até o serviço istio-ingress. Para todas as outras versões do cluster, role para baixo até o serviço istio-ingressgateway.

   4. Copie o endereço IP externo mostrado ao lado do Balanceador de carga, sem a configuração de porta, se houver. Por exemplo, se o IP for XX.XXX.XX.XXX:15020, omitir o :15020. Ignore os outros endereços IP listados.

8. O campo address na seção backend especifica o nome DNS interno do serviço "grpc-bookstore" do Cloud Run com o esquema proto grpc:// e desativa a autenticação para este serviço:

   address: grpc://GRPC_SERVICE.default.svc.cluster.local
   disable_auth: true

   Exemplo:

   address: grpc://grpc-bookstore.default.svc.cluster.local
   disable_auth: true

   Isso é necessário porque a chamada do ESPv2 para o serviço Cloud Run for Anthos é feita como uma chamada interna do cluster e, portanto, a autenticação não é necessária.

9. Anote o valor da propriedade title no arquivo api_config_authos.yaml:

   title: Bookstore gRPC API In Cloud Run Anthos

   O valor da propriedade title se tornará o nome do serviço do Endpoints depois que você implantar a configuração.

10. Salve o documento da API gRPC.

Para mais informações sobre os campos no documento da OpenAPI exigido pelo Endpoints, consulte Como configurar o Endpoints.

Como implantar a configuração do Endpoints

Para implantar a configuração do Endpoints, use o comando gcloud endpoints services deploy. Ele utiliza a Service Management para criar um serviço gerenciado.

Para implantar a configuração do Endpoints:

1. Verifique se você está no diretório que contém o documento gRPC.

2. Faça upload da configuração e crie um serviço gerenciado:

   gcloud endpoints services deploy api_descriptor.pb api_config_anthos.yaml \
     --project ESP_PROJECT_ID

   Isso cria um novo serviço do Endpoints com o nome especificado no campo name do arquivo api_config_anthos.yaml. O serviço do Endpoints é configurado de acordo com o documento da OpenAPI.

   Durante a criação e a configuração do serviço do Endpoints, o Service Management envia informações ao terminal. Quando a implantação for concluída, uma mensagem parecida com esta será exibida:

   Service Configuration [CONFIG_ID] uploaded for service [API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog]

   CONFIG_ID é o ID exclusivo de configuração de serviço do Endpoints criado pela implantação. Exemplo:

   Service Configuration [2019-02-01r0] uploaded for service [grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog] 

   O código de configuração do serviço consiste em um carimbo de data e um número de revisão. Se você implantar api_config_anthos.yaml novamente no mesmo dia, o número de revisão aumentará no ID de configuração do serviço. É possível ver a configuração do serviço e o histórico de implantação na página Endpoints > Serviços do console do Google Cloud.

   Se você receber uma mensagem de erro, consulte Como solucionar problemas de implantação na configuração do Endpoints.

Como verificar os serviços obrigatórios

No mínimo, o Endpoints e o ESP exigem a ativação dos seguintes serviços do Google:

Nome	Cargo
servicemanagement.googleapis.com	API Service Management
servicecontrol.googleapis.com	API Service Control
endpoints.googleapis.com	Google Cloud Endpoints

Na maioria dos casos, o comando gcloud endpoints services deploy ativa os serviços necessários. No entanto, o comando gcloud é concluído com êxito, mas não ativa os serviços necessários nas seguintes circunstâncias:

• Você usou um aplicativo de terceiros, como o Terraform, e não incluiu esses serviços.

• Você implantou a configuração do Endpoints em um projeto do Google Cloud existente, em que esses serviços foram desativados explicitamente.

Use o seguinte comando para confirmar se os serviços necessários estão ativados:

gcloud services list

Se você não encontrar os serviços necessários listados, ative-os:

gcloud services enable servicemanagement.googleapis.com
gcloud services enable servicecontrol.googleapis.com
gcloud services enable endpoints.googleapis.com

Ative também seu serviço do Endpoints:

gcloud services enable ENDPOINTS_SERVICE_NAME

Para determinar o ENDPOINTS_SERVICE_NAME, é possível:

• Depois de implantar a configuração do Endpoints, acesse a página Endpoints no Console do Cloud. A lista de ENDPOINTS_SERVICE_NAME possíveis é mostrada na coluna Nome do serviço.

• Para a OpenAPI, o ENDPOINTS_SERVICE_NAME é o que você especificou no campo host da especificação do OpenAPI. Para gRPC, o ENDPOINTS_SERVICE_NAME é o que você especificou no campo name da configuração do gRPC Endpoints.

Para mais informações sobre os comandos gcloud, consulte serviços gcloud.

Como criar uma nova imagem ESPv2 Beta do Cloud Run for Anthos

Crie a configuração do serviço do Endpoints em uma nova imagem docker do ESPv2. Depois de criar essa imagem, implante-a no cluster.

Observação :

Esta etapa é obrigatória.

A configuração do serviço precisa ser integrada a uma nova imagem docker porque o Cloud Run é um serviço de escalonamento para zero. Isso significa que, quando não houver tráfego, todas as instâncias serão excluídas. Quando o tráfego aumenta, novas instâncias são criadas sob demanda. Esse tipo de criação de instância de serviço também é chamado de inicialização a frio. Consulte a documentação sobre simultaneidade do Cloud Run para saber mais.

Se a imagem do Docker não tivesse a configuração de serviço integrada, o Cloud Run precisaria fazer duas chamadas de API ao Google ServiceManagement na inicialização a frio. Essas chamadas são descontadas da sua cota da API Google ServiceManagement.

Ao criar a configuração do serviço na imagem docker do ESPv2, você remove as duas chamadas de API e evita impactar a contagem da cota do serviço Google ServiceManagement Essa etapa também acelera a criação da nova instância de serviço e reduz a latência das solicitações aguardando a nova instância.

Execute esta etapa inteira novamente e reimplante o novo contêiner:

• Todas as vezes que você modificar e reimplantar a configuração do serviço do Endpoints. Caso contrário, as alterações na configuração do serviço não serão propagadas para o ESPv2.
• Quando uma nova versão do ESPv2 for lançada. Caso contrário, a versão mais antiga do ESPv2 permanecerá implantada.

Para criar a configuração do serviço em uma nova imagem docker do ESPv2:

1. Faça o download deste script na máquina local em que a CLI gcloud está instalada e execute-o como:

   chmod +x gcloud_build_image
   ./gcloud_build_image -s API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog \
   -c CONFIG_ID -p ESP_PROJECT_ID

   Observação: este script requer bash. Se você não estiver usando o macOS/Linux poderá executá-lo no Cloud Shell, no Compute Engine ou no subsistema do Windows para Linux.

   O script usa o comando da gcloud para fazer o download da configuração do serviço, criar essa configuração em uma nova imagem do ESPv2 e fazer upload da nova imagem no registro de contêiner do projeto. O script usa automaticamente a versão mais recente do ESPv2, indicada pelo ESP_VERSION no nome da imagem de saída. O upload da imagem de saída é feito para:

   gcr.io/ESP_PROJECT_ID/endpoints-runtime-serverless:ESP_VERSION-API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog-CONFIG_ID

Como implantar a imagem ESPv2 do Cloud Run for Anthos

Implante a imagem de serviço ESPv2 do Cloud Run for Anthos no cluster:

1. Implante o serviço ESPv2 Cloud Run for Anthos com a nova imagem:

   gcloud run deploy ESP_V2_SERVICE_NAME \
     --image="gcr.io/ESP_PROJECT_ID/endpoints-runtime-serverless:API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog-CONFIG_ID" \
     --platform gke \
     --use-http2 \
     --project=ESP_PROJECT_ID

   Em ESP_PROJECT_ID, especifique o nome que você quer usar para o serviço ESPv2. Neste exemplo, defina ESP_V2_SERVICE_NAME como espv2.

2. Se quiser configurar o Endpoints para usar outras opções de inicialização do ESPv2, como ativar o CORS, transmita os argumentos na variável de ambiente ESPv2_ARGS:

   gcloud run deploy ESP_V2_SERVICE_NAME \
     --image="gcr.io/ESP_PROJECT_ID/endpoints-runtime-serverless:API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog-CONFIG_ID" \
     --set-env-vars=ESPv2_ARGS=--cors_preset=basic \
     --platform gke --use-http2 \
     --project ESP_PROJECT_ID

   Para mais informações e exemplos sobre como configurar a variável de ambiente ESPv2_ARGS, incluindo a lista de opções disponíveis e informações sobre como especificar várias opções, consulte Sinalizações do Extensible Service Proxy V2.

Como criar um mapeamento de domínio para o serviço ESPv2 do Cloud Run for Anthos

Para omitir o cabeçalho host ao fazer uma solicitação, adicione um mapeamento de domínio para o serviço ESPv2:

1. Acesse o Cloud Run

2. Selecione Gerenciar domínios personalizados.

3. Selecione Adicionar mapeamento.

4. No menu suspenso, selecione Adicionar mapeamento de domínio do serviço.

5. No campo Selecionar um serviço para mapear do pop-up Adicionar mapeamento, selecione seu serviço ESPv2.

6. No campo Entrar no nome de domínio, especifique o nome de domínio que você quer usar para acessar o serviço do Cloud Run for Anthos por meio do Endpoints. Por exemplo, especifique:

   API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog

   Em que API_NAME é o nome da API do Endpoints. Neste exemplo, você pode usar "hello-api":

   grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog

7. Clique em Continuar. Um resumo do mapeamento é exibido.

8. Selecione Concluído para salvar o mapeamento.

Como enviar solicitações à API

Para enviar solicitações à API de amostra, use um cliente gRPC de amostra escrito em Python.

1. Verifique se você está no diretório que contém os documentos do gRPC, como api_config_anthos.yaml.

2. Instale as dependências:

   pip3 install virtualenv
   virtualenv env
   source env/bin/activate
   pip3 install -r requirements.txt

3. Envie uma solicitação à API de amostra:

   python3 bookstore_client.py --host API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog --port 80

   Exemplo:

   python3 bookstore_client.py --host grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog --port 80

   Se tudo estiver funcionando corretamente, você verá uma resposta no formulário:

   ListShelves: shelves {
     id: 1
     theme: "Fiction"
   }
   shelves {
     id: 2
     theme: "Fantasy"
   }

   • Veja os gráficos de atividade da API na página Endpoints > Serviços.

     Ir para a página Serviços do Endpoints

     Pode levar alguns instantes até a solicitação aparecer nos gráficos.

   • Verifique os registros de solicitações da API na página "Explorador de registros".

     Acessar a página Explorador de registros

Se não receber uma resposta bem-sucedida, consulte Como solucionar problemas em erros de resposta.

Você acaba de implantar e testar uma API no Endpoints.

Como configurar a API Endpoints para usar HTTPS

O suporte automático a TLS está desativado por padrão para o Cloud Run for Anthos no Google Cloud. Portanto, neste exemplo, ao acessar a API Endpoints por meio do ESPv2, você faz a chamada usando HTTP.

Você pode configurar o ESPv2 para oferecer suporte a solicitações usando HTTPS. Observe que você configura a compatibilidade com HTTPS no ESPv2, o serviço externo, não no "hello", o serviço de back-end interno.

Para oferecer suporte a HTTPS com o ESPv2, é preciso:

1. Tenha um domínio. Se você não tiver um domínio, poderá conseguir um do Google ou de outro fornecedor de domínio.

2. Crie um mapeamento de domínio para o serviço do ESPv2 e atualize o registro DNS seguindo as instruções na página de mapeamento de domínios.

   Se você recebeu seu domínio do Google Domains, use-o como seu servidor DNS. Caso contrário, use Cloud DNS ou um servidor DNS de sua escolha. Usar um domínio do Google Domains é a opção mais fácil.

3. Na especificação OpenAPI do Endpoints:

   1. Defina o campo name para se referir ao seu domínio em vez de *.cloud.goog.

   2. Remova a tag endpoints e as duas propriedades filho.

Para instruções completas e um tutorial, consulte Como ativar certificados HTTPS e TLS automáticos.

Observação: se quiser nos contar do que você gostou neste tutorial, envie um feedback na parte inferior desta página. Isso é muito importante para a melhoria dos tutoriais.
Se ocorrer um erro, entre no grupo do Google google-cloud-endpoints e informe o que aconteceu. Nesse grupo, são enviadas respostas de outros usuários do Endpoints e de engenheiros do Google, que o monitoram.

Como rastrear a atividade da API

1. Veja os gráficos de atividade da sua API na página Endpoints > Serviço no Console do Google Cloud.

   Ver gráficos de atividades do Endpoints

   Pode levar alguns instantes até a solicitação aparecer nos gráficos.

2. Verifique os registros de solicitações da API na página "Visualizador de registros".

   Ver registros de solicitações do Endpoints

Como criar um portal do desenvolvedor para a API

É possível usar o portal do Cloud Endpoints para criar um portal do desenvolvedor, um site para interagir com a API de exemplo. Para saber mais, consulte a Visão geral do Portal do Cloud Endpoints.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados nesta página, siga estas etapas.

Consulte Como excluir uma API e as instâncias relacionadas para mais informações sobre como interromper os serviços usados neste tutorial.

A seguir

• Saiba mais sobre o Cloud Run
• Saiba mais sobre como implantar a configuração do Endpoints
• Compartilhe a API com outro desenvolvedor
• Aprenda sobre autenticação
• Conheça as opções de suporte da comunidade