Sie sehen sich die Service Mesh-Dokumentation für Version 1.22 an.

Verfügbare Versionen

Cloud Service Mesh
1.22-Archiv
1.21-Archiv
1.20-Archiv
1.19-Archiv
1.18-Archiv

Diese Seite wurde von der Cloud Translation API übersetzt.

Proxylose gRPC-Dienste einrichten

In dieser Anleitung wird gezeigt, wie Sie ein proxyloses gRPC-Service Mesh mit Mesh- und GRPCRoute-Ressourcen einrichten.

Proxylose gRPC-Dienste mit GRPCRoute- und Mesh-Ressourcen — Proxylose gRPC-Dienste mit `GRPCRoute`- und `Mesh`-Ressourcen (zum Vergrößern klicken)

Hinweise

Lesen Sie Einrichtung mit Envoy und proxylosen Arbeitslasten vorbereiten und führen Sie die dort beschriebenen Voraussetzungen aus.

`Mesh`-Ressource konfigurieren

Wenn eine proxylose gRPC-Anwendung eine Verbindung zu einem xds://hostname herstellt, stellt die gRPC-Clientbibliothek eine Verbindung zu Cloud Service Mesh her. Die Clientbibliothek nutzt die Verbindung zum Abrufen der Routingkonfiguration, die zum Weiterleiten von Anfragen für den Hostnamen erforderlich ist.

Notieren Sie sich den Namen der Mesh-Ressource. Dies ist der Schlüssel, den die proxylose gRPC-Anwendung verwendet, um die mit diesem Mesh verknüpfte Konfiguration anzufordern.

Erstellen Sie die Spezifikation Mesh und speichern Sie sie in einer Datei mit dem Namen mesh.yaml.
```
name: grpc-mesh
```

Erstellen Sie die Mesh-Ressource mit der Spezifikation mesh.yaml:

gcloud network-services meshes import grpc-mesh \
  --source=mesh.yaml \
  --location=global

Nachdem die Mesh-Ressource erstellt wurde, kann Cloud Service Mesh die Konfiguration bereitstellen. Da aber noch keine Dienste definiert sind, ist die Konfiguration leer. Im nächsten Abschnitt definieren Sie die Dienste und hängen sie an die Mesh-Ressource an.

gRPC-Server konfigurieren

Zu Demonstrationszwecken erstellen Sie einen Backend-Dienst mit automatisch skalierten VMs in einer verwalteten Instanzgruppe. Die VMs stellen mithilfe des gRPC-Protokolls an Port 50051 den Ausdruck hello world bereit.

Erstellen Sie die Compute Engine-VM-Instanzvorlage mit dem gRPC-Dienst helloworld, der an Port 50051 verfügbar ist:

gcloud compute instance-templates create grpc-td-vm-template \
   --scopes=https://www.googleapis.com/auth/cloud-platform \
   --tags=allow-health-checks \
   --image-family=debian-10 \
   --image-project=debian-cloud \
   --metadata-from-file=startup-script=<(echo '#! /bin/bash
 set -e
 cd /root
 sudo apt-get update -y
 sudo apt-get install -y openjdk-11-jdk-headless
 curl -L https://github.com/grpc/grpc-java/archive/v1.38.0.tar.gz | tar -xz
 cd grpc-java-1.38.0/examples/example-hostname
 ../gradlew --no-daemon installDist
 sudo systemd-run ./build/install/hostname-server/bin/hostname-server')

Erstellen Sie anhand der Vorlage eine verwaltete Instanzgruppe:

gcloud compute instance-groups managed create grpc-td-mig-us-east1 \
  --zone=ZONE \
  --size=2 \
  --template=grpc-td-vm-template

Erstellen Sie den benannten Port für den gRPC-Dienst. Der benannte Port ist der Port, den der gRPC-Dienst auf Anfragen überwacht. Im folgenden Beispiel lautet der benannte Port 50051:
```
gcloud compute instance-groups set-named-ports grpc-td-mig-us-east1 \
 --named-ports=grpc-helloworld-port:50051 \
 --zone=ZONE
```
Erstellen Sie eine gRPC-Systemdiagnose. Die Dienste müssen das gRPC-Systemdiagnoseprotokoll implementieren, damit gRPC-Systemdiagnosen funktionieren. Weitere Informationen finden Sie unter Systemdiagnosen.
```
gcloud compute health-checks create grpc grpc-helloworld-health-check \
  --use-serving-port
```

Erstellen Sie eine Firewallregel, um Systemdiagnoseverbindungen zu Instanzen in Ihrem Netzwerk zuzulassen:

gcloud compute firewall-rules create grpc-vm-allow-health-checks \
  --network=default \
  --action=ALLOW \
  --direction=INGRESS \
  --source-ranges=35.191.0.0/16,130.211.0.0/22 \
  --target-tags allow-health-checks \
  --rules=tcp:50051

Erstellen Sie einen globalen Backend-Dienst mit dem Load-Balancing-Schema INTERNAL_SELF_MANAGED und hängen Sie die Systemdiagnose an den Backend-Dienst an. Der hier angegebene Port wird verwendet, um eine Verbindung zu den VMs in der verwalteten Instanzgruppe herzustellen.
```
gcloud compute backend-services create grpc-helloworld-service \
  --global \
  --load-balancing-scheme=INTERNAL_SELF_MANAGED \
  --protocol=GRPC \
  --port-name=grpc-helloworld-port \
  --health-checks grpc-helloworld-health-check
```

Fügen Sie dem Backend-Dienst die verwaltete Instanzgruppe hinzu.

gcloud compute backend-services add-backend \
  grpc-helloworld-service \
  --instance-group=grpc-td-mig-us-east1 \
  --instance-group-zone=ZONE \
  --global

Die Ressource Mesh und die Dienste sind konfiguriert. Im nächsten Abschnitt richten Sie das Routing ein.

Routing mit `GRPCRoute` einrichten

Folgen Sie der Anleitung unten, um das Routing einzurichten.

Erstellen Sie die Spezifikation GRPCRoute und speichern Sie sie in einer Datei mit dem Namen grpc_route.yaml.

Sie können entweder PROJECT_ID oder PROJECT_NUMBER verwenden.

name: helloworld-grpc-route
hostnames:
- helloworld-gce
meshes:
- projects/PROJECT_NUMBER/locations/global/meshes/grpc-mesh
rules:
- action:
    destinations:
    - serviceName: projects/PROJECT_NUMBER/locations/global/backendServices/grpc-helloworld-service

Erstellen Sie die GrpcRoute-Ressource mit der Spezifikation grpc_route.yaml:

gcloud network-services grpc-routes import helloworld-grpc-route \
  --source=grpc_route.yaml \
  --location=global

Cloud Service Mesh ist jetzt so konfiguriert, dass der Traffic für die in der GRPCRoute-Ressource angegebenen Dienste über Back-Ends in der verwalteten Instanzgruppe verteilt wird.

gRPC-Client erstellen

Sie können die Konfiguration prüfen, indem Sie eine proxylose gRPC-Anwendung instanziieren und mit Cloud Service Mesh verbinden. In der Bootstrap-Datei muss die Anwendung das im Mesh angegebene VPC-Netzwerk angeben.

Nach der Konfiguration kann die Anwendung eine Anfrage an die mit helloworld-gce verknüpften Instanzen oder Endpunkte senden und dazu den Dienst-URI xds:///helloworld-gce verwenden.

In den folgenden Beispielen verwenden Sie das grpcurl-Tool, um den gRPC-Dienst zu testen.

Erstellen Sie eine Client-VM.

gcloud compute instances create grpc-client \
  --zone=ZONE\
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --metadata-from-file=startup-script=<(echo '#! /bin/bash
set -e
export GRPC_XDS_BOOTSTRAP=/run/td-grpc-bootstrap.json
echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh
curl -L https://storage.googleapis.com/traffic-director/td-grpc-bootstrap-0.16.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.16.0/td-grpc-bootstrap --config-mesh-experimental grpc-mesh | tee $GRPC_XDS_BOOTSTRAP')

Bootstrap-Datei einrichten

Die Clientanwendung muss eine Bootstrap-Konfigurationsdatei haben. Das Startskript im vorherigen Abschnitt legt die Umgebungsvariable GRPC_XDS_BOOTSTRAP fest und verwendet ein Hilfsskript, um die Bootstrap-Datei zu erstellen. Die Werte für TRAFFICDIRECTOR_GCP_PROJECT_NUMBER und Zone in der erstellten Bootstrap-Datei werden vom Metadatenserver abgerufen, der diese Details zu Ihren VM-Instanzen kennt. Sie können diese Werte mithilfe der Option --gcp-project-number manuell im Hilfsskript angeben. Sie müssen mit der Option --config-mesh-experimental einen Mesh-Namen angeben, der mit der Ressource Mesh übereinstimmt.

Melden Sie sich zur Überprüfung der Konfiguration bei der Client-VM an und führen Sie folgende Aufgaben aus.

Stellen Sie eine SSH-Verbindung zur Client-VM her.
```
gcloud compute ssh grpc-client
```

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

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-gce 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-gce helloworld.Greeter/SayHello
```

Die Ausgabe sollte in etwa so aussehen, wobei INSTANCE_HOSTNAME der Name der VM-Instanz ist:

   Greeting: Hello world, from INSTANCE_HOSTNAME

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

Nächste Schritte

Informationen zum Auflisten von Routenressourcen, die mit einer Mesh- oder Gateway-Ressource verknüpft sind, finden Sie unter Route-Ressourcen auflisten. Diese Feature befindet sich im Vorschaumodus.