Usare il provider di Azure Key Vault per il driver CSI dell'archivio segreti in Azure Red Hat OpenShift

Articolo
10/26/2023

Il provider di Azure Key Vault per il driver CSI dell'archivio segreti consente di ottenere contenuti segreti archiviati in un'istanza di Azure Key Vault e usare il driver CSI dell'archivio segreti per montarli in pod Kubernetes. Questo articolo illustra come usare il provider di Azure Key Vault per il driver CSI dell'archivio segreti in Azure Red Hat OpenShift.

Nota

In alternativa alla soluzione open source presentata in questo articolo, è possibile usare Azure Arc per gestire i cluster ARO insieme alla relativa estensione del provider di Azure Key Vault per il driver CSI dell'archivio segreti. Questo metodo è completamente supportato da Microsoft ed è consigliato al posto della soluzione open source seguente.

Prerequisiti

Sono richiesti i prerequisiti seguenti:

Un cluster Azure Red Hat OpenShift (vedere Creare un cluster Azure Red Hat OpenShift per altre informazioni).
Interfaccia della riga di comando di Azure (connesso)
Interfaccia della riga di comando di Helm 3.x

Impostare le variabili di ambiente

Impostare le variabili seguenti che verranno usate in questa procedura:

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)

Installare il driver CSI dell'archivio segreti Kubernetes

Creare un progetto ARO; si distribuirà il driver CSI in questo progetto:
```
oc new-project k8s-secrets-store-csi
```
Impostare SecurityContextConstraints per consentire l'esecuzione del driver CSI (in caso contrario, il driver CSI non sarà in grado di creare pod):
```
oc adm policy add-scc-to-user privileged \
  system:serviceaccount:k8s-secrets-store-csi:secrets-store-csi-driver
```

Aggiungere il driver CSI dell'archivio segreti ai repository Helm:

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

Aggiornare i repository Helm:
```
helm repo update
```
Installare il driver CSI dell'archivio segreti:
```
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"
```
Facoltativamente, è possibile abilitare l'autorotazione dei segreti aggiungendo i parametri seguenti al comando precedente:

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

Verificare che i DaemonSet del driver CSI siano in esecuzione:

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

Dopo aver eseguito il comando precedente, verrà visualizzato quanto segue:

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

Distribuire il provider di Azure Key Vault per il driver CSI dell'archivio segreti

Aggiungere il repository Helm di Azure:

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

Aggiornare i repository Helm locali:
```
helm repo update
```

Installare il provider CSI di 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

Impostare SecurityContextConstraints per consentire l'esecuzione del driver CSI:

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

Creare un insieme di credenziali delle chiavi e un segreto

Creare uno spazio dei nomi per l'applicazione.
```
oc new-project my-application
```

Creare un insieme di credenziali delle chiavi di Azure nel gruppo di risorse che contiene ARO.

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

Creare un segreto nell'insieme di credenziali delle chiavi.

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

Creare un'entità servizio per l'insieme di credenziali delle chiavi.

Nota

Se viene visualizzato un errore durante la creazione dell'entità servizio, potrebbe essere necessario aggiornare l'interfaccia della riga di comando di Azure alla versione più recente.

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

Impostare un criterio di accesso per l'entità servizio.

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

Creare ed etichettare un segreto per Kubernetes da usare per accedere all'insieme di credenziali delle chiavi.

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

Distribuire un'applicazione che usa il driver CSI

Creare un SecretProviderClass per concedere l'accesso a questo segreto:

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

Creare un pod che usi il SecretProviderClass creato nel passaggio precedente:

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

Verificare che il segreto sia montato:

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

L'output deve corrispondere al seguente:

secret1

Stampare il segreto:

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

L'output deve corrispondere al seguente:

Hello

Pulizia

Disinstallare il provider dell'insieme di credenziali delle chiavi e il driver CSI.

Disinstallare il provider dell'insieme di credenziali delle chiavi

Disinstallare il grafico Helm:

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

Eliminare l'app:
```
oc delete project my-application
```
Eliminare l'insieme di credenziali delle chiavi di Azure:
```
az keyvault delete -n ${KEYVAULT_NAME}
```

Eliminare l'entità servizio:

az ad sp delete --id ${SERVICE_PRINCIPAL_CLIENT_ID}

Disinstallare il driver CSI dell'archivio segreto Kubernetes

Eliminare il driver CSI dell'archivio segreti:

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

Eliminare SecurityContextConstraints:

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

Condividi tramite