Traffic Director mit Compute Engine-VMs und proxylosen gRPC-Diensten einrichten

In diesem Leitfaden erfahren Sie, wie Sie Compute Engine-VM-Hosts, gRPC-Anwendungen und die Load-Balancing-Komponenten konfigurieren, die für Traffic Director erforderlich sind.

Bevor Sie den Anleitungen in diesem Leitfaden folgen, lesen Sie den Artikel Einrichten von Traffic Director mit proxylosen gRPC-Diensten vorbereiten.

Übersicht

Zum Einrichten von Traffic Director mit virtuellen Compute Engine-Maschinen (VMs) und proxylosen gRPC-Diensten sind folgende Schritte erforderlich:

  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. Traffic Director 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 mithilfe von xDS eine Verbindung zu Traffic Director her. Wenn der Client eine Verbindung zu Traffic Director herstellt, sendet Traffic Director dem Client Informationen über die Back-Ends, die mit dem Dienst hello world verknüpft sind. Mithilfe dieser Informationen sendet der proxylose gRPC-Client Anfragen an den gRPC-Server hello world.

Verwaltete Instanzgruppen für Traffic Director konfigurieren

Verwaltete Instanzgruppen verwenden die automatische Skalierung, 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 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.27.0.tar.gz | tar -xz
    cd grpc-java-1.27.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.27.0.tar.gz | tar -xz
cd grpc-java-1.27.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. Öffnen Sie in der Cloud Console die Seite "Instanzgruppen".

    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. Öffnen Sie in der Cloud Console die Seite "Instanzgruppen".

    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

Traffic Director mit Google Cloud Load Balancing-Komponenten konfigurieren

Dieser Abschnitt enthält Anleitungen zur Konfiguration von Traffic Director 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. Sie 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

  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 Back-End-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
    

Traffic Director ist jetzt so konfiguriert, dass das Load-Balancing des Traffics für die in der URL-Zuordnung angegebenen Dienste auf die Back-Ends in der verwalteten Instanzgruppe erfolgt.

Konfiguration prüfen

Prüfen Sie nach Abschluss der Konfiguration, dass Sie eine gRPC-Verbindung zum zuvor erstellten Traffic Director-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.
  • Prüfen Sie auf der Seite "Traffic Director" in der Console die Informationen zum konfigurierten Dienst helloworld-gce und bestätigen Sie, dass 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.9.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.9.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 erstellen. 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 zur Überprüfung der Konfiguration bei der Client-VM an und führen Sie die folgenden Beispiele aus.

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.30.0.tar.gz | tar -xz
    cd grpc-java-1.30.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
    

Go

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

  1. Laden Sie die neueste Version von gRPC Go 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.30.0.tar.gz | tar -xz
    cd grpc-go-1.30.0/examples/features/xds/client
    go get google.golang.org/grpc@v1.30.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 -b v1.30.0 https://github.com/grpc/grpc
    cd grpc
    git submodule update --init
    mkdir -p cmake/build
    cd cmake/build
    cmake ../..
    make
    sudo make install
    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
    

grpcurl

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.6.1/grpcurl_1.6.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.30.0.tar.gz | tar -xz
cd grpc-1.30.0/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.30.0.tar.gz | tar -xz
cd grpc-1.30.0/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 zlib1g-dev
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.30.0.tar.gz | tar -xz
cd grpc-1.30.0
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 bestätigt, dass der proxylose gRPC-Client mit Traffic Director 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