Usar o Provedor do Cofre de Chaves do Azure para driver CSI do repositório de segredos no Red Hat OpenShift no Azure

Artigo
08/09/2024

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

Observação

Como alternativa à solução de software livre apresentada neste artigo, você pode usar o Azure Arc para gerenciar seus clusters ARO, juntamente com sua extensão do Driver do CSI do Provedor do Azure Key Vault para Repositório de Segredos. Esse método é totalmente compatível com a Microsoft e é recomendado em vez da solução de software livre abaixo.

Pré-requisitos

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

Um cluster do Red Hat OpenShift do Azure (consulte Criar um cluster do Red Hat OpenShift no Azure 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)

Instalar o Driver CSI do Repositório de Segredos do Kubernetes

Criar um projeto do 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 do CSI do Repositório de Segredos aos repositórios do Helm:

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

Atualize seus repositórios do Helm:
```
helm repo update
```
Instale o Driver do CSI do Repositório de Segredos:
```
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 autorotação de segredos adicionando os seguintes parâmetros ao comando acima:

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

Verifique se os DaemonSets de Driver do CSI estão em execução:

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

Depois de executar o comando acima, você deverá 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 Azure Key Vault para o driver CSI do Repositório de Segredos

Adicione o repositório do Helm do Azure:

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

Atualize seus repositórios locais do Helm:
```
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 um cofre de chaves e um segredo

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

Crie um cofre de chaves do Azure no grupo de recursos que contém o 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.

Observação

Se você receber um erro ao criar a entidade de serviço, talvez seja necessário atualizar a 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 esse 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 Provedor do Key Vault e o Driver CSI.

Desinstalar o provedor do Key Vault

Desinstalar o gráfico do 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}

Desinstalar o Driver CSI do Repositório Secreto do Kubernetes

Exclua o Driver do CSI do Repositório de Segredos:

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

Compartilhar via