Configuração do Traffic Director com 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 pelo Traffic Director.

Antes de seguir as instruções deste guia, consulte Como se preparar para configurar o Traffic Director com serviços do gRPC sem proxy.

Visão geral

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

  1. configurar um grupo de instâncias gerenciadas que hospeda seus back-ends;
  2. configurar os back-ends para executar um servidor gRPC que retorna hello world em resposta a uma solicitação de um cliente;
  3. configurar o Traffic Director usando o grupo de instâncias gerenciadas e outros componentes de balanceamento de carga do Google Cloud;
  4. 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 ao Traffic Director usando o xDS. Quando o cliente se conecta ao Traffic Director, o Traffic Director envia informações ao cliente sobre os back-ends associados ao serviço do hello world. 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 do Traffic Director

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

  1. No Console do Cloud, acesse a página "Modelos de instância".

    Acessar a página "Modelos de instância"

  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 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
  4. Em Firewall, marque as caixas ao lado de Permitir tráfego HTTP e Permitir tráfego HTTPS.

  5. Clique em Gerenciamento, segurança, discos, rede, locatário único.

  6. 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.27.0.tar.gz | tar -xz
    cd grpc-java-1.27.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 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.27.0.tar.gz | tar -xz
cd grpc-java-1.27.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

  1. Acesse a página "Grupos de instâncias" no Console do Cloud.

    Acessar a página "Grupos de instâncias"

  2. Clique em Criar um grupo de instâncias. Por padrão, você vê a página para criar um grupo de instâncias gerenciadas.
  3. Insira grpc-td-mig-us-central1 como o nome do grupo de instâncias gerenciadas 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 você criou.
  5. Especifique 2 como o número mínimo e máximo de instâncias que você quer criar no grupo.
  6. 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

  1. Acesse a página "Grupos de instâncias" no Console do Cloud.

    Acessar a página "Grupos de instâncias"

  2. Clique no nome do grupo de instâncias grpc-td-mig-us-central1, que você criou.
  3. Clique em Editar grupo.
  4. No campo Nome da porta, digite grpc-helloworld-port.
  5. No campo Número da porta, digite 50051.
  6. 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 Traffic Director com componentes de balanceamento de carga do Google Cloud

Nesta seção, você vê instruções para configurar o Traffic Director 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

  1. Crie a verificação de integridade.

    gcloud compute health-checks create grpc grpc-helloworld-health-check \
     --use-serving-port
    
  2. 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
    
  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 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

  1. Crie o mapa de URL.

    gcloud compute url-maps create grpc-vm-url-map \
      --default-service grpc-helloworld-service
    
  2. 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
    
  3. 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
    
  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 Traffic Director agora está configurado para balancear a carga do tráfego nos back-ends do grupo de instâncias gerenciadas para os serviços especificados no mapa de URLs.

Como verificar a configuração

Quando o processo de configuração estiver concluído, verifique se é possível estabelecer uma conexão gRPC com o serviço de balanceamento de carga do Traffic Director 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.
  • Acesse a página do Traffic Director no Console para mais informações sobre o serviço configurado helloworld-gce e confirme se os back-ends são informados 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.9.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.9.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 e 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:

  1. Faça o download do gRPC Java versão 1.30.0, 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.30.0.tar.gz | tar -xz
    cd grpc-java-1.30.0/examples/example-xds
    ../gradlew --no-daemon installDist
    
  2. 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:

  1. Faça o download do gRPC Go versão 1.30.0, 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.30.0.tar.gz | tar -xz
    cd grpc-go-1.30.0/examples/features/xds/client
    go get google.golang.org/grpc@v1.30.0
    go build .
    
  2. 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++:

  1. Faça o download da versão 1.30.0 do gRPC em 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 -b v1.30.0 https://github.com/grpc/grpc
    cd grpc
    git submodule update --init
    mkdir -p cmake/build
    cd cmake/build
    cmake ../..
    make
    sudo make install
    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 verificar o serviço usando a ferramenta grpcurl:

  1. Faça o download e instale a ferramenta grpcurl.

    curl -L https://github.com/fullstorydev/grpcurl/releases/download/v1.6.1/grpcurl_1.6.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 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 comando:

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

C#

Para verificar o serviço com um cliente gRPC C#:

  1. Instale o SDK dotnet versão 2.1 usando um destes métodos:
  2. Execute o seguinte comando:

    curl -L https://github.com/grpc/grpc/archive/v1.30.0.tar.gz | tar -xz
    cd grpc-1.30.0/examples/csharp/Xds/GreeterClient
    dotnet run --server xds:///helloworld-gce
    

Ruby

Para verificar o serviço com um cliente Ruby do gRPC, execute o seguinte:

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

PHP

Para verificar o serviço com um cliente PHP gRPC, execute o seguinte:

sudo apt-get update
sudo apt-get install -y php7.3 php7.3-dev php-pear phpunit zlib1g-dev
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.30.0.tar.gz | tar -xz
cd grpc-1.30.0
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

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