Créer un compte de service et configurer l’identité de charge de travail pour l’interface CLI agentique pour Azure Kubernetes Service (AKS) (préversion)

Cet article explique comment créer le compte de service requis et éventuellement configurer l’identité de charge de travail pour l’interface CLI agentique pour Azure Kubernetes Service (AKS). La création du compte de service est obligatoire pour le déploiement en mode cluster, tandis que la configuration de l’identité de charge de travail est facultative, mais recommandée pour renforcer la sécurité lors de l’accès aux ressources Azure.

Prerequisites

Conditions préalables à la création d’un compte de service :

Azure CLI version 2.76 ou ultérieure. Vérifiez votre version en utilisant la commande az version. Pour installer ou mettre à jour, consultez Installer Azure CLI.
Définissez votre abonnement Azure actif à l’aide de la az account set commande.
```
az account set --subscription "your-subscription-id-or-name"
```
Vous avez besoin d’autorisations suffisantes pour créer et gérer des comptes de service Kubernetes, des rôles et des liaisons de rôle.

Conditions préalables à la configuration des identités de charge de travail :

Identité de charge de travail activée sur votre cluster AKS.
Vous avez besoin d’autorisations suffisantes pour créer et gérer des identités managées Azure et créer des informations d’identification d’identité fédérée.

Définir des variables

Tout d’abord, configurez les variables requises pour votre environnement. Remplacez les valeurs d’espace réservé par les détails réels concernant votre cluster et vos paramètres Azure.

Variables requises pour la création du compte de service :

# Cluster information
export RESOURCE_GROUP="<YOUR_RESOURCE_GROUP>"
export CLUSTER_NAME="<YOUR_CLUSTER_NAME>"

# Service account configuration
export SERVICE_ACCOUNT_NAME="aks-mcp"
export SERVICE_ACCOUNT_NAMESPACE="<YOUR_NAMESPACE>"  # e.g., "kube-system" or custom namespace

Variables supplémentaires (uniquement si vous configurez l’identité de charge de travail) :

# Azure information for workload identity
export LOCATION="<YOUR_LOCATION>"
export SUBSCRIPTION="$(az account show --query id --output tsv)"

# Workload identity configuration
export USER_ASSIGNED_IDENTITY_NAME="aks-mcp-identity"
export FEDERATED_IDENTITY_CREDENTIAL_NAME="aks-mcp-fed-identity"

# Generate unique suffix for resource naming
export RANDOM_ID="$(openssl rand -hex 3)"

Créer un compte de service Kubernetes et attribuer des autorisations (obligatoires)

Important

Le compte de service est requis pour que l’interface CLI agentique s’authentifie auprès du cluster AKS en mode cluster.

Créer le compte de service

Créez le compte de service dans votre espace de noms cible à l’aide de la commande suivante :

kubectl create serviceaccount "${SERVICE_ACCOUNT_NAME}" --namespace "${SERVICE_ACCOUNT_NAMESPACE}"

Créer des autorisations RBAC

Créez le rôle nécessaire et le RoleBinding pour le compte de service avec accès en lecture pour la résolution des problèmes aks-mcp. Voici deux exemples basés sur vos exigences d’accès :

Accès en lecture à l’échelle du cluster (recommandé pour les administrateurs de cluster)

Utilisez ce ClusterRoleBinding pour accorder un accès en lecture seule à toutes les ressources Kubernetes, à l’exception des secrets de tous les espaces de noms. Cette option est recommandée pour les administrateurs au niveau du cluster ou les ingénieurs DevOps qui doivent examiner et résoudre les problèmes dans l’ensemble du cluster.
```
cat <<EOF | kubectl apply -f -
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: aks-mcp-view-rolebinding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: view
subjects:
- kind: ServiceAccount
  name: ${SERVICE_ACCOUNT_NAME}
  namespace: ${SERVICE_ACCOUNT_NAMESPACE}
EOF
```

Vérifiez que les ressources ont été créées avec succès à l’aide des commandes suivantes :

kubectl get serviceaccount "${SERVICE_ACCOUNT_NAME}" --namespace "${SERVICE_ACCOUNT_NAMESPACE}"
kubectl get clusterrolebinding aks-mcp-view-rolebinding

Accès en lecture limité à un namespace (pour les scénarios d’accès restreint)

Utilisez RoleBindings pour accorder un accès en lecture seule à toutes les ressources Kubernetes, à l’exception des secrets dans des espaces de noms spécifiques uniquement. Cette option convient aux équipes ou aux utilisateurs qui doivent avoir un accès limité à des espaces de noms spécifiques plutôt qu’à l’ensemble du cluster. Répétez ce RoleBinding pour chaque espace de noms qui nécessite un accès.
```
cat <<EOF | kubectl apply -f -
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: aks-mcp-view-rolebinding
  namespace: ${SERVICE_ACCOUNT_NAMESPACE}
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: view
subjects:
- kind: ServiceAccount
  name: ${SERVICE_ACCOUNT_NAME}
  namespace: ${SERVICE_ACCOUNT_NAMESPACE}
EOF
```

Vérifiez que les ressources ont été créées avec succès à l’aide des commandes suivantes :

kubectl get serviceaccount "${SERVICE_ACCOUNT_NAME}" --namespace "${SERVICE_ACCOUNT_NAMESPACE}"
kubectl get rolebinding aks-mcp-view-rolebinding --namespace "${SERVICE_ACCOUNT_NAMESPACE}"

Configurer l’identité de charge de travail pour l’accès aux ressources Azure (facultatif)

Les étapes suivantes sont facultatives , mais recommandées si vous souhaitez activer l’interface CLI agentique pour accéder en toute sécurité aux ressources Azure à l’aide de l’identité de charge de travail.

Vérifier l’état actuel de l’identité de la charge de travail

Vérifiez si l’identité de charge de travail est déjà activée sur votre cluster AKS à l’aide de la az aks show commande.

az aks show --resource-group "${RESOURCE_GROUP}" --name "${CLUSTER_NAME}" --query "securityProfile.workloadIdentity.enabled"

Si la sortie est true, l’identité de charge de travail est activée. Si null ou false, vous devez l’activer manuellement.

Activer l’identité de la charge de travail

Activez l’identité de la charge de travail sur votre cluster AKS à l’aide de la commande az aks update avec les paramètres --enable-workload-identity et --enable-oidc-issuer.

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

Obtenir l’URL de l’émetteur OIDC

Obtenez l’URL de l’émetteur OIDC à l’aide de la commande et enregistrez-la az aks show dans une variable d’environnement.

export AKS_OIDC_ISSUER="$(az aks show --name "${CLUSTER_NAME}" \
    --resource-group "${RESOURCE_GROUP}" \
    --query "oidcIssuerProfile.issuerUrl" \
    --output tsv)"

La variable d’environnement doit contenir l’URL de l’émetteur, comme décrit dans l’exemple suivant :

https://eastus.oic.prod-aks.azure.com/00000000-0000-0000-0000-000000000000/11111111-1111-1111-1111-111111111111/

Créer une identité managée attribuée par l’utilisateur

Créez une identité managée affectée par l’utilisateur pour l’accès aux ressources Azure à l’aide de la az identity create commande.

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

L’exemple de sortie suivant montre la création réussie d’une identité managée :

{
  "clientId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourcegroups/myResourceGroupxxxxxx/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myIdentityxxxxxx",
  "location": "eastus",
  "name": "myIdentityxxxxxx",
  "principalId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "resourceGroup": "myResourceGroupxxxxxx",
  "tenantId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "type": "Microsoft.ManagedIdentity/userAssignedIdentities"
}

Obtenir l’ID client d’identité managée

Obtenez l’ID client de l’identité managée à l’aide de la variable d’environnement et enregistrez-la az identity show dans une variable d’environnement.

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

Attribuer le rôle nécessaire à l’identité managée

Attribuez les rôles nécessaires à l’identité managée à l’aide de la az role assignment create commande.

L’exemple suivant attribue le rôle « Lecteur » dans l’étendue de l’abonnement, ce qui permet à l’interface CLI agentique de lire les informations des ressources Azure. Ajustez le rôle et l’étendue en fonction des besoins de votre cas d’usage.

az role assignment create --role "Reader" \
    --assignee $USER_ASSIGNED_CLIENT_ID \
    --scope /subscriptions/${SUBSCRIPTION}

Si vous utilisez Azure OpenAI avec Microsoft Entra ID (authentification sans clé), vous devez également attribuer le rôle « Utilisateur Cognitive Services » ou « Utilisateur Azure AI » sur la ressource Azure OpenAI :

# Option 1: Assign Cognitive Services User role
az role assignment create \
    --role "Cognitive Services User" \
    --assignee $USER_ASSIGNED_CLIENT_ID \
    --scope /subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.CognitiveServices/accounts/<openai-resource-name>

# Option 2: Assign Azure AI User role
az role assignment create \
    --role "Azure AI User" \
    --assignee $USER_ASSIGNED_CLIENT_ID \
    --scope /subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.CognitiveServices/accounts/<openai-resource-name>

Remplacez <subscription-id>, <resource-group>et <openai-resource-name> par vos valeurs réelles.

Annoter le compte de service avec l'identité de la charge de travail (facultatif)

Mettez à jour le compte de service pour inclure l’annotation de l’identité de charge de travail à l’aide de la commande suivante :

kubectl annotate serviceaccount "${SERVICE_ACCOUNT_NAME}" \
    --namespace "${SERVICE_ACCOUNT_NAMESPACE}" \
    azure.workload.identity/client-id="${USER_ASSIGNED_CLIENT_ID}" \
    --overwrite

Vérifiez que le compte de service a l’annotation d’identité de charge de travail correcte à l’aide de la commande suivante :
```
kubectl describe serviceaccount "${SERVICE_ACCOUNT_NAME}" --namespace "${SERVICE_ACCOUNT_NAMESPACE}"
```

Créer un certificat d'identité fédérée (facultatif)

Créez des informations d’identification d’identité fédérée entre l’identité géré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}" \
    --audience api://AzureADTokenExchange
```
Note

La propagation des informations d'identification de l'identité fédérée prend quelques secondes après leur ajout. Si une demande de jeton est effectuée immédiatement après l’ajout des informations d’identification de l’identité fédérée, la demande peut échouer jusqu’à ce que le cache soit actualisé. Pour éviter ce problème, vous pouvez ajouter un petit délai après l’ajout des informations d’identification de l’identité fédérée.
Répertoriez les informations d’identification d’identité fédérée pour confirmer leur création à l’aide de la commande az identity federated-credential list.
```
az identity federated-credential list \
    --identity-name "${USER_ASSIGNED_IDENTITY_NAME}" \
    --resource-group "${RESOURCE_GROUP}"
```

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-03-28