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 Cloud Service Mesh.

Prima di seguire le istruzioni riportate in questa guida, consulta Preparati a configurare Cloud Service Mesh con i servizi gRPC senza proxy

Panoramica

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

1. Configurazione di un gruppo di istanze gestite che ospita i 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 Cloud Service Mesh utilizzando il gruppo di istanze gestite e altri Google Cloud componenti di bilanciamento del carico.
4. Verifica del corretto funzionamento del deployment 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, Cloud Service Mesh 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 Cloud Service Mesh

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

• Crea un template di istanza con un servizio di esempio che eroga 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 la creazione di un template di istanza. Nell'esempio, esegui il deployment di un servizio gRPC helloworld esposto sulla porta 50051.

Console

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

   Vai alla pagina Template di istanza

2. Fai clic su Crea template di 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 di Compute Engine
   • Ambiti di accesso: Consenti l'accesso completo a tutte le Google Cloud API

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 template 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 Google Cloud console.

   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, 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 Google Cloud console.

   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 Google Cloud componenti di bilanciamento del carico

Questa sezione fornisce istruzioni per la configurazione di Cloud Service Mesh con Google Cloud i componenti di bilanciamento del carico 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 INTERNAL_SELF_MANAGED e il protocollo GRPC, quindi assocerai il controllo di integrità e il gruppo di istanze al servizio di backend. In questo esempio, utilizzerai il gruppo di istanze gestite creato in Creazione del gruppo di istanze gestite. Questo gruppo di istanze gestite esegue il servizio gRPC di esempio. La porta nel flag --port-name è la porta denominata creata 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 della regola di forwarding

In questa sezione creerai una mappa URL, un matcher di percorso e una regola host per indirizzare 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 quando si connette a questo servizio. Per impostazione predefinita, il matcher di percorso corrisponde a tutte le richieste di percorso (/*) per questo host. Creerai anche il proxy gRPC di destinazione e la regola di forwarding.

Per saperne di più, consulta Mappe di 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 di 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 con bilanciamento del carico di Cloud Service Mesh creato in precedenza.

Per verificare che il servizio sia disponibile, procedi in uno dei seguenti modi:

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

Negli esempi seguenti, utilizzerai un client gRPC nel linguaggio di tua scelta 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.19.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.19.0/td-grpc-bootstrap | tee $GRPC_XDS_BOOTSTRAP')

Configurazione della variabile di ambiente e del file di bootstrap

Nota: in base alle nostre norme, invitiamo gli utenti a verificare ogni anno la presenza di aggiornamenti del generatore di bootstrap gRPC TD.

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 helper per generare il file di bootstrap. I valori di TRAFFICDIRECTOR_GCP_PROJECT_NUMBER, TRAFFICDIRECTOR_NETWORK_NAME e zone nel file di bootstrap generato vengono ottenuti dal server dei metadati che conosce questi dettagli sulle istanze VM di Compute Engine. Puoi fornire questi valori allo script helper manualmente utilizzando le opzioni -gcp-project-number e -vpc-network-name.

Nota: l'aggiunta della generazione di bootstrap allo script di inizializzazione della VM garantisce la creazione di un file di bootstrap aggiornato ogni volta che la VM viene riavviata.

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

Java

Per verificare il servizio con un client gRPC Java:

1. Scarica l'ultima versione di gRPC Java, con la patch e la build più recenti, 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
   

Vai

Per verificare il servizio con un client gRPC Go:

1. Scarica l'ultima versione 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 l'ultima versione di gRPC C++, con la patch più recente, e crea l'esempio di 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 del 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 gRPC Python, esegui quanto segue. Utilizza l'ultima versione 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 gRPC Ruby, esegui quanto segue. Utilizza l'ultima versione 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 quanto segue. Utilizza l'ultima versione 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 quanto segue. Utilizza l'ultima versione 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 di 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

• Scopri di più sulla gestione avanzata del traffico.
• Scopri come configurare l'osservabilità.
• Scopri come risolvere i problemi dei deployment di Cloud Service Mesh senza proxy.