Uso del proveedor de Azure Key Vault para el controlador CSI del almacén de secretos en Red Hat OpenShift en Azure

Artículo
05/03/2023

El proveedor de Azure Key Vault para el controlador CSI del almacén de secretos le permite obtener el contenido secreto almacenado en una instancia de Azure Key Vault y usar el controlador CSI del almacén de secretos para montarlos en pods de Kubernetes. En este artículo se explica cómo usar el proveedor de Azure Key Vault para el controlador CSI del almacén de secretos en Red Hat OpenShift en Azure.

Nota:

Como alternativa a la solución de código abierto presentada en este artículo, puede usar Azure Arc para administrar los clústeres de ARO junto con su extensión proveedor de Azure Key Vault para secrets Store CSI Driver. Microsoft admite completamente este método y se recomienda en lugar de la solución código abierto siguiente.

Requisitos previos

Se necesitan los siguientes requisitos previos:

Un clúster de Red Hat OpenShift en Azure (consulte Creación de un clúster de Red Hat OpenShift en Azure para más información).
CLI de Azure (iniciada sesión)
Helm 3.x CLI

Establecimiento de variables de entorno

Establezca las siguientes variables que se usarán en este procedimiento:

export KEYVAULT_RESOURCE_GROUP=${AZR_RESOURCE_GROUP:-"openshift"}
export KEYVAULT_LOCATION=${AZR_RESOURCE_LOCATION:-"eastus"}
export KEYVAULT_NAME=secret-store-$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 10 | head -n 1)
export AZ_TENANT_ID=$(az account show -o tsv --query tenantId)

Instalación del controlador CSI del almacén de secretos de Kubernetes

Crear un proyecto de ARO; implementará el controlador CSI en este proyecto:
```
oc new-project k8s-secrets-store-csi
```
Establezca SecurityContextConstraints para permitir que el controlador CSI se ejecute (de lo contrario, el controlador CSI no podrá crear pods):
```
oc adm policy add-scc-to-user privileged \
  system:serviceaccount:k8s-secrets-store-csi:secrets-store-csi-driver
```

Agregue el controlador CSI del almacén de secretos a los repositorios de Helm:

helm repo add secrets-store-csi-driver \
  https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts

Actualice los repositorios de Helm:
```
helm repo update
```
Instale el controlador CSI del almacén de secretos:
```
helm install -n k8s-secrets-store-csi csi-secrets-store \
   secrets-store-csi-driver/secrets-store-csi-driver \
   --version v1.3.1 \
   --set "linux.providersDir=/var/run/secrets-store-csi-providers"
```
Opcionalmente, puede habilitar la asignación automática de secretos agregando los parámetros siguientes al comando anterior:

--set "syncSecret.enabled=true" --set "enableSecretRotation=true"

Compruebe que se están ejecutando los daemonSets del controlador CSI:

kubectl --namespace=k8s-secrets-store-csi get pods -l "app=secrets-store-csi-driver"

Después de ejecutar el comando anterior, debería ver lo siguiente:

NAME                                               READY   STATUS    RESTARTS   AGE
 csi-secrets-store-secrets-store-csi-driver-cl7dv   3/3     Running   0          57s
 csi-secrets-store-secrets-store-csi-driver-gbz27   3/3     Running   0          57s

Implementación del proveedor de Azure Key Vault para el controlador CSI del almacén de secretos

Agregue el repositorio de Azure Helm:

helm repo add csi-secrets-store-provider-azure \
   https://azure.github.io/secrets-store-csi-driver-provider-azure/charts

Actualice los repositorios de Helm locales:
```
helm repo update
```

Instale el proveedor CSI de Azure Key Vault:

helm install -n k8s-secrets-store-csi azure-csi-provider \
   csi-secrets-store-provider-azure/csi-secrets-store-provider-azure \
   --set linux.privileged=true --set secrets-store-csi-driver.install=false \
   --set "linux.providersDir=/var/run/secrets-store-csi-providers" \
   --version=v1.4.1

Establezca SecurityContextConstraints para permitir que el controlador CSI se ejecute:

oc adm policy add-scc-to-user privileged \
   system:serviceaccount:k8s-secrets-store-csi:csi-secrets-store-provider-azure

Creación de un almacén de claves y un secreto

Cree un espacio de nombres para la aplicación.
```
oc new-project my-application
```

Cree un almacén de claves de Azure en el grupo de recursos que contenga ARO.

az keyvault create -n ${KEYVAULT_NAME} \
   -g ${KEYVAULT_RESOURCE_GROUP} \
   --location ${KEYVAULT_LOCATION}

Cree un secreto en el almacén de claves.

az keyvault secret set \
   --vault-name ${KEYVAULT_NAME} \
   --name secret1 --value "Hello"

Cree una entidad de servicio para el almacén de claves.

Nota:

Si recibe un error al crear la entidad de servicio, es posible que tenga que actualizar la CLI de Azure a la versión más reciente.

export SERVICE_PRINCIPAL_CLIENT_SECRET="$(az ad sp create-for-rbac --skip-assignment --name http://$KEYVAULT_NAME --query 'password' -otsv)"
export SERVICE_PRINCIPAL_CLIENT_ID="$(az ad sp list --display-name http://$KEYVAULT_NAME --query '[0].appId' -otsv)"

Establezca una directiva de acceso para la entidad de servicio.

az keyvault set-policy -n ${KEYVAULT_NAME} \
   --secret-permissions get \
   --spn ${SERVICE_PRINCIPAL_CLIENT_ID}

Cree y etiquete un secreto para que Kubernetes lo use para acceder al almacén de claves.

kubectl create secret generic secrets-store-creds \
   -n my-application \
   --from-literal clientid=${SERVICE_PRINCIPAL_CLIENT_ID} \
   --from-literal clientsecret=${SERVICE_PRINCIPAL_CLIENT_SECRET}
kubectl -n my-application label secret \
   secrets-store-creds secrets-store.csi.k8s.io/used=true

Implementación de una aplicación que usa el controlador CSI

Cree un SecretProviderClass para conceder acceso a este secreto:

cat <<EOF | kubectl apply -f -
 apiVersion: secrets-store.csi.x-k8s.io/v1
 kind: SecretProviderClass
 metadata:
   name: azure-kvname
   namespace: my-application
 spec:
   provider: azure
   parameters:
     usePodIdentity: "false"
     useVMManagedIdentity: "false"
     userAssignedIdentityID: ""
     keyvaultName: "${KEYVAULT_NAME}"
     objects: |
       array:
         - |
           objectName: secret1
           objectType: secret
           objectVersion: ""
     tenantId: "${AZ_TENANT_ID}"
EOF

Cree un pod que use el SecretProviderClass creado en el paso anterior:

cat <<EOF | kubectl apply -f -
 kind: Pod
 apiVersion: v1
 metadata:
   name: busybox-secrets-store-inline
   namespace: my-application
 spec:
   containers:
   - name: busybox
     image: k8s.gcr.io/e2e-test-images/busybox:1.29
     command:
       - "/bin/sleep"
       - "10000"
     volumeMounts:
     - name: secrets-store-inline
       mountPath: "/mnt/secrets-store"
       readOnly: true
   volumes:
     - name: secrets-store-inline
       csi:
         driver: secrets-store.csi.k8s.io
         readOnly: true
         volumeAttributes:
           secretProviderClass: "azure-kvname"
         nodePublishSecretRef:
           name: secrets-store-creds
EOF

Compruebe que el secreto está montado:
```
kubectl exec busybox-secrets-store-inline -- ls /mnt/secrets-store/
```
La salida debe coincidir con lo siguiente:
```
secret1
```

Imprima el secreto:

kubectl exec busybox-secrets-store-inline \
   -- cat /mnt/secrets-store/secret1

La salida debe coincidir con lo siguiente:

Hello

Limpieza

Desinstale el proveedor de Key Vault y el controlador CSI.

Desinstalación del proveedor de Key Vault

Desinstalar el gráfico de Helm:

helm uninstall -n k8s-secrets-store-csi azure-csi-provider

Elimine la aplicación:
```
oc delete project my-application
```
Elimine el almacén de claves de Azure:
```
az keyvault delete -n ${KEYVAULT_NAME}
```

Elimine la entidad de servicio:

az ad sp delete --id ${SERVICE_PRINCIPAL_CLIENT_ID}

Desinstalación del controlador CSI del almacén secreto de Kubernetes

Elimine el controlador CSI del almacén de secretos:

helm uninstall -n k8s-secrets-store-csi csi-secrets-store
oc delete project k8s-secrets-store-csi

Elimine SecurityContextConstraints:

oc adm policy remove-scc-from-user privileged \
  system:serviceaccount:k8s-secrets-store-csi:secrets-store-csi-driver

Share via