Use a extensão do Provedor de Segredos do Azure Key Vault para buscar segredos em clusters do Kubernetes habilitados para Azure Arc

O Azure Key Vault Provider for Secrets Store CSI Driver permite a integração do Azure Key Vault como um armazenamento de segredos com um cluster do Kubernetes por meio de um volume de CSI. Para os clusters do Kubernetes habilitados para Azure Arc, você pode instalar a extensão Azure Key Vault Secrets Provider para buscar segredos.

As funcionalidades da extensão Azure Key Vault Secrets Provider incluem:

• Monta segredos/chaves/certificados no pod usando um volume de CSI em linha
• Dá suporte à portabilidade do pod com o CRD SecretProviderClass
• Dá suporte aos Contêineres do Windows e do Linux
• Dá suporte à sincronização com segredos do Kubernetes
• Dá suporte à rotação automática de segredos
• Os componentes de extensão são implantados em zonas de disponibilidade, fazendo com que eles tenham redundância de zona

Pré-requisitos

• Um cluster com uma distribuição do Kubernetes com suporte conectada ao Azure Arc. No momento, há suporte para as seguintes distribuições do Kubernetes para este cenário:
  • API de Cluster do Azure
  • Clusters do AKS (Serviço de Kubernetes do Azure) no Azure Local
  • AKS habilitado pelo Azure Arc
  • Mecanismo do Kubernetes do Google
  • Distribuição do Kubernetes do OpenShift
  • Distribuição do Kubernetes Canônico
  • Serviço kubernetes elástico
  • Grade do Kubernetes do Tanzu
  • Red Hat OpenShift no Azure
• Conectividade de saída com os seguintes pontos de extremidade:
  • linuxgeneva-microsoft.azurecr.io
  • upstreamarc.azurecr.io
  • *.blob.core.windows.net
• Verifique se você atende aos pré-requisitos gerais para extensões de cluster. Use a versão 0.4.0 ou mais recente da extensão k8s-extension da CLI do Azure.

Instalar a extensão Azure Key Vault Secrets Provider em um cluster do Kubernetes habilitado para Arc

Você pode instalar a extensão Azure Key Vault Secrets Provider no cluster conectado no portal do Azure usando a CLI do Azure ou implantando um modelo do ARM.

Somente uma instância da extensão pode ser implantada em cada cluster do Kubernetes habilitado para Azure Arc.

portal do Azure

1. No portal do Azure, navegue até Kubernetes – Azure Arc e selecione seu cluster.

2. No menu de serviço, em Configurações, selecione Extensões. Em seguida, selecione + Adicionar.

   

3. Na lista de extensões disponíveis, selecione Azure Key Vault Secrets Provider para implantar a versão mais recente da extensão.

   

4. Siga as solicitações para implantar a extensão. Se necessário, personalize a instalação alterando as opções padrão na guia Configuração.

CLI do Azure

1. Defina as variáveis de ambiente:

   export CLUSTER_NAME=<arc-cluster-name>
   export RESOURCE_GROUP=<resource-group-name>
   

2. Instale o Secrets Store CSI Driver e a extensão Azure Key Vault Secrets Provider executando o seguinte comando:

   az k8s-extension create --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --cluster-type connectedClusters --extension-type Microsoft.AzureKeyVaultSecretsProvider --name akvsecretsprovider
   

Você verá uma saída semelhante a este exemplo. Pode levar vários minutos até que o gráfico Helm do provedor de segredos seja implantado no cluster.

{
  "aksAssignedIdentity": null,
  "autoUpgradeMinorVersion": true,
  "configurationProtectedSettings": {},
  "configurationSettings": {},
  "customLocationSettings": null,
  "errorInfo": null,
  "extensionType": "microsoft.azurekeyvaultsecretsprovider",
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Kubernetes/connectedClusters/$CLUSTER_NAME/providers/Microsoft.KubernetesConfiguration/extensions/akvsecretsprovider",
  "identity": {
    "principalId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "tenantId": null,
    "type": "SystemAssigned"
  },
  "location": null,
  "name": "akvsecretsprovider",
  "packageUri": null,
  "provisioningState": "Succeeded",
  "releaseTrain": "Stable",
  "resourceGroup": "$RESOURCE_GROUP",
  "scope": {
    "cluster": {
      "releaseNamespace": "kube-system"
    },
    "namespace": null
  },
  "statuses": [],
  "systemData": {
    "createdAt": "2022-05-12T18:35:56.552889+00:00",
    "createdBy": null,
    "createdByType": null,
    "lastModifiedAt": "2022-05-12T18:35:56.552889+00:00",
    "lastModifiedBy": null,
    "lastModifiedByType": null
  },
  "type": "Microsoft.KubernetesConfiguration/extensions",
  "version": "1.1.3"
}

modelo do ARM

1. Crie um arquivo .json com o formato a seguir. Certifique-se de atualizar o valor <cluster-name> para se referir ao seu cluster.

   {
       "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
       "contentVersion": "1.0.0.0",
       "parameters": {
           "ConnectedClusterName": {
               "defaultValue": "<cluster-name>",
               "type": "String",
               "metadata": {
                   "description": "The Connected Cluster name."
               }
           },
           "ExtensionInstanceName": {
               "defaultValue": "akvsecretsprovider",
               "type": "String",
               "metadata": {
                   "description": "The extension instance name."
               }
           },
           "ExtensionVersion": {
               "defaultValue": "",
               "type": "String",
               "metadata": {
                   "description": "The version of the extension type."
               }
           },
           "ExtensionType": {
               "defaultValue": "Microsoft.AzureKeyVaultSecretsProvider",
               "type": "String",
               "metadata": {
                   "description": "The extension type."
               }
           },
           "ReleaseTrain": {
               "defaultValue": "stable",
               "type": "String",
               "metadata": {
                   "description": "The release train."
               }
           }
       },
       "functions": [],
       "resources": [
           {
               "type": "Microsoft.KubernetesConfiguration/extensions",
               "apiVersion": "2021-09-01",
               "name": "[parameters('ExtensionInstanceName')]",
               "identity": {
                "type": "SystemAssigned"
               },
               "properties": {
                   "extensionType": "[parameters('ExtensionType')]",
                   "releaseTrain": "[parameters('ReleaseTrain')]",
                   "version": "[parameters('ExtensionVersion')]"
               },
               "scope": "[concat('Microsoft.Kubernetes/connectedClusters/', parameters('ConnectedClusterName'))]"
           }
       ]
   }
   

2. Agora defina as variáveis de ambiente usando o seguinte comando da CLI do Azure:

   export TEMPLATE_FILE_NAME=<template-file-path>
   export DEPLOYMENT_NAME=<desired-deployment-name>
   

3. Por fim, execute esse comando da CLI do Azure para instalar a extensão do Provedor de Segredos do Azure Key Vault:

   az deployment group create --name $DEPLOYMENT_NAME --resource-group $RESOURCE_GROUP --template-file $TEMPLATE_FILE_NAME
   

Agora, é possível exibir os recursos do provedor de segredos e usar a extensão no cluster.

Validar a instalação da extensão

Para confirmar a instalação bem-sucedida da extensão do Provedor de Segredos do Azure Key Vault, execute o comando a seguir.

az k8s-extension show --cluster-type connectedClusters --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --name akvsecretsprovider

Você verá uma saída semelhante a este exemplo.

{
  "aksAssignedIdentity": null,
  "autoUpgradeMinorVersion": true,
  "configurationProtectedSettings": {},
  "configurationSettings": {},
  "customLocationSettings": null,
  "errorInfo": null,
  "extensionType": "microsoft.azurekeyvaultsecretsprovider",
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Kubernetes/connectedClusters/$CLUSTER_NAME/providers/Microsoft.KubernetesConfiguration/extensions/akvsecretsprovider",
  "identity": {
    "principalId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "tenantId": null,
    "type": "SystemAssigned"
  },
  "location": null,
  "name": "akvsecretsprovider",
  "packageUri": null,
  "provisioningState": "Succeeded",
  "releaseTrain": "Stable",
  "resourceGroup": "$RESOURCE_GROUP",
  "scope": {
    "cluster": {
      "releaseNamespace": "kube-system"
    },
    "namespace": null
  },
  "statuses": [],
  "systemData": {
    "createdAt": "2022-05-12T18:35:56.552889+00:00",
    "createdBy": null,
    "createdByType": null,
    "lastModifiedAt": "2022-05-12T18:35:56.552889+00:00",
    "lastModifiedBy": null,
    "lastModifiedByType": null
  },
  "type": "Microsoft.KubernetesConfiguration/extensions",
  "version": "1.1.3"
}

Criar ou selecionar um Azure Key Vault

Em seguida, especifique o Azure Key Vault a ser usado com o cluster conectado. Se você ainda não tiver um Key Vault, crie um usando os comandos a seguir. Tenha em mente que o nome do cofre de chaves precisa ser globalmente exclusivo.

Defina as seguintes variáveis de ambiente:

export AKV_RESOURCE_GROUP=<resource-group-name>
export AZUREKEYVAULT_NAME=<AKV-name>
export AZUREKEYVAULT_LOCATION=<AKV-location>

Em seguida, execute o seguinte comando:

az keyvault create -n $AZUREKEYVAULT_NAME -g $AKV_RESOURCE_GROUP -l $AZUREKEYVAULT_LOCATION

O Azure Key Vault pode armazenar chaves, segredos e certificados. Neste exemplo, você pode definir um segredo de texto sem formatação chamado DemoSecret usando o seguinte comando:

az keyvault secret set --vault-name $AZUREKEYVAULT_NAME -n DemoSecret --value MyExampleSecret

Antes de passar para a próxima seção, anote as seguintes propriedades:

• Nome do objeto de segredo no Key Vault
• Tipo de objeto (segredo, chave ou certificado)
• Nome do seu recurso do Key Vault
• A ID do Locatário do Azure da assinatura à qual o Key Vault pertence

Fornecer identidade para acessar o Azure Key Vault

Atualmente, o Secrets Store CSI Driver nos clusters habilitados para Arc pode ser acessado por meio de uma entidade de serviço. Siga estas etapas para fornecer uma identidade que possa acessar o Key Vault.

1. Siga as etapas para criar uma entidade de serviço no Azure. Anote a ID do Cliente e o Segredo do Cliente gerados nesta etapa.

2. Em seguida, verifique se o Azure Key Vault tem a permissão GET para a entidade de serviço criada.

3. Use a ID do cliente e o Segredo do Cliente da primeira etapa para criar um segredo do Kubernetes no cluster conectado:

   kubectl create secret generic secrets-store-creds --from-literal clientid="<client-id>" --from-literal clientsecret="<client-secret>"
   

4. Rotule o segredo criado:

   kubectl label secret secrets-store-creds secrets-store.csi.k8s.io/used=true
   

5. Crie um SecretProviderClass com o seguinte YAML, preenchendo seus valores para o nome do cofre de chaves, a ID do locatário e os objetos para recuperar da sua instância do AKV:

   # This is a SecretProviderClass example using service principal to access Keyvault
   apiVersion: secrets-store.csi.x-k8s.io/v1
   kind: SecretProviderClass
   metadata:
     name: akvprovider-demo
   spec:
     provider: azure
     parameters:
       usePodIdentity: "false"
       keyvaultName: <key-vault-name>
       cloudName:                           # Defaults to AzurePublicCloud
       objects:  |
         array:
           - |
             objectName: DemoSecret
             objectType: secret             # object types: secret, key or cert
             objectVersion: ""              # [OPTIONAL] object versions, default to latest if empty
       tenantId: <tenant-Id>                # The tenant ID of the Azure Key Vault instance
   

   Para uso com nuvens nacionais, altere cloudName para AzureUSGovernmentCloud no Azure Governamental ou para AzureChinaCloud no Microsoft Azure operado pela 21Vianet.

6. Aplique o SecretProviderClass ao cluster:

   kubectl apply -f secretproviderclass.yaml
   

7. Crie um pod com o seguinte YAML, preenchendo o nome da sua identidade:

   # This is a sample pod definition for using SecretProviderClass and service principal to access Keyvault
   kind: Pod
   apiVersion: v1
   metadata:
     name: busybox-secrets-store-inline
   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: "akvprovider-demo"
           nodePublishSecretRef:                       
             name: secrets-store-creds
   

8. Aplique o pod ao cluster:

   kubectl apply -f pod.yaml
   

Validar os segredos

Depois que o pod é iniciado, o conteúdo montado no caminho do volume especificado no YAML de implantação fica disponível.

## show secrets held in secrets-store
kubectl exec busybox-secrets-store-inline -- ls /mnt/secrets-store/

## print a test secret 'DemoSecret' held in secrets-store
kubectl exec busybox-secrets-store-inline -- cat /mnt/secrets-store/DemoSecret

Opções de configuração adicionais

A extensão Azure Key Vault Secrets Provider dá suporte a configurações de gráfico do Helm.

As seguintes definições de configuração geralmente são usadas com a extensão Azure Key Vault Secrets Provider:

Essas configurações podem ser especificadas quando a extensão é instalada usando o comando az k8s-extension create:

az k8s-extension create --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --cluster-type connectedClusters --extension-type Microsoft.AzureKeyVaultSecretsProvider --name akvsecretsprovider --configuration-settings secrets-store-csi-driver.enableSecretRotation=true secrets-store-csi-driver.rotationPollInterval=3m secrets-store-csi-driver.syncSecret.enabled=true

Você também pode alterar essas configurações após a instalação usando o comando az k8s-extension update:

az k8s-extension update --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --cluster-type connectedClusters --name akvsecretsprovider --configuration-settings secrets-store-csi-driver.enableSecretRotation=true secrets-store-csi-driver.rotationPollInterval=3m secrets-store-csi-driver.syncSecret.enabled=true

Você pode usar outras definições de configuração conforme o necessário para a implantação. Por exemplo, para alterar o diretório raiz do kubelet ao criar um cluster, modifique o comando az k8s-extension create:

az k8s-extension create --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --cluster-type connectedClusters --extension-type Microsoft.AzureKeyVaultSecretsProvider --name akvsecretsprovider --configuration-settings linux.kubeletRootDir=/path/to/kubelet secrets-store-csi-driver.linux.kubeletRootDir=/path/to/kubelet

Desinstalar a extensão Azure Key Vault Secrets Provider

Para desinstalar a extensão, execute o seguinte comando:

az k8s-extension delete --cluster-type connectedClusters --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --name akvsecretsprovider

Para confirmar se a instância de extensão foi excluída, execute o seguinte comando:

az k8s-extension list --cluster-type connectedClusters --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP

Se a extensão foi removida com êxito, a extensão Provedor de Segredos do Azure Key Vault não estará listada na saída. Se nenhuma outra extensão estiver instalada no cluster, uma matriz vazia será retornada.

Se você não precisar mais dele, exclua o segredo do Kubernetes associado à entidade de serviço executando o seguinte comando:

kubectl delete secret secrets-store-creds

Reconciliação e solução de problemas

A extensão Azure Key Vault Secrets Provider tem autorrecuperação. Se alguém tentar alterar ou excluir um componente de extensão que foi implantado quando a extensão foi instalada, esse componente retornará ao estado original. As únicas exceções são para as CRDs (Definições de Recursos Personalizados). As CRDs excluídas não são reconciliadas. Para restaurar as CRDs excluídas, use o comando az k8s-extension create novamente com o nome da instância de extensão existente.

Para obter mais informações sobre como resolver problemas comuns, confira os guias de solução de problemas de código aberto do Provedor do Azure Key Vault para o driver CSI do Repositório de Segredos e o Driver CSI do Repositório de Segredos.

Próximas etapas

• Quer experimentar as novidades? Comece rapidamente com um cenário Azure Arc Jumpstart usando a API do Cluster.
• Saiba mais sobre o Azure Key Vault.
• Ajude a proteger seu cluster de outras formas ao seguir as orientações no livro de segurança do Kubernetes com Azure Arc habilitado.