Primeiros passos com o gRPC do Cloud Endpoints para o grupo gerenciado de instâncias com o ESPv2

OpenAPI | gRPC

Neste tutorial, mostramos como implantar um exemplo simples do serviço gRPC com o Extensible Service Proxy V2 (ESPv2) em um grupo gerenciado de instâncias.

A versão Python da amostra bookstore-grpc é utilizada neste tutorial. Consulte a seção A seguir para acessar as amostras do gRPC em outras linguagens.

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

Objetivos

Ao seguir o tutorial, use a lista detalhada de tarefas abaixo. Em todas elas, é necessário que as solicitações para a API sejam enviadas com sucesso.

Configure um projeto do Google Cloud e faça o download do software necessário. Consulte Antes de começar.
Copie e configure arquivos da amostra bookstore-grpc (em inglês). Consulte Como configurar o Endpoints.
Implante a configuração do Endpoints para criar um serviço. Consulte Como implantar a configuração do Endpoints.
Implante a API e o ESPv2 no back-end do grupo gerenciado de instâncias. Consulte Como implantar o back-end da API.
Envie uma solicitação para a API. Consulte Como enviar uma solicitação à API.
Evite cobranças na sua conta do Google Cloud. Consulte Fazer limpeza.

Custos

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

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

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.

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

Acessar o seletor de projetos

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

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

Acessar o seletor de projetos

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

Anote o código do projeto, ele será necessário mais tarde.
Instale e inicialize a Google Cloud CLI.
Atualize a CLI gcloud e instale os componentes do Endpoints:
```
gcloud components update
```
Verifique se a Google Cloud CLI (gcloud) está autorizada a acessar seus dados e serviços no Google Cloud:
```
gcloud auth login
```
Na nova guia aberta no navegador, selecione uma conta.
Defina o projeto padrão como o ID do projeto.
```
gcloud config set project YOUR_PROJECT_ID
```
Substitua YOUR_PROJECT_ID pela ID do seu projeto. Se você tiver outros projetos do Google Cloud e quiser usar gcloud para gerenciá-los, consulte Como CLI gcloud gcloud.
Siga as etapas no Guia de início rápido do gRPC em Python para instalar o gRPC e as ferramentas dele.

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

Como configurar o Endpoints

Clone o repositório bookstore-grpc de amostra (em inglês) do GitHub:

Para configurar o Endpoints:

Crie um arquivo descritor protobuf autocontido a partir do seu arquivo de serviço .proto:
1. Salve uma cópia de bookstore.proto do repositório de exemplo. Esse arquivo define a API do serviço Bookstore.
2. Crie o seguinte diretório: mkdir generated_pb2
3. Crie o arquivo de descritor, api_descriptor.pb, usando o compilador de buffers de protocolo protoc. Execute o seguinte comando no diretório onde você salvou bookstore.proto:
```
python -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.
Crie um arquivo YAML de configuração da API gRPC:
1. Salve uma cópia do arquivo api_config.yaml. Esse arquivo define a configuração da API gRPC do serviço Bookstore.
2. Substitua MY_PROJECT_ID no arquivo api_config.yaml pelo ID do projeto do Google Cloud. Exemplo:
```
#
# Name of the service configuration.
#
name: bookstore.endpoints.example-project-12345.cloud.goog
```
  Observe que o valor do campo apis.name neste arquivo corresponde exatamente ao nome da API totalmente qualificado do arquivo .proto; caso contrário, a implantação não funcionará. O serviço Bookstore é definido em bookstore.proto dentro do pacote endpoints.examples.bookstore. O nome da API totalmente qualificado é endpoints.examples.bookstore.Bookstore, assim como aparece no arquivo api_config.yaml.
```
apis:
  - name: endpoints.examples.bookstore.Bookstore
```

Para saber mais, 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 o Service Management para criar um serviço gerenciado.

Verifique se você está no diretório em que os arquivos api_descriptor.pb e api_config.yaml estão localizados.
Confirme se o projeto padrão que a ferramenta de linha de comando gcloud está usando no momento é o projeto do Google Cloud em que você pretende implantar a configuração do Endpoints. Valide o código do projeto retornado do comando a seguir para garantir que o serviço não seja criado no projeto incorreto.
```
gcloud config list project
```
Se você precisar alterar o projeto padrão, execute o comando:
```
gcloud config set project YOUR_PROJECT_ID
```
Implante os arquivos proto descriptor e de arquivo de configuração usando a Google Cloud CLI:
```
gcloud endpoints services deploy api_descriptor.pb api_config.yaml
```
Durante a criação e a configuração do serviço, 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 [bookstore.endpoints.example-project.cloud.goog]
```
CONFIG_ID é o ID exclusivo de configuração de serviço do Endpoints criado pela implantação. Exemplo:
```
Service Configuration [2017-02-13r0] uploaded for service [bookstore.endpoints.example-project.cloud.goog]
```
No exemplo anterior, 2017-02-13r0 é o ID de configuração do serviço e bookstore.endpoints.example-project.cloud.goog é o nome do serviço. 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 novamente a configuração do Endpoints no mesmo dia, o número de revisão será alterado no código da configuração do serviço.

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.

Se você receber uma mensagem de erro, consulte Como solucionar problemas de implantação na configuração do Endpoints. Para mais informações, consulte Como implantar a configuração do Endpoints.

Como implantar o back-end da API

Até agora, você implantou a configuração da API no Service Management, mas não o código que disponibiliza o back-end da API. Esta seção contém orientações para configurar o Docker no grupo gerenciado de instâncias e executar o código de back-end da API e o ESPv2 em um contêiner do Docker.

Criar um modelo de instância

Crie um modelo que você usará para criar um grupo de instâncias da VM. Cada instância criada a partir do modelo inicia um ESPv2 e um servidor de aplicativos de back-end.

No Console do Google Cloud, acesse a página Modelos de instância.

Acesse "Modelos de instância"
Clique em Criar modelo de instância.
Em Nome, insira load-balancing-espv2-template.
Em Configuração da máquina, defina o Tipo de máquina como e2-micro.
Em Disco de inicialização, defina a Imagem como Container Optimized OS stable version.
Em Firewall, selecione Permitir tráfego HTTP.
Clique em Gerenciamento, segurança, discos, rede, locatário único para ver configurações avançadas.

Clique na guia Gerenciamento. Em Automação, insira o script de inicialização a seguir. Lembre-se de atualizar ENDPOINTS_SERVICE_NAME.

sudo docker network create --driver bridge esp_net
sudo docker run \
  --detach \
  --name=bookstore \
  --net=esp_net \
  gcr.io/endpointsv2/python-grpc-bookstore-server:1
sudo docker run \
  --detach \
  --name=esp \
  --publish=80:9000 \
  --net=esp_net \
  gcr.io/endpoints-release/endpoints-runtime:2 \
  --service=ENDPOINTS_SERVICE_NAME \
  --rollout_strategy=managed \
  --listener_port=9000 \
  --healthz=/healthz \
  --backend=grpc://bookstore:8000

O script recebe, instala e inicia o servidor de aplicativos de eco e o servidor proxy ESPv2 na inicialização da instância.

Clique em Criar.

Aguarde o modelo ser criado para continuar.

Criar um grupo de instâncias gerenciadas regional

Para executar o aplicativo, use o modelo de instância para criar um grupo gerenciado de instâncias regional:

No Console do Google Cloud, acesse a página Grupos de instâncias.

Acesse grupo de instâncias
Clique em Criar grupo de instâncias.
Em Nome, insira load-balancing-espv2-group.
Em Local, selecione Várias zonas.

Dica profissional: para garantir que seu aplicativo esteja disponível durante eventos extremos, como interrupções de zona, o Compute Engine recomenda que você distribua o aplicativo em várias zonas.
Em Região, selecione us-central1.
Clique no menu suspenso Configurar zonas para exibir Zonas. Selecione as seguintes zonas:
- us-central1-b
- us-central1-c
- us-central1-f
Em Modelo de instância, selecione load-balancing-espv2-template.
Em Escalonamento automático, selecione Não fazer escalonamento automático.
Defina o Número de instâncias como 3.

Dica profissional: ao criar um grupo regional de instâncias gerenciadas com o Compute Engine, é recomendável provisionar instâncias suficientes. Assim, caso todas elas em qualquer zona estejam indisponíveis, as instâncias restantes ainda serão o mínimo necessário. No entanto, provisionar mais instâncias do que você precisa pode resultar em custos adicionais. Para mais informações, consulte Como selecionar o tamanho do grupo de instâncias para garantir a disponibilidade.
Em Redistribuição da instância, selecione Ativado.
Em Recuperação automática e Verificação de integridade, selecione Nenhuma verificação de integridade.
Clique em Criar. Isso redireciona você de volta à página Grupos de instâncias.

Observação :pode ser necessário aguardar alguns minutos até que todas as instâncias do grupo estejam em execução e prontas para exibir o aplicativo da Web.

Criar um balanceador de carga

Nesta seção, explicamos as etapas necessárias para criar um balanceador de carga regional que direciona o tráfego TCP para seu grupo de instâncias.

No console do Google Cloud, acesse a página Criar balanceador de carga.

Acessar "Criar um balanceador de carga"
Em Balanceamento de carga TCP, clique em Iniciar configuração.
Em Somente voltado para a Internet ou interno, selecione Da Internet para minhas VMs.
Em Várias regiões ou região única, selecione Apenas uma região.
Em Tipo de back-end, selecione Serviço de back-end.
Clique em Continuar.
Em Nome, insira espv2-load-balancer.
Em Configuração de back-end, selecione a região us-central1.
Selecione o grupo de instâncias load-balancing-espv2-group.
Em Verificação de integridade, crie uma verificação de integridade.
- Em Nome, insira espv2-load-balancer-check.
- Confirme se Protocolo é TCP e se Porta é 80.
Em Configuração de front-end, digite o número da porta 80.
Em Analisar e finalizar, verifique:
- se o Grupo de instâncias é load-balancing-espv2-group;
- se a Região é us-central1;
- se o Protocolo é TCP;
- se o IP:Porta é EPHEMERAL:80.
Depois que o balanceador de carga for criado, localize o endereço IP na página Balanceador de carga.

Acessar "Balanceador de carga"

Como enviar uma solicitação à API

Se você estiver enviando a solicitação da mesma instância em que os contêineres do Docker estão em execução, substitua SERVER_IP por localhost. Caso contrário, substitua SERVER_IP pelo IP externo da instância.

Para encontrar o endereço IP externo, execute:

gcloud compute instances list

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

Clone o repositório do Git onde o código do cliente gRPC está hospedado:

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

Altere o diretório de trabalho:

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

Instale as dependências:

pip install virtualenv
virtualenv env
source env/bin/activate
python -m pip install -r requirements.txt

Envie uma solicitação à API de amostra:
```
python bookstore_client.py --host SERVER_IP --port 80
```
- 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.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Verifique se a CLI gcloud (gcloud) está autorizada a acessar seus dados e serviços no Google Cloud:
```
gcloud auth login
```
Insira o comando abaixo para exibir os IDs dos seus projetos do Google Cloud:
```
gcloud projects list
```
Usando o ID do projeto aplicável da etapa anterior, defina o projeto padrão do Google Cloud como aquele em que seu aplicativo se encontra:
```
gcloud config set project [YOUR_PROJECT_ID]
```
Obtenha o nome de todos os serviços gerenciados no seu projeto do Google Cloud:
```
gcloud endpoints services list
```
Exclua o serviço do Service Management: Substitua SERVICE_NAME pelo nome do serviço que você quer remover.
```
gcloud endpoints services delete SERVICE_NAME
```
A execução de gcloud endpoints services delete não exclui imediatamente o serviço gerenciado. O Service Management desativa o serviço gerenciado por 30 dias, o que permite que você tenha tempo para restaurá-lo, se necessário. Após 30 dias, o Service Management exclui permanentemente o serviço gerenciado.
Acesse a página Balanceador de carga.

Acessar "Balanceador de carga"

Exclua o balanceador de carga espv2-load-balancer com a verificação de integridade espv2-load-balancer-check.
Acesse a página Grupos de instâncias.

Acesse Grupos de instâncias

Excluir load-balancing-espv2-group
Acesse a página Modelo de instância.

Acesse "Modelos de instância"

Excluir load-balancing-espv2-template.

A seguir

Descubra como configurar sua API gRPC do Cloud Endpoints.
Consulte a amostra do Bookstore no GitHub para saber mais. Tanto o cliente quanto o servidor estão disponíveis em Python e em Java (links em inglês).
A amostra getting-started-grpc está disponível no GitHub nas seguintes linguagens:
- Java
- Python
- Ruby
- Go
- Node.js