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.

Esta página foi traduzida pela API Cloud Translation.

Configurar VMs do Compute Engine e serviços gRPC sem proxy

Neste guia, mostramos como configurar hosts de VM do Compute Engine, aplicativos do gRPC e os componentes de balanceamento de carga exigidos pela Cloud Service Mesh.

Antes de seguir as instruções deste guia, consulte Preparar-se para configurar o Cloud Service Mesh com serviços gRPC sem proxy.

Visão geral

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

configurar um grupo de instâncias gerenciadas que hospeda seus back-ends;
configurar os back-ends para executar um servidor gRPC que retorna hello world em resposta a uma solicitação de um cliente;
Como configurar o Cloud Service Mesh usando o grupo gerenciado de instâncias e componentes do balanceamento de carga do Google Cloud.
verificar se a implantação funciona corretamente usando um aplicativo cliente gRPC sem proxy para enviar tráfego ao aplicativo do servidor gRPC.

O cliente gRPC sem proxy se conecta à Cloud Service Mesh usando o xDS. Quando o cliente se conecta ao Cloud Service Mesh, o Cloud Service Mesh envia informações ao cliente sobre os back-ends associados ao hello world serviço. Usando essas informações, o cliente gRPC sem proxy envia solicitações para o servidor gRPC hello world.

Como configurar um grupo de instâncias gerenciadas para o Cloud Service Mesh

Os grupos de instâncias gerenciadas usam o escalonamento automático para criar novas VMs de back-end, conforme necessário para sua implantação. Neste exemplo, mostramos como fazer o seguinte:

Crie um modelo de instância com um serviço de amostra que exibe um serviço hello world usando o protocolo gRPC.
Configure um grupo de instâncias gerenciadas usando o modelo.

Como criar o modelo de instância

Nesta seção, você vê instruções para criar um modelo de instância. No exemplo, você implanta um serviço gRPC helloworld exposto na porta 50051.

Console

No Console do Google Cloud, acesse a página Modelos de instância.
Acessar a página "Modelos de instância"
Clique em Criar modelo de instância.
Preencha os campos da seguinte forma:
- Nome: grpc-td-vm-template
- Versão do disco de inicialização: Debian/Linux 10
- Conta de serviço: conta de serviço padrão do Compute Engine
- Escopos de acesso: permitir acesso total a todas as APIs do Google Cloud
Em Firewall, marque as caixas ao lado de Permitir tráfego HTTP e Permitir tráfego HTTPS.
Clique em Gerenciamento, segurança, discos, rede, locatário único.

Na guia Gerenciamento, copie o seguinte script para o campo Script de inicialização.

#! /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

Clique em Criar.

gcloud

Crie o modelo da 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')

Como criar o grupo de instâncias gerenciadas

Nesta seção, você cria um grupo de instâncias gerenciadas usando o modelo de instância criado na seção anterior.

Console

Acesse a página "Grupos de instâncias" no Console do Google Cloud.
Acessar a página Grupos de instâncias
Clique em Criar um grupo de instâncias. Por padrão, você vê a página para criar um grupo de instâncias gerenciadas.
Insira grpc-td-mig-us-central1 como o nome do grupo de instâncias gerenciadas e selecione a zona us-central1-a.
Em "Modelo de instância", selecione grpc-td-vm-template, que é o modelo de instância que você criou.
Especifique 2 como o número mínimo e máximo de instâncias que você quer criar no grupo.
Clique em Criar.

gcloud

Crie o grupo de instâncias gerenciadas:

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

Como configurar a porta nomeada

Nesta seção, você configura a porta nomeada do serviço gRPC. A porta nomeada é aquela em que o serviço gRPC detecta solicitações. Nesse exemplo, a porta nomeada é a porta 50051.

Console

Acesse a página "Grupos de instâncias" no Console do Google Cloud.
Acessar a página Grupos de instâncias
Clique no nome do grupo de instâncias grpc-td-mig-us-central1, que você criou.
Clique em Editar grupo.
No campo Nome da porta, digite grpc-helloworld-port.
No campo Número da porta, digite 50051.
Clique em Salvar.

gcloud

Configure a porta nomeada.

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

Como configurar o Cloud Service Mesh com componentes de balanceamento de carga do Google Cloud

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

Como criar a verificação de integridade, a regra de firewall e o serviço de back-end

Nesta seção, você cria um serviço de back-end global com o esquema de balanceamento de carga de INTERNAL_SELF_MANAGED e o protocolo GRPC, além de associar a verificação de integridade e o grupo de instâncias ao serviço de back-end Neste exemplo, use o grupo de instâncias gerenciadas criado em Como criar o grupo de instâncias gerenciadas. Esse grupo de instâncias gerenciadas executa o serviço gRPC de amostra. A porta na sinalização --port-name é a porta nomeada que você criou em Como configurar a porta nomeada.

gcloud

Crie a verificação de integridade.

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

Crie a regra de firewall de verificação de integridade.

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

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

Como criar o mapa da regra de roteamento, o proxy de destino e a regra de encaminhamento

Nesta seção, você cria um mapa de URL, a correspondência de caminho e uma regra de host para rotear o tráfego para seu serviço com base no nome do host e em um caminho. O exemplo a seguir usa helloworld-gce como o nome do serviço. O aplicativo gRPC usa esse nome de serviço no URI de destino ao se conectar com este serviço. Por padrão, a correspondência de caminho corresponde a todas as solicitações de caminho (/*) desse host. Crie também a regra de encaminhamento e o proxy gRPC de destino.

Para saber mais, consulte Como mapear mapas de regras.

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

gcloud

Crie o mapa de URL.

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

Crie a correspondência de caminho.

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

Crie o proxy de destino do gRPC.

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

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 agora está configurado para balancear a carga do tráfego na back-ends no grupo gerenciado de instâncias para os serviços especificados no mapa de URL.

Como verificar a configuração

Quando o processo de configuração for concluído, verifique se é possível estabelecer uma conexão gRPC com o serviço de balanceamento de carga do Cloud Service Mesh que você criou anteriormente.

Para verificar se o serviço está disponível, siga um destes procedimentos:

Faça login em um dos hosts de VM (o back-end do serviço gRPC) e verifique se o serviço gRPC está sendo executado na porta de detecção. No exemplo, a porta é 50051.
Verifique a página do Cloud Service Mesh no console para informações sobre o serviço configurado helloworld-gce e confirme se os back-ends serão relatados como íntegros.
Use as instruções a seguir para usar um cliente gRPC do Compute Engine para verificação.

Como verificar o serviço com um aplicativo cliente gRCP

Nos exemplos a seguir, use um cliente gRPC na língua de sua escolha ou a ferramenta grpcurl para testar o serviço gRPC.

Primeiro, crie uma VM cliente em que você 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')

Como configurar a variável de ambiente e o arquivo de inicialização

O aplicativo cliente precisa de 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 usa um script auxiliar para gerar o arquivo de inicialização. Os valores para TRAFFICDIRECTOR_GCP_PROJECT_NUMBER, TRAFFICDIRECTOR_NETWORK_NAME e zone no arquivo de inicialização gerado são recebidos do servidor de metadados que sabe esses detalhes sobre suas instâncias de VM do Compute Engine. É possível fornecer esses valores para o script auxiliar manualmente usando as opções -gcp-project-number e -vpc-network-name.

Para verificar a configuração, faça login na VM cliente e execute os exemplos a seguir.

Java

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

Faça o download da versão mais recente do gRPC Java com o patch mais recente e crie o aplicativo 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

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

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

Go

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

Faça o download da versão mais recente do gRPC Go com o patch mais recente e crie o aplicativo 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 .

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

C++

Para verificar o serviço com um cliente gRPC em C++:

Faça o download da versão mais recente do gRPC C++, com o patch mais recente e crie o exemplo de cliente helloworld.

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

Execute o cliente com "xds:///helloworld-gce" como o URI do serviço.
```
./greeter_client --target=xds:///helloworld-gce
```

grpcurl

Para verificar o serviço usando a ferramenta grpcurl:

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

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

Python

Para verificar o serviço com um cliente gRPC Python, 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 verificar 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 verificar o serviço com um cliente gRPC PHP, 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 verificar 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

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

Greeting: 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

Saiba mais sobre o gerenciamento de tráfego avançado.
Saiba como configurar a observabilidade.
Saiba como resolver problemas de implantações sem proxy do Cloud Service Mesh.