Configurare le VM di Compute Engine e i servizi gRPC proxyless

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

Prima di seguire le istruzioni riportate in questa guida, consulta Prepararsi a configurare Cloud Service Mesh con servizi gRPC proxyless

Panoramica

La configurazione di Cloud Service Mesh con macchine virtuali (VM) di Compute Engine e servizi gRPC proxyless prevede quanto segue:

  1. Configura un gruppo di istanze gestite che ospiti i tuoi backend.
  2. Configurazione dei backend per eseguire un server gRPC che restituisce hello world in risposta a una richiesta di un client.
  3. Configurazione di Cloud Service Mesh 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 senza proxy per inviare traffico all'applicazione server gRPC.

Il client gRPC senza proxy si connette a Cloud Service Mesh utilizzando xDS. Quando il client si connette a Cloud Service Mesh, quest'ultimo invia al client informazioni sui backend associati al servizio hello world. Utilizzando queste informazioni, il client gRPC senza proxy invia richieste al hello world server gRPC.

Configurazione di un gruppo di istanze gestite per Cloud Service Mesh

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

  • Crea un modello di istanza con un servizio di esempio che fornisce 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 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 del disco di avvio: Debian / Linux 10
    • Account di servizio: account di servizio predefinito 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 il seguente script 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 crei 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, ovvero 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, configuri la porta denominata per il servizio gRPC. La porta denominata è la porta su cui il servizio gRPC rimane in ascolto per le 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 Cloud Service Mesh con i componenti di bilanciamento del carico di Google Cloud

Questa sezione fornisce istruzioni per configurare Cloud Service Mesh 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 crei un servizio di backend globale con uno schema di bilanciamento del carico di INTERNAL_SELF_MANAGED e il protocollo GRPC, quindi associ il controllo di integrità e il gruppo di istanze al servizio di backend. In questo esempio utilizzi il gruppo di istanze gestite che hai creato in Creare il gruppo di istanze gestite. Questo gruppo di istanze gestite esegue il servizio gRPC di esempio. La porta nel flag --port-name è la porta denominata che hai creato in 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 regola di forwarding

In questa sezione crei 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 servizio nell'URI di destinazione quando si connette a questo servizio. Per impostazione predefinita, il matcher percorso corrisponde a tutte le richieste di percorso (/*) per questo host. Devi anche creare il proxy gRPC di destinazione e regola di forwarding.

Per ulteriori informazioni, consulta Mappe delle regole di routing.

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

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

Cloud Service Mesh è 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 della procedura di configurazione, verifica di poter stabilire una connessione gRPC al servizio bilanciato del carico Cloud Service Mesh che hai 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 Cloud Service Mesh nella console per informazioni sul servizio configurato helloworld-gce e verifica che i backend siano segnalati come operativi.
  • 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

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

Innanzitutto, crea una VM client su cui eseguire 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.16.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.16.0/td-grpc-bootstrap | tee $GRPC_XDS_BOOTSTRAP')

Configurazione della variabile di ambiente e del file di bootstrap

L'applicazione client ha bisogno di 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 manualmente questi valori allo script di supporto utilizzando le opzioni -gcp-project-number e -vpc-network-name.

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

Java

Per verificare il servizio con un client Java gRPC:

  1. Scarica la versione più recente di gRPC Java, con la patch più recente e compila 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

Vai

Per verificare il servizio con un client gRPC Go:

  1. Scarica la versione più recente di gRPC Go, con la patch più recente, e compila l'applicazione clientxds-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 compila l'esempio di clienthelloworld.

    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 e metodo del servizio da invocare. I parametri del metodo SayHello vengono trasmessi 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 quanto segue. 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 quanto segue. 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 PHP gRPC, esegui quanto segue. 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 Node.js gRPC, esegui quanto segue. 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 visualizzare un output simile al seguente, dove INSTANCE_NAME è il nome dell'istanza VM:

Greeting: Hello world, from INSTANCE_HOSTNAME

In questo modo verifichi che il client gRPC senza proxy si sia connesso correttamente a Cloud Service Mesh e abbia appreso i 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