Zugriff auf das Ändern und Auswählen von ComputeClasses einschränken

Autopilot Standard

Mit ComputeClasses in Google Kubernetes Engine (GKE) können Sie Knoten erstellen, die verschiedene Arbeitslastanforderungen erfüllen. Pods können ComputeClasses verwenden, um Hardware zu erstellen. Je nach ComputeClass kann die Hardware sehr gefragt, nur begrenzt verfügbar oder relativ teuer für Ihr Unternehmen sein. In diesem Tutorial wird gezeigt, wie Sie Kubernetes RBAC und ValidatingAdmissionPolicies verwenden, um das Erstellen, Löschen, Ändern und Auswählen von ComputeClasses einzuschränken.

Mit diesen Einschränkungen können Sie Situationen wie die folgenden vermeiden:

• Pods, die keine spezielle Hardware wie GPUs oder TPUs benötigen, wählen Compute-Klassen aus, die diese Hardware anfordern.
• Eine nicht autorisierte Einheit erstellt oder ändert Compute-Klassen, um Zugriff auf Hardware zu erhalten, die für kritische Arbeitslasten reserviert ist.

In diesem Dokument wird ein Beispiel für eine ValidatingAdmissionPolicy verwendet, die häufige Arten von Missbrauch blockiert, z. B. ComputeClass-Toleranzen mit Platzhaltern oder die Auswahl bestimmter nicht zulässiger ComputeClasses. Sie können die ValidatingAdmissionPolicy ändern, um Anforderungen zu erfüllen, die für Ihre Organisation spezifisch sind, z. B. das Blockieren von Arbeitslasten bestimmter Teams, die ComputeClasses verwenden.

Ziele

• Verwenden Sie eine ValidatingAdmissionPolicy, um die ComputeClasses, die Pods in jedem Namespace auswählen können, auf eine genehmigte Liste zu beschränken.
• Verwenden Sie die rollenbasierte Zugriffssteuerung (Role-Based Access Control, RBAC), um einzuschränken, wer ComputeClasses in Ihren Clustern erstellen, ändern oder löschen kann.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

• Kubernetes Engine
• Google Workspace or Cloud Identity

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Nutzern von Google Cloud steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweis

Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Installieren Sie die Google Cloud CLI.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

Erstellen Sie ein Google Cloud Projekt oder wählen Sie eines aus.

Rollen, die zum Auswählen oder Erstellen eines Projekts erforderlich sind

• Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
• Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Projektersteller“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Weitere Informationen zum Zuweisen von Rollen

Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

• So erstellen Sie ein Google Cloud Projekt:

  gcloud projects create PROJECT_ID

  Ersetzen Sie PROJECT_ID durch einen Namen für das Google Cloud Projekt, das Sie erstellen.

• Wählen Sie das von Ihnen erstellte Google Cloud Projekt aus:

  gcloud config set project PROJECT_ID

  Ersetzen Sie PROJECT_ID durch den Namen Ihres Projekts in Google Cloud .

Wenn Sie für diese Anleitung ein vorhandenes Projekt verwenden, prüfen Sie, ob Sie die erforderlichen Berechtigungen haben. Wenn Sie ein neues Projekt erstellt haben, haben Sie bereits die erforderlichen Berechtigungen.

Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Projekt aktiviert ist.

Aktivieren Sie die Kubernetes Engine API:

Rollen, die zum Aktivieren von APIs erforderlich sind

Zum Aktivieren von APIs benötigen Sie die IAM-Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin), die die Berechtigung serviceusage.services.enable enthält. Weitere Informationen zum Zuweisen von Rollen

gcloud services enable container.googleapis.com

Installieren Sie die Google Cloud CLI.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

Erstellen Sie ein Google Cloud Projekt oder wählen Sie eines aus.

Rollen, die zum Auswählen oder Erstellen eines Projekts erforderlich sind

• Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
• Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Projektersteller“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Weitere Informationen zum Zuweisen von Rollen

Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

• So erstellen Sie ein Google Cloud Projekt:

  gcloud projects create PROJECT_ID

  Ersetzen Sie PROJECT_ID durch einen Namen für das Google Cloud Projekt, das Sie erstellen.

• Wählen Sie das von Ihnen erstellte Google Cloud Projekt aus:

  gcloud config set project PROJECT_ID

  Ersetzen Sie PROJECT_ID durch den Namen Ihres Projekts in Google Cloud .

Wenn Sie für diese Anleitung ein vorhandenes Projekt verwenden, prüfen Sie, ob Sie die erforderlichen Berechtigungen haben. Wenn Sie ein neues Projekt erstellt haben, haben Sie bereits die erforderlichen Berechtigungen.

Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Projekt aktiviert ist.

Aktivieren Sie die Kubernetes Engine API:

Rollen, die zum Aktivieren von APIs erforderlich sind

Zum Aktivieren von APIs benötigen Sie die IAM-Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin), die die Berechtigung serviceusage.services.enable enthält. Weitere Informationen zum Zuweisen von Rollen

gcloud services enable container.googleapis.com

1. Wenn Sie eine lokale Shell verwenden, installieren Sie die Komponente kubectl:

   gcloud components install kubectl

2. Sie benötigen einen GKE-Cluster, der Version 1.30 oder höher verwendet. Sie können für dieses Tutorial auch einen Autopilot-Cluster erstellen.
3. Konfigurieren Sie Ihren Cluster für Google Groups for RBAC:
   1. Richten Sie die Gruppe gke-security-groups in Ihrer Domain ein.
   2. Aktivieren Sie Google Groups for RBAC in Ihrem Cluster.

   Weitere Informationen finden Sie unter Google Groups einrichten.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle „Kubernetes Engine-Administrator“ (role/container.admin) für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen von RBAC-Richtlinien und Kubernetes-Objekten in Ihrem Cluster benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Umgebung vorbereiten

So bereiten Sie Ihren Cluster für die Erstellungs- und Überprüfungsaufgaben in diesem Tutorial vor:

1. Mit dem Cluster verbinden:

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

   Ersetzen Sie Folgendes:

   • CLUSTER_NAME: Der Name Ihres Clusters.
   • CONTROL_PLANE_LOCATION: Die Region oder Zone der Cluster-Steuerungsebene, z. B. us-central1 oder us-central1-a.

2. Erstellen Sie einen Namespace für dieses Tutorial. Sie können auch einen vorhandenen Namespace im Cluster verwenden.

   kubectl create namespace computeclass-vap-tutorial
   

3. Erstellen Sie eine RBAC-Richtlinie, die den Zugriff zum Verwalten von ValidatingAdmissionPolicies und ValidatingAdmissionPolicyBindings gewährt:

   1. Speichern Sie das folgende Manifest als 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
      

      Ersetzen Sie USER_ACCOUNT durch die E-Mail-Adresse Ihres Nutzerkontos.

   2. RBAC-Richtlinie erstellen:

      kubectl apply -f validatingadmissionpolicy-editor.yaml
      

4. Erstellen Sie eine ComputeClass in Ihrem Cluster. Wenn der Cluster bereits eine ComputeClass hat, überspringen Sie diesen Schritt.

   1. Speichern Sie das folgende Manifest als 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 erstellen:

      kubectl apply -f access-computeclass.yaml
      

ValidatingAdmissionPolicy erstellen

Wenn Sie die Compute-Klassen einschränken möchten, die Pods auswählen können, erstellen Sie eine ValidatingAdmissionPolicy und erzwingen sie in einem bestimmten Namespace. Mit der ValidatingAdmissionPolicy-Spezifikation steuern Sie, wie Pods Compute-Klassen auswählen können. Die folgenden Schritte zeigen, wie Sie diese Richtlinie erstellen und erzwingen:

1. Speichern Sie das folgende ValidatingAdmissionPolicy-Manifest als 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.
   

   Ersetzen Sie COMPUTECLASS_NAME durch den Namen einer ComputeClass, die Pods nicht auswählen sollen.

   Diese ValidatingAdmissionPolicy hat die folgenden Eigenschaften:

   • Trigger für statische Pods oder Pods in Deployments.

   • Sucht nach Pods, die eine der folgenden Aktionen ausführen:

     • Verwenden Sie eine Knotenauswahl oder eine Knotenaffinitätsregel, um explizit eine bestimmte unzulässige ComputeClass auszuwählen.
     • Verwenden Sie eine Toleranz, die einer Knoten-Markierung für eine bestimmte unzulässige Compute-Klasse entspricht.
     • Verwenden Sie eine Toleranz, die mit allen Knotenmarkierungen im Cluster übereinstimmt.

   Diese ValidatingAdmissionPolicy ist ein Beispiel. Sie können Ausdrücke verwenden, um die Richtlinie basierend auf Ihren eigenen Bedingungen auszulösen, z. B. um zu verhindern, dass Pods mit bestimmten Labels bestimmte Compute-Klassen auswählen.

2. ValidatingAdmissionPolicy erstellen:

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

3. Speichern Sie die folgende ValidatingAdmissionPolicyBinding als 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.
   

   Mit dieser ValidatingAdmissionPolicyBinding wird die ValidatingAdmissionPolicy aus dem vorherigen Schritt im Namespace computeclass-vap-tutorial erzwungen. Die Werte im Feld validationActions lehnen Pods oder Deployments ab, die gegen die ValidatingAdmissionPolicy verstoßen, und fügen dem Kubernetes-Audit-Log einen Eintrag hinzu.

4. Erstellen Sie die ValidatingAdmissionPolicyBinding:

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

RBAC-Richtlinien konfigurieren

Zusätzlich zur Verwendung einer ValidatingAdmissionPolicy, um zu verhindern, dass Arbeitslasten bestimmte ComputeClasses verwenden, sollten Sie RBAC verwenden, um zu verhindern, dass nicht autorisierte Principals die ComputeClasses in Ihrem Cluster erstellen und ändern. Die folgenden Schritte zeigen, wie Sie einer bestimmten Nutzergruppe mithilfe von Google Groups for RBAC Zugriff auf ComputeClasses gewähren:

1. Gruppe für ComputeClass-Bearbeiter erstellen:

   1. Rufen Sie in der Google Admin-Konsole die Seite Gruppen auf.

      Zu Google Groups

   2. Klicken Sie auf Gruppe erstellen.

   3. Gehen Sie auf der Seite Gruppendetails so vor:

      1. Geben Sie im Feld Gruppenname den Wert computeclass-editors ein.
      2. Geben Sie im Feld Gruppen-E-Mail computeclass-editors an.
      3. Klicken Sie das Kästchen Sicherheit an.
      4. Klicken Sie auf Weiter.

   4. Prüfen Sie auf der Seite Zugriffstyp in der Spalte Gruppenmitglieder, ob das Kästchen Wer kann die Mitgliederliste sehen? angeklickt ist.

   5. Klicken Sie auf Gruppe erstellen.

   6. Klicken Sie im Navigationsmenü auf Verzeichnis > Gruppen.

   7. Bewegen Sie den Mauszeiger auf die Zeile gke-security-groups und klicken Sie dann auf Mitglieder hinzufügen.

   8. Geben Sie im Dialogfeld Mitglieder zu gke-security-groups hinzufügen computeclass-editors an und wählen Sie die Gruppe aus den Ergebnissen aus.

   9. Klicken Sie auf Zu Gruppe hinzufügen.

2. Fügen Sie der Gruppe computeclass-editors die E‑Mail-Adressen autorisierter Nutzer hinzu.

3. Speichern Sie die folgende ClusterRole als 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 erstellen:

   kubectl apply -f computeclass-editor-clusterrole.yaml
   

5. Speichern Sie das folgende ClusterRoleBinding als 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
   

   Ersetzen Sie GROUP_DOMAIN durch den Domainnamen der Gruppe computeclass-editors.

6. ClusterRoleBinding erstellen:

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

Einschränkungen prüfen

In den folgenden Abschnitten wird beschrieben, wie Sie überprüfen, ob die Einschränkungen, die Sie in den vorherigen Abschnitten konfiguriert haben, wie erwartet funktionieren. Wenn Sie eigene Einschränkungen in ValidatingAdmissionPolicies oder RBAC-Richtlinien konfigurieren, testen Sie die Einschränkungen, indem Sie eine Arbeitslast erstellen, die gegen diese Richtlinien verstößt.

ValidatingAdmissionPolicy prüfen

1. Speichern Sie eines der folgenden Manifeste, die jeweils gegen eine andere Bedingung der ValidatingAdmissionPolicy verstoßen:

   • Deployment, das einen Knotenselektor verwendet, um eine nicht zulässige ComputeClass auszuwählen:

     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
     

   • Bereitstellung mit einer Toleranz für eine nicht zulässige 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
     

   • Deployment mit einer Knotenaffinitätsregel für eine nicht zulässige 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 mit einer Toleranz für jede Knotenmarkierung im Cluster:

     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. Testarbeitslast erstellen:

   kubectl apply -f PATH_TO_WORKLOAD_MANIFEST
   

   Die Ausgabe sieht etwa so aus:

   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-Konfiguration überprüfen

So prüfen Sie Ihre RBAC-Konfiguration:

1. Authentifizieren Sie sich beim Cluster mit den Anmeldedaten eines Nutzers, der Mitglied der Gruppe computeclass-editors ist.

2. Prüfen Sie, ob der Nutzer eine ComputeClass erstellen kann:

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

   Ersetzen Sie MEMBER_USER durch die E-Mail-Adresse eines Nutzers, der Mitglied der Gruppe ist.

   Die Ausgabe lautet yes.

3. Authentifizieren Sie sich beim Cluster mit den Anmeldedaten eines Nutzers, der kein Mitglied der Gruppe computeclass-editors ist.

4. Prüfen Sie, ob der Nutzer eine ComputeClass erstellen kann:

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

   Ersetzen Sie NON_MEMBER_USER durch die E-Mail-Adresse eines Nutzers, der kein Mitglied der Gruppe ist.

   Die Ausgabe lautet no.

Wenn die Ausgabe des Befehls kubectl auth can-i für einen Nutzer, der kein Mitglied der Gruppe ist, yes lautet, prüfen Sie Folgendes:

• Die Gruppe computeclass-editors ist Mitglied der Gruppe gke-security-groups.
• Die E-Mail-Adresse der Gruppe in Ihrer ClusterRoleBinding ist die genaue E-Mail-Adresse der Gruppe, z. B. [e-mail].

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Wenn Sie die ValidatingAdmissionPolicy- und RBAC-Richtlinien in dieser Anleitung in einem Produktionscluster bereitstellen, blockiert GKE eingehende Pods und API-Anfragen, die gegen die Richtlinien verstoßen. Wenn Sie diese Richtlinien aktiv lassen möchten, überspringen Sie diesen Abschnitt. In den folgenden Abschnitten wird beschrieben, wie Sie das Projekt oder einzelne Ressourcen löschen, wenn Sie diese Anleitung in einer Lern- oder Testumgebung durchgearbeitet haben.

Projekt löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

• Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
• Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, zum Beispiel eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, anstatt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Google Cloud -Projekt löschen:

gcloud projects delete PROJECT_ID

Einzelne Ressourcen löschen

1. Löschen Sie die von Ihnen erstellte ComputeClass:

   kubectl delete computeclass access-restriction-class
   

2. Löschen Sie die ValidatingAdmissionPolicy und die ValidatingAdmissionPolicyBinding:

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

3. Löschen Sie die ClusterRoles und ClusterRoleBindings:

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

4. Löschen Sie den Beispiel-Namespace:

   kubectl delete namespace computeclass-vap-tutorial
   

Nächste Schritte

• Best Practices für die Clustersicherheit
• Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center