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.

O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

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 para configurar com o Envoy e cargas de trabalho sem proxy e conclua os pré-requisitos descritos nesse documento.

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 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 o aplicativo gRPC sem proxy usa para solicitar a configuração associada a essa 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 é criado, o Cloud Service Mesh 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 gerenciado de instâncias. As VMs veiculam a frase hello world usando o protocolo gRPC na porta 50051.

Crie um arquivo de configuração cloud-init.yaml que declare um serviço systemd para executar o contêiner helloworld na porta 50051:

#cloud-config
write_files:
- path: /etc/systemd/system/grpc-server.service
  permissions: '0644'
  owner: root
  content: |
    [Unit]
    Description=gRPC Server Container
    After=network-online.target docker.service
    Wants=network-online.target
    Requires=docker.service

    [Service]
    TimeoutStartSec=0
    Restart=always
    ExecStartPre=-/usr/bin/docker stop %n
    ExecStartPre=-/usr/bin/docker rm %n
    ExecStart=/usr/bin/docker run --rm --name %n --net=host grpc/java-example-hostname:1.83.1
    ExecStop=/usr/bin/docker stop %n

runcmd:
- iptables -A INPUT -p tcp --dport 50051 -j ACCEPT
- systemctl daemon-reload
- systemctl start --no-block grpc-server.service

Crie o modelo de instância de VM do Compute Engine usando o Container-Optimized OS (cos-stable):

gcloud compute instance-templates create grpc-td-vm-template \
  --image-project=cos-cloud \
  --image-family=cos-stable \
  --metadata-from-file=user-data=cloud-init.yaml \
  --tags=allow-health-checks \
  --scopes=cloud-platform

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

gcloud compute instance-groups managed create grpc-td-mig \
  --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 \
 --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 gerenciado de instâncias.
```
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 \
  --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.

Configurar 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-12 \
  --image-project=debian-cloud \
  --metadata-from-file=startup-script=<(echo '#!/bin/bash
set -ex
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.19.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.19.0/td-grpc-bootstrap --config-mesh=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.

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 --zone=ZONE

Faça o download e instale a ferramenta grpcurl.

curl -L https://github.com/fullstorydev/grpcurl/releases/download/v1.9.2/grpcurl_1.9.2_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 de uma das instâncias de VM do servidor gRPC:

   {
     "message": "Hello world, from INSTANCE_HOSTNAME"
   }

Isso 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 informações sobre como listar recursos de rota associados a um recurso Mesh ou Gateway, consulte Listar recursos Route.