Compute Engine-VMs und proxyfreie gRPC-Dienste einrichten
In dieser Anleitung erfahren Sie, wie Sie Compute Engine-VM-Hosts, gRPC und die Load-Balancing-Komponenten, die von Cloud Service Mesh erfordert.
Bevor Sie der Anleitung in diesem Leitfaden folgen, lesen Sie den Artikel Einrichtung von Cloud Service Mesh mit proxylosen gRPC-Diensten vorbereiten.
Übersicht
Cloud Service Mesh mit virtuellen Compute Engine-Maschinen einrichten (VMs) und proxylose gRPC-Dienste umfassen Folgendes:
- Eine verwaltete Instanzgruppe zum Hosten Ihrer Back-Ends einrichten.
- Back-Ends zum Ausführen eines gRPC-Servers konfigurieren, der
hello world
als Antwort auf eine Anfrage von einem Client zurückgibt. - Cloud Service Mesh mit der verwalteten Instanzgruppe konfigurieren und anderen Load-Balancing-Komponenten von Google Cloud.
- 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. Wann?
stellt der Client eine Verbindung
zu Cloud Service Mesh her, sendet Cloud Service Mesh
Informationen über die mit hello world
verknüpften Back-Ends an den Client
Service. 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 bei Bedarf Autoscaling, um neue Back-End-VMs zu erstellen. durch Ihre Bereitstellung. 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
- Rufen Sie in der Google Cloud Console die Seite Instanzvorlagen auf.
- Klicken Sie auf Instanzvorlage erstellen.
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
Aktivieren Sie unter Firewall die Kästchen neben HTTP-Traffic zulassen und HTTPS-Traffic zulassen.
Klicken Sie auf Verwaltung, Sicherheit, Laufwerke, Netzwerke, einzelne Mandanten.
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
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
- Öffnen Sie in der Google Cloud Console die Seite Instanzgruppen.
- Klicken Sie auf Instanzgruppe erstellen. Standardmäßig wird die Seite zum Erstellen einer verwalteten Instanzgruppe angezeigt.
- Geben Sie
grpc-td-mig-us-central1
als Name für die verwaltete Instanzgruppe ein und wählen Sie die Zoneus-central1-a
aus. - Wählen Sie unter Instanzvorlage die Option
grpc-td-vm-template
aus. Dies ist die von Ihnen erstellte Instanzvorlage. - Geben Sie 2 als Mindest- und Höchstzahl von Instanzen an, die Sie in der Gruppe erstellen möchten.
- 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
- Öffnen Sie in der Google Cloud Console die Seite Instanzgruppen.
- Klicken Sie auf den Namen der Instanzgruppe
grpc-td-mig-us-central1
, die Sie erstellt haben. - Klicken Sie auf Gruppe bearbeiten.
- Geben Sie im Feld Portname den Wert
grpc-helloworld-port
ein. - Geben Sie im Feld Portnummer den Wert
50051
ein. - 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 des 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 dem Load-Balancing-Schema INTERNAL_SELF_MANAGED
und dem Protokoll GRPC
.
und verknüpfen dann 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
Erstellen Sie die Systemdiagnose.
gcloud compute health-checks create grpc grpc-helloworld-health-check \ --use-serving-port
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
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
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
Erstellen Sie die URL-Zuordnung:
gcloud compute url-maps create grpc-vm-url-map \ --default-service grpc-helloworld-service
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
Erstellen Sie den gRPC-Zielproxy.
gcloud compute target-grpc-proxies create grpc-vm-proxy \ --url-map grpc-vm-url-map \ --validate-for-proxyless
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
Das Cloud Service Mesh ist jetzt so konfiguriert, dass der Traffic mithilfe von Load-Balancing im gesamten Back-Ends in der verwalteten Instanzgruppe für die in der URL-Zuordnung angegebenen Dienste.
Konfiguration überprüfen
Prüfen Sie nach Abschluss der Konfiguration, ob Sie eine gRPC-Verbindung zum Cloud Service Mesh-Dienst mit Load-Balancing, den Sie erstellt wurde.
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 überprüfen Sie, ob der gRPC-Dienst auf dem Überwachungsport ausgeführt wird. Im Beispiel lautet der Port 50051.
- Prüfen Sie die Cloud Service Mesh-Seite in der Console.
um Informationen zum konfigurierten Dienst
helloworld-gce
zu erhalten, und bestätigen Sie, dass werden die Back-Ends als fehlerfrei gemeldet. - 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.16.0.tar.gz | tar -xz ./td-grpc-bootstrap-0.16.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 die Umgebungsvariable GRPC_XDS_BOOTSTRAP
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.
Melden Sie sich bei der Client-VM an und führen Sie den folgenden Befehl aus, um die Konfiguration zu prüfen Beispiele.
Java
So prüfen Sie den Dienst mit einem gRPC-Java-Client:
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
Führen Sie den Client mit
world
als Name undxds:///helloworld-gce
als Dienst-URI aus../build/install/example-xds/bin/xds-hello-world-client "world" \ xds:///helloworld-gce
Go
So prüfen Sie den Dienst mit einem gRPC-Go-Client:
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 .
Führen Sie den Client mit
world
als Name undxds:///helloworld-gce
als Dienst-URI aus../client "world" xds:///helloworld-gce
C++
So prüfen Sie den Dienst mit einem gRPC-C++-Client:
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
Führen Sie den Client mit "xds:///helloworld-gce" als Dienst-URI aus.
./greeter_client --target=xds:///helloworld-gce
grpcurl
So prüfen Sie den Dienst mit dem grpcurl
-Tool:
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 undhelloworld.Greeter/SayHello
als Dienstname und aufzurufende Methode aus. Die Parameter für die MethodeSayHello
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 erfolgreich eine Verbindung zu
Cloud Service Mesh und Informationen zu den Back-Ends für das helloworld-gce
mit dem xds
Name Resolver. 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