Tutoriel : Utiliser une identité de charge de travail avec une application sur Azure Kubernetes Service (AKS)

Article
10/29/2023

AKS (Azure Kubernetes Service) est un service Kubernetes managé qui vous permet de déployer et de gérer rapidement des clusters Kubernetes. Dans ce tutoriel, vous allez :

Déployez un cluster AKS à l’aide d’Azure CLI avec l’émetteur OpenID Connect (OIDC) et l’identité managée.
Créez une instance Azure Key Vault et un secret.
Créer Microsoft Entra Workload ID et un compte de service Kubernetes.
Configurez l’identité managée pour la fédération de jeton.
Déployez la charge de travail et vérifiez l’authentification avec l’identité de la charge de travail.

Avant de commencer

Ce didacticiel suppose que vous disposez de connaissances de base sur les concepts de Kubernetes. Pour plus d’informations, consultez Concepts de base de Kubernetes pour AKS (Azure Kubernetes Service).
Si vous n’êtes pas familiarisé avec Microsoft Entra Workload ID, consultez Vue d’ensemble de Microsoft Entra Workload ID.
Lors de la création d’un cluster AKS, un deuxième groupe de ressources est automatiquement créé pour stocker les ressources AKS. Pour plus d’informations, consultez Pourquoi deux groupes de ressources sont-ils créés avec AKS ?

Prérequis

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit Azure avant de commencer.
Cet article nécessite la version 2.47.0 ou ultérieure d’Azure CLI. Si vous utilisez Azure Cloud Shell, la version la plus récente est déjà installée.
L’identité que vous utilisez pour créer votre cluster doit disposer des autorisations minimales appropriées. Pour plus d’informations sur l’accès et l’identité pour AKS, consultez Options d’accès et d’identité pour Kubernetes Azure Service (AKS).
Si vous avez plusieurs abonnements Azure, sélectionnez l’identifiant d’abonnement approprié dans lequel les ressources doivent être facturées avec la commande az account set.

Créer un groupe de ressources

Un groupe de ressources Azure est un groupe logique dans lequel des ressources Azure sont déployées et gérées. Lorsque vous créez un groupe de ressources, vous êtes invité à spécifier un emplacement. Cet emplacement est l'emplacement de stockage des métadonnées de votre groupe de ressources et l'endroit où vos ressources s'exécutent dans Azure si vous ne spécifiez pas une autre région lors de la création de la ressource.

L’exemple suivant crée un groupe de ressources nommé myResourceGroup à l’emplacement eastus.

Créez un groupe de ressources avec la commande az group create.

az group create --name myResourceGroup --location eastus

L’exemple de sortie suivant montre la création réussie du groupe de ressources :

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

Exporter des variables d’environnement

Pour simplifier les étapes de configuration de l’identité requise, les étapes ci-dessous définissent des variables d’environnement pour les références sur le cluster.

Créez ces variables à l’aide des commandes suivantes. Remplacez les valeurs par défaut pour RESOURCE_GROUP, LOCATION, SERVICE_ACCOUNT_NAME, SUBSCRIPTION, USER_ASSIGNED_IDENTITY_NAME et 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"

Créer un cluster AKS

Créez un cluster AKS à l’aide de la commande az aks create avec le paramètre --enable-oidc-issuer pour utiliser l’émetteur OIDC.
```
az aks create --resource-group "${RESOURCE_GROUP}" --name myAKSCluster --node-count 1 --enable-oidc-issuer --enable-workload-identity --generate-ssh-keys
```
Au bout de quelques minutes, la commande se termine et retourne des informations au format JSON sur le cluster.
Obtenez l’URL de l’émetteur OIDC et enregistrez-le dans une variable d’environnement en exécutant la commande suivante. Remplacez la valeur par défaut des arguments -n, qui est le nom du cluster.
```
export AKS_OIDC_ISSUER="$(az aks show --name myAKSCluster --resource-group "${RESOURCE_GROUP}" --query "oidcIssuerProfile.issuerUrl" -o tsv)"
```
La variable doit contenir l’URL de l’émetteur, comme dans l’exemple suivant :
```
https://eastus.oic.prod-aks.azure.com/00000000-0000-0000-0000-000000000000/00000000-0000-0000-0000-000000000000/
```
L’émetteur est défini par défaut pour utiliser l’URL de base https://{region}.oic.prod-aks.azure.com, avec la valeur de {region} qui correspond à l’emplacement de déploiement du cluster AKS.

Créer une instance Azure Key Vault et un secret

Créez un Azure Key Vault dans le groupe de ressources que vous avez créé dans ce tutoriel à l’aide de la commande az keyvault create.
```
az keyvault create --resource-group "${RESOURCE_GROUP}" --location "${LOCATION}" --name "${KEYVAULT_NAME}" --enable-rbac-authorization false
```
La sortie de cette commande affiche les propriétés du coffre de clés que vous venez de créer. Notez les deux propriétés ci-dessous :
- Name : nom du coffre que vous avez fourni au paramètre --name.
- vaultUri : dans l’exemple, il s’agit de https://<your-unique-keyvault-name>.vault.azure.net/. Les applications qui utilisent votre coffre via son API REST doivent utiliser cet URI.
À ce stade, votre compte Azure est le seul autorisé à effectuer des opérations sur ce nouveau coffre.
Ajoutez un secret au coffre en utilisant la commande az keyvault secret set. Le mot de passe est la valeur que vous avez spécifiée pour la variable d’environnement KEYVAULT_SECRET_NAME et stocke la valeur Hello !.
```
az keyvault secret set --vault-name "${KEYVAULT_NAME}" --name "${KEYVAULT_SECRET_NAME}" --value 'Hello!'
```

Ajoutez l’URL Key Vault à la variable d’environnement KEYVAULT_URL à l’aide de la commande az keyvault show.

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

Créer une identité managée et accorder des autorisations pour accéder au secret

Définissez un abonnement spécifique en tant qu’abonnement actif actuel à l’aide de la commande az account set.
```
az account set --subscription "${SUBSCRIPTION}"
```

Créez une identité managée à l’aide de la commande az identity create.

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

Définissez une stratégie d’accès pour l’identité managée afin d’accéder au secret Key Vault en exécutant les commandes suivantes.

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

Créer un compte de service Kubernetes

Créez un compte de service Kubernetes et annotez-le avec l’identifiant client de l’identité managée créée à l’étape précédente à l’aide de la commande az aks get-credentials. Remplacez les valeurs par défaut pour le nom du cluster et le nom du groupe de ressources.
```
az aks get-credentials --name myAKSCluster --resource-group "${RESOURCE_GROUP}"
```

Copiez l’entrée multiligne suivante dans votre terminal et exécutez la commande pour créer le compte de service.

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

La sortie suivante ressemble à la création réussie de l’identité :

Serviceaccount/workload-identity-sa created

Établir des informations d’identification d’identité fédérée

Créez les informations d’identification d’identité fédérées entre l’identité managée, l’émetteur du compte de service et le sujet à l’aide de la commande 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}
```
Remarque

Il faut quelques secondes pour que les informations d’identification d’identité fédérée soient propagées après avoir été ajoutées initialement. Si une requête de jeton est disponible immédiatement après l’ajout des informations d’identification d’identité fédérée, cela peut entraîner un échec pendant quelques minutes, car le cache est rempli dans l’annuaire avec d’anciennes données. Pour éviter ce problème, vous pouvez ajouter un léger délai après l’ajout des informations d’identification d’identité fédérée.

Déployer la charge de travail

Déployez un pod qui référence le compte de service créé à l’étape précédente à l’aide de la commande suivante.

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

La sortie suivante ressemble à la création réussie du pod :

pod/quick-start created

Vérifiez si toutes les propriétés sont injectées correctement avec le webhook en utilisant la commande kubectl describe.
```
kubectl describe pod quick-start
```
Vérifiez que le pod peut obtenir un jeton et accéder au secret à partir du Key Vault à l’aide de la commande kubectl logs.
```
kubectl logs quick-start
```
La sortie suivante ressemble à l’accès réussi du jeton :
```
I1013 22:49:29.872708       1 main.go:30] "successfully got secret" secret="Hello!"
```

Nettoyer les ressources

Vous souhaiterez peut-être laisser ces ressources en place. Si vous n’avez plus besoin de ces ressources, utilisez les commandes suivantes pour les supprimer.

Supprimez le pod à l’aide de la commande kubectl delete pod.
```
kubectl delete pod quick-start
```

Supprimez le compte de service à l’aide de la commande kubectl delete sa.

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

Supprimez le groupe de ressources Azure et toutes ses ressources à l’aide de la commande az group delete.
```
az group delete --name "${RESOURCE_GROUP}"
```

Étapes suivantes

Dans ce tutoriel, vous avez déployé un cluster Kubernetes puis une application conteneur simple pour tester l’utilisation de Microsoft Entra Workload ID.

Ce tutoriel est destiné à des fins d’introduction. Pour obtenir des conseils sur la création de solutions complètes avec AKS pour la production, consultez Conseils pour les solutions AKS.

Share via