Använda Azure Key Vault-providern för Secrets Store CSI Driver i ett AKS-kluster (Azure Kubernetes Service)

• Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.
• Kontrollera att din version av Azure CLI är 2.30.0 eller senare. Om det är en tidigare version installerar du den senaste versionen.

• Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.

• Terraform som är version 1.6 eller senare.

• Azure CLI installerat och loggat in. installera den senaste versionen.

• Behörigheter för att skapa AKS och Key Vault resurser.

• Ange din Azure-prenumeration i Azure CLI med följande kommando. Ersätt <subscriptionId> med ditt prenumerations-ID.

  az account set --subscription <subscriptionId>
  

Skapa ett AKS-kluster

Skapa ett AKS-kluster med Azure Key Vault-leverantören för stöd av Secrets Store CSI Driver.

1. Skapa variabler som används i kommandona för att skapa ett AKS-kluster och 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
   

   Azure Key Vault-namn måste vara globalt unika, alfanumeriska, inklusive bindestreck och 3–24 tecken. Namnet på nyckelvalvet sammanfogar KEYVAULT_NAME variabelns myKeyVault värde med RANDOM_STRING variabelns sträng på 10 tecken.

2. Skapa en Azure-resursgrupp med kommandot az group create .

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

3. Skapa ett AKS-kluster med Azure Key Vault-providern för CSI-drivrutinsfunktionen i Secrets Store med hjälp av az aks create kommandot med parametern --enable-addons azure-keyvault-secrets-provider .

   Parametern --enable-addons skapar en användartilldelad hanterad identitet med namnet azurekeyvaultsecretsprovider-xxxx som du kan använda för att autentisera till ditt nyckelvalv. Den hanterade identiteten lagras i nodens resursgrupp (MC_) och tilldelas automatiskt till skaleringsuppsättningen för virtuella maskiner. Du kan använda den här hanterade identiteten eller din egen hanterade identitet för att få åtkomst till nyckelvalvet. Det är inte möjligt att förhindra skapandet av identiteten.

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

   Tips/Råd

   Om du vill använda Microsoft Entra-arbetsbelastnings-ID az aks create måste kommandot innehålla parametrarna --enable-oidc-issuer och --enable-workload-identity .

Skapa ett AKS-kluster

Skapa en main.tf fil och kopiera följande testade exempelkonfiguration till den. Lagringsplatsen Azure Terraform GitHub underhåller exemplet. Exemplet skapar resursgruppen, AKS-klustret, Azure Key Vault, exempelhemligheten och de nödvändiga rolltilldelningarna.

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. Distribuera konfigurationen. Från en Bash-session kör du följande kommandon för att distribuera resurserna:

   terraform init
   terraform validate
   terraform plan
   terraform apply
   

2. Ange variablerna som används i de återstående kommandona från Terraform-utdata:

   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)
   

Uppdatera ett befintligt AKS-kluster

Uppdatera ett befintligt AKS-kluster med Azure Key Vault-providern för CSI-drivrutinsstöd för Secrets Store.

1. Skapa variabler som används i kommandona. Ersätt värdena efter behov för att uppdatera ditt befintliga AKS-kluster eller Key Vault.

   Om du till exempel använder ett befintligt nyckelvalv ersätter KEYVAULT_NAME du variabelns värde utan att använda variabeln RANDOM_STRING .

   Om du inte har något nyckelvalv måste Azure Key Vault-namn vara globalt unika, alfanumeriska, inklusive bindestreck och 3–24 tecken. Namnet på nyckelvalvet sammanfogar KEYVAULT_NAME variabelns myKeyVault värde med RANDOM_STRING variabelns sträng på 10 tecken. Du kan skapa nyckelvalvet senare i den här artikeln.

   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. Uppdatera ett befintligt AKS-kluster med Azure Key Vault-providern för CSI-drivrutinsfunktionen i Secrets Store med hjälp av az aks enable-addons kommandot och aktivera azure-keyvault-secrets-provider tillägget. Tillägget skapar en användartilldelad hanterad identitet som du kan använda för att autentisera till ditt nyckelvalv.

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

   När du har aktiverat Azure Key Vault-hemlighetsprovidern skapar AKS en hanterad identitet med namnet azurekeyvaultsecretsprovider-xxxx som du kan använda för att autentisera till ditt nyckelvalv. Den hanterade identiteten lagras i nodens resursgrupp (MC_) och tilldelas automatiskt till skaleringsuppsättningen för virtuella maskiner. Du kan använda den här hanterade identiteten eller din egen hanterade identitet för att få åtkomst till nyckelvalvet. Det är inte möjligt att förhindra skapandet av identiteten.

Verifiera installationen av den hanterade identiteten och nyckelvalvsprovidern

Följande kommandon använder variablerna $CLUSTER_NAME och $RESOURCE_GROUP . De Azure CLI arbetsflödena definierar dessa variabler tidigare, och Terraform-arbetsflödet anger dem från utdata efter distributionen.

Verifiera den hanterade identiteten

Använd följande steg för att verifiera att en hanterad identitet skapades och tilldelades skalningsuppsättningen för klustrets virtuella maskiner.

1. Kontrollera att den hanterade identiteten skapades och tilldelades klustret med hjälp av az aks show kommandot .

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

   Egenskapen resourceId visar resursgruppen och identitetens namn azurekeyvaultsecretsprovider-myakscluster.

2. Kontrollera att den hanterade identiteten har tilldelats nodresursgruppens skalningsuppsättning för virtuella datorer.

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

   Utdata visar resurs-ID för Virtuella Maskinskalningsuppsättningar Microsoft.Compute/virtualMachineScaleSets och egenskapen userAssignedIdentities med ett resurs-ID för azurekeyvaultsecretsprovider-myakscluster som bekräftar att identiteten har tilldelats den Virtuella Maskinskalningsuppsättningen.

Verifiera installationen av Azure Key Vault-providern för Secrets Store CSI-drivrutinen

1. Hämta autentiseringsuppgifterna för AKS-klustret med hjälp av az aks get-credentials kommandot .

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

2. Kontrollera att installationen är klar med kubectl get pods kommandot som visar alla poddar med secrets-store-csi-driver etiketterna och secrets-store-provider-azure i kube-system namnområdet.

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

   Flaggan -o wide innehåller den nod som varje podd körs på i utdata.

   Dina utdata bör se ut ungefär som följande exempelutdata:

   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
   

Skapa nytt nyckelvalv

az keyvault create Kör kommandot för att skapa ett nytt nyckelvalv med Azure RBAC aktiverat.

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

Azure RBAC är aktiverat som standard när du skapar ett nytt nyckelvalv även om du inte inkluderar parametern --enable-rbac-authorization .

För mer information om behörighetsmodeller för Key Vault och Azure RBAC, se Ge åtkomst till Key Vault-nycklar, certifikat och hemligheter med Azure rollbaserad åtkomstkontroll.

Uppdatera befintligt nyckelvalv

Kör kommandot az keyvault update för att uppdatera ett befintligt nyckelvalv med Azure rollbaserad åtkomstkontroll (Azure RBAC). Parametern --enable-rbac-authorization krävs för att aktivera Azure RBAC när du uppdaterar ett befintligt nyckelvalv som har Azure RBAC inaktiverat.

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

Mer information om nyckelvalvsbehörighetsmodeller och Azure RBAC finns i Ge åtkomst till Key Vault-nycklar, certifikat och hemligheter med en rollbaserad åtkomstkontroll i Azure

Lägg till rolltilldelning och hemlighet i nyckelvalvet

1. Kör kommandot az keyvault show för att kontrollera att nyckelvalvet har Azure RBAC aktiverat.

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

   Utdata ska vara true.

2. Lägg till en rolltilldelning för ditt användarkonto i nyckelvalvets omfång med az role assignment create kommandot så att du kan lägga till en hemlighet i nyckelvalvet i nästa steg.

   Rollen Key Vault Secrets Officer med unik identifierare b86a8fe4-44ce-4948-aee5-eccb2c155cd7 läggs till och du kan använda antingen namnet eller den unika identifieraren. Det är bra att använda rollens unika identifierare för att förhindra problem om rollnamnet ändras.

   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
   

   Det kan ta flera minuter innan rolltilldelningen börjar gälla. Du kan kontrollera att rolltilldelningen skapades med följande kommando:

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

3. Skapa en oformaterad hemlighet med namnet ExampleSecret i nyckelvalvet med kommandot az keyvault secret set .

   Ditt nyckelvalv kan lagra nycklar, hemligheter och certifikat. Parametern value använder variabeln RANDOM_STRING för att skapa ett unikt värde för hemligheten.

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

4. Kontrollera att hemligheten har lagts till i nyckelvalvet med kommandot az keyvault secret show .

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

Skapa nytt nyckelvalv

Terraform-exemplet som ingick tidigare skapar ett nytt nyckelvalv med Azure RBAC aktiverat, tilldelar nödvändiga roller och skapar ExampleSecret. Ingen separat konfigurationsuppdatering krävs.

1. Hämta nyckelvalvets namn från Terraform-utdata.

   KEYVAULT_NAME=$(terraform output -raw key_vault_name)
   

2. Kontrollera att ExampleSecret har lagts till i nyckelvalvet med kommandot az keyvault secret show.

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

1. Ta bort klustrets autentiseringsuppgifter från din lokala .kube/config-fil .

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

2. Ta bort resursgruppen och alla resurser i den, inklusive resurser i nodresursgruppen (MC_) med kommandot az group delete .

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

Kommandot terraform destroy tar bort alla resurser som definierats i den aktuella Terraform-konfigurations- och tillståndsfilen. Kör endast det här kommandot från arbetskatalogen som används för den här artikeln.

1. Ta bort klustrets autentiseringsuppgifter från din lokala .kube/config-fil .

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

2. Kör följande kommando för att ta bort resurserna som skapats i den här artikeln:

   terraform destroy