Este documento foi traduzido usando tecnologia de tradução automática de máquina. Sempre trabalhamos para apresentar traduções precisas, mas não oferecemos nenhuma garantia em relação à integridade, precisão ou confiabilidade do conteúdo traduzido. Em caso de qualquer discrepância, a versão original em inglês prevalecerá e constituirá o texto official.

Esta é uma documentação não divulgada para Admission Controller 1.34-dev.

Tarefas comuns

Isso descreve tarefas comuns para depois que você instalar SUSE Security Admission Controller em seu cluster Kubernetes.

As tarefas separadas estão em uma ordem lógica.

Testar Políticas

Admission Controller usa duas ferramentas para ajudá-lo a encontrar políticas e testá-las localmente:

  • Hub de Artefatos, usando seu filtro de pacotes para políticas Admission Controller

  • kwctl, uma ferramenta CLI

Hub de Artefatos

O Hub de Artefatos hospeda políticas contribuídas pela comunidade. Por exemplo, você pode encontrar substitutos para as Políticas de Segurança de Pod Kubernetes descontinuadas, criadas pelos Admission Controller desenvolvedores.

Como mostrado na captura de tela abaixo, uma vez que você encontre uma política de interesse, selecione o botão Install e use kwctl para buscar a política para seu cluster.

Hub de Artefatos

Anteriormente, as políticas Admission Controller podiam ser encontradas no Admission Controller Hub de Políticas. Isso foi descontinuado. As políticas agora estão disponíveis no https://artifacthub.io.

kwctl Ferramenta CLI

kwctl é a ferramenta CLI do Admission Controller para autores de políticas e administradores de cluster testarem políticas antes de aplicá-las a um cluster Kubernetes.

Esta ferramenta possui uma interface semelhante à ferramenta CLI do docker.

Casos de uso

Você pode usar kwctl para ajudar nestes cenários:

Como autor de políticas

  • Teste de ponta a ponta da sua política: Teste sua política contra requisições Kubernetes elaboradas e assegure-se de que sua política se comporta como você espera. Você pode até testar políticas contextuais que requerem acesso a um cluster em execução.

  • Incorporar metadados no seu módulo Wasm: O binário contém anotações das permissões que precisa para ser executado. Você pode inspecionar e modificar essas anotações com kwctl.

  • Publicar políticas em registros OCI: O binário é um objeto OCI totalmente compatível e pode ser armazenado em registros OCI.

Como administrador de cluster

  • Inspecionar políticas remotas: Dada uma política em um registro OCI ou em um servidor HTTP, mostre todas as informações estáticas sobre a política.

  • Execução simulada de uma política no seu cluster: Teste a política contra requisições Kubernetes elaboradas e assegure-se de que a política se comporta como você espera, com os dados de entrada que você fornece. Você também pode testar políticas contextuais que requerem acesso a um cluster em execução no modo de execução simulada.

  • Gere a estrutura inicial de ClusterAdmissionPolicy para sua política: Gere um arquivo YAML com todas as configurações necessárias, que podem ser aplicadas ao seu cluster Kubernetes usando kubectl.

Instalação

kwctl binários para os lançamentos estáveis estão disponíveis no repositório do GitHub. Para construir kwctl do repositório do GitHub, você precisa de um ambiente de desenvolvimento Rust.

Uso

Você pode listar todas as opções e subcomandos kwctl executando o seguinte comando:

$ 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

Aqui estão alguns exemplos de uso de comandos:

  • Liste as políticas: lista todas as políticas armazenadas no registro local kwctl

    • Comando: kwctl policies

  • Obtenha a política: baixe e armazene a política dentro do repositório local kwctl

    • Comando: 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 |
+--------------------------------------------------------------+----------+---------------+--------------+----------+

  • Entenda como a política funciona: inspecione os metadados da política

    • Comando: 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.

  • Avalie a política: Avalie a política e, se disponível, encontre os valores de configuração corretos para atender aos seus requisitos.

    Você precisa ter alguma familiaridade com as APIs REST do Kubernetes.

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

    • Cenário 1:

      • Solicitação de avaliação: Crie um pod sem contêiner 'privilegiado'

        $ 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":""}}

      • Comando equivalente com o binário da política baixado:

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

      • Resultado: A política permite a solicitação

    • Cenário 2:

      • Solicitação de avaliação: Crie um pod com pelo menos um contêiner 'privilegiado'

      • Comando:

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

      • Comando equivalente com o binário da política baixado: kwctl run file://$PWD/pod-privileged-policy.wasm -r privileged-pod-request.json

      • Saída:

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

      • Resultado: A política nega a solicitação

    Para exemplos mais complexos, veja o post do blog Introduzindo kwctl para Administradores do Kubernetes.

Fazer cumprir Políticas

Você faz cumprir uma política definindo um ClusterAdmissionPolicy e, em seguida, implantando-a em seu cluster usando kubectl.

kwctl ajuda a gerar um ClusterAdmissionPolicy a partir da política que você deseja fazer cumprir.

Depois de gerar o ClusterAdmissionPolicy e aplicá-lo ao seu cluster, você pode seguir os passos descritos no Início rápido abaixo:

  • Gere o ClusterAdmissionPolicy a partir da política manifest e salve-o em um arquivo

    • Comando: 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

    Por padrão, o valor do name é definido como generated-policy. Você pode querer editá-lo antes de implantar o ClusterAdmissionPolicy. O nome no exemplo anterior é definido como privileged-pods.

  • Implante o ClusterAdmissionPolicy em seu cluster Kubernetes

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

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

Após implantar o ClusterAdmissionPolicy, todas as solicitações enviadas ao seu cluster são avaliadas pela política se estiverem dentro do escopo da política.

Próximas etapas