Configura le VM di Compute Engine e i servizi gRPC senza proxy

Questa guida mostra come configurare gli host VM di Compute Engine, le applicazioni gRPC e i componenti di bilanciamento del carico richiesti da Traffic Director.

Prima di seguire le istruzioni riportate in questa guida, consulta la sezione Preparazione della configurazione di Traffic Director con servizi gRPC proxyless

Panoramica

La configurazione di Traffic Director con macchine virtuali (VM) Compute Engine e servizi gRPC senza proxy prevede quanto segue:

  1. Configurazione di un gruppo di istanze gestite che ospita i tuoi backend.
  2. Configurazione dei backend per l'esecuzione di un server gRPC che restituisce hello world in risposta a una richiesta di un client.
  3. Configurazione di Traffic Director utilizzando il gruppo di istanze gestite e altri componenti di bilanciamento del carico di Google Cloud.
  4. Verificare che il deployment funzioni correttamente utilizzando un'applicazione client gRPC proxyless per inviare il traffico all'applicazione server gRPC.

Il client gRPC senza proxy si connette a Traffic Director utilizzando xDS. Quando il client si connette a Traffic Director, invia al client informazioni sui backend associati al servizio hello world. Utilizzando queste informazioni, il client gRPC senza proxy invia richieste al server gRPC hello world.

Configurazione di un gruppo di istanze gestite per Traffic Director

I gruppi di istanze gestite utilizzano la scalabilità automatica per creare nuove VM di backend in base alle esigenze del tuo deployment. Questo esempio mostra come:

  • Crea un modello di istanza con un servizio di esempio che gestisce un servizio hello world utilizzando il protocollo gRPC.
  • Configura un gruppo di istanze gestite utilizzando il modello.

Creazione del modello di istanza

Questa sezione fornisce le istruzioni per creare un modello di istanza. Nell'esempio, esegui il deployment di un servizio gRPC helloworld esposto sulla porta 50051.

Console

  1. Nella console Google Cloud, vai alla pagina Modelli di istanza.

    Vai alla pagina Modelli di istanza

  2. Fai clic su Crea modello istanza.

  3. Compila i campi come segue:

    • Nome: grpc-td-vm-template
    • Versione disco di avvio: Debian / Linux 10
    • Account di servizio: account di servizio predefinito di Compute Engine
    • Ambiti di accesso: consenti l'accesso completo a tutte le API Google Cloud

  4. In Firewall, seleziona le caselle accanto a Consenti traffico HTTP e Consenti traffico HTTPS.

  5. Fai clic su Gestione, Sicurezza, Dischi, Networking, Single-tenancy.

  6. Nella scheda Gestione, copia lo script seguente nel campo Script di avvio.

    #! /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. Fai clic su Crea.

gcloud

Crea il modello di istanza.

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

Creazione del gruppo di istanze gestite

In questa sezione creerai un gruppo di istanze gestite utilizzando il modello di istanza creato nella sezione precedente.

Console

  1. Vai alla pagina Gruppi di istanze nella console Google Cloud.

    Vai alla pagina Gruppi di istanze

  2. Fai clic su Crea un gruppo di istanze. Per impostazione predefinita, viene visualizzata la pagina per la creazione di un gruppo di istanze gestite.
  3. Inserisci grpc-td-mig-us-central1 come nome del gruppo di istanze gestite e seleziona la zona us-central1-a.
  4. In Modello di istanza, seleziona grpc-td-vm-template, ossia il modello di istanza che hai creato.
  5. Specifica 2 come numero minimo e massimo di istanze da creare nel gruppo.
  6. Fai clic su Crea.

gcloud

Crea il gruppo di istanze gestite.

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

Configurazione della porta denominata

In questa sezione configurerai la porta denominata per il servizio gRPC. La porta denominata è la porta su cui il servizio gRPC rimane in ascolto delle richieste. In questo esempio, la porta denominata è la porta 50051.

Console

  1. Vai alla pagina Gruppi di istanze nella console Google Cloud.

    Vai alla pagina Gruppi di istanze

  2. Fai clic sul nome del gruppo di istanze grpc-td-mig-us-central1 che hai creato.
  3. Fai clic su Modifica gruppo.
  4. Nel campo Nome porta, inserisci grpc-helloworld-port.
  5. Nel campo Numero porta, inserisci 50051.
  6. Fai clic su Salva.

gcloud

Configura la porta denominata.

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

Configurazione di Traffic Director con i componenti di bilanciamento del carico di Google Cloud

Questa sezione fornisce le istruzioni per configurare Traffic Director con i componenti di bilanciamento del carico di Google Cloud per i tuoi servizi.

Creazione del controllo di integrità, della regola firewall e del servizio di backend

In questa sezione creerai un servizio di backend globale con uno schema di bilanciamento del carico di INTERNAL_SELF_MANAGED e protocollo GRPC, quindi associa il controllo di integrità e il gruppo di istanze al servizio di backend. In questo esempio, utilizzerai il gruppo di istanze gestite creato nella sezione Creazione del gruppo di istanze gestite. Questo gruppo di istanze gestite esegue il servizio gRPC di esempio. La porta nel flag --port-name è quella creata nella sezione Configurazione della porta denominata.

gcloud

  1. Crea il controllo di integrità.

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

  2. Crea la regola firewall per il controllo di integrità.

    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. Crea il servizio di backend.

    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. Aggiungi il gruppo di istanze gestite al servizio di backend.

    gcloud compute backend-services add-backend grpc-helloworld-service \
 --instance-group grpc-td-mig-us-central1 \
 --instance-group-zone us-central1-a \
 --global

Creazione della mappa di regole di routing, del proxy di destinazione e della regola di forwarding

In questa sezione, creerai una mappa URL, un matcher percorso e una regola host per instradare il traffico per il tuo servizio in base al nome host e a un percorso. L'esempio seguente utilizza helloworld-gce come nome del servizio. L'applicazione gRPC utilizza questo nome del servizio nell'URI di destinazione durante la connessione a questo servizio. Per impostazione predefinita, il matcher percorso corrisponde a tutte le richieste di percorso (/*) per questo host. Puoi anche creare il proxy gRPC di destinazione e la regola di forwarding.

Per ulteriori informazioni, vedi Mappe di regole di routing.

Nell'esempio seguente, la porta specificata è la porta 80.

gcloud

  1. Crea la mappa URL.

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

  2. Crea il matcher del percorso.

    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. Crea il proxy gRPC di destinazione.

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

  4. Crea la regola di forwarding.

    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

Traffic Director è ora configurato per bilanciare il carico del traffico tra i backend nel gruppo di istanze gestite per i servizi specificati nella mappa URL.

Verifica della configurazione

Al termine del processo di configurazione, verifica di poter stabilire una connessione gRPC al servizio con bilanciamento del carico Traffic Director creato in precedenza.

Per verificare che il servizio sia disponibile, esegui una delle seguenti operazioni:

  • Accedi a uno degli host VM (il backend del servizio gRPC) e verifica che il servizio gRPC sia in esecuzione sulla porta di ascolto. Nell'esempio, la porta è 50051.
  • Controlla la pagina Traffic Director nella console per informazioni sul servizio configurato helloworld-gce e conferma che i backend siano segnalati come integri.
  • Segui le istruzioni riportate di seguito per utilizzare un client gRPC di Compute Engine per la verifica.

Verifica del servizio con un'applicazione client gRPC

Nei seguenti esempi, utilizzi un client gRPC nella lingua che preferisci o lo strumento grpcurl per testare il servizio gRPC.

In primo luogo, crea una VM client su cui esegui il client gRPC per testare il servizio.

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.11.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.11.0/td-grpc-bootstrap | tee $GRPC_XDS_BOOTSTRAP')

Configurazione della variabile di ambiente e del file di bootstrap

L'applicazione client richiede un file di configurazione di bootstrap. Lo script di avvio nella sezione precedente imposta la variabile di ambiente GRPC_XDS_BOOTSTRAP e utilizza uno script di supporto per generare il file di bootstrap. I valori per TRAFFICDIRECTOR_GCP_PROJECT_NUMBER, TRAFFICDIRECTOR_NETWORK_NAME e zone nel file di bootstrap generato vengono ottenuti dal server di metadati che conosce questi dettagli sulle istanze VM di Compute Engine. Puoi fornire questi valori manualmente allo script di supporto utilizzando le opzioni -gcp-project-number e -vpc-network-name.

Per verificare la configurazione, accedi alla VM client ed esegui gli esempi seguenti.

Java

Per verificare il servizio con un client Java gRPC:

  1. Scarica la versione più recente di Java gRPC, con la patch più recente, e crea l'applicazione client 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. Esegui il client con world come nome e xds:///helloworld-gce come URI del servizio.

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

Go

Per verificare il servizio con un client gRPC Go:

  1. Scarica la versione più recente di gRPC Go, con la patch più recente, e crea l'applicazione client 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. Esegui il client con world come nome e xds:///helloworld-gce come URI del servizio.

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

C++

Per verificare il servizio con un client gRPC C++:

  1. Scarica la versione più recente di gRPC C++, con la patch più recente, e crea l'esempio del client 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

  2. Esegui il client con "xds:///helloworld-gce" come URI del servizio.

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

grpcurl

Per verificare il servizio utilizzando lo strumento grpcurl:

  1. Scarica e installa lo strumento 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. Esegui lo strumento grpcurl con "xds:///helloworld-gce" come URI del servizio e helloworld.Greeter/SayHello come nome del servizio e metodo da richiamare. I parametri al metodo SayHello vengono passati utilizzando l'opzione -d.

    ./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld-gce helloworld.Greeter/SayHello

Python

Per verificare il servizio con un client Python gRPC, esegui questo comando. Utilizza la versione più recente di gRPC con la patch più 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

Per verificare il servizio con un client Ruby gRPC, esegui questo comando. Utilizza la versione più recente di gRPC con la patch più 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

Per verificare il servizio con un client gRPC PHP, esegui questo comando. Utilizza la versione più recente di gRPC con la patch più 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

Per verificare il servizio con un client gRPC Node.js, esegui questo comando. Utilizza la versione più recente di gRPC con la patch più 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

Dovresti vedere un output simile a questo, dove INSTANCE_NAME è il nome dell'istanza VM:

Greeting: Hello world, from INSTANCE_HOSTNAME

In questo modo, il client gRPC senza proxy si è connesso a Traffic Director e ha acquisito informazioni sui backend per il servizio helloworld-gce utilizzando il resolver dei nomi xds. Il client ha inviato una richiesta a uno dei backend del servizio senza dover conoscere l'indirizzo IP o eseguire la risoluzione DNS.

Passaggi successivi