Compute Engine-VMs und proxyfreie gRPC-Dienste einrichten

In dieser Anleitung erfahren Sie, wie Sie Compute Engine-VM-Hosts, gRPC-Anwendungen und die Load-Balancing-Komponenten konfigurieren, die Cloud Service Mesh benötigt.

Bevor Sie der Anleitung in diesem Leitfaden folgen, lesen Sie den Artikel Einrichtung von Cloud Service Mesh mit proxylosen gRPC-Diensten vorbereiten.

Überblick

Die Einrichtung von Cloud Service Mesh mit virtuellen Compute Engine-Maschinen (VMs) und proxylosen gRPC-Diensten umfasst Folgendes:

1. Eine verwaltete Instanzgruppe zum Hosten Ihrer Back-Ends einrichten.
2. Back-Ends zum Ausführen eines gRPC-Servers konfigurieren, der hello world als Antwort auf eine Anfrage von einem Client zurückgibt.
3. Cloud Service Mesh mithilfe der verwalteten Instanzgruppe und anderer Load-Balancing-Komponenten von Google Cloud konfigurieren
4. Prüfen, ob die Bereitstellung ordnungsgemäß funktioniert, indem eine proxylose gRPC-Clientanwendung verwendet wird, um Traffic an die gRPC-Serveranwendung zu senden.

Der proxylose gRPC-Client stellt über xDS eine Verbindung zu Cloud Service Mesh her. Wenn der Client eine Verbindung zu Cloud Service Mesh herstellt, sendet Cloud Service Mesh Informationen über die mit dem Dienst hello world verknüpften Back-Ends an den Client. Mithilfe dieser Informationen sendet der proxylose gRPC-Client Anfragen an den gRPC-Server hello world.

Verwaltete Instanzgruppe für Cloud Service Mesh konfigurieren

Verwaltete Instanzgruppen verwenden Autoscaling, um neue Back-End-VMs gemäß Ihrer Bereitstellung zu erstellen. In diesem Beispiel wird Folgendes gezeigt:

• Instanzvorlage mit einem Beispieldienst erstellen, der einen hello world-Dienst mithilfe des gRPC-Protokolls bereitstellt.
• Verwaltete Instanzgruppe mithilfe der Vorlage konfigurieren.

Instanzvorlage erstellen

Dieser Abschnitt enthält Anleitungen zum Erstellen einer Instanzvorlage. Im Beispiel stellen Sie einen gRPC-Dienst helloworld bereit, der auf Port 50051 verfügbar gemacht wird.

Console

1. Rufen Sie in der Google Cloud Console die Seite Instanzvorlagen auf.

   Zur Seite "Instanzvorlagen"

2. Klicken Sie auf Instanzvorlage erstellen.

3. Füllen Sie die Felder so aus:

   • Name: grpc-td-vm-template
   • Version des Bootlaufwerks: Debian/Linux 10
   • Dienstkonto: Standarddienstkonto für Compute Engine
   • Zugriffsbereiche: Uneingeschränkten Zugriff auf alle Google Cloud APIs zulassen

4. Aktivieren Sie unter Firewall die Kästchen neben HTTP-Traffic zulassen und HTTPS-Traffic zulassen.

5. Klicken Sie auf Verwaltung, Sicherheit, Laufwerke, Netzwerke, einzelne Mandanten.

6. Kopieren Sie auf dem Tab Verwaltung das folgende Skript in das Feld Startskript.

   #! /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.37.0.tar.gz | tar -xz
   cd grpc-java-1.37.0/examples/example-hostname
   ../gradlew --no-daemon installDist
   # Server listens on 50051
   sudo systemd-run ./build/install/hostname-server/bin/hostname-server
   

7. Klicken Sie auf Erstellen.

gcloud

Erstellen Sie die Instanzvorlage.

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.37.0.tar.gz | tar -xz
cd grpc-java-1.37.0/examples/example-hostname
../gradlew --no-daemon installDist
# Server listens on 50051
sudo systemd-run ./build/install/hostname-server/bin/hostname-server')

Verwaltete Instanzgruppe erstellen

In diesem Abschnitt erstellen Sie eine verwaltete Instanzgruppe mithilfe der Instanzvorlage, die Sie im vorherigen Abschnitt erstellt haben.

Console

1. Rufen Sie in der Google Cloud Console die Seite "Instanzgruppen" auf.

   Zur Seite "Instanzgruppen"

2. Klicken Sie auf Instanzgruppe erstellen. Standardmäßig wird die Seite zum Erstellen einer verwalteten Instanzgruppe angezeigt.
3. Geben Sie grpc-td-mig-us-central1 als Name für die verwaltete Instanzgruppe ein und wählen Sie die Zone us-central1-a aus.
4. Wählen Sie unter Instanzvorlage die Option grpc-td-vm-template aus. Dies ist die von Ihnen erstellte Instanzvorlage.
5. Geben Sie 2 als Mindest- und Höchstzahl von Instanzen an, die Sie in der Gruppe erstellen möchten.
6. Klicken Sie auf Erstellen.

gcloud

Erstellen Sie die verwaltete Instanzgruppe.

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

Benannten Port konfigurieren

In diesem Abschnitt konfigurieren Sie den benannten Port für den gRPC-Dienst. Der benannte Port ist der Port, den der gRPC-Dienst auf Anfragen überwacht. In diesem Beispiel lautet der benannte Port Port 50051.

Console

1. Rufen Sie in der Google Cloud Console die Seite "Instanzgruppen" auf.

   Zur Seite "Instanzgruppen"

2. Klicken Sie auf den Namen der Instanzgruppe grpc-td-mig-us-central1, die Sie erstellt haben.
3. Klicken Sie auf Gruppe bearbeiten.
4. Geben Sie im Feld Portname den Wert grpc-helloworld-port ein.
5. Geben Sie im Feld Portnummer den Wert 50051 ein.
6. Klicken Sie auf Speichern.

gcloud

Konfigurieren Sie den benannten Port.

gcloud compute instance-groups set-named-ports grpc-td-mig-us-central1 \
  --named-ports=grpc-helloworld-port:50051 \
  --zone us-central1-a

Cloud Service Mesh mit Google Cloud Load Balancing-Komponenten konfigurieren

Dieser Abschnitt enthält eine Anleitung zum Konfigurieren von Cloud Service Mesh mit Google Cloud-Load-Balancing-Komponenten für Ihre Dienste.

Systemdiagnose, Firewallregel und Back-End-Dienst erstellen

In diesem Abschnitt erstellen Sie einen globalen Back-End-Dienst mit einem Load-Balancing-Schema von INTERNAL_SELF_MANAGED und Protokoll GRPC. Dann verknüpfen Sie die Systemdiagnose und die Instanzgruppe mit dem Back-End-Dienst. In diesem Beispiel verwenden Sie die verwaltete Instanzgruppe, die Sie unter Verwaltete Instanzgruppe erstellen erstellt haben. Diese verwaltete Instanzgruppe führt den gRPC-Beispieldienst aus. Der Port im Flag --port-name ist der benannte Port, den Sie unter Benannten Port konfigurieren erstellt haben.

gcloud

1. Erstellen Sie die Systemdiagnose.

   gcloud compute health-checks create grpc grpc-helloworld-health-check \
    --use-serving-port
   

2. Erstellen Sie die Firewallregel für die Systemdiagnose.

   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
   

3. Erstellen Sie den Back-End-Dienst.

   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
   

4. 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-central1 \
    --instance-group-zone us-central1-a \
    --global
   

Routingregelzuordnung, Zielproxy und Weiterleitungsregel erstellen

In diesem Abschnitt erstellen Sie eine URL-Zuordnung, ein Tool zur Abgleichung von Pfaden und eine Hostregel, um Traffic für Ihren Dienst anhand des Hostnamens und eines Pfads weiterzuleiten. Im folgenden Beispiel wird helloworld-gce als Dienstname verwendet. Die gRPC-Anwendung verwendet diesen Dienstnamen im Ziel-URI, um eine Verbindung zu diesem Dienst herzustellen. Das Tool zur Abgleichung von Pfaden gleicht standardmäßig alle Pfadanfragen (/*) für diesen Host ab. Sie erstellen auch den gRPC-Zielproxy und die Weiterleitungsregel.

Weitere Informationen finden Sie unter Routingregelzuordnungen.

Im folgenden Beispiel ist Port 80 der angegebene Port.

gcloud

1. Erstellen Sie die URL-Zuordnung:

   gcloud compute url-maps create grpc-vm-url-map \
     --default-service grpc-helloworld-service
   

2. Erstellen Sie das Tool zur Abgleichung von Pfaden.

   gcloud compute url-maps add-path-matcher grpc-vm-url-map \
     --default-service grpc-helloworld-service \
     --path-matcher-name grpc-vm-path-matcher \
     --new-hosts helloworld-gce
   

3. Erstellen Sie den gRPC-Zielproxy.

   gcloud compute target-grpc-proxies create grpc-vm-proxy \
    --url-map grpc-vm-url-map \
    --validate-for-proxyless
   

4. Erstellen Sie die Weiterleitungsregel.

   gcloud compute forwarding-rules create grpc-vm-forwarding-rule \
    --global \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --address=0.0.0.0 --address-region=us-central1 \
    --target-grpc-proxy=grpc-vm-proxy \
    --ports 80 \
    --network default
   

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

Konfiguration überprüfen

Prüfen Sie nach Abschluss des Konfigurationsvorgangs, ob Sie eine gRPC-Verbindung zum zuvor erstellten Cloud Service Mesh-Dienst mit Load-Balancing herstellen können.

Prüfen Sie mit einem der folgenden Schritte, ob der Dienst verfügbar ist:

• Melden Sie sich bei einem der VM-Hosts (dem gRPC-Dienst-Back-End) an und prüfen Sie, ob der gRPC-Dienst auf dem Überwachungsport ausgeführt wird. Im Beispiel lautet der Port 50051.
• Suchen Sie auf der Seite „Cloud Service Mesh“ in der Console nach Informationen zum konfigurierten Dienst helloworld-gce und prüfen Sie, ob die Back-Ends als fehlerfrei gemeldet werden.
• Verwenden Sie die folgende Anleitung, um einen gRPC-Client von Compute Engine zur Bestätigung zu verwenden.

Dienst mit einer gRPC-Clientanwendung prüfen

In den folgenden Beispielen verwenden Sie einen gRPC-Client in einer beliebigen Sprache oder das grpcurl-Tool, um den gRPC-Dienst zu testen.

Erstellen Sie zuerst eine Client-VM, auf der Sie den gRPC-Client ausführen, um den Dienst zu testen.

gcloud compute instances create grpc-client \
  --zone us-central1-a \
  --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
# Expose bootstrap variable to SSH connections
echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh
# Create the bootstrap file
curl -L https://storage.googleapis.com/traffic-director/td-grpc-bootstrap-0.11.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.11.0/td-grpc-bootstrap | tee $GRPC_XDS_BOOTSTRAP')

Umgebungsvariable und Bootstrap-Datei einrichten

Die Clientanwendung benötigt eine Bootstrap-Konfigurationsdatei. Das Startskript im vorherigen Abschnitt legt die Umgebungsvariable GRPC_XDS_BOOTSTRAP fest und verwendet ein Hilfsskript, um die Bootstrap-Datei zu generieren. Die Werte für TRAFFICDIRECTOR_GCP_PROJECT_NUMBER, TRAFFICDIRECTOR_NETWORK_NAME und zone in der erstellten Bootstrap-Datei werden vom Metadatenserver abgerufen, der diese Details zu Ihren Compute Engine-VM-Instanzen kennt. Sie können diese Werte mithilfe der Optionen -gcp-project-number und -vpc-network-name manuell im Hilfsskript angeben.

Hinweis: Durch das Hinzufügen der Bootstrap-Generierung zum VM-Init-Skript wird bei jedem Neustart der VM eine aktuelle Bootstrap-Datei erstellt.

Melden Sie sich bei der Client-VM an und führen Sie die folgenden Beispiele aus, um die Konfiguration zu prüfen.

Java

So prüfen Sie den Dienst mit einem gRPC-Java-Client:

1. Laden Sie die neueste Version von gRPC Java mit dem neuesten Patch herunter und erstellen Sie die xds-hello-world-Clientanwendung.

   sudo apt-get update -y
   sudo apt-get install -y openjdk-11-jdk-headless
   curl -L https://github.com/grpc/grpc-java/archive/v1.37.0.tar.gz | tar -xz
   cd grpc-java-1.37.0/examples/example-xds
   ../gradlew --no-daemon installDist
   

2. Führen Sie den Client mit world als Name und xds:///helloworld-gce als Dienst-URI aus.

   ./build/install/example-xds/bin/xds-hello-world-client "world" \
      xds:///helloworld-gce
   

Einfach loslegen (Go)

So prüfen Sie den Dienst mit einem gRPC-Go-Client:

1. Laden Sie die neueste Version von gRPC Java mit dem neuesten Patch herunter und erstellen Sie die xds-hello-world-Clientanwendung.

   sudo apt-get update -y
   sudo apt-get install -y golang git
   curl -L https://github.com/grpc/grpc-go/archive/v1.37.0.tar.gz | tar -xz
   cd grpc-go-1.37.0/examples/features/xds/client
   go get google.golang.org/grpc@v1.37.0
   go build .
   

2. Führen Sie den Client mit world als Name und xds:///helloworld-gce als Dienst-URI aus.

   ./client "world" xds:///helloworld-gce
   

C++

So prüfen Sie den Dienst mit einem gRPC-C++-Client:

1. Laden Sie die neueste Version von gRPC C++ mit dem neuesten Patch herunter und erstellen Sie das Beispiel für den helloworld-Client.

   sudo apt-get update -y
   sudo apt-get install -y build-essential cmake git
   git clone --recurse-submodules -b v1.37.1 https://github.com/grpc/grpc
   cd grpc
   mkdir -p cmake/build
   pushd cmake/build
   cmake ../..
   make
   sudo make install
   popd
   mkdir -p third_party/abseil-cpp/cmake/build
   pushd third_party/abseil-cpp/cmake/build
   cmake ../..
   make
   sudo make install
   popd
   cd examples/cpp/helloworld
   mkdir -p cmake/build
   cd cmake/build/
   cmake ../..
   make
   

2. Führen Sie den Client mit "xds:///helloworld-gce" als Dienst-URI aus.

   ./greeter_client --target=xds:///helloworld-gce
   

GRPC-URL

So prüfen Sie den Dienst mit dem grpcurl-Tool:

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

2. Führen Sie das grpcurl-Tool mit "xds:///helloworld-gce" als Dienst-URI und helloworld.Greeter/SayHello als Dienstname 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
   

Python

Führen Sie folgenden Befehl aus, um den Dienst mit einem gRPC-Python-Client zu prüfen. Verwenden Sie die neueste Version von gRPC mit dem neuesten Patch.

sudo apt-get update
sudo apt-get -y install python3-pip
sudo pip3 install virtualenv
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1/examples/python/xds
virtualenv venv -p python3
source venv/bin/activate
pip install -r requirements.txt
python client.py  xds:///helloworld-gce

Ruby

Führen Sie folgenden Befehl aus, um den Dienst mit einem gRPC-Ruby-Client zu prüfen. Verwenden Sie die neueste Version von gRPC mit dem neuesten Patch.

sudo apt-get update
sudo apt-get install -y ruby-full
sudo gem install grpc
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1/examples/ruby
ruby greeter_client.rb john xds:///helloworld-gce

PHP

Führen Sie folgenden Befehl aus, um den Dienst mit einem gRPC-PHP-Client zu prüfen. Verwenden Sie die neueste Version von gRPC mit dem neuesten Patch.

sudo apt-get update
sudo apt-get install -y php7.3 php7.3-dev php-pear phpunit python-all zlib1g-dev git
sudo pecl install grpc
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1
export CC=/usr/bin/gcc
./tools/bazel build @com_google_protobuf//:protoc
./tools/bazel build src/compiler:grpc_php_plugin
cd examples/php
composer install
./../../bazel-bin/external/com_google_protobuf/protoc --proto_path=../protos \
--php_out=. --grpc_out=. \
--plugin=protoc-gen-grpc=../../bazel-bin/src/compiler/grpc_php_plugin \
../protos/helloworld.proto
php -d extension=grpc.so greeter_client.php john xds:///helloworld-gce

Node.js

Führen Sie folgenden Befehl aus, um den Dienst mit einem gRPC-Node.js-Client zu prüfen. Verwenden Sie die neueste Version von gRPC mit dem neuesten Patch.

sudo apt-get update
sudo apt-get install -y nodejs npm
curl -L https://github.com/grpc/grpc/archive/v1.34.0.tar.gz | tar -xz
cd grpc-1.34.0/examples/node/xds
npm install
node ./greeter_client.js --target=xds:///helloworld-gce

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

Greeting: Hello world, from INSTANCE_HOSTNAME

Dadurch wird überprüft, ob der proxylose gRPC-Client eine Verbindung zu Cloud Service Mesh hergestellt und mit dem Namens-Resolver xds von den Back-Ends für den helloworld-gce-Dienst erfahren 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

• Erweiterte Traffic-Verwaltung
• Beobachtbarkeit einrichten
• Fehlerbehebung bei proxylosen Cloud Service Mesh-Bereitstellungen