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 den Artikel Einrichtung mit Envoy und proxylosen Arbeitslasten vorbereiten und erfüllen Sie die beschriebenen Voraussetzungen. in diesem Dokument.

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 Ressource Mesh. Dies ist der Schlüssel, die proxylose gRPC-Anwendung verwendet, um die dieses Mesh-Netzwerks.

  1. Erstellen Sie die Spezifikation Mesh und speichern Sie sie in einer Datei mit dem Namen mesh.yaml.

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

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

Nachdem die Ressource Mesh erstellt wurde, kann das Cloud Service Mesh das Konfiguration ist, aber da noch keine Dienste definiert sind, ist 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.

  1. 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')
     
  2. 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
    
  3. 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
    
  4. 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
    
  5. 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
    
  6. 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
    
  7. 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.

  1. 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
    
  2. 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.

  1. 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.

  1. Stellen Sie eine SSH-Verbindung zur Client-VM her.

    gcloud compute ssh grpc-client
    
  2. 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
    
  3. 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.