Używanie dostawcy Azure Key Vault dla sterownika Secrets Store CSI w klastrze Azure Kubernetes Service (AKS)

• Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.
• Sprawdź, czy wersja interfejsu wiersza polecenia platformy Azure to 2.30.0 lub nowsza. Jeśli jest to starsza wersja, zainstaluj najnowszą wersję.

• Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

• Narzędzie Terraform w wersji 1.6 lub nowszej.

• Azure CLI zainstalowane i zalogowane. instaluj najnowszą wersję.

• Uprawnienia do tworzenia zasobów AKS i Key Vault.

• Ustaw subskrypcję Azure w Azure CLI za pomocą następującego polecenia. Zastąp <subscriptionId> identyfikatorem subskrypcji.

  az account set --subscription <subscriptionId>
  

Utwórz klaster AKS

Utwórz klaster AKS za pomocą dostawcy Azure Key Vault w celu obsługi Secrets Store CSI Driver.

1. Utwórz zmienne, które są używane w poleceniach do tworzenia klastra AKS i 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
   

   Nazwy usługi Azure Key Vault muszą być globalnie unikatowe, alfanumeryczne, w tym łączniki i 3–24 znaki. Nazwa magazynu kluczy łączy wartość zmiennej KEYVAULT_NAME z 10-znakowym ciągiem zmiennej myKeyVault.

2. Utwórz grupę zasobów platformy Azure przy użyciu az group create polecenia .

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

3. pl-PL: Utwórz klaster AKS przy użyciu dostawcy Azure Key Vault dla sterownika CSI Sklepu Tajemnic przy użyciu polecenia az aks create z parametrem --enable-addons azure-keyvault-secrets-provider.

   Parametr --enable-addons tworzy zarządzaną tożsamość użytkownika o nazwie azurekeyvaultsecretsprovider-xxxx, której można użyć do uwierzytelniania w Twoim magazynie kluczy. Tożsamość zarządzana jest przechowywana w grupie zasobów węzła (MC_) i jest automatycznie przypisywana do zestawu skalowania maszyn wirtualnych. Możesz użyć tej zarządzanej tożsamości lub swojej własnej zarządzanej tożsamości, aby uzyskać dostęp do Key Vault. Zapobieganie tworzeniu tożsamości nie jest obsługiwane.

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

   Wskazówka

   Jeśli chcesz użyć Tożsamość obciążeń Microsoft Entra, polecenie az aks create musi zawierać parametry --enable-oidc-issuer i --enable-workload-identity.

Utwórz klaster AKS

Utwórz plik i skopiuj do niego następującą przetestowaną main.tf przykładową konfigurację. Repozytorium GitHub programu Terraform Azure obsługuje przykład. Przykład tworzy grupę zasobów, klaster usługi AKS, usługę Azure Key Vault, przykładowy wpis tajny i wymagane przypisania ról.

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. Wdróż konfigurację. W sesji Bash uruchom następujące polecenia, aby wdrożyć zasoby:

   terraform init
   terraform validate
   terraform plan
   terraform apply
   

2. Ustaw zmienne używane w pozostałych poleceniach na podstawie danych wyjściowych 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)
   

Aktualizowanie istniejącego klastra usługi AKS

Zaktualizuj istniejący klaster usługi AKS za pomocą dostawcy usługi Azure Key Vault na potrzeby obsługi sterowników CSI magazynu wpisów tajnych.

1. Utwórz zmienne, które są używane w poleceniach. Zastąp wartości w razie potrzeby, aby zaktualizować istniejący klaster AKS lub Key Vault.

   Jeśli na przykład używasz istniejącego magazynu kluczy, zastąp wartość zmiennej KEYVAULT_NAME bez użycia zmiennej RANDOM_STRING.

   Jeśli nie masz magazynu kluczy, nazwy usługi Azure Key Vault muszą być globalnie unikatowe, alfanumeryczne, w tym łączniki i 3–24 znaki. Nazwa magazynu kluczy łączy wartość zmiennej KEYVAULT_NAME z 10-znakowym ciągiem zmiennej myKeyVault. Magazyn kluczy można utworzyć w kolejnej części tego artykułu.

   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. Zaktualizuj istniejący klaster usługi AKS, korzystając z dostawcy Azure Key Vault dla funkcjonalności sterownika Secrets Store CSI, używając polecenia az aks enable-addons i włączając dodatek azure-keyvault-secrets-provider. Dodatek tworzy przypisaną użytkownikowi tożsamość zarządzaną, której można użyć do uwierzytelniania w skarbcu kluczy.

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

   Po włączeniu dostawcy sekretnych usługi Azure Key Vault, usługa AKS tworzy tożsamość zarządzaną o nazwie azurekeyvaultsecretsprovider-xxxx, do której uwierzytelnienia w magazynie kluczy można użyć. Tożsamość zarządzana jest przechowywana w grupie zasobów węzła (MC_) i jest automatycznie przypisywana do zestawu skalowania maszyn wirtualnych. Możesz użyć tej zarządzanej tożsamości lub swojej własnej zarządzanej tożsamości, aby uzyskać dostęp do Key Vault. Zapobieganie tworzeniu tożsamości nie jest obsługiwane.

Weryfikowanie tożsamości zarządzanej i instalacji dostawcy magazynu kluczy

Następujące polecenia używają zmiennych $CLUSTER_NAME i $RESOURCE_GROUP. Przepływy pracy Azure CLI definiują te zmienne wcześniej, a przepływ pracy narzędzia Terraform ustawia je z danych wyjściowych po wdrożeniu.

Zweryfikuj tożsamość zarządzaną

Wykonaj poniższe kroki, aby sprawdzić, czy tożsamość zarządzana została utworzona i przypisana do zestawu skalowania maszyn wirtualnych klastra.

1. Sprawdź, czy tożsamość zarządzana została utworzona i przypisana do klastra az aks show przy użyciu polecenia .

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

   Właściwość resourceId pokazuje grupę zasobów i nazwę tożsamości azurekeyvaultsecretsprovider-myakscluster.

2. Sprawdź, czy tożsamość zarządzana jest przypisana do zestawu Virtual Machine Scale Set w grupie zasobów węzłów.

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

   Dane wyjściowe pokazują identyfikator zasobu zestawów skalowania maszyn wirtualnych Microsoft.Compute/virtualMachineScaleSets oraz właściwość userAssignedIdentities z identyfikatorem zasobu dla azurekeyvaultsecretsprovider-myakscluster, który potwierdza, że tożsamość jest przypisana do zestawu skalowania maszyn wirtualnych.

Weryfikacja dostawcy usługi Azure Key Vault dla instalacji sterownika CSI Secrets Store.

1. Pobierz poświadczenia klastra AKS za pomocą polecenia az aks get-credentials.

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

2. Sprawdź, czy instalacja została zakończona przy użyciu kubectl get pods polecenia, które wyświetla listę wszystkich podów z etykietami secrets-store-csi-driver i secrets-store-provider-azure w kube-system przestrzeni nazw.

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

   Flaga -o wide uwzględnia węzeł, na którym działa każdy zasobnik, w danych wyjściowych.

   Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

   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
   

Utwórz nowy magazyn kluczy

Uruchom polecenie az keyvault create aby utworzyć nowy magazyn kluczy z włączonym Azure RBAC.

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

Kontrola dostępu oparta na rolach Azure (RBAC) jest domyślnie włączona podczas tworzenia nowego magazynu kluczy, nawet jeśli nie dołączysz parametru --enable-rbac-authorization.

Aby uzyskać więcej informacji na temat modeli uprawnień Key Vault i kontroli dostępu opartych na rolach w Azure, zobacz Zapewnienie dostępu do kluczy, certyfikatów i tajemnic Key Vault za pomocą kontroli dostępu na bazie ról w Azure.

Zaktualizuj istniejący magazyn kluczy

Uruchom polecenie az keyvault update, aby zaktualizować istniejący magazyn kluczy przy użyciu kontroli dostępu opartej na rolach Azure (Azure RBAC). Parametr --enable-rbac-authorization jest wymagany do włączenia kontroli dostępu opartej na rolach Azure podczas aktualizowania istniejącego magazynu kluczy, który ma wyłączoną kontrolę dostępu opartej na rolach Azure.

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

Aby uzyskać więcej informacji na temat modeli uprawnień magazynu Key Vault i kontroli dostępu opartej na rolach platformy Azure, zobacz Zapewnianie dostępu do kluczy, certyfikatów i wpisów tajnych magazynu Key Vault za pomocą kontroli dostępu opartej na rolach platformy Azure

Dodaj przypisanie roli i wpis tajny do magazynu kluczy

1. Uruchom polecenie az keyvault show aby sprawdzić, czy magazyn kluczy ma włączoną kontrolę dostępu opartą na rolach platformy Azure.

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

   Dane wyjściowe powinny mieć wartość true.

2. Dodaj przypisanie roli dla konta użytkownika do zakresu magazynu kluczy przy użyciu polecenia az role assignment create, aby móc dodać tajny klucz magazynu w następnym kroku.

   Dodano rolę administratora tajemnic Key Vault z unikatowym identyfikatorem b86a8fe4-44ce-4948-aee5-eccb2c155cd7, a do użycia można wykorzystać nazwę lub unikatowy identyfikator. Użycie unikatowego identyfikatora roli jest najlepszym rozwiązaniem, aby zapobiec problemom, jeśli nazwa ról ulegnie zmianie.

   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
   

   Może potrwać kilka minut, zanim przypisanie roli zacznie obowiązywać. Możesz sprawdzić, czy przypisanie roli zostało utworzone za pomocą następującego polecenia:

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

3. Utwórz wpis tajny w postaci zwykłego tekstu o nazwie ExampleSecret w magazynie kluczy przy użyciu az keyvault secret set polecenia .

   Magazyn kluczy może służyć do przechowywania kluczy, tajemnic i certyfikatów. Parametr value używa zmiennej RANDOM_STRING do generowania unikatowej wartości sekretu.

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

4. Przy użyciu polecenia az keyvault secret show, sprawdź, czy wpis tajny został dodany do magazynu kluczy.

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

Utwórz nowy magazyn kluczy

Uwzględniony wcześniej przykład Terraform tworzy nowy magazyn kluczy z włączoną kontrolą dostępu opartą na rolach platformy Azure (Azure RBAC), przypisuje wymagane role i tworzy ExampleSecret. Nie jest wymagana żadna oddzielna aktualizacja konfiguracji.

1. Pobierz nazwę usługi Key Vault z danych wyjściowych Terraform.

   KEYVAULT_NAME=$(terraform output -raw key_vault_name)
   

2. Sprawdź za pomocą polecenia az keyvault secret show, czy element ExampleSecret został dodany do magazynu kluczy.

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

1. Usuń poświadczenia klastra z lokalnego pliku .kube/config.

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

2. Usuń grupę zasobów i wszystkie zasoby w niej, w tym zasoby w grupie zasobów węzła (MC_) przy użyciu az group delete polecenia .

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

Polecenie terraform destroy usuwa wszystkie zasoby zdefiniowane w bieżącej konfiguracji i pliku stanu narzędzia Terraform. Uruchom to polecenie tylko z katalogu roboczego używanego w tym artykule.

1. Usuń poświadczenia klastra z lokalnego pliku .kube/config.

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

2. Uruchom następujące polecenie, aby usunąć zasoby utworzone w tym artykule:

   terraform destroy