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

Article
10/26/2023

Le fournisseur Azure Key Vault pour le pilote CSI du magasin de secrets vous permet d’obtenir le contenu secret stocké dans une instance Azure Key Vault et d’utiliser le pilote CSI du magasin de secrets pour les monter dans des pods Kubernetes. Cet article explique comment utiliser le fournisseur Azure Key Vault pour le pilote CSI du magasin de secrets sur Azure Red Hat OpenShift.

Remarque

En guise d’alternative à la solution code source ouvert présentée dans cet article, vous pouvez utiliser Azure Arc pour gérer vos clusters ARO, ainsi que son fournisseur Azure Key Vault pour l’extension 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 code source ouvert 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.)
Azure CLI (connecté)
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 du 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 du magasin des 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 permettre au pilote CSI d’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éez 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 et é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 SecretProviderClass élément pour accorder l’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 le SecretProviderClass pod 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 correspondre à ce qui suit :
```
secret1
```

Imprimez le secret :

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

La sortie doit correspondre à ce qui suit :

Hello

Nettoyage

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

Désinstaller le fournisseur Key Vault

Désinstaller le graphique Helm :

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

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

Supprimez le principal de service :

az ad sp delete --id ${SERVICE_PRINCIPAL_CLIENT_ID}

Désinstaller le pilote CSI du Magasin secret Kubernetes

Supprimez le pilote CSI du 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

Share via