הגדרת אבטחת שירות באמצעות gRPC בלי שרת proxy (דור קודם)

במדריך הזה מוסבר איך להגדיר שירות אבטחה לרשת שירות gRPC ללא שרת proxy.

המסמך הזה רלוונטי רק ל-Cloud Service Mesh עם ממשקי ה-API לאיזון עומסים. זהו מסמך מדור קודם.

דרישות

לפני שמגדירים את אבטחת השירות לרשת השירותים של gRPC ללא שרת proxy, צריך לוודא שעומדים בדרישות הבאות.

הגדרת ניהול זהויות והרשאות גישה (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:

  1. הגדרת שירות CA, שבו יוצרים מאגרי CA פרטיים ואת רשויות האישורים הנדרשות.
  2. יצירת אשכול GKE עם התכונות "איחוד זהויות של עומסי עבודה ל-GKE" ו"אישורי רשת" ושילוב עם שירות CA.
  3. הגדרת הנפקת אישורים לרשת באשכול.
  4. יצירת חשבונות השירות של הלקוח והשרת.
  5. הגדרת שרת לדוגמה שמשתמש בממשקי API של xDS ובפרטי כניסה לשרת xDS כדי לקבל הגדרות אבטחה מ-Cloud Service Mesh.
  6. הגדרת הלקוח לדוגמה שמשתמש בפרטי הכניסה של xDS.
  7. עדכון ההגדרות של 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 הנדרשים.

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

    יצירת האשכול עשויה להימשך כמה דקות.

  2. אם אתם משתמשים באשכול קיים, הפעילו את איחוד הזהויות של עומסי עבודה ל-GKE ואת אישורי הרשת של GKE. מוודאים שהאשכול נוצר עם הדגל --enable-ip-alias, שאי אפשר להשתמש בו עם הפקודה update.

    gcloud container clusters update CLUSTER_NAME \
      --enable-mesh-certificates
    
  3. מריצים את הפקודה הבאה כדי לעבור לאשכול החדש בתור אשכול ברירת המחדל לפקודות kubectl:

    gcloud container clusters get-credentials CLUSTER_NAME \
      --zone ZONE
    

רישום אשכולות ב-fleet

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

שימו לב: כל אחד מהשלבים האלה יכול להימשך עד עשר דקות.

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

    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
    
  3. משיגים את משאב החברות מהאשכול:

    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
  1. מקצים את 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
    
  2. מקצים את התפקיד 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
    
  3. יוצרים את מאגר השורש של CA Service.

    gcloud privateca pools create ROOT_CA_POOL_NAME \
      --location ROOT_CA_POOL_LOCATION \
      --tier enterprise
    
  4. יוצרים רשות אישורי בסיס.

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

    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
  6. מקצים את התפקיד 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"
    
  7. מקצים את התפקיד 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"
    
  8. שומרים את הגדרת ה-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
  9. שומרים את הגדרת ה-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
  10. מחילים את ההגדרות על האשכול:

    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 של השירות כדי לציין את שם ה-NEG‏ example-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

  1. מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:

    if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
    
  2. יוצרים את המפרט:

    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++‎

  1. מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:

    if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
    
  2. יוצרים את המפרט:

    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

  1. מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:

    if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
    
  2. יוצרים את המפרט:

    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
    

המשך

  1. מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:

    if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
    
  2. יוצרים את המפרט:

    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
    

    כך משלימים את התהליך:

  1. מחילים את המפרט:

    kubectl apply -f example-grpc-server.yaml
    
  2. מקצים לחשבון השירות את התפקידים הנדרשים:

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

    kubectl get deploy/example-grpc-server
    kubectl get svc/example-grpc-server
    
  4. מוודאים ששם ה-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. לכן, מומלץ להשתמש בגישה הראשונה.

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

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

      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
      
  2. יוצרים את חומת האש. חשוב לוודא שהערך של --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
    
  3. יוצרים את השירות לקצה העורפי:

    gcloud compute backend-services create grpc-gke-helloworld-service \
       --global \
       --load-balancing-scheme=INTERNAL_SELF_MANAGED \
       --protocol=GRPC \
       --health-checks grpc-gke-helloworld-hc
    
  4. מצרפים את ה-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.

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

    gcloud compute url-maps create grpc-gke-url-map \
       --default-service grpc-gke-helloworld-service
    
  2. מוסיפים את התאמת הנתיב למפת 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
    
  3. יוצרים את שרת ה-proxy ל-gRPC:

    gcloud compute target-grpc-proxies create grpc-gke-proxy \
       --url-map grpc-gke-url-map --validate-for-proxyless
    
  4. יוצרים את כלל ההעברה:

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

  1. יוצרים קובץ זמני בשם 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
    
  2. יוצרים משאב מדיניות 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
    
  3. יוצרים את מדיניות נקודת הקצה על ידי יצירת הקובץ הזמני 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
    
  4. מייבאים את הקובץ ep-mtls-psms.yaml כדי ליצור את משאב המדיניות של נקודת הקצה:

    gcloud beta network-services endpoint-policies import ep-mtls-psms \
      --source=ep-mtls-psms.yaml --location=global
    

הגדרת mTLS בצד הלקוח

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

  1. יוצרים את תוכן המשאב של מדיניות ה-TLS של הלקוח בקובץ זמני בשם client-mtls-policy.yaml בספרייה הנוכחית:

    name: "client-mtls-policy"
    clientCertificate:
      certificateProviderInstance:
        pluginInstance: google_cloud_private_spiffe
    serverValidationCa:
    - certificateProviderInstance:
        pluginInstance: google_cloud_private_spiffe
    
  2. יוצרים את משאב מדיניות ה-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
    
  3. יוצרים קטע קוד בקובץ זמני כדי להפנות למדיניות הזו, ומוסיפים פרטים של 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
    
  4. מוסיפים את ההודעה 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

  1. מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:

    if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
    
  2. יוצרים את המפרט הבא:

    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++‎

  1. מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:

    if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
    
  2. יוצרים את המפרט הבא:

    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

  1. מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:

    if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
    
  2. יוצרים את המפרט הבא:

    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
    

המשך

  1. מריצים את הפקודה הבאה כדי לוודא שמספר הפרויקט מוגדר נכון:

    if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
    
  2. יוצרים את המפרט הבא:

    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
    

כך משלימים את התהליך:

  1. מחילים את המפרט:

    kubectl apply -f example-grpc-client.yaml
    
  2. מקצים לחשבון השירות את התפקידים הנדרשים:

    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
    
  3. מוודאים שה-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

  1. משיגים את השם של ה-Pod שנוצר בשביל השירות example-grpc-server:

    kubectl get pods | grep example-grpc-server
    

    המשוב שמוצג נראה כך:

    default    example-grpc-server-77548868d-l9hmf     1/1    Running   0     105s
    
  2. פותחים מעטפת ל-Pod של השרת:

    kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash
    
  3. ב-shell, מוודאים שקובץ ה-bootstrap ב-/tmp/grpc-xds/td-grpc-bootstrap.json תואם לסכימה שמתוארת בקטע קובץ Bootstrap.

  4. מורידים את 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
    
  5. מריצים את השרת עם הדגל --xds-creds כדי לציין אבטחה שמותאמת ל-xDS, באמצעות 50051 כיציאת ההאזנה ו-xds-server כשם הזיהוי של השרת:

    ./build/install/example-xds/bin/xds-hello-world-server --xds-creds 50051 xds-server
    
  6. אחרי שהשרת מקבל את ההגדרות הנדרשות מ-Cloud Service Mesh, מופיע הפלט הבא:

    Listening on port 50051
    plain text health service listening on port 50052
    

C++‎

  1. משיגים את השם של ה-Pod שנוצר בשביל השירות example-grpc-server:

    kubectl get pods | grep example-grpc-server
    

    המשוב שמוצג נראה כך:

    default    example-grpc-server-77548868d-l9hmf     1/1    Running   0     105s
    
  2. פותחים מעטפת ל-Pod של השרת:

    kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash
    
  3. ב-shell, מוודאים שקובץ ה-bootstrap ב-/tmp/grpc-xds/td-grpc-bootstrap.json תואם לסכימה שמתוארת בקטע קובץ Bootstrap.

  4. מורידים את 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
    
  5. מריצים את השרת באמצעות 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
    
  6. אחרי שהשרת מקבל את ההגדרות הנדרשות מ-Cloud Service Mesh, מופיע הפלט הבא:

    Listening on port 50051
    plain text health service listening on port 50052
    

Python

  1. משיגים את השם של ה-Pod שנוצר בשביל השירות example-grpc-server:

    kubectl get pods | grep example-grpc-server
    

    המשוב שמוצג נראה כך:

    default    example-grpc-server-77548868d-l9hmf     1/1    Running   0     105s
    
  2. פותחים מעטפת ל-Pod של השרת:

    kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash
    
  3. ב-shell, מוודאים שקובץ ה-bootstrap ב-/tmp/grpc-xds/td-grpc-bootstrap.json תואם לסכימה שמתוארת בקטע קובץ Bootstrap.

  4. מורידים את גרסה 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
    

  5. מריצים את השרת עם הדגל --xds-creds כדי לציין אבטחה שמותאמת ל-xDS, ומשתמשים ב-50051 כיציאת ההאזנה.

    python3 server.py 50051 --xds-creds
    
  6. אחרי שהשרת מקבל את ההגדרות הנדרשות מ-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
    

המשך

  1. משיגים את השם של ה-Pod שנוצר בשביל השירות example-grpc-server:

    kubectl get pods | grep example-grpc-server
    

    המשוב שמוצג נראה כך:

    default    example-grpc-server-77548868d-l9hmf     1/1    Running   0     105s
    
  2. פותחים מעטפת ל-Pod של השרת:

    kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/sh
    
  3. ב-shell, מוודאים שקובץ ה-bootstrap ב-/tmp/grpc-xds/td-grpc-bootstrap.json תואם לסכימה שמתוארת בקטע קובץ Bootstrap.

  4. מורידים את גרסה 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
    
    
  5. מריצים את השרת עם הדגל --xds_creds כדי לציין אבטחה שמותאמת ל-xDS, ומשתמשים ב-50051 כיציאת ההאזנה:

    GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY="info" \
      go run main.go \
      -xds_creds \
      -port 50051
    
  6. אחרי שהשרת מקבל את ההגדרות הנדרשות מ-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

  1. משיגים את השם של Pod הלקוח:

    kubectl get pods | grep example-grpc-client
    

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

    default    example-grpc-client-7c969bb997-9fzjv     1/1    Running   0     105s
    
  2. פותחים מעטפת ל-Pod של הלקוח:

    kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
    
  3. במעטפת הפקודות, מורידים את גרסה 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
    
  4. מריצים את הלקוח עם הדגל --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++‎

  1. משיגים את השם של Pod הלקוח:

    kubectl get pods | grep example-grpc-client
    

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

    default    example-grpc-client-7c969bb997-9fzjv     1/1    Running   0     105s
    
  2. פותחים מעטפת ל-Pod של הלקוח:

    kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
    
  3. אחרי שנכנסים למעטפת, מורידים את 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_client
    
  4. מריצים את הלקוח עם הדגל --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

  1. משיגים את השם של Pod הלקוח:

    kubectl get pods | grep example-grpc-client
    

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

    default    example-grpc-client-7c969bb997-9fzjv     1/1    Running   0     105s
    
  2. פותחים מעטפת ל-Pod של הלקוח:

    kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
    
  3. אחרי שנכנסים למעטפת, מורידים את גרסה 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
    
  4. מריצים את הלקוח עם הדגל --xds-creds כדי לציין אבטחה שמופעלת באמצעות xDS, שם הלקוח ומחרוזת החיבור של היעד:

    python3 client.py xds:///helloworld-gke:8000 --xds-creds
    

    הפלט אמור להיראות כך:

    Greeter client received: Hello you from example-host!
    

המשך

  1. משיגים את השם של Pod הלקוח:

    kubectl get pods | grep example-grpc-client
    

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

    default    example-grpc-client-7c969bb997-9fzjv     1/1    Running   0     105s
    
  2. פותחים מעטפת ל-Pod של הלקוח:

    kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/sh
    
  3. אחרי שנכנסים למעטפת, מורידים את 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
    
  4. מפתחים ומריצים את הלקוח עם הדגל --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

  1. יוצרים מדיניות הרשאה באמצעות יצירת קובץ בשם 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
    
  2. מייבאים את המדיניות.

    gcloud network-security authorization-policies import \
      helloworld-gke-authz-policy \
      --source=helloworld-gke-authz-policy.yaml \
      --location=global
    
  3. מעדכנים את מדיניות נקודת הקצה כך שתפנה למדיניות ההרשאה החדשה, על ידי הוספת הטקסט הבא לקובץ ep-mtls-psms.yaml.

    authorizationPolicy: projects/${PROJECT_ID}/locations/global/authorizationPolicies/helloworld-gke-authz-policy
    

    עכשיו מדיניות נקודת הקצה מציינת שצריך לאכוף גם את mTLS וגם את מדיניות ההרשאה על בקשות נכנסות לפודים שקובצי ה-bootstrap של gRPC שלהם מכילים את התווית app:helloworld.

  4. מייבאים את המדיניות:

    gcloud network-services endpoint-policies import ep-mtls-psms \
      --source=ep-mtls-psms.yaml --location=global
    

אימות מדיניות ההרשאות

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

Java

  1. פותחים מעטפת לפוד הלקוח שבו השתמשתם קודם.

    kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
    
  2. במעטפת הפקודות, מריצים את הפקודות הבאות כדי לאמת את ההגדרה.

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

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

המשך

  1. פותחים מעטפת לפוד הלקוח שבו השתמשתם קודם.

    kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
    
  2. במעטפת הפקודות, מריצים את הפקודות הבאות כדי לאמת את ההגדרה.

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

  1. בServerTlsPolicy, מוחקים את mtlsPolicy:

    cat << EOF > server-tls-policy.yaml
    name: "server-tls-policy"
    serverCertificate:
      certificateProviderInstance:
        pluginInstance: google_cloud_private_spiffe
    EOF
    
  2. במקומה, צריך להשתמש במדיניות הזו ב-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
    
  3. ה-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 מאגר הקונטיינרים.

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

  1. משכפלים את המאגר ומקבלים את הקבצים בספרייה gRPC examples.
  2. עורכים את הקובץ 00-common-env.sh. מסמנים כהערה את השורה הקיימת שמגדירה את הערך של WALLET_DOCKER_IMAGE לקובץ האימג' של Go Docker, ומבטלים את הסימון כהערה של השורה שמגדירה את הערך של WALLET_DOCKER_IMAGE לקובץ האימג' של Java Docker.
  3. יוצרים ומגדירים מכונות של Cloud Router לפי ההוראות במאמר יצירה והגדרה של מכונות Cloud Router, או באמצעות הפונקציה create_cloud_router_instances בסקריפט 10.apis.sh.
  4. יוצרים אשכול לפי ההוראות בדוגמה של hello world או לפי הפונקציה create_cluster בסקריפט 20-cluster.sh.
  5. יוצרים רשויות אישורים פרטיות באמצעות ההוראות לשירות CA או באמצעות הסקריפט 30-private-ca-setup.sh.
  6. יוצרים משאבים ב-Kubernetes, כולל חשבונות שירות, מרחבי שמות, שירותי Kubernetes, קבוצות NEG ופריסה בצד השרת לכל השירותים: account,‏ stats,‏ stats_premium,‏ wallet_v1,‏ wallet_v2, באמצעות הסקריפט 40-k8s-resources.sh.
  7. לכל אחד מהשירותים שיצרתם, יוצרים בדיקת תקינות ושירות לקצה העורפי באמצעות create_health_check ו-create_backend_service בסקריפט 50-td-components.sh.
  8. יוצרים את רכיבי הניתוב של Cloud Service Mesh באמצעות create_routing_components בסקריפט 60-routing-components.sh.
  9. יוצרים את רכיבי האבטחה של Cloud Service Mesh לכל שירות לקצה העורפי באמצעות create_security_components בסקריפט 70-security-components.sh.
  10. יוצרים את פריסת הלקוח של Wallet באמצעות create_client_deployment בסקריפט 75-client-deployment.sh.
  11. כדי לאמת את ההגדרה, מפעילים את הלקוח כמו שמתואר בקטע אימות באמצעות לקוחות grpc-wallet.

C++‎

קוד המקור לדוגמה ל-C++‎ זמין ב-GitHub. הקוד כבר משתמש בפרטי הכניסה של XdsChannel ו-XdsServer כשמגדירים אבטחה בלי שרת Proxy.

ההוראות האלה מתארות את הגדרת הדוגמה של Wallet באמצעות Go. התהליך דומה ל-C++‎. ההוראות משתמשות בקובץ אימג' קיים של Docker שאתם מקבלים מGoogle Cloud מאגר הקונטיינרים.

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

  1. משכפלים את המאגר ומקבלים את הקבצים בספרייה gRPC examples.
  2. עורכים את הקובץ 00-common-env.sh. מסמנים כהערה את השורה הקיימת שמגדירה את הערך של WALLET_DOCKER_IMAGE לקובץ האימג' של Docker ב-Go, ומבטלים את הסימון כהערה של השורה שמגדירה את הערך של WALLET_DOCKER_IMAGE לקובץ האימג' של Docker ב-C++‎.
  3. יוצרים ומגדירים מכונות של Cloud Router לפי ההוראות במאמר יצירה והגדרה של מכונות Cloud Router, או באמצעות הפונקציה create_cloud_router_instances בסקריפט 10.apis.sh.
  4. יוצרים אשכול לפי ההוראות בדוגמה של hello world או לפי הפונקציה create_cluster בסקריפט 20-cluster.sh.
  5. יוצרים רשויות אישורים פרטיות באמצעות ההוראות לשירות CA או באמצעות הסקריפט 30-private-ca-setup.sh.
  6. יוצרים משאבים ב-Kubernetes, כולל חשבונות שירות, מרחבי שמות, שירותי Kubernetes, קבוצות NEG ופריסה בצד השרת לכל השירותים: account,‏ stats,‏ stats_premium,‏ wallet_v1,‏ wallet_v2, באמצעות הסקריפט 40-k8s-resources.sh.
  7. לכל אחד מהשירותים שיצרתם, יוצרים בדיקת תקינות ושירות לקצה העורפי באמצעות create_health_check ו-create_backend_service בסקריפט 50-td-components.sh.
  8. יוצרים את רכיבי הניתוב של Cloud Service Mesh באמצעות create_routing_components בסקריפט 60-routing-components.sh.
  9. יוצרים את רכיבי האבטחה של Cloud Service Mesh לכל שירות לקצה העורפי באמצעות create_security_components בסקריפט 70-security-components.sh.
  10. יוצרים את פריסת הלקוח של Wallet באמצעות create_client_deployment בסקריפט 75-client-deployment.sh.
  11. כדי לאמת את ההגדרה, מפעילים את הלקוח כמו שמתואר בקטע אימות באמצעות לקוחות grpc-wallet.

המשך

ב-GitHub יש קוד מקור לדוגמה ב-Go. הקוד כבר משתמש בפרטי הכניסה של XdsChannel ו-XdsServer כשמגדירים אבטחה בלי שרת proxy.

בהוראות נעשה שימוש ב-Google Cloud קובץ אימג' של Docker קיים, שאפשר לקבל ממאגר הקונטיינרים.

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

  1. משכפלים את המאגר ומקבלים את הקבצים בספרייה gRPC examples.
  2. עורכים את הקובץ 00-common-env.sh כדי להגדיר את הערכים הנכונים למשתני הסביבה.
  3. יוצרים ומגדירים מכונות של Cloud Router לפי ההוראות במאמר יצירה והגדרה של מכונות Cloud Router, או באמצעות הפונקציה create_cloud_router_instances בסקריפט 10.apis.sh.
  4. יוצרים אשכול לפי ההוראות בדוגמה של hello world או לפי הפונקציה create_cluster בסקריפט 20-cluster.sh.
  5. יוצרים רשויות אישורים פרטיות באמצעות ההוראות לשירות CA או באמצעות הסקריפט 30-private-ca-setup.sh.
  6. יוצרים משאבים ב-Kubernetes, כולל חשבונות שירות, מרחבי שמות, שירותי Kubernetes, קבוצות NEG ופריסה בצד השרת לכל השירותים: account,‏ stats,‏ stats_premium,‏ wallet_v1,‏ wallet_v2, באמצעות הסקריפט 40-k8s-resources.sh.
  7. לכל אחד מהשירותים שיצרתם, יוצרים בדיקת תקינות ושירות לקצה העורפי באמצעות create_health_check ו-create_backend_service בסקריפט 50-td-components.sh.
  8. יוצרים את רכיבי הניתוב של Cloud Service Mesh באמצעות create_routing_components בסקריפט 60-routing-components.sh.
  9. יוצרים את רכיבי האבטחה של Cloud Service Mesh לכל שירות לקצה העורפי באמצעות create_security_components בסקריפט 70-security-components.sh.
  10. יוצרים את פריסת הלקוח של Wallet באמצעות create_client_deployment בסקריפט 75-client-deployment.sh.
  11. כדי לאמת את ההגדרה, מפעילים את הלקוח כמו שמתואר בקטע אימות באמצעות לקוחות 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 של מופע של ספק אישורים יש שני שדות:
  • plugin_name. ערך חובה שמזהה את הפלאגין של ספק האישורים שבו צריך להשתמש, כפי שנדרש על ידי ארכיטקטורת הפלאגין של gRPC לספקי אישורים. ל-gRPC יש תמיכה מובנית בפלאגין file-watcher שמשמש בהגדרה הזו. הערך של plugin_name הוא file_watcher.
  • ‫config. ערך חובה שמזהה את בלוג הגדרות ה-JSON של הפלאגין file_watcher. הסכימה והתוכן תלויים בפלאגין.

התוכן של מבנה ה-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, בצעו את ההוראות הבאות כדי לזהות את הסיבה.

  1. להשבית את האבטחה בלי שרת proxy ולפתור בעיות בתרחישים לדוגמה של איזון עומסים ברשת שירות בלי שרת proxy. כדי להשבית את האבטחה ברשת, מבצעים אחת מהפעולות הבאות:
    1. שימוש בפרטי כניסה בטקסט פשוט בצד הלקוח ובצד השרת, או
    2. אל תגדירו אבטחה לשירות לקצה העורפי ולמדיניות נקודות הקצה בהגדרות של Cloud Service Mesh.

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

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

    1. מגדילים את רמת הרישום ביומן גם בצד הלקוח וגם בצד השרת, כדי שתוכלו לראות את הודעות ה-xDS שמועברות בין gRPC לבין Cloud Service Mesh.
    2. מוודאים שהאבטחה לא מופעלת ב-Cloud Service Mesh בתגובות של CDS ו-LDS שנשלחות לעומסי העבודה.
    3. מוודאים שעומסי העבודה לא משתמשים במצבי TLS או mTLS בערוצים שלהם. אם מופיעות הודעות ביומן שקשורות ללחיצות יד בפרוטוקול TLS, צריך לבדוק את קוד המקור של האפליקציה ולוודא שאתם משתמשים בטקסט פשוט או לא מאובטח בתור פרטי הכניסה החלופיים. אם קוד המקור של האפליקציה תקין, יכול להיות שיש באג בספריית gRPC.
  2. כדי לוודא שהשילוב של שירות CA עם GKE פועל בצורה תקינה באשכול GKE, פועלים לפי השלבים לפתרון בעיות במדריך למשתמש. חשוב לוודא שהאישורים והמפתחות שסופקו על ידי התכונה הזו זמינים בספרייה שצוינה, /var/run/secrets/workload-spiffe-credentials/.

  3. מפעילים TLS (במקום mTLS) ברשת, כמו שמתואר למעלה, ומפעילים מחדש את עומסי העבודה של הלקוח והשרת.

    1. כדי לראות את הודעות ה-xDS שמועברות בין gRPC לבין Cloud Service Mesh, מגדילים את רמת הרישום ביומן גם בצד הלקוח וגם בצד השרת.
    2. מוודאים ש-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, צריך לבצע את הפעולות הבאות:

  1. מוודאים שמפרט ה-Pod מכיל את ההערה security.cloud.google.com/use-workload-certificates שמתוארת במאמר יצירת שירות gRPC בלי שרת Proxy באמצעות קבוצות של נקודות קצה ברשת (NEG).

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

    1. שרשרת אישורים יחד עם אישור קצה: "/var/run/secrets/workload-spiffe-credentials/certificates.pem"
    2. מפתח פרטי: "/var/run/secrets/workload-spiffe-credentials/private_key.pem"
    3. חבילת CA:‏ "/var/run/secrets/workload-spiffe-credentials/ca_certificates.pem"
  3. אם האישורים מהשלב הקודם לא זמינים, מבצעים את הפעולות הבאות:

      gcloud privateca subordinates describe SUBORDINATE_CA_POOL_NAME 
    --location=LOCATION

    1. מוודאים שלמישור הבקרה של 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.
      
    2. מוודאים שהתוקף של האישור לא פג. זו שרשרת האישורים ואישור הקצה בכתובת /var/run/secrets/workload-spiffe-credentials/certificates.pem. כדי לבדוק, מריצים את הפקודה הבאה:

      cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"
      

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

      cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Public Key Algorithm" -A 3
      

    4. מוודאים שאפליקציית gRPC Java כוללת את ה-keyAlgorithm הבא בקובץ ה-YAML של WorkloadCertificateConfig:

      keyAlgorithm:
        rsa:
          modulusSize: 4096
    
  4. מוודאים שרשות האישורים משתמשת באותה משפחת מפתחות כמו מפתח האישור.

אישור של אפליקציה נדחה על ידי הלקוח, השרת או נקודת הקצה (peer)

  1. מוודאים שבאפליקציית המשתמש האחר נעשה שימוש באותה חבילת אמון כדי לאמת את האישור.
  2. מוודאים שהתוקף של האישור שבו משתמשים לא פג (שרשרת האישורים יחד עם אישור העלה: "/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.

  1. בודקים את הסטטוס של ה-Pod:

    kubectl get pod -n POD_NAMESPACE POD_NAME
    

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

    • ‫POD_NAMESPACE: מרחב השמות של ה-Pod.
    • ‫POD_NAME: שם ה-Pod.
  2. כדי לבדוק אירועים אחרונים ב-Pod:

    kubectl describe pod -n POD_NAMESPACE POD_NAME
    
  3. אם הקצאת האישור נכשלת, יופיע אירוע עם 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)
    
  4. אם הפודים לא מתחילים לפעול בגלל אובייקטים שהוגדרו באופן שגוי או בגלל בקשות CSR שנדחו, תוכלו להיעזר בשלבים הבאים לפתרון הבעיות.

ההגדרה של WorkloadCertificateConfig או TrustConfig שגויה

מוודאים שיצרתם את האובייקטים WorkloadCertificateConfig ו-TrustConfig בצורה נכונה. אפשר לאבחן הגדרות שגויות בכל אחד מהאובייקטים האלה באמצעות kubectl.

  1. אחזור הסטטוס הנוכחי.

    עבור WorkloadCertificateConfig:

    kubectl get WorkloadCertificateConfig default -o yaml
    

    עבור TrustConfig:

    kubectl get TrustConfig default -o yaml
    
  2. בודקים את פלט הסטטוס. אובייקט תקין יכלול תנאי עם 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.

  1. מציגים את בקשות ה-CSR הרלוונטיות באמצעות kubectl:

    kubectl get csr \
      --field-selector='spec.signerName=spiffe.gke.io/spiffe-leaf-signer'
    
  2. צריך לבחור CSR שהוא Approved ולא Issued, או שהוא לא Approved.

  3. מציגים את הפרטים של ה-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.

חסרים אישורים לפודים

  1. משיגים את מפרט ה-Pod של ה-Pod:

    kubectl get pod -n POD_NAMESPACE POD_NAME -o yaml
    

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

    • ‫POD_NAMESPACE: מרחב השמות של ה-Pod.
    • ‫POD_NAME: שם ה-Pod.
  2. מוודאים שמפרט ה-Pod מכיל את ההערה security.cloud.google.com/use-workload-certificates שמתוארת במאמר הגדרת Pods לקבלת פרטי כניסה של mTLS.

  3. מוודאים שבקר הגישה של אישורי הרשת ב-GKE החדיר בהצלחה נפח של מנהל התקן CSI מסוג workloadcertificates.security.cloud.google.com למפרט ה-Pod:

    volumes:
    ...
    -csi:
      driver: workloadcertificates.security.cloud.google.com
      name: gke-workload-certificates
    ...
    
  4. בודקים אם יש טעינת נפח בכל אחד מהקונטיינרים:

    containers:
    - name: ...
      ...
      volumeMounts:
      - mountPath: /var/run/secrets/workload-spiffe-credentials
        name: gke-workload-certificates
        readOnly: true
      ...
    
  5. מוודאים שחבילות האישורים הבאות והמפתח הפרטי זמינים במיקומים הבאים ב-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
  6. אם הקבצים לא זמינים, מבצעים את הפעולות הבאות:

    1. מאחזרים את המכונה של שירות ה-CA (תצוגה מקדימה) בשביל האשכול:

      kubectl get workloadcertificateconfigs default -o jsonpath '{.spec.certificateAuthorityConfig.certificateAuthorityServiceConfig.endpointURI}'
      
    2. אחזור הסטטוס של המכונה של שירות 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 המנפיק.
    3. מורידים את מדיניות ה-IAM של ה-CA ברמה הבסיסית (root):

      gcloud privateca roots get-iam-policy ROOT_CA_NAME
      

      מחליפים את ROOT_CA_NAME בשם של ה-CA ברמה הבסיסית (root).

    4. במדיניות IAM, מוודאים שקיים הקישור למדיניות privateca.auditor:

      ...
      - members:
        - serviceAccount:service-PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com
        role: roles/privateca.auditor
      ...
      

      בדוגמה הזו, PROJECT_NUMBER הוא מספר הפרויקט של האשכול.

    5. מורידים את מדיניות ה-IAM של רשות האישורים המשנית:

      gcloud privateca subordinates get-iam-policy SUBORDINATE_CA_NAME
      

      מחליפים את SUBORDINATE_CA_NAME בשם של רשות האישורים המשנית.

    6. במדיניות IAM, מוודאים שקיים הקישור של המדיניות privateca.certificateManager:

      ...
      - members:
        - serviceAccount: service-PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com
        role: roles/privateca.certificateManager
      ...
      

      בדוגמה הזו, PROJECT_NUMBER הוא מספר הפרויקט של האשכול.

אפליקציות לא יכולות להשתמש בפרטי כניסה שהונפקו ל-mTLS

  1. מוודאים שהתוקף של האישור לא פג:

    cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"
    
  2. מוודאים שסוג המפתח שבו השתמשתם נתמך באפליקציה.

    cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Public Key Algorithm" -A 3
    
  3. מוודאים שהרשות שמנפיקה את האישורים (CA) משתמשת באותה משפחת מפתחות כמו המפתח של האישור.

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

האישורים נדחים

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

    cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"
    
  3. אם קוד הלקוח לא משתמש ב-Credentials Reloading API של gRPC Go, צריך לוודא שהוא מרענן מדי פעם את פרטי הכניסה ממערכת הקבצים.

  4. מוודאים שעומסי העבודה נמצאים באותו מתחם אמון (trust domain) כמו ה-CA. אישורי רשת ב-GKE תומכים בתקשורת בין עומסי עבודה במתחם אמון (trust domain) אחד.

מגבלות

אבטחת השירות של Cloud Service Mesh נתמכת רק ב-GKE. אי אפשר לפרוס אבטחת שירות באמצעות Compute Engine.

ב-Cloud Service Mesh אין תמיכה בתרחישים שבהם יש שני משאבים או יותר של מדיניות נקודות קצה שתואמים באותה מידה לנקודת קצה, למשל שתי כללי מדיניות עם אותן תוויות ויציאות, או שני כללי מדיניות או יותר עם תוויות שונות שתואמות באותה מידה לתוויות של נקודת קצה. למידע נוסף על האופן שבו מדיניות נקודות הקצה מותאמת לתוויות של נקודת הקצה, קראו את המאמר ממשקי API ל-EndpointPolicy.EndpointMatcher.MetadataLabelMatcher. במצבים כאלה, Cloud Service Mesh לא יוצר הגדרת אבטחה מאף אחד מכללי המדיניות שמתנגשים.