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.
- 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.
- 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 zonaus-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.
- 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 exds:///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 exds:///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 ehelloworld.Greeter/SayHello
como o nome e o método do serviço a serem invocados. Os parâmetros para o métodoSayHello
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.