Google Kubernetes Engine und proxylose gRPC-Dienste einrichten

In dieser Anleitung wird beschrieben, wie Sie Google Kubernetes Engine, 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 Abschnitt Einrichtung von Cloud Service Mesh mit proxylosen gRPC-Diensten vorbereiten.

Überblick

Das Einrichten von Cloud Service Mesh mit GKE und proxylosen gRPC-Diensten umfasst Folgendes:

  1. GKE-Cluster vorbereiten.
  2. gRPC-Serveranwendung als Kubernetes-Dienst bereitstellen. Annotieren Sie die GKE-Bereitstellungsspezifikation, um automatisch eine Netzwerk-Endpunktgruppe (NEG) für den Dienst zu erstellen
  3. Cloud Service Mesh mithilfe der NEG 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.

GKE-Cluster für Cloud Service Mesh konfigurieren

In diesem Abschnitt wird beschrieben, wie GKE-Cluster mit Cloud Service Mesh funktionieren.

GKE-Clusteranforderungen

GKE-Cluster müssen die folgenden Voraussetzungen erfüllen:

  • Sie müssen die Unterstützung für Netzwerk-Endpunktgruppen aktivieren. Weitere Informationen und Beispiele finden Sie unter Eigenständige Netzwerk-Endpunktgruppen. Das Feature für eigenständige NEGs ist für Cloud Service Mesh allgemein verfügbar.
  • Das Dienstkonto der Clusterknoteninstanzen muss die Berechtigung für den Zugriff auf die Cloud Service Mesh API haben. Weitere Informationen zu den erforderlichen Berechtigungen finden Sie unter Dienstkonto für den Zugriff auf die Cloud Service Mesh API aktivieren.
  • Die Container müssen Zugriff auf die Cloud Service Mesh API haben, die durch die OAuth-Authentifizierung geschützt ist. Weitere Informationen finden Sie unter Hostkonfiguration.

GKE-Cluster erstellen

Das folgende Beispiel zeigt, wie ein GKE-Cluster mit dem Namen grpc-td-cluster in us-central1-a zone erstellt wird.

Console

Zum Erstellen eines Clusters mit der Google Cloud Console führen Sie die folgenden Schritte aus:

  1. Rufen Sie in der Google Cloud Console das Menü „Kubernetes Engine” auf.

    Zum Kubernetes Engine-Menü

  2. Klicken Sie auf Cluster erstellen.

  3. Wählen Sie die Vorlage Standardcluster oder eine für die Arbeitslast geeignete Vorlage aus.

  4. Passen Sie die Vorlage bei Bedarf an. Die folgenden Felder sind Pflichtfelder:

    • Name: Geben Sie grpc-td-cluster ein.
    • Standorttyp: Zonal.
    • Zone:us-central1-a.
    • Knotenpool:

  5. Klicken Sie im Menü links auf default-pool.

  6. Ändern Sie den Namen in grpc-td-cluster.

  7. Geben Sie unter Größe die Anzahl der zu erstellenden Knoten ein. Sie müssen verfügbare Ressourcenkontingente für die Knoten und für ihre Ressourcen (z. B. Firewallrouten) haben.

  8. Klicken Sie im linken Menü auf Knoten.

  9. Klicken Sie unter Maschinenkonfiguration in Maschinenfamilie auf computing-optimiert.

  10. Maschinentyp auswählen Informationen zu Preisen für Maschinentypen finden Sie auf der Seite Compute Engine-Preise.

  11. Fügen Sie unter Netzwerk das Netzwerk-Tag allow-health-checks hinzu.

  12. Klicken Sie im linken Menü auf Knotensicherheit.

  13. Wählen Sie unter Zugriffsbereiche die Option Uneingeschränkten Zugriff auf alle Cloud-APIs zulassen aus.

  14. Klicken Sie auf Erstellen.

Nachdem Sie einen Cluster in der Google Cloud Console erstellt haben, müssen Sie kubectl für die Interaktion mit dem Cluster konfigurieren. Weitere Informationen finden Sie unter Eintrag in kubeconfig generieren.

gcloud

Erstellen Sie den Cluster.

gcloud container clusters create grpc-td-cluster \
   --zone us-central1-a \
   --scopes=https://www.googleapis.com/auth/cloud-platform \
   --tags=allow-health-checks \
   --enable-ip-alias

Erforderliche GKE-Clusterberechtigungen abrufen

Wechseln Sie mit dem folgenden Befehl zu dem soeben erstellten Cluster. Dadurch wird kubectl auf den richtigen Cluster verwiesen.

gcloud 

gcloud container clusters get-credentials grpc-td-cluster \
    --zone us-central1-a

GKE-Dienste konfigurieren

In diesem Abschnitt wird beschrieben, wie die GKE-Bereitstellungsspezifikationen für die Verwendung mit Cloud Service Mesh vorbereitet werden. Diese besteht aus der Konfiguration eines helloworld-Beispieldienstes für GKE mit NEG-Annotationen.

Der Beispieldienst helloworld ist eine gRPC-Serveranwendung, die eine Nachricht als Antwort auf die Anfrage eines gRPC-Clients zurückgibt. Beachten Sie, dass für den Dienst helloworld keine Besonderheiten vorliegen. Er ist kein proxyloser gRPC-Dienst und kann auf Anfragen von jedem gRPC-Client antworten.

Der Teil „proxylos“ kommt nur dann ins Spiel, wenn eine gRPC-Clientanwendung eine Verbindung zu Cloud Service Mesh herstellt, den Dienst helloworld kennt und dann Traffic an mit helloworld verknüpfte Pods senden kann, ohne dass IP-Adressen oder DNS-basierte Namensauflösung erforderlich sind.

GKE-Dienste mit NEGs konfigurieren

Der erste Schritt beim Konfigurieren von GKE-Diensten für die Verwendung mit Cloud Service Mesh besteht darin, den Dienst über eine NEG verfügbar zu machen. Zum Bereitstellen über NEGs muss jede Spezifikation die folgende Annotation haben. Diese muss dem Port entsprechen, den Sie verfügbar machen möchten.

...
metadata:
  annotations:
    cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'

Mit dieser Annotation wird eine eigenständige NEG erstellt, wenn Sie Ihren Dienst zum ersten Mal bereitstellen. Diese NEG enthält Endpunkte, die die IP-Adressen und Ports des Pods sind. Weitere Informationen und Beispiele finden Sie unter Eigenständige Netzwerk-Endpunktgruppen.

Im folgenden Beispiel stellen Sie einen helloworld-Kubernetes-Dienst bereit, der über Port 8080 verfügbar ist. Dies ist der Port, auf dem der Dienst im Cluster sichtbar ist. Der gRPC-Dienst im Pod beobachtet targetPort 50051. Dies ist der Port auf dem Pod, an den die Anfrage gesendet wird. Normalerweise sind port und targetPort auf denselben Wert festgelegt, aber in diesem Beispiel werden unterschiedliche Werte verwendet, um den richtigen Wert für die NEG-Annotation anzugeben.

cat << EOF > grpc-td-helloworld.yaml
apiVersion: v1
kind: Service
metadata:
  name: helloworld
  annotations:
    cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'
spec:
  ports:
  - port: 8080
    name: helloworld
    protocol: TCP
    targetPort: 50051
  selector:
    run: app1
  type: ClusterIP

---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: app1
  name: app1
spec:
  selector:
    matchLabels:
      run: app1
  replicas: 2
  template:
    metadata:
      labels:
        run: app1
    spec:
      containers:
      - image: grpc/java-example-hostname:1.50.2
        name: app1
        ports:
        - protocol: TCP
          containerPort: 50051
EOF

kubectl apply -f grpc-td-helloworld.yaml

Prüfen Sie, ob der neue helloworld-Dienst erstellt wurde:

kubectl get svc

Die Ausgabe von kubectl get svc sollte in etwa so aussehen:

NAME           TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
helloworld     ClusterIP   10.71.9.71   <none>        8080/TCP  41m
[..skip..]

Prüfen Sie, ob der Anwendungs-Pod ausgeführt wird:

kubectl get pods

Die Ausgabe von kubectl get pods sollte in etwa so aussehen:

NAME                        READY     STATUS    RESTARTS   AGE
app1-6db459dcb9-zvfg2   1/1       Running   0          6m
app1-6db459dcb9-hlvhj   1/1       Running   0          6m
[..skip..]

Prüfen Sie, ob der NEG-Name korrekt ist.

Console

Sie können sich eine Liste der Netzwerk-Endpunktgruppen anzeigen lassen. Rufen Sie dazu die Seite "Netzwerk-Endpunktgruppen" in der Google Cloud Console auf. Sie sehen eine NEG mit dem Namen example-grpc-server.
Zur Seite "Netzwerk-Endpunktgruppen"

gcloud 

# List the NEGs
gcloud compute network-endpoint-groups list \
    --filter "name=example-grpc-server" --format "value(name)"

# Optionally examine the NEG
gcloud compute network-endpoint-groups describe example-grpc-server \
    --zone us-central1-a

# Optionally examine the endpoint(s) contained
gcloud compute network-endpoint-groups list-network-endpoints example-grpc-server \
    --zone us-central1-a

Cloud Service Mesh mit Load-Balancing-Komponenten konfigurieren

In diesem Abschnitt wird beschrieben, wie Sie Google Cloud-Load-Balancing-Komponenten für Ihre Dienste konfigurieren. Diese Komponenten enthalten Konfigurationsinformationen, über die proxylose gRPC-Clients mit Ihren GKE-Diensten kommunizieren können.

Im folgenden Konfigurationsbeispiel für das Cloud Service Mesh wird von diesen Annahmen ausgegangen:

  • Die NEGs und alle anderen Ressourcen werden im Standardnetzwerk im automatischen Modus in der Zone us-central1-a erstellt.
  • Wenn Sie die Google Cloud CLI verwenden, lautet der NEG-Name für den Cluster example-grpc-server.

Systemdiagnose, Firewallregel und Back-End-Dienst erstellen

In diesem Abschnitt erstellen Sie eine Systemdiagnose und die Firewallregel für die Systemdiagnose. Die Systemdiagnose muss das gRPC-Systemdiagnoseprotokoll verwenden. Die Firewallregel erlaubt es den Systemdiagnosetests, eine Verbindung zu den VMs in Ihrer Bereitstellung herzustellen. Die Anweisung --use-serving-port wird von Systemdiagnosen verwendet, um den konfigurierten Überwachungsport für jeden Endpunkt abzurufen.

Die Firewallregel lässt eingehende Systemdiagnoseverbindungen zu Instanzen in Ihrem Netzwerk zu.

In diesem Abschnitt erstellen Sie einen globalen Back-End-Dienst mit einem Load-Balancing-Schema von INTERNAL_SELF_MANAGED und Protokoll GRPC. Die Systemdiagnose verknüpfen Sie dann mit dem Back-End-Dienst.

Weitere Informationen finden Sie unter Systemdiagnosen erstellen.

gcloud

  1. Erstellen Sie die Systemdiagnose.

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

  2. Erstellen sie die Firewallregel.

    gcloud compute firewall-rules create grpc-gke-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-gke-helloworld-service \
   --global \
   --load-balancing-scheme=INTERNAL_SELF_MANAGED \
   --protocol=GRPC \
   --health-checks grpc-gke-helloworld-hc

  4. Fügen Sie dem Back-End-Dienst die Back-End-NEGs hinzu.

    gcloud compute backend-services add-backend grpc-gke-helloworld-service \
   --global \
   --network-endpoint-group example-grpc-server \
   --network-endpoint-group-zone us-central1-a \
   --balancing-mode RATE \
   --max-rate-per-endpoint 5

Routingregelzuordnung 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-gke als Dienstname verwendet. Der gRPC-Client verwendet diesen Dienstnamen im Ziel-URI beim Herstellen einer Verbindung mit dem Dienst helloworld. Sie erstellen auch den Ziel-gRPC-Proxy und die Weiterleitungsregel.

Weitere Informationen finden Sie unter Routingregelzuordnungen.

Im folgenden Beispiel werden der Dienstname helloworld-gke und der Port 8000 verwendet. Das bedeutet, dass der gRPC-Client mit xds:///helloworld-gke:8000 eine Verbindung zu diesem Dienst herstellen muss und eine Hostregel helloworld-gke:8000 in der URL-Zuordnung konfiguriert werden muss. Beachten Sie, dass der in der Kubernetes-Dienstspezifikation in einem vorherigen Abschnitt gezeigte Dienstport 8080 nicht von Cloud Service Mesh verwendet wird, da helloworld-gke:8000 direkt in die NEG-Endpunkte aufgelöst wird, die targetPort 50051 überwachen. In der Regel sind der Port in der Hostregel der URL-Zuordnung und der Kubernetes-Dienstspezifikation port und targetPort alle auf denselben Wert festgelegt. In diesem Beispiel werden jedoch unterschiedliche Werte verwendet, um zu zeigen, dass die port in der Dienstspezifikation nicht von Cloud Service Mesh verwendet wird.

gcloud

  1. Erstellen Sie die URL-Zuordnung:

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

  2. Erstellen Sie das Tool zur Abgleichung von Pfaden.

    gcloud compute url-maps add-path-matcher grpc-gke-url-map \
--default-service grpc-gke-helloworld-service \
--path-matcher-name grpc-gke-path-matcher \
--new-hosts helloworld-gke:8000

  3. Erstellen Sie den gRPC-Zielproxy.

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

  4. Erstellen Sie die Weiterleitungsregel.

    gcloud compute forwarding-rules create grpc-gke-forwarding-rule \
--global \
--load-balancing-scheme=INTERNAL_SELF_MANAGED \
--address=0.0.0.0 \
--target-grpc-proxy=grpc-gke-proxy \
--ports 8000 \
--network default

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

Konfiguration überprüfen

Prüfen Sie nach Abschluss der Konfiguration, ob Sie den gRPC-Server helloworld mit einem proxylosen gRPC-Client erreichen können. Dieser Client stellt eine Verbindung zu Cloud Service Mesh her, ruft Informationen zum Dienst helloworld ab (konfiguriert mit Cloud Service Mesh über den Back-End-Dienst grpc-gke-helloworld-service) und verwendet diese Informationen, um Traffic an die Back-Ends des Dienstes zu senden.

Sie können auch im Abschnitt „Cloud Service Mesh“ in der Google Cloud Console Informationen zum konfigurierten Dienst helloworld-gke finden und prüfen, ob die Back-Ends als fehlerfrei gemeldet werden.

Verifizierung mit einem proxylosen gRPC-Client

In den folgenden Beispielen verwenden Sie gRPC-Clients in verschiedenen Sprachen oder das grpcurl-Tool, um zu prüfen, ob Cloud Service Mesh Traffic im Mesh richtig weiterleitet. Sie erstellen einen Client-Pod, öffnen eine Shell und führen dann die Überprüfungsbefehle in der Shell aus.

Umgebungsvariable und Bootstrap-Datei einrichten

Die Clientanwendung benötigt eine Bootstrap-Konfigurationsdatei. Ändern Sie die Spezifikation für die Bereitstellung der Kubernetes-Anwendung. Fügen Sie dazu initContainer hinzu, mit dem die Bootstrap-Datei und das Volume zur Übertragung der Datei generiert werden. Aktualisieren Sie den vorhandenen Container, um die Datei zu finden.

Fügen Sie der Spezifikation der Anwendungsbereitstellung initContainer hinzu:

      initContainers:
      - args:
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.11.0

        imagePullPolicy: IfNotPresent
        name: grpc-td-init
        resources:
          limits:
            cpu: 100m
            memory: 100Mi
          requests:
            cpu: 10m
            memory: 100Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/bootstrap/
      volumes:
      - name: grpc-td-conf
        emptyDir:
          medium: Memory

Ändern Sie den Abschnitt env des Anwendungscontainers so, dass er Folgendes enthält:

        env:
        - name: GRPC_XDS_BOOTSTRAP
          value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/grpc-xds/

Im Folgenden ist ein vollständiges Beispiel einer Kubernetes-Clientspezifikation dargestellt:

cat << EOF  | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: client
  name: sleeper
spec:
  selector:
    matchLabels:
      run: client
  template:
    metadata:
      labels:
        run: client
    spec:
      containers:
      - image: openjdk:8-jdk
        imagePullPolicy: IfNotPresent
        name: sleeper
        command:
        - sleep
        - 365d
        env:
        - name: GRPC_XDS_BOOTSTRAP
          value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
        resources:
          limits:
            cpu: "2"
            memory: 2000Mi
          requests:
            cpu: 300m
            memory: 1500Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/grpc-xds/
      initContainers:
      - args:
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.11.0
        imagePullPolicy: IfNotPresent
        name: grpc-td-init
        resources:
          limits:
            cpu: 100m
            memory: 100Mi
          requests:
            cpu: 10m
            memory: 100Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/bootstrap/
      volumes:
      - name: grpc-td-conf
        emptyDir:
          medium: Memory
EOF

Wenn die Bereitstellung bereit ist, öffnen Sie eine Shell für den Client-Pod.

kubectl exec -it $(kubectl get pods -o custom-columns=:.metadata.name \
    --selector=run=client) -- /bin/bash

Führen Sie die entsprechenden Beispiele in der Pod-Shell 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.

     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-gke:8000" als Dienst-URI und Port aus.

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

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.

    apt-get update -y
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-gke:8000" als Dienst-URI und Port aus.

    ./client "world" xds:///helloworld-gke:8000

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.

    apt-get update -y
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
make install
popd
mkdir -p third_party/abseil-cpp/cmake/build
pushd third_party/abseil-cpp/cmake/build
cmake ../..
make
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-gke:8000" als Dienst-URI und Port aus.

    ./greeter_client --target=xds:///helloworld-gke:8000

GRPC-URL

Das grpcurl-Tool kann auch als proxyloser gRPC-Client verwendet werden. In diesem Fall verwendet grpcurl die Umgebungsvariable und die Bootstrap-Informationen, um eine Verbindung zum Cloud Service Mesh herzustellen. Anschließend erfährt er vom Dienst helloworld, der über den Back-End-Dienst grpc-gke-helloworld-service mit Cloud Service Mesh konfiguriert wurde.

So prüfen Sie Ihre Konfiguration 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-gke:8000" als Dienst-URI und helloworld.Greeter/SayHello als Dienstnamen und -methode aus. Die Parameter für die Methode SayHello werden mit der Option -d übergeben.

    ./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld-gke:8000 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.

apt-get update -y
apt-get install python3-pip -y
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-gke:8000

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.

apt-get update -y
apt-get install -y ruby-full
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-gke:8000

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.

apt-get update -y
apt-get install -y php7.3 php7.3-dev php-pear phpunit python-all zlib1g-dev git
pecl install grpc
curl -sS https://getcomposer.org/installer | php
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-gke:8000

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.

apt-get update -y
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-gke:8000

Die Ausgabe sollte in etwa so aussehen, wobei INSTANCE_HOST_NAME der Hostname der VM-Instanz ist:

Greetings: Hello world, from INSTANCE_HOST_NAME

Dadurch wird überprüft, ob der proxylose gRPC-Client erfolgreich mit Cloud Service Mesh verbunden und mit dem xds-Namens-Resolver Informationen zu den Back-Ends für den helloworld-gke-Dienst abgerufen 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