Kubewarden

Kubewarden es un motor de políticas de Kubernetes. Su objetivo es ser el motor de políticas universal para Kubernetes.

Puede reutilizar políticas de otros motores de políticas sin tener que reescribirlas.
Puede escribir sus propias políticas en cualquier lenguaje de programación que genere archivos binarios de WebAssembly, reutilizando sus bibliotecas y herramientas de lenguaje.
Puede ejecutar políticas tanto fuera del clúster como como parte de sus procesos de CI/CD.
Kubewarden también proporciona un escáner de auditoría para comprobar de forma activa y continua el cumplimiento de las políticas a lo largo del tiempo.

Kubewarden es un proyecto CNCF Sandbox, creado originalmente por SUSE Rancher .

Componentes de Kubewarden

Se compone de varios tipos de recursos y componentes que trabajan juntos para proporcionar una gestión avanzada y segura de políticas en Kubernetes. ClusterAdmissionPolicy y AdmissionPolicy definen las políticas a diferentes niveles, PolicyServer evalúa y ejecuta estas políticas, y el kubewarden-controller coordina y asegura el funcionamiento adecuado de todo el sistema.

Recursos ClusterAdmissionPolicy: Estos recursos definen cómo se implementan las políticas para los clústeres de Kubernetes. Cada ClusterAdmissionPolicy especifica una política que se aplica a nivel de clúster, proporcionando una forma centralizada de gestionar las reglas de seguridad y comportamiento que deben seguir los recursos dentro del clúster.

Recursos PolicyServer: Representan una implementación de un PolicyServer de Kubewarden. Los PolicyServer son responsables de cargar y evaluar las políticas definidas por el administrador. Estas políticas se ejecutan en el contexto del PolicyServer, que actúa como un entorno seguro y aislado para la evaluación de las políticas.

Recursos AdmissionPolicy: Definen políticas específicas para un namespace determinado. Mientras que ClusterAdmissionPolicy aplica políticas a nivel de clúster, AdmissionPolicy permite definir y aplicar políticas específicas dentro de un namespace, proporcionando un control más granular sobre los recursos y las reglas dentro de ese ámbito.

Implementación de un kubewarden-controller: Este controlador monitorea los recursos ClusterAdmissionPolicy y AdmissionPolicy, e interactúa con los componentes del PolicyServer de Kubewarden. El kubewarden-controller asegura que las políticas se carguen y apliquen correctamente, gestionando la comunicación entre Kubernetes y los servidores de políticas de Kubewarden.

Instalación en Rancher Kubernetes Engine

Instalar Kubewarden stack usando helm charts de la siguiente forma: Primero se deben agregar los repositorios de los helm charts
```
helm repo add kubewarden https://charts.kubewarden.io
```
```
helm repo update kubewarden
```
Ingresar como usuario administrador al cluster de Kubernetes con el siguiente comando:
```
export KUBECONFIG=$HOME/devcluster/kube_config_cluster.yml
```

Instalar los CRDS

helm install --wait -n kubewarden --create-namespace kubewarden-crds kubewarden/kubewarden-crds

Instalar kubewarden-controller:

helm install --wait -n kubewarden kubewarden-controller kubewarden/kubewarden-controller

Instalar kubewarden-defaults, que creará un recurso de PolicyServer llamado default. También puede instalar un conjunto de políticas recomendadas para proteger su clúster aplicando algunas de las mejores prácticas conocidas.
```
helm install --wait -n kubewarden kubewarden-defaults kubewarden/kubewarden-defaults
```

Ejemplo: Implementando una Politica

El siguiente ejemplo aplicará una Politica que restringe la creación de Pods con securityContext privileged, la configuración securityContext: privileged: true en un POD proporciona a los contenedores permisos extendidos en el host, lo que puede ser necesario para ciertas aplicaciones pero conlleva riesgos significativos de seguridad.

Usaremos el siguiente comando para crear la política pod-privileged. Necesitamos evitar la creación de contenedores privilegiados dentro de nuestro clúster de Kubernetes aplicando esta política.

kubectl apply -f - <<EOF
apiVersion: policies.kubewarden.io/v1
kind: ClusterAdmissionPolicy
metadata:
  name: privileged-pods
spec:
  module: registry://ghcr.io/kubewarden/policies/pod-privileged:v0.2.2
  rules:
  - apiGroups: [""]
    apiVersions: ["v1"]
    resources: ["pods"]
    operations:
    - CREATE
    - UPDATE
  mutating: false
EOF

Esto produce el siguiente resultado:

clusteradmissionpolicy.policies.kubewarden.io/privileged-pods created

Cuando el recurso ClusterAdmissionPolicy se crea, el estado se establece en pending y forzará una implementación del objetivo PolicyServer. En nuestro ejemplo, es el PolicyServer llamado default. Puede monitorear el lanzamiento ejecutando el siguiente comando:

kubectl get clusteradmissionpolicy.policies.kubewarden.io/privileged-pods

Y se debe mostrarse en estado active para comenzar a funcionar:

[student@student-0-aio ~]$ kubectl get clusteradmissionpolicy.policies.kubewarden.io/privileged-pods
NAME              POLICY SERVER   MUTATING   BACKGROUNDAUDIT   MODE      OBSERVED MODE   STATUS   AGE
privileged-pods   default         false      true              protect   protect         active   103s

Una vez que la nueva política esté lista para ser entregada, el controlador kubewarden registrará un objeto ValidatingWebhookConfiguration. El estado de ClusterAdmissionPolicy se establecerá como activo una vez que finalice la implementación para cada instancia de PolicyServer. Verificar el recurso ValidatingWebhookConfiguration con el siguiente comando:
```
kubectl get validatingwebhookconfigurations.admissionregistration.k8s.io -l kubewarden
```
Deberías ver el siguiente resultado:
```
NAME                          WEBHOOKS   AGE
clusterwide-privileged-pods   1          9s
```
Una vez que ClusterAdmissionPolicy esté activo y ValidatingWebhookConfiguration registrado, puede probar la política. Creemos un Pod con un Contenedor que no está en modo privileged:
```
kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: unprivileged-pod
spec:
  containers:
    - name: nginx
      image: nginx:latest
EOF
```
Esto producirá el siguiente resultado:
```
pod/unprivileged-pod created
```
El Pod se creó exitosamente, con lo que comprobamos que contenedores que NO esten en modo privilegiado se crearan sin ningún inconveniente.
Ahora, creemos un Pod con securityContext en privileged con valor true, la configuración securityContext: privileged: true proporciona a los contenedores permisos extendidos en el host, lo que puede ser necesario para ciertas aplicaciones pero conlleva riesgos significativos de seguridad.
```
kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: privileged-pod
spec:
  containers:
    - name: nginx
      image: nginx:latest
      securityContext:
          privileged: true
EOF
```
La política ha denegado la creación del Pod y debería ver el siguiente mensaje:
```
Error from server: error when creating "STDIN": admission webhook "clusterwide-privileged-pods.kubewarden.admission" denied the request: Privileged container is not allowed
```
Lo anterior comprueba que la politica creada anteriormente esta funcionando correctamente, ya que NO permite crear contnedores en modo privileged

Limpieza del ambiente

Puede eliminar los recursos creados desinstalando los helm charts de la siguiente manera::

helm uninstall --namespace kubewarden kubewarden-defaults

helm uninstall --namespace kubewarden kubewarden-controller

helm uninstall --namespace kubewarden kubewarden-crds

kubectl delete namespace kubewarden

Se deben eliminar los recursos ValidatingWebhookConfigurations y MutatingWebhookConfigurations creados por kubewarden, esto se puede verificar de la siguiente manera:

kubectl get validatingwebhookconfigurations.admissionregistration.k8s.io -l "kubewarden"

kubectl get mutatingwebhookconfigurations.admissionregistration.k8s.io -l "kubewarden"

Si estos recursos no se eliminan automáticamente, elimínelos manualmente usando el siguiente comando:

kubectl delete -l "kubewarden" validatingwebhookconfigurations.admissionregistration.k8s.io

kubectl delete -l "kubewarden" mutatingwebhookconfigurations.admissionregistration.k8s.io

Eliminar los PODs que pudieron haberse creado anteriormente:

kubectl delete pod unprivileged-pod

kubectl delete pod privileged-pod