ComputeClass の変更と選択に対するアクセスを制限する

環境を準備する

このチュートリアルの作成タスクと検証タスク用にクラスタを準備する手順は次のとおりです。

1. クラスタに接続します。

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

   次のように置き換えます。

   • CLUSTER_NAME: クラスタの名前。
   • CONTROL_PLANE_LOCATION: クラスタ コントロール プレーンのリージョンまたはゾーン（us-central1、us-central1-a など）。

2. このチュートリアルで使用する Namespace を作成します。クラスタ内の既存の Namespace を使用することもできます。

   kubectl create namespace computeclass-vap-tutorial
   

3. ValidatingAdmissionPolicies と ValidatingAdmissionPolicyBindings の管理権限を付与する RBAC ポリシーを作成します。

   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 を作成する

Pod が選択できる ComputeClass を制限するには、ValidatingAdmissionPolicy を作成して、特定の Namespace で適用します。ValidatingAdmissionPolicy 仕様を使用して、Pod が ComputeClass を選択する方法を制御します。このポリシーを作成して適用する手順は次のとおりです。

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 は、Pod が選択できないようにする ComputeClass の名前に置き換えます。

   この ValidatingAdmissionPolicy には次のプロパティがあります。

   • 静的 Pod または Deployment 内の Pod のトリガー。

   • 次のいずれかの条件を満たす Pod を検索します。

     • ノードセレクタまたはノード アフィニティ ルールを使用して、特定の許可されていない ComputeClass を明示的に選択します。
     • 特定の許可されていない ComputeClass のノード taint に対応する toleration を使用します。
     • クラスタ内のすべてのノード taint と一致する toleration を使用します。

   この ValidatingAdmissionPolicy は一例です。式を使用すると、特定のラベルを持つ Pod が特定の ComputeClass を選択できないようにするなど、独自の条件に基づいてポリシーをトリガーできます。

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 Namespace で適用します。validationActions フィールドの値は、ValidatingAdmissionPolicy に違反する Pod または Deployment を拒否し、Kubernetes 監査ログにエントリを追加します。

4. ValidatingAdmissionPolicyBinding を作成します。

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

RBAC ポリシーを構成する

ValidatingAdmissionPolicy を使用してワークロードが特定の ComputeClass を使用できないようにするだけでなく、RBAC を使用して、承認されていないプリンシパルがクラスタ内の ComputeClass を作成および変更できないようにします。次の手順では、RBAC 向け Google グループを使用して、特定のユーザー グループに ComputeClass へのアクセス権を付与する方法について説明します。

1. ComputeClass エディタのグループを作成します。

   1. Google 管理コンソールで、[グループ] ページに移動します。

      グループに移動

   2. [グループを作成] をクリックします。

   3. [グループの詳細] ページで、次の操作を行います。

      1. [グループ名] フィールドに computeclass-editors を指定します。
      2. [グループのメールアドレス] フィールドに computeclass-editors を指定します。
      3. [セキュリティ] チェックボックスをオンにします。
      4. [次へ] をクリックします。

   4. [アクセスタイプ] ページの [グループ メンバー] 列で、[メンバーを閲覧できるユーザー] チェックボックスがオンになっていることを確認します。

   5. [グループを作成] をクリックします。

   6. ナビゲーション メニューで、[ディレクトリ] > [グループ] をクリックします。

   7. [gke-security-groups] 行にカーソルを合わせて、[メンバーを追加] をクリックします。

   8. [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 を選択する Deployment:

     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 の容認がある Deployment:

     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
     

   • 許可されていない ComputeClass のノード アフィニティ ルールがある Deployment:

     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 のグループのメールアドレスは、computeclass-editors@example.com などのグループの正確なメールアドレスです。