Configura un mesh di servizi gRPC proxyless

Anteprima

Questo prodotto o funzionalità è soggetto ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici del servizio. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Questa guida illustra come configurare un mesh di servizi gRPC proxyless.

Prima di iniziare

Non creare un mesh di servizi gRPC proxyless in uno spazio dei nomi in cui è abilitata l'inserimento automatico del sidecar di Envoy. Per determinare se l'inserimento di sidecar è abilitato, esegui questo comando:

kubectl get namespace default --show-labels

Se l'inserimento automatico collaterale è abilitato, esegui questo comando per rimuovere l'etichetta:

kubectl label namespace default istio-injection-

Esegui il deployment di un servizio gRPC

In questa sezione eseguirai il deployment di un servizio di esempio helloworld gRPC. Il servizio di esempio helloworld è un'applicazione server gRPC che restituisce un semplice messaggio in risposta alla richiesta di un client gRPC. Il servizio helloworld espone il servizio gRPC sulla porta 8080 del cluster.

1. Nel file grpc-td-helloworld.yaml, salva quanto segue:

   apiVersion: v1
   kind: Service
   metadata:
     name: helloworld
     namespace: default
   spec:
     ports:
     - port: 8080
       name: helloworld
       protocol: TCP
       targetPort: 50051
     selector:
       run: app1
     type: ClusterIP
   
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     labels:
       run: app1
     name: app1
     namespace: default
   spec:
     selector:
       matchLabels:
         run: app1
     replicas: 2
     template:
       metadata:
         labels:
           run: app1
         annotations:
           sidecar.istio.io/inject: "false"
       spec:
         containers:
         - image: grpc/java-example-hostname:1.37.0
           name: app1
           ports:
           - protocol: TCP
             containerPort: 50051
   

2. Applica il file grpc-td-helloworld.yaml:

   kubectl apply -f grpc-td-helloworld.yaml
   

3. Verifica che il nuovo servizio helloworld sia stato creato:

   kubectl get svc -n default
   

   L'output è simile al seguente:

   NAME           TYPE        CLUSTER-IP   EXTERNAL-IP   PORT (S)   AGE
   helloworld     ClusterIP   10.71.9.71   <none>        8080/TCP  41m
   [..skip..]
   

4. Verifica che il pod dell'applicazione sia in esecuzione:

   kubectl get pods -n default
   

5. I pod di output dovrebbero essere simili ai seguenti:

   NAME                        READY     STATUS    RESTARTS   AGE
   app1-6db459dcb9-zvfg2   1/1       Running   0          6m
   app1-6db459dcb9-hlvhj   1/1       Running   0          6m
   [..skip..]
   

Configura un mesh di servizi gRPC

In questa sezione configurerai un mesh di servizi gRPC semplice.

1. Nel file td-grpc-mesh.yaml, salva il seguente file manifest di mesh:

   kind: TDMesh
   apiVersion: net.gke.io/v1alpha1
   metadata:
     name: td-grpc-mesh
     namespace: default
   spec:
     gatewayClassName: gke-td
     allowedRoutes:
       namespaces:
         from: All
       kinds:
       - group: net.gke.io
         kind: TDGRPCRoute
   

2. Applica il manifest mesh a gke-1:

   kubectl apply -f td-grpc-mesh.yaml
   

   L'esempio TDMesh consente di collegare solo TDGRPCRoute risorse. Il file manifest definisce i tipi di route consentiti.

3. Verifica che il nuovo mesh td-grpc-mesh sia stato creato:

   kubectl describe tdmesh td-grpc-mesh -n default
   

   L'output è simile al seguente:

   ...
   Status:
     Conditions:
       Last Transition Time:  2022-04-14T22:22:09Z
       Message:
       Reason:                MeshReady
       Status:                True
       Type:                  Ready
       Last Transition Time:  2022-04-14T22:21:41Z
       Message:
       Reason:                Scheduled
       Status:                True
       Type:                  Scheduled
   Events:
     Type    Reason  Age   From                Message
     ----    ------  ----  ----                -------
     Normal  ADD     79s   mc-mesh-controller  Processing mesh default/td-grpc-mesh
     Normal  UPDATE  79s   mc-mesh-controller  Processing mesh default/td-grpc-mesh
     Normal  SYNC    50s   mc-mesh-controller  SYNC on default/td-grpc-mesh was a success
   

4. Nel file helloworld-route.yaml, salva il seguente manifest:

   kind: TDGRPCRoute
   apiVersion: net.gke.io/v1alpha1
   metadata:
     name: helloworld-route
     namespace: default
   spec:
     parentRefs:
     - name: td-grpc-mesh
       namespace: default
       group: net.gke.io
       kind: TDMesh
     hostnames:
     - helloworld
     rules:
     - backendRefs:
       - name: helloworld
         port: 8080
         namespace: default
   

5. Applica il file manifest helloworld-route.yaml a gke-1:

   kubectl apply -f helloworld-route.yaml
   

6. Verifica che la nuova risorsa helloworld-route GRPCRoute sia stata creata:

   kubectl get tdgrpcroute -n default
   

Verificare la configurazione

Al termine del processo di configurazione, verifica di poter raggiungere il server gRPC helloworld utilizzando un client gRPC proxy. Questo client si connette a Traffic Director, ottiene informazioni sul servizio helloworld e utilizza tali informazioni per inviare traffico ai backend del servizio.

Nell'esempio seguente, utilizzi lo strumento grpcurl per verificare che Traffic Director instrada correttamente il traffico nel mesh. Crea un pod client, quindi apri una shell ed esegui i comandi di verifica dalla shell.

Configura la variabile di ambiente e il file di bootstrap

1. In un file grpc-client.yaml, salva il seguente manifest del pod:

   apiVersion: v1
   kind: Pod
   metadata:
     name: static-sleeper
     namespace: default
     annotations:
       sidecar.istio.io/inject: "false"
   spec:
     containers:
     - image: curlimages/curl:7.82.0
       imagePullPolicy: IfNotPresent
       name: sleeper
       command:
       - sleep
       - 365d
       env:
       - name: GRPC_XDS_BOOTSTRAP
         value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
       volumeMounts:
       - name: grpc-td-conf
         mountPath: /tmp/grpc-xds/
     initContainers:
     - args:
       - --config-mesh-experimental
       - "gketd-td-grpc-mesh"
       - --output
       - "/tmp/bootstrap/td-grpc-bootstrap.json"
       image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.14.0
       imagePullPolicy: IfNotPresent
       name: grpc-td-init
       volumeMounts:
       - name: grpc-td-conf
         mountPath: /tmp/bootstrap/
     volumes:
     - name: grpc-td-conf
       emptyDir:
         medium: Memory
   

2. Applica il manifest del pod in gke-1:

   kubectl apply -f grpc-client.yaml
   

3. Quando il pod è pronto, apri una shell sul pod client:

   kubectl exec -it static-sleeper -- /bin/sh
   

Puoi utilizzare lo strumento grpcurl come client gRPC senza proxy. Lo strumento grpcurl utilizza informazioni variabile di ambiente e di bootstrap per connettersi a Traffic Director. Lo strumento apprende quindi il servizio helloworld, che è stato configurato con Traffic Director.

Per verificare la configurazione utilizzando lo strumento grpcurl:

1. Scarica e installa lo strumento grpcurl:

   cd /home/curl_user
   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 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 helloworld.Greeter/SayHello
   

   L'output è simile al seguente, dove INSTANCE_HOST_NAME è il nome host del pod:

   Greetings: Hello world, from INSTANCE_HOST_NAME
   

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

Passaggi successivi

• Scopri come risolvere i problemi relativi al deployment.