במאמר הזה מוסבר איך לבצע את הפעולות הבאות:
- פריסת אפליקציות שמופצות באופן גלובלי ונחשפות דרך GKE Gateway ו-Cloud Service Mesh.
- חשיפת אפליקציה למספר לקוחות על ידי שילוב של Cloud Load Balancing עם Cloud Service Mesh.
- שילוב של מאזני עומסים עם Service mesh שנפרסה בכמה אזוריGoogle Cloud .
מדריך הפריסה הזה מיועד למנהלי פלטפורמות. הוא מיועד גם למשתמשים מתקדמים שמפעילים את Cloud Service Mesh. ההוראות מתאימות גם ל-Istio ב-GKE.
ארכיטקטורה
בתרשים הבא מוצגת טופולוגיית ברירת המחדל של תעבורת הנתונים הנכנסת של רשת שירות – מאזן עומסים חיצוני של TCP/UDP שחושף את שרתי ה-proxy של שער תעבורת הנתונים הנכנסת באשכול יחיד:
במדריך הפריסה הזה נעשה שימוש במשאבי שער של Google Kubernetes Engine (GKE). באופן ספציפי, הוא משתמש בשער מרובה אשכולות כדי להגדיר איזון עומסים במספר אזורים לפני כמה אשכולות Autopilot שמופצים בשני אזורים.
בתרשים שלמעלה מוצג איך הנתונים זורמים בתרחישים של כניסה לענן וכניסה לרשת. למידע נוסף, קראו את ההסבר על תרשים הארכיטקטורה במסמך הארכיטקטורה לדוגמה.
מטרות
- פורסים זוג אשכולות של GKE Autopilot ב- Google Cloud לאותו צי.
- פורסים Cloud Service Mesh מבוסס-Istio באותו צי.
- מגדירים מאזן עומסים באמצעות GKE Gateway כדי לסיים את תנועת ה-HTTPS הציבורית.
- הפניית תנועה ציבורית ב-HTTPS לאפליקציות שמתארחות ב-Cloud Service Mesh ונפרסות בכמה אשכולות ואזורים.
- פורסים את האפליקציה לדוגמה whereami בשני אשכולות Autopilot.
הוזלת עלויות
במסמך הזה משתמשים ברכיבים הבאים של Google Cloud, והשימוש בהם כרוך בתשלום:
- Google Kubernetes Engine
- Cloud Load Balancing
- Cloud Service Mesh
- Multi Cluster Ingress
- Google Cloud Armor
- Certificate Manager
- Cloud Endpoints
בעזרת מחשבון העלויות אתם יכולים להעריך את העלויות בהתאם לשימוש הצפוי.
כשמסיימים את המשימות שמתוארות במסמך הזה אפשר למחוק את המשאבים שיצרתם כדי להימנע מחיובים נוספים. מידע נוסף זמין בקטע הסרת המשאבים.
לפני שמתחילים
-
בדף לבחירת הפרויקט במסוף Google Cloud , בוחרים פרויקט ב- Google Cloud או יוצרים אותו.
התפקידים שנדרשים כדי לבחור או ליצור פרויקט
- בחירת פרויקט: כדי לבחור פרויקט לא נדרש תפקיד IAM ספציפי – אתם יכולים לבחור כל פרויקט שקיבלתם בו תפקיד.
-
יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד "יצירת פרויקטים" (
roles/resourcemanager.projectCreator), שכולל את ההרשאהresourcemanager.projects.create. איך מקצים תפקידים?
-
מפעילים את Cloud Shell במסוף Google Cloud .
אתם מריצים את כל פקודות הטרמינל לפריסה הזו מ-Cloud Shell.
מגדירים את פרויקט ברירת המחדל ב- Google Cloud :
export PROJECT=PROJECT_ID export PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)") gcloud config set project PROJECT_IDמחליפים את
PROJECT_IDבמזהה הפרויקט שבו רוצים להשתמש לפריסה הזו.יוצרים ספריית עבודה:
mkdir -p ${HOME}/edge-to-mesh-multi-region cd ${HOME}/edge-to-mesh-multi-region export WORKDIR=`pwd`
יצירת אשכולות GKE
בקטע הזה תיצרו אשכולות GKE לאירוח האפליקציות והתשתית התומכת, שאותם תיצרו בהמשך המדריך לפריסה.
יוצרים קובץ
kubeconfigחדש ב-Cloud Shell. השלב הזה מבטיח שלא תיווצר התנגשות עם קובץkubeconfigהקיים (ברירת המחדל).touch edge2mesh_mr_kubeconfig export KUBECONFIG=${WORKDIR}/edge2mesh_mr_kubeconfigמגדירים את משתני הסביבה שמשמשים ליצירת אשכולות GKE והמשאבים שבתוכם. אפשר לשנות את אפשרויות ברירת המחדל של האזור בהתאם לצרכים שלכם.
export CLUSTER_1_NAME=edge-to-mesh-01 export CLUSTER_2_NAME=edge-to-mesh-02 export CLUSTER_1_REGION=us-central1 export CLUSTER_2_REGION=us-east4 export PUBLIC_ENDPOINT=frontend.endpoints.PROJECT_ID.cloud.googמפעילים את ממשקי ה-API של Google Cloud שבהם משתמשים במדריך הזה:
gcloud services enable \ container.googleapis.com \ mesh.googleapis.com \ gkehub.googleapis.com \ multiclusterservicediscovery.googleapis.com \ multiclusteringress.googleapis.com \ trafficdirector.googleapis.com \ certificatemanager.googleapis.comיוצרים אשכול GKE Autopilot עם צמתים פרטיים ב-
CLUSTER_1_REGION. כדי לא להמתין להקצאה של האשכול הראשון ולרישום שלו ב-fleet, משתמשים בדגל--async:gcloud container clusters create-auto --async \ ${CLUSTER_1_NAME} --region ${CLUSTER_1_REGION} \ --release-channel rapid \ --enable-private-nodes --enable-fleetיוצרים ורושמים אשכול Autopilot שני ב-
CLUSTER_2_REGION:gcloud container clusters create-auto \ ${CLUSTER_2_NAME} --region ${CLUSTER_2_REGION} \ --release-channel rapid \ --enable-private-nodes --enable-fleetמוודאים שהאשכולות פועלים. יכול להיות שיעברו עד 20 דקות עד שכל האשכולות יפעלו:
gcloud container clusters listהפלט אמור להיראות כך:
NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE NODE_VERSION NUM_NODES STATUS STACK_TYPE edge-to-mesh-01 us-central1 1.35.5-gke.1000000 34.31.166.104 ek-standard-8 1.35.5-gke.1000000 1 RUNNING IPV4 edge-to-mesh-02 us-east4 1.35.5-gke.1000000 35.245.233.88 ek-standard-8 1.35.5-gke.1000000 1 RUNNING IPV4
אוספים את פרטי הכניסה של
CLUSTER_1_NAME.יצרתם אתCLUSTER_1_NAMEבאופן אסינכרוני כדי שתוכלו להריץ פקודות נוספות בזמן הקצאת האשכול.gcloud container clusters get-credentials ${CLUSTER_1_NAME} \ --region ${CLUSTER_1_REGION}כדי להבהיר את השמות של ההקשרים של Kubernetes, משנים את השמות שלהם לשמות של האשכולות:
kubectl config rename-context gke_PROJECT_ID_${CLUSTER_1_REGION}_${CLUSTER_1_NAME} ${CLUSTER_1_NAME} kubectl config rename-context gke_PROJECT_ID_${CLUSTER_2_REGION}_${CLUSTER_2_NAME} ${CLUSTER_2_NAME}
התקנת רשת שירות (service mesh)
בקטע הזה מגדירים את הגרסה המנוהלת של Cloud Service Mesh באמצעות Fleet API. שימוש ב-Fleet API כדי להפעיל את Cloud Service Mesh מספק גישה הצהרתית להקצאת רשת שירות.
ב-Cloud Shell, מפעילים את Cloud Service Mesh בצי:
gcloud container fleet mesh enableהפעלה של ניהול אוטומטי של מישור הבקרה ומישור הנתונים:
gcloud container fleet mesh update \ --management automatic \ --memberships ${CLUSTER_1_NAME},${CLUSTER_2_NAME}ממתינים כ-20 דקות. ואז מוודאים שסטטוס מישור הבקרה הוא
ACTIVE:gcloud container fleet mesh describeהפלט אמור להיראות כך:
createTime: '2026-06-04T23:40:02.666228685Z' membershipSpecs: projects/497535075790/locations/us-central1/memberships/edge-to-mesh-01: mesh: management: MANAGEMENT_AUTOMATIC projects/497535075790/locations/us-east4/memberships/edge-to-mesh-02: mesh: management: MANAGEMENT_AUTOMATIC membershipStates: projects/497535075790/locations/us-central1/memberships/edge-to-mesh-01: servicemesh: conditions: - code: VPCSC_GA_SUPPORTED details: This control plane supports VPC-SC GA. documentationLink: http://cloud.google.com/service-mesh/docs/managed/vpc-sc severity: INFO controlPlaneManagement: details: - code: REVISION_READY details: 'Ready: asm-managed-rapid' implementation: TRAFFIC_DIRECTOR state: ACTIVE dataPlaneManagement: details: - code: OK details: Service is running. state: ACTIVE state: code: OK description: 'Revision ready for use: asm-managed-rapid.' updateTime: '2026-06-04T23:45:52.958139396Z' projects/497535075790/locations/us-east4/memberships/edge-to-mesh-02: servicemesh: conditions: - code: VPCSC_GA_SUPPORTED details: This control plane supports VPC-SC GA. documentationLink: http://cloud.google.com/service-mesh/docs/managed/vpc-sc severity: INFO controlPlaneManagement: details: - code: REVISION_READY details: 'Ready: asm-managed-rapid' implementation: TRAFFIC_DIRECTOR state: ACTIVE dataPlaneManagement: details: - code: OK details: Service is running. state: ACTIVE state: code: OK description: 'Revision ready for use: asm-managed-rapid.' updateTime: '2026-06-04T23:45:54.621862416Z' name: projects/e2m-mc-h2c/locations/global/features/servicemesh resourceState: state: ACTIVE spec: {} updateTime: '2026-06-04T23:40:55.123874541Z'
פריסת מאזן עומסים חיצוני של אפליקציות (ALB) ויצירת שערי כניסה (ingress)
בקטע הזה תפרסו מאזן עומסים חיצוני של אפליקציות (ALB) באמצעות GKE Gateway Controller, ותיצרו שערי כניסה לשני האשכולות. המשאבים gateway ו-gatewayClass מבצעים באופן אוטומטי את הקצאת מאזן העומסים ואת בדיקת התקינות של ה-backend. כדי לספק סיום TLS במאזן העומסים, יוצרים משאבים של Certificate Manager ומצרפים אותם למאזן העומסים. בנוסף, משתמשים ב-Endpoints כדי להקצות באופן אוטומטי שם DNS ציבורי לאפליקציה.
התקנת שער כניסה בשני האשכולות
כשיטה מומלצת לאבטחה, מומלץ לפרוס את שער הכניסה במרחב שמות שונה ממישור הבקרה של רשת ה-mesh.
ב-Cloud Shell, יוצרים מרחב שמות ייעודי של
ingress-gatewayבכל אשכול:kubectl --context=${CLUSTER_1_NAME} create namespace ingress-gateway kubectl --context=${CLUSTER_2_NAME} create namespace ingress-gatewayמוסיפים תווית של מרחב שמות למרחבי השמות של
ingress-gateway:kubectl --context=${CLUSTER_1_NAME} label namespace ingress-gateway istio-injection=enabled kubectl --context=${CLUSTER_2_NAME} label namespace ingress-gateway istio-injection=enabledהפלט אמור להיראות כך:
namespace/ingress-gateway labeled
הוספת התווית
istio-injection=enabledלמרחבי השמות שלingress-gatewayמורה ל-Cloud Service Mesh להוסיף באופן אוטומטי שרתי proxy של Envoy sidecar כשפורסים pod.יוצרים אישור בחתימה עצמית לשימוש עתידי:
openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 \ -subj "/CN=frontend.endpoints.PROJECT_ID.cloud.goog/O=Edge2Mesh Inc" \ -keyout ${WORKDIR}/frontend.endpoints.PROJECT_ID.cloud.goog.key \ -out ${WORKDIR}/frontend.endpoints.PROJECT_ID.cloud.goog.crtהאישור מספק שכבת הצפנה נוספת בין מאזן העומסים לבין שערי הכניסה של Service mesh. הוא גם מאפשר תמיכה בפרוטוקולים שמבוססים על HTTP/2, כמו gRPC. בהמשך המאמר, בקטע יצירת משאבים של כתובת IP חיצונית, רשומת DNS ואישור TLS, מוסבר איך לצרף את האישור בחתימה עצמית לשערי הכניסה.
אם אתם רוצים להשתמש ב-HTTP/2 לחיבור בין GFE לרשת, אבל אתם לא צריכים הצפנה משלכם, אתם יכולים להשתמש ב-H2C.
למידע נוסף על הדרישות של אישור שער הכניסה, ראו הצפנה ממאזן העומסים לקצוות העורפיים.
יוצרים סוד של Kubernetes בכל אשכול כדי לאחסן את האישור בחתימה עצמית:
kubectl --context ${CLUSTER_1_NAME} -n ingress-gateway create secret tls \ edge2mesh-credential \ --key=${WORKDIR}/frontend.endpoints.PROJECT_ID.cloud.goog.key \ --cert=${WORKDIR}/frontend.endpoints.PROJECT_ID.cloud.goog.crt kubectl --context ${CLUSTER_2_NAME} -n ingress-gateway create secret tls \ edge2mesh-credential \ --key=${WORKDIR}/frontend.endpoints.PROJECT_ID.cloud.goog.key \ --cert=${WORKDIR}/frontend.endpoints.PROJECT_ID.cloud.goog.crtכדי לשלב עם מאזן עומסים חיצוני של אפליקציות (ALB), יוצרים וריאנט של kustomize כדי להגדיר את משאבי שער הכניסה:
mkdir -p ${WORKDIR}/asm-ig/base cat <<EOF > ${WORKDIR}/asm-ig/base/kustomization.yaml resources: - github.com/GoogleCloudPlatform/anthos-service-mesh-samples/docs/ingress-gateway-asm-manifests/base EOF mkdir ${WORKDIR}/asm-ig/variant cat <<EOF > ${WORKDIR}/asm-ig/variant/role.yaml apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: name: asm-ingressgateway namespace: ingress-gateway rules: - apiGroups: [""] resources: ["secrets"] verbs: ["get", "watch", "list"] EOF cat <<EOF > ${WORKDIR}/asm-ig/variant/rolebinding.yaml apiVersion: rbac.authorization.k8s.io/v1 kind: RoleBinding metadata: name: asm-ingressgateway namespace: ingress-gateway roleRef: apiGroup: rbac.authorization.k8s.io kind: Role name: asm-ingressgateway subjects: - kind: ServiceAccount name: asm-ingressgateway EOF cat <<EOF > ${WORKDIR}/asm-ig/variant/service-proto-type.yaml apiVersion: v1 kind: Service metadata: name: asm-ingressgateway namespace: ingress-gateway spec: ports: - name: status-port port: 15021 protocol: TCP targetPort: 15021 - name: http port: 80 targetPort: 8080 appProtocol: HTTP - name: https port: 443 targetPort: 8443 appProtocol: HTTP2 type: ClusterIP EOF cat <<EOF > ${WORKDIR}/asm-ig/variant/gateway.yaml apiVersion: networking.istio.io/v1beta1 kind: Gateway metadata: name: asm-ingressgateway namespace: ingress-gateway spec: servers: - port: number: 443 name: https protocol: HTTPS hosts: - "*" # IMPORTANT: Must use wildcard here when using SSL, as SNI isn't passed from GFE tls: mode: SIMPLE credentialName: edge2mesh-credential EOF cat <<EOF > ${WORKDIR}/asm-ig/variant/kustomization.yaml namespace: ingress-gateway resources: - ../base - role.yaml - rolebinding.yaml patches: - path: service-proto-type.yaml target: kind: Service - path: gateway.yaml target: kind: Gateway EOFמחילים את הגדרת שער הכניסה על שני האשכולות:
kubectl --context ${CLUSTER_1_NAME} apply -k ${WORKDIR}/asm-ig/variant kubectl --context ${CLUSTER_2_NAME} apply -k ${WORKDIR}/asm-ig/variant
חשיפת Pods של שער כניסה למאזן העומסים באמצעות שירות מרובה אשכולות
בקטע הזה מייצאים את הפודים של שער הכניסה באמצעות ServiceExport
משאב בהתאמה אישית. צריך לייצא את הפודים של שער הכניסה באמצעות משאב בהתאמה אישית של ServiceExport מהסיבות הבאות:
- מאפשר למאזן העומסים לפנות לפודים של שער הכניסה בכמה אשכולות.
- מאפשר לפודים של שער הכניסה להעביר בקשות דרך שרת proxy לשירותים שפועלים בתוך Service mesh.
ב-Cloud Shell, מפעילים את השירותים מרובי האשכולות (MCS) בצי:
gcloud container fleet multi-cluster-services enableנותנים ל-MCS את הרשאות ה-IAM הנדרשות לפרויקט או לצי:
gcloud projects add-iam-policy-binding PROJECT_ID \ --member "serviceAccount:PROJECT_ID.svc.id.goog[gke-mcs/gke-mcs-importer]" \ --role "roles/compute.networkViewer"יוצרים את קובץ ה-YAML של
ServiceExport:cat <<EOF > ${WORKDIR}/svc_export.yaml kind: ServiceExport apiVersion: net.gke.io/v1 metadata: name: asm-ingressgateway namespace: ingress-gateway EOFמחילים את קובץ ה-YAML של
ServiceExportעל שני האשכולות:kubectl --context=${CLUSTER_1_NAME} apply -f ${WORKDIR}/svc_export.yaml kubectl --context=${CLUSTER_2_NAME} apply -f ${WORKDIR}/svc_export.yamlאם מופיעה הודעת השגיאה הבאה, המתינו כמה רגעים עד להתקנת הגדרות המשאבים בהתאמה אישית (CRD) של MCS. לאחר מכן, מריצים מחדש את הפקודות כדי להחיל את קובץ ה-YAML של
ServiceExportעל שני האשכולות.error: resource mapping not found for name: "asm-ingressgateway" namespace: "ingress-gateway" from "svc_export.yaml": no matches for kind "ServiceExport" in version "net.gke.io/v1" ensure CRDs are installed first
יצירת משאבים של כתובת IP חיצונית, רשומת DNS ואישור TLS
בקטע הזה יוצרים משאבי רשת שתומכים במשאבים של איזון העומסים שיוצרים בהמשך הפריסה.
ב-Cloud Shell, שומרים כתובת IP חיצונית סטטית:
gcloud compute addresses create mcg-ip --globalכתובת IP סטטית משמשת את המשאב של GKE Gateway. כך כתובת ה-IP נשארת זהה, גם אם יוצרים מחדש את מאזן העומסים החיצוני.
משיגים את כתובת ה-IP הסטטית ושומרים אותה כמשתנה סביבה:
export MCG_IP=$(gcloud compute addresses describe mcg-ip --global --format "value(address)") echo ${MCG_IP}כדי ליצור מיפוי יציב ונוח לשימוש לכתובת ה-IP של השער, צריך רשומת DNS ציבורית.
אתם יכולים להשתמש בכל ספק DNS ובכל סכמת אוטומציה שתרצו. בפריסה הזו משתמשים ב-Endpoints במקום ליצור אזור DNS מנוהל. ב-Endpoints יש רשומת DNS בניהול Google בחינם לכתובת IP חיצונית.
מריצים את הפקודה הבאה כדי ליצור קובץ YAML בשם
dns-spec.yaml:cat <<EOF > ${WORKDIR}/dns-spec.yaml swagger: "2.0" info: description: "Cloud Endpoints DNS" title: "Cloud Endpoints DNS" version: "1.0.0" paths: {} host: "frontend.endpoints.PROJECT_ID.cloud.goog" x-google-endpoints: - name: "frontend.endpoints.PROJECT_ID.cloud.goog" target: "${MCG_IP}" EOFהקובץ
dns-spec.yamlמגדיר את רשומת ה-DNS הציבורית בפורמטfrontend.endpoints.PROJECT_ID.cloud.goog, כאשרPROJECT_IDהוא המזהה הייחודי של הפרויקט.פורסים את הקובץ
dns-spec.yamlכדי ליצור את רשומת ה-DNS. התהליך הזה נמשך כמה דקות.gcloud endpoints services deploy ${WORKDIR}/dns-spec.yamlיוצרים אישור באמצעות Certificate Manager לשם של רשומת ה-DNS שיצרתם בשלב הקודם:
gcloud certificate-manager certificates create mcg-cert \ --domains="frontend.endpoints.PROJECT_ID.cloud.goog"אישור TLS בניהול Google משמש לסיום בקשות נכנסות של לקוחות במאזן העומסים.
יוצרים מפת אישורים:
gcloud certificate-manager maps create mcg-cert-mapמפזר העומסים מפנה לאישור דרך רשומת המיפוי לאישורים שיוצרים בשלב הבא.
יוצרים רשומת מיפוי לאישורים לאישור שיצרתם קודם בקטע הזה:
gcloud certificate-manager maps entries create mcg-cert-map-entry \ --map="mcg-cert-map" \ --certificates="mcg-cert" \ --hostname="frontend.endpoints.PROJECT_ID.cloud.goog"
יצירת כללי מדיניות של שירות לקצה העורפי ומשאבים של מאזן עומסים
בקטע הזה תבצעו את המשימות הבאות:
- יוצרים מדיניות אבטחה של Cloud Armor עם כללים.
- יוצרים מדיניות שמאפשרת למאזן העומסים לבדוק את מידת התגובה של הפודים של שער הכניסה, באמצעות קובץ ה-YAML של
ServiceExportשיצרתם קודם. - משתמשים ב-GKE Gateway API כדי ליצור משאב של מאזן עומסים.
- משתמשים במשאב בהתאמה אישית
GatewayClassכדי להגדיר את הסוג הספציפי של מאזן העומסים. - מפעילים איזון עומסים בכמה אשכולות ב-fleet ומגדירים את אחד מהאשכולות בתור אשכול ההגדרות של ה-fleet.
ב-Cloud Shell, יוצרים מדיניות אבטחה של Cloud Armor:
gcloud compute security-policies create edge-fw-policy \ --description "Block XSS attacks"יוצרים כלל למדיניות האבטחה:
gcloud compute security-policies rules create 1000 \ --security-policy edge-fw-policy \ --expression "evaluatePreconfiguredExpr('xss-stable')" \ --action "deny-403" \ --description "XSS attack filtering"יוצרים קובץ YAML למדיניות האבטחה, ומפנים לקובץ ה-YAML של
ServiceExportבאמצעות קובץ YAML תואם שלServiceImport:cat <<EOF > ${WORKDIR}/cloud-armor-backendpolicy.yaml apiVersion: networking.gke.io/v1 kind: GCPBackendPolicy metadata: name: cloud-armor-backendpolicy namespace: ingress-gateway spec: default: securityPolicy: edge-fw-policy targetRef: group: net.gke.io kind: ServiceImport name: asm-ingressgateway EOFמחילים את מדיניות Cloud Armor על שני האשכולות:
kubectl --context=${CLUSTER_1_NAME} apply -f ${WORKDIR}/cloud-armor-backendpolicy.yaml kubectl --context=${CLUSTER_2_NAME} apply -f ${WORKDIR}/cloud-armor-backendpolicy.yamlיוצרים קובץ YAML בהתאמה אישית שמאפשר למאזן העומסים לבצע בדיקות תקינות בנקודת הקצה של Envoy (יציאה
15021בנתיב/healthz/ready) של pod-ים של שער הכניסה בשני האשכולות:cat <<EOF > ${WORKDIR}/ingress-gateway-healthcheck.yaml apiVersion: networking.gke.io/v1 kind: HealthCheckPolicy metadata: name: ingress-gateway-healthcheck namespace: ingress-gateway spec: default: config: httpHealthCheck: port: 15021 portSpecification: USE_FIXED_PORT requestPath: /healthz/ready type: HTTP targetRef: group: net.gke.io kind: ServiceImport name: asm-ingressgateway EOFמחילים את קובץ ה-YAML בהתאמה אישית שיצרתם בשלב הקודם על שני האשכולות:
kubectl --context=${CLUSTER_1_NAME} apply -f ${WORKDIR}/ingress-gateway-healthcheck.yaml kubectl --context=${CLUSTER_2_NAME} apply -f ${WORKDIR}/ingress-gateway-healthcheck.yamlמפעילים איזון עומסים בכמה אשכולות ב-fleet, ומגדירים את
CLUSTER_1_NAMEכאשכול ההגדרות:gcloud container fleet ingress enable \ --config-membership=${CLUSTER_1_NAME} \ --location=${CLUSTER_1_REGION}נותנים הרשאות IAM לבקר של Gateway ב-fleet:
gcloud projects add-iam-policy-binding PROJECT_ID \ --member "serviceAccount:service-${PROJECT_NUMBER}@gcp-sa-multiclusteringress.iam.gserviceaccount.com" \ --role "roles/container.admin"יוצרים את קובץ ה-YAML של מאזן העומסים באמצעות משאב בהתאמה אישית של Gateway, שמפנה אל
gke-l7-global-external-managed-mcgatewayClassואל כתובת ה-IP הסטטית שיצרתם קודם:cat <<EOF > ${WORKDIR}/frontend-gateway.yaml kind: Gateway apiVersion: gateway.networking.k8s.io/v1 metadata: name: external-http namespace: ingress-gateway annotations: networking.gke.io/certmap: mcg-cert-map spec: gatewayClassName: gke-l7-global-external-managed-mc listeners: - name: http # list the port only so we can redirect any incoming http requests to https protocol: HTTP port: 80 - name: https protocol: HTTPS port: 443 allowedRoutes: kinds: - kind: HTTPRoute addresses: - type: NamedAddress value: mcg-ip EOFמחילים את קובץ ה-YAML של
frontend-gatewayעל שני האשכולות. רקCLUSTER_1_NAMEהוא מקור סמכות, אלא אם מגדירים אשכול הגדרות אחר כמקור סמכות:kubectl --context=${CLUSTER_1_NAME} apply -f ${WORKDIR}/frontend-gateway.yaml kubectl --context=${CLUSTER_2_NAME} apply -f ${WORKDIR}/frontend-gateway.yamlיוצרים קובץ YAML של
HTTPRouteבשםdefault-httproute.yaml, שמורה למשאב Gateway לשלוח בקשות לשערי הכניסה:cat << EOF > ${WORKDIR}/default-httproute.yaml apiVersion: gateway.networking.k8s.io/v1 kind: HTTPRoute metadata: name: default-httproute namespace: ingress-gateway spec: parentRefs: - name: external-http namespace: ingress-gateway sectionName: https rules: - backendRefs: - group: net.gke.io kind: ServiceImport name: asm-ingressgateway port: 443 EOFמחילים את קובץ ה-YAML של
HTTPRouteשיצרתם בשלב הקודם על שני האשכולות:kubectl --context=${CLUSTER_1_NAME} apply -f ${WORKDIR}/default-httproute.yaml kubectl --context=${CLUSTER_2_NAME} apply -f ${WORKDIR}/default-httproute.yamlכדי לבצע הפניות אוטומטיות מ-HTTP ל-HTTP(S), יוצרים קובץ YAML נוסף של
HTTPRouteבשםdefault-httproute-redirect.yaml:cat << EOF > ${WORKDIR}/default-httproute-redirect.yaml kind: HTTPRoute apiVersion: gateway.networking.k8s.io/v1 metadata: name: http-to-https-redirect-httproute namespace: ingress-gateway spec: parentRefs: - name: external-http namespace: ingress-gateway sectionName: http rules: - filters: - type: RequestRedirect requestRedirect: scheme: https statusCode: 301 EOFמחילים את קובץ ה-YAML של ההפניה לכתובת אחרת (
HTTPRoute) על שני האשכולות:kubectl --context=${CLUSTER_1_NAME} apply -f ${WORKDIR}/default-httproute-redirect.yaml kubectl --context=${CLUSTER_2_NAME} apply -f ${WORKDIR}/default-httproute-redirect.yamlבודקים את המשאב Gateway כדי לראות את התקדמות הפריסה של מאזן העומסים:
kubectl --context=${CLUSTER_1_NAME} describe gateway external-http -n ingress-gatewayהפלט מציג את המידע שהזנתם בקטע הזה.
פריסת האפליקציה לדוגמה whereami
במדריך הזה משתמשים באפליקציה לדוגמה whereami כדי לספק משוב ישיר על האשכולות שמשיבים לבקשות. בקטע הבא מוגדרים שני פריסות נפרדות של whereami בשני האשכולות: פריסה של frontend ופריסה של backend.
הפריסה frontend היא עומס העבודה הראשון שמקבל את הבקשה. לאחר מכן הוא קורא לפריסה של backend.
המודל הזה משמש להדגמה של ארכיטקטורת אפליקציה עם כמה שירותים.
שני השירותים, frontend ו-backend, פרוסים בשני האשכולות.
ב-Cloud Shell, יוצרים את מרחבי השמות של whereami
frontendו-whereamibackendבשני האשכולות, ומפעילים הזרקה של מרחב שמות:kubectl --context=${CLUSTER_1_NAME} create ns frontend kubectl --context=${CLUSTER_1_NAME} label namespace frontend istio-injection=enabled kubectl --context=${CLUSTER_1_NAME} create ns backend kubectl --context=${CLUSTER_1_NAME} label namespace backend istio-injection=enabled kubectl --context=${CLUSTER_2_NAME} create ns frontend kubectl --context=${CLUSTER_2_NAME} label namespace frontend istio-injection=enabled kubectl --context=${CLUSTER_2_NAME} create ns backend kubectl --context=${CLUSTER_2_NAME} label namespace backend istio-injection=enabledיוצרים וריאנט של kustomize ל-whereami
backend:mkdir -p ${WORKDIR}/whereami-backend/base cat <<EOF > ${WORKDIR}/whereami-backend/base/kustomization.yaml resources: - github.com/GoogleCloudPlatform/kubernetes-engine-samples/quickstarts/whereami/k8s EOF mkdir ${WORKDIR}/whereami-backend/variant cat <<EOF > ${WORKDIR}/whereami-backend/variant/cm-flag.yaml apiVersion: v1 kind: ConfigMap metadata: name: whereami data: BACKEND_ENABLED: "False" # assuming you don't want a chain of backend calls METADATA: "backend" EOF cat <<EOF > ${WORKDIR}/whereami-backend/variant/service-type.yaml apiVersion: "v1" kind: "Service" metadata: name: "whereami" spec: type: ClusterIP EOF cat <<EOF > ${WORKDIR}/whereami-backend/variant/kustomization.yaml nameSuffix: "-backend" namespace: backend labels: - includeSelectors: true includeTemplates: true pairs: app: whereami-backend resources: - ../base patches: - path: cm-flag.yaml target: kind: ConfigMap - path: service-type.yaml target: kind: Service EOFמחילים את הווריאנט whereami
backendעל שני האשכולות:kubectl --context=${CLUSTER_1_NAME} apply -k ${WORKDIR}/whereami-backend/variant kubectl --context=${CLUSTER_2_NAME} apply -k ${WORKDIR}/whereami-backend/variantיוצרים וריאנט של kustomize ל-whereami
frontend:mkdir -p ${WORKDIR}/whereami-frontend/base cat <<EOF > ${WORKDIR}/whereami-frontend/base/kustomization.yaml resources: - github.com/GoogleCloudPlatform/kubernetes-engine-samples/quickstarts/whereami/k8s EOF mkdir whereami-frontend/variant cat <<EOF > ${WORKDIR}/whereami-frontend/variant/cm-flag.yaml apiVersion: v1 kind: ConfigMap metadata: name: whereami data: BACKEND_ENABLED: "True" BACKEND_SERVICE: "http://whereami-backend.backend.svc.cluster.local" EOF cat <<EOF > ${WORKDIR}/whereami-frontend/variant/service-type.yaml apiVersion: "v1" kind: "Service" metadata: name: "whereami" spec: type: ClusterIP EOF cat <<EOF > ${WORKDIR}/whereami-frontend/variant/kustomization.yaml nameSuffix: "-frontend" namespace: frontend labels: - includeSelectors: true includeTemplates: true pairs: app: whereami-frontend resources: - ../base patches: - path: cm-flag.yaml target: kind: ConfigMap - path: service-type.yaml target: kind: Service EOFמחילים את הווריאנט whereami
frontendעל שני האשכולות:kubectl --context=${CLUSTER_1_NAME} apply -k ${WORKDIR}/whereami-frontend/variant kubectl --context=${CLUSTER_2_NAME} apply -k ${WORKDIR}/whereami-frontend/variantיוצרים קובץ YAML של
VirtualServiceכדי לנתב בקשות אלfrontendשל whereami:cat << EOF > ${WORKDIR}/frontend-vs.yaml apiVersion: networking.istio.io/v1beta1 kind: VirtualService metadata: name: whereami-vs namespace: frontend spec: gateways: - ingress-gateway/asm-ingressgateway hosts: - 'frontend.endpoints.PROJECT_ID.cloud.goog' http: - route: - destination: host: whereami-frontend port: number: 80 EOFמחילים את קובץ ה-YAML של
frontend-vsעל שני האשכולות:kubectl --context=${CLUSTER_1_NAME} apply -f ${WORKDIR}/frontend-vs.yaml kubectl --context=${CLUSTER_2_NAME} apply -f ${WORKDIR}/frontend-vs.yamlאחרי שפרסתם את
frontend-vs.yamlבשני האשכולות, נסו לקרוא לנקודת הקצה הציבורית של האשכולות:curl -s https://frontend.endpoints.PROJECT_ID.cloud.goog | jqהפלט אמור להיראות כך:
{ "backend_result": { "cluster_name": "edge-to-mesh-02", "gce_instance_id": "8396338201253702608", "gce_service_account": "e2m-mcg-01.svc.id.goog", "host_header": "whereami-backend.backend.svc.cluster.local", "metadata": "backend", "node_name": "gk3-edge-to-mesh-02-pool-2-675f6abf-645h", "pod_ip": "10.124.0.199", "pod_name": "whereami-backend-7cbdfd788-8mmnq", "pod_name_emoji": "📸", "pod_namespace": "backend", "pod_service_account": "whereami-backend", "project_id": "e2m-mcg-01", "timestamp": "2023-12-01T03:46:24", "zone": "us-east4-b" }, "cluster_name": "edge-to-mesh-01", "gce_instance_id": "1047264075324910451", "gce_service_account": "e2m-mcg-01.svc.id.goog", "host_header": "frontend.endpoints.e2m-mcg-01.cloud.goog", "metadata": "frontend", "node_name": "gk3-edge-to-mesh-01-pool-2-d687e3c0-5kf2", "pod_ip": "10.54.1.71", "pod_name": "whereami-frontend-69c4c867cb-dgg8t", "pod_name_emoji": "🪴", "pod_namespace": "frontend", "pod_service_account": "whereami-frontend", "project_id": "e2m-mcg-01", "timestamp": "2023-12-01T03:46:24", "zone": "us-central1-c" }
אם תריצו את הפקודה curl כמה פעמים, תראו שהתגובות (גם מ-frontend וגם מ-backend) מגיעות מאזורים שונים. בתגובה שלו, מאזן העומסים מספק ניתוב גיאוגרפי. כלומר, מאזן העומסים מנתב בקשות מהלקוח לאשכול הפעיל הקרוב ביותר, אבל הבקשות עדיין מגיעות באופן אקראי. כשבקשות עוברות מדי פעם מאזור אחד לאחר, זמן האחזור והעלות גדלים.
בקטע הבא תטמיעו איזון עומסים לפי מיקום ב-Service mesh כדי שהבקשות יישארו מקומיות.
הפעלה ובדיקה של איזון עומסים לפי מיקום בשירות whereami
בקטע הזה תטמיעו איזון עומסים לפי מיקום ב-Service mesh כדי שהבקשות יישארו מקומיות. בנוסף, תבצעו כמה בדיקות כדי לראות איך whereami מטפל בתרחישי כשל שונים.
כששולחים בקשה לשירות whereami frontend, מאזן העומסים שולח את הבקשה לאשכול עם זמן האחזור הנמוך ביותר ביחס ללקוח. כלומר, הפודים של שער הכניסה בתוך הרשת מאזנים את העומס של הבקשות לפודים של whereami frontend בשני האשכולות. בקטע הזה נסביר איך לפתור את הבעיה הזו על ידי הפעלת איזון עומסים לפי מיקום בתוך הרשת.
ב-Cloud Shell, יוצרים קובץ YAML של
DestinationRuleשמפעיל את יתירות הכשל האזורית של איזון העומסים המקומי לשירותfrontend:cat << EOF > ${WORKDIR}/frontend-dr.yaml apiVersion: networking.istio.io/v1beta1 kind: DestinationRule metadata: name: frontend namespace: frontend spec: host: whereami-frontend.frontend.svc.cluster.local trafficPolicy: connectionPool: http: maxRequestsPerConnection: 0 loadBalancer: simple: LEAST_REQUEST localityLbSetting: enabled: true outlierDetection: consecutive5xxErrors: 1 interval: 1s baseEjectionTime: 1m EOFדוגמת הקוד שלמעלה מפעילה ניתוב מקומי רק לשירות
frontend. צריך גם הגדרה נוספת שמטפלת בקצה העורפי.מחילים את קובץ ה-YAML של
frontend-drעל שני האשכולות:kubectl --context=${CLUSTER_1_NAME} apply -f ${WORKDIR}/frontend-dr.yaml kubectl --context=${CLUSTER_2_NAME} apply -f ${WORKDIR}/frontend-dr.yamlיוצרים קובץ YAML של
DestinationRuleשמפעיל את יתירות הכשל האזורית של איזון העומסים המקומי לשירותbackend:cat << EOF > ${WORKDIR}/backend-dr.yaml apiVersion: networking.istio.io/v1beta1 kind: DestinationRule metadata: name: backend namespace: backend spec: host: whereami-backend.backend.svc.cluster.local trafficPolicy: connectionPool: http: maxRequestsPerConnection: 0 loadBalancer: simple: LEAST_REQUEST localityLbSetting: enabled: true outlierDetection: consecutive5xxErrors: 1 interval: 1s baseEjectionTime: 1m EOFמחילים את קובץ ה-YAML של
backend-drעל שני האשכולות:kubectl --context=${CLUSTER_1_NAME} apply -f ${WORKDIR}/backend-dr.yaml kubectl --context=${CLUSTER_2_NAME} apply -f ${WORKDIR}/backend-dr.yamlכששתי קבוצות קובצי ה-YAML של
DestinationRuleמוחלות על שני האשכולות, הבקשות נשארות מקומיות באשכול שאליו הן מנותבות.כדי לבדוק את יתירות הכשל של השירות
frontend, צריך להקטין את מספר הרפליקות של שער הכניסה באשכול הראשי.מנקודת המבט של מאזן העומסים במספר אזורים, הפעולה הזו מדמה כשל באשכול. כתוצאה מכך, האשכול נכשל בבדיקות התקינות של מאזן העומסים. בדוגמה הזו נשתמש באשכול ב-
CLUSTER_1_REGION. אתם אמורים לראות רק תשובות מהאשכול ב-CLUSTER_2_REGION.מפחיתים לאפס את מספר הרפליקות של שער הכניסה באשכול הראשי, וקוראים לנקודת הקצה הציבורית כדי לוודא שהבקשות עברו לאשכול השני:
kubectl --context=${CLUSTER_1_NAME} -n ingress-gateway scale --replicas=0 deployment/asm-ingressgatewayהפלט אמור להיראות כך:
$ curl -s https://frontend.endpoints.PROJECT_ID.cloud.goog | jq { "backend_result": { "cluster_name": "edge-to-mesh-02", "gce_instance_id": "2717459599837162415", "gce_service_account": "e2m-mcg-01.svc.id.goog", "host_header": "whereami-backend.backend.svc.cluster.local", "metadata": "backend", "node_name": "gk3-edge-to-mesh-02-pool-2-675f6abf-dxs2", "pod_ip": "10.124.1.7", "pod_name": "whereami-backend-7cbdfd788-mp8zv", "pod_name_emoji": "🏌🏽♀", "pod_namespace": "backend", "pod_service_account": "whereami-backend", "project_id": "e2m-mcg-01", "timestamp": "2023-12-01T05:41:18", "zone": "us-east4-b" }, "cluster_name": "edge-to-mesh-02", "gce_instance_id": "6983018919754001204", "gce_service_account": "e2m-mcg-01.svc.id.goog", "host_header": "frontend.endpoints.e2m-mcg-01.cloud.goog", "metadata": "frontend", "node_name": "gk3-edge-to-mesh-02-pool-3-d42ddfbf-qmkn", "pod_ip": "10.124.1.142", "pod_name": "whereami-frontend-69c4c867cb-xf8db", "pod_name_emoji": "🏴", "pod_namespace": "frontend", "pod_service_account": "whereami-frontend", "project_id": "e2m-mcg-01", "timestamp": "2023-12-01T05:41:18", "zone": "us-east4-b" }כדי לחזור לניתוב התנועה הרגיל, משחזרים את הרפליקות של שער הכניסה לערך המקורי באשכול:
kubectl --context=${CLUSTER_1_NAME} -n ingress-gateway scale --replicas=3 deployment/asm-ingressgatewayכדי לדמות כשל בשירות
backend, מקטינים את מספר הרפליקות באזור הראשי ל-0:kubectl --context=${CLUSTER_1_NAME} -n backend scale --replicas=0 deployment/whereami-backendמוודאים שהתשובות מהשירות
frontendמגיעות מהאזור הראשיus-central1דרך מאזן העומסים, ושהתשובות מהשירותbackendמגיעות מהאזור המשניus-east4.הפלט צריך לכלול גם תשובה לשירות
frontendמהאזור הראשי (us-central1), ותשובה לשירותbackendמהאזור המשני (us-east4), כצפוי.כדי לחזור לניתוב התנועה הרגיל, משחזרים את הרפליקות של שירות הקצה העורפי לערך המקורי:
kubectl --context=${CLUSTER_1_NAME} -n backend scale --replicas=3 deployment/whereami-backend
עכשיו יש לכם מאזן עומסים גלובלי מסוג HTTP(S) שמשמש כ-frontend לאפליקציה במספר אזורים שמתארחת ברשת השירות.
הסרת המשאבים
כדי להימנע מצבירת חיובים בחשבון Google Cloud על המשאבים שבהם השתמשתם בפריסה הזו, אתם יכולים למחוק את הפרויקט שמכיל את המשאבים, או להשאיר את הפרויקט ולמחוק את המשאבים הספציפיים.
מחיקת הפרויקט
- במסוף Google Cloud , נכנסים לדף Manage resources.
- ברשימת הפרויקטים, בוחרים את הפרויקט שרוצים למחוק ולוחצים על Delete.
- כדי למחוק את הפרויקט, כותבים את מזהה הפרויקט בתיבת הדו-שיח ולוחצים על Shut down.
מחיקת המשאבים הנפרדים
אם אתם רוצים לשמור את הפרויקט Google Cloud שבו השתמשתם בפריסה הזו, אתם יכולים למחוק את המשאבים הנפרדים:
ב-Cloud Shell, מוחקים את המשאבים של
HTTPRoute:kubectl --context=${CLUSTER_1_NAME} delete -f ${WORKDIR}/default-httproute-redirect.yaml kubectl --context=${CLUSTER_2_NAME} delete -f ${WORKDIR}/default-httproute-redirect.yaml kubectl --context=${CLUSTER_1_NAME} delete -f ${WORKDIR}/default-httproute.yaml kubectl --context=${CLUSTER_2_NAME} delete -f ${WORKDIR}/default-httproute.yamlמוחקים את המשאבים של GKE Gateway:
kubectl --context=${CLUSTER_1_NAME} delete -f ${WORKDIR}/frontend-gateway.yaml kubectl --context=${CLUSTER_2_NAME} delete -f ${WORKDIR}/frontend-gateway.yamlמוחקים את כללי המדיניות:
kubectl --context=${CLUSTER_1_NAME} delete -f ${WORKDIR}/ingress-gateway-healthcheck.yaml kubectl --context=${CLUSTER_2_NAME} delete -f ${WORKDIR}/ingress-gateway-healthcheck.yaml kubectl --context=${CLUSTER_1_NAME} delete -f ${WORKDIR}/cloud-armor-backendpolicy.yaml kubectl --context=${CLUSTER_2_NAME} delete -f ${WORKDIR}/cloud-armor-backendpolicy.yamlמוחקים את קובצי הייצוא של השירות:
kubectl --context=${CLUSTER_1_NAME} delete -f ${WORKDIR}/svc_export.yaml kubectl --context=${CLUSTER_2_NAME} delete -f ${WORKDIR}/svc_export.yamlמוחקים את המשאבים של Cloud Armor:
gcloud --project=PROJECT_ID compute security-policies rules delete 1000 --security-policy edge-fw-policy --quiet gcloud --project=PROJECT_ID compute security-policies delete edge-fw-policy --quietמוחקים את המשאבים של Certificate Manager:
gcloud --project=PROJECT_ID certificate-manager maps entries delete mcg-cert-map-entry --map="mcg-cert-map" --quiet gcloud --project=PROJECT_ID certificate-manager maps delete mcg-cert-map --quiet gcloud --project=PROJECT_ID certificate-manager certificates delete mcg-cert --quietמוחקים את רשומת ה-DNS של נקודות הקצה:
gcloud --project=PROJECT_ID endpoints services delete "frontend.endpoints.PROJECT_ID.cloud.goog" --quietמוחקים את כתובת ה-IP הסטטית:
gcloud --project=PROJECT_ID compute addresses delete mcg-ip --global --quietמוחקים את אשכולות GKE Autopilot. השלב הזה נמשך כמה דקות.
gcloud --project=PROJECT_ID container clusters delete ${CLUSTER_1_NAME} --region ${CLUSTER_1_REGION} --quiet gcloud --project=PROJECT_ID container clusters delete ${CLUSTER_2_NAME} --region ${CLUSTER_2_REGION} --quiet
המאמרים הבאים
- מידע נוסף על תכונות נוספות שמוצעות על ידי GKE Gateway, שאפשר להשתמש בהן עם רשת השירותים
- מידע ולמידה על סוגים שונים של Cloud Load Balancing שזמינים ל-GKE
- מידע ולמידה על התכונות והפונקציות של Cloud Service Mesh
- לדוגמאות נוספות של ארכיטקטורות, תרשימים ושיטות מומלצות, עיינו במאמר Cloud Architecture Center.
שותפים ביצירת התוכן
מחברים:
- אלכס מטסון | מהנדס מומחה לאפליקציות
- מארק צ'ילברס | מהנדס מומחה לאפליקציות
תורמים אחרים:
- עבד אל-פתאח סג'יואר | אחראי קשרי מפתחים ב-Cloud
- גרג בריי | מהנדס לקוחות
- פול רוולו | אדריכל פתרונות ענן
- ולוואן ראג'אקומאר | אדריכל ארגוני בכיר