Blog · Sécurité · · 6 min de lecture
Donner une identité Azure à un workload EKS sans toucher au code
Un pod EKS qui lit un stockage Azure finit souvent avec un secret client dans ses variables. En faisant signer son jeton par AWS STS et en l’écrivant là où le SDK Azure l’attend, l’application s’authentifie sans secret et sans une ligne de code modifiée.
Une application tourne sur EKS et doit lire un stockage Azure. Le réflexe consiste à créer un secret client dans Entra ID et à le poser dans les variables du pod. Ce secret expire, se copie d’un environnement à l’autre et finit un jour dans un journal. Nous voulions la même chose que pour les pipelines de CI sans clé statique : une identité fédérée, des jetons courts, et aucun changement dans le code de l’application.
Le SDK Azure attend un fichier
Les SDK Azure savent s’authentifier par fédération d’identité. DefaultAzureCredential, ou directement WorkloadIdentityCredential, lit quatre variables d’environnement :
| Variable | Rôle |
|---|---|
AZURE_CLIENT_ID | L’application Entra ID à utiliser |
AZURE_TENANT_ID | Le tenant |
AZURE_AUTHORITY_HOST | Le point d’authentification Entra ID |
AZURE_FEDERATED_TOKEN_FILE | Le chemin d’un fichier qui contient un JWT |
Le SDK présente ce JWT à Entra ID comme assertion et reçoit un jeton Azure en échange. C’est là le point dur : l’interface est un fichier. Aucune variable ne permet de dire « va chercher ton assertion ailleurs ». Quelqu’un doit écrire ce fichier : soit l’application, avec du code, soit la plateforme. Nous voulions que ce soit la plateforme.
Deux façons de signer ce JWT
La voie standard sur Kubernetes est le webhook Azure Workload Identity de Microsoft. Il projette dans le pod un jeton de ServiceAccount signé par l’émetteur OIDC du cluster, et Entra ID fait confiance à cet émetteur. Sur EKS, ça fonctionne, avec deux limites qui apparaissent vite dès qu’il y a plusieurs namespaces.
Le sujet du jeton vaut system:serviceaccount:<namespace>:<serviceaccount>. Il faut donc un credential fédéré par couple namespace et ServiceAccount, et Entra ID en accepte au plus 20 par application. Les credentials « flexibles », avec un motif générique sur le sujet, sont réservés aux jetons émis par GitHub, GitLab et Terraform Cloud : l’émetteur OIDC d’un cluster EKS n’y a pas droit. Au-delà de 20 sujets, il ne reste qu’à découper en plusieurs applications.
L’autre voie est plus récente, côté AWS : l’outbound identity federation. Une fois activée sur le compte, STS signe lui-même un JWT qui représente l’identité IAM appelante. Le pod a déjà cette identité, grâce à EKS Pod Identity. Le sujet devient l’ARN du rôle IAM : un seul credential fédéré par rôle, quel que soit le nombre de namespaces.
OIDC du cluster
Sujet : system:serviceaccount:<ns>:<sa>
Un credential fédéré par namespace et ServiceAccount
Limite de 20 vite atteinte, pas de motif générique pour EKS
Kubernetes parle directement à Entra ID
JWT signé par AWS STS
Sujet : l’ARN du rôle IAM
Un credential fédéré par rôle
Indépendant du nombre de namespaces
Kubernetes ne connaît qu’AWS, AWS parle au reste
La mécanique côté AWS et Entra ID
- Activer la fédération sortante au niveau du compte, avec la ressource Terraform
aws_iam_outbound_web_identity_federationplutôt qu’en CLI. AWS publie alors une URL d’émetteur propre au compte, avec sa découverte OIDC et ses clés publiques. - Autoriser le rôle du pod à appeler
sts:GetWebIdentityToken, en restreignant l’audience avec la conditionsts:IdentityTokenAudience. - Déclarer dans Entra ID, sur l’application, un credential fédéré « autre émetteur » : l’URL d’émetteur du compte, sans
/final, l’ARN du rôle comme sujet, etapi://AzureADTokenExchangecomme audience.
Chaîner avec le webhook de Microsoft
Si le webhook Azure Workload Identity est déjà installé sur le cluster, les deux mécanismes se combinent. Un détail de son code le permet : il n’écrase jamais une variable d’environnement déjà déclarée sur un conteneur. Le pod déclare lui-même AZURE_FEDERATED_TOKEN_FILE vers son propre chemin, et le webhook ne fournit plus que les trois autres variables. L’assertion présentée à Entra ID est alors celle que nous avons écrite.
Reste à écrire ce fichier. Un jeton STS vit au plus une heure. Pour un Job court, un initContainer suffit. Pour un pod durable, il faut un sidecar qui le renouvelle. Les sidecars natifs de Kubernetes, un initContainer avec restartPolicy: Always, s’y prêtent bien :
spec:
volumes:
- name: azure-token
emptyDir:
medium: Memory
initContainers:
- name: azure-token
image: amazon/aws-cli
restartPolicy: Always
command: ["/bin/sh", "-c"]
args:
- |
while true; do
aws sts get-web-identity-token \
--audience api://AzureADTokenExchange \
--signing-algorithm RS256 \
--duration-seconds 3600 \
--query WebIdentityToken --output text > /var/run/azure/token.tmp \
&& mv /var/run/azure/token.tmp /var/run/azure/token
sleep 1800
done
volumeMounts:
- name: azure-token
mountPath: /var/run/azure
containers:
- name: app
env:
- name: AZURE_FEDERATED_TOKEN_FILE
value: /var/run/azure/token
volumeMounts:
- name: azure-token
mountPath: /var/run/azure
readOnly: true
L’application garde son DefaultAzureCredential tel quel. Deux précautions : une startupProbe sur le sidecar qui attend la présence du fichier, pour que l’application ne démarre pas avant le premier jeton, et une version récente de l’AWS CLI, qui connaisse cette commande.
Pousser le montage à l’admission
Ce sidecar relève de la plateforme, pas du chart applicatif, au même titre que l’agent Pod Identity. Il peut donc être injecté à l’admission, comme le fait déjà le webhook de Microsoft. Sur un cluster qui utilise Kyverno, une ClusterPolicy en mode mutate suffit : déclenchée par une annotation sur la ServiceAccount, et seulement par elle, elle ajoute le volume en mémoire, le sidecar et les variables dans les conteneurs applicatifs. L’équipe applicative annote sa ServiceAccount et obtient l’accès AWS et Azure sans rien ajouter à son chart.
Nous avons étudié ce montage sans le généraliser. Il ajoute une policy à maintenir et un conteneur sur chaque pod concerné. Il ne se justifie qu’à partir de plusieurs workloads. Pour un seul, le webhook standard, ou un appel STS en début de programme, fait le même travail sans rien ajouter au cluster.
Les pièges à connaître
- Un sujet stable. Si le rôle IAM est créé avec un préfixe de nom, son ARN porte un suffixe horodaté et ne peut pas servir de sujet. Le module communautaire
terraform-aws-modules/eks-pod-identityactive ce préfixe par défaut : passezuse_name_prefix = false, et vérifiez les rôles déjà créés. - Deux changements, pas un. L’URL d’émetteur n’est connue qu’après l’activation. Activez côté AWS, puis déclarez le credential côté Entra ID.
- Un jeton décodé avant tout. Un sujet approximatif se traduit par une erreur
AADSTS700212sans indice utile. Décodez un vrai jeton, émis depuis le pod, avant d’écrire le credential fédéré. Commencez par l’algorithmeRS256. - Un pod sans rôle. Un pod qui reçoit sa configuration AWS par External Secrets Operator n’a souvent aucune identité AWS : c’est le contrôleur qui appelle AWS. Il faut alors lui créer un rôle.
Nous mettons en place ce type de fédération dans nos missions d’infogérance Azure et d’exploitation Kubernetes. Vos workloads EKS portent encore des secrets Azure ? Parlons-en.