‫Anthos Service Mesh ו-Traffic Director נקראים עכשיו Cloud Service Mesh. מידע נוסף זמין בסקירה הכללית על Cloud Service Mesh.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

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

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}"

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

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

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

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

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

kubectl apply -f trafficdirector_client_new_api_sample_xdsv3.yaml
  ```

מדריכי הגדרה

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

הגדרת שירותי gRPC בלי שרת Proxy באמצעות GRPCRoute אזורי ו-Cloud Service Mesh אזורי
הגדרת Proxy מסוג Envoy sidecar עם שירותי HTTP באמצעות HTTPRoute אזורי ו-Cloud Service Mesh אזורי
הגדרת שירותי TCP באמצעות TCPRoute אזורי
ניתוב TLS של שער
הגדרת הפניות בין פרויקטים ל-Cloud Service Mesh אזורי ול-Route אזורי

הגדרת שירותי 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

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

יוצרים מפרט של רשת ושומרים אותו בקובץ mesh.yaml:
```
cat <<EOF > mesh.yaml
name: grpc-mesh
EOF
```
יוצרים רשת באמצעות המפרט 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.

יוצרים תבנית של הגדרות מכונה וירטואלית ב-Compute Engine עם שירות helloworld gRPC שנחשף ביציאה 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')

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

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

מגדירים יציאה עם שם לשירות gRPC. זו היציאה שבה שירות gRPC מוגדר להאזין לבקשות.
```
gcloud compute instance-groups set-named-ports grpc-td-mig-us-central1 \
  --named-ports=grpc-helloworld-port:50051 \
  --zone=${ZONE}
```
בדוגמה הזו, היציאה היא 50051.
יצירת בדיקות תקינות של gRPC.
```
gcloud compute health-checks create grpc grpc-helloworld-health-check \
  --use-serving-port --region=${REGION}
```
השירותים צריכים להטמיע את פרוטוקול בדיקת תקינות של gRPC כדי שבדיקות התקינות של gRPC יפעלו בצורה תקינה. למידע נוסף, ראו יצירת בדיקות תקינות.

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

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

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

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

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

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

יוצרים 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.

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

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 ומשתמש בסקריפט עזר כדי ליצור את קובץ ה-bootstrap. הערכים של TRAFFICDIRECTOR_GCP_PROJECT_NUMBER והאזור בקובץ האתחול שנוצר מתקבלים משרת המטא-נתונים שמכיר את הפרטים האלה לגבי המכונות הווירטואליות שלכם ב-Compute Engine.

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

כדי לאמת את ההגדרה, נכנסים ללקוח:
```
gcloud compute ssh grpc-client --zone=${ZONE}
```

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

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

מריצים את הכלי 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 בלי שרת Proxy התחבר בהצלחה ל-Cloud Service Mesh וקיבל מידע על ה-בק-אנד של שירות helloworld-gce באמצעות פותר השמות xDS. הלקוח שלח בקשה לאחד מהקצה העורפי של השירות בלי לדעת את כתובת ה-IP או לבצע פתרון DNS.

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

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

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 מציג את השם של משאב הרשת האזורית כדי לזהות את Service mesh הספציפית שהוגדרה. הגדרות הניתוב שמתקבלות מ-Cloud Service Mesh משמשות להפניית התנועה שעוברת דרך ה-sidecar proxy לשירותי Backend אזוריים שונים, בהתאם לפרמטרים של הבקשה, כמו שם המארח או הכותרות, שמוגדרים במשאבי הניתוב.

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

יוצרים מפרט של רשת אזורית ושומרים אותו בקובץ mesh.yaml:
```
cat <<EOF > mesh.yaml
name: sidecar-mesh
EOF
```
אם לא מציינים יציאה, ברירת המחדל היא 15001.
יוצרים רשת אזורית באמצעות המפרט mesh.yaml:
```
gcloud network-services meshes import sidecar-mesh \
    --source=mesh.yaml \
    --location=${REGION}
```
אחרי שיוצרים את הרשת האזורית, Cloud Service Mesh מוכן להציג את ההגדרה. עם זאת, מכיוון שעדיין לא הוגדרו שירותים, ההגדרה תהיה ריקה.

הגדרת שרת HTTP

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

יוצרים תבנית של הגדרות מכונה ב-Compute Engine עם שירות HTTP‏ helloworld שנחשף ביציאה 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"

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

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

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

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

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

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

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

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

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

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

יוצרים את ה-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 sidecar

בקטע הזה יוצרים מופע של מכונת VM של לקוח עם פרוקסי קובץ עזר חיצוני של Envoy כדי לבקש את ההגדרה של 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_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

מתחברים למכונה הווירטואלית שנוצרה:
```
gcloud compute ssh td-vm-client --zone=${ZONE}
```
בודקים את הקישוריות של HTTP לשירותי הבדיקה שנוצרו:
```
curl -H "Host: helloworld-gce" http://10.0.0.1/
```
הפקודה מחזירה תגובה מאחת ממכונות ה-VM בקבוצת המופעים המנוהלת, עם שם המארח שלה שמוצג במסוף.

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

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

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

יוצרים מפרט של רשת אזורית ושומרים אותו בקובץ mesh.yaml:
```
cat <<EOF > mesh.yaml
name: sidecar-mesh
EOF
```

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

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

הגדרת שרת TCP

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

יוצרים תבנית של הגדרות מכונה ב-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 &"

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

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

מגדירים את היציאות עם השמות בקבוצה של מופעי מכונה מנוהלים שנוצרה ל-port 10000:
```
gcloud compute instance-groups set-named-ports tcp-td-mig-us-central1 \
  --zone=${ZONE} --named-ports=tcp:10000
```

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

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

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

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

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

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"

מוסיפים את ה-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 אזורי

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

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

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

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

יצירת לקוח TCP עם Envoy sidecar

יצירת מכונה וירטואלית עם 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

מתחברים למכונה הווירטואלית שנוצרה:
```
gcloud compute ssh td-vm-client --zone=${ZONE}
```
בודקים את הקישוריות לשירותי הבדיקה שנוצרו:
```
curl 10.0.0.1:10000 --http0.9 -v
```
אמור להופיע טקסט Hello from TCP service שמוחזר אליכם, וגם תוכלו לראות כל טקסט שתקלידו שמוחזר אליכם על ידי שירות netcat שפועל במכונה הווירטואלית המרוחקת.

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

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

מגדירים משתנה שישמש לאורך כל הדוגמה:
```
export REGION="us-central1"
```
אפשר גם להחליף את us-central1 באזור אחר שרוצים להשתמש בו.
יוצרים מפרט של הרשת ומאחסנים אותו בקובץ mesh.yaml:
```
cat <<EOF > mesh.yaml
name: shared-mesh
EOF
```
מגדירים משאב של רשת בפרויקט הזה עם ההגדרה הנדרשת:
```
gcloud network-services meshes import shared-mesh \
    --source=mesh.yaml \
    --location=${REGION}
```
שימו לב ל-URI המלא של משאב הרשת הזה. בעלי השירות יצטרכו את זה בעתיד כדי לצרף את המסלולים שלהם לרשת הזו.
נותנים את הרשאת ה-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 אזוריים ומשאבי Route אזוריים בפרויקט שלהם, בדומה להגדרת שרתי proxy של Envoy עם שירותי HTTP. ההבדל היחיד הוא שבכל HTTPRoute/GRPCRoute/TCPRoute יהיה ה-URI של משאב הרשת של פרויקט המארח בשדה meshes.

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

TRAFFICDIRECTOR_GCP_PROJECT_NUMBER=HOST_PROJECT_NUMBER
TRAFFICDIRECTOR_MESH_NAME=MESH_NAME

ניתוב TLS בשער

בקטע הזה מוסבר איך להגדיר שער כניסה מבוסס-פרוקסי של 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.

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

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

יוצרים זהות של חשבון שירות לשרתי ה-proxy של השער:
```
gcloud iam service-accounts create gateway-proxy
```

מקצים את תפקידי ה-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"

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

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

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

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

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

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

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

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

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}"
'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

יוצרים כלל העברה לניתוב תנועה לשרתי ה-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

יצירת תבנית של הגדרות מכונה עם שירות 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'

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

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

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

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

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

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

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

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

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

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

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

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

יוצרים את מפרט ה-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

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

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

אימות הפריסה

מריצים את פקודת ה-curl הבאה כדי לאמת את קישוריות ה-HTTP לשירותי הבדיקה שיצרתם:
```
curl https://example.com:8443 --resolve example.com:8443:${IP_ADDRESS} -k
```

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

{
  "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"
  }

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

בפקודה הבאה, ה-SNI לא תואם ל-example.com, ולכן שער הכניסה דוחה את החיבור:
```
curl https://invalid-server.com:8443 --resolve invalid-server.com:8443:${IP_ADDRESS} -k
```
בפקודה הבאה, פרוטוקול 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.
```
בפקודה הבאה, הלקוח יוצר חיבור בטקסט רגיל (לא מוצפן), ולכן השער דוחה את החיבור עם השגיאה 404 Not Found:
```
curl example.com:8443 --resolve example.com:8443:${IP_ADDRESS} -k
```