Anthos Service Mesh e Traffic Director sono ora Cloud Service Mesh. Per saperne di più, consulta la panoramica di Cloud Service Mesh.

Questa pagina è stata tradotta dall'API Cloud Translation.

Configura VM di Compute Engine e servizi gRPC senza proxy

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

Configura un gruppo di istanze gestite che ospiti i tuoi backend.
Configurazione dei backend per eseguire un server gRPC che restituisce hello world in risposta a una richiesta di un client.
Configurazione di Cloud Service Mesh mediante il gruppo di istanze gestite 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 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, se necessario dal 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

Nella console Google Cloud, vai alla pagina Modelli di istanza.
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 crei 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.
Vai alla pagina Gruppi di istanze
Fai clic su Crea un gruppo di istanze. Per impostazione predefinita, viene visualizzata la pagina per la creazione di un gruppo di istanze gestite.
Inserisci grpc-td-mig-us-central1 come nome del gruppo di istanze gestite e seleziona la zona us-central1-a.
In Modello di istanza, seleziona grpc-td-vm-template, ovvero il modello di istanza che hai creato.
Specifica 2 come numero minimo e massimo di istanze da creare nel gruppo.
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. Il nome è la porta su cui il servizio gRPC rimane in ascolto delle richieste. In questo esempio, la porta denominata è la porta 50051.

Console

Vai alla pagina Gruppi di istanze nella console Google Cloud.
Vai alla pagina Gruppi di istanze
Fai clic sul nome del gruppo di istanze grpc-td-mig-us-central1 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 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 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 è 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

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

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 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 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 inoltro.

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

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 che il servizio sia disponibile:

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

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

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 e xds:///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
```

grpcurl

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 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 il comando riportato di seguito. 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 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 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.