הגדרת מכונות וירטואליות ב-Compute Engine ושירותי gRPC ללא proxy

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

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

סקירה כללית

ההגדרה של Cloud Service Mesh עם מכונות וירטואליות (VM) של Compute Engine ושירותי gRPC בלי שרת Proxy כוללת את השלבים הבאים:

  1. הגדרת קבוצת מופעי מכונה מנוהלים שמארחת את השרתים העורפיים.
  2. הגדרת השרתים העורפיים להפעלת שרת gRPC שמחזיר hello world בתגובה לבקשה מלקוח.
  3. הגדרת Cloud Service Mesh באמצעות קבוצת מופעי מכונה מנוהלים ורכיבים אחרים של איזון עומסים. Google Cloud
  4. מוודאים שהפריסה פועלת בצורה תקינה באמצעות אפליקציית לקוח gRPC בלי שרת Proxy כדי לשלוח תעבורת נתונים לאפליקציית שרת gRPC.

לקוח gRPC ללא proxy מתחבר ל-Cloud Service Mesh באמצעות xDS. כשהלקוח מתחבר ל-Cloud Service Mesh, ‏ Cloud Service Mesh שולח ללקוח מידע על השרתים העורפיים שמשויכים לhello worldשירות. בעזרת המידע הזה, לקוח gRPC בלי שרת Proxy שולח בקשות לhello world שרת gRPC.

הגדרת קבוצה של מופעי מכונה מנוהלים ל-Cloud Service Mesh

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

  • יוצרים תבנית של הגדרות מכונה עם שירות לדוגמה שמפעיל שירות hello world באמצעות פרוטוקול gRPC.
  • מגדירים קבוצה של מופעי מכונה מנוהלים באמצעות התבנית.

יצירת תבנית של הגדרות מכונה

בקטע הזה מוסבר איך ליצור תבנית של הגדרות מכונה. בדוגמה, פורס שירות gRPC של helloworld שנחשף ביציאה 50051.

המסוף

  1. נכנסים לדף Instance Templates במסוף Google Cloud .

    לדף Instance templates

  2. לוחצים על Create instance template.

  3. ממלאים את השדות לפי ההנחיות הבאות:

    • שם: grpc-td-vm-template
    • גרסת דיסק האתחול: Debian / Linux 10
    • חשבון שירות: חשבון השירות של Compute Engine שמוגדר כברירת מחדל
    • היקפי גישה: אישור גישה מלאה לכל ממשקי ה-API Google Cloud

  4. בקטע Firewall, מסמנים את התיבות לצד Allow HTTP traffic ו-Allow HTTPS traffic.

  5. לוחצים על Management, Security, Disks, Networking, Sole Tenancy.

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

    #! /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

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

gcloud

יוצרים את תבנית של הגדרות מכונה.

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')

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

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

המסוף

  1. עוברים לדף Instance Groups במסוף Google Cloud .

    כניסה לדף Instance Groups

  2. לוחצים על יצירת קבוצת מופעים. כברירת מחדל, מוצג הדף ליצירת קבוצה של מופעי מכונה מנוהלים.
  3. מזינים grpc-td-mig-us-central1 כשם לקבוצת המופעים המנוהלים ובוחרים את האזור us-central1-a.
  4. בקטע Instance template, בוחרים באפשרות grpc-td-vm-template, שהיא תבנית של הגדרות מכונה שיצרתם.
  5. מציינים 2 כמספר המינימלי והמקסימלי של מופעים שרוצים ליצור בקבוצה.
  6. לוחצים על יצירה.

gcloud

יוצרים את קבוצת מופעי המכונה המנוהלים.

gcloud compute instance-groups managed create grpc-td-mig-us-central1 \
  --zone us-central1-a \
  --size=2 \
  --template=grpc-td-vm-template

הגדרת היציאה עם השם

בקטע הזה מגדירים את היציאה עם השם לשירות gRPC. היציאה שצוינה היא היציאה שבה שירות ה-gRPC מאזין לבקשות. בדוגמה הזו, היציאה שנקראת היא יציאה 50051.

המסוף

  1. עוברים לדף Instance Groups במסוף Google Cloud .

    כניסה לדף Instance Groups

  2. לוחצים על השם של קבוצת המופעים grpc-td-mig-us-central1 שיצרתם.
  3. לוחצים על עריכת הקבוצה.
  4. בשדה שם הניוד מזינים grpc-helloworld-port.
  5. בשדה מספר יציאה, מזינים 50051.
  6. לוחצים על Save.

gcloud

מגדירים את היציאה עם השם.

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

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

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

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

gcloud

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

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

  2. יוצרים את הכלל בחומת האש לבדיקת התקינות.

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

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

    gcloud compute backend-services add-backend grpc-helloworld-service \
 --instance-group grpc-td-mig-us-central1 \
 --instance-group-zone us-central1-a \
 --global

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

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

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

בדוגמה הבאה, יציאה 80 היא היציאה שצוינה.

gcloud

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

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

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

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

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

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

    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

‫Cloud Service Mesh מוגדר עכשיו לאיזון עומסים של תעבורת הנתונים בין הקצוות העורפיים בקבוצת מופעי מכונה מנוהלים עבור השירותים שצוינו במפת URL.

אימות ההגדרה

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

כדי לוודא שהשירות זמין, מבצעים אחת מהפעולות הבאות:

  • נכנסים לאחד ממארחי מכונות ה-VM (הקצה העורפי של שירות gRPC) ומוודאים ששירות gRPC פועל ביציאת ההאזנה. בדוגמה, היציאה היא 50051.
  • בודקים את הדף Cloud Service Mesh במסוף כדי לקבל מידע על השירות המוגדר helloworld-gce, ומוודאים שהעורפים מדווחים כבריאים.
  • כדי לבצע אימות באמצעות לקוח gRPC של Compute Engine, פועלים לפי ההוראות הבאות.

אימות השירות באמצעות אפליקציית לקוח gRPC

בדוגמאות הבאות, אתם משתמשים בלקוח gRPC בשפה שתבחרו או בכלי grpcurl כדי לבדוק את שירות gRPC.

קודם יוצרים מכונה וירטואלית של לקוח שבה מריצים את לקוח gRPC כדי לבדוק את השירות.

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.19.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.19.0/td-grpc-bootstrap | tee $GRPC_XDS_BOOTSTRAP')

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

אפליקציית הלקוח צריכה קובץ תצורת bootstrap. סקריפט לטעינה בזמן ההפעלה בסעיף הקודם מגדיר את משתנה הסביבה GRPC_XDS_BOOTSTRAP ומשתמש בסקריפט עזר כדי ליצור את קובץ האתחול. הערכים של TRAFFICDIRECTOR_GCP_PROJECT_NUMBER,‏ TRAFFICDIRECTOR_NETWORK_NAME ו-zone בקובץ האתחול שנוצר מתקבלים משרת המטא-נתונים שמכיר את הפרטים האלה לגבי המכונות הווירטואליות של Compute Engine. אפשר לספק את הערכים האלה לסקריפט העזר באופן ידני באמצעות האפשרויות -gcp-project-number ו--vpc-network-name.

כדי לאמת את ההגדרה, נכנסים למכונה הווירטואלית של הלקוח ומריצים את הדוגמאות הבאות.

Java

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

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

    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

  2. מריצים את הלקוח עם world בתור השם שלו ועם xds:///helloworld-gce בתור מזהה המשאבים האחיד (URI) של השירות.

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

המשך

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

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

    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 .

  2. מריצים את הלקוח עם world בתור השם שלו ועם xds:///helloworld-gce בתור מזהה המשאבים האחיד (URI) של השירות.

    ./client "world" xds:///helloworld-gce

C++‎

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

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

    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

  2. מריצים את הלקוח עם 'xds:///helloworld-gce' כמזהה המשאבים האחיד (URI) של השירות.

    ./greeter_client --target=xds:///helloworld-gce

grpcurl

כדי לאמת את השירות באמצעות הכלי 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-gce' כמזהה המשאבים האחיד (URI) של השירות, ועם helloworld.Greeter/SayHello כשם השירות והשיטה להפעלה. הפרמטרים של ה-method‏ SayHello מועברים באמצעות האפשרות -d.

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

Python

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

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

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

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

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

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

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

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

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

Greeting: Hello world, from INSTANCE_HOSTNAME

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

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