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

Artigo
09/28/2024

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 por meio 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 sincronização com segredos do Kubernetes
Suporta rotação automática de segredos
Os componentes de extensão são implantados em zonas de disponibilidade, tornando-as redundantes de zona

Gorjeta

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 Secret Store para gerenciamento de segredos em seus clusters Kubernetes habilitados para Arc.

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 Stack HCI
- 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
Verifique se você atendeu 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.

Gorjeta

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 de 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, em seguida, selecione + Adicionar.
Na lista de extensões disponíveis, selecione Azure Key Vault Secrets Provider para implantar a versão mais recente da extensão.
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

Defina as variáveis de ambiente:

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

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 ARM

Crie um arquivo .json usando o seguinte formato. Certifique-se de atualizar o valor de nome> do <cluster 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 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 da Chave
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 para Arc pode ser acessado por meio de uma entidade de serviço. Siga estas etapas para fornecer uma identidade que possa acessar seu Cofre de Chaves.

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 Cofre da Chave do Azure tem permissão GET para a entidade de serviço criada.

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

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 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, mude cloudName para AzureUSGovernmentCloud Azure Government ou para Microsoft AzureChinaCloud Azure operado pela 21Vianet.

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

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

Definição de configuração	Predefinido	Description
enableSecretRotation	false	Tipo booleano. Se `true`, atualiza periodicamente a montagem do pod e o Kubernetes Secret com o conteúdo mais recente do armazenamento de segredos externos
rotaçãoPollInterval	2 metros	Se `enableSecretRotation` for `true`, essa configuração especifica a duração do intervalo de sondagem de rotação secreta. 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 com o mais recente.
syncSecret.enabled	false	Entrada booleana. Em alguns casos, você pode querer criar um segredo do Kubernetes para espelhar o conteúdo montado. If `true`, `SecretProviderClass` permite que o `secretObjects` campo defina o estado desejado dos objetos Kubernetes Secret sincronizados.

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

Nota

A desinstalação da extensão não exclui as CRDs (Custom Resource Definitions) que foram criadas quando a extensão foi instalada.

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, você não verá a extensão do Provedor de Segredos do Cofre de Chaves do Azure listada na saída. Se você não tiver outras extensões instaladas no cluster, verá uma matriz vazia.

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 é autorrecuperável. 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). Se os CRDs forem excluídos, eles não serão reconciliados. Para restaurar CRDs excluídos, use o az k8s-extension create comando 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 do Azure Key Vault para driver CSI do Secrets Store e o driver CSI do Secrets Store.

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.

Partilhar via