Configure MVs do Compute Engine e serviços gRPC sem proxy

Este guia mostra como configurar os anfitriões de VMs do Compute Engine, as aplicações gRPC e os componentes de equilíbrio de carga que o Cloud Service Mesh requer.

Antes de seguir as instruções neste guia, reveja o artigo Prepare-se para configurar a Cloud Service Mesh com serviços gRPC sem proxy

Vista geral

A configuração da Cloud Service Mesh com máquinas virtuais (MVs) do Compute Engine e serviços gRPC sem proxy envolve o seguinte:

1. Configurar um grupo de instâncias geridas que aloja os seus back-ends.
2. Configurar os backends para executar um servidor gRPC que devolve hello world em resposta a um pedido de um cliente.
3. Configurar a Cloud Service Mesh através do grupo de instâncias geridas e de outros componentes de equilíbrio de carga. Google Cloud
4. Validar se a implementação funciona corretamente através de uma aplicação cliente gRPC sem proxy para enviar tráfego para a aplicação de servidor gRPC.

O cliente gRPC sem proxy liga-se ao Cloud Service Mesh através do xDS. Quando o cliente se liga ao Cloud Service Mesh, o Cloud Service Mesh envia informações ao cliente sobre os back-ends associados ao serviço hello world. Com estas informações, o cliente gRPC sem proxy envia pedidos para o servidor gRPC hello world.

Configurar um grupo de instâncias geridas para a malha de serviço do Google Cloud

Os grupos de instâncias geridas usam o dimensionamento automático para criar novas VMs de back-end, conforme necessário, pela sua implementação. Este exemplo mostra como fazer o seguinte:

• Crie um modelo de instância com um serviço de exemplo que forneça um serviço hello world usando o protocolo gRPC.
• Configure um grupo de instâncias geridas com o modelo.

Criar o modelo de instância

Esta secção fornece instruções para criar um modelo de instância. No exemplo, implementa um serviço gRPC que é exposto na porta 50051.helloworld

Consola

1. Na Google Cloud consola, aceda à página Modelos de instâncias.

   Aceda à página Modelos de instâncias

2. Clique em Criar modelo de instância.

3. Preencha os campos da seguinte forma:

   • Nome: grpc-td-vm-template
   • Versão do disco de arranque: Debian / Linux 10
   • Conta de serviço: conta de serviço predefinida do Compute Engine
   • Âmbitos de acesso: permitir acesso total a todas as Google Cloud APIs

4. Em Firewall, selecione as caixas junto a Permitir tráfego HTTP e Permitir tráfego HTTPS.

5. Clique em Gestão, segurança, discos, trabalhar em rede, arrendamento único.

6. No separador Gestão, copie o seguinte script para o campo Script de arranque.

   #! /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.37.0.tar.gz | tar -xz
   cd grpc-java-1.37.0/examples/example-hostname
   ../gradlew --no-daemon installDist
   # Server listens on 50051
   sudo systemd-run ./build/install/hostname-server/bin/hostname-server
   

7. Clique em Criar.

gcloud

Crie o modelo de instância.

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.37.0.tar.gz | tar -xz
cd grpc-java-1.37.0/examples/example-hostname
../gradlew --no-daemon installDist
# Server listens on 50051
sudo systemd-run ./build/install/hostname-server/bin/hostname-server')

Criar o grupo de instâncias geridas

Nesta secção, cria um grupo de instâncias gerido com o modelo de instância que criou na secção anterior.

Consola

1. Aceda à página Grupos de instâncias na Google Cloud consola.

   Aceda à página Grupos de instâncias

2. Clique em Criar um grupo de instâncias. Por predefinição, é apresentada a página para criar um grupo de instâncias gerido.
3. Introduza grpc-td-mig-us-central1 para o nome do grupo de instâncias geridas e selecione a zona us-central1-a.
4. Em Modelo de instância, selecione grpc-td-vm-template, que é o modelo de instância que criou.
5. Especifique 2 como o número mínimo e máximo de instâncias que quer criar no grupo.
6. Clique em Criar.

gcloud

Crie o grupo de instâncias geridas.

gcloud compute instance-groups managed create grpc-td-mig-us-central1 \
  --zone us-central1-a \
  --size=2 \
  --template=grpc-td-vm-template

Configurar a porta com nome

Nesta secção, configura a porta com nome para o serviço gRPC. A porta nomeada é a porta na qual o serviço gRPC deteta pedidos. Neste exemplo, a porta com nome é a porta 50051.

Consola

1. Aceda à página Grupos de instâncias na Google Cloud consola.

   Aceda à página Grupos de instâncias

2. Clique no nome do grupo de instâncias grpc-td-mig-us-central1 que criou.
3. Clique em Editar grupo.
4. No campo Nome da portabilidade, introduza grpc-helloworld-port.
5. No campo Número da porta, introduza 50051.
6. Clique em Guardar.

gcloud

Configure a porta com nome.

gcloud compute instance-groups set-named-ports grpc-td-mig-us-central1 \
  --named-ports=grpc-helloworld-port:50051 \
  --zone us-central1-a

Configurar a malha de serviço na nuvem com Google Cloud componentes de equilíbrio de carga

Esta secção fornece instruções para configurar a Cloud Service Mesh com Google Cloud componentes de balanceamento de carga para os seus serviços.

Criar a verificação de funcionamento, a regra de firewall e o serviço de back-end

Nesta secção, cria um serviço de back-end global com um esquema de equilíbrio de carga de INTERNAL_SELF_MANAGED e um protocolo GRPC e, em seguida, associa a verificação de funcionamento e o grupo de instâncias ao serviço de back-end. Neste exemplo, usa o grupo de instâncias gerido que criou em Criar o grupo de instâncias gerido. Este grupo de instâncias geridas executa o serviço gRPC de exemplo. A porta na flag --port-name é a porta com nome que criou em Configurar a porta com nome.

gcloud

1. Crie a verificação de funcionamento.

   gcloud compute health-checks create grpc grpc-helloworld-health-check \
    --use-serving-port
   

2. Crie a regra de firewall de verificação de funcionamento.

   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
   

3. Crie o serviço de back-end.

   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
   

4. 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-us-central1 \
    --instance-group-zone us-central1-a \
    --global
   

Criar o mapa de regras de encaminhamento, o proxy de destino e a regra de encaminhamento

Nesta secção, cria um mapa de URL, um correspondente de caminhos e uma regra de anfitrião para encaminhar o tráfego para o seu serviço com base no nome do anfitrião e num caminho. O exemplo seguinte usa helloworld-gce como nome do serviço. A aplicação gRPC usa este nome do serviço no URI de destino quando se liga a este serviço. Por predefinição, o correspondente de caminhos corresponde a todos os pedidos de caminhos (/*) para este anfitrião. Também cria o proxy gRPC de destino e a regra de encaminhamento.

Para mais informações, consulte o artigo Mapas de regras de encaminhamento.

No exemplo seguinte, a porta 80 é a porta especificada.

gcloud

1. Crie o mapa de URLs.

   gcloud compute url-maps create grpc-vm-url-map \
     --default-service grpc-helloworld-service
   

2. Crie o correspondente de caminhos.

   gcloud compute url-maps add-path-matcher grpc-vm-url-map \
     --default-service grpc-helloworld-service \
     --path-matcher-name grpc-vm-path-matcher \
     --new-hosts helloworld-gce
   

3. Crie o proxy gRPC de destino.

   gcloud compute target-grpc-proxies create grpc-vm-proxy \
    --url-map grpc-vm-url-map \
    --validate-for-proxyless
   

4. Crie a regra de encaminhamento.

   gcloud compute forwarding-rules create grpc-vm-forwarding-rule \
    --global \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --address=0.0.0.0 --address-region=us-central1 \
    --target-grpc-proxy=grpc-vm-proxy \
    --ports 80 \
    --network default
   

O Cloud Service Mesh está agora configurado para equilibrar a carga do tráfego nos back-ends no grupo de instâncias gerido para os serviços especificados no mapa de URLs.

Validar a configuração

Quando o processo de configuração estiver concluído, verifique se consegue estabelecer uma ligação gRPC ao serviço com balanceamento de carga do Cloud Service Mesh que criou anteriormente.

Para verificar se o serviço está disponível, faça uma das seguintes ações:

• Inicie sessão num dos anfitriões de VM (o back-end do serviço gRPC) e verifique se o serviço gRPC está a ser executado na porta de deteção. No exemplo, a porta é 50051.
• Consulte a página Cloud Service Mesh na consola para ver informações sobre o serviço configurado helloworld-gce e confirme que os back-ends são comunicados como estando em bom estado.
• Use as instruções seguintes para usar um cliente gRPC do Compute Engine para validação.

Validar o serviço com uma aplicação cliente gRPC

Nos exemplos seguintes, usa um cliente gRPC no idioma à sua escolha ou a ferramenta grpcurl para testar o serviço gRPC.

Primeiro, crie uma VM cliente na qual executa o cliente gRPC para testar o serviço.

gcloud compute instances create grpc-client \
  --zone us-central1-a \
  --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
# Expose bootstrap variable to SSH connections
echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh
# Create the bootstrap file
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 | tee $GRPC_XDS_BOOTSTRAP')

Configurar a variável de ambiente e o ficheiro de arranque

Nota: de acordo com a política, recomendamos que os utilizadores verifiquem anualmente se existem atualizações do gerador de arranque do gRPC de TD.

A aplicação cliente precisa de 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, TRAFFICDIRECTOR_NETWORK_NAME 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 do Compute Engine. Pode fornecer estes valores ao script auxiliar manualmente através das opções -gcp-project-number e -vpc-network-name.

Nota: a adição da geração de bootstrap ao script de inicialização da VM garante que é criado um ficheiro de bootstrap atualizado sempre que a VM é reiniciada.

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

Java

Para validar o serviço com um cliente Java gRPC:

1. Transfira a versão mais recente do gRPC Java, com o patch mais recente, e crie a aplicação cliente xds-hello-world.

   sudo apt-get update -y
   sudo apt-get install -y openjdk-11-jdk-headless
   curl -L https://github.com/grpc/grpc-java/archive/v1.37.0.tar.gz | tar -xz
   cd grpc-java-1.37.0/examples/example-xds
   ../gradlew --no-daemon installDist
   

2. Execute o cliente com world como nome e xds:///helloworld-gce como URI do serviço.

   ./build/install/example-xds/bin/xds-hello-world-client "world" \
      xds:///helloworld-gce
   

Ir

Para validar o serviço com um cliente Go gRPC:

1. Transfira a versão mais recente do gRPC Go, com o patch mais recente, e crie a aplicação cliente xds-hello-world.

   sudo apt-get update -y
   sudo apt-get install -y golang git
   curl -L https://github.com/grpc/grpc-go/archive/v1.37.0.tar.gz | tar -xz
   cd grpc-go-1.37.0/examples/features/xds/client
   go get google.golang.org/grpc@v1.37.0
   go build .
   

2. Execute o cliente com world como nome e xds:///helloworld-gce como URI do serviço.

   ./client "world" xds:///helloworld-gce
   

C++

Para validar o serviço com um cliente gRPC C++:

1. Transfira a versão mais recente do gRPC C++, com o patch mais recente, e crie o helloworld exemplo de cliente.

   sudo apt-get update -y
   sudo apt-get install -y build-essential cmake git
   git clone --recurse-submodules -b v1.37.1 https://github.com/grpc/grpc
   cd grpc
   mkdir -p cmake/build
   pushd cmake/build
   cmake ../..
   make
   sudo make install
   popd
   mkdir -p third_party/abseil-cpp/cmake/build
   pushd third_party/abseil-cpp/cmake/build
   cmake ../..
   make
   sudo make install
   popd
   cd examples/cpp/helloworld
   mkdir -p cmake/build
   cd cmake/build/
   cmake ../..
   make
   

2. Execute o cliente com "xds:///helloworld-gce" como o URI do serviço.

   ./greeter_client --target=xds:///helloworld-gce
   

grpcurl

Para validar o serviço através da ferramenta grpcurl:

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

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

Python

Para validar o serviço com um cliente Python gRPC, execute o seguinte. Use a versão mais recente do gRPC com o patch mais recente.

sudo apt-get update
sudo apt-get -y install python3-pip
sudo pip3 install virtualenv
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1/examples/python/xds
virtualenv venv -p python3
source venv/bin/activate
pip install -r requirements.txt
python client.py  xds:///helloworld-gce

Ruby

Para validar o serviço com um cliente gRPC Ruby, execute o seguinte. Use a versão mais recente do gRPC com o patch mais recente.

sudo apt-get update
sudo apt-get install -y ruby-full
sudo gem install grpc
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1/examples/ruby
ruby greeter_client.rb john xds:///helloworld-gce

PHP

Para validar o serviço com um cliente PHP gRPC, execute o seguinte. Use a versão mais recente do gRPC com o patch mais recente.

sudo apt-get update
sudo apt-get install -y php7.3 php7.3-dev php-pear phpunit python-all zlib1g-dev git
sudo pecl install grpc
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1
export CC=/usr/bin/gcc
./tools/bazel build @com_google_protobuf//:protoc
./tools/bazel build src/compiler:grpc_php_plugin
cd examples/php
composer install
./../../bazel-bin/external/com_google_protobuf/protoc --proto_path=../protos \
--php_out=. --grpc_out=. \
--plugin=protoc-gen-grpc=../../bazel-bin/src/compiler/grpc_php_plugin \
../protos/helloworld.proto
php -d extension=grpc.so greeter_client.php john xds:///helloworld-gce

Node.js

Para validar o serviço com um cliente gRPC Node.js, execute o seguinte. Use a versão mais recente do gRPC com o patch mais recente.

sudo apt-get update
sudo apt-get install -y nodejs npm
curl -L https://github.com/grpc/grpc/archive/v1.34.0.tar.gz | tar -xz
cd grpc-1.34.0/examples/node/xds
npm install
node ./greeter_client.js --target=xds:///helloworld-gce

Deverá ver uma saída semelhante a esta, em que INSTANCE_NAME é o nome da instância de VM:

Greeting: Hello world, from INSTANCE_HOSTNAME

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

O que se segue?

• Saiba mais sobre a gestão avançada de tráfego.
• Saiba como configurar a observabilidade.
• Saiba como resolver problemas de implementações da malha de serviços na nuvem sem proxy.