Anthos Service Mesh und Traffic Director heißen jetzt Cloud Service Mesh. Weitere Informationen finden Sie in der Übersicht zu Cloud Service Mesh.

Diese Seite wurde von der Cloud Translation API übersetzt.

Proxyloses gRPC-Service-Mesh einrichten

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

Die Konfiguration wird für Vorschaukunden unterstützt, wir raten jedoch davon ab, für neue Cloud Service Mesh-Nutzer. Weitere Informationen finden Sie unter Cloud Service Mesh – Übersicht.

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.

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

Wenden Sie die Datei grpc-td-helloworld.yaml an:
```
kubectl apply -f grpc-td-helloworld.yaml
```

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

kubectl get svc -n default

Die Ausgabe sieht etwa so aus:

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

Prüfen Sie, ob der Anwendungs-Pod ausgeführt wird:
```
kubectl get pods -n default
```

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.

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

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.

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

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

Wenden Sie das helloworld-route.yaml-Manifest auf gke-1 an:
```
kubectl apply -f helloworld-route.yaml
```
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 Cloud Service Mesh 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 der Cloud Service Mesh leitet Traffic korrekt im Mesh-Netzwerk weiter. Sie erstellen einen Client-Pod, öffnen eine Shell und führen dann die Überprüfungsbefehle in der Shell aus.

Umgebungsvariable und Bootstrap-Datei einrichten

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.16.0
    imagePullPolicy: IfNotPresent
    name: grpc-td-init
    volumeMounts:
    - name: grpc-td-conf
      mountPath: /tmp/bootstrap/
  volumes:
  - name: grpc-td-conf
    emptyDir:
      medium: Memory

Wenden Sie das Pod-Manifest in gke-1 an:
```
kubectl apply -f grpc-client.yaml
```
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 nutzt Umgebungsvariable und Bootstrap-Informationen für die Verbindung Cloud Service Mesh. Das Tool lernt dann den Dienst helloworld, der mit Cloud Service Mesh konfiguriert.

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

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

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

Die Ausgabe überprüft, ob der proxylose gRPC-Client erfolgreich eine Verbindung zu Cloud Service Mesh und Informationen zu den Back-Ends für den Dienst helloworld mit dem xds Name Resolver. 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

Fehlerbehebung für die Bereitstellung