Use a extensão Azure Key Vault Secrets Provider para buscar segredos em clusters do Kubernetes habilitados pelo Azure Arc.

O Azure Key Vault Provider for Secrets Store CSI Driver permite a integração do Azure Key Vault como um repositório de segredos com um cluster Kubernetes através de um volume CSI. Para clusters Kubernetes habilitados para Azure Arc, você pode instalar a extensão Azure Key Vault Secrets Provider para buscar segredos.

Os recursos da extensão Azure Key Vault Secrets Provider incluem:

• Monta segredos/chaves/certs no pod usando um volume CSI Inline
• Suporta portabilidade de pod com o CRD SecretProviderClass
• Suporta contêineres Linux e Windows
• Suporta a sincronização com Secrets do Kubernetes
• Suporta rotação automática de segredos
• Os componentes de extensão são implantados em zonas de disponibilidade, tornando-as redundantes entre zonas

Pré-requisitos

• Um cluster com uma distribuição Kubernetes suportada que está conectada ao Azure Arc. As seguintes distribuições Kubernetes são atualmente suportadas para este cenário:
  • Cluster API Azure
  • Clusters do Serviço Kubernetes do Azure (AKS) no Azure Local
  • AKS habilitado pelo Azure Arc
  • Motor Kubernetes do Google
  • Distribuição OpenShift Kubernetes
  • Distribuição canônica do Kubernetes
  • Serviço Elastic Kubernetes
  • Tanzu Kubernetes Grid
  • Azure Red Hat OpenShift
• Conectividade de saída para os seguintes pontos de extremidade:
  • linuxgeneva-microsoft.azurecr.io
  • upstreamarc.azurecr.io
  • *.blob.core.windows.net
• Certifique-se de atender aos pré-requisitos gerais para extensões de cluster. Você deve usar a versão 0.4.0 ou mais recente da extensão CLI do k8s-extension Azure.

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

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

Apenas uma instância da extensão pode ser implantada em cada cluster 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 instruçõ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 driver CSI do Secrets Store 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ê deve 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 usando o seguinte formato. Certifique-se de atualizar o <cluster-name> valor para fazer referência ao 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 este comando da CLI do Azure para instalar a extensão Azure Key Vault Secrets Provider:

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

Agora você deve ser capaz de exibir os recursos do provedor secreto e usar a extensão em seu cluster.

Validar a instalação da extensão

Para confirmar a instalação bem-sucedida da extensão Azure Key Vault Secrets Provider, execute o seguinte comando.

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

Você deve 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 Cofre da Chave do Azure

Em seguida, especifique o Cofre da Chave do Azure a ser usado com seu cluster conectado. Se você ainda não tiver um, crie um novo Cofre da Chave usando os seguintes comandos. Lembre-se de que o nome do cofre de chaves deve 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, tome nota das seguintes propriedades:

• Nome do objeto secreto no Cofre da Chave
• Tipo de objeto (segredo, chave ou certificado)
• Nome do recurso Cofre de Chaves
• A ID do Locatário do Azure para a assinatura à qual o Cofre da Chave pertence

Fornecer identidade para acessar o Azure Key Vault

Atualmente, o driver CSI do Secrets Store em clusters habilitados com Arc pode ser acessado por meio de um principal de serviço. Siga estas etapas para fornecer uma identidade que possa acessar seu Cofre de Chaves.

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

2. Em seguida, garanta que o Cofre de Chaves do Azure tenha permissão GET para o principal de serviço criado.

3. Use o ID do cliente e o segredo do cliente na 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. Etiquete 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 nome do cofre de chaves, ID do locatário e objetos para recuperar de sua instância 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 para Azure Government, ou para AzureChinaCloud para Microsoft Azure operado pela 21Vianet.

6. Aplique o SecretProviderClass ao seu 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

Após o início do pod, o conteúdo montado no caminho de volume especificado na configuração 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 Helm.

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

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

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 az k8s-extension update comando:

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 necessário para sua implantação. Por exemplo, para alterar o diretório raiz do kubelet ao criar um cluster, modifique o az k8s-extension create comando:

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 que 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 tiver sido removida com êxito, a extensão Azure Key Vault Secrets Provider 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, certifique-se de excluir 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 do Provedor de Segredos do Azure Key Vault é capaz de 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 será reconciliado com seu estado original. As únicas exceções são para Definições de Recursos Personalizados (CRDs). CRDs excluídos não são reconciliados. Para restaurar CRDs excluídos, 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, consulte os guias de solução de problemas de código aberto para o provedor Azure Key Vault do Secrets Store CSI Driver e para o Secrets Store CSI Driver.

Próximos passos

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