Configura servizi gRPC senza proxy

Questa guida illustra come configurare un mesh di servizi gRPC proxyless con le risorse Mesh e GRPCRoute.

Servizi gRPC senza proxy con risorse GRPCRoute e mesh — Servizi gRPC senza proxy con risorse `GRPCRoute` e `Mesh` (fai clic per ingrandire)

Prima di iniziare

Assicurati che il deployment soddisfi i prerequisiti descritti nelle seguenti guide:

Configurazione della risorsa `Mesh`

Quando un'applicazione gRPC senza proxy si connette a un xds://hostname, la libreria client gRPC stabilisce una connessione a Traffic Director. La libreria client utilizza la connessione per ottenere la configurazione di routing necessaria per il routing delle richieste per il nome host.

Assicurati di prendere nota del nome della risorsa mesh, ovvero la chiave utilizzata dall'applicazione gRPC proxyless per richiedere la configurazione associata al mesh.

Crea la specifica Mesh e salvala in un file denominato mesh.yaml.
```
name: grpc-mesh
```

Crea la risorsa Mesh utilizzando la specifica mesh.yaml:

gcloud network-services meshes import grpc-mesh \
  --source=mesh.yaml \
  --location=global

Dopo aver creato la risorsa Mesh, Traffic Director è pronto per gestire la configurazione, ma poiché non sono ancora stati definiti servizi, la configurazione è vuota. Nella sezione successiva definirai i servizi e li collegherai alla risorsa Mesh.

Configura il server gRPC

A fini dimostrativi, puoi creare un servizio di backend con VM con scalabilità automatica in un gruppo di istanze gestite. Le VM pubblicano la frase hello world utilizzando il protocollo gRPC sulla porta 50051.

Crea il modello di istanza VM di Compute Engine con un servizio gRPC helloworld esposto sulla porta 50051:

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.38.0.tar.gz | tar -xz
 cd grpc-java-1.38.0/examples/example-hostname
 ../gradlew --no-daemon installDist
 sudo systemd-run ./build/install/hostname-server/bin/hostname-server')

Crea un gruppo di istanze gestite basato sul modello:

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

Crea la porta denominata per il servizio gRPC. La porta denominata è la porta su cui il servizio gRPC rimane in ascolto delle richieste. Nell'esempio seguente, la porta denominata è 50051:
```
gcloud compute instance-groups set-named-ports grpc-td-mig-us-east1 \
 --named-ports=grpc-helloworld-port:50051 \
 --zone=ZONE
```
Creare un controllo di integrità gRPC. I servizi devono implementare il protocollo per il controllo di integrità gRPC in modo che i controlli di integrità gRPC funzionino correttamente. Per ulteriori informazioni, consulta la sezione Controlli di integrità.
```
gcloud compute health-checks create grpc grpc-helloworld-health-check \
  --use-serving-port
```

Crea una regola firewall per consentire le connessioni per il controllo di integrità alle istanze della tua rete:

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 un servizio di backend globale con uno schema di bilanciamento del carico INTERNAL_SELF_MANAGED e aggiungi il controllo di integrità al servizio di backend. La porta specificata qui viene utilizzata per la connessione alle VM nel gruppo di istanze gestite.
```
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-east1 \
  --instance-group-zone=ZONE \
  --global

La risorsa e i servizi Mesh sono configurati. Nella sezione successiva, configurerai il routing.

Configurazione del routing con `GRPCRoute`

La risorsa Mesh e il server gRPC sono configurati. Utilizza le seguenti istruzioni per configurare il routing.

Crea la specifica GRPCRoute e salvala in un file denominato grpc_route.yaml.

Puoi utilizzare PROJECT_ID o PROJECT_NUMBER.

name: helloworld-grpc-route
hostnames:
- helloworld-gce
meshes:
- projects/PROJECT_NUMBER/locations/global/meshes/grpc-mesh
rules:
- action:
    destinations:
    - serviceName: projects/PROJECT_NUMBER/locations/global/backendServices/grpc-helloworld-service

Crea la risorsa GrpcRoute utilizzando la specifica grpc_route.yaml:

gcloud network-services grpc-routes import helloworld-grpc-route \
  --source=grpc_route.yaml \
  --location=global

Traffic Director è ora configurato per bilanciare il carico del traffico per i servizi specificati nella risorsa GRPCRoute nei backend del gruppo di istanze gestite.

Crea un client gRPC

Puoi verificare la configurazione creando un'istanza di un'applicazione gRPC proxyless e connettendola a Traffic Director. Nel file di bootstrap, l'applicazione deve specificare la rete VPC indicata nel mesh.

Una volta configurata, l'applicazione può inviare una richiesta alle istanze o agli endpoint associati a helloworld-gce utilizzando l'URI di servizio xds:///helloworld-gce.

Nei seguenti esempi, utilizzi lo strumento grpcurl per testare il servizio gRPC.

Creare una VM client.

gcloud compute instances create grpc-client \
  --zone=ZONE\
  --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
echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh
curl -L https://storage.googleapis.com/traffic-director/td-grpc-bootstrap-0.14.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.14.0/td-grpc-bootstrap --config-mesh-experimental grpc-mesh | tee $GRPC_XDS_BOOTSTRAP')

Configura il file di bootstrap

L'applicazione client deve avere un file di configurazione 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 e la zona nel file di bootstrap generato vengono ottenuti dal server dei metadati che conosce questi dettagli sulle istanze VM. Puoi fornire questi valori allo script di supporto manualmente utilizzando l'opzione --gcp-project-number. Devi fornire un nome mesh corrispondente alla risorsa Mesh utilizzando l'opzione --config-mesh-experimental.

Per verificare la configurazione, accedi alla VM client ed esegui quanto segue.

SSH alla VM client.
```
gcloud compute ssh grpc-client
```

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

Dovresti vedere un output simile al seguente, dove INSTANCE_HOSTNAME è il nome dell'istanza VM:

   Greeting: Hello world, from INSTANCE_HOSTNAME

L'output verifica che il client gRPC proxyless si sia connesso correttamente a Traffic Director e abbia 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.