O Anthos Service Mesh e o Traffic Director agora são Cloud Service Mesh. Para mais informações, consulte a Visão geral do Cloud Service Mesh.

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

Leia Preparar-se para configurar com cargas de trabalho Envoy e sem proxy e cumpra os pré-requisitos descritos nesse documento.

Configurar o recurso `Mesh`

Quando um aplicativo gRPC sem proxy se conecta a um xds://hostname, o gRPC a biblioteca de cliente estabelece uma conexão com o Cloud Service Mesh. 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 que o aplicativo gRPC sem proxy usa para solicitar a configuração associada dessa malha.

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 for criado, o Cloud Service Mesh estará pronto para exibir mas, como ainda não há serviços definidos, ela está vazio. 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`

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 Cloud Service Mesh 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 Cloud Service Mesh. 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.16.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.16.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 de cliente e execute o seguindo.

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

A saída verifica se o cliente gRPC sem proxy se conectou ao Cloud Service Mesh 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.

A seguir

Para saber como listar recursos de rota associados a um recurso Mesh ou Gateway, consulte Listar recursos Route. Esse recurso está na visualização.