Skip to content

Tema:

Politicas de manifiestos

Introducción

En la siguiente guia vamos a utilizar conftest para validar politicas que son consideradas como buenas practicas en un archivo yaml que es un despliegue de kubernetes.

Objetivo

Objetivo General:

  • El objetivo de la practica consiste en validar manifiestos de kubernetes con la herramienta conftest para asegurarnos que los mismos cumplan con las mejoras practicas antes de llevarlos a un ambiente productivo.

Desarrollo del Tema

Conftest y la validación de buenas prácticas en Kubernetes

¿Qué es Conftest?

  • Conftest es una herramienta de línea de comandos para validar archivos de configuración (YAML, JSON, HCL, TOML, etc.).
  • Se basa en el lenguaje de políticas Rego (del proyecto Open Policy Agent - OPA).
  • Su objetivo es detectar problemas antes del despliegue, sin necesidad de aplicar los manifiestos en Kubernetes.

Uso en Kubernetes

En Kubernetes, Conftest se emplea para revisar manifiestos YAML como Deployments, Services, ConfigMaps, etc.
Ejemplos de validaciones comunes:

  • Evitar image: latest → forzar uso de tags versionadas.
  • Asegurar que todos los Pods tengan requests/limits de CPU y memoria.
  • Validar que los Pods tengan un securityContext adecuado (ej. no correr como root).
  • Prohibir el uso de hostPath o configuraciones inseguras.
  • Verificar que los objetos tengan labels estándar (app, env, team).

✅ ¿Por qué es importante validar buenas prácticas?

  1. Seguridad
    Evita configuraciones riesgosas como pods privilegiados o ejecución como root.

  2. Confiabilidad
    Detecta errores de configuración antes de llegar a producción.

  3. Consistencia
    Garantiza que los equipos sigan los mismos estándares de despliegue.

  4. Automatización en CI/CD
    Previene que configuraciones inseguras lleguen al clúster integrando Conftest en pipelines.

  5. Cumplimiento (Compliance)
    Facilita el cumplimiento de regulaciones y políticas internas de la organización.

Laboratorio para el Estudiante

Acceder al laboratorio.

  1. Ingresar al servidor de laboratorio con la llave proporcionada.

    export LAB=X
    ssh student@lab-${LAB}-aio 
    

  2. Cambiar al usuario root

    sudo -i
    

  3. Proporcione accesos administrativos al cluster de Kubernetes

    export KUBECONFIG=/etc/rancher/rke2/rke2.yaml
    
    export PATH=$PATH:/var/lib/rancher/rke2/bin
    
    export CONTAINERD_ADDRESS=/run/k3s/containerd/containerd.sock
    

Laboratorio: Políticas de manifiestos

Descripción

La presente guía aborda la automatización de la fase de políticas sobre manifiestos con las herramientas Conftest y Kubelinter.

Objetivos

  • Ejecutar los tests de políticas sobre los manifiestos con Conftest.
  • Ejecutar los tests de políticas sobre los manifiestos con Kubelinter.

Antes de comenzar

  • Contar con el acceso al ambiente del laboratorio

Inicio de laboratorio

  1. Acceda a la carpeta java-demo

    cd ~/java-demo
    

  2. Ejecute la herramienta kubelinter mediante un contenedor de Docker

    nerdctl run -it --rm -v $PWD:/usr/src/app stackrox/kube-linter:0.1.4 lint /usr/src/app
    

  3. Edite el archivo manifests/dev/k8s-resources.yaml agregando el limite de recursos al Deployment

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: api-demo
      namespace: userx
      labels:
        app: api-demo
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: api-demo
      template:
        metadata:
          labels:
            app: api-demo
        spec:
          containers:
            - name: api-demo
              image: harbor.x-x-x-x.nip.io/apis/api-demo:0.0.1
              ports:
                - containerPort: 8080
              resources:
                requests:
                  memory: "256Mi"
                  cpu: "50m"
                limits:
                  memory: "512Mi"
                  cpu: "100m"
    

  4. Ejecute la herramienta kubelinter mediante un contenedor de Docker

    nerdctl run -it --rm -v $PWD:/usr/src/app stackrox/kube-linter:0.1.4 lint /usr/src/app
    

  5. Edite el archivo manifests/dev/k8s-resources.yaml agregando el securityContext al Deployment

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: api-demo
      namespace: userx
      labels:
        app: api-demo
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: api-demo
      template:
        metadata:
          labels:
            app: api-demo
        spec:
          securityContext:
            runAsNonRoot: true
            readOnlyRootFilesystem: true
          containers:
            - name: api-demo
              image: harbor.x-x-x-x.nip.io/apis/api-demo:0.0.1
              securityContext:
                readOnlyRootFilesystem: true
              ports:
                - containerPort: 8080
              resources:
                requests:
                  memory: "256Mi"
                  cpu: "50m"
                limits:
                  memory: "512Mi"
                  cpu: "100m"
    

  6. Ejecute la herramienta kubelinter mediante un contenedor de Docker

    nerdctl -it --rm -v $PWD:/usr/src/app stackrox/kube-linter:0.1.4 lint /usr/src/app
    

  7. Cree un archivo llamado policy.rego con el siguiente contenido

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    package main
    
    name = input.metadata.name
    
    required_deployment_labels {
            input.metadata.labels["app.kubernetes.io/name"]
            input.metadata.labels["app.kubernetes.io/instance"]
            input.metadata.labels["app.kubernetes.io/version"]
            input.metadata.labels["app.kubernetes.io/component"]
            input.metadata.labels["app.kubernetes.io/part-of"]
            input.metadata.labels["app.kubernetes.io/managed-by"]
    }
    
    deny[msg] {
      input.kind = "Deployment"
      not required_deployment_labels
      msg = sprintf("%s must include Kubernetes recommended labels: https://kubernetes.io/docs/concepts/overview/working-with-objects/common-labels/#labels", [name])
    }
    
    deny[msg] {
      input.kind = "Deployment"
      not input.spec.template.spec.securityContext.runAsNonRoot = true
      msg = "Containers must not run as root"
    }
    
    deny[msg] {
      input.kind = "Deployment"
      not input.spec.selector.matchLabels.app
      msg = "Containers must provide app label for pod selectors"
    }
    

  8. Ejecute la herramienta Conftest mediante un contenedor

    nerdctl run -it --rm -v $PWD:/project \
    openpolicyagent/conftest:v0.32.0 test manifests/dev/k8s-resources.yaml -p policy.rego
    

  9. Agregue los labels requeridos al recurso de Deployment

  10. Ejecute la herramienta Conftest mediante un contenedor

    nerdctl -it --rm -v $PWD:/project openpolicyagent/conftest:v0.32.0 test manifests/dev/k8s-resources.yaml