Usare l'estensione Archivio di segreti per recuperare i segreti per l'accesso offline nei cluster Kubernetes abilitati per Azure Arc

L'estensione dell'archivio segreto di Azure Key Vault per Kubernetes ("SSE") sincronizza automaticamente i segreti da un insieme di credenziali delle chiavi di Azure a un cluster Kubernetes abilitato per Azure Arc per l'accesso offline. Ciò significa, che è possibile usare Azure Key Vault per archiviare, gestire e ruotare i segreti, anche quando si esegue il cluster Kubernetes in uno stato semi-disconnesso. I segreti sincronizzati vengono archiviati nel cluster archivio di segreti, rendendoli disponibili come segreti Kubernetes da usare in tutti i modi consueti: montati come volumi di dati o esposti come variabili di ambiente a un contenitore in un pod.

I segreti sincronizzati sono asset aziendali critici, quindi la crittografia SSE li protegge tramite spazi dei nomi e nodi isolati, criteri di controllo degli accessi in base al ruolo e autorizzazioni limitate per il programma di sincronizzazione dei segreti. Per una protezione aggiuntiva, crittografare l'archivio segreti Kubernetes nel cluster.

Questo articolo illustra come installare e configurare la crittografia del servizio di archiviazione come estensione Kubernetes abilitata per Azure Arc.

Prerequisiti

• Un cluster abilitato per Arc. Può trattarsi di una connessione a se stessi (gli esempi in questa guida usano un cluster K3s ) o un servizio Azure Kubernetes gestito da Microsoft enanabled da un cluster Di Azure Arc . Il cluster deve eseguire Kubernetes versione 1.27 o successiva e in una delle aree supportate (Stati Uniti orientali, Stati Uniti orientali 2, Stati Uniti occidentali, Stati Uniti occidentali2, Stati Uniti occidentali 3, Europa occidentale, Europa settentrionale). L'area è definita dall'area del gruppo di risorse usata per la creazione del cluster Arc.
• Assicurarsi di soddisfare i prerequisiti generali per le estensioni del cluster, inclusa la versione più recente dell'estensione dell'interfaccia della riga di comando di Azure k8s-extension.
• cert-manager è necessario per supportare TLS per la comunicazione tra log intracluster. Gli esempi più avanti in questa guida indirizzano l'utente durante l'installazione. Per altre informazioni su cert-manager, vedere cert-manager.io

Installare l'interfaccia della riga di comando di Azure ed eseguire l'accesso, se non è già stato fatto:

az login

Prima di iniziare, impostare le variabili di ambiente da usare per configurare le risorse di Azure e del cluster. Se si dispone già di un'identità gestita, Azure Key Vault o un'altra risorsa elencata qui, aggiornare i nomi nelle variabili di ambiente per riflettere tali risorse.

export RESOURCE_GROUP="AzureArcTest"
export CLUSTER_NAME="AzureArcTest1"
export LOCATION="EastUS"
export SUBSCRIPTION="$(az account show --query id --output tsv)"
az account set --subscription "${SUBSCRIPTION}"
export AZURE_TENANT_ID="$(az account show -s $SUBSCRIPTION --query tenantId --output tsv)"
export CURRENT_USER="$(az ad signed-in-user show --query userPrincipalName --output tsv)"
export KEYVAULT_NAME="my-kv"
export KEYVAULT_SECRET_NAME="my-secret"
export USER_ASSIGNED_IDENTITY_NAME="my-identity"
export FEDERATED_IDENTITY_CREDENTIAL_NAME="my-credential"
export KUBERNETES_NAMESPACE="my-namespace"
export SERVICE_ACCOUNT_NAME="my-service-account"

Attivare la federazione dell'identità del carico di lavoro nel cluster

La crittografia del servizio di archiviazione usa una funzionalità denominata federazione delle identità del carico di lavoro per accedere e sincronizzare i segreti di Azure Key Vault. Questa sezione descrive come configurare questa impostazione. Le sezioni seguenti illustrano in dettaglio come viene usato.

az connectedk8s connect --name ${CLUSTER_NAME} --resource-group ${RESOURCE_GROUP} --enable-oidc-issuer --enable-workload-identity

az connectedk8s update --name ${CLUSTER_NAME} --resource-group ${RESOURCE_GROUP} --enable-oidc-issuer --enable-workload-identity

export SERVICE_ACCOUNT_ISSUER="$(az connectedk8s show --name ${CLUSTER_NAME} --resource-group ${RESOURCE_GROUP} --query "oidcIssuerProfile.issuerUrl" --output tsv)"
echo $SERVICE_ACCOUNT_ISSUER

export SERVICE_ACCOUNT_ISSUER="$(az connectedk8s show --name ${CLUSTER_NAME} --resource-group ${RESOURCE_GROUP} --query "oidcIssuerProfile.issuerUrl" --output tsv)"
echo $SERVICE_ACCOUNT_ISSUER

Creare un segreto e configurare un'identità per accedervi

Per accedere e sincronizzare un determinato segreto di Azure Key Vault, la crittografia del servizio di archiviazione richiede l'accesso a un'identità gestita di Azure con le autorizzazioni di Azure appropriate per accedere a tale segreto. L'identità gestita deve essere collegata a un account del servizio Kubernetes usando la funzionalità di identità del carico di lavoro attivata in precedenza. La crittografia del servizio di archiviazione usa l'identità gestita di Azure federata associata per eseguire il pull dei segreti da Azure Key Vault all'archivio dei segreti Kubernetes. Le sezioni seguenti descrivono come configurare questa impostazione.

Creare un Azure Key Vault

Creare un'istanza di Azure Key Vault e aggiungere un segreto. Se si dispone già di Azure Key Vault e di un segreto, è possibile ignorare questa sezione.

1. Creare un insieme di credenziali delle chiavi di Azure:

   az keyvault create --resource-group "${RESOURCE_GROUP}" --location "${LOCATION}" --name "${KEYVAULT_NAME}" --enable-rbac-authorization
   

2. Concedere a se stessi le autorizzazioni di "Secrets Officer" nell'insieme di credenziali, in modo da poter creare un segreto:

   az role assignment create --role "Key Vault Secrets Officer" --assignee ${CURRENT_USER} --scope /subscriptions/${SUBSCRIPTION}/resourcegroups/${RESOURCE_GROUP}/providers/Microsoft.KeyVault/vaults/${KEYVAULT_NAME}
   

3. Creare un segreto e aggiornarlo in modo da avere due versioni:

   az keyvault secret set --vault-name "${KEYVAULT_NAME}" --name "${KEYVAULT_SECRET_NAME}" --value 'Hello!'
   az keyvault secret set --vault-name "${KEYVAULT_NAME}" --name "${KEYVAULT_SECRET_NAME}" --value 'Hello2'
   

Creare un'identità gestita assegnata dall'utente

Creare quindi un'identità gestita assegnata dall'utente e concedere le autorizzazioni per accedere ad Azure Key Vault. Se si dispone già di un'identità gestita con autorizzazioni utente con autorizzazioni di lettura Key Vault e Segreti Key Vault per Azure Key Vault, è possibile ignorare questa sezione. Per altre informazioni, vedere Creare identità gestite assegnate dall'utente e Usare il segreto, la chiave e il certificato di Controllo degli accessi in base al ruolo di Azure (RBAC) con Key Vault.

1. Creare l'identità gestita assegnata dall'utente.

   az identity create --name "${USER_ASSIGNED_IDENTITY_NAME}" --resource-group "${RESOURCE_GROUP}" --location "${LOCATION}" --subscription "${SUBSCRIPTION}"
   

2. Assegnare all'identità le autorizzazioni utente per il lettore di Key Vault e Segreti Key Vault. Potrebbe essere necessario attendere un momento per la replica della creazione dell'identità prima che questi comandi abbiano esito positivo:

   export USER_ASSIGNED_CLIENT_ID="$(az identity show --resource-group "${RESOURCE_GROUP}" --name "${USER_ASSIGNED_IDENTITY_NAME}" --query 'clientId' -otsv)"
   az role assignment create --role "Key Vault Reader" --assignee "${USER_ASSIGNED_CLIENT_ID}" --scope /subscriptions/${SUBSCRIPTION}/resourcegroups/${RESOURCE_GROUP}/providers/Microsoft.KeyVault/vaults/${KEYVAULT_NAME}
   az role assignment create --role "Key Vault Secrets User" --assignee "${USER_ASSIGNED_CLIENT_ID}" --scope /subscriptions/${SUBSCRIPTION}/resourcegroups/${RESOURCE_GROUP}/providers/Microsoft.KeyVault/vaults/${KEYVAULT_NAME}
   

Creare credenziali di identità federate

Creare un account del servizio Kubernetes per il carico di lavoro che deve accedere ai segreti. Creare quindi una credenziale dell'identità federata per collegarsi tra l'identità gestita, l'emittente dell'account del servizio OIDC e l'account del servizio Kubernetes.

1. Creare un account del servizio Kubernetes che verrà federato all'identità gestita. Annotarlo con i dettagli dell'identità gestita assegnata dall'utente associata.

   kubectl create ns ${KUBERNETES_NAMESPACE}
   

   cat <<EOF | kubectl apply -f -
     apiVersion: v1
     kind: ServiceAccount
     metadata:
       name: ${SERVICE_ACCOUNT_NAME}
       namespace: ${KUBERNETES_NAMESPACE}
   EOF
   

2. Creare credenziali di identità federate:

   az identity federated-credential create --name ${FEDERATED_IDENTITY_CREDENTIAL_NAME} --identity-name ${USER_ASSIGNED_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP} --issuer ${SERVICE_ACCOUNT_ISSUER} --subject system:serviceaccount:${KUBERNETES_NAMESPACE}:${SERVICE_ACCOUNT_NAME}
   

Installare la crittografia del servizio di archiviazione

La crittografia del servizio di archiviazione è disponibile come estensione di Azure Arc. Un cluster Kubernetes abilitato per Azure Arc può essere esteso con estensioni Kubernetes abilitate per Azure Arc. Le estensioni abilitano le funzionalità di Azure nel cluster connesso e offrono un'esperienza guidata da Azure Resource Manager per l'installazione e la gestione del ciclo di vita dell'estensione.

Anche cert-manager e trust-manager sono necessari per la comunicazione sicura dei log tra i servizi cluster e deve essere installato prima dell'estensione Arc.

1. Installare cert-manager.

   helm repo add jetstack https://charts.jetstack.io/ --force-update
   helm install cert-manager jetstack/cert-manager --namespace cert-manager --create-namespace --version v1.16.2 --set crds.enabled=true 
   

2. Installare trust-manager.

   helm upgrade trust-manager jetstack/trust-manager --install --namespace cert-manager --wait
   

3. Installare la crittografia del servizio di archiviazione nel cluster abilitato per Arc usando il comando seguente:

   az k8s-extension create \
     --cluster-name ${CLUSTER_NAME} \
     --cluster-type connectedClusters \
     --extension-type microsoft.azure.secretstore \
     --resource-group ${RESOURCE_GROUP} \
     --release-train preview \
     --name ssarcextension \
     --scope cluster 
   

   Se lo si desidera, è possibile modificare facoltativamente l'intervallo di polling di rotazione predefinito aggiungendo --configuration-settings rotationPollIntervalInSeconds=<time_in_seconds>:

   Nome parametro	Descrizione	Default value
   rotationPollIntervalInSeconds	Specifica la velocità con cui la crittografia del servizio di archiviazione controlla o aggiorna il segreto che gestisce.	3600 (1 ora)

Configurare la crittografia del servizio di archiviazione

Configurare l'estensione installata con informazioni su Azure Key Vault e quali segreti sincronizzare con il cluster definendo istanze delle risorse personalizzate di Kubernetes. Si creano due tipi di risorse personalizzate:

• Un oggetto SecretProviderClass per definire la connessione a Key Vault.
• Un oggetto SecretSync per ogni segreto da sincronizzare.

Creare una risorsa SecretProviderClass

La risorsa SecretProviderClass viene usata per definire la connessione ad Azure Key Vault, l'identità da usare per accedere all'insieme di credenziali, i segreti da sincronizzare e il numero di versioni di ogni segreto da mantenere in locale.

È necessario un SecretProviderClass separato per ogni Azure Key Vault che si intende sincronizzare, per ogni identità usata per l'accesso a un Azure Key Vault e per ogni spazio dei nomi Kubernetes di destinazione.

Creare uno o più file YAML SecretProviderClass con i valori appropriati per Key Vault e i segreti seguendo questo esempio.

cat <<EOF > spc.yaml
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: secret-provider-class-name                      # Name of the class; must be unique per Kubernetes namespace
  namespace: ${KUBERNETES_NAMESPACE}                    # Kubernetes namespace to make the secrets accessible in
spec:
  provider: azure
  parameters:
    clientID: "${USER_ASSIGNED_CLIENT_ID}"               # Managed Identity Client ID for accessing the Azure Key Vault with.
    keyvaultName: ${KEYVAULT_NAME}                       # The name of the Azure Key Vault to synchronize secrets from.
    objects: |
      array:
        - |
          objectName: ${KEYVAULT_SECRET_NAME}            # The name of the secret to sychronize.
          objectType: secret
          objectVersionHistory: 2                       # [optional] The number of versions to synchronize, starting from latest.
    tenantID: "${AZURE_TENANT_ID}"                       # The tenant ID of the Key Vault 
EOF

Creare un oggetto SecretSync

Ogni segreto sincronizzato richiede anche un oggetto SecretSync per definire informazioni specifiche del cluster. Qui si specificano informazioni quali il nome del segreto nel cluster e i nomi per ogni versione del segreto archiviato nel cluster.

Creare un file YAML dell'oggetto SecretSync per ogni segreto, seguendo questo modello. Lo spazio dei nomi Kubernetes deve corrispondere allo spazio dei nomi del SecretProviderClass corrispondente.

cat <<EOF > ss.yaml
apiVersion: secret-sync.x-k8s.io/v1alpha1
kind: SecretSync
metadata:
  name: secret-sync-name                                  # Name of the object; must be unique per Kubernetes namespace
  namespace: ${KUBERNETES_NAMESPACE}                      # Kubernetes namespace
spec:
  serviceAccountName: ${SERVICE_ACCOUNT_NAME}             # The Kubernetes service account to be given permissions to access the secret.
  secretProviderClassName: secret-provider-class-name     # The name of the matching SecretProviderClass with the configuration to access the AKV storing this secret
  secretObject:
    type: Opaque
    data:
    - sourcePath: ${KEYVAULT_SECRET_NAME}/0                # Name of the secret in Azure Key Vault with an optional version number (defaults to latest)
      targetKey: ${KEYVAULT_SECRET_NAME}-data-key0         # Target name of the secret in the Kubernetes secret store (must be unique)
    - sourcePath: ${KEYVAULT_SECRET_NAME}/1                # [optional] Next version of the AKV secret. Note that versions of the secret must match the configured objectVersionHistory in the secrets provider class 
      targetKey: ${KEYVAULT_SECRET_NAME}-data-key1         # [optional] Next target name of the secret in the K8s secret store
EOF

Applicare CR di configurazione

Applicare le risorse personalizzate (CR) di configurazione usando il comando kubectl apply:

kubectl apply -f ./spc.yaml
kubectl apply -f ./ss.yaml

La crittografia del servizio di archiviazione cerca automaticamente i segreti e inizia a sincronizzarli con il cluster.

Visualizzare le opzioni di configurazione

Per visualizzare opzioni di configurazione aggiuntive per questi due tipi di risorse personalizzate, usare il comando kubectl describe per esaminare i CRD nel cluster:

# Get the name of any applied CRD(s)
kubectl get crds -o custom-columns=NAME:.metadata.name

# View the full configuration options and field parameters for a given CRD
kubectl describe crd secretproviderclass
kubectl describe crd secretsync

Osservare la sincronizzazione dei segreti con il cluster

Dopo aver applicato la configurazione, i segreti iniziano a eseguire automaticamente la sincronizzazione con il cluster alla frequenza specificata durante l'installazione della crittografia del servizio di archiviazione.

Visualizzare i segreti sincronizzati

Visualizzare i segreti sincronizzati con il cluster eseguendo il comando seguente:

# View a list of all secrets in the namespace
kubectl get secrets -n ${KUBERNETES_NAMESPACE}

# View details of all secrets in the namespace
kubectl get secrets -n ${KUBERNETES_NAMESPACE} -o yaml

Visualizzare lo stato dell'ultima sincronizzazione

Per visualizzare lo stato della sincronizzazione più recente per un determinato segreto, utilizzare il comando kubectl describe per l'oggetto SecretSync. L'output include il timestamp di creazione del segreto, le versioni del segreto e i messaggi di stato dettagliati per ogni evento di sincronizzazione. Questo output può essere usato per diagnosticare gli errori di connessione o configurazione e per osservare quando il valore del segreto cambia.

kubectl describe secretsync secret-sync-name -n ${KUBERNETES_NAMESPACE}

Visualizzare i valori dei segreti

Per visualizzare i valori dei segreti sincronizzati, ora archiviati nell'archivio segreti Kubernetes, usare il comando seguente:

kubectl get secret secret-sync-name -n ${KUBERNETES_NAMESPACE} -o jsonpath="{.data.${KEYVAULT_SECRET_NAME}-data-key0}" | base64 -d
kubectl get secret secret-sync-name -n ${KUBERNETES_NAMESPACE} -o jsonpath="{.data.${KEYVAULT_SECRET_NAME}-data-key1}" | base64 -d

Risoluzione dei problemi

La crittografia del servizio di archiviazione è una distribuzione Kubernetes che contiene un pod con due contenitori: il controller, che gestisce l'archiviazione dei segreti nel cluster e il provider, che gestisce l'accesso e il pull dei segreti da Azure Key Vault. Ogni segreto sincronizzato ha un oggetto SecretSync che contiene lo stato della sincronizzazione del segreto da Azure Key Vault all'archivio segreti del cluster.

Per risolvere un problema, iniziare esaminando lo stato dell'oggetto SecretSync, come descritto in Visualizzare l'ultimo stato di sincronizzazione. Nella tabella seguente sono elencati i tipi di stato comuni, i relativi significati e i possibili passaggi di risoluzione dei problemi per risolvere gli errori.

Rimuovere la crittografia del servizio di archiviazione

Per rimuovere la crittografia del servizio di archiviazione e arrestare la sincronizzazione dei segreti, disinstallarla con il az k8s-extension delete comando :

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

La disinstallazione dell'estensione non rimuove segreti, oggetti SecretSync o CRD dal cluster. Questi oggetti devono essere rimossi direttamente con kubectl.

L'eliminazione di SecretSync CRD rimuove tutti gli oggetti SecretSync e, per impostazione predefinita, rimuove tutti i segreti di proprietà, ma i segreti possono persistere se:

• È stata modificata la proprietà di uno dei segreti.
• Sono state modificate le impostazioni GC nel cluster, inclusa l'impostazione di finalizzatori diversi.

Nei casi precedenti, i segreti devono essere eliminati direttamente usando kubectl.

Passaggi successivi

• Altre informazioni sulle estensioni di Azure Arc.
• Altre informazioni su Azure Key Vault.