Utiliser l’extension Fournisseur de secrets Azure Key Vault pour extraire des secrets dans des clusters Kubernetes activés pour Azure Arc

  • Article

Le fournisseur Azure Key Vault pour le pilote CSI du magasin de secrets permet d’intégrer Azure Key Vault comme magasin de secrets à un cluster Kubernetes via un volume CSI. Pour les clusters Kubernetes activés pour Azure Arc, vous pouvez installer l’extension Fournisseur de secrets Azure Key Vault pour extraire des secrets.

Les capacités de l’extension Fournisseur de secrets Azure Key Vault sont :

  • Monte des secrets/clés/certificats dans un pod à l’aide d’un volume CSI inlined
  • Prend en charge la portabilité de pod avec SecretProviderClass CRD
  • Prend en charge les conteneurs Linux et Windows
  • Prend en charge la synchronisation des secrets Kubernetes
  • Prend en charge la rotation automatique des secrets
  • Les composants de l’extension sont déployés dans des zones de disponibilité, ce qui les rend redondants interzone

Prérequis

  • Un cluster avec une distribution Kubernetes prise en charge qui a déjà été connectée à Azure Arc. Les distributions Kubernetes suivantes sont actuellement prises en charge pour ce scénario :
    • Cluster API Azure
    • Clusters Azure Kubernetes Service (AKS) sur Azure Stack HCI
    • AKS activé par Azure Arc
    • Google Kubernetes Engine
    • OpenShift Kubernetes Distribution
    • Canonical Kubernetes Distribution
    • Elastic Kubernetes Service
    • Tanzu Kubernetes Grid
    • Azure Red Hat OpenShift
  • Assurez-vous de respecter tous les prérequis généraux pour les extensions de cluster. Vous devez utiliser la version 0.4.0 ou ultérieure de l’extension Azure CLI k8s-extension.

Installer l’extension Fournisseur de secrets Azure Key Vault sur un cluster Kubernetes activé pour Arc

Vous pouvez installer l’extension Fournisseur de secrets Azure Key Vault dans votre cluster connecté depuis le Portail Azure, en utilisant Azure CLI ou en déployant un modèle ARM.

Une seule instance de l’extension peut être déployée sur chaque cluster Kubernetes activé pour Azure Arc.

Conseil

Si le cluster se trouve derrière un serveur proxy sortant, connectez-le à Azure Arc au moyen de l’option de configuration du proxy avant d’installer l’extension.

Portail Azure

  1. Dans le portail Azure, accédez à Kubernetes - Azure Arc, puis sélectionnez votre cluster.

  2. Sélectionnez Extensions (sous Paramètres), puis sélectionnez + Ajouter.

    Screenshot showing the Extensions page for an Arc-enabled Kubernetes cluster in the Azure portal.

  3. Dans la liste des extensions disponibles, sélectionnez Fournisseur de secrets Azure Key Vault pour déployer la dernière version de l’extension.

    Screenshot of the Azure Key Vault Secrets Provider extension in the Azure portal.

  4. Suivez les invites pour installer l’extension. Si nécessaire, personnalisez l’installation en modifiant les options par défaut dans l’onglet Configuration.

Azure CLI

  1. Définissez les variables d’environnement :

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

  2. Installez le pilote CSI du magasin de secrets et l’extension Fournisseur de secrets Azure Key Vault en exécutant la commande suivante :

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

La sortie doit ressembler à cet exemple. Plusieurs minutes peuvent s’écouler avant que le chart Helm du fournisseur de secrets soit déployé sur le 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"
}

Modèle ARM

  1. Créez un fichier .json en utilisant le format suivant. Veillez à mettre à jour la valeur <cluster-name> pour référencer votre 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. Définissez maintenant les variables d’environnement en utilisant la commande Azure CLI suivante :

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

  3. Enfin, exécutez cette commande Azure CLI pour installer l’extension Fournisseur de secrets Azure Key Vault :

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

Normalement, vous devez maintenant voir les ressources du fournisseur de secrets et pouvoir utiliser l’extension dans votre cluster.

Valider l’installation de l’extension

Pour vérifier la réussite de l’installation de l’extension Fournisseur de secrets Azure Key Vault, exécutez la commande suivante.

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

La sortie doit ressembler à cet exemple.

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

Créer ou sélectionner un coffre de clés Azure

Ensuite, spécifiez le coffre de clés Azure à utiliser avec votre cluster connecté. Si vous n’en avez pas déjà un, créez un coffre de clés en utilisant les commandes suivantes. Gardez à l’esprit que le nom de votre coffre de clés doit être en gros unique.

Définissez les variables d’environnement suivantes :

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

Exécutez ensuite la commande suivante :

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

Azure Key Vault peut stocker des clés, des secrets et des certificats. Pour cet exemple, vous pouvez définir un secret en texte brut appelé DemoSecret en utilisant la commande suivante :

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

Avant de passer à la section suivante, prenez note des propriétés suivantes :

  • Nom de l’objet secret dans Key Vault
  • Type d’objet (secret, clé ou certificat)
  • Nom de votre ressource Key Vault
  • ID de locataire Azure pour l’abonnement auquel appartient le coffre de clés

Fournir l’identité pour accéder Azure Key Vault

Actuellement, le pilote CSI du magasin de secrets sur les clusters activés pour Arc est accessible via un principal de service. Suivez ces étapes pour fournir une identité pouvant accéder à votre coffre de clés.

  1. Suivez les étapes pour créer un principal de service dans Azure. Notez l’ID client et la clé secrète client générés au cours de cette étape.

  2. Ensuite, assurez-vous qu’Azure Key Vault a l’autorisation GET au principal du service créé.

  3. Utilisez l’ID client et la clé secrète client de la première étape pour créer un secret Kubernetes sur le cluster connecté :

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

  4. Étiquetez le secret créé :

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

  5. Créez une SecretProviderClass avec le YAML suivant, en renseignant vos valeurs pour le nom du coffre de clés, l’ID de locataire et les objets à récupérer à partir de votre instance 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

    Pour une utilisation avec des clouds nationaux, remplacez cloudName par AzureUSGovernmentCloud pour Azure Government ou AzureChinaCloud pour Microsoft Azure géré par 21Vianet.

  6. Appliquez la SecretProviderClass à votre cluster :

    kubectl apply -f secretproviderclass.yaml

  7. Créez un pod avec le YAML suivant, en renseignant le nom de votre identité :

    # 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. Appliquez le pod à votre cluster :

    kubectl apply -f pod.yaml

Valider les secrets

Une fois le pod démarré, le contenu monté au niveau du chemin d’accès du volume spécifié dans le YAML de votre déploiement est disponible.

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

Options de configuration supplémentaires

L’extension Fournisseur de secrets d’Azure Key Vault prend en charge les configurations de graphique Helm.

Les paramètres de configuration suivants sont régulièrement employés avec l’extension Fournisseur de secrets d’Azure Key Vault :

Paramètre de configuration Default Description
enableSecretRotation false Type booléen. Si true, met à jour périodiquement le montage du pod et le secret Kubernetes avec le contenu le plus récent du magasin de secrets externes
rotationPollInterval 2 m Si enableSecretRotation est true, ce paramètre spécifie la durée de l’intervalle d’interrogation de rotation des secrets. Cette durée peut être ajustée en fonction de la fréquence à laquelle le contenu monté pour tous les pods et secrets Kubernetes doit être resynchronisé avec la dernière version.
syncSecret.enabled false Entrée booléenne. Dans certains cas, vous voulez créer un secret Kubernetes pour mettre en miroir le contenu monté. Si true, SecretProviderClass autorise le champ secretObjects à définir l’état souhaité des objets secrets Kubernetes synchronisés.

Ces paramètres peuvent être spécifiés quand l’extension est installée en utilisant la commande 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

Vous pouvez aussi modifier ces paramètres après l’installation en utilisant la commande 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

Vous pouvez utiliser d’autres paramètres de configuration si nécessaire pour votre déploiement. Par exemple, pour modifier le répertoire racine kubelet, lors de la création d’un cluster, modifiez la commande 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

Désinstaller l’extension Fournisseur de secrets Azure Key Vault

Pour installer l’extension, exécutez la commande suivante :

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

Notes

La désinstallation de l’extension ne supprime pas les définitions de ressources personnalisées (CRD) qui ont été créées lors de l’installation de l’extension.

Pour vérifier que l’instance de l’extension a été supprimée, exécutez la commande suivante :

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

Si l’extension a été supprimée avec succès, vous ne verrez pas l’extension Fournisseur de secrets Azure Key Vault répertoriée dans la sortie. Si vous n’avez pas d’autres extensions installées sur votre cluster, vous verrez un tableau vide.

Si vous n’en avez plus besoin, assurez-vous à supprimer le secret Kubernetes associé au principal de service en exécutant la commande suivante :

kubectl delete secret secrets-store-creds

Restauration à l’état d’origine et résolution des problèmes

L’extension Fournisseur de secrets Azure Key Vault est auto-réparatrice. Si quelqu’un tente de modifier ou de supprimer un composant d’extension déployé lors de l’installation de l’extension, ce composant est replacé à son état d’origine. Les seules exceptions concernent les définitions de ressources personnalisées (CRD). Si des définitions de ressources personnalisées sont supprimées, elles ne seront pas replacées à leur état d’origine. Pour restaurer les définitions de ressources personnalisées supprimées, réutilisez la commande az k8s-extension create avec le nom de l’instance d’extension existante.

Pour plus d’informations sur la résolution des problèmes courants, consultez les guides de résolution des problèmes open source pour le fournisseur Azure Key Vault pour le pilote CSI du magasin de secrets et pour le pilote CSI du magasin de secrets.

Étapes suivantes