Podłącz dostawcę tożsamości platformy Azure do sterownika CSI magazynu sekretów Azure Key Vault w usłudze Azure Kubernetes Service (AKS)

1. W portalu Azure przejdź do zasobu klastra AKS.

2. W menu usługi w obszarze Ustawienia wybierz pozycję Service Connector>Utwórz.

3. Na stronie Tworzenie połączenia skonfiguruj następujące ustawienia na karcie Podstawowe :

   • Namespace Kubernetes: wybierz default.
   • Typ usługi: wybierz pozycję Key Vault i zaznacz pole wyboru, aby włączyć dostawcę CSI usługi Azure Key Vault.
   • Nazwa połączenia: wprowadź nazwę połączenia.
   • Subskrypcja: wybierz subskrypcję zawierającą magazyn kluczy.
   • Magazyn kluczy (Key Vault): wybierz utworzony magazyn kluczy.
   • Typ klienta: wybierz Brak.

4. Wybierz Recenzuj + utwórz, a następnie wybierz Utwórz, aby utworzyć połączenie.

• Utwórz połączenie z magazynem kluczy za pomocą polecenia az aks connection create keyvault.

  az aks connection create keyvault \
      --connection <connection-name> \
      --resource-group <resource-group-of-cluster> \
      --name <cluster-name> \
      --target-resource-group <resource-group-of-key-vault> \
      --vault <key-vault-name> \
      --enable-csi \
      --client-type none
  

Konfigurowanie tożsamości zarządzanej

1. Uzyskaj dostęp do magazynu kluczy przy użyciu az aks show polecenia i przypisanej przez użytkownika tożsamości zarządzanej utworzonej przez dodatek. Należy również pobrać dane tożsamości clientId, które są używane w kolejnych krokach przy tworzeniu obiektu SecretProviderClass.

   export RESOURCE_GROUP=<resource-group>
   export CLUSTER_NAME=<cluster-name>
   export KEYVAULT_NAME=<key-vault-name>
   
   export IDENTITY_OBJECT_ID=$(az aks show --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --query addonProfiles.azureKeyvaultSecretsProvider.identity.objectId -o tsv)
   export USER_ASSIGNED_CLIENT_ID=$(az aks show --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --query addonProfiles.azureKeyvaultSecretsProvider.identity.clientId -o tsv)
   

   Alternatywnie możesz utworzyć nową tożsamość zarządzaną i przypisać ją do zestawu skalowania maszyn wirtualnych lub do każdego wystąpienia maszyny wirtualnej w zestawie dostępności.

   export USER_ASSIGNED_IDENTITY_NAME=<identity-name>
   
   az identity create --resource-group $RESOURCE_GROUP --name $USER_ASSIGNED_IDENTITY_NAME
   
   export IDENTITY_RESOURCE_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $USER_ASSIGNED_IDENTITY_NAME --query id -o tsv)
   export IDENTITY_OBJECT_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $USER_ASSIGNED_IDENTITY_NAME --query principalId -o tsv)
   export USER_ASSIGNED_CLIENT_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $USER_ASSIGNED_IDENTITY_NAME --query clientId -o tsv)
   

   W przypadku klastra opartego na zestawie skalowania maszyn wirtualnych przypisz tożsamość do zestawu skalowania maszyn wirtualnych.

   az vmss identity assign --resource-group <node-resource-group> --name <agent-pool-vmss> --identities $IDENTITY_RESOURCE_ID
   

   W przypadku klastra opartego na zestawie dostępności przypisz tożsamość do każdego wystąpienia maszyny wirtualnej w zestawie dostępności.

   az vm identity assign --resource-group <node-resource-group> --name <agent-pool-vm> --identities $IDENTITY_RESOURCE_ID
   

2. Utwórz przypisanie roli, które przyznaje tożsamości uprawnienie dostępu do tajemnic magazynu kluczy, kluczy dostępu i certyfikatów przy użyciu polecenia az role assignment create.

   Ważne

   • Jeśli skonfigurujesz magazyn kluczy przy użyciu --enable-rbac-authorization i używasz typu key lub cert, przypisz rolę Key Vault Certificate User.
   • Jeśli magazyn kluczy jest ustawiony z --enable-rbac-authorization i używasz secret, przypisz rolę Key Vault Secrets User.
   • Jeśli magazyn kluczy nie jest ustawiony za pomocą --enable-rbac-authorization, możesz użyć polecenia az keyvault set-policy z parametrem --key-permissions get, --certificate-permissions get lub --secret-permissions get, aby utworzyć zasady magazynu kluczy i przyznać dostęp do kluczy, certyfikatów lub wpisów tajnych. Na przykład:

   az keyvault set-policy --name $KEYVAULT_NAME --key-permissions get --secret-permissions get --object-id $IDENTITY_OBJECT_ID
   

   export KEYVAULT_SCOPE=$(az keyvault show --name $KEYVAULT_NAME --query id -o tsv)
   
   # Example commands for a key vault with Azure RBAC enabled using `key` and `secret` types
   az role assignment create --role "Key Vault Certificate User" --assignee-object-id $IDENTITY_OBJECT_ID --assignee-principal-type ServicePrincipal --scope $KEYVAULT_SCOPE
   az role assignment create --role "Key Vault Secrets User" --assignee-object-id $IDENTITY_OBJECT_ID --assignee-principal-type ServicePrincipal --scope $KEYVAULT_SCOPE
   

3. Utwórz SecretProviderClass, używając identyfikatora klienta usługi tożsamości. Pamiętaj, aby użyć własnych wartości dla obiektów do pobrania z magazynu kluczy.

   Następujące parametry konfigurują dostęp przy użyciu tożsamości zarządzanej przypisanej przez użytkownika:

   • usePodIdentity: ustaw wartość na "false" w przypadku korzystania z tożsamości zarządzanej.
   • useVMManagedIdentity: Ustaw na "true", aby włączyć tryb tożsamości zarządzanej.
   • userAssignedIdentityID: Ustaw na identyfikator klienta tożsamości zarządzanej przypisanej przez użytkownika.
   • tenantId: Ustaw na identyfikator dzierżawy zawierającej magazyn kluczy.

   export KEYVAULT_TENANT_ID=$(az keyvault show --name $KEYVAULT_NAME --query properties.tenantId -o tsv)
   
   cat <<EOF > secretproviderclass.yaml
   # This is a SecretProviderClass example using user-assigned identity to access your key vault
   apiVersion: secrets-store.csi.x-k8s.io/v1
   kind: SecretProviderClass
   metadata:
     name: azure-kvname-user-msi
   spec:
     provider: azure
     parameters:
       usePodIdentity: "false"
       useVMManagedIdentity: "true"          # Set to true for using managed identity
       userAssignedIdentityID: ${USER_ASSIGNED_CLIENT_ID} # Set the client ID of the user-assigned managed identity to use
       keyvaultName: ${KEYVAULT_NAME}         # Set to the name of your key vault
       cloudName: ""                         # [OPTIONAL for Azure] if not provided, the Azure environment defaults to AzurePublicCloud
       objects:  |
         array:
           - |
             objectName: secret1
             objectType: secret              # object types: secret, key, or cert
             objectVersion: ""               # [OPTIONAL] object versions, default to latest if empty
           - |
             objectName: key1
             objectType: key
             objectVersion: ""
       tenantId: ${KEYVAULT_TENANT_ID}       # The tenant ID of the key vault
   EOF
   

   Uwaga

   Jeśli używasz objectAlias zamiast objectName, pamiętaj o zaktualizowaniu skryptu YAML.

   Uwaga

   Aby SecretProviderClass działało prawidłowo, przed odwoływaniem się do tych elementów w sekcji objects, upewnij się, że Azure Key Vault jest wypełniony tajemnicami, kluczami lub certyfikatami.

4. Zastosuj SecretProviderClass do swojego klastra przy użyciu polecenia kubectl apply.

   kubectl apply -f secretproviderclass.yaml
   

5. Utwórz manifest zasobnika o nazwie pod.yaml przy użyciu następującego polecenia.

   cat <<EOF > pod.yaml
   # This is a sample pod definition for using SecretProviderClass and the user-assigned identity to access your key vault
   kind: Pod
   apiVersion: v1
   metadata:
     name: busybox-secrets-store-inline-user-msi
   spec:
     containers:
       - name: busybox
         image: registry.k8s.io/e2e-test-images/busybox:1.29-4
         command:
           - "/bin/sleep"
           - "10000"
         volumeMounts:
         - name: secrets-store01-inline
           mountPath: "/mnt/secrets-store"
           readOnly: true
     volumes:
       - name: secrets-store01-inline
         csi:
           driver: secrets-store.csi.k8s.io
           readOnly: true
           volumeAttributes:
             secretProviderClass: "azure-kvname-user-msi"
   EOF
   

6. Nałóż pod na klaster przy użyciu polecenia kubectl apply.

   kubectl apply -f pod.yaml
   

Weryfikowanie wpisów tajnych w usłudze Key Vault przy użyciu tożsamości zarządzanej

Po uruchomieniu zasobnika zamontowana zawartość jest dostępna pod /mnt/secrets-store. Użyj następujących poleceń, aby zweryfikować swoje sekrety i wypisać testowy sekret.

1. Pokaż sekrety przechowywane w repozytorium sekretów przy użyciu następującego polecenia.

   kubectl exec busybox-secrets-store-inline-user-msi -- ls /mnt/secrets-store/
   

2. Wyświetl sekret w przechowalni przy użyciu następującego polecenia. Przykładowe polecenie wyświetla tajny kod testowy secret1.

   kubectl exec busybox-secrets-store-inline-user-msi -- cat /mnt/secrets-store/secret1
   

Wymagania wstępne

• Program Terraform 1.6 lub nowszy.
• Azure CLI — zainstalowano i zalogowano się. Zainstaluj najnowszą wersję.
• kubectl, połączony z Twoim klastrem za pomocą polecenia az aks get-credentials.

Konfigurowanie tożsamości zarządzanej

Przetestowany przykład Terraform tworzy grupę zasobów, klaster AKS z włączonym dostawcą Azure Key Vault dla sterownika Secrets Store CSI Driver, usługę Azure Key Vault, ExampleSecret oraz przypisanie roli, które przyznaje zarządzanej tożsamości dodatku rolę Key Vault Secrets User w usłudze Key Vault. Jeśli masz już wdrożony przykład z Używanie dostawcy Azure Key Vault dla sterownika Secrets Store CSI w klastrze usługi Azure Kubernetes Service (AKS), użyj ponownie tego katalogu roboczego i przejdź od razu do ustawienia zmiennych.

1. 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.

   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
   }
   

2. Zainicjuj, zweryfikuj i zastosuj konfigurację.

   terraform init
   terraform fmt
   terraform validate
   terraform plan
   terraform apply
   

3. Ustaw zmienne używane w pozostałych poleceniach na podstawie danych wyjściowych narzędzia 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)
   export KEYVAULT_SECRET_NAME=$(terraform output -raw key_vault_secret_name)
   export USER_ASSIGNED_CLIENT_ID=$(terraform output -raw aks_csi_client_id)
   export IDENTITY_OBJECT_ID=$(terraform output -raw aks_csi_object_id)
   export KEYVAULT_TENANT_ID=$(terraform output -raw tenant_id)
   

   Uwaga

   W przykładzie utworzono już przypisanie roli, które przyznaje $IDENTITY_OBJECT_IDKey Vault Secrets User rolę w key vault. Nie powtarzaj kroku az role assignment create na karcie Azure CLI dla tej tożsamości i magazynu kluczy — ten krok został już wykonany w przykładzie.

4. SecretProviderClass Utwórz element przy użyciu identyfikatora klienta tożsamości i nazwy wpisu tajnego z danych wyjściowych programu Terraform.

   Następujące parametry konfigurują dostęp przy użyciu tożsamości zarządzanej przypisanej przez użytkownika:

   • usePodIdentity: ustaw wartość na "false" w przypadku korzystania z tożsamości zarządzanej.
   • useVMManagedIdentity: Ustaw na "true", aby włączyć tryb tożsamości zarządzanej.
   • userAssignedIdentityID: Ustaw na identyfikator klienta tożsamości zarządzanej przypisanej przez użytkownika.
   • tenantId: Ustaw na identyfikator dzierżawy zawierającej magazyn kluczy.

   cat <<EOF > secretproviderclass.yaml
   # This is a SecretProviderClass example using the add-on's managed identity, created by the Terraform sample, to access your key vault
   apiVersion: secrets-store.csi.x-k8s.io/v1
   kind: SecretProviderClass
   metadata:
     name: azure-kvname-user-msi
   spec:
     provider: azure
     parameters:
       usePodIdentity: "false"
       useVMManagedIdentity: "true"          # Set to true for using managed identity
       userAssignedIdentityID: ${USER_ASSIGNED_CLIENT_ID} # Set to the client ID of the user-assigned managed identity to use
       keyvaultName: ${KEYVAULT_NAME}         # Set to the name of your key vault
       cloudName: ""                         # [OPTIONAL for Azure] if not provided, the Azure environment defaults to AzurePublicCloud
       objects:  |
         array:
           - |
             objectName: ${KEYVAULT_SECRET_NAME}
             objectType: secret              # object types: secret, key, or cert
             objectVersion: ""               # [OPTIONAL] object versions, default to latest if empty
       tenantId: ${KEYVAULT_TENANT_ID}       # The tenant ID of the key vault
   EOF
   

   Uwaga

   Przykład tworzy tylko obiekt typu secret. Informacje o typie key lub cert można znaleźć w sekcji Uzyskiwanie certyfikatów i kluczy.

5. Zastosuj element SecretProviderClass w klastrze za pomocą polecenia kubectl apply.

   kubectl apply -f secretproviderclass.yaml
   

6. Utwórz manifest podu o nazwie pod.yaml, używając następującego polecenia.

   cat <<EOF > pod.yaml
   # This is a sample pod definition for using SecretProviderClass and the user-assigned identity to access your key vault
   kind: Pod
   apiVersion: v1
   metadata:
     name: busybox-secrets-store-inline-user-msi
   spec:
     containers:
       - name: busybox
         image: registry.k8s.io/e2e-test-images/busybox:1.29-4
         command:
           - "/bin/sleep"
           - "10000"
         volumeMounts:
         - name: secrets-store01-inline
           mountPath: "/mnt/secrets-store"
           readOnly: true
     volumes:
       - name: secrets-store01-inline
         csi:
           driver: secrets-store.csi.k8s.io
           readOnly: true
           volumeAttributes:
             secretProviderClass: "azure-kvname-user-msi"
   EOF
   

7. Wdróż zasobnik w klastrze, używając polecenia kubectl apply.

   kubectl apply -f pod.yaml
   

Weryfikowanie wpisów tajnych w usłudze Key Vault przy użyciu tożsamości zarządzanej

Po uruchomieniu zasobnika zamontowana zawartość jest dostępna pod /mnt/secrets-store. Użyj następujących poleceń, aby zweryfikować swój sekret.

1. Użyj następującego polecenia, aby wyświetlić sekrety przechowywane w magazynie wpisów tajnych.

   kubectl exec busybox-secrets-store-inline-user-msi -- ls /mnt/secrets-store/
   

2. Wyświetl wpis tajny w magazynie przy użyciu następującego polecenia. $KEYVAULT_SECRET_NAME jest rozwiązywany do ExampleSecret przykładu.

   kubectl exec busybox-secrets-store-inline-user-msi -- cat /mnt/secrets-store/$KEYVAULT_SECRET_NAME
   

Czyszczenie zasobów programu Terraform

Jeśli przykład został wdrożony tylko w celu ukończenia tego artykułu i nie potrzebujesz zasobów dla innych elementów, usuń je z tego samego katalogu roboczego, który został użyty do zastosowania konfiguracji.

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