Configura i servizi gRPC senza proxy

Nota: questa guida supporta solo Cloud Service Mesh con le Google Cloud API e non supporta le API Istio. Per saperne di più, consulta la panoramica di Cloud Service Mesh. .

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

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

Prima di iniziare

Assicurati di leggere Preparati alla configurazione con Envoy e workload senza proxy e di completare i prerequisiti descritti in questo documento.

Configura la risorsa Mesh

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

Assicurati di annotare il nome della risorsa Mesh, che è la chiave utilizzata dall'applicazione gRPC senza proxy per richiedere la configurazione associata a questo mesh.

1. Crea la specifica Mesh e salvala in un file denominato mesh.yaml.

   name: grpc-mesh

2. 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, Cloud Service Mesh è pronto a pubblicare la configurazione, ma poiché non sono ancora stati definiti servizi, la configurazione è vuota. Nella sezione successiva, definisci i servizi e li colleghi alla risorsa Mesh.

Configura il server gRPC

A scopo dimostrativo, crei 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.

1. Crea un file di configurazione cloud-init.yaml che dichiara un servizio systemd per eseguire il container helloworld sulla porta 50051:

   #cloud-config
   write_files:
   - path: /etc/systemd/system/grpc-server.service
     permissions: '0644'
     owner: root
     content: |
       [Unit]
       Description=gRPC Server Container
       After=network-online.target docker.service
       Wants=network-online.target
       Requires=docker.service
   
       [Service]
       TimeoutStartSec=0
       Restart=always
       ExecStartPre=-/usr/bin/docker stop %n
       ExecStartPre=-/usr/bin/docker rm %n
       ExecStart=/usr/bin/docker run --rm --name %n --net=host grpc/java-example-hostname:1.83.1
       ExecStop=/usr/bin/docker stop %n
   
   runcmd:
   - iptables -A INPUT -p tcp --dport 50051 -j ACCEPT
   - systemctl daemon-reload
   - systemctl start --no-block grpc-server.service
   

2. Crea il modello di istanza VM di Compute Engine utilizzando Container-Optimized OS (cos-stable):

   gcloud compute instance-templates create grpc-td-vm-template \
     --image-project=cos-cloud \
     --image-family=cos-stable \
     --metadata-from-file=user-data=cloud-init.yaml \
     --tags=allow-health-checks \
     --scopes=cloud-platform

3. Crea un gruppo di istanze gestite basato sul modello:

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

4. 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 \
    --named-ports=grpc-helloworld-port:50051 \
    --zone=ZONE

5. Crea un controllo di integrità gRPC. I servizi devono implementare il protocollo di controllo di integrità gRPC in modo che i controlli di integrità gRPC funzionino correttamente. Per saperne di più, consulta Controlli di integrità.

   gcloud compute health-checks create grpc grpc-helloworld-health-check \
     --use-serving-port

6. Crea una regola firewall per consentire le connessioni di controllo di integrità alle istanze nella 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

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

8. Aggiungi il gruppo di istanze gestite al servizio di backend.

   gcloud compute backend-services add-backend grpc-helloworld-service \
     --instance-group=grpc-td-mig \
     --instance-group-zone=ZONE \
     --global

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

Configura il routing con GRPCRoute

Utilizza le seguenti istruzioni per configurare il routing.

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

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

Cloud Service Mesh è ora configurato per bilanciare il carico del traffico per i servizi specificati nella risorsa GRPCRoute tra i backend nel gruppo di istanze gestite.

Crea un client gRPC

Puoi verificare la configurazione creando un'istanza di un'applicazione gRPC senza proxy e collegandola a Cloud Service Mesh. 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'xds:///helloworld-gce URI del servizio.

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

1. Crea una VM client.

   gcloud compute instances create grpc-client \
     --zone=ZONE\
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --image-family=debian-12 \
     --image-project=debian-cloud \
     --metadata-from-file=startup-script=<(echo '#!/bin/bash
   set -ex
   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.19.0.tar.gz | tar -xz
   ./td-grpc-bootstrap-0.19.0/td-grpc-bootstrap --config-mesh=grpc-mesh | tee $GRPC_XDS_BOOTSTRAP')

Configura il file di bootstrap

L'applicazione client deve avere 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 e della 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 helper manualmente utilizzando l'opzione --gcp-project-number. Devi fornire un nome mesh corrispondente alla risorsa Mesh utilizzando l'opzione --config-mesh.

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

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

1. Accedi alla VM client tramite SSH.

   gcloud compute ssh grpc-client --zone=ZONE

2. Scarica e installa lo strumento grpcurl.

   curl -L https://github.com/fullstorydev/grpcurl/releases/download/v1.9.2/grpcurl_1.9.2_linux_x86_64.tar.gz | tar -xz

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

Dovresti vedere un output simile al seguente, dove INSTANCE_HOSTNAME è il nome di una delle istanze VM del server gRPC:

   {
     "message": "Hello world, from INSTANCE_HOSTNAME"
   }
   

L'output verifica 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

• Per informazioni su come elencare le risorse di route associate a una risorsa Mesh o Gateway, consulta Elenca le risorse Route.