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

Artigo
10/02/2024

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

As funcionalidades da extensão do Provedor de Segredos do Azure Key Vault 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

Dica

Se o acesso offline for necessário ou se você precisar de segredos sincronizados no repositório de segredos do Kubernetes, use a extensão Repositório de Segredos para gerenciamento de segredos em seus clusters do Kubernetes habilitados para Arc.

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 Stack HCI
- AKS habilitado pelo Azure Arc
- Mecanismo Kubernetes do Google
- Distribuição Kubernetes do OpenShift
- Distribuição Canonical Kubernetes
- Serviço de Kubernetes do Elastic
- Tanzu Kubernetes Grid
- 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 todos os pré-requisitos gerais das extensões de cluster foram atendidos. Use a versão 0.4.0 ou mais recente da extensão k8s-extension da CLI do Azure.

Instalar a extensão do Provedor de Segredos do Azure Key Vault em um cluster do Kubernetes habilitado para Arc

Você pode instalar a extensão do Provedor de Segredos do Azure Key Vault 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.

Dica

Se o cluster estiver atrás de um servidor proxy de saída, certifique-se de conectá-lo ao Azure Arc usando a opção configuração de proxy antes de instalar a extensão.

Portal do Azure

No portal do Azure, navegue até Kubernetes – Azure Arc e selecione seu cluster.
Selecione Extensões em Configurações e escolha + Adicionar.
Na lista de extensões disponíveis, selecione Provedor de Segredos do Azure Key Vault para implantar a versão mais recente da extensão.
Siga os prompts 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

Defina as variáveis de ambiente:

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

Instale o Driver CSI do Repositório de Segredos e a extensão do Provedor de Segredos do Azure Key Vault 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 de ARM

Crie um arquivo .json com o formato a seguir. Atualize o valor <cluster-name> 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'))]"
        }
    ]
}

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>

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 Driver CSI do Repositório de Segredos em 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.

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.
Em seguida, verifique se o Azure Key Vault tem a permissão GET para a entidade de serviço criada.

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>"

Rotule o segredo criado:

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

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 por 21Vianet.

Aplique SecretProviderClass ao cluster:

kubectl apply -f secretproviderclass.yaml

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

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 do provedor de segredos do Azure Key Vault 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 do Provedor de Segredos do Azure Key Vault:

Definição de configuração	Padrão	Descrição
enableSecretRotation	false	Tipo booliano. Se for `true`, ele atualizará periodicamente a montagem do pod e o Segredo do Kubernetes com o conteúdo mais recente do repositório de segredos externo
rotationPollInterval	2 m	Se `enableSecretRotation` for `true`, essa configuração especificará a duração do intervalo da enquete da rotação de segredos. Essa duração pode ser ajustada com base na frequência com que o conteúdo montado para todos os pods e segredos do Kubernetes precisa ser ressincronizado para a versão mais recente.
syncSecret.enabled	false	Entrada booliana. Em alguns casos, talvez você queira criar um Segredo do Kubernetes para espelhar o conteúdo montado. Se for `true`, `SecretProviderClass` permite que o campo `secretObjects` defina o estado desejado dos objetos de Segredo do Kubernetes sincronizados.

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 do Provedor de Segredos do Azure Key Vault

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

Observação

Desinstalar a extensão não exclui as CRDs (Definições de Recursos Personalizados) que foram criadas quando a extensão foi instalada.

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 for removida com êxito, você não verá a extensão do Provedor de Segredos do Azure Key Vault listada na saída. Se você não tiver nenhuma outra extensão instalada no cluster, verá apenas uma matriz vazia.

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 do Provedor de Segredos do Azure Key Vault 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 CRDs (Definições de Recursos Personalizados). Se as CRDs forem excluídas, elas não serã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 de Cluster.
Saiba mais sobre o Azure Key Vault.

Compartilhar via