Está a ver a documentação da malha de serviço v1.24.

Versões disponíveis

Cloud Service Mesh
Arquivo 1.24
Arquivo 1.23
Arquivo 1.22
Arquivo 1.21
Arquivo 1.20
Arquivo 1.19
Arquivo 1.18

Esta página foi traduzida pela API Cloud Translation.

Configure serviços gRPC sem proxy

Este guia demonstra como configurar uma malha de serviços gRPC sem proxy com recursos Mesh e GRPCRoute.

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

Antes de começar

Certifique-se de que lê o artigo Prepare-se para a configuração com o Envoy e cargas de trabalho sem proxy e conclui os pré-requisitos descritos nesse documento.

Configure o recurso `Mesh`

Quando uma aplicação gRPC sem proxy se liga a um xds:///hostname, a biblioteca do cliente gRPC estabelece uma ligação ao Cloud Service Mesh. A biblioteca de cliente usa a ligação para obter a configuração de encaminhamento necessária para encaminhar pedidos para o nome do anfitrião.

Certifique-se de que anota o nome do recurso Mesh, que é a chave que a aplicação gRPC sem proxy usa para pedir a configuração associada a esta malha.

Crie a especificação Mesh e guarde-a num ficheiro denominado mesh.yaml.
```
name: grpc-mesh
```

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

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

Depois de o recurso Mesh ser criado, o Cloud Service Mesh está pronto para publicar a configuração, mas, como ainda não existem serviços definidos, a configuração está vazia. Na secção seguinte, define os serviços e anexa-os ao recurso Mesh.

Configure o servidor gRPC

Para fins de demonstração, cria um serviço de back-end com VMs com escala automática num grupo de instâncias geridas. As VMs publicam a frase hello world através do protocolo gRPC na porta 50051.

Crie o modelo de instância de VM do Compute Engine com um helloworld serviço gRPC 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-12 \
   --image-project=debian-cloud \
   --metadata-from-file=startup-script=<(echo '#!/bin/bash
 set -ex
 cd /root
 sudo apt-get update -y
 sudo apt-get install -y openjdk-17-jdk-headless
 curl -L https://github.com/grpc/grpc-java/archive/v1.70.0.tar.gz | tar -xz
 cd grpc-java-1.70.0/examples/example-hostname
 ../gradlew --no-daemon installDist
 sudo systemd-run ./build/install/hostname-server/bin/hostname-server')

Crie um grupo de instâncias geridas 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 com nome para o serviço gRPC. A porta com nome é a porta na qual o serviço gRPC deteta pedidos. No exemplo seguinte, a porta com nome é 50051:
```
gcloud compute instance-groups set-named-ports grpc-td-mig \
 --named-ports=grpc-helloworld-port:50051 \
 --zone=ZONE
```
Crie uma verificação de funcionamento de gRPC. Os serviços têm de implementar o protocolo de verificação do estado do gRPC para que as verificações do estado do gRPC funcionem corretamente. Para mais informações, consulte as verificações de estado.
```
gcloud compute health-checks create grpc grpc-helloworld-health-check \
  --use-serving-port
```

Crie uma regra de firewall para permitir ligações de verificação de funcionamento a instâncias na sua 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 funcionamento ao serviço de back-end. A porta especificada aqui é usada para estabelecer ligação às VMs no grupo de instâncias gerido.
```
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 gerido 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 Mesh e os serviços estão configurados. Na secção seguinte, configura o encaminhamento.

Configure o encaminhamento com o `GRPCRoute`

Siga as instruções abaixo para configurar o encaminhamento.

Crie a especificação GRPCRoute e guarde-a num ficheiro denominado grpc_route.yaml.

Pode usar o PROJECT_ID ou o 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 com 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 está agora configurado para equilibrar a carga do tráfego para os serviços especificados no recurso GRPCRoute em back-ends no grupo de instâncias gerido.

Crie um cliente gRPC

Pode validar a configuração ao instanciar uma aplicação gRPC sem proxy e associá-la ao Cloud Service Mesh. No respetivo ficheiro de arranque, a aplicação tem de especificar a rede VPC indicada na malha.

Depois de configurada, a aplicação pode enviar um pedido para as instâncias ou os pontos finais associados a helloworld-gce através do URI do serviço xds:///helloworld-gce.

Nos exemplos seguintes, usa a ferramenta grpcurl para testar o serviço gRPC.

Crie uma VM de 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.16.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.16.0/td-grpc-bootstrap --config-mesh-experimental=grpc-mesh | tee $GRPC_XDS_BOOTSTRAP')

Configure o ficheiro de arranque

A aplicação cliente tem de ter um ficheiro de configuração de arranque. O script de arranque na secção anterior define a variável de ambiente GRPC_XDS_BOOTSTRAP e usa um script auxiliar para gerar o ficheiro de arranque. Os valores de TRAFFICDIRECTOR_GCP_PROJECT_NUMBER e zone no ficheiro de arranque gerado são obtidos a partir do servidor de metadados que conhece estes detalhes sobre as suas instâncias de VM. Pode fornecer estes valores ao script auxiliar manualmente através da opção --gcp-project-number. Tem de fornecer um nome da malha que corresponda ao recurso Mesh através da opção --config-mesh-experimental.

Para validar a configuração, inicie sessão na VM do cliente e execute o seguinte.

Faça SSH para a VM do cliente.

gcloud compute ssh grpc-client --zone=ZONE

Transfira 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 do serviço e o método a invocar. Os parâmetros para o método SayHello são transmitidos através da opção -d.
```
./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld-gce helloworld.Greeter/SayHello
```

Deverá ver um resultado semelhante ao seguinte, em que INSTANCE_HOSTNAME é o nome de uma das instâncias de VM do servidor gRPC:

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

O resultado verifica se o cliente gRPC sem proxy se ligou com êxito ao Cloud Service Mesh e obteve informações sobre os back-ends do serviço helloworld-gce através do resolvedor de nomes xds. O cliente enviou um pedido a um dos backends do serviço sem precisar de saber o endereço IP nem realizar a resolução de DNS.

O que se segue?

Para informações sobre como listar recursos de trajetos associados a um recurso Mesh ou Gateway, consulte o artigo Liste recursos Route.