‫Cloud Service Mesh אזורי

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

אלו המגבלות שחלות על Cloud Service Mesh אזורי:

  • ‫Istio API לא נתמך. אי אפשר להשתמש ב-Kubernetes עם Istio API באמצעות Traffic Director אזורי. בגרסת הטרום-השקה הזו יש תמיכה רק בממשקי Google Cloud API.
  • השימוש ב-API לניתוב שירותים גלובלי כפוף לשיקולים ולהגבלות הקיימים.
  • הגרסה המינימלית של Envoy שנדרשת לתמיכה בסכימות שמות של xdSTP היא v1.31.1.
  • אין תמיכה ב-Gateway for Mesh API.
  • הגרסה המינימלית של gRPC היא v1.65.

  • יש תמיכה רק באזורים הבאים:

    africa-south1
asia-east1
asia-east2
asia-northeast1
asia-northeast2
asia-northeast3
asia-south1
asia-south2
asia-southeast1
asia-southeast2
australia-southeast1
australia-southeast2
europe-central2
europe-north1
europe-north2
europe-southwest1
europe-west10
europe-west12
europe-west1
europe-west2
europe-west3
europe-west4
europe-west6
europe-west8
europe-west9
me-central1
me-central2
me-west1
northamerica-northeast1
northamerica-northeast2
northamerica-south1
southamerica-east1
southamerica-west1
us-central1
us-east1
us-east4
us-east5
us-south1
us-west1
us-west2
us-west3
us-west4

תמחור

בכל אזור שבו יש תמיכה ב-Cloud Service Mesh אזורי, יהיה מק"ט אזורי כשהתכונה תהיה זמינה לכולם. בשלב הזה, התמחור זהה לזה של התמחור הגלובלי.

הכנת לקוח xDS ל-Cloud Service Mesh

מכונה וירטואלית של Compute Envoy xDS

גלילה ידנית

השלבים הידניים מבוססים על הגדרת מכונות וירטואליות באמצעות פריסה ידנית של Envoy. ההבדל העיקרי הוא ש-ENVOY_CONTROL_PLANE_REGION מוגדר ומוזרק ל-bootstrap.

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

    gcloud compute instance-templates create td-vm-templategcloud compute instance-templates create td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=http-td-tag,http-server,https-server \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --metadata=startup-script='#! /usr/bin/env bash

# Set variables
export ENVOY_CONTROL_PLANE_REGION="us-central1"
export ENVOY_USER="envoy"
export ENVOY_USER_UID="1337"
export ENVOY_USER_GID="1337"
export ENVOY_USER_HOME="/opt/envoy"
export ENVOY_CONFIG="${ENVOY_USER_HOME}/config.yaml"
export ENVOY_PORT="15001"
export ENVOY_ADMIN_PORT="15000"
export ENVOY_TRACING_ENABLED="false"
export ENVOY_XDS_SERVER_CERT="/etc/ssl/certs/ca-certificates.crt"
export ENVOY_ACCESS_LOG="/dev/stdout"
export ENVOY_NODE_ID="$(cat /proc/sys/kernel/random/uuid)~$(hostname -i)"
export BOOTSTRAP_TEMPLATE="${ENVOY_USER_HOME}/bootstrap_template.yaml"
export GCE_METADATA_SERVER="169.254.169.254/32"
export INTERCEPTED_CIDRS="*"
export GCP_PROJECT_NUMBER=PROJECT_NUMBER
export VPC_NETWORK_NAME=mesh:sidecar-mesh
export GCE_ZONE=$(curl -sS -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/instance/zone | cut -d"/" -f4)

# Create system user account for Envoy binary
sudo groupadd ${ENVOY_USER} \
  --gid=${ENVOY_USER_GID} \
  --system
sudo adduser ${ENVOY_USER} \
  --uid=${ENVOY_USER_UID} \
  --gid=${ENVOY_USER_GID} \
  --home=${ENVOY_USER_HOME} \
  --disabled-login \
  --system
# Download and extract the Cloud Service Mesh tar.gz file
cd ${ENVOY_USER_HOME}
sudo curl -sL https://storage.googleapis.com/traffic-director/traffic-director-xdsv3.tar.gz -o traffic-director-xdsv3.tar.gz
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/bootstrap_template.yaml \
  -C bootstrap_template.yaml \
  --strip-components 1
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/iptables.sh \
  -C iptables.sh \
  --strip-components 1
sudo rm traffic-director-xdsv3.tar.gz

# Generate Envoy bootstrap configuration
cat "${BOOTSTRAP_TEMPLATE}" \
  | sed -e "s|ENVOY_NODE_ID|${ENVOY_NODE_ID}|g" \
  | sed -e "s|ENVOY_ZONE|${GCE_ZONE}|g" \
  | sed -e "s|VPC_NETWORK_NAME|${VPC_NETWORK_NAME}|g" \
  | sed -e "s|CONFIG_PROJECT_NUMBER|${GCP_PROJECT_NUMBER}|g" \
  | sed -e "s|ENVOY_PORT|${ENVOY_PORT}|g" \
  | sed -e "s|ENVOY_ADMIN_PORT|${ENVOY_ADMIN_PORT}|g" \
  | sed -e "s|XDS_SERVER_CERT|${ENVOY_XDS_SERVER_CERT}|g" \
  | sed -e "s|TRACING_ENABLED|${ENVOY_TRACING_ENABLED}|g" \
  | sed -e "s|ACCESSLOG_PATH|${ENVOY_ACCESS_LOG}|g" \
  | sed -e "s|BACKEND_INBOUND_PORTS|${BACKEND_INBOUND_PORTS}|g" \
  | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
  | sudo tee "${ENVOY_CONFIG}"

# Install Envoy binary
wget -O envoy_key https://apt.envoyproxy.io/signing.key
cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
sudo apt-get update
sudo apt-get install envoy

# Run Envoy as systemd service
sudo systemd-run --uid=${ENVOY_USER_UID} --gid=${ENVOY_USER_GID} \
  --working-directory=${ENVOY_USER_HOME} --unit=envoy.service \
  bash -c "/usr/bin/envoy --config-path ${ENVOY_CONFIG} | tee"

# Configure iptables for traffic interception and redirection
sudo ${ENVOY_USER_HOME}/iptables.sh \
  -p "${ENVOY_PORT}" \
  -u "${ENVOY_USER_UID}" \
  -g "${ENVOY_USER_GID}" \
  -m "REDIRECT" \
  -i "${INTERCEPTED_CIDRS}" \
  -x "${GCE_METADATA_SERVER}"

מכונה וירטואלית של Compute gRPC xDS

בדומה ל-Cloud Service Mesh גלובלי, לקוחות gRPC צריכים להגדיר bootstrap כדי לציין איך להתחבר ל-Cloud Service Mesh אזורי.

אפשר להשתמש במחולל האתחול של gRPC כדי ליצור את האתחול הזה. כדי להגדיר שימוש ב-Cloud Service Mesh אזורי, מציינים דגל חדש: --xds-server-region.

בדוגמה הזו, הגדרת xds-server-region ל-us-central1 קובעת באופן אוטומטי את נקודת הקצה האזורית של Cloud Service Mesh: trafficdirector.us-central1.rep.googleapis.com:443.

K8s Manual Envoy Injection

השלבים הידניים מבוססים על הגדרה של פודים של Google Kubernetes Engine באמצעות הזרקה ידנית של Envoy. עם זאת, צריך לשנות רק את הקטע בנושא הוספה ידנית של פודים.

  1. שינוי מישור הבקרה מגלובלי לאזורי:

    wget -q -O - https://storage.googleapis.com/traffic-director/demo/trafficdirector_client_new_api_sample_xdsv3.yaml

sed -i "s/PROJECT_NUMBER/PROJECT_NUMBER/g" trafficdirector_client_new_api_sample_xdsv3.yaml

sed -i "s/MESH_NAME/MESH_NAME/g" trafficdirector_client_new_api_sample_xdsv3.yaml

sed -i "s|trafficdirector.googleapis.com|trafficdirector.${REGION}.rep.googleapis.com|g" trafficdirector_client_new_api_sample_xdsv3.yaml

sed -i "s|gcr.io/google-containers/busybox|busybox:stable|g" trafficdirector_client_new_api_sample_xdsv3.yaml

    1. מחילים את השינויים:

      kubectl apply -f trafficdirector_client_new_api_sample_xdsv3.yaml

מדריכי הגדרה

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

הגדרת שירותי gRPC ללא proxy באמצעות GRPCRoute אזורי ו-Cloud Service Mesh אזורי

בקטע הזה מוסבר איך להגדיר רשת Service mesh של gRPC בלי שרת Proxy באמצעות Cloud Service Mesh אזורי ומשאבי GRPCRoute אזוריים.

כדי שתוכלו להעתיק ולהדביק את כל הדוגמאות במדריך הזה בשורת הפקודה, כדאי לשמור את מספר הפרויקט שבו אתם מבצעים את ההגדרה: Google Cloud 

export PROJECT="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-a"

מחליפים את PROJECT_NUMBER במספר הפרויקט.

אפשר גם להחליף את הפרטים הבאים:

  • us-central1 עם אזור אחר שבו רוצים להשתמש.
  • us-central1-a עם אזור אחר שרוצים להשתמש בו.
  • ‫default עם VPC_NAME אחר.

הגדרת רשת Mesh

כשמחוברים לאפליקציית gRPC בלי שרת Proxy ל-xds://hostname, ספריית הלקוח של gRPC יוצרת חיבור ל-Cloud Service Mesh כדי לקבל את הגדרות הניתוב שנדרשות לניתוב בקשות לשם המארח.

  1. יוצרים מפרט של רשת ושומרים אותו בקובץ mesh.yaml:

    cat <<EOF > mesh.yaml
name: grpc-mesh
EOF

  2. יוצרים רשת באמצעות המפרט mesh.yaml:

    gcloud network-services meshes import grpc-mesh \
    --source=mesh.yaml \
    --location=${REGION}

    אחרי שיוצרים את הרשת האזורית, Cloud Service Mesh מוכן להציג את ההגדרה. עם זאת, מכיוון שעדיין לא הוגדרו שירותים, ההגדרה ריקה.

הגדרת שירות gRPC

לצורך ההדגמה, תיצרו שירות backend אזורי עם מכונות וירטואליות (VM) שניתנות לשינוי גודל אוטומטי (באמצעות קבוצות של מופעים מנוהלים – MIG) שישרתו את hello world באמצעות פרוטוקול gRPC ביציאה 50051.

  1. יוצרים תבנית של הגדרות מכונה ב-Compute Engine עם שירות gRPC‏ helloworld שנחשף ביציאה 50051:

    gcloud compute instance-templates create grpc-td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=allow-health-checks \
  --image-family=debian-11 \
  --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.38.0.tar.gz | tar -xz
cd grpc-java-1.38.0/examples/example-hostname
../gradlew --no-daemon installDist
# Server listens on 50051
sudo systemd-run ./build/install/hostname-server/bin/hostname-server')

  2. יוצרים קבוצת MIG על סמך התבנית:

    gcloud compute instance-groups managed create grpc-td-mig-us-central1 \
  --zone=${ZONE} \
  --size=2 \
  --template=grpc-td-vm-template

  3. מגדירים יציאה עם שם לשירות gRPC. זו היציאה שבה שירות gRPC מוגדר להאזין לבקשות.

    gcloud compute instance-groups set-named-ports grpc-td-mig-us-central1 \
  --named-ports=grpc-helloworld-port:50051 \
  --zone=${ZONE}

    בדוגמה הזו, היציאה היא 50051.

  4. יצירת בדיקות תקינות של gRPC.

    gcloud compute health-checks create grpc grpc-helloworld-health-check \
  --use-serving-port --region=${REGION}

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

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

    gcloud compute firewall-rules create grpc-vm-allow-health-checks \
  --network default --action allow --direction INGRESS \
  --source-ranges 35.191.0.0/16,209.85.152.0/22,209.85.204.0/22 \
  --target-tags allow-health-checks \
  --rules tcp:50051

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

    gcloud compute backend-services create grpc-helloworld-service \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --protocol=GRPC \
    --port-name=grpc-helloworld-port \
  --health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/grpc-helloworld-health-check" \
    --region=${REGION}

  7. מוסיפים את קבוצת מופעי המכונה המנוהלים אל BackendService:

    gcloud compute backend-services add-backend grpc-helloworld-service \
  --instance-group=grpc-td-mig-us-central1 \
  --instance-group-zone=${ZONE} \
  --region=${REGION}

הגדרת ניתוב באמצעות GRPCRoute אזורי

בשלב הזה, הרשת האזורית ושירות שרת ה-gRPC מוגדרים. עכשיו אפשר להגדיר את הניתוב הנדרש.

  1. יוצרים מפרט של GRPCRoute אזורי ושומרים אותו בקובץ grpc_route.yaml:

    cat <<EOF > grpc_route.yaml
name: helloworld-grpc-route
hostnames:
- helloworld-gce
meshes:
- projects/${PROJECT}/locations/${REGION}/meshes/grpc-mesh
rules:
- action:
    destinations:
    - serviceName: projects/${PROJECT}/locations/${REGION}/backendServices/grpc-helloworld-service
EOF

  2. יוצרים GRPCRoute אזורי באמצעות המפרט grpc_route.yaml:

    gcloud network-services grpc-routes import helloworld-grpc-route \
    --source=grpc_route.yaml \
    --location=${REGION}

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

יצירת שירות לקוח gRPC

כדי לאמת את ההגדרה, יוצרים מופע של אפליקציית לקוח עם מישור נתונים של gRPC בלי שרת Proxy. באפליקציה הזו צריך לציין (בקובץ האתחול שלה) את השם של הרשת.

אחרי ההגדרה, האפליקציה הזו יכולה לשלוח בקשה למופעים או לנקודות הקצה שמשויכות ל-helloworld-gce באמצעות ה-URI של השירות xds:///helloworld-gce.

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

  1. יוצרים מכונה וירטואלית של לקוח:

    gcloud compute instances create grpc-client \
  --zone=${ZONE}\
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --metadata-from-file=startup-script=<(echo '#! /bin/bash
set -ex
export PROJECT=PROJECT_NUMBER
export REGION=us-central1
export GRPC_XDS_BOOTSTRAP=/run/td-grpc-bootstrap.json
echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh
curl -L https://storage.googleapis.com/traffic-director/td-grpc-bootstrap-0.18.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.18.0/td-grpc-bootstrap --config-mesh=grpc-mesh --xds-server-uri=trafficdirector.${REGION}.rep.googleapis.com:443 --gcp-project-number=${PROJECT} | sudo tee $GRPC_XDS_BOOTSTRAP
sudo sed -i "s|\"authorities\": {|\"authorities\": {\n    \"traffic-director.${REGION}.xds.googleapis.com\": {\"xds_servers\":[{\"server_uri\": \"trafficdirector.${REGION}.rep.googleapis.com:443\", \"channel_creds\": [ { \"type\": \"google_default\" } ], \"server_features\": [ \"xds_v3\", \"ignore_resource_deletion\" ]}], \"client_listener_resource_name_template\": \"xdstp://traffic-director.${REGION}.xds.googleapis.com/envoy.config.listener.v3.Listener/${PROJECT}/mesh:grpc-mesh/%s\"},|g" $GRPC_XDS_BOOTSTRAP
sudo sed -i "s|\"client_default_listener_resource_name_template\": \"xdstp://traffic-director-global.xds.googleapis.com|\"client_default_listener_resource_name_template\": \"xdstp://traffic-director.${REGION}.xds.googleapis.com|g" $GRPC_XDS_BOOTSTRAP')

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

אפליקציית הלקוח צריכה קובץ תצורת bootstrap. סקריפט לטעינה בזמן ההפעלה בסעיף הקודם מגדיר את משתנה הסביבה GRPC_XDS_BOOTSTRAP ומשתמש בסקריפט עזר כדי ליצור את קובץ האתחול. הערכים של TRAFFICDIRECTOR_GCP_PROJECT_NUMBER והאזור בקובץ האתחול שנוצר מתקבלים משרת המטא-נתונים שמכיר את הפרטים האלה לגבי המכונות הווירטואליות ב-Compute Engine.

אפשר לספק את הערכים האלה לסקריפט העזר באופן ידני באמצעות האפשרות -gcp-project-number. צריך לספק שם רשת שתואם למשאב הרשת באמצעות האפשרות -config-mesh-experimental.

  1. כדי לאמת את ההגדרה, נכנסים ללקוח:

    gcloud compute ssh grpc-client --zone=${ZONE}

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

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

  3. מריצים את הכלי grpcurl עם xds:///helloworld-gce כמזהה המשאבים האחיד (URI) של השירות ועם helloworld.Greeter/SayHello כשם השירות והשיטה להפעלה.

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

    הפרמטרים של השיטה SayHello מועברים באמצעות האפשרות ‎-d.

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

    Greeting: Hello world, from INSTANCE_HOSTNAME

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

הגדרת שרת proxy של Envoy sidecar עם שירותי HTTP באמצעות HTTPRoute אזורי ו-Mesh אזורי

בקטע הזה מוסבר איך להגדיר Service mesh מבוסס-Envoy proxy עם משאבי HTTPRoute אזוריים ורשת אזורית.

כדי שתוכלו להעתיק ולהדביק את כל הדוגמאות במדריך הזה בשורת הפקודה, כדאי לשמור את מספר הפרויקט שבו אתם מבצעים את ההגדרה: Google Cloud 

export PROJECT_ID="PROJECT_ID"
export PROJECT="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-a"

מחליפים את מה שכתוב בשדות הבאים:

  • PROJECT_ID במזהה הפרויקט.
  • PROJECT_NUMBER במספר הפרויקט.

אפשר גם להחליף את הפרטים הבאים:

  • us-central1 עם אזור אחר שבו רוצים להשתמש.
  • us-central1-a עם אזור אחר שרוצים להשתמש בו.

הגדרת רשת Mesh

שרת ה-proxy של Envoy מסוג sidecar מקבל את הגדרת הניתוב של השירות מ-Cloud Service Mesh. ה-sidecar מציג את השם של משאב הרשת האזורית כדי לזהות את רשת השירות הספציפית שהוגדרה. הגדרת הניתוב שמתקבלת מ-Cloud Service Mesh משמשת להפניית תעבורת הנתונים שעוברת דרך ה-proxy של קובץ העזר החיצוני לשירותי קצה עורפי אזוריים שונים, בהתאם לפרמטרים של הבקשה, כמו שם המארח או שורות הכותרות, שהוגדרו במשאבי המסלול.

שימו לב: שם הרשת הוא המפתח ששרת ה-proxy מסוג קובץ עזר חיצוני משתמש בו כדי לבקש את ההגדרה שמשויכת לרשת הזו.

  1. יוצרים מפרט של רשת אזורית ושומרים אותו בקובץ mesh.yaml:

    cat <<EOF > mesh.yaml
name: sidecar-mesh
EOF

    אם לא מציינים ערך, יציאת היירוט היא 15001 כברירת מחדל.

  2. יוצרים רשת אזורית באמצעות המפרט mesh.yaml:

    gcloud network-services meshes import sidecar-mesh \
    --source=mesh.yaml \
    --location=${REGION}

    אחרי שיוצרים את הרשת האזורית, Cloud Service Mesh מוכן להציג את ההגדרה. עם זאת, מכיוון שעדיין לא הוגדרו שירותים, ההגדרה תהיה ריקה.

הגדרת שרת HTTP

לצורך ההדגמה, תיצרו שירות בק-אנד אזורי עם מכונות וירטואליות שניתנות להרחבה אוטומטית (באמצעות קבוצות של מופעי מכונה מנוהלים – MIG) שיציגו את המחרוזת hello world באמצעות פרוטוקול gRPC ביציאה 80.

  1. יוצרים תבנית של הגדרות מכונה ב-Compute Engine עם שירות helloworld HTTP שנחשף ביציאה 80:

    gcloud compute instance-templates create td-httpd-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=http-td-server \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --metadata=startup-script="#! /bin/bash

sudo apt-get update -y
sudo apt-get install apache2 -y
sudo service apache2 restart
echo '<!doctype html><html><body><h1>'\`/bin/hostname\`'</h1></body></html>' | sudo tee /var/www/html/index.html"

  2. יוצרים קבוצת MIG על סמך התבנית:

    gcloud compute instance-groups managed create http-td-mig-us-central1 \
  --zone=${ZONE} \
  --size=2 \
  --template=td-httpd-vm-template

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

    gcloud compute health-checks create http http-helloworld-health-check --region=${REGION}

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

    gcloud compute firewall-rules create http-vm-allow-health-checks \
  --network default --action allow --direction INGRESS \
  --source-ranges 35.191.0.0/16,209.85.152.0/22,209.85.204.0/22 \
  --target-tags http-td-server \
  --rules tcp:80

  5. יוצרים שירות לקצה העורפי אזורי עם תוכנית לאיזון עומסים מסוג INTERNAL_SELF_MANAGED:

    gcloud compute backend-services create http-helloworld-service \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --protocol=HTTP \
--health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/http-helloworld-health-check" \
    --region=${REGION}

  6. מוסיפים את בדיקת תקינות ואת קבוצת המופעים המנוהלת או הלא מנוהלת לשירות הקצה העורפי:

    gcloud compute backend-services add-backend http-helloworld-service \
  --instance-group=http-td-mig-us-central1 \
  --instance-group-zone=${ZONE} \
  --region=${REGION}

    בדוגמה הזו נעשה שימוש בקבוצת מופעי מכונה מנוהלים עם תבנית של מכונת VM ב-Compute Engine שמריצה את שירות ה-HTTP לדוגמה שיצרנו קודם.

הגדרת ניתוב באמצעות HTTPRoute אזורי

משאב ה-Mesh ושרת ה-HTTP מוגדרים. עכשיו אפשר לחבר אותם באמצעות משאב HTTPRoute שמשייך שם מארח לשירות Backend.

  1. יוצרים מפרט HTTPRoute ושומרים אותו כ-http_route.yaml:

    cat <<EOF > http_route.yaml
name: helloworld-http-route
hostnames:
- helloworld-gce
meshes:
- projects/${PROJECT}/locations/${REGION}/meshes/sidecar-mesh
rules:
- action:
    destinations:
    - serviceName: projects/${PROJECT}/locations/${REGION}/backendServices/http-helloworld-service
EOF

  2. יוצרים את HTTPRoute באמצעות המפרט http_route.yaml:

    gcloud network-services http-routes import helloworld-http-route \
    --source=http_route.yaml \
    --location=${REGION}

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

יצירת לקוח HTTP עם קובץ עזר של Envoy

בקטע הזה יוצרים מופע של מכונת VM של לקוח עם פרוקסי Envoy sidecar כדי לבקש את ההגדרה של Cloud Service Mesh שנוצרה קודם. שימו לב שהפרמטר mesh בפקודה של Google Cloud CLI מתייחס למשאב הרשת שיצרתם קודם.

gcloud compute instance-templates create td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=http-td-tag,http-server,https-server \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --metadata=startup-script='#! /usr/bin/env bash

# Set variables
export ENVOY_CONTROL_PLANE_REGION="us-central1"
export ENVOY_USER="envoy"
export ENVOY_USER_UID="1337"
export ENVOY_USER_GID="1337"
export ENVOY_USER_HOME="/opt/envoy"
export ENVOY_CONFIG="${ENVOY_USER_HOME}/config.yaml"
export ENVOY_PORT="15001"
export ENVOY_ADMIN_PORT="15000"
export ENVOY_INBOUND_PORT="15006"
export ENVOY_TRACING_ENABLED="false"
export ENVOY_XDS_SERVER_CERT="/etc/ssl/certs/ca-certificates.crt"
export ENVOY_ACCESS_LOG="/dev/stdout"
export ENVOY_NODE_ID="$(cat /proc/sys/kernel/random/uuid)~$(hostname -i)"
export BOOTSTRAP_TEMPLATE="${ENVOY_USER_HOME}/bootstrap_template.yaml"
export GCE_METADATA_SERVER="169.254.169.254/32"
export INTERCEPTED_CIDRS="*"
export GCP_PROJECT_NUMBER=PROJECT_NUMBER
export VPC_NETWORK_NAME=mesh:sidecar-mesh
export GCE_ZONE=$(curl -sS -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/instance/zone | cut -d"/" -f4)

# Create system user account for Envoy binary
sudo groupadd ${ENVOY_USER} \
  --gid=${ENVOY_USER_GID} \
  --system
sudo adduser ${ENVOY_USER} \
  --uid=${ENVOY_USER_UID} \
  --gid=${ENVOY_USER_GID} \
  --home=${ENVOY_USER_HOME} \
  --disabled-login \
  --system
# Download and extract the Cloud Service Mesh tar.gz file
cd ${ENVOY_USER_HOME}
sudo curl -sL https://storage.googleapis.com/traffic-director/traffic-director-xdsv3.tar.gz -o traffic-director-xdsv3.tar.gz
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/bootstrap_template.yaml \
  -C bootstrap_template.yaml \
  --strip-components 1
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/iptables.sh \
  -C iptables.sh \
  --strip-components 1
sudo rm traffic-director-xdsv3.tar.gz

# Generate Envoy bootstrap configuration
cat "${BOOTSTRAP_TEMPLATE}" \
  | sed -e "s|ENVOY_NODE_ID|${ENVOY_NODE_ID}|g" \
  | sed -e "s|ENVOY_ZONE|${GCE_ZONE}|g" \
  | sed -e "s|VPC_NETWORK_NAME|${VPC_NETWORK_NAME}|g" \
  | sed -e "s|CONFIG_PROJECT_NUMBER|${GCP_PROJECT_NUMBER}|g" \
  | sed -e "s|ENVOY_PORT|${ENVOY_PORT}|g" \
  | sed -e "s|ENVOY_ADMIN_PORT|${ENVOY_ADMIN_PORT}|g" \
  | sed -e "s|XDS_SERVER_CERT|${ENVOY_XDS_SERVER_CERT}|g" \
  | sed -e "s|TRACING_ENABLED|${ENVOY_TRACING_ENABLED}|g" \
  | sed -e "s|ACCESSLOG_PATH|${ENVOY_ACCESS_LOG}|g" \
  | sed -e "s|BACKEND_INBOUND_PORTS|${BACKEND_INBOUND_PORTS}|g" \
  | sed -e "s|ENVOY_INBOUND_PORT|${ENVOY_INBOUND_PORT}|g" \
  | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
  | sudo tee "${ENVOY_CONFIG}"

# Install Envoy binary
wget -O envoy_key https://apt.envoyproxy.io/signing.key
cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
sudo apt-get update
sudo apt-get install envoy

# Run Envoy as systemd service
sudo systemd-run --uid=${ENVOY_USER_UID} --gid=${ENVOY_USER_GID} \
  --working-directory=${ENVOY_USER_HOME} --unit=envoy.service \
  bash -c "/usr/bin/envoy --config-path ${ENVOY_CONFIG} | tee"

# Configure iptables for traffic interception and redirection
sudo ${ENVOY_USER_HOME}/iptables.sh \
  -p "${ENVOY_PORT}" \
 -u "${ENVOY_USER_UID}" \
  -g "${ENVOY_USER_GID}" \
  -m "REDIRECT" \
  -i "${INTERCEPTED_CIDRS}" \
  -x "${GCE_METADATA_SERVER}"
'

gcloud compute instances create td-vm-client \
  --zone=${ZONE} \
  --source-instance-template td-vm-template

  1. מתחברים למכונה הווירטואלית שנוצרה:

    gcloud compute ssh td-vm-client --zone=${ZONE}

  2. בודקים את הקישוריות של HTTP לשירותי הבדיקה שנוצרו:

    curl -H "Host: helloworld-gce" http://10.0.0.1/

    הפקודה מחזירה תגובה מאחת ממכונות ה-VM בקבוצת המופעים המנוהלת, עם שם המארח שלה שמוצג במסוף.

הגדרת שירותי TCP באמצעות TCPRoute אזורי

תהליך ההגדרה הזה דומה מאוד להגדרת שרתי proxy של Envoy עם שירותי HTTP, אבל יש הבדל אחד: שירות ה-Backend מספק שירות TCP וניתוב שמבוסס על פרמטרים של TCP/IP ולא על פרוטוקול HTTP.

כדי שתוכלו להעתיק ולהדביק את כל הדוגמאות במדריך הזה בשורת הפקודה, כדאי לשמור את מספר הפרויקט שבו אתם מבצעים את ההגדרה: Google Cloud 

export PROJECT_ID="PROJECT_ID"
export PROJECT="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-a"

מחליפים את מה שכתוב בשדות הבאים:

  • PROJECT_ID במזהה הפרויקט.
  • PROJECT_NUMBER במספר הפרויקט.

אפשר גם להחליף את הפרטים הבאים:

  • us-central1 עם אזור אחר שבו רוצים להשתמש.
  • us-central1-a עם אזור אחר שרוצים להשתמש בו.

הגדרת רשת Mesh

  1. יוצרים מפרט של רשת אזורית ושומרים אותו בקובץ mesh.yaml:

    cat <<EOF > mesh.yaml
name: sidecar-mesh
EOF

  2. יוצרים רשת אזורית באמצעות המפרט mesh.yaml:

    gcloud network-services meshes import sidecar-mesh \
    --source=mesh.yaml \
    --location=${REGION}

הגדרת שרת TCP

לצורך ההדגמה, תיצרו שירות קצה עורפי אזורי עם מכונות וירטואליות (VM) שניתנות להרחבה אוטומטית (באמצעות קבוצות של מופעים מנוהלים – MIG) שיציגו את המחרוזת "hello world" באמצעות פרוטוקול gRPC ביציאה 10000.

  1. יוצרים את תבנית של הגדרות מכונה ב-Compute Engine עם שירות בדיקה ביציאה 10000 באמצעות כלי netcat:

    gcloud compute instance-templates create tcp-td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=allow-health-checks \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --metadata=startup-script="#! /bin/bash
sudo apt-get update -y
sudo apt-get install netcat -y
while true;
  do echo 'Hello from TCP service' | nc -l -s 0.0.0.0 -p 10000;
done &"

  2. יוצרים קבוצת MIG על סמך התבנית:

    gcloud compute instance-groups managed create tcp-td-mig-us-central1 \
  --zone=${ZONE} \
  --size=1 \
  --template=tcp-td-vm-template

  3. מגדירים את היציאות עם השמות בקבוצת מופעי מכונה מנוהלים שנוצרה לערך port 10000:

    gcloud compute instance-groups set-named-ports tcp-td-mig-us-central1 \
  --zone=${ZONE} --named-ports=tcp:10000

  4. יוצרים בדיקת תקינות אזורית:

    gcloud compute health-checks create tcp tcp-helloworld-health-check --port 10000 --region=${REGION}

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

    gcloud compute firewall-rules create tcp-vm-allow-health-checks \
  --network default --action allow --direction INGRESS \
  --source-ranges 35.191.0.0/16,209.85.152.0/22,209.85.204.0/22 \
  --target-tags allow-health-checks \
  --rules tcp:10000

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

    gcloud compute backend-services create tcp-helloworld-service \
    --region=${REGION} \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --protocol=TCP \
    --port-name=tcp \
    --health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/tcp-helloworld-health-check"

  7. מוסיפים את ה-MIG ל-BackendService:

    gcloud compute backend-services add-backend tcp-helloworld-service \
  --instance-group tcp-td-mig-us-central1 \
  --instance-group-zone=${ZONE} \
  --region=${REGION}

הגדרת ניתוב באמצעות TCPRoute אזורי

  1. יוצרים מפרט TCPRoute ומאחסנים אותו בקובץ tcp_route.yaml:

    cat <<EOF > tcp_route.yaml
name: helloworld-tcp-route
meshes:
- projects/${PROJECT}/locations/${REGION}/meshes/sidecar-mesh
rules:
- action:
    destinations:
    - serviceName: projects/${PROJECT}/locations/${REGION}/backendServices/tcp-helloworld-service
  matches:
  - address: '10.0.0.1/32'
    port: '10000'
EOF

  2. יוצרים TCPRoute באמצעות המפרט tcp_route.yaml:

    gcloud network-services tcp-routes import helloworld-tcp-route \
    --source=tcp_route.yaml \
    --location=${REGION}

יצירת לקוח TCP עם קובץ עזר של Envoy

  1. יצירת מכונה וירטואלית עם Envoy שמחובר ל-Cloud Service Mesh:

    gcloud compute instance-templates create td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=http-td-tag,http-server,https-server \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --metadata=startup-script='#! /usr/bin/env bash

# Set variables
export ENVOY_CONTROL_PLANE_REGION="us-central1"
export ENVOY_USER="envoy"
export ENVOY_USER_UID="1337"
export ENVOY_USER_GID="1337"
export ENVOY_USER_HOME="/opt/envoy"
export ENVOY_CONFIG="${ENVOY_USER_HOME}/config.yaml"
export ENVOY_PORT="15001"
export ENVOY_ADMIN_PORT="15000"
export ENVOY_TRACING_ENABLED="false"
export ENVOY_XDS_SERVER_CERT="/etc/ssl/certs/ca-certificates.crt"
export ENVOY_ACCESS_LOG="/dev/stdout"
export ENVOY_NODE_ID="$(cat /proc/sys/kernel/random/uuid)~$(hostname -i)"
export BOOTSTRAP_TEMPLATE="${ENVOY_USER_HOME}/bootstrap_template.yaml"
export GCE_METADATA_SERVER="169.254.169.254/32"
export INTERCEPTED_CIDRS="*"
export GCP_PROJECT_NUMBER=PROJECT_NUMBER
export VPC_NETWORK_NAME=mesh:sidecar-mesh

export GCE_ZONE=$(curl -sS -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/instance/zone | cut -d"/" -f4)

# Create system user account for Envoy binary
sudo groupadd ${ENVOY_USER} \
  --gid=${ENVOY_USER_GID} \
  --system
sudo adduser ${ENVOY_USER} \
  --uid=${ENVOY_USER_UID} \
  --gid=${ENVOY_USER_GID} \
  --home=${ENVOY_USER_HOME} \
  --disabled-login \
  --system
# Download and extract the Cloud Service Mesh tar.gz file
cd ${ENVOY_USER_HOME}
sudo curl -sL https://storage.googleapis.com/traffic-director/traffic-director-xdsv3.tar.gz -o traffic-director-xdsv3.tar.gz
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/bootstrap_template.yaml \
  -C bootstrap_template.yaml \
  --strip-components 1
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/iptables.sh \
  -C iptables.sh \
  --strip-components 1
sudo rm traffic-director-xdsv3.tar.gz

# Generate Envoy bootstrap configuration
cat "${BOOTSTRAP_TEMPLATE}" \
  | sed -e "s|ENVOY_NODE_ID|${ENVOY_NODE_ID}|g" \
  | sed -e "s|ENVOY_ZONE|${GCE_ZONE}|g" \
  | sed -e "s|VPC_NETWORK_NAME|${VPC_NETWORK_NAME}|g" \
  | sed -e "s|CONFIG_PROJECT_NUMBER|${GCP_PROJECT_NUMBER}|g" \
  | sed -e "s|ENVOY_PORT|${ENVOY_PORT}|g" \
  | sed -e "s|ENVOY_ADMIN_PORT|${ENVOY_ADMIN_PORT}|g" \
  | sed -e "s|XDS_SERVER_CERT|${ENVOY_XDS_SERVER_CERT}|g" \
  | sed -e "s|TRACING_ENABLED|${ENVOY_TRACING_ENABLED}|g" \
  | sed -e "s|ACCESSLOG_PATH|${ENVOY_ACCESS_LOG}|g" \
  | sed -e "s|BACKEND_INBOUND_PORTS|${BACKEND_INBOUND_PORTS}|g" \
  | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
  | sudo tee "${ENVOY_CONFIG}"

# Install Envoy binary
wget -O envoy_key https://apt.envoyproxy.io/signing.key
cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
sudo apt-get update
sudo apt-get install envoy

# Run Envoy as systemd service
sudo systemd-run --uid=${ENVOY_USER_UID} --gid=${ENVOY_USER_GID} \
  --working-directory=${ENVOY_USER_HOME} --unit=envoy.service \
  bash -c "/usr/bin/envoy --config-path ${ENVOY_CONFIG} | tee"

# Configure iptables for traffic interception and redirection
sudo ${ENVOY_USER_HOME}/iptables.sh \
  -p "${ENVOY_PORT}" \
-u "${ENVOY_USER_UID}" \
  -g "${ENVOY_USER_GID}" \
  -m "REDIRECT" \
  -i "${INTERCEPTED_CIDRS}" \
  -x "${GCE_METADATA_SERVER}"
'

gcloud compute instances create td-vm-client \
  --zone=${ZONE} \
  --source-instance-template td-vm-template

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

    gcloud compute ssh td-vm-client --zone=${ZONE}

  3. בודקים את הקישוריות לשירותי הבדיקה שנוצרו:

    curl 10.0.0.1:10000 --http0.9 -v

    אמור להופיע הטקסט Hello from TCP service שמוחזר אליכם, וגם הטקסט שתקלידו יוחזר אליכם על ידי שירות netcat שפועל במכונה הווירטואלית המרוחקת.

הגדרת רשת אזורית בפרויקט המארח

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

  1. מגדירים משתנה שישמש לאורך כל הדוגמה:

    export REGION="us-central1"

    אפשר גם להחליף את us-central1 באזור אחר שרוצים להשתמש בו.

  2. יוצרים מפרט של הרשת ומאחסנים אותו בקובץ mesh.yaml:

    cat <<EOF > mesh.yaml
name: shared-mesh
EOF

  3. מגדירים משאב של רשת בפרויקט הזה עם ההגדרה הנדרשת:

    gcloud network-services meshes import shared-mesh \
    --source=mesh.yaml \
    --location=${REGION}

    שימו לב ל-URI המלא של משאב הרשת הזה. בעלי השירות יצטרכו את זה בעתיד כדי לצרף את המסלולים שלהם לרשת הזו.

  4. נותנים את הרשאת ה-IAM‏ networkservices.meshes.use לרשת הזו ולחשבונות השירות בפרויקטים שונים שאמורים להיות להם אפשרות לצרף את פרטי השירותים שלהם לרשת הזו:

    gcloud projects add-iam-policy-binding HOST_PROJECT_NUMBER --member='HTTP_ROUTE_SERVICE_OWNER_ACCOUNT' --role='roles/compute.networkAdmin'

    עכשיו כל בעלי השירותים שיש להם הרשאה networkservices.meshes.use יכולים להוסיף את כללי הניתוב שלהם לרשת הזו.

הגדרת מסלולים בפרויקטים של שירותים

כל בעלי השירות צריכים ליצור פרויקט עם משאבי Backend Service אזוריים ומשאבי Route אזוריים, בדומה להגדרת שרתי proxy של Envoy עם שירותי HTTP. ההבדל היחיד הוא שבכל HTTPRoute/GRPCRoute/TCPRoute יהיה ה-URI של משאב הרשת של פרויקט המארח בשדה meshes.

  1. יוצרים את המסלול sharedvpc-http-route:

    echo "name: sharedvpc-http-route
hostnames:
- helloworld-gce
meshes:
- /projects/HOST_PROJECT_NUMBER/locations/${REGION}/meshes/shared-mesh
rules:
- action:
    destinations:
    - serviceName: \"SERVICE_URL\"" | \
gcloud network-services http-routes import sharedvpc-http-route \
    --source=- \
    --location=${REGION}

הגדרת שירותי לקוחות בפרויקטים של שירות

במהלך ההגדרה של לקוח Cloud Service Mesh (Envoy proxy או proxyless) שנמצא בפרויקט שירות, צריך לציין את מספר הפרויקט שבו נמצא משאב הרשת ואת שם הרשת בהגדרת ה-bootstrap שלו.sh TRAFFICDIRECTOR_GCP_PROJECT_NUMBER=HOST_PROJECT_NUMBER TRAFFICDIRECTOR_MESH_NAME=MESH_NAME

הגדרת קצה עורפי של שירות שפורסם עבור Cloud Service Mesh אזורי

בק-אנדים של שירותים שפורסמו מאפשרים לכם להגדיר את Cloud Service Mesh האזורי כדי לנתב תנועה לשירותים שפורסמו דרך Private Service Connect.

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

לפני שמבצעים את השלבים בקטעים הבאים, צריך:

  • מוודאים שרשתות ה-VPC של הספק והצרכן שייכות לאותו ארגון.
  • מזהים את ה-URI של קובץ השירות של השירות שאליו רוצים לגשת.
  • מזהים את השם של רשת ה-VPC שבה ישתמשו הלקוחות של Cloud Service Mesh. ההגדרה הזו נדרשת להגדרת TRAFFICDIRECTOR_NETWORK_NAME.

הגדרה של משתני סביבה

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

export PROJECT_NUMBER="PROJECT_NUMBER"
export REGION="us-central1"
export MESH_NAME="my-mesh"
export NETWORK_NAME="default"
export SUBNET_NAME="default"
export SERVICE_ATTACHMENT_URI="SERVICE_ATTACHMENT_URI"
export BACKEND_SERVICE_NAME="published-service-backend"

הגדרת לקוח

כדי לוודא שנקודות הקצה הנכונות של Private Service Connect מועברות ללקוחות Cloud Service Mesh (Envoy או gRPC בלי שרת Proxy), צריך לכלול את המשתנה TRAFFICDIRECTOR_NETWORK_NAME במטא-נתונים של הצומת.

TRAFFICDIRECTOR_GCP_PROJECT_NUMBER=${PROJECT_NUMBER}
TRAFFICDIRECTOR_MESH_NAME=${MESH_NAME}
TRAFFICDIRECTOR_NETWORK_NAME=${NETWORK_NAME}

יצירת רשת Mesh אזורית

gcloud network-services meshes import ${MESH_NAME} \
    --location=${REGION} \
    --source=- <<EOF
name: ${MESH_NAME}
EOF

יצירת נקודת קצה של Private Service Connect

כדי להתחבר לקובץ המצורף עם השירות, צריך נקודת קצה של Private Service Connect ברשת הצרכן.

  1. שמירת כתובת IP פנימית לנקודת הקצה. אם רשת המשנה שרוצים להשתמש בה לא קיימת, צריך ליצור אותה.

    gcloud compute addresses create psc-endpoint-ip \
    --region=${REGION} \
    --subnet=${SUBNET_NAME} \
    --purpose=GCE_ENDPOINT

  2. יוצרים את כלל ההעברה לנקודת הקצה:

    gcloud compute forwarding-rules create psc-endpoint \
    --region=${REGION} \
    --network=${NETWORK_NAME} \
    --address=psc-endpoint-ip \
    --target=${SERVICE_ATTACHMENT_URI}

יצירת שירות לקצה העורפי עם קצה עורפי של שירות שפורסם

כדי להשתמש בקצה עורפי של שירות שפורסם, מוסיפים את ה-URI של קובץ השירות כקצה עורפי לשירות הקצה העורפי האזורי.

  1. יוצרים את השירות לקצה עורפי אזורי:

    gcloud beta compute backend-services create published-service-backend \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --protocol=HTTP \
    --region=${REGION}

  2. משייכים את שירות הקצה העורפי לחיבור שירות (מחליפים את ‎ /regions ב-‎ /locations במזהה המשאבים האחיד של חיבור השירות):

    gcloud beta compute backend-services add-backend published-service-backend \
    --region=${REGION} \
    --service=${SERVICE_ATTACHMENT_URI}

הגדרת ניתוב באמצעות HTTPRoute

  • יוצרים את HTTPRoute ומצרפים אותו ל-Mesh:

    gcloud network-services http-routes import published-service-backend-route \
    --location=${REGION} \
    --source=- <<EOF
name: published-service-backend-route
hostnames:
- helloworld-gce
meshes:
- projects/${PROJECT_NUMBER}/locations/${REGION}/meshes/${MESH_NAME}
rules:
- action:
    destinations:
    - serviceName: projects/${PROJECT_NUMBER}/locations/${REGION}/backendServices/${BACKEND_SERVICE_NAME}
EOF

לקוחות ברשת יכולים עכשיו לגשת לשירות שפורסם באמצעות שם המארח helloworld-gce.

ניתוב TLS של שער

בקטע הזה מוסבר איך להגדיר שער כניסה (ingress) מבוסס-פרוקסי של Envoy עם משאבי Gateway אזוריים ו-TLSRoute אזוריים.

מאזן עומסי רשת אזורי חיצוני להעברת סיגנל ללא שינוי מפנה את התעבורה לשרתי proxy של Envoy שפועלים כשער כניסה. שרתי ה-proxy של Envoy משתמשים בניתוב TLS passthrough ומפנים את התנועה ישירות לשרתי HTTPS שפועלים במופעי המכונות הווירטואליות של הבק-אנד.

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

export PROJECT_ID="PROJECT_ID"
export PROJECT_NUMBER="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-b"
export NETWORK_NAME = "default"

מחליפים את מה שכתוב בשדות הבאים: default

  • PROJECT_ID במזהה הפרויקט.
  • PROJECT_NUMBER במספר הפרויקט.

אפשר גם להחליף את הפרטים הבאים:

  • us-central1 עם אזור אחר שבו רוצים להשתמש.
  • us-central1-b עם אזור אחר שרוצים להשתמש בו.
  • default בשם רשת אחר שרוצים להשתמש בו.

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

יש תרחישים שבהם הגדרת Service mesh כוללת שירותים שנמצאים בבעלות של פרויקטים שונים. לדוגמה, בפריסות של VPC משותף או של רשתות VPC מקושרות, כל בעל פרויקט יכול להגדיר קבוצה משלו של שירותים, כדי שהשירותים האלה יהיו זמינים לכל הפרויקטים האחרים.

ההגדרה הזו היא 'בין פרויקטים' כי כמה משאבים שמוגדרים בפרויקטים שונים משולבים יחד ליצירת הגדרה אחת שאפשר להעביר לשרת proxy או ללקוח בלי שרת Proxy.

הגדרת כללים לחומת אש

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

    gcloud compute firewall-rules create allow-gateway-health-checks \
--network=${NETWORK_NAME} \
--direction=INGRESS \
--action=ALLOW \
--rules=tcp \
--source-ranges="35.191.0.0/16,209.85.152.0/22,209.85.204.0/22" \
--target-tags=gateway-proxy

הגדרת הרשאות IAM

  1. יוצרים זהות של חשבון שירות לשרתי ה-proxy של השער:

    gcloud iam service-accounts create gateway-proxy

  2. מקצים את תפקידי ה-IAM הנדרשים לזהות של חשבון השירות:

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/trafficdirector.client"

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/logging.logWriter"

מגדירים את השער האזורי:

  1. יוצרים קובץ בשם gateway8443.yaml עם הגדרת ה-Gateway לתנועת HTTP:

    cat <<EOF > gateway8443.yaml
name: gateway8443
scope: gateway-proxy-8443
ports:
- 8443
type: OPEN_MESH
EOF

  2. יוצרים את משאב השער האזורי באמצעות המפרט gateway8443.yaml:

    gcloud network-services gateways import gateway8443 \
    --source=gateway8443.yaml \
    --location=${REGION}

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

בקטע הזה יוצרים תבנית של הגדרות מכונה וירטואלית שמריצה פרוקסי של שירות Envoy שנפרס באופן אוטומטי. ההיקף של ה-Envoys מוגדר ל-gateway-proxy. אל תעבירו את יציאת ההצגה כפרמטר של הדגל --service-proxy.

  1. יצירת קבוצה של מופעי מכונה מנוהלים עם שרתי proxy של Envoy:

    gcloud beta compute instance-templates create gateway-proxy \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=gateway-proxy,http-td-tag,http-server,https-server \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --network-interface=network=${NETWORK_NAME} \
  --service-account="gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
  --metadata=startup-script='#! /usr/bin/env bash

# Set variables
export ENVOY_CONTROL_PLANE_REGION="us-central1"
export GCP_PROJECT_NUMBER=PROJECT_NUMBER
export VPC_NETWORK_NAME=scope:gateway-proxy-8443
export ENVOY_USER="envoy"
export ENVOY_USER_UID="1337"
export ENVOY_USER_GID="1337"
export ENVOY_USER_HOME="/opt/envoy"
export ENVOY_CONFIG="${ENVOY_USER_HOME}/config.yaml"
export ENVOY_PORT="15001"
export ENVOY_ADMIN_PORT="15000"
export ENVOY_TRACING_ENABLED="false"
export ENVOY_XDS_SERVER_CERT="/etc/ssl/certs/ca-certificates.crt"
export ENVOY_ACCESS_LOG="/dev/stdout"
export ENVOY_NODE_ID="$(cat /proc/sys/kernel/random/uuid)~$(hostname -i)"
export BOOTSTRAP_TEMPLATE="${ENVOY_USER_HOME}/bootstrap_template.yaml"
export GCE_METADATA_SERVER="169.254.169.254/32"
export INTERCEPTED_CIDRS="*"

export GCE_ZONE=$(curl -sS -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/instance/zone | cut -d"/" -f4)

# Create system user account for Envoy binary
sudo groupadd ${ENVOY_USER} \
  --gid=${ENVOY_USER_GID} \
  --system
sudo adduser ${ENVOY_USER} \
  --uid=${ENVOY_USER_UID} \
  --gid=${ENVOY_USER_GID} \
  --home=${ENVOY_USER_HOME} \
  --disabled-login \
  --system
# Download and extract the Cloud Service Mesh tar.gz file
cd ${ENVOY_USER_HOME}
sudo curl -sL https://storage.googleapis.com/traffic-director/traffic-director-xdsv3.tar.gz -o traffic-director-xdsv3.tar.gz
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/bootstrap_template.yaml \
  -C bootstrap_template.yaml \
  --strip-components 1
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/iptables.sh \
  -C iptables.sh \
  --strip-components 1
sudo rm traffic-director-xdsv3.tar.gz

# Generate Envoy bootstrap configuration
cat "${BOOTSTRAP_TEMPLATE}" \
  | sed -e "s|ENVOY_NODE_ID|${ENVOY_NODE_ID}|g" \
  | sed -e "s|ENVOY_ZONE|${GCE_ZONE}|g" \
  | sed -e "s|VPC_NETWORK_NAME|${VPC_NETWORK_NAME}|g" \
  | sed -e "s|CONFIG_PROJECT_NUMBER|${GCP_PROJECT_NUMBER}|g" \
  | sed -e "s|ENVOY_PORT|${ENVOY_PORT}|g" \
  | sed -e "s|ENVOY_ADMIN_PORT|${ENVOY_ADMIN_PORT}|g" \
  | sed -e "s|XDS_SERVER_CERT|${ENVOY_XDS_SERVER_CERT}|g" \
  | sed -e "s|TRACING_ENABLED|${ENVOY_TRACING_ENABLED}|g" \
  | sed -e "s|ACCESSLOG_PATH|${ENVOY_ACCESS_LOG}|g" \
  | sed -e "s|BACKEND_INBOUND_PORTS|${BACKEND_INBOUND_PORTS}|g" \
  | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
  | sudo tee "${ENVOY_CONFIG}"

# Install Envoy binary
wget -O envoy_key https://apt.envoyproxy.io/signing.key
cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
sudo apt-get update
sudo apt-get install envoy

# Run Envoy as systemd service
sudo systemd-run --uid=${ENVOY_USER_UID} --gid=${ENVOY_USER_GID} \
  --working-directory=${ENVOY_USER_HOME} --unit=envoy.service \
  bash -c "/usr/bin/envoy --config-path ${ENVOY_CONFIG} | tee"

# Configure iptables for traffic interception and redirection
sudo ${ENVOY_USER_HOME}/iptables.sh \
  -p "${ENVOY_PORT}" \
-u "${ENVOY_USER_UID}" \
  -g "${ENVOY_USER_GID}" \
  -m "REDIRECT" \
  -i "${INTERCEPTED_CIDRS}" \
  -x "${GCE_METADATA_SERVER}"
'

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

    gcloud compute instance-groups managed create gateway-proxy \
  --region=${REGION} \
  --size=1 \
  --template=gateway-proxy

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

    gcloud compute instance-groups managed set-named-ports gateway-proxy \
  --named-ports=https:8443 \
  --region=${REGION}

הגדרה של מאזן עומסי רשת אזורי חיצוני להעברת סיגנל ללא שינוי

  1. יוצרים כתובת IP חיצונית סטטית אזורית:

    gcloud compute addresses create xnlb-${REGION} \
  --region=${REGION}

  2. מקבלים את כתובת ה-IP ששמורה למאזן העומסים החיצוני:

    gcloud compute addresses describe xnlb-${REGION} \
  --region=${REGION} --format='value(address)'

  3. יוצרים בדיקת תקינות לשרתי ה-Proxy של השער:

    gcloud compute health-checks create tcp xnlb-${REGION} \
  --region=${REGION} \
  --use-serving-port

  4. יוצרים שירות קצה עורפי לשרתי ה-proxy של השער:

    gcloud compute backend-services create xnlb-${REGION} \
  --health-checks=xnlb-${REGION} \
  --health-checks-region=${REGION} \
  --load-balancing-scheme=EXTERNAL \
  --protocol=TCP \
  --region=${REGION} \
  --port-name=https

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

    gcloud compute backend-services add-backend xnlb-${REGION} \
  --instance-group=gateway-proxy \
  --instance-group-region=${REGION} \
  --region=${REGION}

  6. יוצרים כלל העברה לניתוב תנועה לשרתי ה-Proxy של השער:

    gcloud compute forwarding-rules create xnlb-${REGION} \
  --region=${REGION} \
  --load-balancing-scheme=EXTERNAL \
  --address=${IP_ADDRESS} \
  --ip-protocol=TCP \
  --ports=8443 \
  --backend-service=xnlb-${REGION} \
  --backend-service-region=${REGION}

הגדרת קבוצה של מופעי מכונה מנוהלים שמריצים שירות HTTPS

  1. יצירת תבנית של הגדרות מכונה עם שירות HTTPS שנחשף ביציאה 8443:

    gcloud compute instance-templates create td-https-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=https-td-server \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --metadata=startup-script='#! /bin/bash

sudo rm -rf /var/lib/apt/lists/*
sudo apt-get -y clean
sudo apt-get -y update
sudo apt-get -y install apt-transport-https ca-certificates curl gnupg2 software-properties-common
sudo curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
sudo add-apt-repository -y "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"
sudo apt-get -y update
sudo apt-get -y install docker-ce
sudo which docker
echo "{ \"registry-mirrors\": [\"https://mirror.gcr.io\"] }" | sudo tee -a /etc/docker/daemon.json
sudo service docker restart
sudo docker run -e HTTPS_PORT=9999 -p 8443:9999 --rm -dt mendhak/http-https-echo:22'

  2. יוצרים קבוצה של מופעי מכונה מנוהלים על סמך תבנית המכונה:

    gcloud compute instance-groups managed create https-td-mig-us-${REGION} \
  --zone=${ZONE} \
  --size=2 \
  --template=td-https-vm-template

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

    gcloud compute instance-groups managed set-named-ports https-td-mig-us-${REGION} \
  --named-ports=https:8443 \
  --zone=${ZONE}

  4. יוצרים בדיקת תקינות:

    gcloud compute health-checks create https https-helloworld-health-check \
  --port=8443 --region=${REGION}

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

    gcloud compute firewall-rules create https-vm-allow-health-checks \
  --network ${NETWORK_NAME} --action allow --direction INGRESS \
  --source-ranges 35.191.0.0/16,130.211.0.0/22 \
  --target-tags https-td-server \
  --rules tcp:8443

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

    gcloud compute backend-services create https-helloworld-service \
  --region=${REGION} \
  --load-balancing-scheme=INTERNAL_SELF_MANAGED \
  --port-name=https \
  --health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/https-helloworld-health-check"

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

    gcloud compute backend-services add-backend https-helloworld-service \
  --instance-group=https-td-mig-us-${REGION} \
  --instance-group-zone=${ZONE} \
  --region=${REGION}

הגדרת ניתוב באמצעות משאב TLSRoute

  1. יוצרים את מפרט ה-TLSRoute בקובץ בשם tls_route.yaml:

    cat <<EOF > tls_route.yaml
name: helloworld-tls-route
gateways:
- projects/${PROJECT_NUMBER}/locations/${REGION}/gateways/gateway8443
rules:
- matches:
  - sniHost:
    - example.com
    alpn:
    - h2
  action:
    destinations:
    - serviceName: projects/${PROJECT_NUMBER}/locations/${REGION}/backendServices/https-helloworld-service
EOF

    בהוראה הקודמת, TLSRoute מתאים ל-example.com כ-SNI ול-h2 כ-ALPN. אם ההתאמות משתנות באופן הבא, TLSRoute מתאים ל-SNI או ל-ALPN:

    - matches:
  - sniHost:
    - example.com
  - alpn:
    - h2

  2. משתמשים במפרט tls_route.yaml כדי ליצור את משאב ה-TLSRoute:

    gcloud network-services tls-routes import helloworld-tls-route \
    --source=tls_route.yaml \
    --location=${REGION}

אימות הפריסה

  1. מריצים את פקודת ה-curl הבאה כדי לאמת את קישוריות ה-HTTP לשירותי הבדיקה שיצרתם:

    curl https://example.com:8443 --resolve example.com:8443:${IP_ADDRESS} -k

  2. הפקודה מחזירה תגובה מאחת מהמכונות הווירטואליות בקבוצת המופעים המנוהלת. הפלט אמור להיראות כך:

    {
  "path": "/",
  "headers": {
    "host": "example.com:8443",
    "user-agent": "curl/8.16.0",
    "accept": "*/*"
  },
  "method": "GET",
  "body": "",
  "fresh": false,
  "hostname": "example.com",
  "ip": "::ffff:10.128.0.59",
  "ips": [],
  "protocol": "https",
  "query": {},
  "subdomains": [],
  "xhr": false,
  "os": {
    "hostname": "19cd7812e792"
  },
  "connection": {
    "servername": "example.com"
  }

אימות באמצעות אימות שלילי

  1. בפקודה הבאה, ה-SNI לא תואם ל-example.com, ולכן שער הכניסה דוחה את החיבור:

    curl https://invalid-server.com:8443 --resolve invalid-server.com:8443:${IP_ADDRESS} -k

  2. בפקודה הבאה, פרוטוקול ALPN לא תואם ל-h2 (פרוטוקול HTTP2), ולכן שער הגישה דוחה את החיבור:

    curl https://example.com:8443 --resolve example.com:8443:${IP_ADDRESS} -k --http1.1

    כל הפקודות הקודמות מחזירות את השגיאה הבאה:

    curl: (35) OpenSSL SSL_connect: Connection reset by peer in connection.

  3. בפקודה הבאה, הלקוח יוצר חיבור בטקסט רגיל (לא מוצפן), ולכן השער דוחה את החיבור עם שגיאת 404 Not Found:

    curl example.com:8443 --resolve example.com:8443:${IP_ADDRESS} -k