Este documento ha sido traducido utilizando tecnología de traducción automática. Si bien nos esforzamos por proporcionar traducciones precisas, no ofrecemos garantías sobre la integridad, precisión o confiabilidad del contenido traducido. En caso de discrepancia, la versión original en inglés prevalecerá y constituirá el texto autorizado.

Esta es documentación inédita para Admission Controller 1.34-dev.

Instalación en entorno aislado

Para una instalación en entorno aislado de SUSE Security Admission Controller, necesitas un registro privado de Open Container Initiative (OCI) accesible por tu clúster de Kubernetes. Las políticas de Admission Controller son módulos de WebAssembly, por lo tanto, puedes almacenarlas en un registro compatible con OCI como artefactos OCI. Necesitas añadir las imágenes y políticas de Admission Controller a este registro OCI. Puedes consultar una lista de artefactos de Admission Controller en la página de Referencia de artefactos. Las siguientes secciones describen el proceso.

Recomendamos usar Hauler. Consulta nuestra página de documentación de Hauler.

Alternativamente, puedes usar el proceso manual que se detalla a continuación.

Guarda los gráficos de Helm localmente

Necesitas descargar los siguientes gráficos de Helm a tu estación de trabajo:

helm pull kubewarden/kubewarden-crds
helm pull kubewarden/kubewarden-controller
helm pull kubewarden/kubewarden-defaults
helm pull kubewarden/sbomscanner

Opcionalmente, puedes verificar las firmas de los gráficos de Helm y imágenes de contenedor.

Guarda las imágenes de contenedor localmente

Cada uno de nuestros gráficos de Helm contiene un imagelist.txt con las imágenes de contenedor que consume, y, cuando sea aplicable, un policylist.txt con los módulos OCI Wasm de las políticas que también consume.

Para obtenerlos, puedes hacer:
```
helm pull --untar \
  kubewarden/kubewarden-crds \
  kubewarden/kubewarden-controller \
  kubewarden/kubewarden-defaults \
  kubewarden/sbomscanner
```
Y luego concatenarlos en un archivo:
```
cat */imagelist.txt > kubewarden-images.txt
```
Descarga kubewarden-save-images.sh y kubewarden-load-images.sh del repositorio de utilidades.
Guarda Admission Controllerlas imágenes de contenedor en un archivo .tar.gz:
```
 ./kubewarden-save-images.sh \
   --image-list ./kubewarden-images.txt \
   --images kubewarden-images.tar.gz
```
Docker comienza a descargar las imágenes utilizadas para una instalación en un entorno aislado. Este proceso puede llevar algunos minutos. Cuando esté completo, tu directorio actual, donde ejecutaste el comando, tendrá un tarball, kubewarden-images.tar.gz.

Guarda las directivas localmente

Añade todas las directivas que quieras usar a un archivo policies.txt:
```
cat */policylist.txt > policies.txt
```
Un archivo con una lista de directivas predeterminadas está en la Admission Controller defaults página de lanzamiento.
Descarga kubewarden-save-policies.sh y kubewarden-load-policies.sh del kubewarden-controller repositorio.
Guarda las directivas en un archivo .tar.gz:
```
./kubewarden-save-policies.sh --policies-list policies.txt
```
Usa kwctl para descargar las directivas. El `kubewarden-policies.tar.gz`archivo contiene las directivas.

Gráficos de Helm

Necesitas descargar los siguientes gráficos de Helm a tu estación de trabajo:

helm pull kubewarden/kubewarden-crds
helm pull kubewarden/kubewarden-controller
helm pull kubewarden/kubewarden-defaults

Poblar el registro privado

Mueve estos archivos al entorno aislado:

Gráficos de Helm en formato tgz (por ejemplo, kubewarden-crds-1.23.0.tgz)
kubewarden-policies.tar.gz,
kubewarden-images.tar.gz,
kubewarden-load-images.sh,
kubewarden-load-policies.sh y

policies.txt

Carga Admission Controllerlas imágenes en el registro privado. Necesitas autenticar el cliente de Docker contra el registro local.

 ./kubewarden-load-images.sh \
   --image-list ./kubewarden-images.txt \
   --images kubewarden-images.tar.gz \
   --registry <REGISTRY.YOURDOMAIN.COM:PORT>

Carga Admission Controllerlas directivas en el registro privado. Debes autenticar kwctl el registro local (kwctl utiliza el mismo mecanismo para autenticar como docker, un archivo ~/.docker/config.json)
```
 ./kubewarden-load-policies.sh \
   --policies-list policies.txt \
   --policies kubewarden-policies.tar.gz \
   --registry <REGISTRY.YOURDOMAIN.COM:PORT> \
   --sources-path sources.yml
```

El kwctl comando necesita el sources.yaml archivo para conectarse a los registros en estas categorías:

Se requiere autenticación
Se está utilizando un certificado autofirmado
No se realiza terminación TLS

Consulta la sección sobre autoridades de certificación personalizadas en la documentación para aprender a configurar el `sources.yaml`archivo

Instalar Admission Controller

Ahora que tu registro privado tiene todo lo necesario, puedes instalar Admission Controller. La única diferencia con una instalación estándar de Admission Controller es que necesitas cambiar el registro en las imágenes de contenedor y directivas para que sea el registro privado.

Instala el Admission Controllerstack:

helm install --wait -n kubewarden \
  kubewarden-crds kubewarden-crds.tgz

helm install --wait -n kubewarden \
  kubewarden-controller kubewarden-controller.tgz \
  --set global.cattle.systemDefaultRegistry=<REGISTRY.YOURDOMAIN.COM:PORT>

Para usar el subgráfico Policy Reporter disponible en el `kubewarden-controller`gráfico, necesitas definir otros valores específicos para el subgráfico en un entorno aislado. Un ejemplo se muestra a continuación:

helm install --wait -n kubewarden kubewarden-controller kubewarden-controller.tgz \
    --set global.cattle.systemDefaultRegistry=<REGISTRY.YOURDOMAIN.COM:PORT> \
    --set auditScanner.policyReporter=true \
    --set policy-reporter.image.registry=<REGISTRY.YOURDOMAIN.COM:PORT> \
    --set policy-reporter.ui.image.registry=<REGISTRY.YOURDOMAIN.COM:PORT> \
    --set policy-reporter.image.repository=kyverno/policy-reporter \
    --set policy-reporter.ui.image.repository=kyverno/policy-reporter-ui

Es necesario definir auditScanner.policyReporter para habilitar el subgráfico y 4 valores más, para configurar el registro y el repositorio donde almacenas las imágenes del Policy Reporter. Para más información sobre los valores del subgráfico de informes de directivas, consulta la documentación del Policy Reporter.

helm install --wait -n kubewarden \
  kubewarden-defaults kubewarden-defaults.tgz \
  --set global.cattle.systemDefaultRegistry=<REGISTRY.YOURDOMAIN.COM:PORT>

Para descargar las directivas recomendadas instaladas por el gráfico Helm kubewarden-defaults desde un registro diferente a global.cattle.systemDefaultRegistry, utiliza la configuración recommendedPolicies.defaultPoliciesRegistry. Esta configuración permite a los usuarios especificar un registro dedicado a obtener los artefactos OCI de las directivas. Es particularmente útil cuando su repositorio de imágenes de contenedor no soporta artefactos OCI.

Para instalar y esperar a que la instalación se complete, utiliza el siguiente comando:

helm install --wait -n kubewarden \
  kubewarden-defaults kubewarden-defaults.tgz \
  --set global.cattle.systemDefaultRegistry=<REGISTRY.YOURDOMAIN.COM:PORT> \
  --set recommendedPolicies.defaultPoliciesRegistry=<REGISTRY.YOURDOMAIN.COM:PORT>

Si la recommendedPolicies.defaultPoliciesRegistry`configuración no está establecida, se utiliza `global.cattle.systemDefaultRegistry como el registro predeterminado.

Finalmente, necesitas configurar el Servidor de Directivas para obtener directivas de tu registro privado. Consulta la sección usando registro privado de la documentación.

Ahora puedes crear Admission Controllerdirectivas en tu clúster. Las directivas deben estar disponibles en tu registro privado.

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

Los `PolicyServer`recursos deben utilizar la imagen disponible en tu registro privado. Por ejemplo:

apiVersion: policies.kubewarden.io/v1
kind: PolicyServer
metadata:
  name: reserved-instance-for-tenant-a
spec:
  image: <REGISTRY.YOURDOMAIN.COM:PORT>/kubewarden/policy-server:v1.3.0
  replicas: 2
  serviceAccountName: sa