Configurer un maillage de services gRPC sans proxy

Ce guide explique comment configurer un maillage de services gRPC sans proxy.

Avant de commencer

Ne créez pas de maillage de services gRPC sans proxy dans un espace de noms dans lequel l'injection side-car automatique Envoy est activée. Pour déterminer si l'injection side-car est activée, exécutez la commande suivante :

kubectl get namespace default --show-labels

Si l'injection side-car automatique est activée, exécutez la commande suivante pour supprimer le libellé :

kubectl label namespace default istio-injection-

Déployer un service gRPC

Dans cette section, vous allez déployer un exemple de service helloworld gRPC. L'exemple de service helloworld est une application de serveur gRPC qui renvoie un message simple en réponse à la requête d'un client gRPC. Le service helloworld expose le service gRPC sur le port 8080 du cluster.

  1. Dans le fichier grpc-td-helloworld.yaml, enregistrez les éléments suivants :

    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. Appliquez le fichier grpc-td-helloworld.yaml :

    kubectl apply -f grpc-td-helloworld.yaml

  3. Vérifiez que le service helloworld est créé :

    kubectl get svc -n default

    Le résultat ressemble à ce qui suit :

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

  4. Vérifiez que le pod de l'application est en cours d'exécution :

    kubectl get pods -n default

  5. Les pods de sortie doivent ressembler à ce qui suit :

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

Configurer un maillage de services gRPC

Dans cette section, vous allez configurer un maillage de services gRPC simple.

  1. Dans le fichier td-grpc-mesh.yaml, enregistrez le fichier manifeste mesh suivant :

    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. Appliquez le fichier manifeste de maillage à gke-1 :

    kubectl apply -f td-grpc-mesh.yaml

    L'exemple TDMesh ne permet d'associer que TDGRPCRoute ressources. Le fichier manifeste définit les types de routes autorisés.

  3. Vérifiez que le nouveau maillage td-grpc-mesh est créé :

    kubectl describe tdmesh td-grpc-mesh -n default

    Le résultat ressemble à ce qui suit :

    ...
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. Dans le fichier helloworld-route.yaml, enregistrez le fichier manifeste suivant :

    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. Appliquez le fichier manifeste helloworld-route.yaml à gke-1 :

    kubectl apply -f helloworld-route.yaml

  6. Vérifiez que la nouvelles ressource GRPCRoute helloworld-route est créée :

    kubectl get tdgrpcroute -n default

Vérifier la configuration

Une fois le processus de configuration terminé, vérifiez que vous pouvez accéder au serveur gRPC helloworld à l'aide d'un client gRPC sans proxy. Ce client se connecte à Traffic Director, obtient des informations sur le service helloworld, puis utilise ces informations pour envoyer du trafic vers les backends du service.

Dans l'exemple suivant, vous utilisez l'outil grpcurl pour vérifier que Traffic Director achemine correctement le trafic dans le maillage. Créez un pod client, puis ouvrez un shell et exécutez les commandes de validation à partir du shell.

Configurer la variable d'environnement et le fichier d'amorçage

  1. Dans un fichier grpc-client.yaml, enregistrez le fichier manifeste de pod suivant :

    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. Appliquez le fichier manifeste de pod dans gke-1 :

    kubectl apply -f grpc-client.yaml

  3. Lorsque le pod est prêt, ouvrez un shell sur le pod client :

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

Vous pouvez utiliser l'outil grpcurl en tant que client gRPC sans proxy. L'outil grpcurl utilise les informations sur les variables d'environnement et d'amorçage pour se connecter à Traffic Director. Il apprend ensuite le service helloworld, qui a été configuré avec Traffic Director.

Pour vérifier votre configuration à l'aide de l'outil grpcurl, procédez comme suit :

  1. Téléchargez et installez l'outil 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. Exécutez l'outil grpcurl avec xds:///helloworld en tant qu'URI de service et helloworld.Greeter/SayHello en tant que nom de service et méthode à appeler. Les paramètres de la méthode SayHello sont transmis à l'aide de l'option -d :

    ./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld helloworld.Greeter/SayHello

    Le résultat ressemble à ce qui suit, où INSTANCE_HOST_NAME correspond au nom d'hôte du pod :

    Greetings: Hello world, from INSTANCE_HOST_NAME

Cela confirme que le client gRPC sans proxy a bien été connecté à Traffic Director et a découvert les backends du service helloworld à l'aide du résolveur de nom xds. Le client a envoyé une requête à l'un des backends du service sans avoir à connaître l'adresse IP ou effectuer la résolution DNS.

Étapes suivantes