Usar o Provedor do Cofre de Chaves do Azure para o Driver CSI do Secrets Store no Azure Red Hat OpenShift

Artigo
10/26/2023

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

Observação

Como alternativa à solução de software livre apresentada neste artigo, você pode usar o Azure Arc para gerenciar seus clusters ARO junto com sua extensão do Azure Key Vault Provider for Secrets Store CSI Driver. 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)
CLI do Leme 3.x

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 Kubernetes Secrets Store

Criar um projeto ARO; você implantará o CSI Driver 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 do Secrets Store 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 do 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 os DaemonSets do driver 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ê 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 locais do Helm:
```
helm repo update
```

Instale o provedor CSI do Cofre de Chaves do Azure:

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.

Observação

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.

Desinstalar o provedor do Cofre de Chaves

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}

Desinstalar 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 o SecurityContextConstraints:

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

Share via