Usar o Azure Key Vault Provider for Secrets Store CSI Driver no Azure Red Hat OpenShift

Artigo
10/26/2023

O Azure Key Vault Provider for Secrets Store CSI Driver permite que você obtenha conteúdo secreto armazenado em uma instância do Azure Key Vault e use o Driver CSI do Secrets Store para montá-los em pods do Kubernetes. Este artigo explica como usar o Azure Key Vault Provider for Secrets Store CSI Driver no Azure Red Hat OpenShift.

Nota

Como alternativa à solução de código aberto apresentada neste artigo, você pode usar o Azure Arc para gerenciar seus clusters ARO junto com sua extensão de Driver CSI do Azure Key Vault Provider for Secrets Store. Este método é totalmente suportado pela Microsoft e é recomendado em vez da solução de código aberto abaixo.

Pré-requisitos

Os seguintes pré-requisitos são necessários:

Um cluster do Azure Red Hat OpenShift (Consulte Criar um cluster do Azure Red Hat OpenShift para saber mais.)
CLI do Azure (conectado)
Helm 3.x CLI

Definir variáveis de ambiente

Defina as seguintes variáveis que serão usadas ao longo deste procedimento:

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)

Instale o driver CSI do Kubernetes Secrets Store

Criar um projeto ARO; você implantará o driver CSI neste projeto:
```
oc new-project k8s-secrets-store-csi
```
Defina SecurityContextConstraints para permitir que o driver CSI seja executado (caso contrário, o driver CSI não poderá criar pods):
```
oc adm policy add-scc-to-user privileged \
  system:serviceaccount:k8s-secrets-store-csi:secrets-store-csi-driver
```

Adicione o driver CSI da Loja de Segredos aos seus repositórios Helm:

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

Atualize seus repositórios Helm:
```
helm repo update
```
Instale o driver CSI da Secrets Store:
```
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, você pode habilitar a rotação automática de segredos adicionando os seguintes parâmetros ao comando acima:

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

Verifique se o driver CSI DaemonSets está em execução:

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

Depois de executar o comando acima, você verá o seguinte:

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

Implantar o Provedor do Cofre de Chaves do Azure para o Driver CSI do Repositório de Segredos

Adicione o repositório do Azure Helm:

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

Atualize seus repositórios Helm locais:
```
helm repo update
```

Instale o provedor CSI do 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

Defina SecurityContextConstraints para permitir que o driver CSI seja executado:

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

Criar cofre de chaves e um segredo

Crie um namespace para seu aplicativo.
```
oc new-project my-application
```

Crie um cofre de chaves do Azure em seu grupo de recursos que contenha ARO.

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

Crie um segredo no cofre de chaves.

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

Crie uma entidade de serviço para o cofre de chaves.

Nota

Se você receber um erro ao criar a entidade de serviço, talvez seja necessário atualizar sua CLI do Azure para a versão mais 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)"

Defina uma política de acesso para a entidade de serviço.

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

Crie e rotule um segredo para o Kubernetes usar para acessar o cofre de chaves.

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

Implantar um aplicativo que usa o driver CSI

Crie um SecretProviderClass para dar acesso a este segredo:

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

Crie um pod que use o SecretProviderClass criado na etapa 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

Verifique se o segredo está montado:

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

A saída deve corresponder ao seguinte:

secret1

Imprima o segredo:

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

A saída deve corresponder ao seguinte:

Hello

Limpeza

Desinstale o Key Vault Provider e o driver CSI.

Desinstale o provedor do Key Vault

Desinstalar o gráfico Helm:

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

Exclua o aplicativo:
```
oc delete project my-application
```
Exclua o cofre de chaves do Azure:
```
az keyvault delete -n ${KEYVAULT_NAME}
```

Exclua a entidade de serviço:

az ad sp delete --id ${SERVICE_PRINCIPAL_CLIENT_ID}

Desinstale o driver CSI do Kubernetes Secret Store

Exclua o driver CSI do Secrets Store:

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

Exclua SecurityContextConstraints:

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

Partilhar via