הגדרה של Google Kubernetes Engine ושירותי gRPC בלי שרת Proxy

במדריך הזה מוסבר איך להגדיר את Google Kubernetes Engine, אפליקציות gRPC ורכיבי איזון העומסים שנדרשים ל-Cloud Service Mesh.

לפני שמבצעים את ההוראות במדריך הזה, כדאי לעיין במאמר הכנה להגדרת Cloud Service Mesh עם שירותי gRPC בלי שרת Proxy.

סקירה כללית

הגדרת Cloud Service Mesh עם GKE ושירותי gRPC ללא שרת proxy כוללת את השלבים הבאים:

  1. הכנת אשכול GKE.
  2. פריסת אפליקציית שרת gRPC כשירות Kubernetes. מוסיפים הערה למפרט הפריסה של GKE כדי ליצור באופן אוטומטי קבוצה של נקודות קצה ברשת (NEG) בשביל השירות.
  3. הגדרת Cloud Service Mesh באמצעות ה-NEG ורכיבים אחרים של איזון עומסים. Google Cloud
  4. מוודאים שהפריסה פועלת בצורה תקינה באמצעות אפליקציית לקוח gRPC בלי שרת Proxy כדי לשלוח תעבורת נתונים לאפליקציית שרת gRPC.

הגדרת אשכולות GKE ל-Cloud Service Mesh

בקטע הזה מוסבר איך להפעיל אשכולות GKE כדי לעבוד עם Cloud Service Mesh.

הדרישות לאשכול GKE

אשכולות GKE צריכים לעמוד בדרישות הבאות:

  • צריך להפעיל תמיכה בקבוצות של נקודות קצה ברשת. מידע נוסף ודוגמאות זמינים במאמר בנושא קבוצות עצמאיות של נקודות קצה ברשת. התכונה 'קבוצות נקודות קצה עצמאיות' זמינה לכלל המשתמשים ב-Cloud Service Mesh.
  • לחשבון השירות של מופעי הצמתים באשכול צריכה להיות הרשאה לגשת ל-Cloud Service Mesh API. למידע נוסף על ההרשאות הנדרשות, אפשר לעיין במאמר הפעלת הגישה של חשבון השירות אל Cloud Service Mesh API.
  • למאגרי התוכן צריכה להיות גישה ל-Cloud Service Mesh API, שמוגן על ידי אימות OAuth. מידע נוסף זמין במאמר בנושא הגדרת המארח.

יצירת אשכול GKE

בדוגמה הבאה אפשר לראות איך יוצרים אשכול GKE בשם grpc-td-cluster ב-us-central1-a zone.

המסוף

כדי ליצור אשכול באמצעות מסוף Google Cloud :

  1. עוברים לתפריט Kubernetes Engine במסוף Google Cloud .

    מעבר לתפריט Google Kubernetes Engine

  2. לוחצים על יצירת אשכול.

  3. בוחרים בתבנית Standard cluster או בוחרים תבנית מתאימה לעומס העבודה.

  4. אם צריך, אפשר להתאים אישית את התבנית. חובה למלא את השדות הבאים:

    • שם: מזינים grpc-td-cluster.
    • סוג המיקום: Zonal.
    • תחום: us-central1-a.
    • מאגר צמתים:

  5. בתפריט הימני, לוחצים על default-pool.

  6. משנים את השם ל-grpc-td-cluster.

  7. בקטע גודל, מזינים את מספר הצמתים שרוצים ליצור. צריכה להיות לכם מכסת משאבים זמינה עבור הצמתים והמשאבים שלהם (כמו מסלולי חומת אש).

  8. בתפריט הימני, לוחצים על צמתים.

  9. בקטע Machine Configuration, במשפחת מכונות, לוחצים על Compute Optimized.

  10. בוחרים סוג מכונה. מידע על תמחור של סוגי מכונות זמין בדף התמחור של Compute Engine.

  11. בקטע Networking, מוסיפים את Network tag allow-health-checks.

  12. בתפריט הימני, לוחצים על Node security (אבטחת צמתים).

  13. בקטע Access scopes, בוחרים באפשרות Allow full access to all Cloud APIs.

  14. לוחצים על יצירה.

אחרי שיוצרים אשכול ב- Google Cloud console, צריך להגדיר את kubectl כדי ליצור אינטראקציה עם האשכול. מידע נוסף זמין במאמר בנושא יצירת רשומה של kubeconfig.

gcloud

יוצרים את האשכול.

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

קבלת ההרשאות הנדרשות באשכול GKE

כדי לעבור לאשכול שיצרתם, מריצים את הפקודה הבאה. הנקודה הזו kubectl מצביעה על האשכול הנכון.

gcloud 

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

הגדרת שירותי GKE

בקטע הזה מוסבר איך להכין מפרטים של פריסת GKE כדי לעבוד עם Cloud Service Mesh. התהליך כולל הגדרה של שירות לדוגמה ב-GKE helloworld עם הערות NEG.

שירות הדוגמה helloworld הוא אפליקציית שרת gRPC שמחזירה הודעה בתגובה לבקשה של לקוח gRPC. חשוב לזכור: אין שום דבר מיוחד בשירות helloworld. הוא לא שירות gRPC בלי שרת Proxy ויכול להגיב לבקשות מכל לקוח gRPC.

החלק 'בלי שרת Proxy' רלוונטי רק כשיישום לקוח gRPC מתחבר ל-Cloud Service Mesh, מקבל מידע על השירות helloworld ויכול לשלוח תעבורת נתונים ל-Pods שמשויכים ל-helloworld, בלי להסתמך על כתובות IP או על תרגום שם מבוסס-DNS.

הגדרת שירותי GKE באמצעות NEGs

השלב הראשון בהגדרת שירותי GKE לשימוש ב-Cloud Service Mesh הוא חשיפת השירות באמצעות NEG. כדי שהמפרט ייחשף דרך קבוצות של נקודות קצה ברשת (NEGs), צריך להוסיף לו את ההערה הבאה, שתתאים ליציאה שרוצים לחשוף.

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

ההערה הזו יוצרת NEG עצמאי כשפורסים את השירות בפעם הראשונה. ה-NEG הזה מכיל נקודות קצה שהן כתובות ה-IP והיציאות של ה-Pod. מידע נוסף ודוגמאות זמינים במאמר קבוצות עצמאיות של נקודות קצה ברשת.

בדוגמה הבאה, פורסים שירות helloworld Kubernetes שנחשף ביציאה 8080. זו היציאה שדרכה השירות גלוי באשכול. שירות gRPC ב-Pod מאזין בכתובת targetPort 50051. זוהי היציאה ב-Pod שאליה נשלחת הבקשה. בדרך כלל, הערכים של port ושל targetPort זהים כדי שיהיה נוח יותר, אבל בדוגמה הזו נעשה שימוש בערכים שונים כדי לציין את הערך הנכון שצריך להשתמש בו בהערה של קבוצת המילים השליליות.

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

מוודאים שנוצר שירות חדש helloworld:

kubectl get svc

הפלט של kubectl get svc אמור להיראות כך:

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

מוודאים ש-Pod האפליקציה פועל:

kubectl get pods

הפלט של kubectl get pods אמור להיראות כך:

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

מוודאים שהשם של ה-NEG נכון.

המסוף

כדי לראות רשימה של קבוצות נקודות קצה ברשת, עוברים לדף Network Endpoint Groups במסוף Google Cloud . מוצג לכם NEG בשם example-grpc-server.
כניסה לדף Network Endpoint Groups

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 עם רכיבי איזון עומסים

בקטע הזה מוסבר איך להגדיר רכיבי איזון עומסים לשירותים שלכם. Google Cloud הרכיבים האלה מכילים פרטי הגדרה שמאפשרים ללקוחות gRPC בלי שרת Proxy לתקשר עם שירותי GKE.

בדוגמה הבאה של הגדרות Cloud Service Mesh, מניחים את ההנחות הבאות:

  • ה-NEGs וכל שאר המשאבים נוצרים ברשת ברירת המחדל של מצב אוטומטי, באזור us-central1-a.
  • כשמשתמשים ב-Google Cloud CLI, שם ה-NEG של האשכול הוא example-grpc-server.

יצירת בדיקת התקינות, הכלל בחומת האש ושירות הקצה העורפי

בקטע הזה יוצרים בדיקת תקינות ואת כלל חומת האש לבדיקת התקינות. בבדיקת התקינות צריך להשתמש בפרוטוקול בדיקת התקינות של gRPC. כלל חומת האש מאפשר לבדיקות תקינות להתחבר למכונות הווירטואליות בפריסה. ההנחיה --use-serving-port משמשת את בדיקות התקינות כדי לקבל את יציאת ההאזנה שהוגדרה לכל נקודת קצה.

כלל חומת האש מאפשר חיבורים נכנסים של בדיקות תקינות למופעים ברשת.

בקטע הזה יוצרים שירות לקצה עורפי גלובלי עם סכמת איזון עומסים של INTERNAL_SELF_MANAGED ופרוטוקול GRPC, ואז משייכים את בדיקת התקינות לשירות לקצה העורפי.

מידע נוסף זמין במאמר בנושא יצירת בדיקות תקינות.

gcloud

  1. יוצרים את בדיקת התקינות.

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

  2. יוצרים את הכלל לחומת האש.

    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. יוצרים את שירות הקצה העורפי.

    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. מוסיפים את קבוצות ה-NEG של הקצה העורפי לשירות הקצה העורפי.

    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

יצירת מפת כללי הניתוב

בקטע הזה יוצרים מפת URL, התאמת נתיבים וכלל מארח כדי להפנות תנועה לשירות על סמך שם המארח ונתיב. בדוגמה הבאה, helloworld-gke הוא שם השירות. לקוח gRPC משתמש בשם השירות הזה ב-URI של היעד כשהוא מתחבר לשירות helloworld. יוצרים גם את שרת ה-gRPC Proxy ואת כלל ההעברה.

מידע נוסף על מפות של כללי ניתוב

בדוגמה הבאה השתמשנו בשם השירות helloworld-gke ובמספר היציאה 8000. כלומר, לקוח gRPC צריך להשתמש ב-xds:///helloworld-gke:8000 כדי להתחבר לשירות הזה, וחובה להגדיר כלל מארח helloworld-gke:8000 במפת ה-URL. שימו לב: יציאת השירות 8080 שמוצגת במפרט השירות של Kubernetes בקטע הקודם לא נמצאת בשימוש ב-Cloud Service Mesh, כי helloworld-gke:8000 מומר ישירות לנקודות הקצה של ה-NEG שמקשיבות ב-targetPort 50051. בדרך כלל, יציאה בכלל המארח של מפת URL ובמפרט השירות של Kubernetes‏ port ו-targetPort מוגדרת לאותו ערך לנוחות, אבל בדוגמה הזו נעשה שימוש בערכים שונים כדי להראות ש-port במפרט השירות לא נמצא בשימוש ב-Cloud Service Mesh.

gcloud

  1. יוצרים את מפת ה-URL.

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

  2. יוצרים את התאמת הנתיב.

    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. יוצרים את שרת ה-proxy של gRPC.

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

  4. יוצרים את כלל ההעברה.

    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 מוגדר עכשיו לאיזון עומסים של תעבורת נתונים בין נקודות הקצה ב-NEG עבור השירותים שצוינו במפת ה-URL.

אימות ההגדרה

אחרי שתהליך ההגדרה יסתיים, צריך לוודא שאפשר להגיע לשרת helloworld gRPC באמצעות לקוח gRPC ללא Proxy. הלקוח הזה מתחבר ל-Cloud Service Mesh, מקבל מידע על שירות helloworld (שמוגדר באמצעות Cloud Service Mesh באמצעות שירות ה-backend‏ grpc-gke-helloworld-service) ומשתמש במידע הזה כדי לשלוח תעבורה ל-backend של השירות.

אפשר גם לבדוק את הקטע Cloud Service Mesh ב Google Cloud מסוף כדי לקבל מידע על שירות helloworld-gke שהוגדר, ולבדוק אם ה-backend מדווח כפעיל.

אימות באמצעות לקוח gRPC ללא proxy

בדוגמאות הבאות נעשה שימוש בלקוחות gRPC בשפות שונות או בכלי grpcurl כדי לוודא ש-Cloud Service Mesh מנתב את התנועה בצורה נכונה ברשת. יוצרים Pod של לקוח, פותחים מעטפת ומריצים את פקודות האימות מהמעטפת.

הגדרת משתנה הסביבה וקובץ האתחול

אפליקציית הלקוח דורשת קובץ תצורת bootstrap. משנים את מפרט הפריסה של אפליקציית Kubernetes על ידי הוספת initContainer שיוצר את קובץ האתחול ואת אמצעי האחסון להעברת הקובץ. כדי למצוא את הקובץ, צריך לעדכן את מאגר התגים הקיים.

מוסיפים את initContainer הבא למפרט הפריסה של האפליקציה:

      initContainers:
      - args:
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.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

מעדכנים את הקטע env של מאגר האפליקציה כך שיכלול את הפרטים הבאים:

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

זו דוגמה מלאה למפרט Kubernetes של לקוח:

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

כשהפריסה מוכנה, פותחים מעטפת ל-Pod של הלקוח.

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

כדי לוודא שההגדרה תקינה, מריצים את הדוגמאות המתאימות במעטפת של ה-Pod.

Java

כדי לאמת את השירות באמצעות לקוח gRPC Java:

  1. מורידים את הגרסה האחרונה של gRPC Java, עם התיקון והגרסה העדכניים ביותר, ובוחרים באפשרות build של אפליקציית הלקוח xds-hello-world.

     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. מריצים את הלקוח עם "world" כשם ועם "xds:///helloworld-gke:8000" כמזהה המשאבים האחיד (URI) והיציאה של השירות.

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

המשך

כדי לאמת את השירות באמצעות לקוח gRPC Go:

  1. מורידים את הגרסה האחרונה של gRPC Go, עם הטלאי האחרון, ויוצרים את אפליקציית הלקוח xds-hello-world.

    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. מריצים את הלקוח עם "world" כשם ועם "xds:///helloworld-gke:8000" כמזהה המשאבים האחיד (URI) והיציאה של השירות.

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

C++‎

כדי לאמת את השירות באמצעות לקוח gRPC C++‎:

  1. מורידים את הגרסה האחרונה של gRPC C++‎,עם התיקון האחרון, ויוצרים את דוגמת הלקוח helloworld.

    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. מריצים את הלקוח עם 'xds:///helloworld-gke:8000' כמזהה המשאבים האחיד (URI) של השירות והיציאה.

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

grpcurl

הכלי grpcurl יכול לשמש גם כלקוח gRPC בלי שרת Proxy. במקרה הזה, grpcurl משתמש במשתנה הסביבה ובמידע על האתחול כדי להתחבר ל-Cloud Service Mesh. הוא לומד על שירות helloworld שהוגדר באמצעות Cloud Service Mesh דרך שירות הקצה העורפי grpc-gke-helloworld-service.

כדי לאמת את ההגדרה באמצעות הכלי grpcurl:

  1. מורידים ומתקינים את הכלי grpcurl.

    curl -L https://github.com/fullstorydev/grpcurl/releases/download/v1.8.1/grpcurl_1.8.1_linux_x86_64.tar.gz | tar -xz

  2. מריצים את הכלי grpcurl עם 'xds:///helloworld-gke:8000' כמזהה המשאבים האחיד (URI) של השירות, ועם helloworld.Greeter/SayHello כשם השירות והשיטה להפעלה. הפרמטרים של ה-method‏ SayHello מועברים באמצעות האפשרות -d.

    ./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld-gke:8000 helloworld.Greeter/SayHello

Python

כדי לאמת את השירות באמצעות לקוח gRPC Python, מריצים את הפקודה הבאה. משתמשים בגרסה העדכנית של gRPC עם התיקון האחרון.

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

כדי לאמת את השירות באמצעות לקוח gRPC Ruby, מריצים את הפקודה הבאה. משתמשים בגרסה העדכנית של gRPC עם התיקון האחרון.

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

כדי לאמת את השירות באמצעות לקוח gRPC PHP, מריצים את הפקודה הבאה. משתמשים בגרסה העדכנית של gRPC עם התיקון האחרון.

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

כדי לאמת את השירות באמצעות לקוח gRPC Node.js, מריצים את הפקודה הבאה. משתמשים בגרסה העדכנית של gRPC עם התיקון האחרון.

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

הפלט שאתם מקבלים אמור להיראות כך, כאשר INSTANCE_HOST_NAME הוא שם המארח של מכונת ה-VM::

Greetings: Hello world, from INSTANCE_HOST_NAME

האימות הזה מוודא שלקוח gRPC ללא proxy התחבר בהצלחה ל-Cloud Service Mesh וקיבל מידע על ה-backends של שירות helloworld-gke באמצעות פותר השמות xds. הלקוח שלח בקשה לאחד מהבק-אנדים של השירות בלי לדעת את כתובת ה-IP או לבצע פענוח DNS.

המאמרים הבאים