הגדרת אבטחת שירות באמצעות gRPC בלי שרת proxy (דור קודם)
במדריך הזה מוסבר איך להגדיר שירות אבטחה לרשת שירות gRPC ללא שרת proxy.
המסמך הזה רלוונטי רק ל-Cloud Service Mesh עם ממשקי ה-API לאיזון עומסים. זהו מסמך מדור קודם.
דרישות
לפני שמגדירים את אבטחת השירות לרשת השירותים של gRPC ללא שרת proxy, צריך לוודא שעומדים בדרישות הבאות.
- הפריסה עומדת בדרישות שמפורטות במאמר הכנה להגדרה של Cloud Service Mesh עם gRPC ללא שרת proxy.
- צריך להשתמש ב-xDS v3.
- יש לכם גישה לגרסת ה-xDS הנדרשת ולפונקציה של ספק האישורים באחת מהשפות הבאות:
- gRPC Java
- gRPC C++
- gRPC Python
- gRPC Go גרסאות השפה הנדרשות מפורטות ב-GitHub
- יש לכם גישה למחולל האתחול, גרסה 0.13.0. תמונת ה-bootstrap generator נמצאת ב Google Cloud מאגר הקונטיינרים.
- אתם עומדים בכל הדרישות המוקדמות לאיזון עומסים של רשת שירותים ללא שרת proxy ב-gRPC.
- יש לכם הרשאות מספיקות כדי ליצור או לעדכן את Cloud Service Mesh ואת המשאבים של רשת השירותGoogle Cloud , כדי להשתמש באבטחה של רשת שירות בלי שרת Proxy (PSM). למידע מלא על ההרשאות הנדרשות, קראו את המאמר הכנה להגדרה של Cloud Service Mesh עם שירותי gRPC ללא שרת proxy.
- יש לכם את ההרשאות הנדרשות לשימוש ב-Certificate Authority Service, שמתוארות במאמר יצירת רשויות אישורים להנפקת אישורים.
הגדרת ניהול זהויות והרשאות גישה (IAM)
צריכות להיות לכם ההרשאות הנדרשות לשימוש ב-Google Kubernetes Engine. התפקידים המינימליים שצריך:
- תפקיד אחד (
roles/container.clusterAdmin) ב-GKE - תפקיד
roles/compute.instanceAdminב-Compute Engine - תפקיד
roles/iam.serviceAccountUser
כדי ליצור את המשאבים שנדרשים להגדרה, צריך את התפקיד compute.NetworkAdmin. התפקיד הזה כולל את כל ההרשאות שנדרשות כדי ליצור, לעדכן, למחוק, להציג ולהשתמש (כלומר, להפנות אליהם במשאבים אחרים) במשאבים הנדרשים. אם אתם הבעלים-עורכים של הפרויקט, התפקיד הזה מוקצה לכם באופן אוטומטי.
שימו לב שהמדיניות networksecurity.googleapis.com.clientTlsPolicies.use ו-networksecurity.googleapis.com.serverTlsPolicies.use לא נאכפת כשמפנים למשאבים האלה בשירות לקצה העורפי ובמשאבי שרת ה-Proxy ל-HTTPS.
אם האכיפה הזו תתבצע בעתיד ואתם משתמשים בתפקיד compute.NetworkAdmin, לא תבחינו בבעיות כלשהן כשהבדיקה הזו תיאכף.
אם אתם משתמשים בתפקידים בהתאמה אישית והבדיקה הזו תיאכף בעתיד, תצטרכו לוודא שאתם כוללים את ההרשאה .use המתאימה. אחרת, יכול להיות שבעתיד לתפקיד בהתאמה אישית לא יהיו ההרשאות הנדרשות כדי להפנות אל clientTlsPolicy או אל serverTlsPolicy משירות הקצה העורפי או משרת ה-Proxy ל-HTTPS, בהתאמה.
הכנות להגדרה
אבטחת רשת שירותים בלי שרת proxy (PSM) מוסיפה אבטחה לרשת שירותים שמוגדרת לאיזון עומסים, בהתאם למסמכי התיעוד של שירותי gRPC בלי שרת proxy. ברשת Service mesh בלי שרת Proxy, לקוח gRPC משתמש בסכימה xds: ב-URI כדי לגשת לשירות, וכך מפעיל את התכונות של איזון עומסים וגילוי נקודות קצה ב-PSM.
עדכון הלקוחות והשרתים של gRPC לגרסה הנכונה
בונים או בונים מחדש את האפליקציות באמצעות גרסת ה-gRPC המינימלית שנתמכת בשפה שלכם.
עדכון קובץ ה-bootstrap
אפליקציות gRPC משתמשות בקובץ אתחול אחד, שחייב להכיל את כל השדות שנדרשים על ידי קוד בצד הלקוח ובצד השרת של gRPC. מחולל קובצי האתחול יוצר באופן אוטומטי את קובץ האתחול כך שיכלול דגלים וערכים שנדרשים לאבטחת PSM. מידע נוסף זמין בקטע קובץ Bootstrap, שכולל קובץ Bootstrap לדוגמה.
סקירה כללית על ההגדרה
תהליך ההגדרה הזה הוא הרחבה של הגדרת Cloud Service Mesh עם GKE ושירותי gRPC ללא שרת proxy. בכל מקום שבו השלבים הקיימים של תהליך ההגדרה לא השתנו, יש הפניה אליהם.
אלה השיפורים העיקריים בהגדרה של Cloud Service Mesh ב-GKE:
- הגדרת שירות CA, שבו יוצרים מאגרי CA פרטיים ואת רשויות האישורים הנדרשות.
- יצירת אשכול GKE עם התכונות "איחוד זהויות של עומסי עבודה ל-GKE" ו"אישורי רשת" ושילוב עם שירות CA.
- הגדרת הנפקת אישורים לרשת באשכול.
- יצירת חשבונות השירות של הלקוח והשרת.
- הגדרת שרת לדוגמה שמשתמש בממשקי API של xDS ובפרטי כניסה לשרת xDS כדי לקבל הגדרות אבטחה מ-Cloud Service Mesh.
- הגדרת הלקוח לדוגמה שמשתמש בפרטי הכניסה של xDS.
- עדכון ההגדרות של Cloud Service Mesh כך שיכללו את הגדרות האבטחה.
דוגמאות קוד לשימוש בפרטי כניסה של xDS מופיעות במיקומים הבאים:
עדכון של Google Cloud CLI
כדי לעדכן את Google Cloud CLI, מריצים את הפקודה הבאה:
gcloud components update
הגדרת משתני סביבה
במדריך הזה משתמשים בפקודות של Cloud Shell, ומידע שחוזר על עצמו בפקודות מיוצג על ידי משתני סביבה שונים. לפני שמריצים את הפקודות, צריך להגדיר את הערכים הספציפיים שלכם למשתני הסביבה הבאים בסביבת המעטפת. כל שורת הערה מציינת את המשמעות של משתנה הסביבה המשויך.
# Your project ID
PROJECT_ID=YOUR_PROJECT_ID
# GKE cluster name and zone for this example.
CLUSTER_NAME="secure-psm-cluster"
ZONE="us-east1-d"
# GKE cluster URL derived from the above
GKE_CLUSTER_URL="https://container.googleapis.com/v1/projects/${PROJECT_ID}/locations/${ZONE}/clusters/${CLUSTER_NAME}"
# Workload pool to be used with the GKE cluster
WORKLOAD_POOL="${PROJECT_ID}.svc.id.goog"
# Kubernetes namespace to run client and server demo.
K8S_NAMESPACE='default'
DEMO_BACKEND_SERVICE_NAME='grpc-gke-helloworld-service'
# Compute other values
# Project number for your project
PROJNUM=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")
# VERSION is the GKE cluster version. Install and use the most recent version
# from the rapid release channel and substitute its version for
# CLUSTER_VERSION, for example:
# VERSION=latest available version
# Note that the minimum required cluster version is 1.21.4-gke.1801.
VERSION="CLUSTER_VERSION"
SA_GKE=service-${PROJNUM}@container-engine-robot.iam.gserviceaccount.com
הפעלת הגישה לממשקי ה-API הנדרשים
בקטע הזה מוסבר איך להפעיל את הגישה לממשקי ה-API הנדרשים.
מריצים את הפקודה הבאה כדי להפעיל את Cloud Service Mesh וממשקי API אחרים שנדרשים לאבטחה של רשת שירותים של gRPC בלי שרת proxy.
gcloud services enable \ container.googleapis.com \ cloudresourcemanager.googleapis.com \ compute.googleapis.com \ trafficdirector.googleapis.com \ networkservices.googleapis.com \ networksecurity.googleapis.com \ privateca.googleapis.com \ gkehub.googleapis.comמריצים את הפקודה הבאה כדי לאפשר לחשבון השירות שמוגדר כברירת מחדל לגשת ל-Cloud Service Mesh Security API.
GSA_EMAIL=$(gcloud iam service-accounts list --format='value(email)' \ --filter='displayName:Compute Engine default service account') gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member serviceAccount:${GSA_EMAIL} \ --role roles/trafficdirector.client
יצירה או עדכון של אשכול GKE
אבטחת השירות של Cloud Service Mesh תלויה בשילוב של CA Service עם GKE. אשכול GKE צריך לעמוד בדרישות הבאות, בנוסף לדרישות להגדרה:
- גרסת האשכול המינימלית צריכה להיות 1.21.4-gke.1801. אם אתם צריכים תכונות שקיימות בגרסה מאוחרת יותר, אתם יכולים להשיג את הגרסה הזו מערוץ ההפצה המהירה.
- צריך להפעיל את אשכול GKE ולהגדיר אותו עם אישורי רשת, כמו שמתואר במאמר יצירת רשויות אישורים להנפקת אישורים.
יוצרים אשכול חדש שמשתמש באיחוד זהויות של עומסי עבודה ל-GKE. אם אתם מעדכנים אשכול קיים, דלגו לשלב הבא. הערך שאתם נותנים ל-
--tagsצריך להתאים לשם שמועבר לדגל--target-tagsשל הפקודהfirewall-rules createבקטע הגדרת Cloud Service Mesh עם רכיבי Cloud Load Balancing.# Create a GKE cluster with GKE managed mesh certificates. gcloud container clusters create CLUSTER_NAME \ --release-channel=rapid \ --scopes=cloud-platform \ --image-type=cos_containerd \ --machine-type=e2-standard-2 \ --zone=ZONE \ --workload-pool=PROJECT_ID.svc.id.goog \ --enable-mesh-certificates \ --cluster-version=CLUSTER_VERSION \ --enable-ip-alias \ --tags=allow-health-checks \ --workload-metadata=GKE_METADATA
יצירת האשכול עשויה להימשך כמה דקות.
אם אתם משתמשים באשכול קיים, הפעילו את איחוד הזהויות של עומסי עבודה ל-GKE ואת אישורי הרשת של GKE. מוודאים שהאשכול נוצר עם הדגל
--enable-ip-alias, שאי אפשר להשתמש בו עם הפקודהupdate.gcloud container clusters update CLUSTER_NAME \ --enable-mesh-certificates
מריצים את הפקודה הבאה כדי לעבור לאשכול החדש בתור אשכול ברירת המחדל לפקודות
kubectl:gcloud container clusters get-credentials CLUSTER_NAME \ --zone ZONE
רישום אשכולות ב-fleet
רושמים את האשכול שיצרתם או עדכנתם ב-יצירת אשכול GKE עם צי. רישום האשכול מאפשר להגדיר בקלות אשכולות בכמה פרויקטים.
שימו לב: כל אחד מהשלבים האלה יכול להימשך עד עשר דקות.
רושמים את האשכול ב-fleet:
gcloud container fleet memberships register CLUSTER_NAME \ --gke-cluster=ZONE/CLUSTER_NAME \ --enable-workload-identity --install-connect-agent \ --manifest-output-file=MANIFEST-FILE_NAME
מחליפים את המשתנים באופן הבא:
- CLUSTER_NAME: שם האשכול.
- ZONE: האזור של האשכול.
- MANIFEST-FILE_NAME: הנתיב שבו הפקודות האלה יוצרות את המניפסט לרישום.
אם תהליך הרישום יצליח, תופיע הודעה כמו זו:
Finished registering the cluster CLUSTER_NAME with the fleet.
מחילים את קובץ המניפסט שנוצר על האשכול:
kubectl apply -f MANIFEST-FILE_NAME
אם תהליך ההחלה יצליח, יופיעו הודעות כמו אלה:
namespace/gke-connect created serviceaccount/connect-agent-sa created podsecuritypolicy.policy/gkeconnect-psp created role.rbac.authorization.k8s.io/gkeconnect-psp:role created rolebinding.rbac.authorization.k8s.io/gkeconnect-psp:rolebinding created role.rbac.authorization.k8s.io/agent-updater created rolebinding.rbac.authorization.k8s.io/agent-updater created role.rbac.authorization.k8s.io/gke-connect-agent-20210416-01-00 created clusterrole.rbac.authorization.k8s.io/gke-connect-impersonation-20210416-01-00 created clusterrolebinding.rbac.authorization.k8s.io/gke-connect-impersonation-20210416-01-00 created clusterrolebinding.rbac.authorization.k8s.io/gke-connect-feature-authorizer-20210416-01-00 created rolebinding.rbac.authorization.k8s.io/gke-connect-agent-20210416-01-00 created role.rbac.authorization.k8s.io/gke-connect-namespace-getter created rolebinding.rbac.authorization.k8s.io/gke-connect-namespace-getter created secret/http-proxy created deployment.apps/gke-connect-agent-20210416-01-00 created service/gke-connect-monitoring created secret/creds-gcp create
משיגים את משאב החברות מהאשכול:
kubectl get memberships membership -o yaml
הפלט צריך לכלול את מאגר Workload Identity שהוקצה על ידי ה-fleet, כאשר PROJECT_ID הוא מזהה הפרויקט:
workload_identity_pool: PROJECT_ID.svc.id.goog
זה אומר שהאשכול נרשם בהצלחה.
יצירת רשויות אישורים להנפקת אישורים
כדי להנפיק אישורים ל-Pods, יוצרים מאגר של שירות CA ואת רשויות האישורים (CA) הבאות:
- רשות אישורים ברמה הבסיסית (root). זהו הבסיס לאמון בכל אישורי הרשת שהונפקו. אם יש לכם רשות אישורים בסיסית, אתם יכולים להשתמש בה. יוצרים את רשות האישורים ברמה הבסיסית (root CA) ברמה
enterprise, שמיועדת להנפקת אישורים לטווח ארוך ובנפח נמוך. - רשות אישורים משנית. רשות האישורים הזו מנפיקה אישורים לעומסי עבודה. יוצרים את רשות האישורים המשנית באזור שבו האשכול פרוס. יוצרים את רשות האישורים המשנית ברמה
devops, שמיועדת להנפקת אישורים לטווח קצר ובנפח גבוה.
יצירת רשות אישורים משנית היא אופציונלית, אבל מומלץ מאוד ליצור אחת במקום להשתמש ברשות אישורי הבסיס כדי להנפיק אישורי רשת GKE. אם אתם מחליטים להשתמש ב-CA הבסיסי כדי להנפיק אישורי רשת, ודאו שמצב ההנפקה מבוסס-ההגדרות שמוגדר כברירת מחדל נשאר מורשה.
רשות האישורים המשנית יכולה להיות באזור שונה מהאשכול, אבל מומלץ מאוד ליצור אותה באותו אזור של האשכול כדי לשפר את הביצועים. עם זאת, אפשר ליצור את רשויות האישורים ברמה הבסיסית וברמה המשנית באזורים שונים בלי להשפיע על הביצועים או על הזמינות.
אלה האזורים שנתמכים ב-CA Service:
| שם האזור | תיאור האזור |
|---|---|
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-southwest1 |
מדריד |
europe-west1 |
בלגיה |
europe-west2 |
לונדון |
europe-west3 |
פרנקפורט |
europe-west4 |
הולנד |
europe-west6 |
ציריך |
europe-west8 |
מילאנו |
europe-west9 |
פריז |
europe-west10 |
ברלין |
europe-west12 |
טורינו |
me-central1 |
דוחה |
me-central2 |
דמאם |
me-west1 |
תל אביב |
northamerica-northeast1 |
מונטריאול |
northamerica-northeast2 |
טורונטו |
southamerica-east1 |
סאו פאולו |
southamerica-west1 |
סנטיאגו |
us-central1 |
איווה |
us-east1 |
דרום קרוליינה |
us-east4 |
צפון וירג'יניה |
us-east5 |
קולומבוס |
us-south1 |
דאלאס |
us-west1 |
אורגון |
us-west2 |
לוס-אנג׳לס |
us-west3 |
סולט לייק סיטי |
us-west4 |
לאס וגאס |
אפשר גם לבדוק את רשימת המיקומים הנתמכים באמצעות הפקודה הבאה:
gcloud privateca locations list
מקצים את
roles/privateca.caManagerשל IAM לאנשים שיוצרים מאגר CA ו-CA. שימו לב שהפורמט הנכון של MEMBER הואuser:userid@example.com. אם המשתמש הנוכחי הוא האדם הזה, אפשר לקבל את מזהה המשתמש הנוכחי באמצעות פקודת המעטפת$(gcloud auth list --filter=status:ACTIVE --format="value(account)").gcloud projects add-iam-policy-binding PROJECT_ID \ --member=MEMBER \ --role=roles/privateca.caManager
מקצים את התפקיד
role/privateca.adminשל CA Service לאנשים שצריכים לשנות את מדיניות ה-IAM, כאשרMEMBERהוא אדם שצריך את הגישה הזו, ובמיוחד אנשים שמבצעים את השלבים הבאים שמקצים את התפקידיםprivateca.auditorו-privateca.certificateManager:gcloud projects add-iam-policy-binding PROJECT_ID \ --member=MEMBER \ --role=roles/privateca.admin
יוצרים את מאגר השורש של CA Service.
gcloud privateca pools create ROOT_CA_POOL_NAME \ --location ROOT_CA_POOL_LOCATION \ --tier enterprise
יוצרים רשות אישורי בסיס.
gcloud privateca roots create ROOT_CA_NAME --pool ROOT_CA_POOL_NAME \ --subject "CN=ROOT_CA_NAME, O=ROOT_CA_ORGANIZATION" \ --key-algorithm="ec-p256-sha256" \ --max-chain-length=1 \ --location ROOT_CA_POOL_LOCATION
בהגדרה הזו להדגמה, משתמשים בערכים הבאים למשתנים:
- ROOT_CA_POOL_NAME=td_sec_pool
- ROOT_CA_NAME=pkcs2-ca
- ROOT_CA_POOL_LOCATION=us-east1
- ROOT_CA_ORGANIZATION="TestCorpLLC"
יוצרים את מאגר המשנה ואת רשות האישורים המשנית. מוודאים שמצב ההנפקה המבוסס על הגדרות שמוגדר כברירת מחדל עדיין מותר.
gcloud privateca pools create SUBORDINATE_CA_POOL_NAME \ --location SUBORDINATE_CA_POOL_LOCATION \ --tier devops
gcloud privateca subordinates create SUBORDINATE_CA_NAME \ --pool SUBORDINATE_CA_POOL_NAME \ --location SUBORDINATE_CA_POOL_LOCATION \ --issuer-pool ROOT_CA_POOL_NAME \ --issuer-location ROOT_CA_POOL_LOCATION \ --subject "CN=SUBORDINATE_CA_NAME, O=SUBORDINATE_CA_ORGANIZATION" \ --key-algorithm "ec-p256-sha256" \ --use-preset-profile subordinate_mtls_pathlen_0
בהגדרה הזו להדגמה, משתמשים בערכים הבאים למשתנים:
- SUBORDINATE_CA_POOL_NAME="td-ca-pool"
- SUBORDINATE_CA_POOL_LOCATION=us-east1
- SUBORDINATE_CA_NAME="td-ca"
- SUBORDINATE_CA_ORGANIZATION="TestCorpLLC"
- ROOT_CA_POOL_NAME=td_sec_pool
- ROOT_CA_POOL_LOCATION=us-east1
מקצים את התפקיד
privateca.auditorב-IAM למאגר ה-CA ברמה הבסיסית (root), כדי לאפשר גישה מסוכן השירות של GKE:gcloud privateca pools add-iam-policy-binding ROOT_CA_POOL_NAME \ --location ROOT_CA_POOL_LOCATION \ --role roles/privateca.auditor \ --member="serviceAccount:service-PROJNUM@container-engine-robot.iam.gserviceaccount.com"
מקצים את התפקיד
privateca.certificateManagerב-IAM למאגר רשויות האישורים המשניות, כדי לאפשר גישה מסוכן השירות של GKE:gcloud privateca pools add-iam-policy-binding SUBORDINATE_CA_POOL_NAME \ --location SUBORDINATE_CA_POOL_LOCATION \ --role roles/privateca.certificateManager \ --member="serviceAccount:service-PROJNUM@container-engine-robot.iam.gserviceaccount.com"
שומרים את הגדרת ה-YAML הבאה של
WorkloadCertificateConfigכדי להורות לאשכול איך להנפיק אישורי רשת:apiVersion: security.cloud.google.com/v1 kind: WorkloadCertificateConfig metadata: name: default spec: # Required. The CA service that issues your certificates. certificateAuthorityConfig: certificateAuthorityServiceConfig: endpointURI: ISSUING_CA_POOL_URI # Required. The key algorithm to use. Choice of RSA or ECDSA. # # To maximize compatibility with various TLS stacks, your workloads # should use keys of the same family as your root and subordinate CAs. # # To use RSA, specify configuration such as: # keyAlgorithm: # rsa: # modulusSize: 4096 # # Currently, the only supported ECDSA curves are "P256" and "P384", and the only # supported RSA modulus sizes are 2048, 3072 and 4096. keyAlgorithm: rsa: modulusSize: 4096 # Optional. Validity duration of issued certificates, in seconds. # # Defaults to 86400 (1 day) if not specified. validityDurationSeconds: 86400 # Optional. Try to start rotating the certificate once this # percentage of validityDurationSeconds is remaining. # # Defaults to 50 if not specified. rotationWindowPercentage: 50מחליפים את מה שכתוב בשדות הבאים:
- מזהה הפרויקט שבו פועל האשכול:
PROJECT_ID
- ה-URI המלא של רשות האישורים (CA) שמנפיקה את האישורים של רשת ה-Mesh (ISSUING_CA_POOL_URI).
היא יכולה להיות רשות האישורים המשנית (מומלץ) או רשות האישורים הבסיסית. הפורמט הוא:
//privateca.googleapis.com/projects/PROJECT_ID/locations/SUBORDINATE_CA_POOL_LOCATION/caPools/SUBORDINATE_CA_POOL_NAME
- מזהה הפרויקט שבו פועל האשכול:
שומרים את הגדרת ה-YAML הבאה של
TrustConfigכדי להגדיר לאשכול איך לתת אמון באישורים שהונפקו:apiVersion: security.cloud.google.com/v1 kind: TrustConfig metadata: name: default spec: # You must include a trustStores entry for the trust domain that # your cluster is enrolled in. trustStores: - trustDomain: PROJECT_ID.svc.id.goog # Trust identities in this trustDomain if they appear in a certificate # that chains up to this root CA. trustAnchors: - certificateAuthorityServiceURI: ROOT_CA_POOL_URIמחליפים את מה שכתוב בשדות הבאים:
- מזהה הפרויקט שבו פועל האשכול:
PROJECT_ID
- ה-URI המלא של מאגר רשויות ה-CA הבסיסיות (ROOT_CA_POOL_URI).
הפורמט הוא:
//privateca.googleapis.com/projects/PROJECT_ID/locations/ROOT_CA_POOL_LOCATION/caPools/ROOT_CA_POOL_NAME
- מזהה הפרויקט שבו פועל האשכול:
מחילים את ההגדרות על האשכול:
kubectl apply -f WorkloadCertificateConfig.yaml kubectl apply -f TrustConfig.yaml
יצירת שירות gRPC בלי שרת Proxy עם קבוצות של נקודות קצה ברשת (NEG)
כדי להשתמש באבטחת PSM, צריך שרת gRPC בלי שרת Proxy שיכול להשתמש ב-xDS כדי לקבל הגדרות אבטחה מ-Cloud Service Mesh. השלב הזה דומה להגדרת שירותי GKE עם קבוצות NEG במדריך להגדרת איזון עומסים של PSM, אבל משתמשים בשרת helloworld שמותאם ל-xDS בדוגמה ל-xDS במאגר grpc-java במקום בתמונת java-example-hostname.
אתם יוצרים ומריצים את השרת הזה בקונטיינר שנוצר מ-openjdk:8-jdk image.
אתם משתמשים גם בתכונה של קבוצת נקודות קצה בעלת שם, שמאפשרת לכם לציין שם לקבוצת נקודות הקצה. כך השלבים הבאים יהיו פשוטים יותר, כי הפריסה תדע את שם ה-NEG בלי שתצטרכו לחפש אותו.
הדוגמה הבאה היא מפרט Kubernetes מלא של שרת gRPC. שימו לב לפרטים הבאים:
- המפרט יוצר חשבון שירות של Kubernetes
example-grpc-serverשמשמש את ה-Pod של שרת ה-gRPC. - המפרט משתמש בשדה
nameבהערהcloud.google.com/negשל השירות כדי לציין את שם ה-NEGexample-grpc-server. - המשתנה
${PROJNUM}מייצג את מספר הפרויקט שלכם. - המפרט משתמש בקטע
initContainersכדי להריץ מחולל של קובץ אתחול, כדי לאכלס את קובץ האתחול שספריית gRPC בלי שרת Proxy צריכה. קובץ ה-bootstrap הזה נמצא ב-/tmp/grpc-xds/td-grpc-bootstrap.jsonב-מאגר תגים בצד השרת של gRPC שנקראexample-grpc-server.
מוסיפים את ההערה הבאה למפרט של ה-Pod:
annotations: security.cloud.google.com/use-workload-certificates: ""
אפשר לראות את המיקום הנכון במפרט המלא שבהמשך.
כשיוצרים Pod, הוא מקבל אמצעי אחסון בנתיב /var/run/secrets/workload-spiffe-credentials.
הכרך הזה מכיל את הפריטים הבאים:
-
private_key.pemהוא מפתח פרטי שנוצר באופן אוטומטי. -
certificates.pemהיא חבילה של אישורים בפורמט PEM שאפשר להציג ל-Pod אחר בתור שרשרת אישורי לקוח, או להשתמש בה בתור שרשרת אישורי שרת. -
ca_certificates.pemהיא חבילה של אישורים בפורמט PEM שמשמשים כישויות עוגן אמינות כשמאמתים את שרשרת אישורי הלקוח שמוצגת על ידי Pod אחר, או את שרשרת אישורי השרת שמתקבלת כשמתחברים ל-Pod אחר.
שימו לב ש-ca_certificates.pem מכיל אישורים למתחם האמון המקומי של עומסי העבודה, שהוא מאגר עומסי העבודה של האשכול.
אישור הקצה ב-certificates.pem מכיל את טענת הנכוֹנוּת (assertion) הבאה של זהות SPIFFE בטקסט פשוט:
spiffe://WORKLOAD_POOL/ns/NAMESPACE/sa/KUBERNETES_SERVICE_ACCOUNT
בטענה הזו:
- WORKLOAD_POOL הוא השם של מאגר עומסי העבודה של האשכול.
- NAMESPACE הוא מרחב השמות של חשבון השירות של Kubernetes.
- KUBERNETES_SERVICE_ACCOUNT הוא השם של חשבון השירות ב-Kubernetes.
ההוראות הבאות בשפה שלכם יוצרות את המפרט לשימוש בדוגמה הזו.
Java
מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
יוצרים את המפרט:
cat << EOF > example-grpc-server.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-server namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com --- apiVersion: v1 kind: Service metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server annotations: cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}' spec: ports: - name: helloworld port: 8080 protocol: TCP targetPort: 50051 selector: k8s-app: example-grpc-server type: ClusterIP --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-server strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-server spec: containers: - image: openjdk:8-jdk imagePullPolicy: IfNotPresent name: example-grpc-server command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" ports: - protocol: TCP containerPort: 50051 resources: limits: cpu: 800m memory: 512Mi requests: cpu: 100m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" - --node-metadata=app=helloworld resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-server volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
C++
מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
יוצרים את המפרט:
cat << EOF > example-grpc-server.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-server namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com --- apiVersion: v1 kind: Service metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server annotations: cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}' spec: ports: - name: helloworld port: 8080 protocol: TCP targetPort: 50051 selector: k8s-app: example-grpc-server type: ClusterIP --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-server strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-server spec: containers: - image: phusion/baseimage:18.04-1.0.0 imagePullPolicy: IfNotPresent name: example-grpc-server command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" ports: - protocol: TCP containerPort: 50051 resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" - --node-metadata=app=helloworld resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-server volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
Python
מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
יוצרים את המפרט:
cat << EOF > example-grpc-server.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-server namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com --- apiVersion: v1 kind: Service metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server annotations: cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}' spec: ports: - name: helloworld port: 8080 protocol: TCP targetPort: 50051 selector: k8s-app: example-grpc-server type: ClusterIP --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-server strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-server spec: containers: - image: phusion/baseimage:18.04-1.0.0 imagePullPolicy: IfNotPresent name: example-grpc-server command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" ports: - protocol: TCP containerPort: 50051 resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" - --node-metadata=app=helloworld resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-server volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
המשך
מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
יוצרים את המפרט:
cat << EOF > example-grpc-server.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-server namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com --- apiVersion: v1 kind: Service metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server annotations: cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}' spec: ports: - name: helloworld port: 8080 protocol: TCP targetPort: 50051 selector: k8s-app: example-grpc-server type: ClusterIP --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-server strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-server spec: containers: - image: golang:1.16-alpine imagePullPolicy: IfNotPresent name: example-grpc-server command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" ports: - protocol: TCP containerPort: 50051 resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" - --node-metadata=app=helloworld resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-server volumes: - name: grpc-td-conf emptyDir: medium: Memory EOFכך משלימים את התהליך:
מחילים את המפרט:
kubectl apply -f example-grpc-server.yaml
מקצים לחשבון השירות את התפקידים הנדרשים:
gcloud iam service-accounts add-iam-policy-binding \ --role roles/iam.workloadIdentityUser \ --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/example-grpc-server]" \ ${PROJNUM}-compute@developer.gserviceaccount.com gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/example-grpc-server]" \ --role roles/trafficdirector.clientמריצים את הפקודות הבאות כדי לוודא שהשירות וה-Pod נוצרו בצורה נכונה:
kubectl get deploy/example-grpc-server kubectl get svc/example-grpc-server
מוודאים ששם ה-NEG נכון:
gcloud compute network-endpoint-groups list \ --filter "name=example-grpc-server" --format "value(name)"הפקודה הקודמת אמורה להחזיר את השם של קבוצת נקודות הקצה ברשת
example-grpc-server.
הגדרת Cloud Service Mesh עם רכיבי איזון עומסים של Google Cloud
השלבים בקטע הזה דומים לשלבים שמפורטים במאמר הגדרת Cloud Service Mesh עם רכיבים של איזון עומסים, אבל יש כמה שינויים, כפי שמתואר בקטעים הבאים.
יצירת בדיקת תקינות, כלל חומת אש ושירות לקצה העורפי
כשהשרת של gRPC מוגדר להשתמש ב-mTLS, בדיקות התקינות של gRPC לא פועלות כי הלקוח של בדיקת התקינות לא יכול להציג לשרתים אישור לקוח תקין. יש שתי דרכים לפתור את הבעיה.
בגישה הראשונה, השרת יוצר יציאת הצגה נוספת שמוגדרת כיציאה לבדיקת תקינות. הוא מחובר לשירות בדיקת תקינות מיוחד, כטקסט פשוט או כ-TLS ליציאה הזו.
helloworldשרת ה-xDS לדוגמה משתמש ב-PORT_NUMBER + 1 כיציאה לבדיקת תקינות של טקסט פשוט. בדוגמה הזו, היציאה 50052 משמשת לבדיקת תקינות כי היציאה 50051 היא היציאה של שרת האפליקציה של gRPC.
בגישה השנייה, מגדירים את בדיקת התקינות כך שתבדוק רק את הקישוריות של TCP ליציאה להצגת האפליקציה. היא בודקת רק את הקישוריות, וגם יוצרת תנועה מיותרת לשרת כשאין לחיצות יד מוצלחות בפרוטוקול TLS. לכן, מומלץ להשתמש בגישה הראשונה.
יוצרים את בדיקת התקינות. שימו לב שבדיקת התקינות לא תתחיל עד שתיצרו ותפעילו את השרת.
אם אתם יוצרים יציאת שירות ייעודית לבדיקת תקינות, שזו הגישה המומלצת, השתמשו בפקודה הזו:
gcloud compute health-checks create grpc grpc-gke-helloworld-hc \ --enable-logging --port 50052
אם אתם יוצרים בדיקת תקינות של TCP, שאנחנו לא ממליצים עליה, השתמשו בפקודה הזו:
gcloud compute health-checks create tcp grpc-gke-helloworld-hc \ --use-serving-port
יוצרים את חומת האש. חשוב לוודא שהערך של
--target-tagsתואם לערך שציינתם בשביל--tagsבקטע יצירה או עדכון של אשכול GKE.gcloud compute firewall-rules create grpc-gke-allow-health-checks \ --network default --action allow --direction INGRESS \ --source-ranges 35.191.0.0/16,130.211.0.0/22 \ --target-tags allow-health-checks \ --rules tcp:50051-50052
יוצרים את השירות לקצה העורפי:
gcloud compute backend-services create grpc-gke-helloworld-service \ --global \ --load-balancing-scheme=INTERNAL_SELF_MANAGED \ --protocol=GRPC \ --health-checks grpc-gke-helloworld-hc
מצרפים את ה-NEG לשירות לקצה העורפי:
gcloud compute backend-services add-backend grpc-gke-helloworld-service \ --global \ --network-endpoint-group example-grpc-server \ --network-endpoint-group-zone ${ZONE} \ --balancing-mode RATE \ --max-rate-per-endpoint 5
יצירת המפה של כללי הניתוב
התהליך הזה דומה ליצירת מפה של כללי מסלול בהגדרה של Cloud Service Mesh עם Google Kubernetes Engine ושירותי gRPC בלי שרת Proxy.
יוצרים את מפת כתובות ה-URL:
gcloud compute url-maps create grpc-gke-url-map \ --default-service grpc-gke-helloworld-service
מוסיפים את התאמת הנתיב למפת URL:
gcloud compute url-maps add-path-matcher grpc-gke-url-map \ --default-service grpc-gke-helloworld-service \ --path-matcher-name grpc-gke-path-matcher \ --new-hosts helloworld-gke:8000
יוצרים את שרת ה-proxy ל-gRPC:
gcloud compute target-grpc-proxies create grpc-gke-proxy \ --url-map grpc-gke-url-map --validate-for-proxyless
יוצרים את כלל ההעברה:
gcloud compute forwarding-rules create grpc-gke-forwarding-rule \ --global \ --load-balancing-scheme=INTERNAL_SELF_MANAGED \ --address=0.0.0.0 \ --target-grpc-proxy=grpc-gke-proxy \ --ports 8000 \ --network default
הגדרת Cloud Service Mesh עם אבטחת gRPC בלי שרת proxy
הדוגמה הזו ממחישה איך להגדיר mTLS בצד הלקוח ובצד השרת.
הפורמט של הפניות למדיניות
שימו לב לפורמט הנדרש הבא להפניה לכללי מדיניות של TLS בשרת ו-TLS בלקוח:
projects/PROJECT_ID/locations/global/[serverTlsPolicies|clientTlsPolicies]/[server-tls-policy|client-mtls-policy]
לדוגמה:
projects/PROJECT_ID/locations/global/serverTlsPolicies/server-tls-policy
projects/PROJECT_ID/locations/global/clientTlsPolicies/client-mtls-policy
הגדרת mTLS בצד השרת
קודם יוצרים מדיניות TLS לשרת. המדיניות מבקשת מצד השרת של gRPC להשתמש בהגדרת הפלאגין של certificateProvicerInstance שמזוהה לפי השם google_cloud_private_spiffe לאישור הזהות, שהוא חלק מ-serverCertificate. הקטע mtlsPolicy מציין אבטחת mTLS ומשתמש באותו google_cloud_private_spiffe כמו הגדרת הפלאגין של clientValidationCa, שהוא מפרט אישור הבסיס (אימות).
בשלב הבא יוצרים מדיניות של נקודת קצה. ההגדרה הזו מציינת ש-backend, למשל שרת gRPC, שמשתמש ביציאה 50051 עם תוויות מטא-נתונים כלשהן או בלי תוויות מטא-נתונים, מקבל את מדיניות ה-TLS המצורפת לשרת בשם server-mtls-policy. כדי לציין תוויות של מטא-נתונים, משתמשים ב-MATCH_ALL. יוצרים את מדיניות נקודת הקצה באמצעות קובץ זמני ep-mtls-psms.yaml שמכיל את הערכים של משאב מדיניות נקודת הקצה, על סמך המדיניות שכבר הגדרתם.
יוצרים קובץ זמני בשם
server-mtls-policy.yamlבספרייה הנוכחית עם הערכים של משאב מדיניות ה-TLS של השרת:name: "projects/${PROJECT_ID}/locations/global/serverTlsPolicies/server-mtls-policy" serverCertificate: certificateProviderInstance: pluginInstance: google_cloud_private_spiffe mtlsPolicy: clientValidationCa: - certificateProviderInstance: pluginInstance: google_cloud_private_spiffeיוצרים משאב מדיניות TLS לשרת בשם
server-mtls-policyעל ידי ייבוא הקובץ הזמניserver-mtls-policy.yaml:gcloud network-security server-tls-policies import server-mtls-policy \ --source=server-mtls-policy.yaml --location=global
יוצרים את מדיניות נקודת הקצה על ידי יצירת הקובץ הזמני
ep-mtls-psms.yaml:name: "ep-mtls-psms" type: "GRPC_SERVER" serverTlsPolicy: "projects/${PROJECT_ID}/locations/global/serverTlsPolicies/server-mtls-policy" trafficPortSelector: ports: - "50051" endpointMatcher: metadataLabelMatcher: metadataLabelMatchCriteria: "MATCH_ALL" metadataLabels: - labelName: app labelValue: helloworldמייבאים את הקובץ
ep-mtls-psms.yamlכדי ליצור את משאב המדיניות של נקודת הקצה:gcloud beta network-services endpoint-policies import ep-mtls-psms \ --source=ep-mtls-psms.yaml --location=global
הגדרת mTLS בצד הלקוח
מדיניות האבטחה בצד הלקוח מצורפת לשירות לקצה העורפי. כשלקוח ניגש לקצה עורפי (שרת gRPC) דרך שירות לקצה העורפי, מדיניות האבטחה בצד הלקוח שמצורפת נשלחת ללקוח.
יוצרים את תוכן המשאב של מדיניות ה-TLS של הלקוח בקובץ זמני בשם
client-mtls-policy.yamlבספרייה הנוכחית:name: "client-mtls-policy" clientCertificate: certificateProviderInstance: pluginInstance: google_cloud_private_spiffe serverValidationCa: - certificateProviderInstance: pluginInstance: google_cloud_private_spiffeיוצרים את משאב מדיניות ה-TLS של הלקוח שנקרא
client-mtls-policyעל ידי ייבוא הקובץ הזמניclient-mtls-policy.yaml:gcloud network-security client-tls-policies import client-mtls-policy \ --source=client-mtls-policy.yaml --location=global
יוצרים קטע קוד בקובץ זמני כדי להפנות למדיניות הזו, ומוסיפים פרטים של
subjectAltNamesבהודעהSecuritySettingsכמו בדוגמה הבאה. מחליפים את${PROJECT_ID}בערך של מזהה הפרויקט, שהוא הערך של משתנה הסביבה${PROJECT_ID}שמתואר למעלה. שימו לב ש-example-grpc-serverב-subjectAltNamesהוא השם של חשבון השירות ב-Kubernetes שמשמש ל-Pod של שרת ה-gRPC במפרט הפריסה.if [ -z "$PROJECT_ID" ] ; then echo Please make sure PROJECT_ID is set. ; fi cat << EOF > client-security-settings.yaml securitySettings: clientTlsPolicy: projects/${PROJECT_ID}/locations/global/clientTlsPolicies/client-mtls-policy subjectAltNames: - "spiffe://${PROJECT_ID}.svc.id.goog/ns/default/sa/example-grpc-server" EOFמוסיפים את ההודעה
securitySettingsלשירות לקצה העורפי שכבר יצרתם. בשלבים האלה מייצאים את התוכן הנוכחי של השירות לקצה העורפי, מוסיפים את ההודעהsecuritySettingשל הלקוח ומייבאים מחדש את התוכן החדש כדי לעדכן את השירות לקצה העורפי.gcloud compute backend-services export grpc-gke-helloworld-service --global \ --destination=/tmp/grpc-gke-helloworld-service.yaml cat /tmp/grpc-gke-helloworld-service.yaml client-security-settings.yaml \ >/tmp/grpc-gke-helloworld-service1.yaml gcloud compute backend-services import grpc-gke-helloworld-service --global \ --source=/tmp/grpc-gke-helloworld-service1.yaml -q
אימות ההגדרות האישיות
הגדרת Cloud Service Mesh הושלמה, כולל אבטחה בצד השרת ובצד הלקוח. בשלב הבא מכינים ומריצים את עומסי העבודה של השרת והלקוח. בשלב הזה הדוגמה מסתיימת.
יצירת לקוח gRPC בלי שרת proxy
השלב הזה דומה לשלב הקודם, יצירת שירות gRPC בלי שרת Proxy.
אתם משתמשים בלקוח helloworld שמותאם ל-xDS מספריית הדוגמאות של xDS במאגר grpc-java. אתם יוצרים ומריצים את הלקוח בקונטיינר שנוצר מ-openjdk:8-jdk image. המפרט של לקוח gRPC ב-Kubernetes מבצע את הפעולות הבאות:
- הוא יוצר חשבון שירות של Kubernetes (
example-grpc-client) שמשמש את Pod הלקוח של gRPC. -
${PROJNUM}מייצג את מספר הפרויקט שלכם, וצריך להחליף אותו במספר האמיתי.
מוסיפים את ההערה הבאה למפרט של ה-Pod:
annotations:
security.cloud.google.com/use-workload-certificates: ""
כשיוצרים Pod, הוא מקבל אמצעי אחסון בנתיב /var/run/secrets/workload-spiffe-credentials.
הכרך הזה מכיל את הפריטים הבאים:
-
private_key.pemהוא מפתח פרטי שנוצר באופן אוטומטי. -
certificates.pemהיא חבילה של אישורים בפורמט PEM שאפשר להציג ל-Pod אחר בתור שרשרת אישורי לקוח, או להשתמש בה בתור שרשרת אישורי שרת. -
ca_certificates.pemהיא חבילה של אישורים בפורמט PEM שמשמשים כישויות עוגן אמינות כשמאמתים את שרשרת אישורי הלקוח שמוצגת על ידי Pod אחר, או את שרשרת אישורי השרת שמתקבלת כשמתחברים ל-Pod אחר.
שימו לב שהמשתנה ca_certificates.pem מכיל את אישורי הבסיס של מתחם האמון המקומי של עומסי העבודה, שהוא מאגר עומסי העבודה של האשכול.
אישור הקצה ב-certificates.pem מכיל את טענת הנכוֹנוּת (assertion) הבאה של זהות SPIFFE בטקסט פשוט:
spiffe://WORKLOAD_POOL/ns/NAMESPACE/sa/KUBERNETES_SERVICE_ACCOUNT
בטענה הזו:
- WORKLOAD_POOL הוא השם של מאגר עומסי העבודה של האשכול.
- NAMESPACE הוא השם של חשבון השירות של Kubernetes.
- KUBERNETES_SERVICE_ACCOUNT הוא מרחב השמות של חשבון השירות של Kubernetes.
ההוראות הבאות בשפה שלכם יוצרות את המפרט לשימוש בדוגמה הזו.
Java
מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
יוצרים את המפרט הבא:
cat << EOF > example-grpc-client.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-client namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-client namespace: default labels: k8s-app: example-grpc-client spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-client strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-client spec: containers: - image: openjdk:8-jdk imagePullPolicy: IfNotPresent name: example-grpc-client command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" resources: limits: cpu: 800m memory: 512Mi requests: cpu: 100m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-client volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
C++
מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
יוצרים את המפרט הבא:
cat << EOF > example-grpc-client.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-client namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-client namespace: default labels: k8s-app: example-grpc-client spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-client strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-client spec: containers: - image: phusion/baseimage:18.04-1.0.0 imagePullPolicy: IfNotPresent name: example-grpc-client command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-client volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
Python
מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
יוצרים את המפרט הבא:
cat << EOF > example-grpc-client.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-client namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-client namespace: default labels: k8s-app: example-grpc-client spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-client strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-client spec: containers: - image: phusion/baseimage:18.04-1.0.0 imagePullPolicy: IfNotPresent name: example-grpc-client command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-client volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
המשך
מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
יוצרים את המפרט הבא:
cat << EOF > example-grpc-client.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-client namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-client namespace: default labels: k8s-app: example-grpc-client spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-client strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-client spec: containers: - image: golang:1.16-alpine imagePullPolicy: IfNotPresent name: example-grpc-client command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-client volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
כך משלימים את התהליך:
מחילים את המפרט:
kubectl apply -f example-grpc-client.yaml
מקצים לחשבון השירות את התפקידים הנדרשים:
gcloud iam service-accounts add-iam-policy-binding \ --role roles/iam.workloadIdentityUser \ --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/example-grpc-client]" \ ${PROJNUM}-compute@developer.gserviceaccount.com gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/example-grpc-client]" \ --role roles/trafficdirector.clientמוודאים שה-Pod של הלקוח פועל:
kubectl get pods
הפקודה מחזירה טקסט שדומה לזה:
NAMESPACE NAME READY STATUS RESTARTS AGE default example-grpc-client-7c969bb997-9fzjv 1/1 Running 0 104s [..skip..]
הפעלת השרת
מפתחים ומריצים את שרת helloworld עם xDS ב-Pod של השרת שיצרתם קודם.
Java
משיגים את השם של ה-Pod שנוצר בשביל השירות
example-grpc-server:kubectl get pods | grep example-grpc-server
המשוב שמוצג נראה כך:
default example-grpc-server-77548868d-l9hmf 1/1 Running 0 105s
פותחים מעטפת ל-Pod של השרת:
kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash
ב-shell, מוודאים שקובץ ה-bootstrap ב-
/tmp/grpc-xds/td-grpc-bootstrap.jsonתואם לסכימה שמתוארת בקטע קובץ Bootstrap.מורידים את gRPC Java בגרסה 1.42.1 ויוצרים את אפליקציית השרת של
xds-hello-world.curl -L https://github.com/grpc/grpc-java/archive/v1.42.1.tar.gz | tar -xz cd grpc-java-1.42.1/examples/example-xds ../gradlew --no-daemon installDist
מריצים את השרת עם הדגל
--xds-credsכדי לציין אבטחה שמותאמת ל-xDS, באמצעות50051כיציאת ההאזנה ו-xds-serverכשם הזיהוי של השרת:./build/install/example-xds/bin/xds-hello-world-server --xds-creds 50051 xds-server
אחרי שהשרת מקבל את ההגדרות הנדרשות מ-Cloud Service Mesh, מופיע הפלט הבא:
Listening on port 50051 plain text health service listening on port 50052
C++
משיגים את השם של ה-Pod שנוצר בשביל השירות
example-grpc-server:kubectl get pods | grep example-grpc-server
המשוב שמוצג נראה כך:
default example-grpc-server-77548868d-l9hmf 1/1 Running 0 105s
פותחים מעטפת ל-Pod של השרת:
kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash
ב-shell, מוודאים שקובץ ה-bootstrap ב-
/tmp/grpc-xds/td-grpc-bootstrap.jsonתואם לסכימה שמתוארת בקטע קובץ Bootstrap.מורידים את gRPC C++ ויוצרים את אפליקציית השרת
xds-hello-world.apt-get update -y && \ apt-get install -y \ build-essential \ clang \ python3 \ python3-dev curl -L https://github.com/grpc/grpc/archive/master.tar.gz | tar -xz cd grpc-master tools/bazel build examples/cpp/helloworld:xds_greeter_serverמריצים את השרת באמצעות
50051כיציאת ההאזנה, ו-xds_greeter_serverכשם הזיהוי של השרת:bazel-bin/examples/cpp/helloworld/xds_greeter_server --port=50051 --maintenance_port=50052 --secure
כדי להפעיל את השרת בלי פרטי כניסה, אפשר לציין את הפרטים הבאים:
bazel-bin/examples/cpp/helloworld/xds_greeter_server --nosecure
אחרי שהשרת מקבל את ההגדרות הנדרשות מ-Cloud Service Mesh, מופיע הפלט הבא:
Listening on port 50051 plain text health service listening on port 50052
Python
משיגים את השם של ה-Pod שנוצר בשביל השירות
example-grpc-server:kubectl get pods | grep example-grpc-server
המשוב שמוצג נראה כך:
default example-grpc-server-77548868d-l9hmf 1/1 Running 0 105s
פותחים מעטפת ל-Pod של השרת:
kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash
ב-shell, מוודאים שקובץ ה-bootstrap ב-
/tmp/grpc-xds/td-grpc-bootstrap.jsonתואם לסכימה שמתוארת בקטע קובץ Bootstrap.מורידים את גרסה 1.41.0 של gRPC Python ויוצרים את האפליקציה לדוגמה.
apt-get update -y
apt-get install -y python3 python3-pip
curl -L https://github.com/grpc/grpc/archive/v1.41.x.tar.gz | tar -xz
cd grpc-1.41.x/examples/python/xds/
python3 -m virtualenv venv
source venv/bin/activate
python3 -m pip install -r requirements.txt
מריצים את השרת עם הדגל
--xds-credsכדי לציין אבטחה שמותאמת ל-xDS, ומשתמשים ב-50051כיציאת ההאזנה.python3 server.py 50051 --xds-creds
אחרי שהשרת מקבל את ההגדרות הנדרשות מ-Cloud Service Mesh, מופיע הפלט הבא:
2021-05-06 16:10:34,042: INFO Running with xDS Server credentials 2021-05-06 16:10:34,043: INFO Greeter server listening on port 50051 2021-05-06 16:10:34,046: INFO Maintenance server listening on port 50052
המשך
משיגים את השם של ה-Pod שנוצר בשביל השירות
example-grpc-server:kubectl get pods | grep example-grpc-server
המשוב שמוצג נראה כך:
default example-grpc-server-77548868d-l9hmf 1/1 Running 0 105s
פותחים מעטפת ל-Pod של השרת:
kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/sh
ב-shell, מוודאים שקובץ ה-bootstrap ב-
/tmp/grpc-xds/td-grpc-bootstrap.jsonתואם לסכימה שמתוארת בקטע קובץ Bootstrap.מורידים את גרסה 1.41.0 של gRPC Go ועוברים לספרייה שמכילה את אפליקציית השרת של
xds-hello-world.apk add curl curl -L https://github.com/grpc/grpc-go/archive/v1.42.0.tar.gz | tar -xz cd grpc-go-1.42.0/examples/features/xds/server
מריצים את השרת עם הדגל
--xds_credsכדי לציין אבטחה שמותאמת ל-xDS, ומשתמשים ב-50051כיציאת ההאזנה:GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY="info" \ go run main.go \ -xds_creds \ -port 50051
אחרי שהשרת מקבל את ההגדרות הנדרשות מ-Cloud Service Mesh, מופיע הפלט הבא:
Using xDS credentials... Serving GreeterService on 0.0.0.0:50051 and HealthService on 0.0.0.0:50052
תהליך בדיקת התקינות נמשך בין 3 ל-5 דקות, ואחרי שהשרת מתחיל, השירות מוגדר כתקין.
הפעלת הלקוח ואימות ההגדרות האישיות
מריצים את הלקוח helloworld עם xDS ב-Pod של הלקוח שיצרתם קודם.
Java
משיגים את השם של Pod הלקוח:
kubectl get pods | grep example-grpc-client
אתם רואים משוב כמו זה:
default example-grpc-client-7c969bb997-9fzjv 1/1 Running 0 105s
פותחים מעטפת ל-Pod של הלקוח:
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
במעטפת הפקודות, מורידים את גרסה 1.42.1 של gRPC Java ויוצרים את אפליקציית הלקוח של
xds-hello-world.curl -L https://github.com/grpc/grpc-java/archive/v1.42.1.tar.gz | tar -xz cd grpc-java-1.42.1/examples/example-xds ../gradlew --no-daemon installDist
מריצים את הלקוח עם הדגל
--xds-credsכדי לציין אבטחה שמופעלת באמצעות xDS, שם הלקוח ומחרוזת החיבור של היעד:./build/install/example-xds/bin/xds-hello-world-client --xds-creds xds-client \ xds:///helloworld-gke:8000הפלט אמור להיראות כך:
Greeting: Hello xds-client, from xds-server
C++
משיגים את השם של Pod הלקוח:
kubectl get pods | grep example-grpc-client
אתם רואים משוב כמו זה:
default example-grpc-client-7c969bb997-9fzjv 1/1 Running 0 105s
פותחים מעטפת ל-Pod של הלקוח:
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
אחרי שנכנסים למעטפת, מורידים את gRPC C++ ויוצרים את אפליקציית הלקוח של
xds-hello-world.apt-get update -y && \ apt-get install -y \ build-essential \ clang \ python3 \ python3-devcurl -L https://github.com/grpc/grpc/archive/master.tar.gz | tar -xz
cd grpc-master
tools/bazel build examples/cpp/helloworld:xds_greeter_client
מריצים את הלקוח עם הדגל
--xds-credsכדי לציין אבטחה שמופעלת באמצעות xDS, שם הלקוח ומחרוזת החיבור של היעד:bazel-bin/examples/cpp/helloworld/xds_greeter_client --target=xds:///helloworld-gke:8000
כדי להריץ את הלקוח בלי פרטי כניסה, משתמשים בקוד הבא:
bazel-bin/examples/cpp/helloworld/xds_greeter_client --target=xds:///helloworld-gke:8000 --nosecure
הפלט אמור להיראות כך:
Greeter received: Hello world
Python
משיגים את השם של Pod הלקוח:
kubectl get pods | grep example-grpc-client
אתם רואים משוב כמו זה:
default example-grpc-client-7c969bb997-9fzjv 1/1 Running 0 105s
פותחים מעטפת ל-Pod של הלקוח:
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
אחרי שנכנסים למעטפת, מורידים את גרסה 1.41.0 של gRPC Python ויוצרים את אפליקציית הלקוח לדוגמה.
apt-get update -y apt-get install -y python3 python3-pip python3 -m pip install virtualenv curl -L https://github.com/grpc/grpc/archive/v1.41.x.tar.gz | tar -xz cd grpc-1.41.x/examples/python/xds/ python3 -m virtualenv venv source venv/bin/activate python3 -m pip install -r requirements.txt
מריצים את הלקוח עם הדגל
--xds-credsכדי לציין אבטחה שמופעלת באמצעות xDS, שם הלקוח ומחרוזת החיבור של היעד:python3 client.py xds:///helloworld-gke:8000 --xds-creds
הפלט אמור להיראות כך:
Greeter client received: Hello you from example-host!
המשך
משיגים את השם של Pod הלקוח:
kubectl get pods | grep example-grpc-client
אתם רואים משוב כמו זה:
default example-grpc-client-7c969bb997-9fzjv 1/1 Running 0 105s
פותחים מעטפת ל-Pod של הלקוח:
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/sh
אחרי שנכנסים למעטפת, מורידים את gRPC Go בגרסה 1.42.0 ועוברים לספרייה שמכילה את אפליקציית הלקוח של
xds-hello-world.apk add curl curl -L https://github.com/grpc/grpc-go/archive/v1.42.0.tar.gz | tar -xz cd grpc-go-1.42.0/examples/features/xds/client
מפתחים ומריצים את הלקוח עם הדגל
--xds_credsכדי לציין אבטחה עם xDS, שם הלקוח ומחרוזת החיבור של היעד:GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY="info" \ go run main.go \ -xds_creds \ -name xds-client \ -target xds:///helloworld-gke:8000
הפלט אמור להיראות כך:
Greeting: Hello xds-client, from example-grpc-server-77548868d-l9hmf
הגדרת גישה ברמת השירות באמצעות מדיניות הרשאה
כדי לתמוך במדיניות ההרשאות, נדרשת תמיכה ב-gRFC A41. גרסאות השפה הנדרשות מפורטות ב-GitHub.
כדי להגדיר גישה ברמת השירות באמצעות כללי מדיניות הרשאה, צריך לפעול לפי ההוראות הבאות. לפני שיוצרים כללי מדיניות הרשאה, חשוב לקרוא את האזהרה במאמר הגבלת הגישה באמצעות הרשאה.
כדי שיהיה קל יותר לאמת את ההגדרה, יוצרים שם מארח נוסף שהלקוח יכול להשתמש בו כדי להפנות לשירות helloworld-gke.
gcloud compute url-maps add-host-rule grpc-gke-url-map \ --path-matcher-name grpc-gke-path-matcher \ --hosts helloworld-gke-noaccess:8000
בהוראות הבאות מוסבר איך ליצור מדיניות הרשאה שמאפשרת בקשות שנשלחות על ידי החשבון example-grpc-client שבו שם המארח הוא helloworld-gke:8000 והיציאה היא 50051.
gcloud
יוצרים מדיניות הרשאה באמצעות יצירת קובץ בשם
helloworld-gke-authz-policy.yaml.action: ALLOW name: helloworld-gke-authz-policy rules: - sources: - principals: - spiffe://PROJECT_ID.svc.id.goog/ns/default/sa/example-grpc-client destinations: - hosts: - helloworld-gke:8000 ports: - 50051מייבאים את המדיניות.
gcloud network-security authorization-policies import \ helloworld-gke-authz-policy \ --source=helloworld-gke-authz-policy.yaml \ --location=global
מעדכנים את מדיניות נקודת הקצה כך שתפנה למדיניות ההרשאה החדשה, על ידי הוספת הטקסט הבא לקובץ
ep-mtls-psms.yaml.authorizationPolicy: projects/${PROJECT_ID}/locations/global/authorizationPolicies/helloworld-gke-authz-policyעכשיו מדיניות נקודת הקצה מציינת שצריך לאכוף גם את mTLS וגם את מדיניות ההרשאה על בקשות נכנסות לפודים שקובצי ה-bootstrap של gRPC שלהם מכילים את התווית
app:helloworld.מייבאים את המדיניות:
gcloud network-services endpoint-policies import ep-mtls-psms \ --source=ep-mtls-psms.yaml --location=global
אימות מדיניות ההרשאות
כדי לוודא שמדיניות ההרשאות פועלת כמו שצריך, בצעו את ההוראות הבאות.
Java
פותחים מעטפת לפוד הלקוח שבו השתמשתם קודם.
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
במעטפת הפקודות, מריצים את הפקודות הבאות כדי לאמת את ההגדרה.
cd grpc-java-1.42.1/examples/example-xds ./build/install/example-xds/bin/xds-hello-world-client --xds-creds xds-client \ xds:///helloworld-gke:8000הפלט אמור להיראות כך:
Greeting: Hello xds-client, from xds-server
מריצים שוב את הלקוח עם שם השרת החלופי. שימו לב שזה מקרה של כישלון. הבקשה לא תקינה כי מדיניות ההרשאה מאפשרת גישה רק לשם המארח
helloworld-gke:8000../build/install/example-xds/bin/xds-hello-world-client --xds-creds xds-client \ xds:///helloworld-gke-noaccess:8000הפלט אמור להיראות כך:
WARNING: RPC failed: Status{code=PERMISSION_DENIED}אם הפלט הזה לא מופיע, יכול להיות שמדיניות ההרשאה עדיין לא בשימוש. חכו כמה דקות ונסו שוב את כל תהליך האימות.
המשך
פותחים מעטפת לפוד הלקוח שבו השתמשתם קודם.
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
במעטפת הפקודות, מריצים את הפקודות הבאות כדי לאמת את ההגדרה.
cd grpc-go-1.42.0/examples/features/xds/client GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY="info" \ go run main.go \ -xds_creds \ -name xds-client \ -target xds:///helloworld-gke:8000
הפלט אמור להיראות כך:
Greeting: Hello xds-client, from example-grpc-server-77548868d-l9hmf
מריצים שוב את הלקוח עם שם השרת החלופי. שימו לב שזה מקרה של כישלון. הבקשה לא תקינה כי מדיניות ההרשאה מאפשרת גישה רק לשם המארח
helloworld-gke:8000.GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY="info" \ go run main.go \ -xds_creds \ -name xds-client \ -target xds:///helloworld-gke-noaccess:8000
הפלט אמור להיראות כך:
could not greet: rpc error: code = PermissionDenied desc = Incoming RPC is not allowed: rpc error: code = PermissionDenied desc = incoming RPC did not match an allow policy exit status 1
אם הפלט הזה לא מופיע, יכול להיות שמדיניות ההרשאה עדיין לא בשימוש. חכו כמה דקות ונסו שוב את כל תהליך האימות.
שימוש ב-TLS במקום ב-mTLS
כדי להשתמש ב-TLS בדוגמה הזו, צריך לבצע רק שינוי קטן.
ב
ServerTlsPolicy, מוחקים אתmtlsPolicy:cat << EOF > server-tls-policy.yaml name: "server-tls-policy" serverCertificate: certificateProviderInstance: pluginInstance: google_cloud_private_spiffe EOFבמקומה, צריך להשתמש במדיניות הזו ב-
EndpointPolicy:cat << EOF > ep-tls-psms.yaml name: "ep-mtls-psms" type: "GRPC_SERVER" serverTlsPolicy: "projects/${PROJECT_ID}/locations/global/serverTlsPolicies/server-tls-policy" trafficPortSelector: ports: - "50051" endpointMatcher: metadataLabelMatcher: metadataLabelMatchCriteria: "MATCH_ALL" metadataLabels: [] EOFה-
ClientTlsPolicyל-mTLS פועל גם במקרה של TLS, אבל אפשר להשמיט את הקטעclientCertificateשל המדיניות כי הוא לא נדרש ל-TLS:cat << EOF > client-tls-policy.yaml name: "client-tls-policy" serverValidationCa: - certificateProviderInstance: pluginInstance: google_cloud_private_spiffe EOF
שימוש באבטחת שירות באמצעות הדוגמה של Wallet
בקטע הזה מוסבר באופן כללי איך להפעיל את הדוגמה של Wallet עם אבטחת שירות ב-Java, ב-C++ וב-Go.
Java
קוד המקור לדוגמה ל-Java זמין ב-GitHub.
הקוד כבר משתמש בפרטי הכניסה של XdsChannel ו-XdsServer כשמגדירים אבטחה בלי שרת proxy.
ההוראות האלה מתארות את הגדרת הדוגמה של Wallet באמצעות Go. התהליך דומה ב-Java. בהוראות נעשה שימוש בקובץ אימג' קיים של Docker, שאותו אתם מקבלים מGoogle Cloud מאגר הקונטיינרים.
כדי ליצור את הדוגמה, פועלים לפי ההוראות הבאות:
- משכפלים את המאגר ומקבלים את הקבצים בספרייה gRPC examples.
- עורכים את הקובץ
00-common-env.sh. מסמנים כהערה את השורה הקיימת שמגדירה את הערך שלWALLET_DOCKER_IMAGEלקובץ האימג' של Go Docker, ומבטלים את הסימון כהערה של השורה שמגדירה את הערך שלWALLET_DOCKER_IMAGEלקובץ האימג' של Java Docker. - יוצרים ומגדירים מכונות של Cloud Router לפי ההוראות במאמר יצירה והגדרה של מכונות Cloud Router, או באמצעות הפונקציה
create_cloud_router_instancesבסקריפט10.apis.sh. - יוצרים אשכול לפי ההוראות בדוגמה של
hello worldאו לפי הפונקציהcreate_clusterבסקריפט20-cluster.sh. - יוצרים רשויות אישורים פרטיות באמצעות ההוראות לשירות CA או באמצעות הסקריפט
30-private-ca-setup.sh. - יוצרים משאבים ב-Kubernetes, כולל חשבונות שירות, מרחבי שמות, שירותי Kubernetes, קבוצות NEG ופריסה בצד השרת לכל השירותים:
account,stats,stats_premium,wallet_v1,wallet_v2, באמצעות הסקריפט40-k8s-resources.sh. - לכל אחד מהשירותים שיצרתם, יוצרים בדיקת תקינות ושירות לקצה העורפי באמצעות
create_health_checkו-create_backend_serviceבסקריפט50-td-components.sh. - יוצרים את רכיבי הניתוב של Cloud Service Mesh באמצעות
create_routing_componentsבסקריפט60-routing-components.sh. - יוצרים את רכיבי האבטחה של Cloud Service Mesh לכל שירות לקצה העורפי באמצעות
create_security_componentsבסקריפט70-security-components.sh. - יוצרים את פריסת הלקוח של Wallet באמצעות
create_client_deploymentבסקריפט75-client-deployment.sh. - כדי לאמת את ההגדרה, מפעילים את הלקוח כמו שמתואר בקטע אימות באמצעות לקוחות grpc-wallet.
C++
קוד המקור לדוגמה ל-C++ זמין ב-GitHub. הקוד כבר משתמש בפרטי הכניסה של XdsChannel ו-XdsServer כשמגדירים אבטחה בלי שרת Proxy.
ההוראות האלה מתארות את הגדרת הדוגמה של Wallet באמצעות Go. התהליך דומה ל-C++. ההוראות משתמשות בקובץ אימג' קיים של Docker שאתם מקבלים מGoogle Cloud מאגר הקונטיינרים.
כדי ליצור את הדוגמה, פועלים לפי ההוראות הבאות:
- משכפלים את המאגר ומקבלים את הקבצים בספרייה gRPC examples.
- עורכים את הקובץ
00-common-env.sh. מסמנים כהערה את השורה הקיימת שמגדירה את הערך שלWALLET_DOCKER_IMAGEלקובץ האימג' של Docker ב-Go, ומבטלים את הסימון כהערה של השורה שמגדירה את הערך שלWALLET_DOCKER_IMAGEלקובץ האימג' של Docker ב-C++. - יוצרים ומגדירים מכונות של Cloud Router לפי ההוראות במאמר יצירה והגדרה של מכונות Cloud Router, או באמצעות הפונקציה
create_cloud_router_instancesבסקריפט10.apis.sh. - יוצרים אשכול לפי ההוראות בדוגמה של
hello worldאו לפי הפונקציהcreate_clusterבסקריפט20-cluster.sh. - יוצרים רשויות אישורים פרטיות באמצעות ההוראות לשירות CA או באמצעות הסקריפט
30-private-ca-setup.sh. - יוצרים משאבים ב-Kubernetes, כולל חשבונות שירות, מרחבי שמות, שירותי Kubernetes, קבוצות NEG ופריסה בצד השרת לכל השירותים:
account,stats,stats_premium,wallet_v1,wallet_v2, באמצעות הסקריפט40-k8s-resources.sh. - לכל אחד מהשירותים שיצרתם, יוצרים בדיקת תקינות ושירות לקצה העורפי באמצעות
create_health_checkו-create_backend_serviceבסקריפט50-td-components.sh. - יוצרים את רכיבי הניתוב של Cloud Service Mesh באמצעות
create_routing_componentsבסקריפט60-routing-components.sh. - יוצרים את רכיבי האבטחה של Cloud Service Mesh לכל שירות לקצה העורפי באמצעות
create_security_componentsבסקריפט70-security-components.sh. - יוצרים את פריסת הלקוח של Wallet באמצעות
create_client_deploymentבסקריפט75-client-deployment.sh. - כדי לאמת את ההגדרה, מפעילים את הלקוח כמו שמתואר בקטע אימות באמצעות לקוחות grpc-wallet.
המשך
ב-GitHub יש קוד מקור לדוגמה ב-Go. הקוד כבר משתמש בפרטי הכניסה של XdsChannel ו-XdsServer כשמגדירים אבטחה בלי שרת proxy.
בהוראות נעשה שימוש ב-Google Cloud קובץ אימג' של Docker קיים, שאפשר לקבל ממאגר הקונטיינרים.
כדי ליצור את הדוגמה, פועלים לפי ההוראות הבאות:
- משכפלים את המאגר ומקבלים את הקבצים בספרייה gRPC examples.
- עורכים את הקובץ
00-common-env.shכדי להגדיר את הערכים הנכונים למשתני הסביבה. - יוצרים ומגדירים מכונות של Cloud Router לפי ההוראות במאמר יצירה והגדרה של מכונות Cloud Router, או באמצעות הפונקציה
create_cloud_router_instancesבסקריפט10.apis.sh. - יוצרים אשכול לפי ההוראות בדוגמה של
hello worldאו לפי הפונקציהcreate_clusterבסקריפט20-cluster.sh. - יוצרים רשויות אישורים פרטיות באמצעות ההוראות לשירות CA או באמצעות הסקריפט
30-private-ca-setup.sh. - יוצרים משאבים ב-Kubernetes, כולל חשבונות שירות, מרחבי שמות, שירותי Kubernetes, קבוצות NEG ופריסה בצד השרת לכל השירותים:
account,stats,stats_premium,wallet_v1,wallet_v2, באמצעות הסקריפט40-k8s-resources.sh. - לכל אחד מהשירותים שיצרתם, יוצרים בדיקת תקינות ושירות לקצה העורפי באמצעות
create_health_checkו-create_backend_serviceבסקריפט50-td-components.sh. - יוצרים את רכיבי הניתוב של Cloud Service Mesh באמצעות
create_routing_componentsבסקריפט60-routing-components.sh. - יוצרים את רכיבי האבטחה של Cloud Service Mesh לכל שירות לקצה העורפי באמצעות
create_security_componentsבסקריפט70-security-components.sh. - יוצרים את פריסת הלקוח של Wallet באמצעות
create_client_deploymentבסקריפט75-client-deployment.sh. - כדי לאמת את ההגדרה, מפעילים את הלקוח כמו שמתואר בקטע אימות באמצעות לקוחות grpc-wallet.
קובץ אתחול
תהליך ההגדרה במדריך הזה משתמש במחולל של קובץ האתחול כדי ליצור את קובץ האתחול הנדרש. בקטע הזה מפורט מידע על קובץ ה-bootstrap עצמו.
קובץ ה-bootstrap מכיל את פרטי ההגדרה שנדרשים לקוד gRPC בלי שרת proxy, כולל פרטי החיבור לשרת ה-xDS. קובץ ה-bootstrap מכיל הגדרות אבטחה שנדרשות לתכונת האבטחה של gRPC בלי שרת proxy. שרת ה-gRPC דורש שדה אחד נוסף, כפי שמתואר בקטעים הבאים. קובץ אתחול לדוגמה נראה כך:
{
"xds_servers": [
{
"server_uri": "trafficdirector.googleapis.com:443",
"channel_creds": [
{
"type": "google_default"
}
],
"server_features": [
"xds_v3"
]
}
],
"node": {
"cluster": "cluster",
"id": "projects/9876012345/networks/default/nodes/client1",
"metadata": {
"TRAFFICDIRECTOR_GCP_PROJECT_NUMBER": "9876012345",
"TRAFFICDIRECTOR_NETWORK_NAME": "default",
"INSTANCE_IP": "10.0.0.3"
},
"locality": {
"zone": "us-central1-a"
}
},
"server_listener_resource_name_template": "grpc/server?xds.resource.listening_address=%s",
"certificate_providers": {
"google_cloud_private_spiffe": {
"plugin_name": "file_watcher",
"config": {
"certificate_file": "/var/run/secrets/workload-spiffe-credentials/certificates.pem",
"private_key_file": "/var/run/secrets/workload-spiffe-credentials/private_key.pem",
"ca_certificate_file": "/var/run/secrets/workload-spiffe-credentials/ca_certificates.pem",
"refresh_interval": "600s"
}
}
}
}
עדכונים לקובץ ה-bootstrap של שירות האבטחה
השדות הבאים משקפים שינויים שקשורים לאבטחה ולשימוש ב-xDS v3:
השדה id בתוך node מספק זהות ייחודית ללקוח ה-gRPC ב-Cloud Service Mesh. צריך לציין את מספר הפרויקט ואת שם הרשת באמצעות מזהה הצומת, בפורמט הבא: Google Cloud
projects/{project number}/networks/{network name}/nodes/[UNIQUE_ID]
דוגמה לפרויקט מספר 1234 ולרשת ברירת המחדל:
projects/1234/networks/default/nodes/client1
השדה INSTANCE_IP הוא כתובת ה-IP של ה-Pod, או 0.0.0.0 כדי לציין INADDR_ANY. השדה הזה משמש את שרת ה-gRPC לאחזור משאב ה-Listener מ-Cloud Service Mesh לאבטחה בצד השרת.
שדות של הגדרות אבטחה בקובץ ה-bootstrap
| מפתח JSON | סוג | ערך | הערות |
|---|---|---|---|
server_listener_resource_name_template |
String | grpc/server?xds.resource.listening_address=%s |
נדרש לשרתי gRPC. הערך הזה משמש את gRPC כדי ליצור את שם המשאב לאחזור המשאב Listener מ-Cloud Service Mesh לאבטחה בצד השרת ולהגדרות אחרות. הערך הזה משמש את gRPC כדי ליצור את מחרוזת שם המשאב. |
certificate_providers |
מבנה JSON | google_cloud_private_spiffe |
חובה. הערך הוא מבנה JSON שמייצג מפה של שמות למופעים של ספקי אישורים. מופע של ספק אישורים משמש לאחזור אישורי זהות ואישורי בסיס. קובץ ה-bootstrap לדוגמה מכיל שם אחד: google_cloud_private_spiffe, עם מבנה ה-JSON של המכונה של ספק האישורים כערך. לכל מבנה JSON של מופע של ספק אישורים יש שני שדות:
|
התוכן של מבנה ה-JSON של config לפלאגין file_watcher הוא:
-
certificate_file: מחרוזת חובה. הערך הזה הוא המיקום של אישור הזהות. -
private_key_file: מחרוזת חובה. הערך הוא המיקום של קובץ המפתח הפרטי, שצריך להתאים לאישור הזהות. -
ca_certificate_file: מחרוזת חובה. הערך הוא המיקום של אישור הבסיס, שנקרא גם חבילת האמון. -
refresh_interval: מחרוזת אופציונלית. הערך מציין את מרווח הזמן לרענון, שמוגדר באמצעות ייצוג המחרוזת של מיפוי JSON של משך זמן. ערך ברירת המחדל הוא "600s", משך זמן של 10 דקות.
מחולל Bootstrap
קובץ האימג' של קונטיינר מחולל האתחול זמין בכתובת gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0. קוד המקור שלו זמין בכתובת https://github.com/GoogleCloudPlatform/traffic-director-grpc-bootstrap.
אלה האפשרויות הנפוצות ביותר של שורת הפקודה:
-
--output: משתמשים באפשרות הזו כדי לציין לאן קובץ ה-bootstrap של הפלט נכתב. לדוגמה, הפקודה--output /tmp/bootstrap/td-grpc-bootstrap.jsonיוצרת את קובץ ה-bootstrap ב-/tmp/bootstrap/td-grpc-bootstrap.jsonבמערכת הקבצים של ה-Pod. -
--node-metadata: משתמשים בדגל הזה כדי לאכלס את המטא-נתונים של הצומת בקובץ ה-bootstrap. השדה הזה נדרש כשמשתמשים בהתאמות של תוויות מטא-נתונים ב-EndpointPolicy, שבה Cloud Service Mesh משתמש בנתוני התוויות שסופקו בקטע של המטא-נתונים של הצומת בקובץ ה-bootstrap. הארגומנט מסופק בפורמט key=value, לדוגמה:--node-metadata version=prod --node-metadata type=grpc
האפשרויות האלה מוסיפות את הפרטים הבאים לקטע המטא-נתונים של הצומת בקובץ ה-bootstrap:
{
"node": {
...
"metadata": {
"version": "prod",
"type": "grpc",
...
},
...
},
...
}
מחיקת הפריסה
אפשר להריץ את הפקודות הבאות כדי למחוק את הפריסה שיצרתם באמצעות המדריך הזה.
כדי למחוק את האשכול, מריצים את הפקודה הבאה:
gcloud container clusters delete CLUSTER_NAME --zone ZONE --quiet
כדי למחוק את המשאבים שיצרתם, מריצים את הפקודות הבאות:
gcloud compute backend-services delete grpc-gke-helloworld-service --global --quiet
cloud compute network-endpoint-groups delete example-grpc-server --zone ZONE --quiet
gcloud compute firewall-rules delete grpc-gke-allow-health-checks --quiet
gcloud compute health-checks delete grpc-gke-helloworld-hc --quiet
gcloud network-services endpoint-policies delete ep-mtls-psms \
--location=global --quiet
gcloud network-security authorization-policies delete helloworld-gke-authz-policy \
--location=global --quiet
gcloud network-security client-tls-policies delete client-mtls-policy \
--location=global --quiet
gcloud network-security server-tls-policies delete server-tls-policy \
--location=global --quiet
gcloud network-security server-tls-policies delete server-mtls-policy \
--location=global --quiet
פתרון בעיות
ההוראות האלה יעזרו לכם לפתור בעיות בפריסת האבטחה.
עומסי העבודה לא יכולים לקבל הגדרות מ-Cloud Service Mesh
אם מופיעה שגיאה בסגנון הזה:
PERMISSION_DENIED: Request had insufficient authentication scopes.
חשוב לוודא את הדברים הבאים:
- יצרתם את אשכול GKE עם הארגומנט
--scopes=cloud-platform. - הקציתם את
roles/trafficdirector.clientלחשבונות השירות של Kubernetes. - הקציתם את התפקיד
roles/trafficdirector.clientלחשבון השירות שמוגדר כברירת מחדל ( Google Cloud ) (${GSA_EMAIL} למעלה). - הפעלתם את השירות (API) של
trafficdirector.googleapis.com.
שרת ה-gRPC לא משתמש ב-TLS או ב-mTLS, גם אם ההגדרה של Cloud Service Mesh נכונה
חשוב לציין את GRPC_SERVER בהגדרות של מדיניות נקודות הקצה. אם ציינתם את SIDECAR_PROXY, המערכת מתעלמת מההגדרה של gRPC.
לא הצלחתם ליצור את אשכול GKE עם גרסת האשכול שביקשתם
יכול להיות שהפקודה ליצירת אשכול GKE תיכשל ותופיע שגיאה כמו זו:
Node version "1.20.5-gke.2000" is unsupported.
מוודאים שמשתמשים בארגומנט --release-channel rapid בפקודה ליצירת האשכול. כדי לקבל את הגרסה הנכונה של המהדורה הזו, צריך להשתמש בערוץ ההפצה המהירה.
מוצגת שגיאה מסוג No usable endpoint
אם לקוח לא יכול לתקשר עם השרת בגלל שגיאת No usable endpoint, יכול להיות שהכלי לבדיקת תקינות סימן את ה-backend של השרת כלא תקין.
כדי לבדוק את התקינות של הקצוות העורפיים, מריצים את הפקודה הבאה של gcloud:
gcloud compute backend-services get-health grpc-gke-helloworld-service --global
אם הפקודה מחזירה את הסטטוס unhealthy של הקצה העורפי, יכול להיות שזה בגלל אחת מהסיבות הבאות:
- חומת האש לא נוצרה או שהיא לא מכילה את טווח כתובות ה-IP הנכון של המקור.
- תגי היעד בחומת האש לא תואמים לתגים באשכול שיצרתם.
עומסי העבודה לא יכולים לתקשר בהגדרת האבטחה
אם עומסי העבודה לא יכולים לתקשר אחרי שהגדרתם אבטחה לרשת השירות ללא שרת proxy, בצעו את ההוראות הבאות כדי לזהות את הסיבה.
- להשבית את האבטחה בלי שרת proxy ולפתור בעיות בתרחישים לדוגמה של איזון עומסים ברשת שירות בלי שרת proxy. כדי להשבית את האבטחה ברשת, מבצעים אחת מהפעולות הבאות:
- שימוש בפרטי כניסה בטקסט פשוט בצד הלקוח ובצד השרת, או
- אל תגדירו אבטחה לשירות לקצה העורפי ולמדיניות נקודות הקצה בהגדרות של Cloud Service Mesh.
פועלים לפי השלבים במאמר פתרון בעיות בפריסות של Cloud Service Mesh בלי שרת proxy, כי אין הגדרת אבטחה בפריסה.
משנים את עומסי העבודה כך שישתמשו בפרטי כניסה של xDS עם טקסט פשוט או פרטי כניסה לא מאובטחים כפרטי הכניסה החלופיים. משאירים את הגדרת Cloud Service Mesh עם אבטחה מושבתת, כמו שמתואר למעלה. במקרה כזה, למרות ש-gRPC מאפשר ל-Cloud Service Mesh להגדיר אבטחה, Cloud Service Mesh לא שולח מידע אבטחה. במקרה כזה, gRPC צריך לחזור לפרטי כניסה בטקסט פשוט (או לא מאובטחים), שאמורים לפעול באופן דומה למקרה הראשון שתואר קודם. אם זה לא עובד, צריך לבצע את הפעולות הבאות:
- מגדילים את רמת הרישום ביומן גם בצד הלקוח וגם בצד השרת, כדי שתוכלו לראות את הודעות ה-xDS שמועברות בין gRPC לבין Cloud Service Mesh.
- מוודאים שהאבטחה לא מופעלת ב-Cloud Service Mesh בתגובות של CDS ו-LDS שנשלחות לעומסי העבודה.
- מוודאים שעומסי העבודה לא משתמשים במצבי TLS או mTLS בערוצים שלהם. אם מופיעות הודעות ביומן שקשורות ללחיצות יד בפרוטוקול TLS, צריך לבדוק את קוד המקור של האפליקציה ולוודא שאתם משתמשים בטקסט פשוט או לא מאובטח בתור פרטי הכניסה החלופיים. אם קוד המקור של האפליקציה תקין, יכול להיות שיש באג בספריית gRPC.
כדי לוודא שהשילוב של שירות CA עם GKE פועל בצורה תקינה באשכול GKE, פועלים לפי השלבים לפתרון בעיות במדריך למשתמש. חשוב לוודא שהאישורים והמפתחות שסופקו על ידי התכונה הזו זמינים בספרייה שצוינה,
/var/run/secrets/workload-spiffe-credentials/.מפעילים TLS (במקום mTLS) ברשת, כמו שמתואר למעלה, ומפעילים מחדש את עומסי העבודה של הלקוח והשרת.
- כדי לראות את הודעות ה-xDS שמועברות בין gRPC לבין Cloud Service Mesh, מגדילים את רמת הרישום ביומן גם בצד הלקוח וגם בצד השרת.
- מוודאים ש-Cloud Service Mesh הפעיל את האבטחה בתגובות של CDS ו-LDS שנשלחות לעומסי העבודה.
הלקוח נכשל עם CertificateException וההודעה Peer certificate SAN check failed
המשמעות היא שיש בעיה בערכי subjectAltNames בהודעה SecuritySettings. שימו לב שהערכים האלה מבוססים על שירותי Kubernetes שיצרתם בשביל שירות הקצה העורפי. לכל שירות Kubernetes שאתם יוצרים יש מזהה SPIFFE משויך בפורמט הבא:
spiffe://${WORKLOAD_POOL}/ns/${K8S_NAMESPACE}/sa/${SERVICE_ACCOUNT}
הערכים האלה הם:
-
WORKLOAD_POOL: מאגר עומסי העבודה של האשכול, שהוא${PROJECT_ID}.svc.id.goog -
K8S_NAMESPACE: מרחב השמות של Kubernetes שבו השתמשתם בפריסת השירות -
SERVICE_ACCOUNT: חשבון השירות של Kubernetes שבו השתמשתם בפריסת השירות
לכל שירות Kubernetes שצירפתם לשירות לקצה העורפי כקבוצת נקודות קצה (NEG), ודאו שחישבתם נכון את מזהה ה-SPIFFE והוספתם אותו לשדה subjectAltNames בהודעה SecuritySettings.
האפליקציות לא יכולות להשתמש באישורי mTLS עם ספריית ה-gRPC שלכם
אם האפליקציות לא יכולות להשתמש באישורי mTLS עם ספריית gRPC, צריך לבצע את הפעולות הבאות:
מוודאים שמפרט ה-Pod מכיל את ההערה
security.cloud.google.com/use-workload-certificatesשמתוארת במאמר יצירת שירות gRPC בלי שרת Proxy באמצעות קבוצות של נקודות קצה ברשת (NEG).מוודאים שאפשר לגשת לקבצים שמכילים את שרשרת האישורים, יחד עם אישור הקצה, המפתח הפרטי ואישורי ה-CA המהימנים, בנתיבים הבאים מתוך ה-Pod:
- שרשרת אישורים יחד עם אישור קצה: "/var/run/secrets/workload-spiffe-credentials/certificates.pem"
- מפתח פרטי: "/var/run/secrets/workload-spiffe-credentials/private_key.pem"
- חבילת CA: "/var/run/secrets/workload-spiffe-credentials/ca_certificates.pem"
אם האישורים מהשלב הקודם לא זמינים, מבצעים את הפעולות הבאות:
gcloud privateca subordinates describe SUBORDINATE_CA_POOL_NAME
--location=LOCATIONמוודאים שלמישור הבקרה של GKE יש את הקישור הנכון לתפקיד ב-IAM, שנותן לו גישה לשירות CA:
# Get the IAM policy for the CA gcloud privateca roots get-iam-policy ROOT_CA_POOL_NAME # Verify that there is an IAM binding granting access in the following format - members: - serviceAccount:service-projnumber@container-engine-robot.iam.gserviceaccount.com role: roles/privateca.certificateManager # Where projnumber is the project number (e.g. 2915810291) for the GKE cluster.
מוודאים שהתוקף של האישור לא פג. זו שרשרת האישורים ואישור הקצה בכתובת
/var/run/secrets/workload-spiffe-credentials/certificates.pem. כדי לבדוק, מריצים את הפקודה הבאה:cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"
כדי לוודא שהאפליקציה תומכת בסוג המפתח, מריצים את הפקודה הבאה:
cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Public Key Algorithm" -A 3
מוודאים שאפליקציית gRPC Java כוללת את ה-
keyAlgorithmהבא בקובץ ה-YAML שלWorkloadCertificateConfig:
keyAlgorithm: rsa: modulusSize: 4096מוודאים שרשות האישורים משתמשת באותה משפחת מפתחות כמו מפתח האישור.
אישור של אפליקציה נדחה על ידי הלקוח, השרת או נקודת הקצה (peer)
- מוודאים שבאפליקציית המשתמש האחר נעשה שימוש באותה חבילת אמון כדי לאמת את האישור.
- מוודאים שהתוקף של האישור שבו משתמשים לא פג (שרשרת האישורים יחד עם אישור העלה: "/var/run/secrets/workload-spiffe-credentials/certificates.pem").
ה-Pods נשארים במצב המתנה
אם ה-Pods נשארים במצב המתנה במהלך תהליך ההגדרה, צריך להגדיל את משאבי המעבד (CPU) והזיכרון של ה-Pods במפרט הפריסה.
אי אפשר ליצור אשכול עם הדגל --enable-mesh-certificates
מוודאים שאתם משתמשים בגרסה העדכנית של ה-CLI של gcloud:
gcloud components update
שימו לב שהדגל --enable-mesh-certificates פועל רק עם gcloud beta.
ה-Pods לא מתחילים
אם הקצאת האישורים נכשלת, יכול להיות שפודים שמשתמשים באישורי רשת של GKE לא יתחילו לפעול. זה יכול לקרות במצבים כמו:
- ה-
WorkloadCertificateConfigאו ה-TrustConfigחסרים או שהם מוגדרים באופן שגוי. - בקשות CSR לא מאושרות.
כדי לבדוק אם הקצאת האישורים נכשלה, אפשר לבדוק את האירועים של ה-Pod.
בודקים את הסטטוס של ה-Pod:
kubectl get pod -n POD_NAMESPACE POD_NAMEמחליפים את מה שכתוב בשדות הבאים:
-
POD_NAMESPACE: מרחב השמות של ה-Pod. -
POD_NAME: שם ה-Pod.
-
כדי לבדוק אירועים אחרונים ב-Pod:
kubectl describe pod -n POD_NAMESPACE POD_NAMEאם הקצאת האישור נכשלת, יופיע אירוע עם
Type=Warning,Reason=FailedMount,From=kubeletוהשדהMessageשמתחיל ב-MountVolume.SetUp failed for volume "gke-workload-certificates". השדהMessageמכיל מידע לפתרון בעיות.Events: Type Reason Age From Message ---- ------ ---- ---- ------- Warning FailedMount 13s (x7 over 46s) kubelet MountVolume.SetUp failed for volume "gke-workload-certificates" : rpc error: code = Internal desc = unable to mount volume: store.CreateVolume, err: unable to create volume "csi-4d540ed59ef937fbb41a9bf5380a5a534edb3eedf037fe64be36bab0abf45c9c": caPEM is nil (check active WorkloadCertificateConfig)אם הפודים לא מתחילים לפעול בגלל אובייקטים שהוגדרו באופן שגוי או בגלל בקשות CSR שנדחו, תוכלו להיעזר בשלבים הבאים לפתרון הבעיות.
ההגדרה של WorkloadCertificateConfig או TrustConfig שגויה
מוודאים שיצרתם את האובייקטים WorkloadCertificateConfig ו-TrustConfig בצורה נכונה. אפשר לאבחן הגדרות שגויות בכל אחד מהאובייקטים האלה באמצעות kubectl.
אחזור הסטטוס הנוכחי.
עבור
WorkloadCertificateConfig:kubectl get WorkloadCertificateConfig default -o yamlעבור
TrustConfig:kubectl get TrustConfig default -o yamlבודקים את פלט הסטטוס. אובייקט תקין יכלול תנאי עם
type: Readyו-status: "True".status: conditions: - lastTransitionTime: "2021-03-04T22:24:11Z" message: WorkloadCertificateConfig is ready observedGeneration: 1 reason: ConfigReady status: "True" type: Readyאם האובייקטים לא תקינים, מופיע הסמל
status: "False". השדותreasonו-messageמכילים פרטים נוספים לפתרון בעיות.
בקשות CSR לא מאושרות
אם משהו משתבש במהלך תהליך האישור של ה-CSR, אפשר לבדוק את פרטי השגיאה בתנאים type: Approved ו-type: Issued של ה-CSR.
מציגים את בקשות ה-CSR הרלוונטיות באמצעות
kubectl:kubectl get csr \ --field-selector='spec.signerName=spiffe.gke.io/spiffe-leaf-signer'צריך לבחור CSR שהוא
ApprovedולאIssued, או שהוא לאApproved.מציגים את הפרטים של ה-CSR שנבחר באמצעות kubectl:
kubectl get csr CSR_NAME -o yamlמחליפים את
CSR_NAMEבשם של ה-CSR שבחרתם.
ב-CSR תקין יש תנאי עם type: Approved ו-status: "True", ואישור תקין בשדה status.certificate:
status:
certificate: <base64-encoded data>
conditions:
- lastTransitionTime: "2021-03-04T21:58:46Z"
lastUpdateTime: "2021-03-04T21:58:46Z"
message: Approved CSR because it is a valid SPIFFE SVID for the correct identity.
reason: AutoApproved
status: "True"
type: Approved
מידע לפתרון בעיות של בקשות CSR לא תקינות מופיע בשדות message ו-reason.
חסרים אישורים לפודים
משיגים את מפרט ה-Pod של ה-Pod:
kubectl get pod -n POD_NAMESPACE POD_NAME -o yamlמחליפים את מה שכתוב בשדות הבאים:
-
POD_NAMESPACE: מרחב השמות של ה-Pod. -
POD_NAME: שם ה-Pod.
-
מוודאים שמפרט ה-Pod מכיל את ההערה
security.cloud.google.com/use-workload-certificatesשמתוארת במאמר הגדרת Pods לקבלת פרטי כניסה של mTLS.מוודאים שבקר הגישה של אישורי הרשת ב-GKE החדיר בהצלחה נפח של מנהל התקן CSI מסוג
workloadcertificates.security.cloud.google.comלמפרט ה-Pod:volumes: ... -csi: driver: workloadcertificates.security.cloud.google.com name: gke-workload-certificates ...בודקים אם יש טעינת נפח בכל אחד מהקונטיינרים:
containers: - name: ... ... volumeMounts: - mountPath: /var/run/secrets/workload-spiffe-credentials name: gke-workload-certificates readOnly: true ...מוודאים שחבילות האישורים הבאות והמפתח הפרטי זמינים במיקומים הבאים ב-Pod:
- חבילת שרשרת האישורים:
/var/run/secrets/workload-spiffe-credentials/certificates.pem - מפתח פרטי:
/var/run/secrets/workload-spiffe-credentials/private_key.pem - חבילת ישויות עוגן אמינות של רשות אישורים (CA):
/var/run/secrets/workload-spiffe-credentials/ca_certificates.pem
- חבילת שרשרת האישורים:
אם הקבצים לא זמינים, מבצעים את הפעולות הבאות:
מאחזרים את המכונה של שירות ה-CA (תצוגה מקדימה) בשביל האשכול:
kubectl get workloadcertificateconfigs default -o jsonpath '{.spec.certificateAuthorityConfig.certificateAuthorityServiceConfig.endpointURI}'אחזור הסטטוס של המכונה של שירות CA (גרסת טרום-השקה (Preview)):
gcloud privateca ISSUING_CA_TYPE describe ISSUING_CA_NAME \ --location ISSUING_CA_LOCATIONמחליפים את מה שכתוב בשדות הבאים:
-
ISSUING_CA_TYPE: סוג ה-CA המנפיק, שיכול להיותsubordinatesאוroots. -
ISSUING_CA_NAME: השם של הרשות המנפיקה לאישורים. -
ISSUING_CA_LOCATION: האזור של ה-CA המנפיק.
-
מורידים את מדיניות ה-IAM של ה-CA ברמה הבסיסית (root):
gcloud privateca roots get-iam-policy ROOT_CA_NAMEמחליפים את
ROOT_CA_NAMEבשם של ה-CA ברמה הבסיסית (root).במדיניות IAM, מוודאים שקיים הקישור למדיניות
privateca.auditor:... - members: - serviceAccount:service-PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com role: roles/privateca.auditor ...בדוגמה הזו,
PROJECT_NUMBERהוא מספר הפרויקט של האשכול.מורידים את מדיניות ה-IAM של רשות האישורים המשנית:
gcloud privateca subordinates get-iam-policy SUBORDINATE_CA_NAMEמחליפים את
SUBORDINATE_CA_NAMEבשם של רשות האישורים המשנית.במדיניות IAM, מוודאים שקיים הקישור של המדיניות
privateca.certificateManager:... - members: - serviceAccount: service-PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com role: roles/privateca.certificateManager ...בדוגמה הזו,
PROJECT_NUMBERהוא מספר הפרויקט של האשכול.
אפליקציות לא יכולות להשתמש בפרטי כניסה שהונפקו ל-mTLS
מוודאים שהתוקף של האישור לא פג:
cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"מוודאים שסוג המפתח שבו השתמשתם נתמך באפליקציה.
cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Public Key Algorithm" -A 3מוודאים שהרשות שמנפיקה את האישורים (CA) משתמשת באותה משפחת מפתחות כמו המפתח של האישור.
בודקים את הסטטוס של המכונה של שירות CA (גרסת טרום-השקה (Preview)):
gcloud privateca ISSUING_CA_TYPE describe ISSUING_CA_NAME \ --location ISSUING_CA_LOCATIONמחליפים את מה שכתוב בשדות הבאים:
-
ISSUING_CA_TYPE: סוג ה-CA המנפיק, שיכול להיותsubordinatesאוroots. -
ISSUING_CA_NAME: השם של הרשות המנפיקה לאישורים. -
ISSUING_CA_LOCATION: האזור של ה-CA המנפיק.
-
מוודאים שהערך של
keySpec.algorithmבפלט הוא אותו אלגוריתם מפתח שהגדרתם במניפסט ה-YAML שלWorkloadCertificateConfig. הפלט אמור להיראות כך:config: ... subjectConfig: commonName: td-sub-ca subject: organization: TestOrgLLC subjectAltName: {} createTime: '2021-05-04T05:37:58.329293525Z' issuingOptions: includeCaCertUrl: true keySpec: algorithm: RSA_PKCS1_2048_SHA256 ...
האישורים נדחים
- מוודאים שבאפליקציית המשתמש נעשה שימוש באותה חבילת אמון כדי לאמת את האישור.
מוודאים שהתוקף של האישור לא פג:
cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"אם קוד הלקוח לא משתמש ב-Credentials Reloading API של gRPC Go, צריך לוודא שהוא מרענן מדי פעם את פרטי הכניסה ממערכת הקבצים.
מוודאים שעומסי העבודה נמצאים באותו מתחם אמון (trust domain) כמו ה-CA. אישורי רשת ב-GKE תומכים בתקשורת בין עומסי עבודה במתחם אמון (trust domain) אחד.
מגבלות
אבטחת השירות של Cloud Service Mesh נתמכת רק ב-GKE. אי אפשר לפרוס אבטחת שירות באמצעות Compute Engine.
ב-Cloud Service Mesh אין תמיכה בתרחישים שבהם יש שני משאבים או יותר של מדיניות נקודות קצה שתואמים באותה מידה לנקודת קצה, למשל שתי כללי מדיניות עם אותן תוויות ויציאות, או שני כללי מדיניות או יותר עם תוויות שונות שתואמות באותה מידה לתוויות של נקודת קצה. למידע נוסף על האופן שבו מדיניות נקודות הקצה מותאמת לתוויות של נקודת הקצה, קראו את המאמר ממשקי API ל-EndpointPolicy.EndpointMatcher.MetadataLabelMatcher. במצבים כאלה, Cloud Service Mesh לא יוצר הגדרת אבטחה מאף אחד מכללי המדיניות שמתנגשים.