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)
{ 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 que o aplicativo gRPC sem proxy usa para solicitar a configuração associada dessa 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 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.

  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.

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.