Google Kubernetes Engine und proxylose gRPC-Dienste einrichten

In dieser Anleitung wird beschrieben, wie Sie Google Kubernetes Engine, gRPC-Anwendungen und Load-Balancing-Komponenten, 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.

Übersicht

Das Einrichten von Cloud Service Mesh mit GKE und proxylosen gRPC-Diensten erfordert 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 Google Cloud-Lasten konfigurieren ausgleichen.
  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 Sie GKE-Cluster für die Arbeit mit Cloud Service Mesh.

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 allgemein verfügbar für Cloud Service Mesh.
  • Die Clusterknoteninstanzen Dienstkonto muss eine Zugriffsberechtigung haben der Cloud Service Mesh API. 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 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 Sie die GKE-Bereitstellung vorbereiten Spezifikationen für die Arbeit mit dem Cloud Service Mesh. Diese besteht aus der Konfiguration eines helloworld-Beispieldienstes für GKE mit NEG-Annotationen.

Der GKE-helloworld-Beispieldienst ist eine gRPC-Serveranwendung, die als Antwort auf die Anfrage eines gRPC-Clients eine Nachricht 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.

Das "proxylose" eine gRPC-Clientanwendung, stellt eine Verbindung zum Cloud Service Mesh her, lernt den helloworld-Dienst und kann dann Traffic an mit helloworld verknüpfte Pods senden, ohne für IP-Adressen oder die DNS-basierte Namensauflösung.

GKE-Dienste mit NEGs konfigurieren

Der erste Schritt bei der Konfiguration der GKE-Dienste zur 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 dem Load-Balancing-Schema INTERNAL_SELF_MANAGED und dem Protokoll GRPC. und verknüpfen dann die Systemdiagnose 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 angegebene Dienst-Port 8080 von Cloud Service Mesh nicht verwendet wird, da helloworld-gke:8000 direkt auf die NEG-Endpunkte aufgelöst wird, die den targetPort50051 beobachten. In der Regel ist der Port in der Hostregel der URL-Zuordnung und der Kubernetes-Dienstspezifikation port und targetPort sind alle auf denselben Wert festgelegt, aber In diesem Beispiel werden verschiedene Werte verwendet, um zu zeigen, dass die port in der Dienstspezifikation wird vom Cloud Service Mesh nicht verwendet.

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

Das Cloud Service Mesh ist jetzt so konfiguriert, dass der Traffic mithilfe von Load-Balancing Endpunkte in der NEG für die in der URL-Zuordnung angegebenen Dienste.

Konfiguration überprüfen

Prüfen Sie nach Abschluss der Konfiguration, ob Sie den gRPC-Server helloworld mit einem proxylosen gRPC-Client erreichen können. Der Client stellt eine Verbindung zu Cloud Service Mesh her, erhält Informationen zum helloworld-Dienst, der mit Cloud Service Mesh über den grpc-gke-helloworld-service-Back-End-Dienst konfiguriert ist, 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 nach dem konfigurierten Dienst helloworld-gke suchen 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 Traffic von Cloud Service Mesh im Mesh-Netzwerk ordnungsgemäß weitergeleitet wird. 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.16.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.16.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

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

grpcurl

Das grpcurl-Tool kann auch als proxyloser gRPC-Client verwendet werden. In diesem Fall grpcurl verwendet die Umgebungsvariable und Bootstrap-Informationen für die Verbindung zum Cloud Service Mesh. Dann lernt es den helloworld-Dienst, der wurde mit Cloud Service Mesh über grpc-gke-helloworld-service konfiguriert Back-End-Dienst.

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 bestätigt, dass der proxylose gRPC-Client mit Cloud Service Mesh erfolgreich verbunden und Informationen zu den Back-Ends für den Dienst helloworld-gke über den xds-Name-Resolver 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