Configura VM di Compute Engine e servizi gRPC senza proxy
Questa guida mostra come configurare gRPC host delle VM di Compute Engine applicazioni e i componenti di bilanciamento del carico che Cloud Service Mesh richiede.
Prima di seguire le istruzioni di questa guida, consulta Prepararsi a configurare Cloud Service Mesh con servizi gRPC senza proxy
Panoramica
Configurazione di Cloud Service Mesh con le macchine virtuali Compute Engine (VM) e i servizi gRPC senza proxy prevedono quanto segue:
- È in corso la configurazione di un gruppo di istanze gestite che ospita i tuoi backend.
- Configurazione dei backend per l'esecuzione di un server gRPC che restituisce
hello world
in risposta a una richiesta di un cliente. - Configurazione di Cloud Service Mesh mediante il gruppo di istanze gestite e altri componenti di bilanciamento del carico di Google Cloud.
- Verifica del corretto funzionamento del deployment utilizzando un client gRPC senza proxy per inviare il 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
le informazioni al client sui backend associati a hello world
completamente gestito di Google Cloud. Utilizzando queste informazioni, il client gRPC senza proxy invia richieste
il 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, se necessario dal deployment. Questo esempio mostra come svolgere le seguenti operazioni:
- Crea un modello di istanza con un servizio di esempio che gestisce una
hello world
utilizzando il protocollo gRPC. - Configurare un gruppo di istanze gestite utilizzando il modello.
Creazione del modello di istanza
Questa sezione fornisce le istruzioni per creare un modello di istanza. Nella
Ad esempio, esegui il deployment di un servizio gRPC helloworld
esposto sulla porta
50051.
Console
- Nella console Google Cloud, vai alla pagina Modelli di istanza.
- Fai clic su Crea modello istanza.
Compila i campi come segue:
- Nome: grpc-td-vm-template
- Versione 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
In Firewall, seleziona le caselle accanto a Consenti traffico HTTP. e Consenti traffico HTTPS.
Fai clic su Gestione, sicurezza, dischi, networking, single-tenancy.
Nella scheda Gestione, copia il seguente script nel 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
Fai clic su Crea.
gcloud
Creare 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
- Vai alla pagina Gruppi di istanze nella console Google Cloud.
- Fai clic su Crea un gruppo di istanze. Per impostazione predefinita, viene visualizzata la pagina la creazione di un gruppo di istanze gestite.
- Inserisci
grpc-td-mig-us-central1
come nome dell'istanza gestita gruppo di dispositivi e seleziona la zonaus-central1-a
. - In Modello di istanza, seleziona
grpc-td-vm-template
, ovvero che hai creato. - Specifica 2 come numero minimo e massimo di istanze che vuoi da creare nel gruppo.
- Fai clic su Crea.
gcloud
Creare 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. Il nome è la porta su cui il servizio gRPC rimane in ascolto delle richieste. In questo Ad esempio, la porta denominata è 50051.
Console
- Vai alla pagina Gruppi di istanze nella console Google Cloud.
- Fai clic sul nome del gruppo di istanze
grpc-td-mig-us-central1
, che che hai creato. - Fai clic su Modifica gruppo.
- Nel campo Nome porta, inserisci
grpc-helloworld-port
. - Nel campo Numero porta, inserisci
50051
. - 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 le istruzioni per configurare Cloud Service Mesh con 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 corso...
In questa sezione, creerai un servizio di backend globale
con uno schema di bilanciamento del carico di INTERNAL_SELF_MANAGED
e il protocollo GRPC
,
e poi associare il controllo di integrità e il gruppo di istanze al servizio di backend.
In questo esempio, utilizzerai il gruppo di istanze gestite creato
Creazione del gruppo di istanze gestite. Questo gruppo di istanze gestite
esegue il servizio gRPC di esempio. La porta nel flag --port-name
è denominata
che hai creato in Configurazione della porta denominata.
gcloud
Crea il controllo di integrità.
gcloud compute health-checks create grpc grpc-helloworld-health-check \ --use-serving-port
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
Creare 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
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, uno strumento di abbinamento del percorso e una regola host da indirizzare
per il tuo servizio in base al nome host e a un percorso. Nell'esempio che segue
usa helloworld-gce
come nome del servizio. L'applicazione gRPC utilizza questo
nome del servizio nell'URI di destinazione quando ti connetti a questo servizio. Per impostazione predefinita,
il matcher di percorso corrisponde a tutte le richieste di percorso (/*
) per questo host. Crei anche tu
il proxy gRPC di destinazione e la regola di forwarding.
Per ulteriori informazioni, consulta Mappe di regole di routing.
Nell'esempio seguente, la porta 80 è la porta specificata.
gcloud
Crea la mappa URL.
gcloud compute url-maps create grpc-vm-url-map \ --default-service grpc-helloworld-service
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
Crea il proxy gRPC di destinazione.
gcloud compute target-grpc-proxies create grpc-vm-proxy \ --url-map grpc-vm-url-map \ --validate-for-proxyless
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 nel gruppo di istanze gestite per i servizi specificati nella mappa URL.
Verifica della configurazione in corso...
Una volta completato il processo di configurazione, verifica di poter definire una connessione gRPC al servizio Cloud Service Mesh con bilanciamento del carico che creato in precedenza.
Per verificare se il servizio è disponibile, esegui una delle seguenti operazioni:
- Accedi a uno degli host della VM (il backend del servizio gRPC) e verifica che il servizio gRPC è 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 sono segnalati come in stato integro. - Segui le istruzioni riportate di seguito per utilizzare un client gRPC di Compute Engine per verifica.
Verifica del servizio con un'applicazione client gRPC
Nei seguenti esempi, viene utilizzato un client gRPC nella lingua che preferisci
oppure lo strumento grpcurl
per testare il servizio gRPC.
Innanzitutto, 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. 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 sono ottenuti dal server dei metadati
che conosce questi dettagli
sulle istanze VM di Compute Engine. Puoi
fornire manualmente questi valori allo script di supporto utilizzando il metodo
Opzioni -gcp-project-number
e -vpc-network-name
.
Per verificare la configurazione, accedi alla VM client ed esegui questo comando: esempi.
Java
Per verificare il servizio con un client Java gRPC:
Scarica l'ultima versione di gRPC Java, con la patch più recente e crea
xds-hello-world
applicazione client.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
Esegui il client con
world
come nome exds:///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:
Scarica l'ultima versione di gRPC Go con la patch più recente e crea
xds-hello-world
applicazione client.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 .
Esegui il client con
world
come nome exds:///helloworld-gce
come URI del servizio../client "world" xds:///helloworld-gce
C++
Per verificare il servizio con un client gRPC C++:
Scarica l'ultima versione di gRPC C++, con la patch più recente, e crea 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
Esegui il client con "xds:///helloworld-gce" come URI del servizio.
./greeter_client --target=xds:///helloworld-gce
Gripcurl
Per verificare il servizio utilizzando lo strumento grpcurl
:
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
Esegui lo strumento
grpcurl
con "xds:///helloworld-gce" come URI del serviziohelloworld.Greeter/SayHello
come nome del servizio e metodo da richiamare. La I parametri al metodoSayHello
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 quanto segue. Utilizza le funzionalità di 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 le funzionalità di 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 il comando riportato di seguito. Utilizza le funzionalità di 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 le funzionalità di 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 del
Istanza VM:
Greeting: Hello world, from INSTANCE_HOSTNAME
Questo verifica che il client gRPC senza proxy si sia connesso correttamente
Cloud Service Mesh e abbiamo imparato a conoscere i backend per helloworld-gce
utilizzando il resolver del nome xds
. Il client ha inviato una richiesta a uno dei
a backend di servizio senza la necessità di conoscere l'indirizzo IP
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.