Proxyloses gRPC-Service-Mesh einrichten

In dieser Anleitung wird beschrieben, wie Sie ein proxyloses gRPC-Service-Mesh konfigurieren.

Hinweise

Erstellen Sie kein proxyloses gRPC-Service-Mesh in einem Namespace, in dem die automatische Envoy-Sidecar-Injektion aktiviert ist. Führen Sie den folgenden Befehl aus, um festzustellen, ob die Sidecar-Injektion aktiviert ist:

kubectl get namespace default --show-labels

Wenn die automatische Sidecar-Injektion aktiviert ist, entfernen Sie das Label mit diesem Befehl:

kubectl label namespace default istio-injection-

gRPC-Dienst bereitstellen

In diesem Abschnitt stellen Sie einen gRPC-helloworld-Beispieldienst bereit. Der GKE-helloworld-Beispieldienst ist eine gRPC-Serveranwendung, die als Antwort auf die Anfrage eines gRPC-Clients eine einfache Nachricht zurückgibt. Der helloworld-Dienst stellt den gRPC-Dienst an Port 8080 im Cluster bereit.

  1. Speichern Sie in der Datei grpc-td-helloworld.yaml Folgendes:

    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. Wenden Sie die Datei grpc-td-helloworld.yaml an:

    kubectl apply -f grpc-td-helloworld.yaml

  3. Prüfen Sie, ob der neue helloworld-Dienst erstellt wurde:

    kubectl get svc -n default

    Die Ausgabe sieht in etwa so aus:

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

  4. Prüfen Sie, ob der Anwendungs-Pod ausgeführt wird:

    kubectl get pods -n default

  5. Die Ausgabe-Pods sollten in etwa so aussehen:

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

gRPC-Service-Mesh konfigurieren

In diesem Abschnitt konfigurieren Sie ein einfaches gRPC-Service-Mesh.

  1. Speichern Sie in der Datei td-grpc-mesh.yaml das folgende mesh-Manifest:

    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. Wenden Sie das Mesh-Netzwerkmanifest auf gke-1 an:

    kubectl apply -f td-grpc-mesh.yaml

    An das Beispiel-TDMesh können nur TDGRPCRoute-Ressourcen angehängt werden. Das Manifest definiert, welche Routentypen zulässig sind.

  3. Prüfen Sie, ob das neue td-grpc-mesh-Mesh-Netzwerk erstellt wurde:

    kubectl describe tdmesh td-grpc-mesh -n default

    Die Ausgabe sieht etwa so aus:

    ...
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. Speichern Sie in der Datei helloworld-route.yaml das folgende 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. Wenden Sie das helloworld-route.yaml-Manifest auf gke-1 an:

    kubectl apply -f helloworld-route.yaml

  6. Prüfen Sie, ob die neue helloworld-route-GRPCRoute--Ressource erstellt wurde:

    kubectl get tdgrpcroute -n default

Konfiguration prüfen

Prüfen Sie nach Abschluss der Konfiguration, ob Sie den gRPC-Server helloworld mit einem proxylosen gRPC-Client erreichen können. Der Client stellt eine Verbindung zu Traffic Director her, erhält Informationen zum helloworld-Dienst und verwendet diese Informationen, um Traffic an die Back-Ends des Dienstes zu senden.

Im folgenden Beispiel prüfen Sie mit dem grpcurl-Tool, ob Traffic Director Traffic im Mesh-Netzwerk korrekt weiterleitet. Sie erstellen einen Client-Pod, öffnen eine Shell und führen dann die Überprüfungsbefehle in der Shell aus.

Umgebungsvariable und Bootstrap-Datei einrichten

  1. Speichern Sie in der Datei grpc-client.yaml das folgende Pod-Manifest:

    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. Wenden Sie das Pod-Manifest in gke-1 an:

    kubectl apply -f grpc-client.yaml

  3. Wenn der Pod bereit ist, öffnen Sie eine Shell für den Client-Pod:

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

Sie können das grpcurl-Tool als proxylosen gRPC-Client verwenden. Das grpcurl-Tool verwendet die Umgebungsvariable und die Bootstrap-Informationen, um eine Verbindung zu Traffic Director herzustellen. Das Tool erhält dann Informationen zum helloworld-Dienst, der mit Traffic Director konfiguriert wurde.

So prüfen Sie Ihre Konfiguration mit dem grpcurl-Tool:

  1. Laden Sie das grpcurl-Tool herunter und installieren Sie es:

    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. Führen Sie das grpcurl-Tool mit xds:///helloworld als Dienst-URI und helloworld.Greeter/SayHello als Dienstnamen und aufzurufende Methode aus. Die Parameter für die Methode SayHello werden mit der Option -d übergeben.

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

    Die Ausgabe sieht in etwa so aus, wobei INSTANCE_HOST_NAME der Hostname des Pods ist:

    Greetings: Hello world, from INSTANCE_HOST_NAME

Durch die Ausgabe wird bestätigt, dass der proxylose gRPC-Client erfolgreich mit Traffic Director verbunden wurde und Informationen zu den Back-Ends für den helloworld-Dienst über den xds-Name-Resolver erhalten hat. Der Client hat eine Anfrage an eines der Back-Ends des Dienstes gesendet, ohne die IP-Adresse kennen oder ein DNS-Auflösung durchführen zu müssen.

Nächste Schritte