Utiliser le fournisseur Azure Key Vault pour le pilote CSI du magasin de secrets dans un cluster Azure Kubernetes Service (AKS)

• Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
• Vérifiez que votre version d’Azure CLI est 2.30.0 ou ultérieure. S’il s’agit d’une version antérieure, Installez la version la plus récente.

• Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

• Terraform version 1.6 ou ultérieure.

• Azure CLI installé et connecté. installez la dernière version.

• Autorisations pour créer des ressources AKS et Key Vault.

• Définissez votre abonnement Azure dans le Azure CLI avec la commande suivante. Remplacez <subscriptionId> par votre ID d’abonnement.

  az account set --subscription <subscriptionId>
  

Créer un cluster AKS

Créer un cluster AKS avec le fournisseur Azure Key Vault pour la prise en charge du pilote CSI du magasin de secrets.

1. Créez des variables utilisées dans les commandes pour créer un cluster AKS et Key Vault.

   export RANDOM_STRING=$(printf '%05d%05d' "$RANDOM" "$RANDOM")
   export KEYVAULT_NAME=myKeyVault${RANDOM_STRING}
   export RESOURCE_GROUP=myResourceGroup
   export CLUSTER_NAME=myAKSCluster
   export LOCATION=eastus2
   

   Les noms Azure Key Vault doivent être globalement uniques, alphanumériques, y compris les traits d’union et 3 à 24 caractères. Le nom du coffre de clés concatène la valeur KEYVAULT_NAME de la variable myKeyVaultRANDOM_STRING avec la chaîne de 10 caractères de la variable.

2. Créez un groupe de ressources Azure à l’aide de la commande az group create.

   az group create --name $RESOURCE_GROUP --location $LOCATION
   

3. Créez un cluster AKS avec la fonctionnalité du fournisseur Azure Key Vault pour le pilote CSI du magasin de secrets en utilisant la commande az aks create avec le paramètre --enable-addons azure-keyvault-secrets-provider.

   Le paramètre --enable-addons crée une identité managée attribuée à l'utilisateur, nommée azurekeyvaultsecretsprovider-xxxx, que vous pouvez utiliser pour authentifier votre accès à votre coffre de clés. L'identité gérée est stockée dans le groupe de ressources de nœud (MC_) et est automatiquement affectée à l'ensemble d'échelles de machines virtuelles. Vous pouvez utiliser cette identité managée ou votre identité managée pour accéder au coffre de clés. Cela n’est pas pris en charge pour empêcher la création de l’identité.

   az aks create \
     --name $CLUSTER_NAME \
     --resource-group $RESOURCE_GROUP \
     --enable-addons azure-keyvault-secrets-provider \
     --generate-ssh-keys
   

   Conseil / Astuce

   Si vous souhaitez utiliser l’ID de charge de travail Microsoft Entra, la commande az aks create doit inclure les paramètres --enable-oidc-issuer et --enable-workload-identity.

Créer un cluster AKS

Créez un fichier main.tf avec la configuration suivante pour créer un cluster AKS avec le fournisseur Azure Key Vault pour la prise en charge du Secrets Store CSI Driver.

1. Créez la configuration Terraform.

   terraform {
    required_version = ">= 1.6.0"
    required_providers {
      azurerm = {
        source  = "hashicorp/azurerm"
        version = "~> 4.0"
      }
    }
   }
   provider "azurerm" {
    features {}
   }
   data "azurerm_client_config" "current" {}
   resource "azurerm_resource_group" "rg" {
    name     = "aks-rg"
    location = "East US"
   }
   

2. Créez le cluster AKS.

   resource "azurerm_kubernetes_cluster" "aks" {
    name                = "aks-cluster"
    location            = azurerm_resource_group.rg.location
    resource_group_name = azurerm_resource_group.rg.name
    dns_prefix          = "akscsi"
    default_node_pool {
      name       = "system"
      node_count = 1
      vm_size    = "Standard_DS2_v2"
    }
    identity {
      type = "SystemAssigned"
    }
    key_vault_secrets_provider {
      secret_rotation_enabled = false
    }
   }
   

3. Déployez la configuration. Formez une session Bash, exécutez les commandes suivantes pour déployer les ressources :

   terraform init
   terraform validate
   terraform plan
   terraform apply
   

Mettre à jour un cluster AKS existant

Mettez à jour un cluster AKS existant avec Azure Key Vault provider pour la prise en charge de Secrets Store CSI Driver.

1. Créez des variables utilisées dans les commandes. Remplacez les valeurs si nécessaire pour mettre à jour votre cluster AKS existant ou Key Vault.

   Par exemple, si vous utilisez un coffre de clés existant, remplacez la valeur de la KEYVAULT_NAME variable sans utiliser la RANDOM_STRING variable.

   Si vous n’avez pas de coffre de clés, les noms Azure Key Vault doivent être globalement uniques, alphanumériques, y compris les traits d’union et 3 à 24 caractères. Le nom du coffre de clés concatène la valeur KEYVAULT_NAME de la variable myKeyVaultRANDOM_STRING avec la chaîne de 10 caractères de la variable. Vous pouvez créer le coffre de clés plus loin dans cet article.

   export RANDOM_STRING=$(printf '%05d%05d' "$RANDOM" "$RANDOM")
   export KEYVAULT_NAME=myKeyVault${RANDOM_STRING}
   export RESOURCE_GROUP=myResourceGroup
   export CLUSTER_NAME=myAKSCluster
   export LOCATION=eastus2
   

2. Mettez à jour un cluster AKS existant avec le fournisseur Azure Key Vault pour la fonctionnalité du pilote CSI du Store de Secrets en utilisant la commande az aks enable-addons et activez le module complémentaire azure-keyvault-secrets-provider. Le module complémentaire crée une identité gérée affectée par l’utilisateur, que vous pouvez utiliser pour vous authentifier auprès de votre coffre de clés.

   az aks enable-addons \
     --addons azure-keyvault-secrets-provider \
     --name $CLUSTER_NAME \
     --resource-group $RESOURCE_GROUP
   

   Après avoir activé le fournisseur de secrets Azure Key Vault, AKS crée une identité managée nommée azurekeyvaultsecretsprovider-xxxx que vous pouvez utiliser pour vous authentifier auprès de votre coffre de clés. L'identité gérée est stockée dans le groupe de ressources de nœud (MC_) et est automatiquement affectée à l'ensemble d'échelles de machines virtuelles. Vous pouvez utiliser cette identité managée ou votre identité managée pour accéder au coffre de clés. Cela n’est pas pris en charge pour empêcher la création de l’identité.

Mettre à jour un cluster AKS existant

Créez un fichier main.tf avec la configuration suivante pour mettre à jour un cluster AKS existant avec le fournisseur Azure Key Vault pour la prise en charge du Secret Store CSI Driver.

1. Mettre à jour un cluster AKS existant.

   resource "azurerm_kubernetes_cluster" "aks" {
    name                = "<existing-cluster>"
    resource_group_name = "<resource-group>"
    key_vault_secrets_provider {
      secret_rotation_enabled = false
    }
   }
   

2. Déployez la configuration. Formez une session Bash, exécutez les commandes suivantes pour déployer la configuration :

   Run the following commands to apply the updates:
   
   terraform init
   terraform validate
   terraform plan
   terraform apply
   

Vérifier l’installation du fournisseur d’identité gérée et de Key Vault.

Si vous avez utilisé Terraform pour créer un cluster ou mettre à jour un cluster existant, vous devez remplacer les variables comme $CLUSTER_NAME dans les commandes suivantes par les valeurs que vous avez utilisées dans votre configuration Terraform.

Vérifier l’identité managée

Procédez comme suit pour vérifier que l’identité managée a été créée et affectée au Scale Set de machines virtuelles du cluster.

1. Vérifiez que l’identité managée a été créée et affectée au cluster à l’aide de la az aks show commande.

   az aks show \
     --name $CLUSTER_NAME \
     --resource-group $RESOURCE_GROUP \
     --query addonProfiles
   

   {
     "azureKeyvaultSecretsProvider": {
       "config": {
         "enableSecretRotation": "false",
         "rotationPollInterval": "2m"
       },
       "enabled": true,
       "identity": {
         "clientId": "00001111-aaaa-2222-bbbb-3333cccc4444",
         "objectId": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
         "resourceId": "/subscriptions/<subscriptionID>/resourcegroups/MC_myResourceGroup_myAKSCluster_eastus2/providers/Microsoft.ManagedIdentity/userAssignedIdentities/azurekeyvaultsecretsprovider-myakscluster"
       }
     }
   }
   

   La resourceId propriété affiche le groupe de ressources et le nom azurekeyvaultsecretsprovider-myaksclusterde l’identité.

2. Vérifiez que l’identité managée est affectée à un ensemble de machines virtuelles du groupe de ressources de nœuds.

   NODE_RG=$(az aks show \
     --name $CLUSTER_NAME \
     --resource-group $RESOURCE_GROUP \
     --query nodeResourceGroup --output tsv)
   
   VMSS_NAME=$(az vmss list \
     --resource-group $NODE_RG \
     --query [].name --output tsv)
   
   az vmss show --name $VMSS_NAME --resource-group $NODE_RG --query '[id, identity]'
   

   La sortie affiche l’ID de ressource des jeux de mise à l'échelle de machines virtuelles Microsoft.Compute/virtualMachineScaleSets et la propriété userAssignedIdentities avec un ID de ressource pour azurekeyvaultsecretsprovider-myakscluster qui confirme que l’identité est affectée au jeu de mise à l'échelle de machines virtuelles.

Vérifier l’installation du fournisseur Azure Key Vault pour le pilote CSI du magasin de secrets

1. Obtenez les informations d’identification du cluster AKS à l’aide de la commande az aks get-credentials.

   az aks get-credentials \
     --name $CLUSTER_NAME \
     --resource-group $RESOURCE_GROUP
   

2. Vérifiez que l’installation est terminée à l’aide de la commande kubectl get pods, qui répertorie tous les pods avec les labels secrets-store-csi-driver et secrets-store-provider-azure dans le namespace kube-system.

   kubectl get pods -n kube-system -l 'app in (secrets-store-csi-driver,secrets-store-provider-azure)' -o wide
   

   L’indicateur o wide inclut le nœud sur lequel chaque pod s’exécute dans la sortie.

   Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

   NAME                                     READY   STATUS    RESTARTS   AGE    NODE
   aks-secrets-store-csi-driver-4vpkj       3/3     Running   2          4m25s  aks-nodepool1-12345678-vmss000002
   aks-secrets-store-csi-driver-ctjq6       3/3     Running   2          4m21s  aks-nodepool1-12345678-vmss000001
   aks-secrets-store-csi-driver-tlvlq       3/3     Running   2          4m24s  aks-nodepool1-12345678-vmss000000
   aks-secrets-store-provider-azure-5p4nb   1/1     Running   0          4m21s  aks-nodepool1-12345678-vmss000000
   aks-secrets-store-provider-azure-6pqmv   1/1     Running   0          4m24s  aks-nodepool1-12345678-vmss000001
   aks-secrets-store-provider-azure-f5qlm   1/1     Running   0          4m25s  aks-nodepool1-12345678-vmss000002
   

Créer un coffre de clés

Exécutez la az keyvault create commande pour créer un coffre de clés avec Azure RBAC activé.

az keyvault create \
  --name $KEYVAULT_NAME \
  --resource-group $RESOURCE_GROUP \
  --location $LOCATION \
  --enable-rbac-authorization

Azure RBAC est activé par défaut lorsque vous créez un coffre de clés même si vous n’incluez pas le --enable-rbac-authorization paramètre.

Pour plus d’informations sur les modèles d’autorisation de Key Vault et Azure RBAC, consultez Fournir l'accès aux clés, certificats et secrets de Key Vault avec un contrôle d’accès en fonction du rôle Azure.

Mettre à jour le coffre de clés existant

Exécutez la commande az keyvault update pour mettre à jour un coffre de clés existant avec Azure contrôle d’accès en fonction du rôle (Azure RBAC). Le paramètre --enable-rbac-authorization est nécessaire pour activer Azure RBAC lorsque vous mettez à jour un coffre de clés existant qui a Azure RBAC désactivé.

az keyvault update \
  --name $KEYVAULT_NAME \
  --resource-group $RESOURCE_GROUP \
  --enable-rbac-authorization

Pour plus d’informations sur les modèles d’autorisation key vault et Azure RBAC, consultez Fournir l’accès aux clés, certificats et secrets Key Vault avec un contrôle d’accès en fonction du rôle Azure

Ajouter l’attribution de rôle et le secret au Key Vault

1. Exécutez la commande az keyvault show pour vérifier que le Key Vault dispose du RBAC Azure activé.

   az keyvault show \
     --name $KEYVAULT_NAME \
     --resource-group $RESOURCE_GROUP \
     --query properties.enableRbacAuthorization
   

   La sortie doit être true.

2. Ajoutez une attribution de rôle à l'étendue du coffre de clés pour votre compte d’utilisateur à l’aide de la commande az role assignment create afin de pouvoir ajouter un secret de coffre de clés à l’étape suivante.

   Le rôle Agent des secrets Key Vault avec identificateur b86a8fe4-44ce-4948-aee5-eccb2c155cd7 unique est ajouté et vous pouvez utiliser le nom ou l’identificateur unique. L’utilisation de l’identificateur unique du rôle est une bonne pratique pour éviter les problèmes si le nom des rôles change.

   KEYVAULT_ID=$(az keyvault show \
     --name $KEYVAULT_NAME \
     --resource-group $RESOURCE_GROUP \
     --query id -o tsv)
   
   MYID=$(az ad signed-in-user show --query id --output tsv)
   
   az role assignment create \
     --assignee-object-id $MYID \
     --role "b86a8fe4-44ce-4948-aee5-eccb2c155cd7" \
     --scope $KEYVAULT_ID \
     --assignee-principal-type User
   

   L’attribution de rôle peut prendre plusieurs minutes. Vous pouvez vérifier que l’attribution de rôle a été créée avec la commande suivante :

   az role assignment list \
     --assignee-object-id $MYID \
     --scope $KEYVAULT_ID \
     --query '[].{Role:roleDefinitionName, Scope:scope}' \
     --output table
   

3. Créez un secret de texte brut nommé ExampleSecret dans le coffre de clés à l’aide de la az keyvault secret set commande.

   Votre coffre de clés peut stocker des clés, des secrets et des certificats. Le value paramètre utilise la RANDOM_STRING variable pour créer une valeur unique pour le secret.

   az keyvault secret set \
     --vault-name $KEYVAULT_NAME \
     --name ExampleSecret \
     --value MyAKSExampleSecret${RANDOM_STRING}
   

4. Vérifiez que le secret a été ajouté au coffre de clés en utilisant la commande az keyvault secret show.

   az keyvault secret show --vault-name $KEYVAULT_NAME --name ExampleSecret
   

Créer un coffre de clés

Mettez à jour votre fichier main.tf pour créer un coffre de clés avec Azure contrôle d’accès en fonction du rôle (Azure RBAC) activé.

1. Créez un coffre de clés avec Azure RBAC activé.

   data "azurerm_client_config" "current" {}
   resource "random_string" "suffix" {
    length  = 5
    special = false
    upper   = false
   }
   resource "azurerm_key_vault" "kv" {
    name                = "akskv${random_string.suffix.result}"
    location            = azurerm_resource_group.rg.location
    resource_group_name = azurerm_resource_group.rg.name
    tenant_id           = data.azurerm_client_config.current.tenant_id
    sku_name            = "standard"
    enable_rbac_authorization = true
   }
   

2. Attribuez le rôle d'agent des secrets du Key Vault.

   resource "azurerm_role_assignment" "kv_role" {
    scope                = azurerm_key_vault.kv.id
    role_definition_name = "Key Vault Secrets Officer"
    principal_id         = data.azurerm_client_config.current.object_id
   }
   

3. Créer ExampleSecret dans le coffre de clés.

   resource "azurerm_key_vault_secret" "example" {
    name         = "ExampleSecret"
    value        = "MyAKSExampleSecret"
    key_vault_id = azurerm_key_vault.kv.id
   }
   

4. Déployez la configuration. Formez une session Bash, exécutez les commandes suivantes pour déployer la configuration mise à jour :

   terraform plan
   terraform apply
   

5. Vérifiez que ExampleSecret a été ajouté au coffre de clés à l’aide de la az keyvault secret show commande. Remplacez <keyvault-name> par le nom du coffre de clés que vous avez créé dans votre configuration Terraform.

   az keyvault secret show \
    --vault-name <keyvault-name> \
    --name ExampleSecret
   

Mettre à jour le coffre de clés existant

Mettez à jour votre fichier main.tf pour mettre à jour un coffre de clés existant avec Azure contrôle d’accès en fonction du rôle (Azure RBAC) activé.

1. Mettez à jour le coffre de clés existant pour activer Azure RBAC.

   resource "azurerm_key_vault" "kv" {
    name                = "<existing-kv>"
    resource_group_name = "<resource-group>"
    enable_rbac_authorization = true
   }
   

2. Attribuez un rôle et ajoutez un secret.

   resource "azurerm_role_assignment" "kv_role" {
    scope                = azurerm_key_vault.kv.id
    role_definition_name = "Key Vault Secrets Officer"
    principal_id         = data.azurerm_client_config.current.object_id
   }
   resource "azurerm_key_vault_secret" "example" {
    name         = "ExampleSecret"
    value        = "MyAKSExampleSecret"
    key_vault_id = azurerm_key_vault.kv.id
   }
   

3. Déployez la configuration. Formez une session Bash, exécutez les commandes suivantes pour déployer la configuration mise à jour :

   terraform plan
   terraform apply
   

1. Supprimez les informations d’identification de votre cluster de votre fichier .kube/config local.

   KUBE_CONTEXT=$(kubectl config current-context)
   kubectl config delete-context $KUBE_CONTEXT
   

2. Supprimez le groupe de ressources et toutes les ressources qu’il contient, y compris les ressources du groupe de ressources de nœud (MC_) à l’aide de la az group delete commande.

   az group delete --name $RESOURCE_GROUP --yes --no-wait
   

La terraform destroy commande supprime toutes les ressources définies dans le fichier de configuration et d’état Terraform actuel. Exécutez uniquement cette commande à partir du répertoire de travail utilisé pour cet article.

1. Supprimez les informations d’identification de votre cluster de votre fichier .kube/config local.

   KUBE_CONTEXT=$(kubectl config current-context)
   kubectl config delete-context $KUBE_CONTEXT
   

2. Exécutez la commande suivante pour supprimer les ressources créées dans cet article :

   terraform destroy