הגבלת הגישה לשינוי ולבחירה של ComputeClasses

טייס אוטומטי רגילה

אתם יכולים להשתמש ב-ComputeClasses של Google Kubernetes Engine‏ (GKE) כדי ליצור צמתים שעומדים בדרישות שונות של עומסי עבודה. אפשר להשתמש ב-ComputeClasses כדי ליצור חומרה ל-Pods. בהתאם ל-ComputeClass, יכול להיות שהחומרה הזו תהיה מבוקשת מאוד, הזמינות שלה תהיה מוגבלת או שהיא תהיה יקרה יחסית לעסק שלכם. במדריך הזה מוסבר איך להשתמש ב-Kubernetes RBAC וב-ValidatingAdmissionPolicies כדי להגביל את היצירה, המחיקה, השינוי והבחירה של ComputeClasses.

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

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

במסמך הזה מוצג לדוגמה ValidatingAdmissionPolicy שחוסם סוגים נפוצים של שימוש לרעה, כמו wildcard ComputeClass tolerations או בחירה של ComputeClasses ספציפיים שאסורים לשימוש. אפשר לשנות את ValidatingAdmissionPolicy כדי לעמוד בדרישות ספציפיות לארגון, כמו חסימת עומסי עבודה מצוותים מסוימים משימוש ב-ComputeClasses.

מטרות

• אפשר להשתמש ב-ValidatingAdmissionPolicy כדי להגביל את ה-ComputeClasses ש-Pods יכולים לבחור בכל מרחב שמות לרשימה מאושרת.
• משתמשים בבקרת גישה מבוססת-תפקידים (RBAC) כדי להגביל את המשתמשים שיכולים ליצור, לשנות או למחוק ComputeClasses באשכולות.

עלויות

במסמך הזה משתמשים ברכיבים הבאים של Google Cloud, והשימוש בהם כרוך בתשלום:

• Kubernetes Engine
• Google Workspace or Cloud Identity

כדי להעריך את ההוצאות בהתאם לתחזית השימוש שלכם, אתם יכולים להיעזר במחשבון העלויות.

משתמשים חדשים של Google Cloud ? יכול להיות שאתם זכאים לתקופת ניסיון בחינם.

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

לפני שמתחילים

נכנסים לחשבון Google Cloud . אם אתם משתמשים חדשים ב- Google Cloud, צרו חשבון כדי שתוכלו להעריך את הביצועים של המוצרים שלנו בתרחישים מהעולם האמיתי. לקוחות חדשים מקבלים בחינם גם קרדיט בשווי 300$ להרצה, לבדיקה ולפריסה של עומסי העבודה.

התקינו את ה-CLI של Google Cloud.

אם אתם משתמשים בספק זהויות חיצוני (IdP), קודם אתם צריכים להיכנס ל-CLI של gcloud באמצעות המאגר המאוחד לניהול זהויות.

כדי לאתחל את ה-CLI של gcloud, הריצו את הפקודה הבאה:

gcloud init

יוצרים או בוחרים Google Cloud פרויקט.

תפקידים שנדרשים כדי לבחור או ליצור פרויקט

• Select a project: כדי לבחור פרויקט לא צריך תפקיד IAM ספציפי – אפשר לבחור כל פרויקט שקיבלתם בו תפקיד.
• יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד Project Creator (roles/resourcemanager.projectCreator), שכולל את ההרשאה resourcemanager.projects.create. איך מקצים תפקידים

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

• יוצרים Google Cloud פרויקט:

  gcloud projects create PROJECT_ID

  מחליפים את PROJECT_ID בשם של פרויקט Google Cloud שיוצרים.

• בוחרים את הפרויקט שיצרתם: Google Cloud

  gcloud config set project PROJECT_ID

  מחליפים את PROJECT_ID בשם הפרויקט ב- Google Cloud .

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

מוודאים שהחיוב מופעל בפרויקט Google Cloud .

מפעילים את Kubernetes Engine API, אם הוא עדיין לא מופעל:

תפקידים שנדרשים להפעלת ממשקי API

כדי להפעיל ממשקי API, נדרשת ההרשאה serviceusage.services.enable. אם יצרתם את הפרויקט, סביר להניח שכבר יש לכם את ההרשאה הזו דרך התפקיד 'בעלים' (roles/owner). אחרת, תוכלו לקבל את ההרשאה הזו דרך התפקיד 'אדמין בממשק Service Usage' (roles/serviceusage.serviceUsageAdmin). איך מקצים תפקידים

gcloud services enable container.googleapis.com

התקינו את ה-CLI של Google Cloud.

אם אתם משתמשים בספק זהויות חיצוני (IdP), קודם אתם צריכים להיכנס ל-CLI של gcloud באמצעות המאגר המאוחד לניהול זהויות.

כדי לאתחל את ה-CLI של gcloud, הריצו את הפקודה הבאה:

gcloud init

יוצרים או בוחרים Google Cloud פרויקט.

תפקידים שנדרשים כדי לבחור או ליצור פרויקט

• Select a project: כדי לבחור פרויקט לא צריך תפקיד IAM ספציפי – אפשר לבחור כל פרויקט שקיבלתם בו תפקיד.
• יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד Project Creator (roles/resourcemanager.projectCreator), שכולל את ההרשאה resourcemanager.projects.create. איך מקצים תפקידים

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

• יוצרים Google Cloud פרויקט:

  gcloud projects create PROJECT_ID

  מחליפים את PROJECT_ID בשם של פרויקט Google Cloud שיוצרים.

• בוחרים את הפרויקט שיצרתם: Google Cloud

  gcloud config set project PROJECT_ID

  מחליפים את PROJECT_ID בשם הפרויקט ב- Google Cloud .

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

מוודאים שהחיוב מופעל בפרויקט Google Cloud .

מפעילים את Kubernetes Engine API, אם הוא עדיין לא מופעל:

תפקידים שנדרשים להפעלת ממשקי API

כדי להפעיל ממשקי API, נדרשת ההרשאה serviceusage.services.enable. אם יצרתם את הפרויקט, סביר להניח שכבר יש לכם את ההרשאה הזו דרך התפקיד 'בעלים' (roles/owner). אחרת, תוכלו לקבל את ההרשאה הזו דרך התפקיד 'אדמין בממשק Service Usage' (roles/serviceusage.serviceUsageAdmin). איך מקצים תפקידים

gcloud services enable container.googleapis.com

1. אם אתם משתמשים במעטפת מקומית, צריך להתקין את הרכיב kubectl:

   gcloud components install kubectl

2. מוודאים שיש לכם אשכול GKE שמשתמש בגרסה 1.30 ואילך. אפשר גם ליצור אשכול Autopilot לצורך המדריך הזה.
3. מגדירים את האשכול לקבוצות Google לצורך RBAC:
   1. מגדירים את הקבוצה gke-security-groups בדומיין.
   2. מפעילים את קבוצות Google עבור RBAC באשכול.

   מידע נוסף מופיע במאמר בנושא הגדרת קבוצות Google.

התפקידים הנדרשים

כדי לקבל את ההרשאות שנדרשות ליצירת כללי מדיניות של RBAC ואובייקטים של Kubernetes באשכול, צריך לבקש מהאדמין להקצות לכם את תפקיד ה-IAM ‏Kubernetes Engine Admin ‏ (role/container.admin) בפרויקט. כדי לקרוא הסבר על מתן תפקידים, ראו איך מנהלים את הגישה ברמת הפרויקט, התיקייה והארגון.

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

הכנת הסביבה

כדי להכין את האשכול למשימות היצירה והאימות במדריך הזה, פועלים לפי השלבים הבאים:

1. מתחברים לאשכול:

   gcloud container clusters get-credentials CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION
   

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

   • ‫CLUSTER_NAME: השם של האשכול.
   • ‫CONTROL_PLANE_LOCATION: האזור או האזור של מישור הבקרה של האשכול, למשל us-central1 או us-central1-a.

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

   kubectl create namespace computeclass-vap-tutorial
   

3. יוצרים מדיניות RBAC שמעניקה גישה לניהול של ValidatingAdmissionPolicies ו-ValidatingAdmissionPolicyBindings:

   1. שומרים את קובץ המניפסט הבא בשם validatingadmissionpolicy-editor.yaml:

      apiVersion: rbac.authorization.k8s.io/v1
      kind: ClusterRole
      metadata:
        name: validatingadmissionpolicy-editor
      rules:
      - apiGroups: ["admissionregistration.k8s.io"]
        resources: ["validatingadmissionpolicies","validatingadmissionpolicybindings"]
        verbs: ["get", "list", "create", "update", "patch", "delete"]
      ---
      apiVersion: rbac.authorization.k8s.io/v1
      kind: ClusterRoleBinding
      metadata:
        name: edit-validatingadmissionpolicies
      subjects:
      - kind: User
        name: USER_ACCOUNT
        apiGroup: rbac.authorization.k8s.io
      roleRef:
        apiGroup: rbac.authorization.k8s.io
        kind: ClusterRole
        name: validatingadmissionpolicy-editor
      

      מחליפים את USER_ACCOUNT בכתובת האימייל של חשבון המשתמש.

   2. יוצרים את מדיניות RBAC:

      kubectl apply -f validatingadmissionpolicy-editor.yaml
      

4. יוצרים ComputeClass באשכול. אם באשכול כבר יש ComputeClass, מדלגים על השלב הזה.

   1. שומרים את קובץ המניפסט הבא בשם access-computeclass.yaml:

      apiVersion: cloud.google.com/v1
      kind: ComputeClass
      metadata:
        name: access-restriction-class
      spec:
        priorities:
        - machineFamily: e2
        nodePoolAutoCreation:
          enabled: true
        whenUnsatisfiable: ScaleUpAnyway
      

   2. יוצרים את ComputeClass:

      kubectl apply -f access-computeclass.yaml
      

יצירה של ValidatingAdmissionPolicy

כדי להגביל את ComputeClasses שה-Pods יכולים לבחור, יוצרים ValidatingAdmissionPolicy ומחילים אותו במרחב שמות ספציפי. משתמשים במפרט ValidatingAdmissionPolicy כדי לקבוע איך אפשר לבחור ComputeClasses עבור Pods. כדי ליצור את המדיניות הזו ולאכוף אותה:

1. שומרים את המניפסט הבא של ValidatingAdmissionPolicy בתור restrict-computeclass-usage-vap.yaml:

   apiVersion: admissionregistration.k8s.io/v1
   kind: ValidatingAdmissionPolicy
   metadata:
     name: restrict-computeclass-usage
   spec:
     failurePolicy: Fail # If an internal error occurs, deny the request.
     variables:
     # Check whether the admission request is for a Deployment.
     - name: isDeployment
       expression: "object.kind == 'Deployment'"
     # Get the Pod specification from the admission request by reading the
     # spec.template.spec field for Deployments or the spec field for static Pods.
     - name: podSpec
       expression: "variables.isDeployment ? object.spec.template.spec : object.spec"
     # Check whether a node selector or an affinity rule that explicitly requests a
     # disallowed ComputeClass.
     - name: hasForbiddenNodeSelectorOrAffinity
       expression: >-
         (has(variables.podSpec.nodeSelector) &&
         variables.podSpec.nodeSelector['cloud.google.com/compute-class'] == 'COMPUTECLASS_NAME') ||
         (has(variables.podSpec.affinity) &&
         has(variables.podSpec.affinity.nodeAffinity) &&
         has(variables.podSpec.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution) &&
         variables.podSpec.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms.exists(term, has(term.matchExpressions) &&
           term.matchExpressions.exists(
             exp, exp.key == 'cloud.google.com/compute-class' &&
             exp.operator == 'In' && exp.values.exists(v, v == 'COMPUTECLASS_NAME')
           )
         ))
   
     # Check whether the Pod has a toleration for the taint that corresponds to a
     # disallowed ComputeClass.
     - name: hasForbiddenComputeClassToleration
       expression: >-
         has(variables.podSpec.tolerations) &&
         variables.podSpec.tolerations.exists(t, 
           t.key == 'cloud.google.com/compute-class' &&
           (t.operator == 'Exists' || (t.operator == 'Equal' && t.value == 'COMPUTECLASS_NAME')) &&
           has(t.effect) && t.effect == 'NoSchedule')
   
     # Check whether the Pod has a toleration that could match any taint.
     - name: hasWildcardToleration
       expression: >-
         has(variables.podSpec.tolerations) &&
         variables.podSpec.tolerations.exists(t, 
           (t.operator == 'Exists' && !(has(t.key) && t.key != ''))
         )
   
     # Trigger the ValidatingAdmissionPolicy when Pods or Deployments are created or
     # updated.
     matchConstraints:
       resourceRules:
       - apiGroups: [""]
         apiVersions: ["v1"]
         operations: ["CREATE", "UPDATE"]
         resources: ["pods"]
       - apiGroups: ["apps"]
         apiVersions: ["v1"]
         operations: ["CREATE", "UPDATE"]
         resources: ["deployments"]
   
     # Validate whether any of the expressions in the variables section evaluate to
     # true.
     validations:
       - expression: >-
           !(variables.hasForbiddenNodeSelectorOrAffinity ||
             variables.hasForbiddenComputeClassToleration ||
             variables.hasWildcardToleration)
         message: >-
           Pods and Deployments in this namespace cannot request ComputeClass
           COMPUTECLASS_NAME or use wildcard
           tolerations.
   

   מחליפים את COMPUTECLASS_NAME בשם של ComputeClass שרוצים למנוע מ-Pods לבחור.

   ל-ValidatingAdmissionPolicy הזה יש את המאפיינים הבאים:

   • טריגרים ל-Pods סטטיים או ל-Pods בפריסות.

   • הכלי מוצא Pods שמבצעים אחת מהפעולות הבאות:

     • משתמשים בבורר צמתים או בכלל זיקה לצמתים כדי לבחור במפורש ComputeClass ספציפי שאסור להשתמש בו.
     • צריך להשתמש בtoleration שתואם ל-taint של הצומת עבור ComputeClass ספציפי שאסור לשימוש.
     • משתמשים בטולרנטיות שתואמת לכל הדחיות של הצמתים באשכול.

   זו דוגמה ל-ValidatingAdmissionPolicy. אתם יכולים להשתמש בביטויים כדי להפעיל את המדיניות על סמך התנאים שלכם, למשל כדי למנוע מ-Pods עם תוויות ספציפיות לבחור ComputeClasses מסוימים.

2. יוצרים את ValidatingAdmissionPolicy:

   kubectl apply -f restrict-computeclass-usage-vap.yaml
   

3. שומרים את ValidatingAdmissionPolicyBinding הבא בתור restrict-computeclass-usage-binding.yaml:

   apiVersion: admissionregistration.k8s.io/v1
   kind: ValidatingAdmissionPolicyBinding
   metadata:
     name: restrict-computeclass-usage-binding
   spec:
     policyName: restrict-computeclass-usage
     validationActions: ["Deny","Audit"]
     matchResources:
       namespaceSelector:
         matchLabels:
           kubernetes.io/metadata.name: computeclass-vap-tutorial # Replace with the name of any namespace in the cluster.
   

   ה-ValidatingAdmissionPolicyBinding הזה אוכף את ה-ValidatingAdmissionPolicy מהשלב הקודם במרחב השמות computeclass-vap-tutorial. הערכים בשדה validationActions דוחים קבוצות Pod או פריסות שמפירות את ValidatingAdmissionPolicy ומוסיפים רשומה ליומן הביקורת של Kubernetes.

4. יוצרים את ValidatingAdmissionPolicyBinding:

   kubectl apply -f restrict-computeclass-usage-binding.yaml
   

הגדרת מדיניות RBAC

בנוסף לשימוש ב-ValidatingAdmissionPolicy כדי למנוע מעומסי עבודה להשתמש ב-ComputeClasses מסוימים, אפשר להשתמש ב-RBAC כדי למנוע מחשבונות ראשיים לא מורשים ליצור ולשנות את ה-ComputeClasses באשכול. בשלבים הבאים מוסבר איך להעניק גישה ל-ComputeClasses לקבוצה ספציפית של משתמשים באמצעות קבוצות Google ל-RBAC:

1. יוצרים קבוצה לעורכים של ComputeClass:

   1. במסוף Google Admin, עוברים לדף Groups.

      מעבר אל "קבוצות Google"

   2. לוחצים על יצירת קבוצה.

   3. בדף Group details, מבצעים את הפעולות הבאות:

      1. בשדה Group name (שם הקבוצה), מציינים computeclass-editors.
      2. בשדה כתובת אימייל קבוצתית, מציינים את הערך computeclass-editors.
      3. מסמנים את תיבת הסימון אבטחה.
      4. לוחצים על הבא.

   4. בדף סוג הגישה, בעמודה חברי הקבוצה, מוודאים שתיבת הסימון מי יכול לראות את החברים מסומנת.

   5. לוחצים על יצירת קבוצה.

   6. בתפריט הניווט, לוחצים על ספרייה > קבוצות.

   7. מעבירים את העכבר מעל השורה gke-security-groups ולוחצים על הוספת חברים.

   8. בתיבת הדו-שיח Add members to gke-security-groups, מציינים את computeclass-editors ובוחרים את הקבוצה הזו מהתוצאות.

   9. לוחצים על הוספה לקבוצה.

2. מוסיפים את כתובות האימייל של המשתמשים המורשים לקבוצה computeclass-editors.

3. שומרים את ה-ClusterRole הבא בתור computeclass-editor-clusterrole.yaml:

   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: computeclass-editor
   rules:
   -   apiGroups: ["cloud.google.com"]
     resources: ["computeclasses"]
     verbs: ["create","update"]
   

4. יוצרים את ClusterRole:

   kubectl apply -f computeclass-editor-clusterrole.yaml
   

5. שומרים את ClusterRoleBinding הבא בתור computeclass-editor-role-binding.yaml:

   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: computeclass-editor-role-binding
   subjects:
   - kind: Group
     name: computeclass-editors@GROUP_DOMAIN
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: ClusterRole
     name: computeclass-editor
     apiGroup: rbac.authorization.k8s.io # Required for role references
   

   מחליפים את GROUP_DOMAIN בשם הדומיין של קבוצת computeclass-editors.

6. יוצרים את ClusterRoleBinding:

   kubectl apply -f computeclass-editor-role-binding.yaml
   

אימות ההגבלות

בקטעים הבאים מוסבר איך לוודא שההגבלות שהגדרתם בקטעים הקודמים פועלות כמצופה. אם אתם מגדירים הגבלות משלכם במדיניות ValidatingAdmissionPolicies או במדיניות RBAC, אתם יכולים לבדוק את ההגבלות על ידי יצירת עומס עבודה שמפר את המדיניות הזו.

אימות של ValidatingAdmissionPolicy

1. שומרים את אחד מהמניפסטים הבאים, שכל אחד מהם מפר תנאי אחר של ValidatingAdmissionPolicy:

   • פריסה שמשתמשת בסלקטור של צומת כדי לבחור ComputeClass שלא מורשה:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: disallowed-computeclass-deployment
       namespace: computeclass-vap-tutorial
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: forbidden-selector-app
       template:
         metadata:
           labels:
             app: forbidden-selector-app
         spec:
           containers:
           - name: my-app-container
             image: nginx:latest
           # The node selector triggers the policy.
           nodeSelector:
             cloud.google.com/compute-class: COMPUTECLASS_NAME
     

   • פריסה עם סבילות ל-ComputeClass שאסור להשתמש בה:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: disallowed-computeclass-deployment-toleration
       namespace: computeclass-vap-tutorial
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: forbidden-selector-app
       template:
         metadata:
           labels:
             app: forbidden-selector-app
         spec:
           containers:
           - name: my-app-container
             image: nginx:latest
           tolerations:
           - key: cloud.google.com/compute-class
             operator: Equal
             value: COMPUTECLASS_NAME
             effect: NoSchedule
     

   • פריסה עם כלל של צירוף צמתים (node affinity) ל-ComputeClass שלא מותר:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: disallowed-computeclass-deployment-toleration
       namespace: computeclass-vap-tutorial
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: forbidden-selector-app
       template:
         metadata:
           labels:
             app: forbidden-selector-app
         spec:
           containers:
           - name: my-app-container
             image: nginx:latest
           affinity:
             nodeAffinity:
               requiredDuringSchedulingIgnoredDuringExecution:
                 nodeSelectorTerms:
                 - matchExpressions:
                   - key: cloud.google.com/compute-class
                     operator: In
                     values:
                     - COMPUTECLASS_NAME
     

   • ‫Pod שיש לו טולרנטיות לכל דחיית צומת באשכול:

     apiVersion: v1
     kind: Pod
     metadata:
       name: disallowed-computeclass-deployment-toleration
       namespace: computeclass-vap-tutorial
     spec:
       containers:
       - name: my-app-container
         image: nginx:latest
       tolerations:
       - operator: Exists
         effect: NoSchedule
     

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

   kubectl apply -f PATH_TO_WORKLOAD_MANIFEST
   

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

   Error from server (BadRequest): admission webhook "validation-policy.kubernetes.io" denied the request: Pods and Deployments in this namespace cannot request ComputeClass COMPUTECLASS_NAME or use wildcard tolerations.
   

אימות הגדרות ה-RBAC

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

1. מבצעים אימות לאשכול באמצעות פרטי הכניסה של משתמש שהוא חבר בקבוצה computeclass-editors.

2. בודקים אם המשתמש יכול ליצור ComputeClass:

   kubectl auth can-i create computeclasses.cloud.google.com \
       --as=MEMBER_USER
   

   מחליפים את MEMBER_USER בכתובת האימייל של משתמש שהוא חבר בקבוצה.

   הפלט הוא yes.

3. מבצעים אימות לאשכול באמצעות פרטי הכניסה של משתמש שלא חבר בקבוצה computeclass-editors.

4. בודקים אם המשתמש יכול ליצור ComputeClass:

   kubectl auth can-i create computeclasses.cloud.google.com \
       --as=NON_MEMBER_USER
   

   מחליפים את NON_MEMBER_USER בכתובת האימייל של משתמש שלא חבר בקבוצה.

   הפלט הוא no.

אם הפלט של הפקודה kubectl auth can-i הוא yes עבור משתמש שלא חבר בקבוצה, צריך לוודא את הדברים הבאים:

• הקבוצה computeclass-editors היא חברה בקבוצה gke-security-groups.
• כתובת האימייל של הקבוצה ב-ClusterRoleBinding היא כתובת האימייל המדויקת של הקבוצה, למשל [e-mail].

הסרת המשאבים

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

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

מחיקת הפרויקט

זהירות: כשמוחקים פרויקט:

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

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

כדי למחוק Google Cloud פרויקט:

gcloud projects delete PROJECT_ID

מחיקת משאבים בודדים

1. מוחקים את ComputeClass שיצרתם:

   kubectl delete computeclass access-restriction-class
   

2. מוחקים את ValidatingAdmissionPolicy ואת ValidatingAdmissionPolicyBinding:

   kubectl delete validatingadmissionpolicy restrict-computeclass-usage
   kubectl delete validatingadmissionpolicybinding restrict-computeclass-usage-binding
   

3. מוחקים את ClusterRoles ואת ClusterRoleBindings:

   kubectl delete clusterroles \
       computeclass-editor validatingadmissionpolicy-editor
   kubectl delete clusterrolebindings \
       computeclass-editor-role-binding edit-validatingadmissionpolicies
   

4. מוחקים את מרחב השמות לדוגמה:

   kubectl delete namespace computeclass-vap-tutorial
   

המאמרים הבאים

• שיטות מומלצות לשימוש ב-ComputeClasses
• שיטות מומלצות לאבטחת אשכולות
• כדאי להעמיק את הקריאה ולהכיר דוגמאות לארכיטקטורות, תרשימים ושיטות מומלצות בנושאי Google Cloud. כל אלה זמינים במרכז הארכיטקטורה של Cloud.