Utiliser le fournisseur Azure Key Vault pour le pilote CSI du magasin de secrets sur Azure Red Hat OpenShift

Article
08/14/2024

Le fournisseur Azure Key Vault pour le pilote CSI de magasin de secrets vous permet d’obtenir des contenus de secrets stockés dans une instance Azure Key Vault et d’utiliser le pilote CSI de magasin de secrets pour les monter dans des pods Kubernetes. Cet article explique comment utiliser Azure Key Vault Provider for Secrets Store CSI Driver (fournisseur Azure Key Vault pour le pilote CSI du magasin des secrets) sur Azure Red Hat OpenShift.

Remarque

En guise de remplacement de la solution open source présentée dans cet article, vous pouvez utiliser Azure Arc pour gérer vos clusters ARO, ainsi que son extension Azure Key Vault Provider for Secrets Store CSI Driver (Fournisseur Azure Key Vault pour le pilote CSI du magasin de secrets). Cette méthode est entièrement prise en charge par Microsoft et est recommandée au lieu de la solution open source ci-dessous.

Prérequis

Les prérequis suivants sont obligatoires :

Un cluster Azure Red Hat OpenShift (consultez Créer un cluster Azure Red Hat OpenShift pour en savoir plus.)
Interface de ligne de commande Azure (CLI) (connectée)
Helm 3.x CLI

Définir des variables d’environnement

Définissez les variables suivantes qui seront utilisées tout au long de cette procédure :

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)

Installer le pilote CSI de magasin de secrets Kubernetes

Créer un projet ARO ; vous allez déployer le pilote CSI dans ce projet :
```
oc new-project k8s-secrets-store-csi
```
Définissez SecurityContextConstraints pour autoriser le pilote CSI à s’exécuter (sinon, le pilote CSI ne pourra pas créer de pods) :
```
oc adm policy add-scc-to-user privileged \
  system:serviceaccount:k8s-secrets-store-csi:secrets-store-csi-driver
```

Ajoutez le pilote CSI du magasin de secrets à vos référentiels Helm :

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

Mettez à jour vos référentiels Helm :
```
helm repo update
```
Installez le pilote CSI de magasin de secrets :
```
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"
```
Si vous le souhaitez, vous pouvez activer l’autorotation des secrets en ajoutant les paramètres suivants à la commande ci-dessus :

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

Vérifiez que les DaemonSets du pilote CSI sont en cours d’exécution :

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

Après avoir exécuté la commande ci-dessus, vous devez voir ce qui suit :

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

Déployer le fournisseur Azure Key Vault pour le pilote CSI du magasin de Secrets

Ajoutez le référentiel Azure Helm :

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

Mettez à jour vos référentiels Helm locaux :
```
helm repo update
```

Installez le fournisseur CSI 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

Définissez SecurityContextConstraints pour autoriser le pilote CSI à s’exécuter :

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

Créer un coffre de clés et un secret

Créez un espace de noms pour votre application.
```
oc new-project my-application
```

Créez un coffre de clés Azure dans votre groupe de ressources qui contient ARO.

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

Créez un secret dans le coffre de clés.

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

Créer un principal de service pour le coffre de clés.

Remarque

Si vous recevez une erreur lors de la création du principal de service, vous devrez peut-être mettre à niveau votre interface Azure CLI vers la dernière version.

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)"

Définissez une stratégie d’accès pour le principal de service.

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

Créez, puis étiquetez un secret pour Kubernetes à utiliser pour accéder au coffre de clés.

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

Déployer une application qui utilise le pilote CSI

Créez un élément SecretProviderClass pour donner accès à ce secret :

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

Créez un pod qui utilise l’élément SecretProviderClass créé à l’étape précédente :

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

Vérifiez que le secret est monté :

kubectl exec busybox-secrets-store-inline -- ls /mnt/secrets-store/

La sortie doit ressembler à ce qui suit :

secret1

Imprimez le secret :

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

La sortie doit ressembler à ce qui suit :

Hello

Nettoyage

Désinstallez le fournisseur Key Vault et le pilote CSI.

Désinstaller le fournisseur Azure Key Vault

Désinstallez le graphique Helm :

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

Supprimer l’application :
```
oc delete project my-application
```
Supprimez le coffre de clés :
```
az keyvault delete -n ${KEYVAULT_NAME}
```

Supprimez le principal de service :

az ad sp delete --id ${SERVICE_PRINCIPAL_CLIENT_ID}

Désinstallez le pilote CSI de magasin des secrets Kubernetes

Supprimez le pilote CSI de magasin de secrets :

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

Supprimez SecurityContextConstraints :

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

Partager via