Esta página foi traduzida pela API Cloud Translation.

Configurar serviços gRPC sem proxy

Neste guia, demonstramos como configurar uma malha de serviço gRPC sem proxy com os recursos Mesh e GRPCRoute.

Serviços gRPC sem proxy com recursos GRPCRoute e Mesh — Serviços gRPC sem proxy com os recursos `GRPCRoute` e `Mesh` (clique para ampliar)

Antes de começar

Verifique se a implantação atende aos pré-requisitos descritos nos guias a seguir:

Configurar o recurso `Mesh`

Quando um aplicativo gRPC sem proxy se conecta a um xds://hostname, a biblioteca de cliente do gRPC estabelece uma conexão com o Traffic Director. A biblioteca de cliente usa a conexão para conseguir a configuração de roteamento necessária para encaminhar solicitações para o nome do host.

Anote o nome do recurso Mesh, que é a chave que o aplicativo gRPC sem proxy usa para solicitar a configuração associada ao Mesh.

Crie a especificação Mesh e salve-a em um arquivo chamado mesh.yaml.
```
name: grpc-mesh
```

Crie o recurso Mesh usando a especificação mesh.yaml:

gcloud network-services meshes import grpc-mesh \
  --source=mesh.yaml \
  --location=global

Depois que o recurso Mesh é criado, o Traffic Director está pronto para disponibilizar a configuração, mas como ainda não há serviços definidos, a configuração está vazia. Na próxima seção, você define os serviços e os anexa ao recurso Mesh.

Configurar o servidor gRPC

Para fins de demonstração, você cria um serviço de back-end com VMs com escalonamento automático em um grupo de instâncias gerenciadas. As VMs veiculam a frase hello world usando o protocolo gRPC na porta 50051.

Crie o modelo de instância de VM do Compute Engine com um serviço gRPC helloworld que é exposto na porta 50051:

gcloud compute instance-templates create grpc-td-vm-template \
   --scopes=https://www.googleapis.com/auth/cloud-platform \
   --tags=allow-health-checks \
   --image-family=debian-10 \
   --image-project=debian-cloud \
   --metadata-from-file=startup-script=<(echo '#! /bin/bash
 set -e
 cd /root
 sudo apt-get update -y
 sudo apt-get install -y openjdk-11-jdk-headless
 curl -L https://github.com/grpc/grpc-java/archive/v1.38.0.tar.gz | tar -xz
 cd grpc-java-1.38.0/examples/example-hostname
 ../gradlew --no-daemon installDist
 sudo systemd-run ./build/install/hostname-server/bin/hostname-server')

Crie o grupo gerenciado de instâncias com base no modelo.

gcloud compute instance-groups managed create grpc-td-mig-us-east1 \
  --zone=ZONE \
  --size=2 \
  --template=grpc-td-vm-template

Crie a porta nomeada do serviço gRPC. A porta nomeada é aquela em que o serviço gRPC detecta solicitações. No exemplo a seguir, a porta nomeada é 50051:
```
gcloud compute instance-groups set-named-ports grpc-td-mig-us-east1 \
 --named-ports=grpc-helloworld-port:50051 \
 --zone=ZONE
```
Crie uma verificação de integridade do gRPC. Os serviços precisam implementar o protocolo de verificação de integridade do gRPC para que a verificação de integridade do gRPC funcione corretamente. Para mais informações, consulte Verificações de integridade.
```
gcloud compute health-checks create grpc grpc-helloworld-health-check \
  --use-serving-port
```

Crie uma regra de firewall para permitir conexões de verificação de integridade com instâncias na rede:

gcloud compute firewall-rules create grpc-vm-allow-health-checks \
  --network=default \
  --action=ALLOW \
  --direction=INGRESS \
  --source-ranges=35.191.0.0/16,130.211.0.0/22 \
  --target-tags allow-health-checks \
  --rules=tcp:50051

Crie um serviço de back-end global com um esquema de balanceamento de carga de INTERNAL_SELF_MANAGED e adicione a verificação de integridade ao serviço de back-end. A porta especificada aqui é usada para se conectar às VMs no grupo de instâncias gerenciadas.
```
gcloud compute backend-services create grpc-helloworld-service \
  --global \
  --load-balancing-scheme=INTERNAL_SELF_MANAGED \
  --protocol=GRPC \
  --port-name=grpc-helloworld-port \
  --health-checks grpc-helloworld-health-check
```

Adicione o grupo de instâncias gerenciadas ao serviço de back-end.

gcloud compute backend-services add-backend \
  grpc-helloworld-service \
  --instance-group=grpc-td-mig-us-east1 \
  --instance-group-zone=ZONE \
  --global

O recurso e os serviços do Mesh estão configurados. Na próxima seção, você configura o roteamento.

Configure o roteamento com `GRPCRoute`

O recurso Mesh e o servidor gRPC estão configurados. Use as instruções a seguir para configurar o roteamento.

Crie a especificação GRPCRoute e salve-a em um arquivo chamado grpc_route.yaml.

É possível usar PROJECT_ID ou PROJECT_NUMBER.

name: helloworld-grpc-route
hostnames:
- helloworld-gce
meshes:
- projects/PROJECT_NUMBER/locations/global/meshes/grpc-mesh
rules:
- action:
    destinations:
    - serviceName: projects/PROJECT_NUMBER/locations/global/backendServices/grpc-helloworld-service

Crie o recurso GrpcRoute usando a especificação grpc_route.yaml:

gcloud network-services grpc-routes import helloworld-grpc-route \
  --source=grpc_route.yaml \
  --location=global

O Traffic Director agora está configurado para balancear a carga do tráfego dos serviços especificados no recurso GRPCRoute nos back-ends no grupo de instâncias gerenciadas.

Criar um cliente gRPC

É possível verificar a configuração instanciando um aplicativo gRPC sem proxy e conectando-o ao Traffic Director. No arquivo de inicialização, o aplicativo precisa especificar a rede VPC indicada na malha.

Após a configuração, o aplicativo pode enviar uma solicitação a instâncias ou endpoints associados a helloworld-gce usando o URI de serviço xds:///helloworld-gce.

Nos exemplos a seguir, use a ferramenta datalaburl para testar o serviço gRPC.

Criar uma VM cliente.

gcloud compute instances create grpc-client \
  --zone=ZONE\
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --metadata-from-file=startup-script=<(echo '#! /bin/bash
set -e
export GRPC_XDS_BOOTSTRAP=/run/td-grpc-bootstrap.json
echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh
curl -L https://storage.googleapis.com/traffic-director/td-grpc-bootstrap-0.14.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.14.0/td-grpc-bootstrap --config-mesh-experimental grpc-mesh | tee $GRPC_XDS_BOOTSTRAP')

Configurar o arquivo de inicialização

O aplicativo cliente precisa ter um arquivo de configuração de inicialização. O script de inicialização na seção anterior define a variável de ambiente GRPC_XDS_BOOTSTRAP e usa um script auxiliar para gerar o arquivo de inicialização. Os valores de TRAFFICDIRECTOR_GCP_PROJECT_NUMBER, e da zona no arquivo de inicialização gerado são recebidos do servidor de metadados que conhece esses detalhes sobre suas instâncias de VM do Compute Engine. É possível fornecer manualmente esses valores para o script auxiliar usando a opção --gcp-project-number. É necessário fornecer um nome de malha que corresponda ao recurso Mesh usando a opção --config-mesh-experimental.

Para verificar a configuração, faça login na VM cliente e execute os exemplos a seguir.

SSH para a VM cliente.
```
gcloud compute ssh grpc-client
```

Faça o download e instale a ferramenta grpcurl.

curl -L https://github.com/fullstorydev/grpcurl/releases/download/v1.8.1/grpcurl_1.8.1_linux_x86_64.tar.gz | tar -xz

Execute a ferramenta grpcurl com xds:///helloworld-gce como o URI do serviço e helloworld.Greeter/SayHello como o nome e o método do serviço a serem invocados. Os parâmetros para o método SayHello são transmitidos usando a opção -d.
```
./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld-gce helloworld.Greeter/SayHello
```

Você verá uma saída semelhante à seguinte, em que INSTANCE_HOSTNAME é o nome da instância de VM:

   Greeting: Hello world, from INSTANCE_HOSTNAME

Isso verifica se o cliente gRPC sem proxy se conectou ao Traffic Director e aprendeu sobre os back-ends do serviço helloworld-gce usando o resolvedor de nomes xds. O cliente enviou uma solicitação para um dos back-ends do serviço sem precisar saber sobre o endereço IP ou executar a resolução de DNS.