Ce document a été traduit à l'aide d'une technologie de traduction automatique. Bien que nous nous efforcions de fournir des traductions exactes, nous ne fournissons aucune garantie quant à l'exhaustivité, l'exactitude ou la fiabilité du contenu traduit. En cas de divergence, la version originale anglaise prévaut et fait foi.

Il s'agit d'une documentation non publiée pour Admission Controller 1.34-dev.

Tâches courantes

Cela décrit les tâches courantes après que vous installiez SUSE Security Admission Controller dans votre cluster Kubernetes.

Les tâches séparées sont dans un ordre logique.

Tester les stratégies

Admission Controller utilise deux outils pour vous aider à trouver des stratégies et à les tester localement :

  • Artifact Hub, en utilisant leur filtre de paquet pour les stratégies Admission Controller

  • kwctl, un outil CLI

Artifact Hub

Artifact Hub héberge des stratégies contribuées par la communauté. Par exemple, vous pouvez trouver des substituts aux stratégies de sécurité de pod Kubernetes dont la prise en charge a cessé, créées par les développeurs Admission Controller.

Comme indiqué dans la capture d’écran ci-dessous, une fois que vous trouvez une stratégie d’intérêt, sélectionnez le bouton Install et utilisez kwctl pour récupérer la stratégie pour votre cluster.

Artifact Hub

Auparavant, les stratégies Admission Controller pouvaient être trouvées au Admission Controller Hub de stratégies. Ceci a été retiré. Les stratégies sont désormais disponibles à partir de https://artifacthub.io.

kwctl outil CLI

kwctl est l’outil CLI de Admission Controller pour les auteurs de stratégies et les administrateurs de clusters afin de tester les stratégies avant leur application à un cluster Kubernetes.

Cet outil a une interface similaire à celle de l’outil CLI docker.

Cas pratiques d’utilisation

Vous pouvez utiliser kwctl pour vous aider dans ces scénarios :

En tant qu’auteur de stratégie

  • Tests de bout en bout de votre stratégie : Testez votre stratégie contre des requêtes Kubernetes élaborées et assurez-vous que votre stratégie se comporte comme vous l’attendez. Vous pouvez même tester des stratégies contextuelles qui nécessitent un accès à un cluster en cours d’exécution.

  • Intégrer des métadonnées dans votre module Wasm : Le binaire contient des annotations des permissions nécessaires à son exécution. Vous pouvez inspecter et modifier ces annotations avec kwctl.

  • Publier des stratégies dans des registres OCI : Le binaire est un objet OCI entièrement conforme et peut être stocké dans des registres OCI.

En tant qu’administrateur de cluster

  • Inspecter des stratégies distantes : Étant donné une stratégie dans un registre OCI ou sur un serveur HTTP, montrez toutes les informations statiques concernant la stratégie.

  • Exécution à blanc d’une stratégie dans votre cluster : Testez la stratégie contre des requêtes Kubernetes élaborées et assurez-vous que la stratégie se comporte comme vous l’attendez en fonction des données d’entrée que vous fournissez. Vous pouvez également tester des stratégies contextuelles qui nécessitent un accès à un cluster en cours d’exécution en mode d’exécution à blanc.

  • Générer l’ossature initiale ClusterAdmissionPolicy pour votre stratégie : Générer un fichier YAML avec tous les paramètres requis, qui peuvent être appliqués à votre cluster Kubernetes en utilisant kubectl.

Installation

Les binaires kwctl pour les versions stables sont disponibles sur le dépôt GitHub. Pour construire kwctl à partir du dépôt GitHub, vous avez besoin d’un environnement de développement Rust.

Syntaxe

Vous pouvez lister toutes les options et sous-commandes kwctl en exécutant la commande suivante :

$ kwctl --help
kwctl 0.2.5
Admission Controller Developers <cncf-kubewarden-maintainers@lists.cncf.io>
Tool to manage Admission Controller policies

USAGE:
    kwctl [OPTIONS] <SUBCOMMAND>

OPTIONS:
    -h, --help       Print help information
    -v               Increase verbosity
    -V, --version    Print version information

SUBCOMMANDS:
    annotate       Add Admission Controller metadata to a WebAssembly module
    completions    Generate shell completions
    digest         Fetch the digest of its OCI manifest
    help           Print this message or the help of the given subcommand(s)
    inspect        Inspect Admission Controller policy
    policies       Lists all downloaded policies
    pull           Pulls a Admission Controller policy from a given URI
    push           Pushes a Admission Controller policy to an OCI registry
    rm             Removes a Admission Controller policy from the store
    run            Runs a Admission Controller policy from a given URI
    scaffold       Scaffold a Kubernetes resource or configuration file
    verify         Verify a Admission Controller policy from a given URI using Sigstore

Voici quelques exemples d’utilisation de commandes :

  • Lister les stratégies : liste toutes les stratégies stockées dans le registre local kwctl

    • Commande : kwctl policies

  • Obtenir la stratégie : télécharger et stocker la stratégie dans le registre local kwctl

    • Commande : kwctl pull <policy URI>

      $ kwctl pull registry://ghcr.io/kubewarden/policies/pod-privileged:v0.1.9

$ kwctl policies
+--------------------------------------------------------------+----------+---------------+--------------+----------+
| Policy                                                       | Mutating | Context aware | SHA-256      | Size     |
+--------------------------------------------------------------+----------+---------------+--------------+----------+
| registry://ghcr.io/kubewarden/policies/pod-privileged:v0.1.9 | no       | no            | 59e34f482b40 | 21.86 kB |
+--------------------------------------------------------------+----------+---------------+--------------+----------+

  • Comprendre comment la stratégie fonctionne : inspecter les métadonnées de la stratégie

    • Commande : kwctl inspect <policy URI>

        $ kwctl inspect registry://ghcr.io/kubewarden/policies/pod-privileged:v0.1.9
  Details
  title:              pod-privileged
  description:        Limit the ability to create privileged containers
  author:             Flavio Castelli
  url:                https://github.com/kubewarden/pod-privileged-policy
  source:             https://github.com/kubewarden/pod-privileged-policy
  license:            Apache-2.0
  mutating:           false
  context aware:      false
  execution mode:     kubewarden-wapc
  protocol version:   1

  Annotations
  io.kubewarden.kwctl 0.1.9

  Rules
  ────────────────────
  ---
  - apiGroups:
      - ""
    apiVersions:
      - v1
    resources:
      - pods
    operations:
      - CREATE
  ────────────────────

  Usage
  This policy doesn't have a configuration. Once enforced, it will reject
  the creation of Pods that have at least a privileged container defined.

  • Évaluer la stratégie : Évaluer la stratégie et, si disponible, trouver les bonnes valeurs de configuration pour correspondre à vos exigences.

    Vous devez avoir une certaine familiarité avec les API REST Kubernetes.

    • Commande : kwctl run -r <"Kubernetes Admission request" file path> -s <"JSON document" file path> <policy URI>

    • Scénario 1 :

      • Demande d’évaluation : Créer un pod sans conteneur 'privilégié'

        $ kwctl run registry://ghcr.io/kubewarden/policies/pod-privileged:v0.1.9 -r unprivileged-pod-request.json
{"uid":"C6E115F4-A789-49F8-B0C9-7F84C5961FDE","allowed":true,"status":{"message":""}}

      • Commande équivalente avec le binaire de stratégie téléchargé :

        `$ kwctl run file://$PWD/pod-privileged-policy.wasm -r unprivileged-pod-request.json
{"uid":"C6E115F4-A789-49F8-B0C9-7F84C5961FDE","allowed":true,"status":{"message":""}}

      • Résultat : La stratégie permet la demande

    • Scénario 2 :

      • Demande d’évaluation : Créer un pod avec au moins un conteneur 'privilégié'

      • Commande :

        kwctl run registry://ghcr.io/kubewarden/policies/pod-privileged:v0.1.9 -r privileged-pod-request.json

      • Commande équivalente avec le binaire de stratégie téléchargé : kwctl run file://$PWD/pod-privileged-policy.wasm -r privileged-pod-request.json

      • Sortie :

        {
  "uid": "8EE6AF8C-C8C8-45B0-9A86-CB52A70EC50D",
  "allowed": false,
  "status": { "message": "User 'kubernetes-admin' cannot schedule privileged containers" }
}

      • Résultat : La stratégie refuse la demande

    Pour des exemples plus complexes, consultez l’article de blog Présentation de kwctl aux administrateurs Kubernetes.

Appliquer les stratégies

Vous appliquez une stratégie en définissant un ClusterAdmissionPolicy puis en la déployant sur votre cluster à l’aide de kubectl.

kwctl aide à générer un ClusterAdmissionPolicy à partir de la stratégie que vous souhaitez appliquer.

Après avoir généré le ClusterAdmissionPolicy et l’avoir appliqué à votre cluster, vous pouvez suivre les étapes décrites dans le Démarrage rapide ci-dessous :

  • Générez le ClusterAdmissionPolicy à partir de la stratégie manifest et enregistrez-le dans un fichier

    • Commande : kwctl scaffold manifest -t ClusterAdmissionPolicy <policy URI> > <"policy name".yaml>

      $ kwctl scaffold manifest -t ClusterAdmissionPolicy registry://ghcr.io/kubewarden/policies/pod-privileged:v0.1.9
---
apiVersion: policies.kubewarden.io/v1alpha2
kind: ClusterAdmissionPolicy
metadata:
  name: privileged-pods
spec:
  module: "registry://ghcr.io/kubewarden/policies/pod-privileged:v0.1.9"
  settings: {}
  rules:
    - apiGroups:
        - ""
      apiVersions:
        - v1
      resources:
        - pods
      operations:
        - CREATE
  mutating: false

    Par défaut, la valeur du name est définie sur generated-policy. Vous voudrez peut-être l’éditer avant de déployer le ClusterAdmissionPolicy. Le nom dans l’exemple précédent est défini sur privileged-pods.

  • Déployez le ClusterAdmissionPolicy sur votre cluster Kubernetes

    • Commande : kubectl apply -f <"policy name".yaml>

      $ kubectl apply -f pod-privileged-policy.yaml
clusteradmissionpolicy.policies.kubewarden.io/privileged-pods created

Après avoir déployé le ClusterAdmissionPolicy, toutes les requêtes envoyées à votre cluster sont évaluées par la stratégie si elles sont dans le champ d’application de la stratégie.

Étapes suivantes