Anslut din Azure-identitetsleverantör till Azure Key Vault Secrets Store CSI-drivrutinen i Azure Kubernetes Service (AKS)

CSI-drivrutinen (Secrets Store Container Storage Interface) i Azure Kubernetes Service (AKS) ger olika metoder för identitetsbaserad åtkomst till ditt Azure Key Vault. Den här artikeln beskriver dessa metoder och metodtips för när du ska använda Azures rollbaserade åtkomstkontroll (Azure RBAC) eller OpenID Connect-säkerhetsmodeller (OIDC) för att få åtkomst till ditt nyckelvalv och AKS-kluster.

Du kan använda någon av följande åtkomstmetoder:

  • Service Connector med hanterad identitet
  • Arbetsbelastnings-ID
  • Arbetsbelastnings-ID med identitetsbindningar
  • Användartilldelad hanterad identitet

Lär dig hur du ansluter till Azure Key Vault med CSI-drivrutinen för Secrets Store i ett AKS-kluster (Azure Kubernetes Service) med hjälp av Service Connector. I den här artikeln utför du följande uppgifter:

  • Registrera de nödvändiga Azure resursprovidrar.
  • Skapa en anslutning mellan AKS-klustret och Azure Key Vault med Service Connector.
  • Skapa en SecretProviderClass CRD och en Pod som använder CSI-leverantören för att testa anslutningen.
  • Kontrollera att podden har åtkomst till nyckelvalvshemligheten.

Förutsättningar

Inledande konfiguration

  1. Om du använder Service Connector för första gången börjar du med att köra kommandot az provider register för att registrera resursprovidrar för Service Connector och Kubernetes Configuration.

    az provider register -n Microsoft.ServiceLinker
    
    az provider register -n Microsoft.KubernetesConfiguration
    

    Tips

    Du kan kontrollera om dessa resursprovidrar redan har registrerats genom att köra kommandona az provider show -n "Microsoft.ServiceLinker" --query registrationState och az provider show -n "Microsoft.KubernetesConfiguration" --query registrationState.

  2. Du kan också använda Azure CLI-kommandot för att hämta en lista över måltjänster som stöds för AKS-kluster.

    az aks connection list-support-types --output table
    

Skapa en tjänstanslutning i AKS med Service Connector

Du kan skapa en tjänstanslutning till Azure Key Vault med hjälp av Azure Portal eller Azure CLI.

  1. I Azure Portal navigerar du till aks-klusterresursen.

  2. På tjänstmenyn går du till Inställningar och väljer Skapa tjänstanslutning>.

  3. På sidan Skapa anslutning konfigurerar du följande inställningar på fliken Grundläggande :

    • Kubernetes-namnområde: Välj standard.
    • Tjänsttyp: Välj Key Vault och markera kryssrutan för att aktivera Azure Key Vault CSI-providern.
    • Anslutningsnamn: Ange ett namn för anslutningen.
    • Prenumeration: Välj den prenumeration som innehåller nyckelvalvet.
    • Nyckelvalv: Välj det nyckelvalv som du skapade.
    • Klienttyp: Välj Ingen.
  4. Välj Granska + skapa och välj sedan Skapa för att skapa anslutningen.

Testa anslutningen

Klona exempellagringsplatsen och distribuera manifestfiler

  1. Klona exempellagringsplatsen med kommandot git clone .

    git clone https://github.com/Azure-Samples/serviceconnector-aks-samples.git
    
  2. Ändra kataloger till Azure Key Vault CSI-providerexemplet.

    cd serviceconnector-aks-samples/azure-keyvault-csi-provider
    
  3. secret_provider_class.yaml Ersätt följande platshållare i filen med din Azure Key Vault-information:

    • Ersätt <AZURE_KEYVAULT_NAME> med namnet på nyckelvalvet som du skapade och anslöt.
    • Ersätt <AZURE_KEYVAULT_TENANTID> med hyresgästens ID för nyckelvalvet.
    • Ersätt <AZURE_KEYVAULT_CLIENTID> med identitetsklient-ID för azureKeyvaultSecretsProvider tillägget.
    • Ersätt <KEYVAULT_SECRET_NAME> med den nyckelvalvshemlighet som du skapade. Exempel: ExampleSecret
  4. SecretProviderClass Distribuera CRD med kommandot kubectl apply .

    kubectl apply -f secret_provider_class.yaml
    
  5. Pod Distribuera manifestfilen med kommandot kubectl apply .

    Kommandot skapar en podd med namnet sc-demo-keyvault-csi i standardnamnområdet för aks-klustret.

    kubectl apply -f pod.yaml
    

Verifiera anslutningen

  1. Kontrollera att podden har skapats med kommandot kubectl get .

    kubectl get pod/sc-demo-keyvault-csi
    

    När podden har startats är det monterade innehållet på den volymsökväg som anges i din distributions-YAML tillgängligt.

  2. Visa hemligheterna i hemlighetsarkivet med hjälp av kubectl exec kommandot .

    kubectl exec sc-demo-keyvault-csi -- ls /mnt/secrets-store/
    
  3. Visa en hemlighet med kommandot kubectl exec .

    Det här exempelkommandot visar en testhemlighet med namnet ExampleSecret.

    kubectl exec sc-demo-keyvault-csi -- cat /mnt/secrets-store/ExampleSecret
    

Förutsättningar för CSI-drivrutin med arbetsbelastningsidentitet

Åtkomst med ett Microsoft Entra-arbetsbelastnings-ID

En Microsoft Entra Workload ID är en identitet som ett program eller en tjänst använder för att autentisera sig mot andra Azure tjänster, till exempel arbetsbelastningar i programvara. CSI-drivrutinen för Secrets Store integreras med inbyggda Kubernetes-funktioner för att federera med externa identitetsprovidrar.

I den här säkerhetsmodellen fungerar AKS-klustret som tokenutfärdare. När CSI-drivrutinen för Secrets Store monterar volymen begär den en token för Kubernetes-tjänstkontot, och Azure Key Vault-providern byter ut den tokenen mot en Microsoft Entra-token. Programmet läser de monterade filerna och behöver inte Azure Identity-klientbiblioteket eller Microsofts autentiseringsbibliotek (MSAL) för det här volymmonteringsflödet. Om programmet oberoende begär Microsoft Entra token för att anropa skyddade API:er använder du Azure Identity eller MSAL i programmet.

Azure Key Vault-providern för CSI-drivrutinstillägget för Secrets Store stöder även identitetsbindningar. Med identitetsbindningar kan flera AKS-kluster använda samma användartilldelade hanterade identitet (UAMI) med en enda federerad identitetsautentiseringsuppgift. Det här stödet hjälper dig att skala Key Vault åtkomst mellan kluster utan att nå gränsen för federerade identitetsautentiseringsuppgifter. Konfigurera den här åtkomstmetoden genom att konfigurera en identitetsbindning mellan UAMI och varje AKS-kluster.

Kommentar

  • Den här autentiseringsmetoden ersätter Microsoft Entra identitet som hanteras av en pod (förhandsversion). Microsoft Entra med öppen källkod för poddhanterad identitet (förhandsversion) i Azure Kubernetes Service har upphört att stödas från och med den 24 oktober 2022.
  • Microsoft Entra-arbetsbelastnings-ID stöder både Windows- och Linux-kluster.

Konfigurera arbetsprocessidentitet

  1. Ange din prenumeration med hjälp av az account set kommandot .

    export SUBSCRIPTION_ID=<subscription id>
    export RESOURCE_GROUP=<resource group name>
    export UAMI=<name for user assigned identity>
    export KEYVAULT_NAME=<existing keyvault name>
    export CLUSTER_NAME=<aks cluster name>
    
    az account set --subscription $SUBSCRIPTION_ID
    
  2. Skapa en hanterad identitet med kommandot az identity create .

    Kommentar

    Det här steget förutsätter att du har ett befintligt AKS-kluster med arbetsbelastningsidentitet aktiverad. Om arbetsbelastningsidentiteten inte är aktiverad kan du läsa Aktivera arbetsbelastningsidentitet i ett befintligt AKS-kluster för att aktivera den.

    az identity create --name $UAMI --resource-group $RESOURCE_GROUP
    
    export USER_ASSIGNED_CLIENT_ID="$(az identity show --resource-group $RESOURCE_GROUP --name $UAMI --query 'clientId' -o tsv)"
    export KEYVAULT_TENANT_ID="$(az keyvault show --name $KEYVAULT_NAME --query properties.tenantId -o tsv)"
    
  3. Skapa en rolltilldelning som ger arbetsbelastningsidentiteten behörighet att komma åt nyckelvalvets hemligheter, åtkomstnycklar och certifikat med hjälp av az role assignment create kommandot .

    Viktigt!

    • Om du konfigurerar ditt nyckelvalv med --enable-rbac-authorization och använder typen key eller cert, tilldela rollen Key Vault Certificate User för att ge behörighet.
    • Om ditt nyckelvalv är konfigurerat med --enable-rbac-authorization och du använder secret-typ, tilldela rollen Key Vault Secrets User.
    • Om nyckelvalvet inte har angetts med --enable-rbac-authorizationkan du använda az keyvault set-policy kommandot med parametern --key-permissions get, --certificate-permissions geteller --secret-permissions get för att skapa en nyckelvalvsprincip för att bevilja åtkomst för nycklar, certifikat eller hemligheter. Till exempel:
    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 $USER_ASSIGNED_CLIENT_ID --scope $KEYVAULT_SCOPE
    az role assignment create --role "Key Vault Secrets User" --assignee $USER_ASSIGNED_CLIENT_ID --scope $KEYVAULT_SCOPE
    
  4. Hämta URL:en för AKS-klustrets OIDC-utfärdare med hjälp av az aks show kommandot .

    Kommentar

    Det här steget förutsätter att du har ett befintligt AKS-kluster med URL:en för OIDC-utfärdaren aktiverad. Om url:en för OIDC-utfärdaren inte är aktiverad kan du läsa Uppdatera ett AKS-kluster med OIDC-utfärdare för att aktivera det.

    export AKS_OIDC_ISSUER="$(az aks show --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --query "oidcIssuerProfile.issuerUrl" -o tsv)"
    echo $AKS_OIDC_ISSUER
    
  5. Skapa ett Kubernetes-tjänstkonto för arbetsbelastningen. Uppdatera värdena för SERVICE_ACCOUNT_NAME och SERVICE_ACCOUNT_NAMESPACE med Kubernetes-tjänstkontots namn och dess namnområde.

    export SERVICE_ACCOUNT_NAME="workload-identity-sa"  # sample name; can be changed
    export SERVICE_ACCOUNT_NAMESPACE="default" # can be changed to namespace of your workload
    
    cat <<EOF | kubectl apply -f -
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      annotations:
        azure.workload.identity/client-id: ${USER_ASSIGNED_CLIENT_ID}
      name: ${SERVICE_ACCOUNT_NAME}
      namespace: ${SERVICE_ACCOUNT_NAMESPACE}
    EOF
    
  6. Skapa den federerade identitetslegitimationen mellan den hanterade identiteten, tjänstekontots utfärdare och subjektet med az identity federated-credential create-kommandot.

    export FEDERATED_IDENTITY_NAME="aksfederatedidentity" # can be changed as needed
    
    az identity federated-credential create --name $FEDERATED_IDENTITY_NAME --identity-name $UAMI --resource-group $RESOURCE_GROUP --issuer ${AKS_OIDC_ISSUER} --subject system:serviceaccount:${SERVICE_ACCOUNT_NAMESPACE}:${SERVICE_ACCOUNT_NAME}
    
  7. Distribuera en SecretProviderClass med hjälp av kubectl apply kommandot och följande YAML-skript.

    Följande parametrar konfigurerar identitetsåtkomst för arbetsbelastning:

    • usePodIdentity: Ställ in på "false" när du använder arbetsbelastningsidentitet.
    • clientID: Ange värdet ${USER_ASSIGNED_CLIENT_ID} för klient-ID:t för den användartilldelade hanterade identitet som används för workloadidentitet.
    • cloudName: Valfritt. Låt vara tom om du vill använda standardmiljön AzurePublicCloud .
    • objectType: Ställ in på vilken typ av Key Vault objekt som ska monteras. Giltiga värden är secret, key och cert.
    • tenantId: Ange till det klient-ID som innehåller nyckelvalvet.
    cat <<EOF | kubectl apply -f -
    # This is a SecretProviderClass example using workload identity to access your key vault
    apiVersion: secrets-store.csi.x-k8s.io/v1
    kind: SecretProviderClass
    metadata:
      name: azure-kvname-wi # needs to be unique per namespace
      namespace: ${SERVICE_ACCOUNT_NAMESPACE}
    spec:
      provider: azure
      parameters:
        usePodIdentity: "false"
        clientID: "${USER_ASSIGNED_CLIENT_ID}" # Setting this to use workload identity
        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             # Set to the name of your secret
              objectType: secret              # object types: secret, key, or cert
              objectVersion: ""               # [OPTIONAL] object versions, default to latest if empty
            - |
              objectName: key1                # Set to the name of your key
              objectType: key
              objectVersion: ""
        tenantId: "${KEYVAULT_TENANT_ID}"     # The tenant ID of the key vault
    EOF
    

    Kommentar

    Om du använder objectAlias i stället för objectNameuppdaterar du YAML-skriptet för att ta hänsyn till det.

    Kommentar

    För att SecretProviderClass ska fungera korrekt, se till att fylla ditt Azure Key Vault med hemligheter, nycklar eller certifikat innan du refererar till dem i objects-avsnittet.

  8. Distribuera en exempelpodd med kommandot kubectl apply och följande YAML-skript.

    cat <<EOF | kubectl apply -f -
    # This is a sample pod definition for using SecretProviderClass and workload identity to access your key vault
    kind: Pod
    apiVersion: v1
    metadata:
      name: busybox-secrets-store-inline-wi
      namespace: ${SERVICE_ACCOUNT_NAMESPACE}
      labels:
        azure.workload.identity/use: "true"
    spec:
      serviceAccountName: ${SERVICE_ACCOUNT_NAME}
      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-wi"
    EOF
    

Validera Key Vault-hemligheter med arbetsbelastningsidentitet

När podden har startats är det monterade innehållet på /mnt/secrets-store tillgängligt. Använd följande kommandon för att verifiera dina hemligheter och skriva ut en testhemlighet.

  1. Visa hemligheter som lagras i hemlighetsarkivet med hjälp av följande kommando.

    kubectl exec --namespace $SERVICE_ACCOUNT_NAMESPACE busybox-secrets-store-inline-wi -- ls /mnt/secrets-store/
    
  2. Visa en hemlighet i butiken med hjälp av följande kommando. Det här exempelkommandot visar testhemligheten secret1.

    kubectl exec --namespace $SERVICE_ACCOUNT_NAMESPACE busybox-secrets-store-inline-wi -- cat /mnt/secrets-store/secret1
    

Förutsättningar för CSI-drivrutin med hanterad identitet

Åtkomst med hanterad identitet

Den här metoden använder den användartilldelade hanterade identiteten som AKS automatiskt skapar när du aktiverar Azure Key Vault-providern för Secrets Store CSI-drivrutinen. Identiteten har namnet azurekeyvaultsecretsprovider-xxxxx, lagras i nodresursgruppen och tilldelas skalningsuppsättningen för virtuella datorer.

Med en Microsoft Entra hanterad identitet kan en Azure resurs eller arbetsbelastning autentisera till tjänster som stöder Microsoft Entra autentisering utan att lagra autentiseringsuppgifter i kod. Ge den här identiteten de lämpliga behörigheterna på dataplansnivå för Key Vault via Azure RBAC eller åtkomstprinciper, och använd sedan den i följande steg.

Välj fliken som matchar hur du skapade ditt AKS-kluster och nyckelvalv i Använd Azure Key Vault-providern för Secrets Store CSI-drivrutinen i ett Azure Kubernetes Service (AKS) kluster. Om du har distribuerat det testade Terraform-exemplet har tilläggsidentiteten redan tilldelats rollen Key Vault Secrets User, så du kan hoppa över steget för manuell rolltilldelning.

Konfigurera hanterad identitet

  1. Få åtkomst till ditt nyckelvalv med kommandot az aks show och den användartilldelade hanterade identiteten som skapas av tillägget. Du bör också hämta identitetens clientId, vilken du kommer att använda i senare steg när du skapar en 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)
    

    Alternativt kan du skapa en ny hanterad identitet och tilldela den till din skalningsuppsättning för virtuella datorer (VM) eller till varje VM-instans i din tillgänglighetsuppsättning.

    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)
    

    För ett VM-skalningsuppsättningsbaserat kluster tilldelar du identiteten till VM-skalningsuppsättningen.

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

    För ett tillgänglighetsuppsättningsbaserat kluster tilldelar du identiteten till varje VM-instans i tillgänglighetsuppsättningen.

    az vm identity assign --resource-group <node-resource-group> --name <agent-pool-vm> --identities $IDENTITY_RESOURCE_ID
    
  2. Skapa en rolltilldelning som ger identiteten behörighet att komma åt nyckelvalvets hemligheter, åtkomstnycklar och certifikat med hjälp av az role assignment create kommandot .

    Viktigt!

    • Om du konfigurerar ditt nyckelvalv med --enable-rbac-authorization och använder typen key eller cert, tilldela rollen Key Vault Certificate User.
    • Om ditt nyckelvalv är konfigurerat med --enable-rbac-authorization och du använder secret-typ, tilldela rollen Key Vault Secrets User.
    • Om nyckelvalvet inte har angetts med --enable-rbac-authorizationkan du använda az keyvault set-policy kommandot med parametern --key-permissions get, --certificate-permissions geteller --secret-permissions get för att skapa en nyckelvalvsprincip för att bevilja åtkomst för nycklar, certifikat eller hemligheter. Till exempel:
    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. Skapa en SecretProviderClass med identitetsklient-ID:t. Se till att använda dina egna värden för objekten som ska hämtas från nyckelvalvet.

    Följande parametrar konfigurerar användartilldelad åtkomst till hanterad identitet:

    • usePodIdentity: Ange till "false" när du använder hanterad identitet.
    • useVMManagedIdentity: Ange "true" för att aktivera läget för hanterad identitet.
    • userAssignedIdentityID: Ange till klient-ID för den användartilldelade hanterade identiteten.
    • tenantId: Ange till det klient-ID som innehåller nyckelvalvet.
    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
    

    Kommentar

    Om du använder objectAlias i stället för objectNamemåste du uppdatera YAML-skriptet.

    Kommentar

    För att SecretProviderClass ska fungera korrekt, se till att fylla ditt Azure Key Vault med hemligheter, nycklar eller certifikat innan du refererar till dem i objects-avsnittet.

  4. Använd SecretProviderClass i ditt kluster med hjälp av kubectl apply-kommandot.

    kubectl apply -f secretproviderclass.yaml
    
  5. Skapa ett poddmanifest med namnet pod.yaml med följande kommando.

    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. Tillämpa podden på klustret med kommandot kubectl apply.

    kubectl apply -f pod.yaml
    

Verifiera Key Vault hemligheter med hanterad identitet

När podden har startats är det monterade innehållet på /mnt/secrets-store tillgängligt. Använd följande kommandon för att verifiera dina hemligheter och skriva ut en testhemlighet.

  1. Visa hemligheter som lagras i hemlighetsarkivet med hjälp av följande kommando.

    kubectl exec busybox-secrets-store-inline-user-msi -- ls /mnt/secrets-store/
    
  2. Visa en hemlighet i butiken med hjälp av följande kommando. Det här exempelkommandot visar testhemligheten secret1.

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

Hämta certifikat och nycklar

Azure Key Vault-designen gör skarpa distinktioner mellan nycklar, hemligheter och certifikat. Certifikatfunktionerna i Key Vault-tjänsten är utformade för att använda nyckel- och hemlighetsfunktioner. När du skapar ett key vault-certifikat skapas en adresserbar nyckel och hemlighet med samma namn. Den här nyckeln tillåter autentiseringsåtgärder, och den hemliga nyckeln tillåter hämtning av certifikatvärdet som en hemlighet.

Ett key vault-certifikat innehåller även offentliga x509-certifikatmetadata. Nyckelvalvet lagrar både offentliga och privata komponenter i certifikatet i en hemlighet. Du kan hämta varje enskild komponent genom att objectType ange i SecretProviderClass. I följande tabell visas de objectType värden som du kan ange i för att hämta olika komponenter i SecretProviderClass ett key vault-certifikat och vad varje värde returnerar:

objectType värde Returvärde Returnerar hela certifikatkedjan
key Den offentliga nyckeln i PEM-format (Privacy Enhanced Mail). Ej tillämpligt
cert Certifikatet i PEM-format. Nej
secret Den privata nyckeln och certifikatet i PEM-format. Ja

Inaktivera tillägget i befintliga kluster

Kommentar

Innan du inaktiverar tillägget kontrollerar du att ingetSecretProviderClass används. Om du försöker inaktivera tillägget medan det SecretProviderClass finns resulterar det i ett fel.

Inaktivera Azure Key Vault-leverantören för funktionen Secrets Store CSI Driver i ett befintligt kluster genom att använda kommandot az aks disable-addons med tillägget azure-keyvault-secrets-provider.

az aks disable-addons --addons azure-keyvault-secrets-provider --resource-group myResourceGroup --name myAKSCluster

Kommentar

När du inaktiverar tillägget bör befintliga laster inte ha några problem eller märka några uppdateringar i de monterade hemligheterna. Om podden startas om eller en ny podd skapas som en del av uppskalningshändelsen startar inte podden eftersom drivrutinen inte längre körs.

Nästa steg

I den här artikeln har du lärt dig hur du skapar och tillhandahåller en identitet för åtkomst till ditt Azure Key Vault. Integreringen av Service Connector förenklar anslutningskonfigurationen för AKS-arbetsbelastningar och Azure-säkerhetskopieringstjänster. Den hanterar autentisering och nätverkskonfigurationer på ett säkert sätt och följer metodtipsen för att ansluta till Azure-tjänster. Mer information finns i Använda Azure Key Vault-providern för Secrets Store CSI-drivrutinen i ett AKS-kluster och introduktionen till Service Connector.

Om du vill konfigurera extra konfigurationsalternativ eller utföra felsökning kan du läsa Konfigurationsalternativ och felsökningsresurser för Azure Key Vault-provider med Secrets Store CSI-drivrutin i AKS.