Använd tillägget Secret Store för att hämta hemligheter för offlineåtkomst i Azure Arc-aktiverade Kubernetes-kluster

Azure Key Vault Secret Store-tillägget för Kubernetes (SSE) synkroniserar automatiskt hemligheter från ett Azure Key Vault till ett Azure Arc-aktiverat Kubernetes-kluster för offlineåtkomst. Det innebär att du kan använda Azure Key Vault för att lagra, underhålla och rotera dina hemligheter, även när du kör Kubernetes-klustret i ett semi-frånkopplat tillstånd. Synkroniserade hemligheter lagras i klusterhemlighetslagret, vilket gör dem tillgängliga som Kubernetes-hemligheter som ska användas på alla vanliga sätt: monterade som datavolymer eller exponerade som miljövariabler till en container i en podd.

Synkroniserade hemligheter är viktiga affärstillgångar, så SSE skyddar dem genom isolerade namnområden, rollbaserad åtkomstkontroll (RBAC) principer och begränsade behörigheter för synkroniseringskontrollanten. För extra skydd krypterar du Kubernetes-hemlighetsarkivet i klustret.

Den här artikeln visar hur du installerar och konfigurerar SSE som ett Azure Arc-aktiverat Kubernetes-tillägg.

Förutsättningar

• Ett Arc-aktiverat kluster. Detta kan vara ett som du har anslutit till dig själv (den här guiden förutsätter ett K3s-kluster och ger vägledning om hur du arcaktiverar det.) eller en Microsoft-hanterad AKS som aktiveras av Azure Arc-kluster . Klustret måste köra Kubernetes version 1.27 eller senare.
• Se till att du uppfyller de allmänna förutsättningarna för klustertillägg, inklusive den senaste versionen av k8s-extension Azure CLI-tillägget.
• cert-manager krävs för att stödja TLS för intracluster-loggkommunikation. Exemplen senare i den här guiden leder dig genom installationen. Mer information om cert-manager finns i cert-manager.io

Installera Azure CLI och logga in, om du inte redan har gjort det:

az login

Innan du börjar anger du miljövariabler som ska användas för att konfigurera Azure- och klusterresurser. Om du redan har en hanterad identitet, Azure Key Vault eller någon annan resurs som anges här uppdaterar du namnen i miljövariablerna så att de återspeglar dessa resurser. Observera att KEYVAULT_NAME måste vara globalt unikt; Det går inte att skapa Keyvault senare om det här namnet redan används i Azure.

export RESOURCE_GROUP="AzureArcTest"
export CLUSTER_NAME="AzureArcTest1"
export LOCATION="EastUS"
export SUBSCRIPTION="$(az account show --query id --output tsv)"
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-UNIQUE-kv-name"
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"

Skapa resursgruppen om det behövs:

az group create --name ${RESOURCE_GROUP}  --location ${LOCATION}

Aktivera arbetslastidentitetsfederation i klustret

SSE använder en funktion som kallas arbetsbelastningsidentitetsfederation för att komma åt och synkronisera Azure Key Vault-hemligheter. I det här avsnittet beskrivs hur du konfigurerar funktionen. I följande avsnitt förklaras hur det används i detalj.

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

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

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

Skapa en hemlighet och konfigurera en identitet för åtkomst till den

För att få åtkomst till och synkronisera en viss Azure Key Vault-hemlighet kräver SSE åtkomst till en Hanterad Azure-identitet med lämpliga Azure-behörigheter för att få åtkomst till den hemligheten. Den hanterade identiteten måste vara länkad till ett Kubernetes-tjänstkonto med hjälp av den arbetsbelastningsidentitetsfunktion som du aktiverade tidigare. Handelshögskolan använder den associerade federerade hanterade Azure-identiteten för att hämta hemligheter från Azure Key Vault till ditt Kubernetes-hemlighetsarkiv. I följande avsnitt beskrivs hur du konfigurerar detta.

Skapa ett Azure Key Vault

Skapa ett Azure Key Vault och lägg till en hemlighet. Om du redan har ett Azure Key Vault och en hemlighet kan du hoppa över det här avsnittet.

1. Skapa ett Azure Key Vault:

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

2. Ge dig själv behörigheten "Secrets Officer" för valvet så att du kan skapa en hemlighet.

   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. Skapa en hemlighet och uppdatera den så att du har två versioner:

   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'
   

Skapa en användartilldelad hanterad identitet

Skapa sedan en användartilldelad hanterad identitet och ge den behörighet att komma åt Azure Key Vault. Om du redan har en hanterad identitet med behörigheten Key Vault Reader och Key Vault Secrets User till Azure Key Vault kan du hoppa över det här avsnittet. Mer information finns i Skapa en användartilldelad hanterad identitet och Använda Azure RBAC-hemlighet, nyckel- och certifikatbehörigheter med Key Vault.

1. Skapa den användartilldelade hanterade identiteten:

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

2. Tilldela identiteten rättigheter till Key Vault Reader och Key Vault Secrets User. Du kan behöva vänta en stund på replikering av identitetsskapandet innan dessa kommandon lyckas:

   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}
   

Skapa en federerad identitetsautentiseringsuppgift

Skapa ett Kubernetes-tjänstkonto för den arbetsbelastning som behöver åtkomst till hemligheter. Skapa sedan en federerad identitetsautentiseringsuppgift för att länka mellan den hanterade identiteten, utfärdaren av OIDC-tjänstkontot och Kubernetes-tjänstkontot.

1. Skapa ett Kubernetes-tjänstkonto som federeras till den hanterade identiteten. Kommentera med information om den associerade hanterade identiteten som har tilldelats användaren.

   kubectl create ns ${KUBERNETES_NAMESPACE}
   

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

2. Skapa en federerad identitetsautentiseringsuppgift:

   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} --audience api://AzureADTokenExchange
   

Installera SSE

SSE är tillgängligt som ett Azure Arc-tillägg. Ett Azure Arc-aktiverat Kubernetes-kluster kan utökas med Azure Arc-aktiverade Kubernetes-tillägg. Tillägg möjliggör Azure-funktioner i ditt anslutna kluster och ger en Azure Resource Manager-driven upplevelse för tilläggsinstallation och livscykelhantering.

cert-manager och trust-manager krävs också för säker kommunikation av loggar mellan klustertjänster och måste installeras före Arc-tillägget.

1. Installera cert-manager.

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

2. Installera trust-manager.

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

3. Installera SSE till ditt Arc-aktiverade kluster med följande kommando:

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

   Om du vill kan du ändra standardintervallet för rotationssökning genom att lägga till --configuration-settings rotationPollIntervalInSeconds=<time_in_seconds> (se konfigurationsreferens).

Konfigurera SSE

Konfigurera det installerade tillägget med information om ditt Azure Key Vault och vilka hemligheter som ska synkroniseras med klustret genom att definiera instanser av anpassade Kubernetes-resurser. Du skapar två typer av anpassade resurser:

• Ett SecretProviderClass objekt som definierar anslutningen till Key Vault.
• Ett SecretSync objekt för varje hemlighet som ska synkroniseras.

Skapa en SecretProviderClass resurs

Resursen SecretProviderClass används för att definiera anslutningen till Azure Key Vault, identiteten som ska användas för att komma åt valvet, vilka hemligheter som ska synkroniseras och antalet versioner av varje hemlighet som ska behållas lokalt.

Du behöver en separat SecretProviderClass för varje Azure Key Vault som du tänker synkronisera, för varje identitet som används för åtkomst till ett Azure Key Vault och för varje Kubernetes-målnamnområde.

Skapa en eller flera SecretProviderClass YAML-filer med lämpliga värden för ditt Key Vault och dina hemligheter genom att följa det här exemplet.

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

Se SecretProviderClass-referens för ytterligare konfigurationsvägledning.

Skapa ett SecretSync objekt

Ett SecretSync objekt behövs för att definiera hur objekt som SecretsProviderClass hämtas av lagras i Kubernetes. Kubernetes-hemligheter är nyckel-värde-kartor, precis som ConfigMaps, och SecretSync-objektet informerar SSE om hur objekt som definierats i det länkade SecretsProviderClass ska mappas till nycklar i Kubernetes-hemligheten. SSE skapar en Kubernetes-hemlighet med samma namn som den SecretSync som beskriver den.

Skapa en SecretSync YAML-objektfil för varje kubernetes-hemlighet genom att följa den här mallen. Kubernetes-namnområdet ska matcha namnområdet för SecretProviderClass.

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

Se SecretSync-referens för ytterligare konfigurationsvägledning.

Tillämpa konfigurations-CR:erna

Använd de anpassade konfigurationsresurserna (CR) med kommandot kubectl apply :

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

SSE söker automatiskt efter hemligheterna och börjar synkronisera dem till klustret.

Observera hemligheter som synkroniseras med klustret

När konfigurationen har tillämpats börjar hemligheter synkroniseras automatiskt med klustret vid den takt som anges när SSE installeras.

Visa synkroniserade hemligheter

Visa hemligheterna som synkroniserats med klustret genom att köra följande kommando:

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

Visa hemligheters värden

Om du vill visa de synkroniserade hemliga värdena, som nu lagras i Kubernetes hemliga arkiv, använder du följande kommando:

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

Felsökning

Se felsökningsguiden för hjälp med att diagnostisera och lösa problem.

Ta bort SSE

Om du vill ta bort SSE och sluta synkronisera hemligheter avinstallerar du den med az k8s-extension delete kommandot :

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

Om du avinstallerar tillägget tas inte hemligheter, SecretSync objekt eller CRD:er bort från klustret. Dessa objekt måste tas bort direkt med kubectl.

Om du tar bort SecretSync CRD tas alla SecretSync objekt bort och alla ägda hemligheter tas bort som standard, men hemligheter kan sparas om:

• Du har ändrat ägarskapet för någon av hemligheterna.
• Du har ändrat inställningarna för skräpinsamling i klustret, inklusive att ange olika finalizers.

I dessa fall måste hemligheter tas bort direkt med hjälp av kubectl.

Nästa steg

• Läs mer om Azure Arc-tillägg.
• Läs mer om Azure Key Vault.
• Hjälp med att skydda klustret på andra sätt genom att följa riktlinjerna i säkerhetsboken för Azure Arc-aktiverade Kubernetes.