Configurar serviços gRPC sem proxy

Observação: este guia só oferece suporte ao Cloud Service Mesh com APIs do Google Cloud e não às APIs do Istio. Para mais informações, consulte Visão geral do Cloud Service Mesh.

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 os recursos GRPCRoute e Mesh (clique para ampliar)

{ 101)

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 o aplicativo gRPC sem proxy usa para solicitar a configuração associada a essa malha.

1. Crie a especificação Mesh e salve-a em um arquivo chamado mesh.yaml.

   name: grpc-mesh
   

2. 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.

1. 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')
    

2. 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
   

3. 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
   

4. 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
   

5. 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
   

6. 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
   

7. 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.

1. 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
   

2. 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 especificado no recurso GRPCRoute nos back-ends da instância gerenciada grupo.

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.

1. 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.

Observação: de acordo com a política, recomendamos que os usuários verifiquem se há atualizações do gerador de bootstrap do gRPC TD anualmente.

Para verificar a configuração, faça login na VM de cliente e execute o seguindo.

1. SSH para a VM cliente.

   gcloud compute ssh grpc-client
   

2. 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
   

3. 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.