Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Configura un mesh di servizi gRPC proxyless

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 sidecar Envoy. Per determinare se l'inserimento sidecar è abilitato, esegui il comando seguente:

kubectl get namespace default --show-labels

Se è attivata l'inserimento automatico sidecar, 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 gRPC helloworld. Il servizio di esempio helloworld è un'applicazione server gRPC che restituisce un semplice messaggio in risposta a una richiesta del client gRPC. Il servizio helloworld espone il servizio gRPC sulla porta 8080 nel 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 sia creato il nuovo servizio helloworld:

    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 devono 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 manifest 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 del 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 percorso consentiti.

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

    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 manifest helloworld-route.yaml a gke-1:

    kubectl apply -f helloworld-route.yaml
    
  6. Verifica che sia creata la nuova risorsa GRPCRoute di helloworld-route:

    kubectl get tdgrpcroute -n default
    

Verificare la configurazione

Al termine della procedura di configurazione, verifica di poter raggiungere il server gRPC helloworld utilizzando un client gRPC proxyless. Questo client si connette al Traffic Director, ottiene informazioni sul servizio helloworld e utilizza queste informazioni per inviare traffico ai backend del servizio.

Nel seguente esempio, utilizzi lo strumento grpcurl per verificare che Traffic Director stia indirizzando 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 al pod client:

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

Puoi utilizzare lo strumento grpcurl come client gRPC proxyless. Lo strumento grpcurl utilizza informazioni sulle variabili 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 e metodo di servizio 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, in cui INSTANCE_HOST_NAME è il nome host del pod:

    Greetings: Hello world, from INSTANCE_HOST_NAME
    

L'output verifica che il client gRPC proxyless si è connesso correttamente a Traffic Director e ha appreso i backend per il servizio helloworld 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