Usa il provider Azure Key Vault per il driver CSI di Secrets Store in un cluster di Servizio Azure Kubernetes (AKS)

• Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.
• Verificare che la versione dell'interfaccia della riga di comando di Azure sia 2.30.0 o successiva. Se si tratta di una versione precedente, installare la versione più recente.

• Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

• Terraform versione 1.6 o successiva.

• interfaccia della riga di comando di Azure installato e connesso. installare la versione più recente.

• Autorizzazioni per creare risorse AKS e le risorse Key Vault.

• Impostare la sottoscrizione Azure nel interfaccia della riga di comando di Azure con il comando seguente. Sostituire <subscriptionId> con l'ID della sottoscrizione.

  az account set --subscription <subscriptionId>
  

Crea un cluster AKS

Creare un cluster AKS con il provider di Azure Key Vault per il supporto del Secrets Store CSI Driver.

1. Creare variabili usate nei comandi per creare un cluster del servizio Azure Kubernetes e 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
   

   I nomi di Azure Key Vault devono essere univoci a livello globale, alfanumerici, inclusi trattini e 3-24 caratteri. Il nome del Key Vault concatena il valore della variabile KEYVAULT_NAME con la stringa di 10 caratteri della variabile myKeyVault.

2. Creare un gruppo di risorse di Azure usando il comando az group create.

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

3. Creare un cluster AKS con il provider di Azure Key Vault per la funzionalità del Secrets Store CSI Driver usando il comando az aks create con il parametro --enable-addons azure-keyvault-secrets-provider.

   Il --enable-addons parametro crea un'identità gestita assegnata dall'utente chiamata azurekeyvaultsecretsprovider-xxxx che è possibile usare per autenticarsi al Key Vault. L'identità gestita viene archiviata nel gruppo di risorse del nodo (MC_) e viene assegnata automaticamente al set di scalabilità di macchine virtuali. È possibile usare questa identità gestita o la propria identità gestita per accedere all'insieme di credenziali delle chiavi. Non è supportato per impedire la creazione dell'identità.

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

   Suggerimento

   Se si intende utilizzare l'ID del carico di lavoro Microsoft Entra, il comando az aks create deve includere i parametri --enable-oidc-issuer e --enable-workload-identity.

Crea un cluster AKS

Creare un file main.tf con la seguente configurazione per creare un cluster AKS con provider Azure Key Vault per il supporto del Secrets Store CSI Driver.

1. Creare la configurazione di 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. Creare il 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. Eseguire la configurazione. Formare una sessione Bash, eseguire i comandi seguenti per distribuire le risorse:

   terraform init
   terraform validate
   terraform plan
   terraform apply
   

Aggiornare un cluster AKS esistente

Aggiorna un cluster AKS esistente con il provider di Azure Key Vault per il supporto del Secrets Store CSI Driver.

1. Creare variabili usate nei comandi. Sostituire i valori necessari per aggiornare il cluster AKS esistente o Key Vault.

   Ad esempio, se si usa un key vault esistente, sostituire il valore della variabile KEYVAULT_NAME senza usare la variabile RANDOM_STRING.

   Se non si ha un insieme di credenziali, i nomi di Azure Key Vault devono essere univoci a livello globale, composti da caratteri alfanumerici, inclusi i trattini, e devono avere una lunghezza compresa tra 3 e 24 caratteri. Il nome del Key Vault concatena il valore della variabile KEYVAULT_NAME con la stringa di 10 caratteri della variabile myKeyVault. Sarà possibile creare l'insieme di credenziali delle chiavi più avanti in questo articolo.

   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. Aggiornare un cluster del servizio Azure Kubernetes esistente con il provider Azure Key Vault per la funzionalità del driver CSI dell'archivio segreti usando il comando az aks enable-addons e abilitare il componente aggiuntivo azure-keyvault-secrets-provider. Il componente aggiuntivo crea un'identità gestita assegnata dall'utente che puoi utilizzare per autenticarti nel Key Vault.

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

   Dopo aver abilitato il provider di segreti di Azure Key Vault, AKS crea un'identità gestita denominata azurekeyvaultsecretsprovider-xxxx che è possibile usare per l'autenticazione al Key Vault. L'identità gestita viene archiviata nel gruppo di risorse del nodo (MC_) e viene assegnata automaticamente al set di scalabilità di macchine virtuali. È possibile usare questa identità gestita o la propria identità gestita per accedere all'insieme di credenziali delle chiavi. Non è supportato per impedire la creazione dell'identità.

Aggiornare un cluster AKS esistente

Creare un file main.tf con la configurazione seguente per aggiornare un cluster AKS esistente con il provider Azure Key Vault per il supporto del Secrets Store CSI Driver.

1. Aggiornare un cluster AKS esistente.

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

2. Eseguire la configurazione. Formare una sessione Bash, eseguire i comandi seguenti per distribuire la configurazione:

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

Verificare l'installazione dell'identità gestita e del provider dell'insieme di credenziali delle chiavi

Se Terraform è stato usato per creare un nuovo cluster o aggiornare un cluster esistente, è necessario sostituire le variabili come $CLUSTER_NAME nei comandi seguenti con i valori usati nella configurazione di Terraform.

Verificare l'identità gestita

Usare la procedura seguente per verificare che l'identità gestita sia stata creata e assegnata al set di scalabilità di macchine virtuali del cluster.

1. Verificare che l'identità gestita sia stata creata e assegnata al cluster usando il az aks show comando .

   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 proprietà resourceId mostra il gruppo di risorse e il nome dell'identità azurekeyvaultsecretsprovider-myakscluster.

2. Verifica che l'identità gestita sia assegnata al set di scalabilità di macchine virtuali del gruppo di risorse del nodo.

   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]'
   

   L'output mostra l'ID risorsa del set di scalabilità delle macchine virtuali Microsoft.Compute/virtualMachineScaleSets e la proprietà userAssignedIdentities con un ID risorsa per azurekeyvaultsecretsprovider-myakscluster che conferma l'assegnazione dell'identità al set di scalabilità delle macchine virtuali.

Verificare il provider di Azure Key Vault per l'installazione del Secrets Store CSI Driver.

1. Ottenere le credenziali del cluster del servizio Azure Kubernetes usando il comando az aks get-credentials.

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

2. Verificare che l'installazione sia terminata usando il comando kubectl get pods, che elenca tutti i pod con le etichette secrets-store-csi-driver e secrets-store-provider-azure nello spazio dei nomi kube-system.

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

   Il flag -o wide include il nodo in cui è in esecuzione ogni pod nell'output.

   L'output dovrebbe essere simile all'esempio di output seguente:

   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
   

Creare un nuovo key vault

Eseguire il comando az keyvault create per creare un nuovo insieme di credenziali delle chiavi con il controllo degli accessi in base al ruolo di Azure abilitato.

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

Il controllo degli accessi in base al ruolo di Azure è abilitato per impostazione predefinita quando si crea un nuovo insieme di credenziali anche se non si include il parametro --enable-rbac-authorization.

Per ulteriori informazioni sui modelli di autorizzazione di Key Vault e sul controllo degli accessi in base ai ruoli di Azure, vedere Concedere l'accesso a chiavi, certificati e segreti di Key Vault con un controllo degli accessi in base ai ruoli di Azure.

Aggiornare l'insieme di credenziali delle chiavi esistente

Eseguire il comando az keyvault update per aggiornare una cassaforte delle chiavi esistente con il controllo degli accessi in base al ruolo di Azure (Azure RBAC). Il parametro --enable-rbac-authorization è necessario per abilitare Azure RBAC quando si aggiorna un insieme di credenziali esistente con Azure RBAC disabilitato.

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

Per ulteriori informazioni sui modelli di autorizzazione di Key Vault e sul controllo degli accessi in base al ruolo di Azure, vedere Fornire l'accesso a chiavi, certificati e segreti di Key Vault con un controllo degli accessi in base al ruolo di Azure

Aggiungere un'assegnazione di ruolo e un segreto a Key Vault

1. Eseguire il comando az keyvault show per verificare che il Key Vault abbia Azure RBAC abilitato.

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

   L'output deve essere true.

2. Aggiungi un'assegnazione di ruolo per l'account utente all'ambito del Key Vault usando il comando az role assignment create in modo da poter aggiungere un segreto del Key Vault nel passaggio successivo.

   Il ruolo Responsabile dei Segreti di Key Vault con identificatore univoco b86a8fe4-44ce-4948-aee5-eccb2c155cd7 viene aggiunto ed è possibile utilizzare il nome o l'identificatore univoco. L'uso dell'identificatore univoco del ruolo è una procedura consigliata per evitare problemi se il nome dei ruoli cambia.

   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'applicazione dell'assegnazione di ruolo può richiedere alcuni minuti. È possibile verificare che l'assegnazione di ruolo sia stata creata con il comando seguente:

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

3. Creare un segreto di testo in chiaro denominato ExampleSecret nell'archivio delle chiavi usando il comando az keyvault secret set.

   Il tuo archivio di chiavi può conservare chiavi, segreti e certificati. Il value parametro usa la RANDOM_STRING variabile per creare un valore univoco per il segreto.

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

4. Verifica che il segreto sia stato aggiunto nell'insieme di credenziali delle chiavi tramite il comando [az keyvault secret show][az-keyvault-secret-show].

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

Creare un nuovo key vault

Aggiorna il file main.tf per creare un nuovo Key Vault con il controllo degli accessi in base ai ruoli di Azure (Azure RBAC) abilitato.

1. Creare un insieme di credenziali delle chiavi con RBAC di Azure abilitato.

   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. Assegnare il ruolo di Responsabile dei segreti di 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. Creare ExampleSecret nel key vault.

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

4. Eseguire la configurazione. Formare una sessione Bash, eseguire i comandi seguenti per distribuire la configurazione aggiornata:

   terraform plan
   terraform apply
   

5. Verificare che ExampleSecret sia stato aggiunto al Key Vault usando il comando [az keyvault secret show][az-keyvault-secret-show]. Sostituire <keyvault-name> con il nome dell'insieme di credenziali creato nella configurazione di Terraform.

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

Aggiornare l'insieme di credenziali delle chiavi esistente

Aggiorna il file main.tf per aggiornare un Key Vault esistente con il controllo degli accessi basato sui ruoli di Azure (Azure RBAC) abilitato.

1. Aggiornare l'insieme di credenziali esistente per abilitare Azure RBAC.

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

2. Assegna un ruolo e aggiungi un segreto.

   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. Eseguire la configurazione. Formare una sessione Bash, eseguire i comandi seguenti per distribuire la configurazione aggiornata:

   terraform plan
   terraform apply
   

1. Rimuovi le credenziali del tuo cluster dal file locale .kube/config.

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

2. Eliminare il gruppo di risorse e tutte le risorse al suo interno, incluse le risorse nel gruppo di risorse del nodo (MC_) usando il az group delete comando .

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

Il terraform destroy comando rimuove tutte le risorse definite nella configurazione di Terraform corrente e nel file di stato. Eseguire questo comando solo dalla directory di lavoro usata per questo articolo.

1. Rimuovi le credenziali del tuo cluster dal file locale .kube/config.

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

2. Eseguire il comando seguente per rimuovere le risorse create in questo articolo:

   terraform destroy