Kubernetes Validating Admission Policy | Kubernetes

• Kubernetes Validating Admission Policy | Kubernetes

1. O que são Validating Admission Controllers?

Eles são um mecanismo no API Server do Kubernetes que valida requisições antes que elas sejam aplicadas ou persistidas no cluster. Isso permite que você controle o comportamento e as configurações dos objetos no cluster.

• Por que usá-los?
  • Garantir conformidade com políticas organizacionais (por exemplo, uso de namespaces obrigatórios, restrições de segurança, etc.).
  • Impedir a criação de recursos mal configurados ou não seguros.
  • Melhorar a segurança e a estabilidade do cluster.

---

2. Onde os Validating Admission Controllers agem?

No ciclo de vida de uma requisição ao Kubernetes:

1. Recepção pelo API Server:

   • O usuário (ou uma aplicação) envia uma requisição HTTP ao API Server.

2. Autenticação:

   • O Kubernetes verifica se o cliente está autenticado.

3. Autorização:

   • O Kubernetes verifica se o cliente tem permissão para executar a operação.

4. Mutating Admission Controllers (opcional):

   • Plugins podem modificar a requisição, adicionando ou alterando valores.

5. Validating Admission Controllers:

   • A requisição é validada por meio de webhooks configurados.
   • Se a validação falhar, a requisição é rejeitada.

6. Persistência no etcd:

   • Se a validação for bem-sucedida, a alteração é persistida no etcd e aplicada ao cluster.

---

3. Como Funcionam os Validating Admission Controllers?

3.1 Estrutura Geral

O Kubernetes chama webhooks configurados para validar requisições. Esses webhooks são serviços externos que:

1. Recebem uma solicitação JSON com detalhes da requisição.
2. Avaliam se a requisição é válida ou não.
3. Respondem ao Kubernetes com um resultado:
   • allowed: true → Permitir a requisição.
   • allowed: false → Rejeitar a requisição com uma mensagem de erro.

---

3.2 Exemplo de Fluxo

Imagine que você quer garantir que todos os Pods criados no cluster tenham uma anotação específica chamada team.

1. Um usuário cria um Pod:

   apiVersion: v1
   kind: Pod
   metadata:
     name: example-pod
     namespace: default
   spec:
     containers:
     - name: nginx
       image: nginx

2. O Validating Admission Controller intercepta a requisição antes que ela seja salva no etcd.

3. O Webhook verifica se a anotação team está presente:

   • Se estiver ausente:
     • O Webhook responde com allowed: false e uma mensagem de erro.
   • Se estiver presente:
     • O Webhook responde com allowed: true.

---

3.3 Implementação Detalhada

Para implementar um Validating Admission Controller, siga estes passos:

---

Passo 1: Criar o Webhook

Um webhook é um serviço HTTP que recebe e processa solicitações de validação. Vamos usar um exemplo simples em Python:

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/validate', methods=['POST'])
def validate():
    admission_review = request.json

    # Extrair as informações do objeto
    obj = admission_review['request']['object']
    metadata = obj.get('metadata', {})
    annotations = metadata.get('annotations', {})

    # Verificar se a anotação 'team' está presente
    if 'team' not in annotations:
        return jsonify({
            "response": {
                "uid": admission_review['request']['uid'],
                "allowed": False,
                "status": {
                    "message": "Annotation 'team' is required."
                }
            }
        })

    # Aprovar a requisição
    return jsonify({
        "response": {
            "uid": admission_review['request']['uid'],
            "allowed": True
        }
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=443, ssl_context=('cert.pem', 'key.pem'))

Passo 2: Configurar o Webhook no Cluster

Crie um recurso ValidatingWebhookConfiguration para informar ao Kubernetes sobre o Webhook.

apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata:
  name: validate-pod-annotations
webhooks:
  - name: validate-annotations.example.com
    clientConfig:
      service:
        name: validation-service
        namespace: default
        path: /validate
      caBundle: <Base64-encoded-CA-cert>
    rules:
      - apiGroups: [""]
        apiVersions: ["v1"]
        operations: ["CREATE", "UPDATE"]
        resources: ["pods"]
    admissionReviewVersions: ["v1"]
    sideEffects: None

Passo 3: Implantar o Serviço

Implante o serviço de Webhook no cluster. Você precisará:

1. Um Deployment:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: validation-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: validation-service
     template:
       metadata:
         labels:
           app: validation-service
       spec:
         containers:
         - name: webhook
           image: your-webhook-image
           ports:
           - containerPort: 443
           volumeMounts:
           - mountPath: /certs
             name: webhook-cert
         volumes:
         - name: webhook-cert
           secret:
             secretName: webhook-cert

2. Um Service para expor o webhook:

   apiVersion: v1
   kind: Service
   metadata:
     name: validation-service
   spec:
     ports:
       - port: 443
         targetPort: 443
     selector:
       app: validation-service

3. Certificados TLS válidos: Admission Controllers exigem que os webhooks usem TLS. Você pode gerar certificados usando o cert-manager ou ferramentas como openssl.

---

4. Casos de Uso Reais

1. Segurança:

   • Impedir a criação de Pods com privilégios elevados (securityContext.privileged: true).
   • Restringir o uso de imagens de contêiner não verificadas.

2. Conformidade:

   • Garantir que todos os objetos tenham anotações ou rótulos obrigatórios.
   • Validar que os namespaces seguem um padrão de nomenclatura.

3. Boas Práticas:

   • Bloquear recursos com valores de CPU/memória ausentes ou inadequados.
   • Validar que apenas certas contas de serviço podem executar determinadas operações.