3 min de lecture
Azure Workload Identity sur AKS : supprimer les secrets de vos pods
Remplacement de AAD Pod Identity par Workload Identity : fédération OIDC, intégration Key Vault, et suppression complète des secrets dans les pods AKS.
Sommaire
Les secrets Kubernetes stockés dans des pods pour accéder aux ressources Azure posent un problème de sécurité structurel : ils doivent être créés, distribués, renouvelés, et leur compromission peut ouvrir l'accès à des ressources critiques. Azure Workload Identity résout ce problème en s'appuyant sur la fédération OIDC — sans aucun secret à gérer.
Le problème avec les approches classiques#
Avant Workload Identity, les équipes géraient les identités de leurs pods de deux façons.
Les secrets Kubernetes : un Service Principal Azure est créé, ses credentials sont stockés dans un Secret Kubernetes, et le pod les monte en variables d'environnement. Le problème : les secrets doivent être renouvelés avant expiration, ils sont visibles dans l'etcd, et leur fuite expose directement les ressources Azure.
AAD Pod Identity (déprécié) : une surcouche qui interceptait les requêtes IMDS depuis les pods. Fonctionnel mais complexe à opérer, sujet à des conditions de race, et désormais déprécié par Microsoft.
Comment fonctionne Workload Identity#
Workload Identity repose sur la fédération d'identité OIDC. Le cluster AKS expose un endpoint OIDC qui permet à Azure AD de vérifier que les tokens JWT émis par Kubernetes pour un Service Account sont authentiques. Azure accepte alors ces tokens directement, sans secret partagé.
Le flux :
- AKS émet un token JWT pour le Service Account du pod
- Le pod demande un token Azure AD en présentant ce JWT à Azure AD via une fédération OIDC
- Azure AD valide le JWT auprès de l'issuer OIDC d'AKS
- Si valide, Azure AD retourne un token d'accès Azure
- Le pod utilise ce token pour accéder aux ressources Azure (Key Vault, Storage, etc.)
Aucun secret n'est stocké nulle part — le trust est établi par la fédération.
Prérequis : activer OIDC Issuer et Workload Identity sur AKS#
# Activer sur un cluster existant
az aks update \
--resource-group mon-rg \
--name mon-cluster \
--enable-oidc-issuer \
--enable-workload-identity
# Récupérer l'URL de l'issuer OIDC
OIDC_ISSUER=$(az aks show \
--resource-group mon-rg \
--name mon-cluster \
--query "oidcIssuerProfile.issuerUrl" \
--output tsv)
En Terraform :
resource "azurerm_kubernetes_cluster" "main" {
# ...
oidc_issuer_enabled = true
workload_identity_enabled = true
}
Création de la chaîne de confiance#
1. Créer une Managed Identity#
az identity create \
--name mi-mon-app \
--resource-group mon-rg
2. Créer la Federated Identity Credential#
C'est le maillon central : elle lie le Service Account Kubernetes à la Managed Identity Azure.
az identity federated-credential create \
--name fic-mon-app \
--identity-name mi-mon-app \
--resource-group mon-rg \
--issuer "${OIDC_ISSUER}" \
--subject "system:serviceaccount:mon-namespace:mon-service-account" \
--audience "api://AzureADTokenExchange"
Le subject correspond exactement à system:serviceaccount:<namespace>:<nom-du-service-account>.
3. Créer le Service Account Kubernetes annoté#
apiVersion: v1
kind: ServiceAccount
metadata:
name: mon-service-account
namespace: mon-namespace
annotations:
azure.workload.identity/client-id: "<CLIENT-ID-DE-LA-MANAGED-IDENTITY>"
4. Annoter le pod ou le Deployment#
apiVersion: apps/v1
kind: Deployment
metadata:
name: mon-app
spec:
template:
metadata:
labels:
azure.workload.identity/use: "true" # Label obligatoire sur le pod
spec:
serviceAccountName: mon-service-account
containers:
- name: app
image: mon-image:latest
Le label azure.workload.identity/use: "true" déclenche la mutation du pod par le webhook Workload Identity, qui injecte les variables d'environnement et le volume de token.
Intégration avec Key Vault#
Donner accès à la Managed Identity#
az keyvault set-policy \
--name mon-keyvault \
--object-id "<OBJECT-ID-DE-LA-MANAGED-IDENTITY>" \
--secret-permissions get list
Ou via RBAC (recommandé) :
az role assignment create \
--role "Key Vault Secrets User" \
--assignee "<CLIENT-ID-DE-LA-MANAGED-IDENTITY>" \
--scope "/subscriptions/<sub>/resourceGroups/<rg>/providers/Microsoft.KeyVault/vaults/mon-keyvault"
Accéder au secret depuis le pod#
Le pod peut accéder aux secrets Key Vault via le SDK Azure, sans aucun credential configuré — l'authentification est transparente via le token injecté :
from azure.identity import WorkloadIdentityCredential
from azure.keyvault.secrets import SecretClient
credential = WorkloadIdentityCredential()
client = SecretClient(vault_url="https://mon-keyvault.vault.azure.net/", credential=credential)
secret = client.get_secret("mon-secret")
Les variables d'environnement AZURE_CLIENT_ID, AZURE_TENANT_ID, et AZURE_FEDERATED_TOKEN_FILE sont automatiquement injectées par le webhook — le SDK les utilise sans configuration supplémentaire.
Vérification#
# Vérifier que le webhook a muté le pod
kubectl describe pod mon-pod | grep -A5 "azure.workload.identity"
# Les variables d'env injectées
kubectl exec mon-pod -- env | grep AZURE_
Pourquoi c'est mieux#
| Critère | Secret K8s | AAD Pod Identity | Workload Identity |
|---|---|---|---|
| Secrets à gérer | Oui | Non | Non |
| Rotation manuelle | Oui | Non | Non |
| Complexité opérationnelle | Faible | Élevée | Faible |
| Support Microsoft | Oui | Déprécié | Recommandé |
| Auditabilité | Limitée | Correcte | Excellente |
Workload Identity est aujourd'hui l'approche recommandée par Microsoft pour tout nouveau workload AKS qui doit accéder à des ressources Azure.