Esercitazione: Usare un'identità del carico di lavoro con un'applicazione nel servizio Azure Kubernetes

Articolo
03/20/2024

Il servizio Azure Kubernetes è un servizio Kubernetes gestito che permette di distribuire e gestire rapidamente i cluster Kubernetes. In questa esercitazione:

Distribuire un cluster del servizio Azure Kubernetes usando l'interfaccia della riga di comando di Azure con l'autorità di certificazione OIDC (OpenID Connect) e l'identità gestita.
Creare un Key Vault di Azure e un segreto.
Creare un ID carico di lavoro Microsoft Entra e un account del servizio Kubernetes.
Configurare l'identità gestita per la federazione dei token.
Distribuire il carico di lavoro e verificare l'autenticazione con l'identità del carico di lavoro.

Operazioni preliminari

Questa esercitazione presuppone una conoscenza di base dei concetti di Kubernetes. Per altre informazioni, vedere Concetti di base relativi a Kubernetes per il servizio Azure Kubernetes.
Se non si ha familiarità con l'ID del carico di lavoro Microsoft Entra, vedere la panoramica dell'ID del carico di lavoro di Microsoft Entra.
Quando si crea un cluster del servizio Azure Kubernetes, viene creato automaticamente un secondo gruppo di risorse per archiviare le risorse del servizio Azure Kubernetes. Per altre informazioni, vedere Perché vengono creati due gruppi di risorse con servizio Azure Kubernetes?

Prerequisiti

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.
Questo articolo richiede la versione 2.47.0 o successiva dell'interfaccia della riga di comando di Azure. Se si usa Azure Cloud Shell, la versione più recente è già installata.
L'identità usata per creare il cluster deve disporre delle autorizzazioni minime appropriate. Per altre informazioni sull'accesso e l'identità per il servizio Azure Kubernetes, vedere Opzioni di accesso e identità per il servizio Azure Kubernetes.
Se si hanno più sottoscrizioni di Azure, selezionare l'ID sottoscrizione appropriato in cui le risorse devono essere fatturate usando il comando az account set.

Creare un gruppo di risorse

Un gruppo di risorse di Azure è un gruppo logico in cui le risorse di Azure vengono distribuite e gestite. Quando si crea un gruppo di risorse, viene richiesto di specificare una posizione. Questa posizione è la posizione di archiviazione dei metadati del gruppo di risorse e la posizione in cui le risorse vengono eseguite in Azure se non si specifica un'altra area durante la creazione delle risorse.

L'esempio seguente crea un gruppo di risorse denominato myResourceGroup nella località stati uniti orientali.

Creare un gruppo di risorse con il comando az group create.

az group create --name myResourceGroup --location eastus

L'esempio di output seguente è simile alla corretta creazione del gruppo di risorse:

{
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup",
  "location": "eastus",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Esportare le variabili di ambiente

Per semplificare la procedura per configurare le identità necessarie, la procedura seguente definisce le variabili di ambiente per riferimento nel cluster.

Creare queste variabili usando i comandi seguenti. Sostituire i valori predefiniti per RESOURCE_GROUP, LOCATION, SERVICE_ACCOUNT_NAME, SUBSCRIPTION , USER_ASSIGNED_IDENTITY_NAME e FEDERATED_IDENTITY_CREDENTIAL_NAME.

export RESOURCE_GROUP="myResourceGroup"
export LOCATION="westcentralus"
export SERVICE_ACCOUNT_NAMESPACE="default"
export SERVICE_ACCOUNT_NAME="workload-identity-sa"
export SUBSCRIPTION="$(az account show --query id --output tsv)"
export USER_ASSIGNED_IDENTITY_NAME="myIdentity"
export FEDERATED_IDENTITY_CREDENTIAL_NAME="myFedIdentity"
export KEYVAULT_NAME="azwi-kv-tutorial"
export KEYVAULT_SECRET_NAME="my-secret"

Creare un cluster del servizio Azure Kubernetes

Creare un cluster del servizio Azure Kubernetes usando il comando az aks create con il parametro --enable-oidc-issuer per usare l'autorità di certificazione OIDC.
```
az aks create --resource-group "${RESOURCE_GROUP}" --name myAKSCluster --node-count 1 --enable-oidc-issuer --enable-workload-identity --generate-ssh-keys
```
Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON sul cluster.
Ottenere l'URL dell'autorità emittente OIDC e salvarlo in una variabile di ambiente usando il comando seguente. Sostituire il valore predefinito per gli argomenti -n, ovvero il nome del cluster.
```
export AKS_OIDC_ISSUER="$(az aks show --name myAKSCluster --resource-group "${RESOURCE_GROUP}" --query "oidcIssuerProfile.issuerUrl" -o tsv)"
```
La variabile deve contenere l'URL dell'autorità di certificazione simile all'esempio seguente:
```
https://eastus.oic.prod-aks.azure.com/00000000-0000-0000-0000-000000000000/00000000-0000-0000-0000-000000000000/
```
Per impostazione predefinita, l'autorità emittente è impostata per usare l'URL di base https://{region}.oic.prod-aks.azure.com, dove il valore per {region} corrisponde al percorso in cui viene distribuito il cluster del servizio Azure Kubernetes.

Creare un insieme di credenziali delle chiavi di Azure e un segreto

Creare un insieme di credenziali delle chiavi di Azure nel gruppo di risorse creato in questa esercitazione usando il comando az keyvault create.
```
az keyvault create --resource-group "${RESOURCE_GROUP}" --location "${LOCATION}" --name "${KEYVAULT_NAME}" --enable-rbac-authorization false
```
L'output di questo comando mostra le proprietà dell'insieme di credenziali delle chiavi appena creato. Prendere nota delle due proprietà elencate di seguito:
- Name: nome dell'insieme di credenziali specificato al parametro --name.
- vaultUri: in questo esempio corrisponde a https://<your-unique-keyvault-name>.vault.azure.net/. Le applicazioni che usano l'insieme di credenziali tramite l'API REST devono usare questo URI.
A questo punto, l'account Azure è l'unico autorizzato a eseguire qualsiasi operazione su questo nuovo insieme di credenziali.
Aggiungere ora un segreto all'insieme di credenziali delle chiavi usando il comando az keyvault secret set. La password è il valore specificato per la variabile di ambiente KEYVAULT_SECRET_NAME e archivia il valore di Hello!.
```
az keyvault secret set --vault-name "${KEYVAULT_NAME}" --name "${KEYVAULT_SECRET_NAME}" --value 'Hello!'
```

Aggiungere l'URL dell'insieme di credenziali delle chiavi alla variabile di ambiente KEYVAULT_URL usando il comando az keyvault show.

export KEYVAULT_URL="$(az keyvault show --resource-group "${RESOURCE_GROUP}" --name ${KEYVAULT_NAME} --query properties.vaultUri -o tsv)"

Creare un'identità gestita e concedere le autorizzazioni per accedere al segreto

Impostare una sottoscrizione specifica come sottoscrizione attiva corrente usando il comando az account set.
```
az account set --subscription "${SUBSCRIPTION}"
```

Creare un'identità gestita usando il comando az identity create.

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

Impostare un criterio di accesso per l'identità gestita per accedere al segreto dell'insieme di credenziali delle chiavi usando i comandi seguenti.

export USER_ASSIGNED_CLIENT_ID="$(az identity show --resource-group "${RESOURCE_GROUP}" --name "${USER_ASSIGNED_IDENTITY_NAME}" --query 'clientId' -otsv)"

az keyvault set-policy --name "${KEYVAULT_NAME}" --secret-permissions get --spn "${USER_ASSIGNED_CLIENT_ID}"

Creare un account del servizio Kubernetes

Creare un account del servizio Kubernetes e annotarlo con l'ID client dell'identità gestita creata nel passaggio precedente usando il comando az aks get-credentials. Sostituire il valore predefinito per il nome del cluster e il nome del gruppo di risorse.
```
az aks get-credentials --name myAKSCluster --resource-group "${RESOURCE_GROUP}"
```

Copiare il seguente input su più righe nel terminale ed eseguire il comando per creare l'account del servizio.

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

L'output seguente è simile alla corretta creazione dell'identità:

Serviceaccount/workload-identity-sa created

Stabilire credenziali di identità federate

Creare le credenziali di identità federate tra l'identità gestita, l'autorità emittente dell'account del servizio e l'oggetto usando il comando az identity federated-credential create.
```
az identity federated-credential create --name ${FEDERATED_IDENTITY_CREDENTIAL_NAME} --identity-name ${USER_ASSIGNED_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP} --issuer ${AKS_OIDC_ISSUER} --subject system:serviceaccount:${SERVICE_ACCOUNT_NAMESPACE}:${SERVICE_ACCOUNT_NAME}
```
Nota

La propagazione delle credenziali dell'identità federata dopo l'aggiunta iniziale richiede alcuni secondi. Se una richiesta di token è immediatamente disponibile dopo l'aggiunta delle credenziali dell'identità federata, è possibile che si verifichi un errore per un paio di minuti, perché la cache viene popolata nella directory con dati obsoleti. Per evitare questo problema, è possibile aggiungere un lieve ritardo dopo l'aggiunta delle credenziali di identità federate.

Distribuire il carico di lavoro

Distribuire un pod che fa riferimento all'account del servizio creato nel passaggio precedente usando il comando seguente.

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: quick-start
  namespace: ${SERVICE_ACCOUNT_NAMESPACE}
  labels:
    azure.workload.identity/use: "true"
spec:
  serviceAccountName: ${SERVICE_ACCOUNT_NAME}
  containers:
    - image: ghcr.io/azure/azure-workload-identity/msal-go
      name: oidc
      env:
      - name: KEYVAULT_URL
        value: ${KEYVAULT_URL}
      - name: SECRET_NAME
        value: ${KEYVAULT_SECRET_NAME}
  nodeSelector:
    kubernetes.io/os: linux
EOF

L'output seguente è simile alla corretta creazione del pod:

pod/quick-start created

Controllare se tutte le proprietà vengono inserite correttamente con il webhook usando il comando kubectl describe.
```
kubectl describe pod quick-start
```
Verificare che il pod possa ottenere un token e accedere al segreto dall'insieme di credenziali delle chiavi usando il comando kubectl logs.
```
kubectl logs quick-start
```
L'output seguente è simile all'accesso riuscito del token:
```
I1013 22:49:29.872708       1 main.go:30] "successfully got secret" secret="Hello!"
```

Pulire le risorse

È possibile lasciare queste risorse. Se queste risorse non sono più necessarie, usare i comandi seguenti per eliminarle.

Eliminare il pod usando il comando kubectl delete pod.
```
kubectl delete pod quick-start
```

Eliminare l'account del servizio usando il comando kubectl delete sa.

kubectl delete sa "${SERVICE_ACCOUNT_NAME}" --namespace "${SERVICE_ACCOUNT_NAMESPACE}"

Eliminare il gruppo di risorse di Azure e tutte le relative risorse usando il comando az group delete.
```
az group delete --name "${RESOURCE_GROUP}"
```

Passaggi successivi

In questa esercitazione è stato distribuito un cluster Kubernetes e quindi è stata distribuita una semplice applicazione contenitore per testare l'uso di un ID carico di lavoro di Microsoft Entra.

Questa esercitazione è destinata a scopi introduttivi. Per indicazioni sulla creazione di soluzioni complete con il servizio Azure Kubernetes per la produzione, vedere le Linee guida per la soluzione del servizio Azure Kubernetes.

Share via