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 main.tf file e copiarne la configurazione di esempio testata seguente. Il repository GitHub di Azure Terraform mantiene l'esempio. L'esempio crea il gruppo di risorse, il cluster AKS, Azure Key Vault, il segreto di esempio e le assegnazioni di ruolo necessarie.

terraform {
  required_version = ">= 1.5.0"

  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 3.116"
    }
    random = {
      source  = "hashicorp/random"
      version = "~> 3.6"
    }
  }
}

provider "azurerm" {
  features {
    resource_group {
      prevent_deletion_if_contains_resources = false
    }
  }
}

data "azurerm_client_config" "current" {}

resource "random_string" "suffix" {
  length  = 6
  upper   = false
  special = false
}

locals {
  location            = "eastus"
  resource_group_name = "rg-aks-kv-csi-demo-${random_string.suffix.result}"
  aks_name            = "aks-kv-csi-demo"
  key_vault_name      = "kvcsidemo${random_string.suffix.result}"
  secret_name         = "ExampleSecret"
}

resource "azurerm_resource_group" "this" {
  name     = local.resource_group_name
  location = local.location
}

resource "azurerm_log_analytics_workspace" "this" {
  name                = "law-aks-kv-csi-demo"
  location            = azurerm_resource_group.this.location
  resource_group_name = azurerm_resource_group.this.name
  sku                 = "PerGB2018"
  retention_in_days   = 30
}

resource "azurerm_kubernetes_cluster" "this" {
  name                      = local.aks_name
  location                  = azurerm_resource_group.this.location
  resource_group_name       = azurerm_resource_group.this.name
  dns_prefix                = "akskvcsidemo"
  kubernetes_version        = null
  oidc_issuer_enabled       = true
  workload_identity_enabled = true

  default_node_pool {
    name       = "system"
    node_count = 1
    vm_size    = "Standard_D2s_v3"

    upgrade_settings {
      drain_timeout_in_minutes      = 0
      max_surge                     = "10%"
      node_soak_duration_in_minutes = 0
    }
  }

  identity {
    type = "SystemAssigned"
  }

  key_vault_secrets_provider {
    secret_rotation_enabled = false
  }

  oms_agent {
    log_analytics_workspace_id = azurerm_log_analytics_workspace.this.id
  }

  network_profile {
    network_plugin    = "azure"
    load_balancer_sku = "standard"
  }

  tags = {
    scenario = "aks-keyvault-csi"
  }
}

resource "azurerm_key_vault" "this" {
  name                          = local.key_vault_name
  location                      = azurerm_resource_group.this.location
  resource_group_name           = azurerm_resource_group.this.name
  tenant_id                     = data.azurerm_client_config.current.tenant_id
  sku_name                      = "standard"
  purge_protection_enabled      = false
  soft_delete_retention_days    = 7
  enable_rbac_authorization     = true
  public_network_access_enabled = true
}

resource "azurerm_role_assignment" "current_user_kv_admin" {
  scope                = azurerm_key_vault.this.id
  role_definition_name = "Key Vault Administrator"
  principal_id         = data.azurerm_client_config.current.object_id
}

resource "azurerm_key_vault_secret" "example" {
  name         = local.secret_name
  value        = "HelloFromKeyVault"
  key_vault_id = azurerm_key_vault.this.id

  depends_on = [
    azurerm_role_assignment.current_user_kv_admin
  ]
}

resource "azurerm_role_assignment" "aks_csi_secrets_user" {
  scope                = azurerm_key_vault.this.id
  role_definition_name = "Key Vault Secrets User"
  # This is the managed identity automatically created by the AKS Key Vault CSI addon.
  principal_id = azurerm_kubernetes_cluster.this.key_vault_secrets_provider[0].secret_identity[0].object_id
}

output "resource_group_name" {
  value = azurerm_resource_group.this.name
}

output "aks_cluster_name" {
  value = azurerm_kubernetes_cluster.this.name
}

output "key_vault_name" {
  value = azurerm_key_vault.this.name
}

output "key_vault_secret_name" {
  value = azurerm_key_vault_secret.example.name
}

output "tenant_id" {
  value = data.azurerm_client_config.current.tenant_id
}

output "aks_csi_client_id" {
  value = azurerm_kubernetes_cluster.this.key_vault_secrets_provider[0].secret_identity[0].client_id
}

output "aks_csi_object_id" {
  value = azurerm_kubernetes_cluster.this.key_vault_secrets_provider[0].secret_identity[0].object_id
}

1. Eseguire la configurazione. Da una sessione Bash eseguire i comandi seguenti per distribuire le risorse:

   terraform init
   terraform validate
   terraform plan
   terraform apply
   

2. Impostare le variabili usate nei comandi rimanenti dagli output di Terraform:

   export RESOURCE_GROUP=$(terraform output -raw resource_group_name)
   export CLUSTER_NAME=$(terraform output -raw aks_cluster_name)
   export KEYVAULT_NAME=$(terraform output -raw key_vault_name)
   

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 utilizza un insieme di credenziali 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à.

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

I comandi seguenti usano le $CLUSTER_NAME variabili e $RESOURCE_GROUP . I flussi di lavoro interfaccia della riga di comando di Azure definiscono queste variabili in precedenza e il flusso di lavoro Terraform li imposta dagli output dopo la distribuzione.

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. Verificare 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. Verificare che il segreto sia stato aggiunto al Key Vault usando il comando az keyvault secret show.

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

Creare un nuovo key vault

L'esempio di Terraform descritto in precedenza crea un nuovo insieme di credenziali con RBAC di Azure abilitato, assegna i ruoli necessari e crea ExampleSecret. Non è necessario alcun aggiornamento di configurazione separato.

1. Ottieni il nome del Key Vault nell'output di Terraform.

   KEYVAULT_NAME=$(terraform output -raw key_vault_name)
   

2. Verificare che ExampleSecret sia stato aggiunto all'insieme di credenziali delle chiavi usando il comando az keyvault secret show.

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

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