De Azure Key Vault Secrets Provider-extensie gebruiken om geheimen op te halen in Kubernetes-clusters met Azure Arc

Artikel
09/28/2024

De Azure Key Vault-provider voor het CSI-stuurprogramma Secrets Store maakt de integratie van Azure Key Vault mogelijk als geheimenarchief met een Kubernetes-cluster via een CSI-volume. Voor Kubernetes-clusters met Azure Arc kunt u de Azure Key Vault Secrets Provider-extensie installeren om geheimen op te halen.

De mogelijkheden van de Azure Key Vault Secrets Provider-extensie zijn onder andere:

Hiermee koppelt u geheimen/sleutels/certificaten aan pods met behulp van een inline CSI-volume
Ondersteunt draagbaarheid van pods met de SecretProviderClass CRD
Ondersteunt Linux- en Windows-containers
Ondersteunt synchronisatie met Kubernetes Secrets
Ondersteunt automatische rotatie van geheimen
Extensieonderdelen worden geïmplementeerd in beschikbaarheidszones, waardoor ze zone-redundant worden

Tip

Als offlinetoegang nodig is of als u geheimen wilt synchroniseren met het Kubernetes-geheimenarchief, gebruikt u de extensie Secret Store voor geheimbeheer in uw Kubernetes-clusters met Arc.

Vereisten

Een cluster met een ondersteunde Kubernetes-distributie die is verbonden met Azure Arc. De volgende Kubernetes-distributies worden momenteel ondersteund voor dit scenario:
- Cluster-API Azure
- AKS-clusters (Azure Kubernetes Service) in Azure Stack HCI
- AKS ingeschakeld door Azure Arc
- Google Kubernetes Engine
- OpenShift Kubernetes-distributie
- Canonical Kubernetes Distribution
- Elastic Kubernetes Service
- Tanzu Kubernetes Grid
- Azure Red Hat OpenShift
Uitgaande connectiviteit met de volgende eindpunten:
- linuxgeneva-microsoft.azurecr.io
- upstreamarc.azurecr.io
- *.blob.core.windows.net
Zorg ervoor dat u voldoet aan de algemene vereisten voor clusterextensies. U moet versie 0.4.0 of hoger van de k8s-extension Azure CLI-extensie gebruiken.

De Azure Key Vault Secrets Provider-extensie installeren op een Kubernetes-cluster met Arc

U kunt de Azure Key Vault Secrets Provider-extensie installeren op uw verbonden cluster in Azure Portal, met behulp van Azure CLI of door een ARM-sjabloon te implementeren.

Er kan slechts één exemplaar van de extensie worden geïmplementeerd op elk Kubernetes-cluster met Azure Arc.

Tip

Als het cluster zich achter een uitgaande proxyserver bevindt, moet u ervoor zorgen dat u deze verbindt met Azure Arc met behulp van de proxyconfiguratieoptie voordat u de extensie installeert.

Azure Portal

Navigeer in Azure Portal naar Kubernetes - Azure Arc en selecteer uw cluster.
Selecteer Extensies (onder Instellingen) en selecteer vervolgens + Toevoegen.
Selecteer azure Key Vault Secrets Provider in de lijst met beschikbare extensies om de nieuwste versie van de extensie te implementeren.
Volg de aanwijzingen om de extensie te implementeren. Pas indien nodig de installatie aan door de standaardopties op het tabblad Configuratie te wijzigen.

Azure-CLI

Stel de omgevingsvariabelen in:

export CLUSTER_NAME=<arc-cluster-name>
export RESOURCE_GROUP=<resource-group-name>

Installeer het stuurprogramma Secrets Store CSI en de Azure Key Vault Secrets Provider-extensie door de volgende opdracht uit te voeren:

az k8s-extension create --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --cluster-type connectedClusters --extension-type Microsoft.AzureKeyVaultSecretsProvider --name akvsecretsprovider

Als het goed is, ziet u uitvoer die vergelijkbaar is met dit voorbeeld. Het kan enkele minuten duren voordat de Helm-grafiek van de geheimenprovider in het cluster wordt geïmplementeerd.

{
  "aksAssignedIdentity": null,
  "autoUpgradeMinorVersion": true,
  "configurationProtectedSettings": {},
  "configurationSettings": {},
  "customLocationSettings": null,
  "errorInfo": null,
  "extensionType": "microsoft.azurekeyvaultsecretsprovider",
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Kubernetes/connectedClusters/$CLUSTER_NAME/providers/Microsoft.KubernetesConfiguration/extensions/akvsecretsprovider",
  "identity": {
    "principalId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "tenantId": null,
    "type": "SystemAssigned"
  },
  "location": null,
  "name": "akvsecretsprovider",
  "packageUri": null,
  "provisioningState": "Succeeded",
  "releaseTrain": "Stable",
  "resourceGroup": "$RESOURCE_GROUP",
  "scope": {
    "cluster": {
      "releaseNamespace": "kube-system"
    },
    "namespace": null
  },
  "statuses": [],
  "systemData": {
    "createdAt": "2022-05-12T18:35:56.552889+00:00",
    "createdBy": null,
    "createdByType": null,
    "lastModifiedAt": "2022-05-12T18:35:56.552889+00:00",
    "lastModifiedBy": null,
    "lastModifiedByType": null
  },
  "type": "Microsoft.KubernetesConfiguration/extensions",
  "version": "1.1.3"
}

ARM-sjabloon

Maak een .json-bestand met de volgende indeling. Zorg ervoor dat u de <clusternaamwaarde> bijwerkt om naar uw cluster te verwijzen.

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "ConnectedClusterName": {
            "defaultValue": "<cluster-name>",
            "type": "String",
            "metadata": {
                "description": "The Connected Cluster name."
            }
        },
        "ExtensionInstanceName": {
            "defaultValue": "akvsecretsprovider",
            "type": "String",
            "metadata": {
                "description": "The extension instance name."
            }
        },
        "ExtensionVersion": {
            "defaultValue": "",
            "type": "String",
            "metadata": {
                "description": "The version of the extension type."
            }
        },
        "ExtensionType": {
            "defaultValue": "Microsoft.AzureKeyVaultSecretsProvider",
            "type": "String",
            "metadata": {
                "description": "The extension type."
            }
        },
        "ReleaseTrain": {
            "defaultValue": "stable",
            "type": "String",
            "metadata": {
                "description": "The release train."
            }
        }
    },
    "functions": [],
    "resources": [
        {
            "type": "Microsoft.KubernetesConfiguration/extensions",
            "apiVersion": "2021-09-01",
            "name": "[parameters('ExtensionInstanceName')]",
            "identity": {
             "type": "SystemAssigned"
            },
            "properties": {
                "extensionType": "[parameters('ExtensionType')]",
                "releaseTrain": "[parameters('ReleaseTrain')]",
                "version": "[parameters('ExtensionVersion')]"
            },
            "scope": "[concat('Microsoft.Kubernetes/connectedClusters/', parameters('ConnectedClusterName'))]"
        }
    ]
}

Stel nu de omgevingsvariabelen in met behulp van de volgende Azure CLI-opdracht:

export TEMPLATE_FILE_NAME=<template-file-path>
export DEPLOYMENT_NAME=<desired-deployment-name>

Voer ten slotte deze Azure CLI-opdracht uit om de Azure Key Vault Secrets Provider-extensie te installeren:

az deployment group create --name $DEPLOYMENT_NAME --resource-group $RESOURCE_GROUP --template-file $TEMPLATE_FILE_NAME

U moet nu de resources van de geheime provider kunnen bekijken en de extensie in uw cluster kunnen gebruiken.

De installatie van de extensie valideren

Voer de volgende opdracht uit om te bevestigen dat de Azure Key Vault Secrets Provider-extensie is geïnstalleerd.

az k8s-extension show --cluster-type connectedClusters --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --name akvsecretsprovider

Als het goed is, ziet u uitvoer die vergelijkbaar is met dit voorbeeld.

{
  "aksAssignedIdentity": null,
  "autoUpgradeMinorVersion": true,
  "configurationProtectedSettings": {},
  "configurationSettings": {},
  "customLocationSettings": null,
  "errorInfo": null,
  "extensionType": "microsoft.azurekeyvaultsecretsprovider",
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Kubernetes/connectedClusters/$CLUSTER_NAME/providers/Microsoft.KubernetesConfiguration/extensions/akvsecretsprovider",
  "identity": {
    "principalId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "tenantId": null,
    "type": "SystemAssigned"
  },
  "location": null,
  "name": "akvsecretsprovider",
  "packageUri": null,
  "provisioningState": "Succeeded",
  "releaseTrain": "Stable",
  "resourceGroup": "$RESOURCE_GROUP",
  "scope": {
    "cluster": {
      "releaseNamespace": "kube-system"
    },
    "namespace": null
  },
  "statuses": [],
  "systemData": {
    "createdAt": "2022-05-12T18:35:56.552889+00:00",
    "createdBy": null,
    "createdByType": null,
    "lastModifiedAt": "2022-05-12T18:35:56.552889+00:00",
    "lastModifiedBy": null,
    "lastModifiedByType": null
  },
  "type": "Microsoft.KubernetesConfiguration/extensions",
  "version": "1.1.3"
}

Een Azure Key Vault maken of selecteren

Geef vervolgens de Azure Key Vault op die moet worden gebruikt met uw verbonden cluster. Als u er nog geen hebt, maakt u een nieuwe Sleutelkluis met behulp van de volgende opdrachten. Houd er rekening mee dat de naam van uw sleutelkluis wereldwijd uniek moet zijn.

Stel de volgende omgevingsvariabelen in:

export AKV_RESOURCE_GROUP=<resource-group-name>
export AZUREKEYVAULT_NAME=<AKV-name>
export AZUREKEYVAULT_LOCATION=<AKV-location>

Voer vervolgens de volgende opdracht uit:

az keyvault create -n $AZUREKEYVAULT_NAME -g $AKV_RESOURCE_GROUP -l $AZUREKEYVAULT_LOCATION

Azure Key Vault kan sleutels, geheimen en certificaten opslaan. In dit voorbeeld kunt u een geheim DemoSecret voor tekst zonder opmaak instellen met behulp van de volgende opdracht:

az keyvault secret set --vault-name $AZUREKEYVAULT_NAME -n DemoSecret --value MyExampleSecret

Voordat u verdergaat met de volgende sectie, moet u rekening houden met de volgende eigenschappen:

Naam van het geheime object in Key Vault
Objecttype (geheim, sleutel of certificaat)
Naam van uw Key Vault-resource
De Azure-tenant-id voor het abonnement waartoe de Key Vault behoort

Identiteit opgeven voor toegang tot Azure Key Vault

Op dit moment kan het CSI-stuurprogramma Secrets Store op clusters met Arc worden geopend via een service-principal. Volg deze stappen om een identiteit op te geven die toegang heeft tot uw Key Vault.

Volg de stappen om een service-principal te maken in Azure. Noteer de client-id en het clientgeheim die in deze stap zijn gegenereerd.
Controleer vervolgens of Azure Key Vault GET-machtigingen heeft voor de gemaakte service-principal.

Gebruik de client-id en het clientgeheim uit de eerste stap om een Kubernetes-geheim te maken op het verbonden cluster:

kubectl create secret generic secrets-store-creds --from-literal clientid="<client-id>" --from-literal clientsecret="<client-secret>"

Label het gemaakte geheim:

kubectl label secret secrets-store-creds secrets-store.csi.k8s.io/used=true

Maak een SecretProviderClass met de volgende YAML, waarbij u uw waarden invult voor de naam van de sleutelkluis, tenant-id en objecten die u wilt ophalen uit uw AKV-exemplaar:

# This is a SecretProviderClass example using service principal to access Keyvault
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: akvprovider-demo
spec:
  provider: azure
  parameters:
    usePodIdentity: "false"
    keyvaultName: <key-vault-name>
    cloudName:                           # Defaults to AzurePublicCloud
    objects:  |
      array:
        - |
          objectName: DemoSecret
          objectType: secret             # object types: secret, key or cert
          objectVersion: ""              # [OPTIONAL] object versions, default to latest if empty
    tenantId: <tenant-Id>                # The tenant ID of the Azure Key Vault instance

Voor gebruik met nationale clouds moet u overstappen op cloudName AzureUSGovernmentCloud Azure Government of AzureChinaCloud op Microsoft Azure beheerd door 21Vianet.

De SecretProviderClass toepassen op uw cluster:
```
kubectl apply -f secretproviderclass.yaml
```

Maak een pod met de volgende YAML, waarbij u de naam van uw identiteit invult:

# This is a sample pod definition for using SecretProviderClass and service principal to access Keyvault
kind: Pod
apiVersion: v1
metadata:
  name: busybox-secrets-store-inline
spec:
  containers:
    - name: busybox
      image: k8s.gcr.io/e2e-test-images/busybox:1.29
      command:
        - "/bin/sleep"
        - "10000"
      volumeMounts:
      - name: secrets-store-inline
        mountPath: "/mnt/secrets-store"
        readOnly: true
  volumes:
    - name: secrets-store-inline
      csi:
        driver: secrets-store.csi.k8s.io
        readOnly: true
        volumeAttributes:
          secretProviderClass: "akvprovider-demo"
        nodePublishSecretRef:                       
          name: secrets-store-creds

Pas de pod toe op uw cluster:
```
kubectl apply -f pod.yaml
```

De geheimen valideren

Nadat de pod is gestart, is de gekoppelde inhoud op het volumepad dat is opgegeven in uw YAML-implementatie beschikbaar.

## show secrets held in secrets-store
kubectl exec busybox-secrets-store-inline -- ls /mnt/secrets-store/

## print a test secret 'DemoSecret' held in secrets-store
kubectl exec busybox-secrets-store-inline -- cat /mnt/secrets-store/DemoSecret

Extra configuratieopties

De Azure Key Vault Secrets Provider-extensie biedt ondersteuning voor Helm-grafiekconfiguraties.

De volgende configuratie-instellingen worden vaak gebruikt met de Azure Key Vault Secrets Provider-extensie:

Configuratie-instelling	Default	Beschrijving
enableSecretRotation	false	Booleaanse waarde. Als `true`de podkoppeling periodiek wordt bijgewerkt en Kubernetes Secret met de nieuwste inhoud uit het externe geheimenarchief
rotationPollInterval	2 m	Als `enableSecretRotation` dat het is `true`, geeft deze instelling de duur van het poll-interval voor geheimrotatie aan. Deze duur kan worden aangepast op basis van hoe vaak de gekoppelde inhoud voor alle pods en Kubernetes-geheimen opnieuw moet worden gesynchroniseerd naar de meest recente.
syncSecret.enabled	false	Booleaanse invoer. In sommige gevallen wilt u mogelijk een Kubernetes-geheim maken om de gekoppelde inhoud te spiegelen. Als `true`het `SecretProviderClass` veld de `secretObjects` gewenste status van de gesynchroniseerde Kubernetes Secret-objecten kan definiëren.

Deze instellingen kunnen worden opgegeven wanneer de extensie wordt geïnstalleerd met behulp van de az k8s-extension create opdracht:

az k8s-extension create --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --cluster-type connectedClusters --extension-type Microsoft.AzureKeyVaultSecretsProvider --name akvsecretsprovider --configuration-settings secrets-store-csi-driver.enableSecretRotation=true secrets-store-csi-driver.rotationPollInterval=3m secrets-store-csi-driver.syncSecret.enabled=true

U kunt deze instellingen ook wijzigen na de installatie met behulp van de az k8s-extension update opdracht:

az k8s-extension update --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --cluster-type connectedClusters --name akvsecretsprovider --configuration-settings secrets-store-csi-driver.enableSecretRotation=true secrets-store-csi-driver.rotationPollInterval=3m secrets-store-csi-driver.syncSecret.enabled=true

U kunt indien nodig andere configuratie-instellingen gebruiken voor uw implementatie. Als u bijvoorbeeld de kubelet-hoofdmap wilt wijzigen tijdens het maken van een cluster, wijzigt u de az k8s-extension create opdracht:

az k8s-extension create --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --cluster-type connectedClusters --extension-type Microsoft.AzureKeyVaultSecretsProvider --name akvsecretsprovider --configuration-settings linux.kubeletRootDir=/path/to/kubelet secrets-store-csi-driver.linux.kubeletRootDir=/path/to/kubelet

De Azure Key Vault Secrets Provider-extensie verwijderen

Voer de volgende opdracht uit om de extensie te verwijderen:

az k8s-extension delete --cluster-type connectedClusters --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --name akvsecretsprovider

Notitie

Als u de extensie verwijdert, worden de aangepaste resourcedefinities (CRD's) die zijn gemaakt toen de extensie werd geïnstalleerd, niet verwijderd.

Voer de volgende opdracht uit om te bevestigen dat het extensie-exemplaar is verwijderd:

az k8s-extension list --cluster-type connectedClusters --cluster-name $CLUSTER_NAME --resource-group $RESOURCE_GROUP

Als de extensie is verwijderd, ziet u de azure Key Vault Secrets Provider-extensie niet in de uitvoer. Als er geen andere extensies op uw cluster zijn geïnstalleerd, ziet u een lege matrix.

Als u het niet meer nodig hebt, verwijdert u het Kubernetes-geheim dat is gekoppeld aan de service-principal door de volgende opdracht uit te voeren:

kubectl delete secret secrets-store-creds

Afstemming en probleemoplossing

De Azure Key Vault Secrets Provider-extensie is zelfherstel. Als iemand probeert een extensieonderdeel te wijzigen of verwijderen dat is geïmplementeerd toen de extensie werd geïnstalleerd, wordt dat onderdeel afgestemd op de oorspronkelijke status. De enige uitzonderingen zijn voor aangepaste resourcedefinities (CRD's). Als CRD's worden verwijderd, worden ze niet afgestemd. Als u verwijderde CRD's wilt herstellen, gebruikt u de az k8s-extension create opdracht opnieuw met de naam van het bestaande extensie-exemplaar.

Zie de opensource-handleidingen voor het oplossen van problemen voor Azure Key Vault-provider voor het stuurprogramma Secrets Store CSI en Secrets Store CSI Driver voor meer informatie over het oplossen van veelvoorkomende problemen.

Volgende stappen

Wilt u dingen uitproberen? Ga snel aan de slag met een Azure Arc Jumpstart-scenario met behulp van cluster-API.
Meer informatie over Azure Key Vault.

Share via