Usare l'estensione del provider di segreti di Azure Key Vault per recuperare i segreti nei cluster Kubernetes abilitati per Azure Arc

Articolo
09/27/2024

Il provider di Azure Key Vault per il driver CSI dell'archivio segreti consente l'integrazione di Azure Key Vault come archivio segreti con un cluster Kubernetes tramite un volume CSI. Per i cluster Kubernetes abilitati per Azure Arc, è possibile installare l'estensione del provider di segreti di Azure Key Vault per recuperare i segreti.

Le funzionalità dell'estensione del provider di segreti di Azure Key Vault includono:

Monta segreti/chiavi/certificati nel pod usando un volume CSI inline
Supporta la portabilità dei pod con SecretProviderClass CRD
Supporta contenitori Linux e Windows
Supporta le sincronizzazioni con i segreti kubernetes
Supporta la rotazione automatica dei segreti
I componenti di estensione vengono distribuiti nelle zone di disponibilità, rendendoli ridondanti per la zona.

Suggerimento

Se è necessario l'accesso offline o se sono necessari segreti sincronizzati nell'archivio segreti Kubernetes, usare l'estensione dell'archivio segreti per la gestione dei segreti nei cluster Kubernetes abilitati per Arc.

Prerequisiti

Un cluster con una distribuzione Kubernetes supportata connessa ad Azure Arc. Attualmente sono supportate le distribuzioni Kubernetes seguenti per questo scenario:
- Cluster API Azure
- Cluster del Servizio Azure Kubernetes (AKS) in Azure Stack HCI
- Servizio Azure Kubernetes abilitato da Azure Arc
- Google Kubernetes Engine
- Distribuzione di OpenShift Kubernetes
- Distribuzione di Kubernetes canonica
- Elastic Kubernetes Service
- Tanzu Kubernetes Grid
- Azure Red Hat OpenShift
Connettività in uscita agli endpoint seguenti:
- linuxgeneva-microsoft.azurecr.io
- upstreamarc.azurecr.io
- *.blob.core.windows.net
Assicurarsi di aver soddisfatto i prerequisiti generali per le estensioni del cluster. È necessario usare la versione 0.4.0 o successiva dell'estensione dell'interfaccia della riga di comando di Azure k8s-extension.

Installare l'estensione del provider di segreti di Azure Key Vault su cluster Kubernetes abilitato per Arc

È possibile installare l'estensione del provider di segreti di Azure Key Vault nel cluster connesso nel portale di Azure usando l'interfaccia della riga di comando di Azure o distribuendo un modello di Resource Manager.

È possibile distribuire una sola istanza dell'estensione in ogni cluster Kubernetes abilitato per Azure Arc.

Suggerimento

Se il cluster si trova in prossimità di un server proxy in uscita, assicurarsi di connetterlo ad Azure Arc usando l'opzione di configurazione del proxy prima di installare l'estensione.

Portale di Azure

Nel portale di Azure passare a Kubernetes - Azure Arc e selezionare il cluster.
Selezionare Estensioni in Impostazioni, quindi selezionare + Aggiungi.
Nell'elenco delle estensioni disponibili selezionare Provider di segreti di Azure Key Vault per distribuire la versione più recente dell'estensione.
Seguire le istruzioni per distribuire l'estensione. Se necessario, personalizzare l'installazione modificando le opzioni predefinite nella scheda Configurazione.

Interfaccia della riga di comando di Azure

Impostare le variabili di ambiente:

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

Installare il driver CSI dell'archivio segreti e l'estensione del Provider di segreti di Azure Key Vault eseguendo il comando seguente:

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

Verrà visualizzato un output simile a questo esempio. Potrebbero essere necessari alcuni minuti prima che il grafico Helm del provider di segreti venga distribuito nel cluster.

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

Modello ARM

Creare un file .json usando il formato seguente: Assicurarsi di aggiornare il valore <cluster-name> per fare riferimento al cluster.

{
    "$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'))]"
        }
    ]
}

Ora, configurare le variabili di ambiente usando i comandi seguenti dell'interfaccia della riga di comando di Azure:
```
export TEMPLATE_FILE_NAME=<template-file-path>
export DEPLOYMENT_NAME=<desired-deployment-name>
```
Eseguire infine questo comando dell'interfaccia della riga di comando di Azure per installare l'estensione del provider di segreti di Azure Key Vault:
```
az deployment group create --name $DEPLOYMENT_NAME --resource-group $RESOURCE_GROUP --template-file $TEMPLATE_FILE_NAME
```

Dovrebbe ora essere possibile visualizzare le risorse del provider di segreti e usare l'estensione nel cluster.

Convalidare l'installazione dell'estensione

Per confermare l'installazione dell'estensione del provider di segreti di Azure Key Vault, eseguire il comando seguente.

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

Verrà visualizzato un output simile a questo esempio.

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

Creare o selezionare un Azure Key Vault

Specificare quindi l'Azure Key Vault da usare con il cluster connesso. Se non è già disponibile, creare un nuovo insieme di credenziali delle chiavi usando i comandi seguenti. Si rammenta che il nome dell'insieme di credenziali delle chiavi deve essere globalmente univoco.

Impostare le seguenti variabili di ambiente:

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

Successivamente, eseguire il comando seguente:

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

Azure Key Vault può archiviare chiavi, segreti e certificati. Per questo esempio, è possibile impostare un segreto di testo normale denominato DemoSecret utilizzando il comando seguente:

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

Prima di passare alla sezione successiva, prendere nota delle proprietà seguenti:

Nome dell'oggetto segreto in Key Vault
Tipo di oggetto (segreto, chiave o certificato)
Nome della risorsa Key Vault
ID tenant di Azure per la sottoscrizione a cui appartiene l'insieme di credenziali delle chiavi

Fornire l'identità per accedere ad Azure Key Vault

Attualmente, è possibile accedere al driver CSI dell'archivio segreti nei cluster abilitati per Arc tramite un'entità servizio. Seguire questa procedura per fornire un'identità che possa accedere all'insieme di credenziali delle chiavi.

Per creare un'entità servizio in Azure , seguire la procedura. Prendere nota dei valori Client_iID e Client Secret generati in questo passaggio.
Successivamente, verificare che Azure Key Vault disponga dell'autorizzazione GET per l'entità servizio creata.

Usare l'ID client e il Segreto client dal primo passaggio per creare un segreto Kubernetes nel cluster connesso:

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

Etichettare il segreto creato:

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

Creare un SecretProviderClass con il codice YAML seguente, inserendo i valori per il nome dell'insieme di credenziali delle chiavi, l'ID tenant e gli oggetti da recuperare dall'istanza AKV:

# 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

Per l'uso con i cloud nazionali, modificare cloudName in AzureUSGovernmentCloud per Azure per enti pubblici o in AzureChinaCloud per Microsoft Azure gestito da 21Vianet.

Applicare SecretProviderClass al cluster:

kubectl apply -f secretproviderclass.yaml

Creare un pod con il codice YAML seguente, inserendo il nome dell'identità:

# 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

Applicare il pod al cluster:
```
kubectl apply -f pod.yaml
```

Convalidare i segreti

Dopo l'avvio del pod, il contenuto montato nel percorso del volume specificato nella distribuzione YAML è disponibile.

## 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

Opzioni di configurazione aggiuntive

L'estensione del provider di segreti di Azure Key Vault supporta le configurazioni del grafico Helm.

Le impostazioni di configurazione seguenti vengono usate di frequente con l'estensione del provider di segreti di Azure Key Vault:

Impostazione di configurazione	Default	Descrizione
enableSecretRotation	false	Tipo booleano. Se `true`, aggiorna periodicamente il montaggio del pod e il segreto Kubernetes con il contenuto più recente dall'archivio segreti esterni
rotationPollInterval	2 m	Se `enableSecretRotation` è `true`, questa impostazione specifica la durata dell'intervallo di polling della rotazione del segreto. Questa durata può essere modificata in base alla frequenza con cui è necessario risincronizzare il contenuto montato per tutti i pod e i segreti Kubernetes alla versione più recente.
syncSecret.enabled	false	Input booleano. In alcuni casi, si potrebbe voler creare un segreto Kubernetes per eseguire il mirroring del contenuto montato. Se `true`, `SecretProviderClass` consente al campo `secretObjects` di definire lo stato desiderato degli oggetti Segreto Kubernetes sincronizzati.

Queste impostazioni possono essere specificate quando l'estensione viene installata usando il comando az k8s-extension create:

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

È inoltre possibile modificare queste impostazioni dopo l'installazione usando il comando az k8s-extension update:

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

È possibile usare altre impostazioni di configurazione in base alle esigenze di distribuzione. Ad esempio, per modificare la directory radice kubelet durante la creazione di un cluster, modificare il comando az k8s-extension create:

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

Disinstallare l'estensione del provider di segreti di Azure Key Vault

Per disinstallare l'estensione, eseguire il comando seguente:

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

Nota

La disinstallazione dell'estensione non elimina le definizioni di risorse personalizzate create durante la sua installazione.

Per verificare che l'istanza dell'estensione sia stata eliminata, eseguire il comando seguente:

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

Se l'estensione è stata rimossa correttamente, non verrà visualizzata l'estensione del provider di segreti di Azure Key Vault elencata nell'output. Se nel cluster non sono installate altre estensioni, si vedrà solo una matrice vuota.

Se non è più necessario, assicurarsi di eliminare il segreto Kubernetes associato all'entità servizio eseguendo il comando seguente:

kubectl delete secret secrets-store-creds

Riconciliazione e risoluzione dei problemi

L'estensione del provider di segreti di Azure Key Vault è self-healing. Se qualcuno tenta di modificare o eliminare un componente di estensione distribuito al momento dell'installazione dell'estensione, tale componente viene riconciliato con lo stato originale. Le uniche eccezioni sono relative alle definizioni di risorse personalizzate (CRD). Se i CRD vengono eliminati, non verranno riconciliati. Per ripristinare i CRD eliminati, usare di nuovo il comando az k8s-extension create con il nome dell'istanza di estensione esistente.

Per altre informazioni sulla risoluzione dei problemi comuni, vedere le guide alla risoluzione dei problemi open source riferite a Provider di Azure Key Vault per i driver CSI dell'archivio segreti e Driver CSI dell'archivio segreti.

Passaggi successivi

Si desidera fare una prova? Iniziare rapidamente a usare uno scenario di avvio rapido di Azure Arc con l'API cluster.
Altre informazioni su Azure Key Vault.

Condividi tramite