Container Service for Kubernetes:Configure Pod security policies

Installer et configurer ack-policy-external-provider

1. Sur la page ACK Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Add-ons .

2. Recherchez ack-policy-external-provider et suivez les instructions affichées pour terminer la configuration.

   • ProviderPodNumber : nombre d'instances du composant.

   • ProtectedKinds : ajoutez les types de ressources correspondant aux CRD que vous souhaitez protéger.

     La protection contre la suppression des CRD nécessite de vérifier si des instances du type de ressource existent dans le cluster. Conformément au principe du moindre privilège, ack-policy-external-provider ne dispose pas des autorisations de requête requises par défaut et doit être configuré manuellement.

     Définissez ProviderPodNumber (nombre de réplicas, valeur par défaut : 1). Dans la section ProtectedKinds, saisissez les noms des types de ressources (par exemple pods, policies ou customresources). Cliquez sur Add pour ajouter plusieurs entrées, ou sur Delete pour supprimer une entrée. Cliquez sur OK.

Définition de l'API et paramètres

ack-policy-external-provider implémente un fournisseur de données externes Gatekeeper standard. Dans un modèle de politique Rego, vous pouvez envoyer une demande de requête de ressource à ce composant en appelant la fonction external_data et en spécifiant provider: ack-policy-external-data-provider.

Les paramètres de la demande sont définis au format JSON. Voici quelques exemples.

// Example 1
{
  "action": "ListK8sResource",
  "namespaced": false,
  "group": "",
  "version": "v1",
  "resource": "persistentvolumeclaims"
  "requestID": review.uid,
  "userInfo": review.userInfo,
  "requestFrom": "PVCProtector",
  "labelSelector": "protected",
  "limit": 1
}
// Example 2
{
  "action": "GetK8sResource",
  "namespaced": true,
  "namespace": "default",
  "group": "apps",
  "version": "v1",
  "resource": "deployments",
  "requestID": review.uid,
  "userInfo": review.userInfo,
  "requestFrom": "FinOpsPolicy",
  "labelSelector": "protected",
  "limit": 1
}

Le tableau suivant décrit les principaux paramètres.

Exemple : Empêcher la suppression d'un CRD

Cet exemple montre comment utiliser ack-policy-external-provider pour mettre en œuvre une politique avancée courante : interdire la suppression d'une CustomResourceDefinition (CRD) si des instances de ressources personnalisées (CR) associées existent toujours.

Cette politique est une règle intégrée et ne nécessite aucun déploiement manuel. Cette section est fournie à titre de démonstration uniquement.

• Logique de la politique

  • Déclencheur : Gatekeeper détecte une opération DELETE sur un CRD.

  • Requête : les politiques Rego utilisent external_data pour appeler ack-policy-external-provider.

  • Vérification : sur la base des paramètres de la demande, le composant ack-policy-external-provider interroge le cluster pour vérifier si des instances CR correspondantes existent.

  • Décision : si le résultat de la requête renvoie au moins une instance CR, ack-policy-external-provider renverra le résultat à la politique Rego, et la politique finira par deny (rejeter) cette opération de suppression.

• Modèle de politique (ConstraintTemplate)

  Définit la logique de la politique.

  apiVersion: templates.gatekeeper.sh/v1beta1
  kind: ConstraintTemplate
  metadata:
    name: blockcrddeletion
    annotations:
      meta.helm.sh/release-name: gatekeeper
      meta.helm.sh/release-namespace: kube-system
      metadata.gatekeeper.sh/version: 1.0.0
    labels:
      app.kubernetes.io/managed-by: Helm
  spec:
    crd:
      spec:
        names:
          kind: BlockCrdDeletion
        validation:
          legacySchema: true
    targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package block_crd_deletion
        violation[{"msg": msg}] {
          before(input.review.operation)
          response := handle(input.review)
          msg := after(response)
        }
  
        before(operation) {
          operation == "DELETE"
        }
  
        handle(review) = response {
          customrequest := {
            "action": "ListK8sResource",
            "namespaced": false,
            "group": review.object.spec.group,
            "version": "",
            "resource": review.object.spec.names.plural,
            "requestID": review.uid,
            "userInfo": review.userInfo,
            "requestFrom": "BlockCrdDeletion",
            "labelSelector": "protected",
            "limit": 1
          }
          request_keys := [json.marshal(customrequest)]
          response := external_data({
            "provider": "ack-policy-external-data-provider",
            "keys": request_keys
          })
        }
  
        after(response) = msg {
          count(response.responses[0]) > 0
          msg := sprintf(
            "The CRD %v is not allowed to be deleted. Reason: It is not allowed to delete a CRD object when it contains a collection of custom resources. Current existing custom resources: %v, etc.",
            [input.review.name, response.responses[0][0]]
          )
        }

• Instance de politique (Constraint)

  Applique le modèle à des ressources spécifiques. Cet exemple applique la politique à tous les CRD.

  apiVersion: constraints.gatekeeper.sh/v1beta1
  kind: BlockCrdDeletion
  metadata:
    name: block-crd-deletion-rule
  spec:
    enforcementAction: deny
    match:
      kinds:
      - apiGroups:
        - '*'
        kinds:
        - CustomResourceDefinition

• Vérifier le résultat

  1. Créez un CRD de test et une instance CR correspondante.

     # Create a CRD
     apiVersion: apiextensions.k8s.io/v1
     kind: CustomResourceDefinition
     metadata:
       name: simplestthings.example.com
     spec:
       group: example.com
       scope: Namespaced
       names:
         plural: simplestthings
         singular: simplestthing
         kind: SimplestThing
       versions:
         - name: v1
           served: true
           storage: true
           schema:
             openAPIV3Schema:
               type: object
               properties:
                 spec:
                   type: object
                   properties:
                     message:
                       type: string
     ---
     # Create a CR instance
     apiVersion: example.com/v1
     kind: SimplestThing
     metadata:
       name: my-simple-thing
       namespace: default
       labels:
         protected: "false"
     spec:
       message: "Hello"

  2. Tentez de supprimer le CRD.

     kubectl delete crd simplestthings.example.com

  3. Vérifiez que la politique bloque la suppression et renvoie un message d'erreur clair.

     Sortie attendue :

     Error from server (Forbidden): admission webhook "delete.validation.gatekeeper.sh" denied the request: [block-crd-deletion-rule] The CRD simplestthings.example.com is not allowed to be deleted. Reason: It is not allowed to delete a CRD object when it contains a collection of custom resources. Current existing custom resources: my-simple-thing, etc.