

 **Aidez à améliorer cette page** 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien **Modifier cette page sur** qui se trouve dans le volet droit de chaque page.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Accorder aux charges de travail Kubernetes l’accès à AWS à l’aide des comptes de service Kubernetes
Accès des charges de travail à AWS[Gestion des comptes de service](https://kubernetes.io/docs/reference/access-authn-authz/service-accounts-admin)[Rôles IAM pour les comptes de service](iam-roles-for-service-accounts.md)[Découvrir comment l’identité du pod Amazon EKS accorde aux pods l’accès aux services AWS](pod-identities.md)

## Jetons de compte de service


La fonctionnalité [BoundServiceAccountTokenVolume](https://kubernetes.io/docs/reference/access-authn-authz/service-accounts-admin/#bound-service-account-token-volume) est activée par défaut dans les versions Kubernetes. Cette fonctionnalité améliore la sécurité des jetons de compte de service en permettant aux charges de travail exécutées sur Kubernetes de demander des jetons Web JSON liés à l'audience, à l'heure et à la clé. Les jetons de compte de service ont une expiration d'une heure. Dans les versions antérieures de Kubernetes, les jetons n’avaient pas de date d’expiration. Cela signifie que les clients qui s'appuient sur ces jetons doivent actualiser les jetons en moins d'une heure. Les [kits SDK client Kubernetes](https://kubernetes.io/docs/reference/using-api/client-libraries/) suivants actualisent automatiquement les jetons dans le délai requis :
+ Go version `0.15.7` et ultérieure
+ Python version `12.0.0` et ultérieure
+ Java version `9.0.0` et ultérieure
+ JavaScript version `0.10.3` et ultérieure
+ Branche `master` Ruby
+ Haskell version `0.3.0.0` 
+ Version C\$1 `7.0.5` et ultérieure

Si votre charge de travail utilise une version client antérieure, vous devez la mettre à jour. Afin de permettre une migration fluide des clients vers les nouveaux jetons de compte de service à durée limitée, Kubernetes ajoute une période d’expiration prolongée au jeton de compte de service, au-delà de l’heure par défaut. Pour les clusters Amazon EKS, la période d'expiration prolongée est de 90 jours. Le serveur API Kubernetes de votre cluster Amazon EKS rejette les demandes dont les jetons ont plus de 90 jours. Nous vous recommandons de vérifier vos applications et leurs dépendances pour vous assurer que les SDK des clients Kubernetes sont de versions identiques ou ultérieures aux versions répertoriées ci-dessus.

Lorsque le serveur API reçoit des requêtes avec des jetons de plus d'une heure, il annote l'événement du journal d'audit de l'API avec `annotations.authentication.k8s.io/stale-token`. La valeur de l'annotation ressemble à l'exemple suivant :

```
subject: system:serviceaccount:common:fluent-bit, seconds after warning threshold: 4185802.
```

Si votre cluster a une [journalisation de plan de contrôle](control-plane-logs.md) activée, les annotations se trouvent dans les journaux d'audit. Vous pouvez utiliser la requête [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html) suivante pour identifier tous les pods de votre cluster Amazon EKS qui utilisent des jetons périmés :

```
fields @timestamp
|filter @logStream like /kube-apiserver-audit/
|filter @message like /seconds after warning threshold/
|parse @message "subject: *, seconds after warning threshold:*\"" as subject, elapsedtime
```

Le `subject` fait référence au compte de service utilisé par le pod. Le `elapsedtime` indique le temps écoulé (en secondes) après la lecture du dernier jeton. Les demandes adressées au serveur d'API sont refusées lorsque le `elapsedtime` dépasse 90 jours (7 776 000 secondes). Il est recommandé de mettre à jour de manière proactive le kit SDK client Kubernetes de vos applications afin d’utiliser l’une des versions répertoriées précédemment qui actualisent automatiquement le jeton. Si le jeton de compte de service utilisé approche les 90 jours et que vous ne disposez pas de suffisamment de temps pour mettre à jour les versions de votre kit SDK client avant l’expiration du jeton, vous pouvez résilier les pods existants et en créer de nouveaux. Il en résulte une récupération du jeton de compte de service, ce qui vous donne 90 jours supplémentaires pour mettre à jour les kits SDK de votre version client.

Si le pod fait partie d’un déploiement, la suggestion pour résilier les pods tout en conservant une haute disponibilité consiste à effectuer un déploiement à l’aide de la commande suivante. Remplacez *my-deployment* par le nom de votre déploiement.

```
kubectl rollout restart deployment/my-deployment
```

## Modules complémentaires de cluster


Les modules complémentaires de cluster suivants ont été mis à jour afin d’utiliser les SDK clients Kubernetes qui récupèrent automatiquement les jetons de compte de service. Nous vous recommandons de vous assurer que les versions répertoriées, ou des versions ultérieures, sont installées sur votre cluster.
+ Plug-in CNI Amazon VPC pour Kubernetes et plug-ins d’aide aux métriques version `1.8.0` et ultérieure. Pour vérifier votre version actuelle ou la mettre à jour, consultez [Attribuer IPs à des pods avec l'Amazon VPC CNI](managing-vpc-cni.md) et [cni-metrics-helper](https://github.com/aws/amazon-vpc-cni-k8s/blob/master/cmd/cni-metrics-helper/README.md).
+ CoreDNS version `1.8.4` et ultérieure. Pour vérifier votre version actuelle ou la mettre à jour, consultez [Gérer CoreDNS pour DNS dans les clusters Amazon EKS](managing-coredns.md).
+  AWS Load Balancer Controller version `2.0.0` et ultérieure. Pour vérifier votre version actuelle ou la mettre à jour, consultez [Acheminez le trafic Internet avec le AWS Load Balancer Controller](aws-load-balancer-controller.md).
+ Une version actuelle de `kube-proxy`. Pour vérifier votre version actuelle ou la mettre à jour, consultez [Gérer `kube-proxy` dans les Clusters Amazon EKS](managing-kube-proxy.md).
+  AWS pour Fluent Bit version `2.25.0` ou ultérieure. Pour mettre à jour votre version actuelle, consultez [Versions](https://github.com/aws/aws-for-fluent-bit/releases) sur GitHub.
+ Version d'image Fluentd [1.14.6-1.2](https://hub.docker.com/r/fluent/fluentd/tags?page=1&name=v1.14.6-1.2) ou version ultérieure et plug-in de filtre Fluentd pour les métadonnées de Kubernetes version [2.11.1](https://rubygems.org/gems/fluent-plugin-kubernetes_metadata_filter/versions/2.11.1) ou ultérieure.

## Octroi d’autorisations de gestion des identités et des accès AWS aux charges de travail sur les clusters Amazon Elastic Kubernetes Service


Amazon EKS propose deux méthodes pour octroyer des autorisations de gestion des identités et des accès AWS aux charges de travail qui s’exécutent dans les clusters Amazon EKS : *Rôles IAM pour les comptes de service* et *Identités du pod EKS*.

 **Rôles IAM pour les comptes de service**   
 Les *rôles IAM des comptes de service (IRSA)* configurent les applications Kubernetes s’exécutant sur AWS avec des autorisations IAM détaillées pour accéder à diverses autres ressources AWS, telles que les compartiments Amazon S3, les tables Amazon DynamoDB, etc. Vous pouvez exécuter plusieurs applications ensemble dans le même cluster Amazon EKS, et vous assurer que chaque application ne dispose que de l’ensemble minimum d’autorisations dont elle a besoin. IRSA a été créé pour prendre en charge diverses options de déploiement Kubernetes prises en charge par AWS, telles qu’Amazon EKS, Amazon EKS Anywhere, Red Hat OpenShift Service sur AWS et les clusters Kubernetes autogérés sur les instances Amazon EC2. Ainsi, IRSA a été créé en utilisant un service AWS fondamental comme IAM, et n’a pas pris de dépendance directe sur le service Amazon EKS et l’API EKS. Pour de plus amples informations, consultez [Rôles IAM pour les comptes de service](iam-roles-for-service-accounts.md).

 **Identités des pods EKS**   
L’identité du pod EKS offre aux administrateurs de cluster un flux simplifié pour l’authentification des applications afin d’accéder à diverses autres ressources AWS telles que les compartiments Amazon S3, les tables Amazon DynamoDB, etc. L’identité du pod EKS est réservée uniquement à EKS et, par conséquent, elle simplifie la manière dont les administrateurs de cluster peuvent configurer les applications Kubernetes pour obtenir des autorisations IAM. Ces autorisations peuvent désormais être facilement configurées en quelques étapes directement via AWS Management Console, l’API EKS et l’interface AWS CLI, et aucune action n’est requise à l’intérieur du cluster dans les objets Kubernetes. Les administrateurs de clusters n’ont pas besoin de basculer entre les services EKS et IAM, ni d’utiliser des opérations IAM privilégiées pour configurer les autorisations requises par vos applications. Les rôles IAM peuvent désormais être utilisés dans plusieurs clusters sans qu’il soit nécessaire de mettre à jour la politique d’approbation des rôles lors de la création de nouveaux clusters. Les informations d’identification IAM fournies par l’identité du pod EKS comprennent des balises de session de rôle, avec des attributs tels que le nom du cluster, l’espace de noms, le nom du compte de service. Les balises de session de rôle permettent aux administrateurs de créer un rôle unique qui peut fonctionner sur plusieurs comptes de service en autorisant l’accès aux ressources AWS sur la base des balises correspondantes. Pour de plus amples informations, consultez [Découvrir comment l’identité du pod Amazon EKS accorde aux pods l’accès aux services AWS](pod-identities.md).

### Comparaison de l’identité du pod EKS et de l’IRSA


À un niveau élevé, l’identité du pod EKS et l’IRSA vous permettent tous deux d’accorder des autorisations IAM aux applications exécutées sur des clusters Kubernetes. Mais ils sont fondamentalement différents dans la façon dont vous les configurez, les limites prises en charge et les fonctionnalités activées. Ci-dessous, nous comparons certains des aspects clés des deux solutions.

**Note**  
 AWS recommande d’utiliser les identités du pod EKS pour accorder l’accès aux ressources AWS à vos pods dans la mesure du possible. Pour de plus amples informations, consultez [Découvrir comment l’identité du pod Amazon EKS accorde aux pods l’accès aux services AWS](pod-identities.md).


| Attribut | Identité du pod EKS | IRSA | 
| --- | --- | --- | 
|  Extensibilité des rôles  |  Vous devez configurer chaque rôle une fois pour établir la confiance avec le nouveau principal de service Amazon EKS `pods.eks.amazonaws.com`. Après cette étape unique, vous n’avez pas besoin de mettre à jour la politique d’approbation du rôle à chaque fois qu’il est utilisé dans un nouveau cluster.  |  Vous devez mettre à jour la politique d’approbation du rôle IAM avec le nouveau point de terminaison du fournisseur OIDC du cluster EKS chaque fois que vous voulez utiliser le rôle dans un nouveau cluster.  | 
|  Capacité de mise à l’échelle des clusters  |  L’identité du pod EKS n’exige pas des utilisateurs qu’ils configurent le fournisseur IAM OIDC, cette limite ne s’applique donc pas.  |  Chaque cluster EKS est associé à une URL d’émetteur OpenID Connect (OIDC). Pour utiliser IRSA, un fournisseur OpenID Connect unique doit être créé pour chaque cluster EKS dans IAM. IAM a une limite globale par défaut de 100 fournisseurs OIDC pour chaque compte AWS. Si vous prévoyez d’avoir plus de 100 clusters EKS pour chaque compte AWS avec IRSA, vous atteindrez la limite du fournisseur IAM OIDC.  | 
|  Capacité de mise à l’échelle des rôles  |  L’identité du pod EKS n’exige pas des utilisateurs qu’ils définissent une relation d’approbation entre le rôle IAM et le compte de service dans la politique d’approbation, cette limite ne s’applique donc pas.  |  Dans IRSA, vous définissez la relation d’approbation entre un rôle IAM et un compte de service dans la politique d’approbation du rôle. Par défaut, la longueur de la politique d’approbation est `2048`. Cela signifie que vous pouvez généralement définir 4 relations d’approbation dans une seule politique d’approbation. Bien qu’il soit possible d’augmenter la limite de longueur de la politique d’approbation, vous êtes généralement limité à un maximum de 8 relations d’approbation au sein d’une même politique d’approbation.  | 
|  Utilisation du quota d’API STS  |  L’identité du pod EKS simplifie la fourniture d’informations d’identification AWS à vos pods et ne nécessite pas que votre code effectue des appels directement avec le service de jetons de sécurité AWS (STS). Le service EKS gère l’assomption de rôle et fournit des informations d’identification aux applications écrites à l’aide du kit SDK AWS dans vos pods sans que ceux-ci communiquent avec AWS STS ou utilisent le quota d’API STS.  |  Dans IRSA, les applications écrites à l’aide du kit SDK AWS dans vos pods utilisent des jetons pour appeler l’API `AssumeRoleWithWebIdentity` sur le service de jetons de sécurité AWS (STS). En fonction de la logique de votre code sur le kit SDK AWS, il est possible que votre code effectue des appels inutiles vers AWS STS et reçoive des erreurs de limitation.  | 
|  Réutilisation des rôles  |   Les informations d’identification temporaires AWS STS fournies par l’identité du pod Amazon EKS comprennent des balises de session de rôle, telles que le nom du cluster, l’espace de noms et le nom du compte de service. Les balises de session de rôle permettent aux administrateurs de créer un rôle IAM unique qui peut être utilisé avec plusieurs comptes de service, avec différentes autorisations effectives, en autorisant l’accès aux ressources AWS en fonction des balises qui leur sont attachées. C’est ce qu’on appelle le contrôle d’accès par attributs (ABAC). Pour de plus amples informations, consultez [Accordez aux Pods l'accès aux AWS ressources en fonction des balises](pod-id-abac.md).  |   Les balises de session AWS STS ne sont pas prises en charge. Vous pouvez réutiliser un rôle entre les clusters, mais chaque pod reçoit toutes les autorisations du rôle.  | 
|  Environnements pris en charge  |  L’identité du pod EKS est uniquement disponible sur Amazon EKS.  |  IRSA peut être utilisé avec Amazon EKS, Amazon EKS Anywhere, Red Hat OpenShift Service sur AWS et les clusters Kubernetes autogérés sur les instances Amazon EC2.  | 
|  Versions EKS prises en charge  |  Toutes les versions de clusters EKS prises en charge. Pour les versions de plateforme spécifiques, consultez [Versions du cluster de l’identité du pod EKS](pod-identities.md#pod-id-cluster-versions).  |  Toutes les versions de clusters EKS prises en charge.  | 

# Rôles IAM pour les comptes de service
Informations d’identification auprès de l’IRSA

**Astuce**  
 [Inscrivez-vous](https://aws-experience.com/emea/smb/events/series/get-hands-on-with-amazon-eks?trk=4a9b4147-2490-4c63-bc9f-f8a84b122c8c&sc_channel=el) aux prochains ateliers Amazon EKS.

Les applications situées dans les conteneurs d'un pod peuvent utiliser un AWS SDK ou la AWS CLI pour envoyer des demandes d'API aux AWS services à l'aide des AWS autorisations Identity and Access Management (IAM). Les applications doivent signer leurs demandes AWS d'API avec des AWS informations d'identification. **Les rôles IAM pour les comptes de service (IRSA)** permettent de gérer les informations d'identification de vos applications, de la même manière que les profils d' EC2 instance Amazon fournissent des informations d'identification aux instances Amazon EC2 . Au lieu de créer et de distribuer vos AWS informations d'identification aux conteneurs ou d'utiliser le rôle de l' EC2 instance Amazon, vous associez un rôle IAM à un compte de service Kubernetes et configurez vos Pods pour utiliser le compte de service. Vous ne pouvez pas utiliser de rôles IAM pour des comptes de service dotés de [clusters locaux pour Amazon EKS on AWS Outposts](eks-outposts-local-cluster-overview.md).

Les rôles IAM pour les comptes de service offrent les bénéfices suivants :
+  **Moindre privilège** : vous pouvez définir les autorisations IAM sur un compte de service et seuls les pods qui utilisent ce compte de service ont accès à ces autorisations. Cette fonctionnalité élimine également le besoin de solutions tierces telles que `kiam` ou `kube2iam`.
+  **Isolation des informations d'identification** : lorsque l'accès à l'[Amazon EC2 Instance Metadata Service (IMDS)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html) est restreint, les conteneurs d'un pod peuvent uniquement récupérer les informations d'identification pour le rôle IAM associé au compte de service utilisé par le conteneur. Un conteneur n’a jamais accès aux informations d’identification qui sont utilisées par d’autres conteneurs dans d’autres pods. Si IMDS n’est pas restreint, les conteneurs du Pod ont également accès au [rôle IAM du nœud Amazon EKS](create-node-role.md) et les conteneurs peuvent être en mesure d’accéder aux informations d’identification des rôles IAM d’autres Pods sur le même nœud. Pour plus d'informations, consultez [Restreindre l'accès au profil d'instance affecté au composant master](https://docs.aws.amazon.com/eks/latest/best-practices/identity-and-access-management.html#_identities_and_credentials_for_eks_pods_recommendations).

**Note**  
Les pods configurés avec `hostNetwork: true` auront toujours un accès IMDS, mais la CLI AWS SDKs and utilisera les informations d'identification IRSA lorsqu'elle est activée.
+  **Auditabilité — La** journalisation des accès et des événements est disponible AWS CloudTrail pour garantir un audit rétrospectif.

**Important**  
Les conteneurs ne constituent pas une limite de sécurité, et l’utilisation de rôles IAM pour les comptes de service ne change rien à cela. Les pods attribués au même nœud partageront un noyau et éventuellement d’autres ressources en fonction de la configuration de votre pod. Bien que les pods s’exécutant sur des nœuds distincts soient isolés au niveau de la couche de calcul, certaines applications de nœuds disposent d’autorisations supplémentaires dans l’API Kubernetes qui dépassent le champ d’application d’une instance individuelle. Quelques exemples : `kubelet`, `kube-proxy`, les pilotes de stockage CSI ou vos propres applications Kubernetes.

Activez les rôles IAM pour les comptes de service en suivant les procédures suivantes :

1.  [Créez un fournisseur IAM OIDC pour votre cluster](enable-iam-roles-for-service-accounts.md) : vous ne devez effectuer cette procédure qu’une seule fois pour chaque cluster.
**Note**  
Si vous avez activé le point de terminaison d’un VPC EKS, le point de terminaison du service OIDC EKS n’était pas accessible depuis l’intérieur de ce VPC. Par conséquent, les opérations telles que la création d'un fournisseur OIDC avec `eksctl` dans le VPC n'aboutiront pas et entraîneront une expiration lors de la tentative de demande de `https://oidc.eks.region.amazonaws.com`. Voici un exemple de message d'erreur :  

   ```
   server cant find oidc.eks.region.amazonaws.com: NXDOMAIN
   ```
Pour terminer cette étape, vous pouvez exécuter la commande en dehors du VPC, par exemple dans AWS CloudShell ou sur un ordinateur connecté à Internet. Vous pouvez également créer un résolveur conditionnel à horizon divisé dans le VPC, tel que Route 53 Resolver, afin d’utiliser un résolveur différent pour l’URL de l’émetteur OIDC et de ne pas utiliser le DNS VPC pour celle-ci. Pour un exemple de transfert conditionnel dans CoreDNS, consultez la demande de fonctionnalité [Amazon EKS sur](https://github.com/aws/containers-roadmap/issues/2038). GitHub

1.  [Attribuer des rôles IAM aux comptes de service Kubernetes](associate-service-account-role.md) : suivez cette procédure pour chaque ensemble unique d’autorisations que vous souhaitez attribuer à une application.

1.  [Configurer les pods pour utiliser un compte de service Kubernetes](pod-configuration.md) : effectuez cette procédure pour chaque pod devant accéder aux services. AWS 

1.  [Utiliser IRSA avec le AWS SDK](iam-roles-for-service-accounts-minimum-sdk.md) : vérifiez que la charge de travail utilise un AWS SDK d'une version prise en charge et qu'elle utilise la chaîne d'identification par défaut.

## Informations générales sur IAM, Kubernetes et OpenID Connect (OIDC)


En 2014, AWS Identity and Access Management a ajouté la prise en charge des identités fédérées à l'aide d'OpenID Connect (OIDC). Cette fonctionnalité vous permet d'authentifier les appels d' AWS API auprès des fournisseurs d'identité pris en charge et de recevoir un jeton Web OIDC JSON (JWT) valide. Vous pouvez transmettre ce jeton à l'opération de l'`AssumeRoleWithWebIdentity`API AWS STS et recevoir des informations d'identification de rôle temporaires IAM. Vous pouvez utiliser ces informations d'identification pour interagir avec n'importe quel AWS service, y compris Amazon S3 et DynamoDB.

Chaque jeton JWT est signé par une paire de clés de signature. Les clés sont servies sur le fournisseur OIDC géré par Amazon EKS et la clé privée change tous les 7 jours. Amazon EKS conserve les clés publiques jusqu'à leur expiration. Si vous connectez des clients OIDC externes, sachez que vous devez actualiser les clés de signature avant l’expiration de la clé publique. Apprenez à [récupérer les clés de signature pour valider les jetons OIDC](irsa-fetch-keys.md).

Kubernetes utilise depuis longtemps les comptes de service comme son propre système d'identité interne. Les pods peuvent s'authentifier auprès du serveur d'API Kubernetes à l'aide d'un jeton monté automatiquement (qui était un JWT non OIDC) que seul le serveur d'API Kubernetes a pu valider. Ces jetons de compte de service hérités n’expirent pas et la rotation de la clé de signature est un processus difficile. Dans la version Kubernetes `1.12`, une nouvelle fonctionnalité `ProjectedServiceAccountToken` a été ajoutée. Cette fonctionnalité est un jeton Web JSON OIDC qui contient également l’identité du compte de service et prend en charge une audience configurable.

Amazon EKS héberge un point de terminaison de découverte OIDC public pour chaque cluster qui contient les clés de signature des jetons Web JSON `ProjectedServiceAccountToken` afin que les systèmes externes, tels que IAM, puissent valider et accepter les jetons OIDC émis par Kubernetes.

# Créer un fournisseur d'identité OIDC IAM pour votre cluster
Fournisseur IAM OIDC

Votre cluster a une URL de diffuseur [OpenID Connect](https://openid.net/connect/) (OIDC) qui lui est associée. Pour utiliser les rôles AWS Identity and Access Management (IAM) pour les comptes de service, un fournisseur IAM OIDC doit exister pour l'URL de l'émetteur OIDC de votre cluster.

## Conditions préalables

+ Un cluster Amazon EKS existant. Pour en déployer un, consultez [Mise en route avec Amazon EKS](getting-started.md).
+ Version `2.12.3` ou version ultérieure `1.27.160` ou version ultérieure de l'interface de ligne de AWS commande (AWS CLI) installée et configurée sur votre appareil ou AWS CloudShell. Pour vérifier votre version actuelle, utilisez `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Les gestionnaires de packages tels que `yum` Homebrew pour macOS ont souvent plusieurs versions de retard sur la dernière version de la AWS CLI. `apt-get` Pour installer la dernière version, consultez la section [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) et [configuration rapide avec aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) dans le *Guide de l'utilisateur de l'interface de ligne de AWS commande*. La version de la AWS CLI installée AWS CloudShell peut également avoir plusieurs versions de retard par rapport à la dernière version. Pour le mettre à jour, consultez la section [Installation de la AWS CLI dans votre répertoire](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) de base dans le *guide de AWS CloudShell l'utilisateur*.
+ L'outil de ligne de commande `kubectl` est installé sur votre appareil ou AWS CloudShell. La version peut correspondre à celle utilisée par votre cluster Kubernetes, ou différer d’au plus une version mineure, qu’elle soit antérieure ou plus récente. Par exemple, si la version de votre cluster est `1.29`, vous pouvez utiliser la version `kubectl` `1.28`, `1.29` ou `1.30`. Pour installer ou mettre à niveau `kubectl`, veuillez consulter [Configuration de `kubectl` et `eksctl`](install-kubectl.md).
+ Un fichier existant `kubectl` `config` qui contient la configuration de votre cluster. Pour créer un fichier `kubectl` `config`, consultez [Connexion de kubectl à un cluster EKS en créant un fichier kubeconfig](create-kubeconfig.md).

Vous pouvez créer un fournisseur IAM OIDC pour votre cluster en utilisant `eksctl` ou la AWS Management Console.

## Créer un fournisseur OIDC (eksctl)


1. Version `0.215.0` ou ultérieure de l'outil de ligne de commande `eksctl` installée sur votre appareil ou AWS CloudShell. Pour installer ou mettre à jour `eksctl`, veuillez consulter [Installation](https://eksctl.io/installation) dans la documentation de `eksctl`.

1. Déterminez l’identifiant de l’émetteur OIDC pour votre cluster.

   Récupérez l’ID émetteur OIDC de votre cluster et stockez-le dans une variable. Remplacez `<my-cluster>` par votre propre valeur.

   ```
   cluster_name=<my-cluster>
   oidc_id=$(aws eks describe-cluster --name $cluster_name --query "cluster.identity.oidc.issuer" --output text | cut -d '/' -f 5)
   echo $oidc_id
   ```

1. Déterminez si un fournisseur IAM OIDC avec l’ID d’émetteur de votre cluster figure déjà dans votre compte.

   ```
   aws iam list-open-id-connect-providers | grep $oidc_id | cut -d "/" -f4
   ```

   Si la sortie est renvoyée, cela signifie que vous disposez déjà d’un fournisseur IAM OIDC pour votre cluster. Vous pouvez donc ignorer l’étape suivante. Si aucune sortie n'est renvoyée, vous devez créer un fournisseur OIDC IAM pour votre cluster.

1. Créez votre fournisseur d'identité OIDC IAM pour votre cluster avec la commande suivante.

   ```
   eksctl utils associate-iam-oidc-provider --cluster $cluster_name --approve
   ```
**Note**  
Si vous avez activé le point de terminaison d’un VPC EKS, le point de terminaison du service OIDC EKS n’était pas accessible depuis l’intérieur de ce VPC. Par conséquent, vos opérations telles que la création d’un fournisseur OIDC avec `eksctl` dans le VPC ne fonctionneront pas et entraîneront un délai d’expiration. Voici un exemple de message d'erreur :  

   ```
   ** server cant find oidc.eks.<region-code>.amazonaws.com: NXDOMAIN
   ```

   Pour terminer cette étape, vous pouvez exécuter la commande en dehors du VPC, par exemple dans AWS CloudShell ou sur un ordinateur connecté à Internet. Vous pouvez également créer un résolveur conditionnel à horizon divisé dans le VPC, tel que Route 53 Resolver, afin d’utiliser un résolveur différent pour l’URL de l’émetteur OIDC et de ne pas utiliser le DNS VPC pour celle-ci. Pour un exemple de transfert conditionnel dans CoreDNS, consultez la demande de fonctionnalité [Amazon EKS sur](https://github.com/aws/containers-roadmap/issues/2038). GitHub

## Créer un fournisseur OIDC (AWS console)


1. Ouvrez la [console Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

1. Dans le volet de gauche, sélectionnez **Clusters**, puis sélectionnez le nom de votre cluster sur la page **Clusters**.

1. Dans la section **Détails** de l'onglet **Présentation**, notez la valeur de l'**URL du fournisseur d'OpenID Connect**.

1. Ouvrez la console IAM à https://console.aws.amazon.com/iam/ l'adresse.

1. Dans le panneau de navigation, sélectionnez **Identity Providers** (Fournisseurs d'identité) sous **Access management** (Gestion des accès). Si un **fournisseur** est répertorié et correspond à l'URL de votre cluster, alors vous avez déjà un fournisseur pour votre cluster. Si aucun fournisseur ne correspond à l’URL de votre cluster, vous devez en créer un.

1. Pour créer un fournisseur, cliquez sur **Ajouter un fournisseur**.

1. Pour le **type de fournisseur**, sélectionnez **OpenID Connect**.

1. Pour **l’URL du fournisseur**, saisissez l’URL du fournisseur OIDC pour votre cluster.

1. Pour **Audience**, saisissez `sts.amazonaws.com`.

1. (Facultatif) Ajoutez des balises, par exemple une balise permettant d’identifier le cluster associé à ce fournisseur.

1. Choisissez **Ajouter un fournisseur**.

Étape suivante : [Attribution de rôles IAM aux comptes de service Kubernetes](associate-service-account-role.md) 

# Attribution de rôles IAM aux comptes de service Kubernetes
Attribution d’un rôle IAM

Cette rubrique explique comment configurer un compte de service Kubernetes pour qu'il assume un rôle AWS Identity and Access Management (IAM). Tous les pods configurés pour utiliser le compte de service peuvent ensuite accéder à tout AWS service auquel le rôle est autorisé à accéder.

## Conditions préalables

+ Un cluster existant. Si vous n’en avez pas, vous pouvez en créer un en suivant l’un des guides [Mise en route avec Amazon EKS](getting-started.md).
+ Un fournisseur IAM OpenID Connect (OIDC) existant pour votre cluster. Pour déterminer si vous en avez déjà un ou comment en créer un, consultez [Créer un fournisseur d'identité OIDC IAM pour votre cluster](enable-iam-roles-for-service-accounts.md).
+ Version `2.12.3` ou version ultérieure `1.27.160` ou version ultérieure de l'interface de ligne de AWS commande (AWS CLI) installée et configurée sur votre appareil ou AWS CloudShell. Pour vérifier votre version actuelle, utilisez `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Les gestionnaires de packages tels que `yum` Homebrew pour macOS ont souvent plusieurs versions de retard sur la dernière version de la AWS CLI. `apt-get` Pour installer la dernière version, consultez la section [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) et [configuration rapide avec aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) dans le *Guide de l'utilisateur de l'interface de ligne de AWS commande*. La version de la AWS CLI installée AWS CloudShell peut également avoir plusieurs versions de retard par rapport à la dernière version. Pour le mettre à jour, consultez la section [Installation de la AWS CLI dans votre répertoire](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) de base dans le *guide de AWS CloudShell l'utilisateur*.
+ L'outil de ligne de commande `kubectl` est installé sur votre appareil ou AWS CloudShell. La version peut correspondre à celle utilisée par votre cluster Kubernetes, ou différer d’au plus une version mineure, qu’elle soit antérieure ou plus récente. Par exemple, si la version de votre cluster est `1.29`, vous pouvez utiliser la version `kubectl` `1.28`, `1.29` ou `1.30`. Pour installer ou mettre à niveau `kubectl`, veuillez consulter [Configuration de `kubectl` et `eksctl`](install-kubectl.md).
+ Un fichier existant `kubectl` `config` qui contient la configuration de votre cluster. Pour créer un fichier `kubectl` `config`, consultez [Connexion de kubectl à un cluster EKS en créant un fichier kubeconfig](create-kubeconfig.md).

## Étape 1 : créer une politique IAM


Si vous souhaitez associer une politique IAM existante à votre rôle IAM, passez à l'étape suivante.

1. Créez une politique IAM. Vous pouvez créer votre propre politique ou copier une politique AWS gérée qui accorde déjà certaines des autorisations dont vous avez besoin et la personnaliser en fonction de vos besoins spécifiques. Pour plus d’informations, consultez [Création de politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) dans le *Guide de l’utilisateur IAM*.

1. Créez un fichier qui inclut les autorisations pour les AWS services auxquels vous souhaitez que vos pods accèdent. Pour obtenir la liste de toutes les actions pour tous les AWS services, consultez la [référence d'autorisation des services](https://docs.aws.amazon.com/service-authorization/latest/reference/).

   Vous pouvez exécuter la commande suivante pour créer un exemple de fichier de politique autorisant l'accès en lecture seule à un compartiment Amazon S3. Vous pouvez, si vous le souhaitez, stocker des informations de configuration ou un script d’amorçage dans ce compartiment et les conteneurs de votre pod pourront lire le fichier dans le compartiment et le charger dans votre application. Si vous souhaitez créer cet exemple de politique, copiez le contenu suivant sur votre appareil. *my-pod-secrets-bucket*Remplacez-le par le nom de votre compartiment et exécutez la commande.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::my-pod-secrets-bucket"
           }
       ]
   }
   ```

1. Créez la politique IAM.

   ```
   aws iam create-policy --policy-name my-policy --policy-document file://my-policy.json
   ```

## Étape 2 : créer et associer un rôle IAM


Créez un rôle IAM, puis associez-le à un compte de service Kubernetes. Vous pouvez utiliser l'une ou l'autre `eksctl` option ou la AWS CLI.

### Création et association du rôle (eksctl)


Cette commande `eksctl` crée un compte de service Kubernetes dans l’espace de noms spécifié, crée un rôle IAM (s’il n’existe pas) portant le nom indiqué, attache une politique IAM existante au rôle, puis annote le compte de service avec l’ARN du rôle IAM. Veillez à remplacer les valeurs d’exemple de cette commande par vos propres valeurs. Pour installer ou mettre à jour `eksctl`, veuillez consulter [Installation](https://eksctl.io/installation) dans la documentation de `eksctl`.

```
eksctl create iamserviceaccount --name my-service-account --namespace default --cluster my-cluster --role-name my-role \
    --attach-policy-arn arn:aws: iam::111122223333:policy/my-policy --approve
```

**Important**  
Si le rôle ou le compte de service existe déjà, la commande précédente peut échouer. `eksctl` propose différentes options que vous pouvez fournir dans ces situations. Pour de plus amples informations, exécutez `eksctl create iamserviceaccount --help`.

### Créer et associer un rôle (AWS CLI)


Si vous avez déjà un compte de service Kubernetes devant assumer un rôle IAM, vous pouvez ignorer cette étape.

1. Créez un compte de service Kubernetes. Copiez les contenus suivants sur votre appareil. *my-service-account*Remplacez-le par le nom de votre choix et *default* par un autre espace de noms, si nécessaire. Si vous modifiez*default*, l'espace de noms doit déjà exister.

   ```
   cat >my-service-account.yaml <<EOF
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: my-service-account
     namespace: default
   EOF
   kubectl apply -f my-service-account.yaml
   ```

1. Définissez votre identifiant de AWS compte sur une variable d'environnement à l'aide de la commande suivante.

   ```
   account_id=$(aws sts get-caller-identity --query "Account" --output text)
   ```

1. Définissez le fournisseur d’identité OIDC de votre cluster dans une variable d’environnement à l’aide de la commande suivante. Remplacez *my-cluster* par le nom de votre cluster.

   ```
   oidc_provider=$(aws eks describe-cluster --name my-cluster --region $AWS_REGION --query "cluster.identity.oidc.issuer" --output text | sed -e "s/^https:\/\///")
   ```

1. Définissez des variables pour l'espace de noms et le nom du compte de service. *my-service-account*Remplacez-le par le compte de service Kubernetes dont vous souhaitez assumer le rôle. Remplacez *default* par l'espace de noms du compte de service.

   ```
   export namespace=default
   export service_account=my-service-account
   ```

1. Exécutez la commande suivante pour créer un fichier de stratégie d'approbation pour le rôle IAM. Si vous souhaitez autoriser tous les comptes de service d'un espace de noms à utiliser le rôle, copiez le contenu suivant sur votre appareil. Remplacez *StringEquals* par `StringLike` et remplacez *\$1service\$1account* par`*`. Vous pouvez ajouter plusieurs entrées dans les conditions `StringEquals` ou `StringLike` pour autoriser plusieurs comptes de service ou espaces de noms à endosser le rôle. Pour autoriser les rôles provenant d'un AWS compte différent de celui dans lequel se trouve votre cluster à assumer le rôle, consultez [Authentifiez-vous sur un autre compte avec IRSA](cross-account-access.md) pour plus d'informations.

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Federated": "arn:aws:iam::123456789012:oidc-provider/$oidc_provider"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
           "StringEquals": {
             "$oidc_provider:aud": "sts.amazonaws.com",
             "$oidc_provider:sub": "system:serviceaccount:$namespace:$service_account"
           }
         }
       }
     ]
   }
   ```

1. Créez le rôle. Remplacez *my-role* avec un nom pour votre rôle IAM, et *my-role-description* avec une description de votre rôle.

   ```
   aws iam create-role --role-name my-role --assume-role-policy-document file://trust-relationship.json --description "my-role-description"
   ```

1. Liez une politique IAM à votre rôle. Remplacez *my-role* par le nom de votre rôle IAM et *my-policy* par le nom d'une politique existante que vous avez créée.

   ```
   aws iam attach-role-policy --role-name my-role --policy-arn=arn:aws: iam::$account_id:policy/my-policy
   ```

1. Annotez votre compte de service avec l'Amazon Resource Name (ARN) du rôle IAM que vous souhaitez que le compte de service endosse. Remplacez *my-role* par le nom de votre rôle IAM existant. Supposons que vous ayez autorisé un rôle provenant d'un AWS compte différent de celui dans lequel se trouve votre cluster à assumer ce rôle lors d'une étape précédente. Assurez-vous ensuite de spécifier le AWS compte et le rôle de l'autre compte. Pour de plus amples informations, veuillez consulter [Authentifiez-vous sur un autre compte avec IRSA](cross-account-access.md).

   ```
   kubectl annotate serviceaccount -n $namespace $service_account eks.amazonaws.com/role-arn=arn:aws: iam::$account_id:role/my-role
   ```

1. (Facultatif) [Configurez le point de terminaison du service AWS Security Token pour un compte de service](configure-sts-endpoint.md). AWS recommande d'utiliser un point de terminaison AWS STS régional au lieu du point de terminaison global. Cela réduit la latence, fournit une redondance intégrée et augmente la validité des jetons de session.

## Étape 3 : confirmer la configuration


1. Vérifiez que la stratégie d’approbation du rôle IAM est correctement configurée.

   ```
   aws iam get-role --role-name my-role --query Role.AssumeRolePolicyDocument
   ```

   L'exemple qui suit illustre un résultat.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
               },
               "Action": "sts:AssumeRoleWithWebIdentity",
               "Condition": {
                   "StringEquals": {
                       "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:default:my-service-account",
                       "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
                   }
               }
           }
       ]
   }
   ```

1. Vérifiez que la stratégie que vous avez associée à votre rôle lors d'une étape précédente est associée au rôle.

   ```
   aws iam list-attached-role-policies --role-name my-role --query "AttachedPolicies[].PolicyArn" --output text
   ```

   L'exemple qui suit illustre un résultat.

   ```
    arn:aws: iam::111122223333:policy/my-policy
   ```

1. Définissez une variable pour stocker l'Amazon Resource Name (ARN) de la stratégie que vous souhaitez utiliser. *my-policy*Remplacez-le par le nom de la politique pour laquelle vous souhaitez confirmer les autorisations.

   ```
   export policy_arn=arn:aws: iam::111122223333:policy/my-policy
   ```

1. Affichez la version par défaut de la stratégie.

   ```
   aws iam get-policy --policy-arn $policy_arn
   ```

   L'exemple qui suit illustre un résultat.

   ```
   {
       "Policy": {
           "PolicyName": "my-policy",
           "PolicyId": "EXAMPLEBIOWGLDEXAMPLE",
           "Arn": "arn:aws: iam::111122223333:policy/my-policy",
           "Path": "/",
           "DefaultVersionId": "v1",
           [...]
       }
   }
   ```

1. Consultez le contenu de la stratégie pour vous assurer qu’elle inclut toutes les autorisations nécessaires pour votre pod. Si nécessaire, remplacez *1* la commande suivante par la version renvoyée dans la sortie précédente.

   ```
   aws iam get-policy-version --policy-arn $policy_arn --version-id v1
   ```

   L'exemple qui suit illustre un résultat.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::my-pod-secrets-bucket"
           }
       ]
   }
   ```

   Si vous avez créé l'exemple de stratégie lors d'une étape précédente, le résultat est le même. Si vous avez créé une politique différente, le *example* contenu est différent.

1. Confirmez que le compte de service Kubernetes est annoté avec le rôle.

   ```
   kubectl describe serviceaccount my-service-account -n default
   ```

   L'exemple qui suit illustre un résultat.

   ```
   Name:                my-service-account
   Namespace:           default
   Annotations:         eks.amazonaws.com/role-arn: arn:aws: iam::111122223333:role/my-role
   Image pull secrets:  <none>
   Mountable secrets:   my-service-account-token-qqjfl
   Tokens:              my-service-account-token-qqjfl
   [...]
   ```

## Étapes suivantes

+  [Configurer les pods pour utiliser un compte de service Kubernetes](pod-configuration.md) 

# Configurer les pods pour utiliser un compte de service Kubernetes
Attribuer à un pod

Si un Pod doit accéder à AWS des services, vous devez le configurer pour utiliser un compte de service Kubernetes. Le compte de service doit être associé à un rôle AWS Identity and Access Management (IAM) autorisé à accéder aux services. AWS 
+ Un cluster existant. Si vous n’en avez pas, vous pouvez en créer un à l’aide de l’un des guides disponibles dans [Mise en route avec Amazon EKS](getting-started.md).
+ Un fournisseur IAM OpenID Connect (OIDC) existant pour votre cluster. Pour déterminer si vous en avez déjà un ou comment en créer un, consultez [Créer un fournisseur d'identité OIDC IAM pour votre cluster](enable-iam-roles-for-service-accounts.md).
+ Un compte de service Kubernetes existant associé à un rôle IAM. Le compte de service doit être annoté avec l'Amazon Resource Name (ARN) du rôle IAM. Le rôle doit être associé à une politique IAM contenant les autorisations dont vous souhaitez que vos pods disposent pour utiliser les AWS services. Pour plus d'informations sur la façon de créer et de configurer le compte de service et le rôle, consultez [Attribution de rôles IAM aux comptes de service Kubernetes](associate-service-account-role.md).
+ Version `2.12.3` ou version ultérieure `1.27.160` ou version ultérieure de l'interface de ligne de AWS commande (AWS CLI) installée et configurée sur votre appareil ou AWS CloudShell. Pour vérifier votre version actuelle, utilisez `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Les gestionnaires de packages tels que `yum` Homebrew pour macOS ont souvent plusieurs versions de retard sur la dernière version de la AWS CLI. `apt-get` Pour installer la dernière version, consultez la section [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) et [configuration rapide avec aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) dans le *Guide de l'utilisateur de l'interface de ligne de AWS commande*. La version de la AWS CLI installée AWS CloudShell peut également avoir plusieurs versions de retard par rapport à la dernière version. Pour le mettre à jour, consultez la section [Installation de la AWS CLI dans votre répertoire](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) de base dans le *guide de AWS CloudShell l'utilisateur*.
+ L'outil de ligne de commande `kubectl` est installé sur votre appareil ou AWS CloudShell. La version peut correspondre à celle utilisée par votre cluster Kubernetes, ou différer d’au plus une version mineure, qu’elle soit antérieure ou plus récente. Par exemple, si la version de votre cluster est `1.29`, vous pouvez utiliser la version `kubectl` `1.28`, `1.29` ou `1.30`. Pour installer ou mettre à niveau `kubectl`, veuillez consulter [Configuration de `kubectl` et `eksctl`](install-kubectl.md).
+ Un fichier existant `kubectl` `config` qui contient la configuration de votre cluster. Pour créer un fichier `kubectl` `config`, consultez [Connexion de kubectl à un cluster EKS en créant un fichier kubeconfig](create-kubeconfig.md).

  1. Utilisez la commande suivante pour créer un manifeste de déploiement que vous pouvez déployer sur un pod afin de confirmer la configuration. Remplacez les exemples de valeurs par vos propres valeurs.

     ```
     cat >my-deployment.yaml <<EOF
     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: my-app
     spec:
       selector:
         matchLabels:
           app: my-app
       template:
         metadata:
           labels:
             app: my-app
         spec:
           serviceAccountName: my-service-account
           containers:
           - name: my-app
             image: public.ecr.aws/nginx/nginx:X.XX
     EOF
     ```

  1. Appliquez le manifeste à votre cluster.

     ```
     kubectl apply -f my-deployment.yaml
     ```

  1. Vérifiez que les variables d’environnement requises existent pour votre pod.

     1. Affichez les pods qui ont été déployés avec le déploiement à l’étape précédente.

        ```
        kubectl get pods | grep my-app
        ```

        L'exemple qui suit illustre un résultat.

        ```
        my-app-6f4dfff6cb-76cv9   1/1     Running   0          3m28s
        ```

     1. Affichez l’ARN du rôle IAM utilisé par le pod.

        ```
        kubectl describe pod my-app-6f4dfff6cb-76cv9 | grep AWS_ROLE_ARN:
        ```

        L'exemple qui suit illustre un résultat.

        ```
        AWS_ROLE_ARN: arn:aws: iam::111122223333:role/my-role
        ```

        L'ARN du rôle doit correspondre à l'ARN du rôle avec lequel vous avez annoté le compte de service existant. Pour en savoir plus sur l'annotation du compte de service, consultez [Attribution de rôles IAM aux comptes de service Kubernetes](associate-service-account-role.md).

     1. Vérifiez que le pod dispose d’un fichier de jeton d’identité Web monté.

        ```
        kubectl describe pod my-app-6f4dfff6cb-76cv9 | grep AWS_WEB_IDENTITY_TOKEN_FILE:
        ```

        L'exemple qui suit illustre un résultat.

        ```
        AWS_WEB_IDENTITY_TOKEN_FILE:  /var/run/secrets/eks.amazonaws.com/serviceaccount/token
        ```

        Le `kubelet` demande et stocke le jeton au nom du pod. Par défaut, `kubelet` actualise le jeton si ce dernier est supérieur à 80 % de son temps total avant le live, ou si le jeton est âgé de plus de 24 heures. Vous pouvez modifier la durée d’expiration de tout compte autre que le compte de service par défaut à l’aide des paramètres de votre spécification de pod. Pour plus d'informations, consultez la section [Projection du volume des jetons de compte de service](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#serviceaccount-token-volume-projection) dans la documentation Kubernetes.

        Le [webhook d’identité du pod Amazon EKS](https://github.com/aws/amazon-eks-pod-identity-webhook#amazon-eks-pod-identity-webhook) sur le cluster surveille les pods qui utilisent un compte de service avec l’annotation suivante :

        ```
        eks.amazonaws.com/role-arn: arn:aws: iam::111122223333:role/my-role
        ```

        Le webhook applique les variables d’environnement précédentes à ces pods. Votre cluster n’a pas besoin d’utiliser le webhook pour configurer les variables d’environnement et les montages de fichiers de jeton. Vous pouvez configurer manuellement les pods pour qu’ils disposent de ces variables d’environnement. Les [versions prises en charge du AWS SDK](iam-roles-for-service-accounts-minimum-sdk.md) recherchent d'abord ces variables d'environnement dans le fournisseur de chaîne d'informations d'identification. Les informations d’identification du rôle sont utilisées pour les pods qui répondent à ces critères.

  1. Vérifiez que vos Pods peuvent interagir avec les AWS services à l'aide des autorisations que vous avez attribuées dans la politique IAM associée à votre rôle.
**Note**  
Lorsqu'un pod utilise les AWS informations d'identification d'un rôle IAM associé à un compte de service, la AWS CLI ou un autre SDKs élément des conteneurs de ce pod utilisent les informations d'identification fournies par ce rôle. Si vous ne restreignez pas l’accès aux informations d’identification fournies au [rôle IAM du nœud Amazon EKS](create-node-role.md), le pod a toujours accès à ces informations d’identification. Pour plus d'informations, consultez [Restreindre l'accès au profil d'instance affecté au composant master](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node).

     Si vos pods ne peuvent pas interagir avec les services comme prévu, suivez les étapes suivantes pour vérifier que tout est correctement configuré.

     1. Vérifiez que vos Pods utilisent une version du AWS SDK qui permet d'assumer un rôle IAM via un fichier de jeton d'identité Web OpenID Connect. Pour de plus amples informations, veuillez consulter [Utiliser IRSA avec le SDK AWS](iam-roles-for-service-accounts-minimum-sdk.md).

     1. Vérifiez que le déploiement utilise le compte de service.

        ```
        kubectl describe deployment my-app | grep "Service Account"
        ```

        L'exemple qui suit illustre un résultat.

        ```
        Service Account:  my-service-account
        ```

     1. Si vos pods ne peuvent toujours pas accéder aux services, passez en revue les [étapes](associate-service-account-role.md#irsa-confirm-role-configuration) décrites dans [Attribuer des rôles IAM aux comptes de service Kubernetes](associate-service-account-role.md) pour vérifier que votre rôle et votre compte de service sont correctement configurés.

# Configurer le point de terminaison du service de jetons de sécurité AWS pour un compte de service
Critères d’évaluation STS

Si vous utilisez un compte de service Kubernetes avec des [rôles IAM pour les comptes de service](iam-roles-for-service-accounts.md), vous pouvez configurer le type de point de terminaison du service de jetons de sécurité AWS utilisé par le compte de service.

 AWS recommande d’utiliser les points d’arrivée régionaux STS AWS plutôt que le point d’arrivée global. Cela réduit la latence, fournit une redondance intégrée et augmente la validité des jetons de session. Le service de jetons de sécurité AWS doit être actif dans la région AWS où le pod est exécuté. De plus, votre application doit disposer d’une redondance intégrée pour une autre région AWS en cas de défaillance du service dans la région AWS. Pour plus d’informations, consultez [Gestion d’AWS STS dans une région AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html) dans le Guide de l’utilisateur IAM.
+ Un cluster existant. Si vous n’en avez pas, vous pouvez en créer un à l’aide de l’un des guides disponibles dans [Mise en route avec Amazon EKS](getting-started.md).
+ Un fournisseur IAM OIDC existant pour votre cluster. Pour de plus amples informations, consultez [Créer un fournisseur d'identité OIDC IAM pour votre cluster](enable-iam-roles-for-service-accounts.md).
+ Un compte de service Kubernetes existant configuré pour être utilisé avec la fonction [Amazon EKS IAM pour les comptes de service](iam-roles-for-service-accounts.md).

Les exemples suivants utilisent tous le compte de service Kubernetes aws-node utilisé par le plug-in [Amazon VPC CNI](cni-iam-role.md). Vous pouvez remplacer les *valeurs d’exemple* par vos propres comptes de service, pods, espaces de noms et autres ressources.

1. Sélectionnez un pod qui utilise un compte de service dont vous souhaitez modifier le point de terminaison. Déterminez dans quelle région AWS le Pod fonctionne. Remplacez *aws-node-6mfgv* par le nom de votre pod et *kube-system* par l’espace de noms de votre pod.

   ```
   kubectl describe pod aws-node-6mfgv -n kube-system |grep Node:
   ```

   L'exemple qui suit illustre un résultat.

   ```
   ip-192-168-79-166.us-west-2/192.168.79.166
   ```

   Dans la sortie précédente, le Pod s’exécute sur un nœud dans la région AWS us-west-2.

1. Déterminez le type de point de terminaison utilisé par le compte de service du pod.

   ```
   kubectl describe pod aws-node-6mfgv -n kube-system |grep AWS_STS_REGIONAL_ENDPOINTS
   ```

   L'exemple qui suit illustre un résultat.

   ```
   AWS_STS_REGIONAL_ENDPOINTS: regional
   ```

   Si le point de terminaison actuel est international, alors `global` est renvoyé en sortie. Si aucune sortie n'est renvoyée, le type de point de terminaison par défaut est en cours d'utilisation et n'a pas été remplacé.

1. Si la version de votre cluster ou celle de votre plateforme est identique ou ultérieure à celles répertoriées dans le tableau, vous pouvez modifier le type de point de terminaison utilisé par votre compte de service pour le faire passer du type par défaut à un type différent à l'aide de l'une des commandes suivantes. Remplacez *aws-node* par le nom de votre compte de service et *kube-system* par l'espace de noms de votre compte de service.
   + Si votre type de point de terminaison par défaut ou actuel est international et que vous souhaitez le remplacer par régional :

     ```
     kubectl annotate serviceaccount -n kube-system aws-node eks.amazonaws.com/sts-regional-endpoints=true
     ```

     Si vous utilisez des [rôles IAM pour les comptes de service](iam-roles-for-service-accounts.md) afin de générer des URL S3 pré-signées dans votre application exécutée dans les conteneurs Pods, le format de l’URL pour les points de terminaison régionaux est similaire à l’exemple suivant :

     ```
     https://bucket.s3.us-west-2.amazonaws.com/path?...&X-Amz-Credential=your-access-key-id/date/us-west-2/s3/aws4_request&...
     ```
   + Si votre type de point de terminaison par défaut ou actuel est régional et que vous souhaitez le remplacer par international :

     ```
     kubectl annotate serviceaccount -n kube-system aws-node eks.amazonaws.com/sts-regional-endpoints=false
     ```

     Si votre application envoie explicitement des requêtes aux points de terminaison globaux STS AWS et que vous ne remplacez pas le comportement par défaut consistant à utiliser les points de terminaison régionaux dans les clusters Amazon EKS, les requêtes échoueront et généreront une erreur. Pour de plus amples informations, consultez [Les conteneurs Pod reçoivent l'erreur suivante : `An error occurred (SignatureDoesNotMatch) when calling the GetCallerIdentity operation: Credential should be scoped to a valid region`](security-iam-troubleshoot.md#security-iam-troubleshoot-wrong-sts-endpoint).

     Si vous utilisez des [rôles IAM pour les comptes de service](iam-roles-for-service-accounts.md) afin de générer des URL S3 pré-signées dans votre application exécutée dans les conteneurs Pods, le format de l’URL pour les points de terminaison globaux est similaire à l’exemple suivant :

     ```
     https://bucket.s3.amazonaws.com/path?...&X-Amz-Credential=your-access-key-id/date/us-west-2/s3/aws4_request&...
     ```

   Si votre automatisation nécessite une URL pré-signée dans un certain format ou si votre application ou les dépendances en aval qui utilisent des URL pré-signées ont des attentes concernant la région AWS ciblée, effectuez les modifications nécessaires pour utiliser le point de terminaison STS AWS approprié.

1. Supprimez et recréez tous les pods existants associés au compte de service pour appliquer les variables d’environnement des informations d’identification. Le hook web en mutation ne les applique pas aux qui sont déjà en cours d’exécution. Vous pouvez remplacer *pods*, *kube-system* et *-l k8s-app=aws-node* par les informations relatives aux pods pour lesquels vous avez défini votre annotation.

   ```
   kubectl delete Pods -n kube-system -l k8s-app=aws-node
   ```

1. Vérifiez que les pods ont tous redémarré.

   ```
   kubectl get Pods -n kube-system -l k8s-app=aws-node
   ```

1. Affichez les variables d’environnement pour l’un des pods. Vérifiez que la valeur `AWS_STS_REGIONAL_ENDPOINTS` est celle que vous avez définie à une étape précédente.

   ```
   kubectl describe pod aws-node-kzbtr -n kube-system |grep AWS_STS_REGIONAL_ENDPOINTS
   ```

   L'exemple qui suit illustre un résultat.

   ```
   AWS_STS_REGIONAL_ENDPOINTS=regional
   ```

# Authentifiez-vous sur un autre compte avec IRSA
IAM inter-comptes

Vous pouvez configurer les autorisations IAM entre comptes en créant un fournisseur d’identité à partir du cluster d’un autre compte ou en utilisant les opérations `AssumeRole` chaînées. Dans les exemples suivants, le *compte A* possède un cluster Amazon EKS qui prend en charge les rôles IAM pour les comptes de service. Les pods qui s’exécutent sur ce cluster doivent assumer les autorisations IAM du *compte B*.
+  **L'option 1** est plus simple mais nécessite que le compte B crée et gère un fournisseur d'identité OIDC pour le cluster du compte A.
+  **L'option 2** conserve la gestion de l'OIDC dans le compte A mais nécessite un chaînage des rôles via deux `AssumeRole` appels.

## Option 1 : créer un fournisseur d'identité à partir du cluster d'un autre compte


Dans cet exemple, le Compte A fournit au Compte B l'URL de l'émetteur OpenID Connect (OIDC) à partir de son cluster. Le compte B suit les instructions de la section [Créer un fournisseur IAM OIDC pour votre cluster](enable-iam-roles-for-service-accounts.md) et [Attribution de rôles IAM aux comptes de service Kubernetes](associate-service-account-role.md) utilise l’URL d’émetteur OIDC du cluster du compte A. Ensuite, un administrateur de cluster annote le compte de service dans le cluster du compte A pour utiliser le rôle du compte B (*444455556666*).

```
apiVersion: v1
kind: ServiceAccount
metadata:
  annotations:
    eks.amazonaws.com/role-arn: arn:aws: iam::444455556666:role/account-b-role
```

## Option 2 : utiliser des opérations chaînées `AssumeRole`


Dans cette approche, chaque compte crée un rôle IAM. Le rôle du compte B fait confiance au compte A, et le rôle du compte A utilise la fédération OIDC pour obtenir les informations d'identification du cluster. Le Pod enchaîne ensuite les deux rôles à l'aide de profils AWS CLI.

### Étape 1 : créer le rôle cible dans le compte B


Le compte B (*444455556666*) crée un rôle IAM avec les autorisations dont ont besoin les pods du cluster du compte A. Le compte B associe la politique d'autorisation souhaitée à ce rôle, puis ajoute la politique de confiance suivante.

 **Politique de confiance pour le rôle du compte B** — Cette politique permet au rôle IRSA spécifique du compte A d'assumer ce rôle.

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::111122223333:root"
      },
      "Action": "sts:AssumeRole",
      "Condition": {}
    }
  ]
}
```

**Important**  
Pour obtenir le moindre privilège, remplacez l'`Principal`ARN par l'ARN du rôle spécifique du compte A au lieu d'utiliser le compte root (`arn:aws:iam::111122223333:root`). L'utilisation de la racine du compte permet *à n'importe quel* principal IAM du compte A d'assumer ce rôle.

### Étape 2 : créer le rôle IRSA dans le compte A


Le compte A (*111122223333*) crée un rôle doté d'une politique de confiance qui obtient les informations d'identification du fournisseur d'identité créé avec l'adresse de l'émetteur OIDC du cluster.

 **Politique de confiance pour le rôle du compte A (fédération OIDC)** — Cette politique permet au fournisseur OIDC du cluster EKS de délivrer des informations d'identification pour ce rôle.

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
        }
      }
    }
  ]
}
```

**Important**  
Pour bénéficier du moindre privilège, ajoutez une `StringEquals` condition à la `sub` revendication visant à restreindre ce rôle à un compte de service Kubernetes spécifique. Sans `sub` condition, n'importe quel compte de service du cluster peut assumer ce rôle. La `sub` valeur utilise le format`system:serviceaccount:NAMESPACE:SERVICE_ACCOUNT_NAME `. Par exemple, pour vous limiter à un compte de service nommé `my-service-account` dans l'espace de `default` noms :  

```
"oidc.eks.region-code.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:default:my-service-account"
```

### Étape 3 : associer l' AssumeRole autorisation au rôle du compte A


Le compte A associe une politique d'autorisation au rôle créé à l'étape 2. Cette politique permet au rôle d'assumer le rôle du compte B.

 **Politique d'autorisation pour le rôle du compte A** — Cette politique accorde `sts:AssumeRole` le rôle cible du compte B.

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::444455556666:role/account-b-role"
        }
    ]
}
```

### Étape 4 : configurer le Pod pour enchaîner les rôles


Le code d’application permettant aux pods d’assumer le rôle du compte B utilise deux profils : `account_b_role` et `account_a_role`. Le profil `account_b_role` utilise le profil `account_a_role` comme source. Pour la AWS CLI, le `~/.aws/config` fichier est similaire au suivant.

```
[profile account_b_role]
source_profile = account_a_role
role_arn=arn:aws: iam::444455556666:role/account-b-role

[profile account_a_role]
web_identity_token_file = /var/run/secrets/eks.amazonaws.com/serviceaccount/token
role_arn=arn:aws: iam::111122223333:role/account-a-role
```

Pour spécifier des profils chaînés pour d'autres AWS SDKs, consultez la documentation du SDK que vous utilisez. Pour plus d'informations, consultez la section [Outils sur lesquels vous pouvez vous appuyer AWS](https://aws.amazon.com/developer/tools/).

# Utiliser IRSA avec le SDK AWS
Kits SDK pris en charge

**Utilisation des informations d’identification**  
Pour utiliser les informations d’identification des rôles IAM des comptes de service (IRSA), votre code peut utiliser n’importe quel kit SDK AWS pour créer un client pour un service AWS avec un kit SDK, et par défaut, le kit SDK recherche dans une chaîne d’emplacements les informations d’identification de gestion des identités et des accès AWS à utiliser. Les informations d’identification des rôles IAM des comptes de service seront utilisées si vous ne spécifiez pas de fournisseur d’informations d’identification lors de la création du client ou de l’initialisation du kit SDK.

Cela fonctionne parce que les rôles IAM des comptes de service ont été ajoutés en tant qu’étape dans la chaîne d’informations d’identification par défaut. Si vos charges de travail utilisent actuellement des informations d’identification qui se trouvent plus haut dans la chaîne d’informations d’identification, ces informations d’identification continueront d’être utilisées même si vous configurez un rôle IAM des comptes de service pour la même charge de travail.

Le SDK échange automatiquement le jeton OIDC du compte de service contre des informations d’identification temporaires provenant du service de jetons de sécurité AWS à l’aide de l’action `AssumeRoleWithWebIdentity`. Amazon EKS et cette action du kit SDK poursuivent la rotation des informations d’identification temporaires en les renouvelant avant qu’elles n’expirent.

Lorsque vous utilisez des [rôles IAM pour les comptes de service](iam-roles-for-service-accounts.md), les conteneurs de vos pods doivent utiliser une version du SDK AWS qui prend en charge l’attribution d’un rôle IAM via un fichier de jetons d’identité Web OpenID Connect. Veillez à utiliser les versions suivantes, ou ultérieures, pour votre SDK AWS :
+ Java (version 2) – [2.10.11](https://github.com/aws/aws-sdk-java-v2/releases/tag/2.10.11) 
+ Java : [1.12.782](https://github.com/aws/aws-sdk-java/releases/tag/1.12.782) 
+  Kit SDK AWS pour Go v1 : [1.23.13](https://github.com/aws/aws-sdk-go/releases/tag/v1.23.13) 
+  Kit SDK AWS pour Go v2 : toutes les versions sont prises en charge
+ Python (Boto3) – [1.9.220](https://github.com/boto/boto3/releases/tag/1.9.220) 
+ Python (botocore) – [1.12.200](https://github.com/boto/botocore/releases/tag/1.12.200) 
+  AWS CLI : [1.16.232](https://github.com/aws/aws-cli/releases/tag/1.16.232) 
+ Node – [2.525.0](https://github.com/aws/aws-sdk-js/releases/tag/v2.525.0) et [3.27.0](https://github.com/aws/aws-sdk-js-v3/releases/tag/v3.27.0) 
+ Ruby – [3.58.0](https://github.com/aws/aws-sdk-ruby/blob/version-3/gems/aws-sdk-core/CHANGELOG.md#3580-2019-07-01) 
+ C\$1\$1 – [1.7.174](https://github.com/aws/aws-sdk-cpp/releases/tag/1.7.174) 
+ .NET – [3.3.659.1](https://github.com/aws/aws-sdk-net/releases/tag/3.3.659.1) – Vous devez également inclure `AWSSDK.SecurityToken`.
+ PHP – [3.110.7](https://github.com/aws/aws-sdk-php/releases/tag/3.110.7) 

De nombreux modules complémentaires Kubernetes populaires, tels que [Cluster Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler), [Routage du trafic Internet avec AWS Load Balancer Controller](aws-load-balancer-controller.md) et le [plug-in CNI Amazon VPC pour Kubernetes](cni-iam-role.md), prennent en charge les rôles IAM pour les comptes de service.

Pour vous assurer d’utiliser un kit SDK pris en charge, suivez les instructions d’installation relatives à votre SDK préféré de la page [Tools to Build on AWS](https://aws.amazon.com/tools/) lorsque vous créez vos conteneurs.

## Considérations


### Java


Lorsque vous utilisez Java, vous *devez* inclure le module `sts` dans le chemin de classe. Pour plus d’informations, consultez [WebIdentityTokenFileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/WebIdentityTokenFileCredentialsProvider.html) dans la documentation du SDK Java.

# Récupérer les clés de signature pour valider les jetons OIDC
Récupérez les clés de signature

Kubernetes délivre un `ProjectedServiceAccountToken` à chaque compte de service Kubernetes. Ce jeton est un jeton OIDC, qui est lui-même un type de jeton web JSON (JWT). Amazon EKS héberge un point de terminaison OIDC public pour chaque cluster qui contient les clés de signature du jeton afin que les systèmes externes puissent le valider.

Pour valider un `ProjectedServiceAccountToken`, vous devez récupérer les clés de signature publiques OIDC, également appelées JSON Web Key Set (JWKS). Utilisez ces clés dans votre application pour valider le jeton. Par exemple, vous pouvez utiliser la [bibliothèque Python PyJWT](https://pyjwt.readthedocs.io/en/latest/) pour valider les jetons à l’aide de ces clés. Pour plus d’informations sur le `ProjectedServiceAccountToken`, consultez [Informations générales sur IAM, Kubernetes et OpenID Connect (OIDC)](iam-roles-for-service-accounts.md#irsa-oidc-background).

## Prérequis

+ Un fournisseur OpenID Connect (OIDC) existant pour la gestion des identités et des accès (IAM) AWS pour votre cluster. Pour déterminer si vous en avez déjà un, ou pour en créer un, consultez [Créer un fournisseur d'identité OIDC IAM pour votre cluster](enable-iam-roles-for-service-accounts.md).
+  ** AWS CLI** : Un outil de ligne de commande pour travailler avec les services AWS, y compris Amazon EKS. Pour plus d’informations, consultez la section [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) du Guide de l’utilisateur de l’interface de la ligne de commande AWS. Après avoir installé CLI AWS, nous vous recommandons de le configurer également. Pour plus d’informations, consultez la section [Configuration rapide avec aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) du Guide de l’utilisateur de l’interface de la ligne de commande AWS.

## Procédure


1. Récupérez l’URL OIDC de votre cluster Amazon EKS à l’aide de la CLI AWS.

   ```
   $ aws eks describe-cluster --name my-cluster --query 'cluster.identity.oidc.issuer'
   "https://oidc.eks.us-west-2.amazonaws.com/id/8EBDXXXX00BAE"
   ```

1. Récupérez la clé de signature publique à l’aide de curl ou d’un outil similaire. Le résultat est un [ensemble de clés web JSON (JWKS](https://www.rfc-editor.org/rfc/rfc7517#section-5)).
**Important**  
Amazon EKS limite les appels vers le point de terminaison OIDC. Vous devez mettre en cache la clé de signature publique. Respectez l’en-tête `cache-control` inclus dans la réponse.
**Important**  
Amazon EKS fait pivoter la clé de signature OIDC tous les sept jours.

   ```
   $ curl https://oidc.eks.us-west-2.amazonaws.com/id/8EBDXXXX00BAE/keys
   {"keys":[{"kty":"RSA","kid":"2284XXXX4a40","use":"sig","alg":"RS256","n":"wklbXXXXMVfQ","e":"AQAB"}]}
   ```

# Découvrir comment l’identité du pod Amazon EKS accorde aux pods l’accès aux services AWS
Pod Identity

Les applications dans les conteneurs d’un Pod peuvent utiliser un SDK AWS ou l’interface CLI AWS pour envoyer des requêtes API aux services AWS à l’aide des autorisations de la gestion des identités et des accès AWS (IAM). Les applications doivent signer leurs demandes d’API AWS avec les informations d’identification AWS.

 Les *identités du pod EKS* permettent de gérer les informations d’identification de vos applications, de la même manière que les profils d’instance Amazon EC2 fournissent des informations d’identification aux instances Amazon EC2. Au lieu de créer et distribuer vos informations d’identification AWS aux conteneurs ou d’utiliser le rôle de l’instance Amazon EC2, vous associez un rôle IAM à un compte de service Kubernetes et vous configurez vos pods pour qu’ils utilisent le compte de service.

[![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/aUjJSorBE70?rel=0/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/aUjJSorBE70?rel=0)


Chaque identité du pod EKS mappe un rôle à un compte de service dans un espace de noms dans le cluster spécifié. Si vous avez la même application dans plusieurs clusters, vous pouvez faire des associations identiques dans chaque cluster sans modifier la politique d’approbation du rôle.

Si un pod utilise un compte de service qui a une association, Amazon EKS définit des variables d’environnement dans les conteneurs du pod. Les variables d’environnement configurent les kits SDK AWS, y compris l’AWS CLI, pour utiliser les informations d’identification d’identité du pod EKS.

## Avantages des identités du pod EKS


Les identités du pod EKS offrent les avantages suivants :
+  **Moindre privilège** : vous pouvez définir les autorisations IAM sur un compte de service et seuls les pods qui utilisent ce compte de service ont accès à ces autorisations. Cette fonctionnalité élimine également le besoin de solutions tierces telles que `kiam` ou `kube2iam`.
+  **Isolation des informations d’identification** : lorsque l’accès au [service de métadonnées d’instance (IMDS) Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html) est restreint, les conteneurs d’un pod ne peuvent récupérer que les informations d’identification du rôle IAM associé au compte de service utilisé par le conteneur. Un conteneur n’a jamais accès aux informations d’identification qui sont utilisées par d’autres conteneurs dans d’autres pods. Si IMDS n’est pas restreint, les conteneurs du Pod ont également accès au [rôle IAM du nœud Amazon EKS](create-node-role.md) et les conteneurs peuvent être en mesure d’accéder aux informations d’identification des rôles IAM d’autres Pods sur le même nœud. Pour plus d'informations, consultez [Restreindre l'accès au profil d'instance affecté au composant master](https://docs.aws.amazon.com/eks/latest/best-practices/identity-and-access-management.html#_identities_and_credentials_for_eks_pods_recommendations).

**Note**  
Les pods configurés avec `hostNetwork: true` auront toujours accès à IMDS, mais les kits SDK et l’AWS CLI utiliseront les informations d’identification du pod lorsque celles-ci seront activées.
+  **Auditabilité** : l’accès et la journalisation des événements sont disponibles via AWS CloudTrail afin de faciliter l’audit rétrospectif.

**Important**  
Les conteneurs ne constituent pas une frontière de sécurité, et l’utilisation de l’identité du pod ne change rien à cela. Les pods attribués au même nœud partageront un noyau et éventuellement d’autres ressources en fonction de la configuration de votre pod. Bien que les pods s’exécutant sur des nœuds distincts soient isolés au niveau de la couche de calcul, certaines applications de nœuds disposent d’autorisations supplémentaires dans l’API Kubernetes qui dépassent le champ d’application d’une instance individuelle. Quelques exemples : `kubelet`, `kube-proxy`, les pilotes de stockage CSI ou vos propres applications Kubernetes.

L’identité du pod EKS est une méthode plus simple que [Rôles IAM pour les comptes de service](iam-roles-for-service-accounts.md), car elle n’utilise pas de fournisseurs d’identité OIDC. L’identité du pod EKS présente les améliorations suivantes :
+  **Opérations indépendantes** : dans de nombreuses organisations, la création de fournisseurs d’identité OIDC relève de la responsabilité d’équipes différentes de celles qui administrent les clusters Kubernetes. L’identité du pod EKS présente une séparation nette des tâches, où toute la configuration des associations de l’identité du pod EKS est effectuée dans Amazon EKS et toute la configuration des autorisations IAM est effectuée dans IAM.
+  **Réutilisabilité** : l’identité du pod EKS utilise un seul principal IAM au lieu des principaux distincts pour chaque cluster que les rôles IAM des comptes de service utilisent. Votre administrateur IAM ajoute le principal suivant à la politique d’approbation de n’importe quel rôle pour le rendre utilisable par les identités du pod EKS.

  ```
              "Principal": {
                  "Service": "pods.eks.amazonaws.com"
              }
  ```
+  **Capacité de mise à l’échelle** : chaque ensemble d’informations d’identification temporaires est pris en charge par le service d’authentification EKS dans l’identité du pod EKS, au lieu de chaque kit SDK AWS que vous exécutez dans chaque pod. Ensuite, l’agent de l’identité du pod Amazon EKS qui s’exécute sur chaque nœud émet les informations d’identification aux kits SDK. La charge est ainsi réduite à une seule fois pour chaque nœud et n’est pas dupliquée dans chaque pod. Pour plus de détails sur le processus, consultez [Comprendre le fonctionnement de l’identité du pod Amazon EKS](pod-id-how-it-works.md).

Pour plus d’informations sur la comparaison des deux solutions, consultez [Accorder aux charges de travail Kubernetes l’accès à AWS à l’aide des comptes de service Kubernetes](service-accounts.md).

## Présentation de la configuration des identités du pod EKS


Activez les identités du pod EKS en effectuant les procédures suivantes :

1.  [Configurer l’agent de l’identité du pod Amazon EKS](pod-id-agent-setup.md) : vous n’effectuez cette procédure qu’une seule fois pour chaque cluster. Vous n’avez pas besoin d’effectuer cette étape si le mode automatique EKS est activé sur votre cluster.

1.  [Attribuer un rôle IAM à un compte de service Kubernetes](pod-id-association.md) : effectuez cette procédure pour chaque ensemble unique d’autorisations que vous voulez attribuer à une application.

1.  [Configurer les pods pour accéder aux AWS services avec des comptes de service](pod-id-configure-pods.md) : effectuez cette procédure pour chaque pod qui doit accéder aux services AWS.

1.  [Utiliser l’identité du pod avec le SDK AWS](pod-id-minimum-sdk.md) : vérifiez que la charge de travail utilise un kit SDK AWS d’une version prise en charge et qu’elle utilise la chaîne d’informations d’identification par défaut.

## Limites

+ Jusqu’à 5 000 associations d’identité du pod EKS par cluster sont prises en charge pour mapper les rôles IAM aux comptes de service Kubernetes.

## Considérations

+  **Association de rôles IAM** : chaque compte de service Kubernetes d’un cluster peut être associé à un rôle IAM du même compte AWS que le cluster. Pour modifier le rôle, modifiez l’association d’identité du pod EKS. Pour l’accès intercompte, déléguez l’accès au rôle à l’aide des rôles IAM. Pour en savoir plus, consultez [Déléguer l’accès entre les comptes AWS à l’aide des rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) dans le *Guide de l’utilisateur IAM*.
+  **Agent d’identité du pod EKS** : l’agent d’identité du pod est nécessaire pour utiliser l’identité du pod EKS. L’agent s’exécute en tant que `DaemonSet` Kubernetes sur les nœuds du cluster, fournissant des informations d’identification uniquement aux pods du même nœud. Il utilise le `hostNetwork` du nœud, occupant les ports `80` et `2703` sur l’adresse locale de liaison (`169.254.170.23` pour IPv4, `[fd00:ec2::23]` pour IPv6). Si IPv6 est désactivé dans votre cluster, désactivez IPv6 pour l’agent d’identité du pod EKS. Pour en savoir plus, consultez [Désactiver IPv6 dans l’agent d’identité du pod EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-agent-config-ipv6.html).
+  **Cohérence à terme** : les associations d’identité du pod EKS sont cohérentes à terme, avec des retards potentiels de plusieurs secondes après les appels d’API. Évitez de créer ou de mettre à jour des associations dans des chemins de code critiques et à haute disponibilité. Effectuez plutôt ces actions dans des routines d’initialisation ou de configuration distinctes et moins fréquentes. Pour en savoir plus, consultez [Groupes de sécurité par pod](https://docs.aws.amazon.com/eks/latest/best-practices/sgpp.html) dans le *Guide des bonnes pratiques EKS*.
+  **Considérations relatives au proxy et au groupe de sécurité** : pour les pods utilisant un proxy, ajoutez `169.254.170.23` (IPv4) et `[fd00:ec2::23]` (IPv6) aux variables d’environnement `no_proxy/NO_PROXY` afin d’éviter les échecs de demandes vers l’agent d’identité du pod EKS. Si vous utilisez des groupes de sécurité pour les pods avec le CNI VPC AWS, définissez l’indicateur `ENABLE_POD_ENI` sur « true » et l’indicateur `POD_SECURITY_GROUP_ENFORCING_MODE` sur « standard ». Pour en savoir plus, consultez [Attribuer des groupes de sécurité à des pods individuels](https://docs.aws.amazon.com/eks/latest/userguide/security-groups-for-pods.html).

### Versions du cluster de l’identité du pod EKS


Pour utiliser l’identité du pod EKS, le cluster doit disposer d’une version de plateforme identique ou supérieure à celle indiquée dans le tableau suivant, ou d’une version Kubernetes supérieure à celles indiquées dans le tableau. Pour connaître la version recommandée de l’Agent de l’identité du pod Amazon EKS pour une version Kubernetes, consultez [Vérification de la compatibilité de la version du module complémentaire Amazon EKS avec un cluster](addon-compat.md).


| Version de Kubernetes | Version de la plateforme | 
| --- | --- | 
|  Versions Kubernetes non répertoriées  |  Toutes les versions de plateforme prennent en charge  | 
|   `1.28`   |   `eks.4`   | 

### Restrictions relatives à l’identité du pod EKS


Les identités du pod EKS sont disponibles sur les éléments suivants :
+ Les versions du cluster Amazon EKS répertoriées dans la rubrique précédente [Versions du cluster de l’identité du pod EKS](#pod-id-cluster-versions).
+ Les composants master du cluster qui sont des instances Amazon EC2 Linux.

Les identités du pod Amazon EKS ne sont pas disponibles dans les cas suivants :
+  AWS Outposts.
+ Amazon EKS Anywhere.
+ Clusters Kubernetes que vous créez et exécutez sur Amazon EC2. Les composants de l’identité du pod Amazon EKS sont uniquement disponibles sur Amazon EKS.

Vous ne pouvez pas utiliser les identités du pod Amazon EKS avec :
+ Les pods qui s’exécutent n’importe où, à l’exception des instances Amazon EC2 Linux. Les pods Linux et Windows qui s’exécutent sur AWS Fargate (Fargate) ne sont pas pris en charge. Les pods qui s’exécutent sur des instances Amazon EC2 Windows ne sont pas pris en charge.

# Comprendre le fonctionnement de l’identité du pod Amazon EKS
Fonctionnement

Les associations de l’identité du pod Amazon EKS offrent une capacité de gestion des informations d’identification à utiliser pour les applications, de la même façon que les profils d’instance Amazon EC2 fournissent des informations d’identification aux instances EC2.

L’identité du pod Amazon EKS fournit des informations d’identification à vos charges de travail avec une API d’*authentification EKS* supplémentaire et un pod d’agent qui s’exécute sur chaque nœud.

Dans vos modules complémentaires, tels que les *modules complémentaires Amazon EKS* et le contrôleur autogéré, les opérateurs et autres modules complémentaires, l’auteur doit mettre à jour son logiciel pour utiliser les derniers kits SDK AWS. Pour la liste de compatibilité entre l’identité du pod EKS et les modules complémentaires produits par Amazon EKS, reportez-vous à la section précédente [Restrictions relatives à l’identité du pod EKS](pod-identities.md#pod-id-restrictions).

## Utilisation des identités du pod EKS dans votre code


Dans votre code, vous pouvez utiliser les kits SDK AWS pour accéder aux services AWS. Vous écrivez du code pour créer un client pour un service AWS avec un kit SDK, et par défaut, le kit SDK recherche dans une chaîne d’emplacements les informations d’identification de la gestion des identités et des accès AWS à utiliser. Une fois les informations d’identification valides trouvées, la recherche s’arrête. Pour plus d’informations sur les emplacements par défaut utilisés, consultez [Chaîne de fournisseurs d’informations d’identification](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain) dans le Guide de référence des kits SDK et des outils AWS.

Les identités du pod EKS ont été ajoutées au *fournisseur d’informations d’identification du conteneur* qui est recherché dans une étape de la chaîne d’informations d’identification par défaut. Si vos charges de travail utilisent actuellement des informations d’identification antérieures dans la chaîne de fournisseurs d’informations d’identification, ces informations continueront d’être utilisées même si vous configurez une association d’identité du pod EKS pour la même charge de travail. Ainsi, vous pouvez migrer en toute sécurité à partir d’autres types d’informations d’identification en créant d’abord l’association, avant de supprimer les anciennes informations d’identification.

Le fournisseur d’informations d’identification de conteneur fournit des informations d’identification temporaires à partir d’un agent qui s’exécute sur chaque nœud. Dans Amazon EKS, l’agent est l’agent d’identité du pod Amazon EKS et sur Amazon Elastic Container Service, l’agent est le `amazon-ecs-agent`. Les kits SDK utilisent des variables d’environnement pour localiser l’agent auquel se connecter.

En revanche, les *rôles IAM pour les comptes de service* fournissent un jeton d’*identité Web * que le kit SDK AWS doit échanger avec le service de jetons de sécurité AWS à l’aide d’`AssumeRoleWithWebIdentity`.

## Fonctionnement de l’agent de l’identité du pod EKS avec un pod


1. Lorsque Amazon EKS démarre un nouveau pod qui utilise un compte de service associé à une identité du pod EKS, le cluster ajoute le contenu suivant au manifeste du pod :

   ```
       env:
       - name: AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE
         value: "/var/run/secrets/pods.eks.amazonaws.com/serviceaccount/eks-pod-identity-token"
       - name: AWS_CONTAINER_CREDENTIALS_FULL_URI
         value: "http://169.254.170.23/v1/credentials"
       volumeMounts:
       - mountPath: "/var/run/secrets/pods.eks.amazonaws.com/serviceaccount/"
         name: eks-pod-identity-token
     volumes:
     - name: eks-pod-identity-token
       projected:
         defaultMode: 420
         sources:
         - serviceAccountToken:
             audience: pods.eks.amazonaws.com
             expirationSeconds: 86400 # 24 hours
             path: eks-pod-identity-token
   ```

1. Kubernetes sélectionne le nœud sur lequel exécuter le pod. Ensuite, l’agent d’identité du pod Amazon EKS sur le nœud utilise l’action [AssumeRoleForPodIdentity](https://docs.aws.amazon.com/eks/latest/APIReference/API_auth_AssumeRoleForPodIdentity.html) pour récupérer des informations d’identification temporaires auprès de l’API d’authentification EKS.

1. L’agent d’identité du pod EKS met ces identités à la disposition des kits SDK AWS que vous exécutez à l’intérieur de vos conteneurs.

1. Vous utilisez le kit SDK dans votre application sans spécifier de fournisseur d’informations d’identification pour utiliser la chaîne d’informations d’identification par défaut. Vous pouvez également spécifier le fournisseur d’informations d’identification du conteneur. Pour plus d’informations sur les emplacements par défaut utilisés, consultez [Chaîne de fournisseurs d’informations d’identification](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain) dans le Guide de référence des kits SDK et des outils AWS.

1. Le kit SDK utilise les variables d’environnement pour se connecter à l’agent d’identité du pod EKS et récupérer les informations d’identification.
**Note**  
Si vos charges de travail utilisent actuellement des informations d’identification antérieures dans la chaîne de fournisseurs d’informations d’identification, ces informations continueront d’être utilisées même si vous configurez une association d’identité du pod EKS pour la même charge de travail.

# Configurer l’agent de l’identité du pod Amazon EKS
Configurer l’agent

Les associations Amazon EKS Pod Identity permettent de gérer les informations d'identification de vos applications, de la même manière que les profils d' EC2 instance Amazon fournissent des informations d'identification aux EC2 instances Amazon.

L’identité du pod Amazon EKS fournit des informations d’identification à vos charges de travail avec une API d’*authentification EKS* supplémentaire et un pod d’agent qui s’exécute sur chaque nœud.

**Astuce**  
Vous n’avez pas besoin d’installer l’agent de l’identité du pod Amazon EKS sur les clusters du mode automatique EKS. Cette fonctionnalité est créée dans le mode automatique EKS.

## Considérations

+ Par défaut, l’agent de l’identité du pod Amazon EKS est préinstallé sur les clusters du mode automatique EKS. Pour en savoir plus, veuillez consulter la section [Automatisation de l’infrastructure du cluster avec le mode automatique EKS](automode.md).
+ Par défaut, l’agent d’identité du pod EKS écoute sur une adresse `IPv4` et `IPv6` pour que les pods puissent demander des informations d’identification. L’agent utilise l’adresse IP de bouclage (localhost) `169.254.170.23` pour `IPv4` et l’adresse IP localhost `[fd00:ec2::23]` pour `IPv6`.
+ Si vous désactivez les adresses `IPv6` ou empêchez d’une autre manière les adresses IP `IPv6` localhost, l’agent ne peut pas démarrer. Pour démarrer l’agent sur des nœuds qui ne peuvent pas utiliser `IPv6`, suivez les étapes décrites dans [Désactiver `IPv6` dans l’agent d’identité du pod EKS](pod-id-agent-config-ipv6.md) pour désactiver la configuration `IPv6`.

## Création d’un agent d’identité du pod Amazon EKS


### Conditions préalables pour l’agent

+ Un cluster Amazon EKS existant. Pour en déployer un, consultez [Mise en route avec Amazon EKS](getting-started.md). La version du cluster et la version de plateforme doivent être identiques ou supérieures aux versions répertoriées dans [Versions du cluster de l’identité du pod EKS](pod-identities.md#pod-id-cluster-versions).
+ Le rôle de nœud dispose d’autorisations permettant à l’agent d’effectuer l’action `AssumeRoleForPodIdentity` dans l’API d’authentification EKS. Vous pouvez utiliser la [politique AWS gérée : Amazon EKSWorker NodePolicy](security-iam-awsmanpol.md#security-iam-awsmanpol-amazoneksworkernodepolicy) ou ajouter une politique personnalisée similaire à la suivante :

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks-auth:AssumeRoleForPodIdentity"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

  Cette action peut être limitée par des balises pour restreindre les rôles qui peuvent être assumés par les pods qui utilisent l’agent.
+ Les nœuds peuvent atteindre et télécharger des images à partir d’Amazon ECR. L’image de conteneur pour le module complémentaire se trouve dans les registres répertoriés dans [Afficher les registres d’images de conteneur Amazon pour les modules complémentaires Amazon EKS](add-ons-images.md).

  Notez que vous pouvez modifier l'emplacement de l'image et `imagePullSecrets` prévoir des modules complémentaires EKS dans les **paramètres de configuration facultatifs** de et `--configuration-values` dans la AWS CLI. AWS Management Console
+ Les nœuds peuvent accéder à l’API d’authentification Amazon EKS. Pour les clusters privés, le `eks-auth` point de terminaison AWS PrivateLink est obligatoire.

### Agent d'installation avec AWS console


1. Ouvrez la [console Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

1. Dans le panneau de navigation de gauche, sélectionnez **Clusters**, puis sélectionnez le nom du cluster pour lequel vous souhaitez configurer le module complémentaire l’agent d’identité du pod EKS.

1. Choisissez l’onglet **Modules complémentaires**.

1. Choisissez **Obtenez plus de modules complémentaires**.

1. Cochez la case en haut à droite du module complémentaire de l’agent d’identité du pod EKS, puis sélectionnez **Suivant**.

1. Sur la page **Configurer les paramètres de modules complémentaires sélectionnés**, sélectionnez n’importe quelle **Version** dans la liste déroulante Version.

1. (Facultatif) Développez les **Paramètres de configuration facultatifs** pour entrer une configuration supplémentaire. Par exemple, vous pouvez fournir un autre emplacement d’image de conteneur et `ImagePullSecrets`. Le schéma JSON avec les clés acceptées est présenté dans **Schéma de configuration du module complémentaire**.

   Saisissez les clés et les valeurs de configuration dans **Valeurs de configuration**.

1. Choisissez **Suivant**.

1. Confirmez que les pods de l’agent d’identité du pod EKS sont en cours d’exécution sur votre cluster.

   ```
   kubectl get pods -n kube-system | grep 'eks-pod-identity-agent'
   ```

   L'exemple qui suit illustre un résultat.

   ```
   eks-pod-identity-agent-gmqp7                                          1/1     Running   1 (24h ago)   24h
   eks-pod-identity-agent-prnsh                                          1/1     Running   1 (24h ago)   24h
   ```

   Vous pouvez maintenant utiliser les associations d’identité du pod EKS dans votre cluster. Pour de plus amples informations, veuillez consulter [Attribuer un rôle IAM à un compte de service Kubernetes](pod-id-association.md).

### Agent de configuration avec AWS CLI


1. Exécutez la commande AWS CLI suivante. Remplacez `my-cluster` par le nom de votre cluster.

   ```
   aws eks create-addon --cluster-name my-cluster --addon-name eks-pod-identity-agent --addon-version v1.0.0-eksbuild.1
   ```
**Note**  
L’agent de l’identité du pod Amazon EKS n’utilise pas le `service-account-role-arn` pour les *rôles IAM pour les comptes de service*. Vous devez fournir à l’agent d’identité du pod EKS des autorisations dans le rôle de nœud.

1. Confirmez que les pods de l’agent d’identité du pod EKS sont en cours d’exécution sur votre cluster.

   ```
   kubectl get pods -n kube-system | grep 'eks-pod-identity-agent'
   ```

   L'exemple qui suit illustre un résultat.

   ```
   eks-pod-identity-agent-gmqp7                                          1/1     Running   1 (24h ago)   24h
   eks-pod-identity-agent-prnsh                                          1/1     Running   1 (24h ago)   24h
   ```

   Vous pouvez maintenant utiliser les associations d’identité du pod EKS dans votre cluster. Pour de plus amples informations, veuillez consulter [Attribuer un rôle IAM à un compte de service Kubernetes](pod-id-association.md).

# Attribuer un rôle IAM à un compte de service Kubernetes
Attribution d’un rôle IAM

Cette rubrique explique comment configurer un compte de service Kubernetes pour qu'il assume un rôle de gestion des AWS identités et des accès (IAM) avec EKS Pod Identity. Tous les pods configurés pour utiliser le compte de service peuvent ensuite accéder à tout AWS service auquel le rôle est autorisé à accéder.

Pour créer une association EKS Pod Identity, il n'y a qu'une seule étape : vous créez l'association dans EKS via la AWS Management Console AWS CLI AWS CloudFormation et d'autres outils. AWS SDKs Il n’y a aucune donnée ou métadonnée concernant les associations à l’intérieur du cluster dans les objets Kubernetes et vous n’ajoutez aucune annotation aux comptes de service.

 **Conditions préalables** 
+ Un cluster existant. Si vous n’en avez pas, vous pouvez en créer un en suivant l’un des guides [Mise en route avec Amazon EKS](getting-started.md).
+ Le principal IAM qui crée l’association doit avoir le `iam:PassRole`.
+ La dernière version de la AWS CLI installée et configurée sur votre appareil ou AWS CloudShell. Vous pouvez vérifier votre version actuelle avec `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Les gestionnaires de packages tels que `yum` Homebrew pour macOS ont souvent plusieurs versions de retard sur la dernière version de la AWS CLI. `apt-get` Pour installer la dernière version, consultez la section [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) et [configuration rapide avec aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) dans le Guide de l'utilisateur de l'interface de ligne de AWS commande. La version de la AWS CLI installée dans le AWS CloudShell peut également avoir plusieurs versions de retard par rapport à la dernière version. Pour le mettre à jour, consultez la section [Installation de la AWS CLI dans votre répertoire](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) de base dans le guide de AWS CloudShell l'utilisateur.
+ L'outil de ligne de commande `kubectl` est installé sur votre appareil ou AWS CloudShell. La version peut correspondre à celle utilisée par votre cluster Kubernetes, ou différer d’au plus une version mineure, qu’elle soit antérieure ou plus récente. Par exemple, si la version de votre cluster est `1.29`, vous pouvez utiliser la version `kubectl` `1.28`, `1.29` ou `1.30`. Pour installer ou mettre à niveau `kubectl`, veuillez consulter [Configuration de `kubectl` et `eksctl`](install-kubectl.md).
+ Un fichier existant `kubectl` `config` qui contient la configuration de votre cluster. Pour créer un fichier `kubectl` `config`, consultez [Connexion de kubectl à un cluster EKS en créant un fichier kubeconfig](create-kubeconfig.md).

## Création d'une association Pod Identity (AWS console)


1. Ouvrez la [console Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

1. Dans le panneau de navigation de gauche, sélectionnez **Clusters**, puis sélectionnez le nom du cluster pour lequel vous souhaitez configurer le module complémentaire l’agent d’identité du pod EKS.

1. Choisissez l’onglet **Access**.

1. Dans **Associations d’identité du pod**, sélectionnez **Créer**.

1. Pour **Rôle IAM**, sélectionnez le rôle IAM avec les autorisations dont a besoin la charge de travail.
**Note**  
La liste ne contient que les rôles qui ont la politique d’approbation suivante qui permet à l’identité du pod EKS de les utiliser.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "AllowEksAuthToAssumeRoleForPodIdentity",
               "Effect": "Allow",
               "Principal": {
                   "Service": "pods.eks.amazonaws.com"
               },
               "Action": [
                   "sts:AssumeRole",
                   "sts:TagSession"
               ]
           }
       ]
   }
   ```

    `sts:AssumeRole` : l’identité du pod EKS utilise `AssumeRole` pour assumer le rôle IAM avant de transmettre les informations d’identification temporaires à vos pods.

    `sts:TagSession`— EKS Pod Identity est utilisé `TagSession` pour inclure des *balises de session* dans les demandes adressées à AWS STS.

   Vous pouvez utiliser ces balises dans les *clés de condition* de la politique d’approbation pour restreindre les comptes de service, les espaces de noms et les clusters pouvant utiliser ce rôle.

   Pour obtenir la liste des clés de condition Amazon EKS, consultez la rubrique [Conditions définies par Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html#amazonelastickubernetesservice-policy-keys) de la *Référence de l'autorisation de service*. Pour savoir avec quelles actions et ressources vous pouvez utiliser une clé de condition, consultez la rubrique [Actions définies par Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html#amazonelastickubernetesservice-actions-as-permissions).

1. Pour l’**espace de noms Kubernetes**, sélectionnez l’espace de noms Kubernetes qui contient le compte de service et la charge de travail. Vous pouvez également spécifier un espace de noms par son nom qui n’existe pas dans le cluster.

1. Pour le **compte de service Kubernetes**, sélectionnez le compte de service Kubernetes à utiliser. Le manifeste de votre charge de travail Kubernetes doit spécifier ce compte de service. Vous pouvez également spécifier un compte de service par son nom qui n’existe pas dans le cluster.

1. (Facultatif) Sélectionnez **Désactiver les balises de session** pour désactiver les balises de session par défaut que Pod Identity ajoute automatiquement lorsqu'il assume le rôle.

1. (Facultatif) Activez l'option **Configurer la politique de session** pour configurer une politique IAM afin d'appliquer des restrictions supplémentaires à cette association Pod Identity au-delà des autorisations définies dans la stratégie IAM attachée au rôle IAM.
**Note**  
Une politique de session ne peut être appliquée que lorsque le paramètre **Désactiver les balises de session** est coché.

1. (Facultatif) Pour **Balises**, choisissez **Ajouter une balise** pour ajouter des métadonnées dans une paire clé et valeur. Ces balises sont appliquées à l’association et peuvent être utilisées dans les politiques IAM.

   Vous pouvez répéter cette étape pour ajouter plusieurs balises.

1. Choisissez **Créer**.

## Création d'une association Pod Identity (AWS CLI)


1. Si vous souhaitez associer une politique IAM existante à votre rôle IAM, passez à l'étape suivante.

   Créez une politique IAM. Vous pouvez créer votre propre politique ou copier une politique AWS gérée qui accorde déjà certaines des autorisations dont vous avez besoin et la personnaliser en fonction de vos besoins spécifiques. Pour plus d’informations, consultez [Création de politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) dans le *Guide de l’utilisateur IAM*.

   1. Créez un fichier qui inclut les autorisations pour les AWS services auxquels vous souhaitez que vos pods accèdent. Pour obtenir la liste de toutes les actions pour tous les AWS services, consultez la [référence d'autorisation des services](https://docs.aws.amazon.com/service-authorization/latest/reference/).

      Vous pouvez exécuter la commande suivante pour créer un exemple de fichier de politique autorisant l'accès en lecture seule à un compartiment Amazon S3. Vous pouvez, si vous le souhaitez, stocker des informations de configuration ou un script d’amorçage dans ce compartiment et les conteneurs de votre pod pourront lire le fichier dans le compartiment et le charger dans votre application. Si vous souhaitez créer cet exemple de politique, copiez le contenu suivant sur votre appareil. *my-pod-secrets-bucket*Remplacez-le par le nom de votre compartiment et exécutez la commande.

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": "s3:GetObject",
                  "Resource": "arn:aws:s3:::my-pod-secrets-bucket"
              }
          ]
      }
      ```

   1. Créez la politique IAM.

      ```
      aws iam create-policy --policy-name my-policy --policy-document file://my-policy.json
      ```

1. Créez un rôle IAM, puis associez-le à un compte de service Kubernetes.

   1. Si vous avez déjà un compte de service Kubernetes devant assumer un rôle IAM, vous pouvez ignorer cette étape.

      Créez un compte de service Kubernetes. Copiez les contenus suivants sur votre appareil. *my-service-account*Remplacez-le par le nom de votre choix et *default* par un autre espace de noms, si nécessaire. Si vous modifiez*default*, l'espace de noms doit déjà exister.

      ```
      cat >my-service-account.yaml <<EOF
      apiVersion: v1
      kind: ServiceAccount
      metadata:
        name: my-service-account
        namespace: default
      EOF
      kubectl apply -f my-service-account.yaml
      ```

      Exécutez la commande suivante.

      ```
      kubectl apply -f my-service-account.yaml
      ```

   1. Exécutez la commande suivante pour créer un fichier de stratégie d'approbation pour le rôle IAM.

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Sid": "AllowEksAuthToAssumeRoleForPodIdentity",
                  "Effect": "Allow",
                  "Principal": {
                      "Service": "pods.eks.amazonaws.com"
                  },
                  "Action": [
                      "sts:AssumeRole",
                      "sts:TagSession"
                  ]
              }
          ]
      }
      ```

   1. Créez le rôle. Remplacez *my-role* avec un nom pour votre rôle IAM, et *my-role-description* avec une description de votre rôle.

      ```
      aws iam create-role --role-name my-role --assume-role-policy-document file://trust-relationship.json --description "my-role-description"
      ```

   1. Liez une politique IAM à votre rôle. Remplacez *my-role* par le nom de votre rôle IAM et *my-policy* par le nom d'une politique existante que vous avez créée.

      ```
      aws iam attach-role-policy --role-name my-role --policy-arn=arn:aws: iam::111122223333:policy/my-policy
      ```
**Note**  
Contrairement aux rôles IAM pour les comptes de service, l’identité du pod EKS n’utilise pas d’annotation sur le compte de service.

   1. Exécutez la commande suivante pour créer l’association. `my-cluster`Remplacez-le par le nom du cluster, remplacez-le *my-service-account* par le nom de votre choix et *default* par un autre espace de noms, si nécessaire.

      ```
      aws eks create-pod-identity-association --cluster-name my-cluster --role-arn arn:aws: iam::111122223333:role/my-role --namespace default --service-account my-service-account
      ```

      L'exemple qui suit illustre un résultat.

      ```
      {
          "association": {
              "clusterName": "my-cluster",
              "namespace": "default",
              "serviceAccount": "my-service-account",
              "roleArn": "arn:aws: iam::111122223333:role/my-role",
              "associationArn": "arn:aws::111122223333:podidentityassociation/my-cluster/a-abcdefghijklmnop1",
              "associationId": "a-abcdefghijklmnop1",
              "tags": {},
              "createdAt": 1700862734.922,
              "modifiedAt": 1700862734.922
          }
      }
      ```
**Note**  
Vous pouvez spécifier un espace de noms et un compte de service par leur nom qui n’existent pas dans le cluster. Vous devez créer l’espace de noms, le compte de service et la charge de travail qui utilise le compte de service pour que l’association de l’identité du pod EKS fonctionne.

## Confirmer la configuration


1. Vérifiez que la stratégie d’approbation du rôle IAM est correctement configurée.

   ```
   aws iam get-role --role-name my-role --query Role.AssumeRolePolicyDocument
   ```

   L'exemple qui suit illustre un résultat.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "Allow EKS Auth service to assume this role for Pod Identities",
               "Effect": "Allow",
               "Principal": {
                   "Service": "pods.eks.amazonaws.com"
               },
               "Action": [
                   "sts:AssumeRole",
                   "sts:TagSession"
               ]
           }
       ]
   }
   ```

1. Vérifiez que la stratégie que vous avez associée à votre rôle lors d'une étape précédente est associée au rôle.

   ```
   aws iam list-attached-role-policies --role-name my-role --query 'AttachedPolicies[].PolicyArn' --output text
   ```

   L'exemple qui suit illustre un résultat.

   ```
    arn:aws: iam::111122223333:policy/my-policy
   ```

1. Définissez une variable pour stocker l'Amazon Resource Name (ARN) de la stratégie que vous souhaitez utiliser. *my-policy*Remplacez-le par le nom de la politique pour laquelle vous souhaitez confirmer les autorisations.

   ```
   export policy_arn=arn:aws: iam::111122223333:policy/my-policy
   ```

1. Affichez la version par défaut de la stratégie.

   ```
   aws iam get-policy --policy-arn $policy_arn
   ```

   L'exemple qui suit illustre un résultat.

   ```
   {
       "Policy": {
           "PolicyName": "my-policy",
           "PolicyId": "EXAMPLEBIOWGLDEXAMPLE",
           "Arn": "arn:aws: iam::111122223333:policy/my-policy",
           "Path": "/",
           "DefaultVersionId": "v1",
           [...]
       }
   }
   ```

1. Consultez le contenu de la stratégie pour vous assurer qu’elle inclut toutes les autorisations nécessaires pour votre pod. Si nécessaire, remplacez *1* la commande suivante par la version renvoyée dans la sortie précédente.

   ```
   aws iam get-policy-version --policy-arn $policy_arn --version-id v1
   ```

   L'exemple qui suit illustre un résultat.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::my-pod-secrets-bucket"
           }
       ]
   }
   ```

   Si vous avez créé l'exemple de stratégie lors d'une étape précédente, le résultat est le même. Si vous avez créé une politique différente, le *example* contenu est différent.

## Étapes suivantes


 [Configurer les pods pour accéder aux AWS services avec des comptes de service](pod-id-configure-pods.md) 

# Accédez aux AWS ressources à l'aide des rôles IAM EKS Pod Identity Target
Attribuer un rôle cible IAM

Lorsque vous exécutez des applications sur Amazon Elastic Kubernetes Service (Amazon EKS), il se peut que vous deviez accéder AWS à des ressources qui existent dans différents comptes. AWS Ce guide explique comment configurer l'accès entre comptes à l'aide d'EKS Pod Identity, qui permet à vos pods Kubernetes d'accéder à d'autres AWS ressources à l'aide de rôles cibles.

## Conditions préalables


Avant de commencer, assurez-vous d’avoir effectué les étapes suivantes :
+  [Configurer l’agent de l’identité du pod Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-agent-setup.html) 
+  [Créer un rôle identité du pod EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html) 

## Comment ça marche


Pod Identity permet aux applications de votre cluster EKS d'accéder aux AWS ressources de différents comptes par le biais d'un processus appelé chaînage des rôles.

Lorsque vous créez une association Pod Identity, vous pouvez fournir deux rôles IAM : un [rôle EKS Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html) dans le même compte que votre cluster EKS et un rôle IAM cible provenant du compte contenant les AWS ressources auxquelles vous souhaitez accéder (comme les compartiments S3 ou les bases de données RDS). Le [rôle EKS Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html) doit figurer dans le compte de votre cluster EKS en raison des PassRole exigences [IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_examples_iam-passrole-service.html), tandis que le rôle IAM cible peut se trouver dans n'importe quel AWS compte. PassRole permet à une AWS entité de déléguer l'attribution de rôles à un autre service. EKS Pod Identity PassRole permet de connecter un rôle à un compte de service Kubernetes, ce qui nécessite que le rôle et l'identité qui le transmettent se trouvent dans le même AWS compte que le cluster EKS. Lorsque votre pod d'application a besoin d'accéder à AWS des ressources, il demande des informations d'identification à Pod Identity. L’identité du pod effectue alors automatiquement deux prises de rôle consécutives : elle prend d’abord le [rôle d’identité du pod EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html), puis utilise ces informations d’identification pour prendre le rôle IAM cible. Ce processus fournit à votre pod des informations d'identification temporaires dotées des autorisations définies dans le rôle cible, ce qui permet un accès sécurisé aux ressources d'autres AWS comptes.

## Considérations relatives à la mise en cache


En raison des mécanismes de mise en cache, les mises à jour d’un rôle IAM dans une association identité du pod EKS peuvent ne pas prendre effet immédiatement dans les pods s’exécutant sur votre cluster EKS. L’agent identité du pod met en cache les informations d’identification IAM en fonction de la configuration de l’association au moment où les informations d’identification sont récupérées. Si l’association comprend uniquement un [rôle d’identité du pod EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html) et aucun rôle IAM cible, les informations d’identification mises en cache sont valables pendant 6 heurs. Si l’association comprend à la fois l’ARN du [rôle d’identité du pod EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html) et un rôle IAM cible, les informations d’identification mises en cache sont valables pendant 59 minutes. La modification d’une association existante, telle que la mise à jour de l’ARN du [rôle d’identité du pod EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html) ou l’ajout d’un rôle IAM cible, ne réinitialise pas le cache existant. Par conséquent, l’agent ne reconnaîtra pas les mises à jour tant que les informations d’identification mises en cache n’auront pas été actualisées. Pour appliquer les modifications plus rapidement, vous pouvez recréer les pods existants ; sinon, vous devrez attendre l’expiration du cache.

## Étape 1 : créer et associer un rôle IAM cible


Au cours de cette étape, vous allez établir une chaîne de confiance sécurisée en créant et en configurant un rôle IAM cible. À titre de démonstration, nous allons créer un nouveau rôle IAM cible pour établir une chaîne de confiance entre deux AWS comptes : le [rôle EKS Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html) (par exemple`eks-pod-identity-primary-role`) du AWS compte du cluster EKS est autorisé à assumer le rôle IAM cible (par exemple`eks-pod-identity-aws-resources`) sur votre compte cible, permettant ainsi d'accéder à des AWS ressources telles que les compartiments Amazon S3.

### Créer le rôle IAM cible


1. Ouvrez la [console Amazon IAM](https://console.aws.amazon.com/iam/home).

1. Dans la barre de navigation supérieure, vérifiez que vous êtes connecté au compte contenant les AWS ressources (telles que des compartiments S3 ou des tables DynamoDB) pour votre rôle IAM cible.

1. Dans le volet de navigation de gauche, choisissez **Rôles**.

1. Cliquez sur le bouton **Créer un rôle**, puis sur le ** AWS compte** sous « Type d'entité fiable ».

1. Choisissez **Un autre AWS compte**, entrez votre numéro de AWS compte (le compte sur lequel se trouve votre [rôle EKS Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html)), puis choisissez **Next**.

1. **Ajoutez les politiques d'autorisation que vous souhaitez associer au rôle (par exemple, AmazonS3FullAccess), puis choisissez Next.**

1. Saisissez un nom de rôle, tel que `MyCustomIAMTargetRole`, puis sélectionnez **Créer un rôle**.

### Mettre à jour la politique d’approbation du rôle IAM cible


1. Après avoir créé le rôle, vous serez redirigé vers la liste **Rôles**. Recherchez et sélectionnez le nouveau rôle que vous avez créé à l’étape précédente (par exemple, `MyCustomIAMTargetRole`).

1. Sélectionnez l’onglet **Relations d’approbation**.

1. Cliquez sur **Modifier la politique d’approbation** à droite.

1. Dans l’éditeur de politique, remplacez le JSON par défaut par votre politique d’approbation. Remplacez les valeurs d'espace réservé pour le nom du rôle et `111122223333` dans l'ARN du rôle IAM par l'ID du AWS compte hébergeant votre cluster EKS. Vous pouvez également éventuellement utiliser la politique de confiance PrincipalTags dans les rôles pour autoriser uniquement des comptes de service spécifiques d'un cluster et d'un espace de noms donnés à assumer votre rôle cible. Par exemple :

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::111122223333:root"
      },
      "Action": [
        "sts:AssumeRole",
        "sts:TagSession"
      ],
      "Condition": {
        "StringEquals": {
          "aws:RequestTag/eks-cluster-arn": "arn:aws:eks:us-east-1:111122223333:cluster/example-cluster",
          "aws:RequestTag/kubernetes-namespace": "ExampleNameSpace",
          "aws:RequestTag/kubernetes-service-account": "ExampleServiceAccountName"
        },
        "ArnEquals": {
          "aws:PrincipalARN": "arn:aws:iam::111122223333:role/eks-pod-identity-primary-role"
        }
      }
    }
  ]
}
```

La politique ci-dessus permet au rôle `eks-pod-identeity-primary-role` du AWS compte 111122223333 doté des [tags de session EKS Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-abac.html) appropriés d'assumer ce rôle.

Si vous avez [désactivé les balises de session](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-abac.html#pod-id-abac-tags) dans votre identité du pod EKS, l’identité du pod EKS définit également le `sts:ExternalId` avec des informations sur le cluster, l’espace de noms et le compte de service d’un pod lors de l’assomption d’un rôle cible.

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::111122223333:root"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "sts:ExternalId": "region/111122223333/cluster-name/namespace/service-account-name"
        },
        "ArnEquals": {
          "aws:PrincipalARN": "arn:aws:iam::111122223333:role/eks-pod-identity-primary-role"
        }
      }
    },
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::111122223333:root"
      },
      "Action": "sts:TagSession"
    }
  ]
}
```

La politique ci-dessus permet de garantir que seuls le cluster, l’espace de noms et le compte de service attendus peuvent assumer le rôle cible.

### Mettre à jour la politique d’autorisation pour le rôle d’identité du pod EKS


Au cours de cette étape, vous allez mettre à jour la politique d’autorisation du [rôle d’identité du pod EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html) associé à votre cluster Amazon EKS en ajoutant l’ARN du rôle IAM cible en tant que ressource.

1. Ouvrez la [console Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

1. Dans le volet de navigation gauche, sélectionnez **Clusters**, puis sélectionnez le nom de votre cluster EKS.

1. Choisissez l’onglet **Access**.

1. Sous **Associations d’identité du pod**, sélectionnez votre [rôle d’identité du pod EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html).

1. Sélectionnez **Autorisations**, **Ajouter des autorisations**, puis **Créer une politique en ligne**.

1. Sélectionnez **JSON** sur le côté droit.

1. Dans l’éditeur de politique, remplacez le JSON par défaut par votre politique d’autorisation. Remplacez la valeur de remplacement pour le nom du rôle et `222233334444` dans l’ARN du rôle IAM par votre rôle IAM cible. Par exemple :

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "sts:AssumeRole",
                "sts:TagSession"
            ],
            "Resource": "arn:aws:iam::222233334444:role/eks-pod-identity-aws-resources"
        }
    ]
}
```

## Étape 2 : associer le rôle IAM cible à un compte de service Kubernetes


Au cours de cette étape, vous allez créer une association entre le rôle IAM cible et le compte de service Kubernetes dans votre cluster EKS.

1. Ouvrez la [console Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

1. Dans le panneau de navigation gauche, sélectionnez **Clusters**, puis le nom du cluster auquel vous voulez ajouter l’association.

1. Choisissez l’onglet **Access**.

1. Dans **Associations d’identité du pod**, sélectionnez **Créer**.

1. Sélectionnez le [Rôle d’identité du pod EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html) dans **Rôle IAM** pour vos charges de travail.

1. Sélectionnez le rôle IAM cible dans **Rôle IAM cible** qui sera assumé par le [Rôle d’identité du pod EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html).

1. Dans le champ **Espace de noms Kubernetes**, saisissez le nom de l’espace de noms dans lequel vous voulez créer l’association (par exemple, `my-app-namespace`). Cela permet de définir l’emplacement du compte de service.

1. Dans le champ **Compte de service Kubernetes**, saisissez le nom du compte de service (par exemple, `my-service-account`) qui utilisera les informations d’identification IAM. Cela permet de lier le rôle IAM au compte de service.

1. (Facultatif) Sélectionnez **Désactiver les balises de session** pour désactiver les balises de session par défaut que Pod Identity ajoute automatiquement lorsqu'il assume le rôle.

1. (Facultatif) Activez l'option **Configurer la politique de session** pour configurer une politique IAM afin d'appliquer des restrictions supplémentaires à cette association Pod Identity au-delà des autorisations définies dans la stratégie IAM attachée au rôle IAM **cible**.
**Note**  
1. Une politique de session ne peut être appliquée que lorsque le paramètre **Désactiver les balises de session** est coché. 2. Si vous spécifiez une politique de session, les restrictions de politique s'appliquent aux autorisations du **rôle Target IAM** et non au **rôle IAM** associé à cette association Pod Identity.

1. Sélectionnez **Créer** pour créer l’association.

# Configurer les pods pour accéder aux AWS services avec des comptes de service
Compte de service de pod

Si un Pod doit accéder à AWS des services, vous devez le configurer pour utiliser un compte de service Kubernetes. Le compte de service doit être associé à un rôle AWS Identity and Access Management (IAM) autorisé à accéder aux services. AWS 
+ Un cluster existant. Si vous n’en avez pas, vous pouvez en créer un à l’aide de l’un des guides disponibles dans [Mise en route avec Amazon EKS](getting-started.md).
+ Un compte de service Kubernetes existant et une association d’identité du pod EKS qui associe le compte de service à un rôle IAM. Le rôle doit être associé à une politique IAM contenant les autorisations dont vous souhaitez que vos pods disposent pour utiliser les AWS services. Pour plus d'informations sur la façon de créer et de configurer le compte de service et le rôle, consultez [Attribuer un rôle IAM à un compte de service Kubernetes](pod-id-association.md).
+ La dernière version de la AWS CLI installée et configurée sur votre appareil ou AWS CloudShell. Vous pouvez vérifier votre version actuelle avec `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Les gestionnaires de packages tels que `yum` Homebrew pour macOS ont souvent plusieurs versions de retard sur la dernière version de la AWS CLI. `apt-get` Pour installer la dernière version, consultez la section [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) et [configuration rapide avec aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) dans le Guide de l'utilisateur de l'interface de ligne de AWS commande. La version de la AWS CLI installée dans le AWS CloudShell peut également avoir plusieurs versions de retard par rapport à la dernière version. Pour le mettre à jour, consultez la section [Installation de la AWS CLI dans votre répertoire](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) de base dans le guide de AWS CloudShell l'utilisateur.
+ L'outil de ligne de commande `kubectl` est installé sur votre appareil ou AWS CloudShell. La version peut correspondre à celle utilisée par votre cluster Kubernetes, ou différer d’au plus une version mineure, qu’elle soit antérieure ou plus récente. Par exemple, si la version de votre cluster est `1.29`, vous pouvez utiliser la version `kubectl` `1.28`, `1.29` ou `1.30`. Pour installer ou mettre à niveau `kubectl`, veuillez consulter [Configuration de `kubectl` et `eksctl`](install-kubectl.md).
+ Un fichier existant `kubectl` `config` qui contient la configuration de votre cluster. Pour créer un fichier `kubectl` `config`, consultez [Connexion de kubectl à un cluster EKS en créant un fichier kubeconfig](create-kubeconfig.md).

  1. Utilisez la commande suivante pour créer un manifeste de déploiement que vous pouvez déployer sur un pod afin de confirmer la configuration. Remplacez les exemples de valeurs par vos propres valeurs.

     ```
     cat >my-deployment.yaml <<EOF
     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: my-app
     spec:
       selector:
         matchLabels:
           app: my-app
       template:
         metadata:
           labels:
             app: my-app
         spec:
           serviceAccountName: my-service-account
           containers:
           - name: my-app
             image: public.ecr.aws/nginx/nginx:X.XX
     EOF
     ```

  1. Appliquez le manifeste à votre cluster.

     ```
     kubectl apply -f my-deployment.yaml
     ```

  1. Vérifiez que les variables d’environnement requises existent pour votre pod.

     1. Affichez les pods qui ont été déployés avec le déploiement à l’étape précédente.

        ```
        kubectl get pods | grep my-app
        ```

        L'exemple qui suit illustre un résultat.

        ```
        my-app-6f4dfff6cb-76cv9   1/1     Running   0          3m28s
        ```

     1. Vérifiez que le pod dispose d’un fichier de jeton de compte de service monté.

        ```
        kubectl describe pod my-app-6f4dfff6cb-76cv9 | grep AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE:
        ```

        L'exemple qui suit illustre un résultat.

        ```
        AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE:  /var/run/secrets/pods.eks.amazonaws.com/serviceaccount/eks-pod-identity-token
        ```

  1. Vérifiez que vos pods peuvent interagir avec les AWS services à l'aide des autorisations que vous avez attribuées dans la politique IAM associée à votre rôle.
**Note**  
Lorsqu'un pod utilise les AWS informations d'identification d'un rôle IAM associé à un compte de service, la AWS CLI ou un autre SDKs élément des conteneurs de ce pod utilisent les informations d'identification fournies par ce rôle. Si vous ne restreignez pas l’accès aux informations d’identification fournies au [rôle IAM du nœud Amazon EKS](create-node-role.md), le pod a toujours accès à ces informations d’identification. Pour plus d'informations, consultez [Restreindre l'accès au profil d'instance affecté au composant master](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node).

     Si vos pods ne peuvent pas interagir avec les services comme prévu, suivez les étapes suivantes pour vérifier que tout est correctement configuré.

     1. Vérifiez que vos pods utilisent une version du AWS SDK qui permet d'assumer un rôle IAM via une association EKS Pod Identity. Pour de plus amples informations, veuillez consulter [Utiliser l’identité du pod avec le SDK AWS](pod-id-minimum-sdk.md).

     1. Vérifiez que le déploiement utilise le compte de service.

        ```
        kubectl describe deployment my-app | grep "Service Account"
        ```

        L'exemple qui suit illustre un résultat.

        ```
        Service Account:  my-service-account
        ```

# Accordez aux Pods l'accès aux AWS ressources en fonction des balises
Accorder l’accès aux pods

Le contrôle d’accès par attributs (ABAC) accorde des droits aux utilisateurs grâce à des politiques qui combinent des attributs. L’identité du pod EKS associe des balises aux informations d’identification temporaires de chaque pod avec des attributs tels que le nom du cluster, l’espace de noms et le nom du compte de service. Ces balises de session de rôle permettent aux administrateurs de créer un rôle unique qui peut fonctionner avec tous les comptes de service en autorisant l'accès aux AWS ressources en fonction des balises correspondantes. En ajoutant la prise en charge des balises de session de rôle, vous pouvez renforcer la sécurité entre les clusters et les charges de travail au sein des clusters, tout en réutilisant les mêmes rôles et politiques IAM.

## Exemple de politique avec balises


Vous trouverez ci-dessous un exemple de politique IAM qui accorde les autorisations `s3:GetObject` lorsque l’objet correspondant est balisé avec le nom du cluster EKS.

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:GetObjectTagging"
            ],
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "s3:ExistingObjectTag/eks-cluster-name": "${aws:PrincipalTag/eks-cluster-name}"
                }
            }
        }
    ]
}
```

## Activer ou désactiver les balises de session


Lorsqu’il assume le rôle, l’identité du pod EKS ajoute un ensemble prédéfini de balises de session. Ces balises de session permettent aux administrateurs de créer un rôle unique qui peut fonctionner avec toutes les ressources en autorisant l'accès aux AWS ressources en fonction des balises correspondantes.

### Activer les balises de session


Les balises de session sont automatiquement activées avec l’identité du pod EKS. Aucune action n’est requise de votre part. Par défaut, l’identité du pod EKS associe un ensemble de balises prédéfinies à votre session. Pour référencer ces balises dans les politiques, utilisez la syntaxe `${aws:PrincipalTag/` suivie de la clé de balise. Par exemple, `${aws:PrincipalTag/kubernetes-namespace}`.
+  `eks-cluster-arn` 
+  `eks-cluster-name` 
+  `kubernetes-namespace` 
+  `kubernetes-service-account` 
+  `kubernetes-pod-name` 
+  `kubernetes-pod-uid` 

### Désactivation des balises de session


 AWS compresse les politiques de session intégrées, les politiques ARNs gérées et les balises de session dans un format binaire compressé doté d'une limite distincte. Si vous recevez une erreur `PackedPolicyTooLarge` indiquant que le format binaire compressé a dépassé la limite de taille, vous pouvez essayer de réduire la taille en désactivant les balises de session ajoutées par l’identité du pod EKS. Pour désactiver ces balises de session, veuillez suivre les étapes suivantes :

1. Ouvrez la [console Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

1. Dans le panneau de navigation gauche, sélectionnez **Clusters**, puis sélectionnez le nom du cluster que vous voulez modifier.

1. Choisissez l’onglet **Access**.

1. Dans **Associations d’identité du pod**, choisissez l’ID d’association que vous souhaitez modifier dans **ID d’association**, puis choisissez **Modifier**.

1. Sous **Balises de session**, choisissez **Désactiver les balises de session**.

1. Sélectionnez **Enregistrer les modifications**.

## Balises inter-comptes


Toutes les balises de session ajoutées par l’identité du pod EKS sont *transitives* ; les clés et les valeurs des balises sont transmises à toutes les actions `AssumeRole` que vos charges de travail utilisent pour changer de rôle dans un autre compte. Vous pouvez utiliser ces balises dans les politiques d’autres comptes pour limiter l’accès dans des scénarios intercomptes. Pour plus d’informations, consultez [Chaînage des rôles avec des balises de session](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_role-chaining) dans le *Guide de l’utilisateur IAM*.

## Balises personnalisées


L’identité du pod EKS ne peut pas ajouter de balises personnalisées supplémentaires à l’action `AssumeRole` qu’il effectue. Cependant, les balises que vous appliquez au rôle `${aws:PrincipalTag/` IAM sont toujours disponibles dans le même format : `${aws:PrincipalTag/MyCustomTag}` suivi de la clé, par exemple .

**Note**  
Les balises ajoutées à la session via la demande `sts:AssumeRole` sont prioritaires en cas de conflit. Par exemple, supposons que :  
Amazon EKS ajoute une clé `eks-cluster-name` et une valeur `my-cluster` à la session lorsque EKS assume le rôle client et
Vous ajoutez une balise `eks-cluster-name` au rôle IAM avec la valeur `my-own-cluster`.
Dans ce cas, la première a priorité et la valeur de la balise `eks-cluster-name` sera `my-cluster`.

# Utiliser l’identité du pod avec le SDK AWS
Kits SDK pris en charge

## Utilisation des informations d'identification de l'identité du pod EKS


Pour utiliser les informations d’identification d’une association d’identité du pod EKS, votre code peut utiliser n’importe quel kit SDK AWS pour créer un client pour un service AWS avec un kit SDK. Par défaut, le kit SDK recherche dans une chaîne d’emplacements les informations d’identification de la gestion des identités et des accès AWS à utiliser. Les informations d’identification d’identité du pod EKS seront utilisées si vous ne spécifiez pas de fournisseur d’informations d’identification lors de la création du client ou de l’initialisation du SDK.

Cela fonctionne parce que les identités du pod EKS ont été ajoutées au *fournisseur d'informations d'identification du conteneur* qui est recherché dans une étape de la chaîne d'informations d'identification par défaut. Si vos charges de travail utilisent actuellement des informations d'identification antérieures dans la chaîne de fournisseurs d'informations d'identification, ces informations continueront d'être utilisées même si vous configurez une association d'identité du pod EKS pour la même charge de travail.

Pour plus d'informations sur le fonctionnement des identités du pod EKS, consultez [Comprendre le fonctionnement de l’identité du pod Amazon EKS](pod-id-how-it-works.md).

Lorsque vous utilisez [Découvrez comment l’identité du pod EKS accorde aux pods l’accès aux services AWS](pod-identities.md), les conteneurs de vos pods doivent utiliser une version AWS du kit SDK qui prend en charge l’assumption d’un rôle IAM à partir de l’agent d’identité du pod EKS. Veillez à utiliser les versions suivantes, ou ultérieures, pour votre kit SDK AWS :
+ Java (version 2) : [2.21.30](https://github.com/aws/aws-sdk-java-v2/releases/tag/2.21.30) 
+ Java : [1.12.746](https://github.com/aws/aws-sdk-java/releases/tag/1.12.746) 
+ Go v1 : [v1.47.11](https://github.com/aws/aws-sdk-go/releases/tag/v1.47.11) 
+ Go v2 : [release-2023-11-14](https://github.com/aws/aws-sdk-go-v2/releases/tag/release-2023-11-14) 
+ Python (Boto3) : [1.34.41](https://github.com/boto/boto3/releases/tag/1.34.41) 
+ Python (botocore) : [1.34.41](https://github.com/boto/botocore/releases/tag/1.34.41) 
+  AWS CLI : [1.30.0](https://github.com/aws/aws-cli/releases/tag/1.30.0) 

   AWS CLI : [2.15.0](https://github.com/aws/aws-cli/releases/tag/2.15.0) 
+ JavaScript v2 : [2.1550.0](https://github.com/aws/aws-sdk-js/releases/tag/v2.1550.0) 
+ JavaScript v3 : [v3.458.0](https://github.com/aws/aws-sdk-js-v3/releases/tag/v3.458.0) 
+ Kotlin : [v1.0.1](https://github.com/awslabs/aws-sdk-kotlin/releases/tag/v1.0.1) 
+ Ruby : [3.188.0](https://github.com/aws/aws-sdk-ruby/blob/version-3/gems/aws-sdk-core/CHANGELOG.md#31880-2023-11-22) 
+ Rust : [release-2024-03-13](https://github.com/awslabs/aws-sdk-rust/releases/tag/release-2024-03-13) 
+ C\$1\$1 : [1.11.263](https://github.com/aws/aws-sdk-cpp/releases/tag/1.11.263) 
+ .NET : [3.7.734.0](https://github.com/aws/aws-sdk-net/releases/tag/3.7.734.0) 
+ PowerShell : [4.1.502](https://www.powershellgallery.com/packages/AWS.Tools.Common/4.1.502) 
+ PHP : [3.289.0](https://github.com/aws/aws-sdk-php/releases/tag/3.287.1) 

Pour vous assurer d’utiliser un kit SDK pris en charge, suivez les instructions d’installation relatives à votre SDK préféré de la page [Tools to Build on AWS](https://aws.amazon.com/tools/) lorsque vous créez vos conteneurs.

Pour obtenir la liste des modules complémentaires qui prennent en charge l’identité du pod EKS, consultez [Référence relative à la prise en charge de l’identité du pod](retreive-iam-info.md#pod-id-add-on-versions).

# Désactiver `IPv6` dans l’agent d’identité du pod EKS
Désactivation d'IPv6

## AWS Management Console


1. Pour désactiver `IPv6` dans l’agent d’identité du pod EKS, ajoutez la configuration suivante aux **Paramètres de configuration facultatifs** du module complémentaire EKS.

   1. Ouvrez la [console Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

   1. Dans le panneau de navigation de gauche, sélectionnez **Clusters**, puis sélectionnez le nom du cluster pour lequel vous souhaitez configurer le module complémentaire.

   1. Choisissez l'onglet **Modules complémentaires**.

   1. Cochez la case en haut à droite de la case du module complémentaire identité du pod EKS, puis sélectionnez **Modifier**.

   1. Sur la page **Configurer l’agent d’identité du pod EKS** :

      1. Sélectionnez la **version** que vous souhaitez utiliser. Il est recommandé de conserver la même version que celle de l’étape précédente et d’effectuer la mise à jour de la version et de la configuration séparément.

      1. Sélectionnez **Paramètres de configuration facultatifs**.

      1. Saisissez la clé JSON `"agent":` et la valeur d’un objet JSON imbriqué avec une clé `"additionalArgs":` dans **Valeurs de configuration**. Le texte obtenu doit être un objet JSON valide. Si cette clé et cette valeur sont les seules données de la zone de texte, entourez-les d'accolades `{ }`. L’exemple suivant montre que la politique réseau est activée :

         ```
         {
             "agent": {
                 "additionalArgs": {
                     "-b": "169.254.170.23"
                 }
             }
         }
         ```

         Cette configuration définit l’adresse `IPv4` comme seule adresse utilisée par l’agent.

   1. Pour appliquer la nouvelle configuration en remplaçant les pods de l’agent d’identité du pod EKS, sélectionnez **Enregistrer les modifications**.

      Amazon EKS applique les modifications aux modules complémentaires Amazon EKS à l’aide d’un *déploiement* du `DaemonSet` Kubernetes pour l’agent d’identité du pod EKS. Vous pouvez suivre l’état du déploiement dans l’**Historique des mises à jour** du module complémentaire, dans AWS Management Console, ainsi qu’à l’aide de `kubectl rollout status daemonset/eks-pod-identity-agent --namespace kube-system`.

       L’outil `kubectl rollout` propose les commandes suivantes :

      ```
      $ kubectl rollout
      
      history  -- View rollout history
      pause    -- Mark the provided resource as paused
      restart  -- Restart a resource
      resume   -- Resume a paused resource
      status   -- Show the status of the rollout
      undo     -- Undo a previous rollout
      ```

      Si le déploiement prend trop de temps, Amazon EKS annule automatiquement le déploiement, et un message indiquant un type de **Mise à jour du module complémentaire** avec un état **Échec** est ajouté à l’**Historique des mises à jour** du module complémentaire. Pour examiner tout problème, commencez par l’historique du déploiement, puis journalisez `kubectl logs` sur un pod de l’agent d’identité du pod EKS pour afficher les journaux de l’agent d’identité du pod EKS.

1. Si la nouvelle entrée dans **Historique des mises à jour** a le statut **Réussi**, cela signifie que le déploiement est terminé et que le module complémentaire utilise la nouvelle configuration dans tous les pods de l’agent d’identité du pod EKS.

## AWS CLI


1. Pour désactiver `IPv6` dans l’agent d’identité du pod EKS, ajoutez la configuration suivante aux **valeurs de configuration** du module complémentaire EKS.

   Exécutez la commande AWS CLI suivante. Remplacez `my-cluster` par le nom de votre cluster et l'ARN du rôle IAM par le rôle que vous utilisez.

   ```
   aws eks update-addon --cluster-name my-cluster --addon-name eks-pod-identity-agent \
       --resolve-conflicts PRESERVE --configuration-values '{"agent":{"additionalArgs": { "-b": "169.254.170.23"}}}'
   ```

   Cette configuration définit l’adresse `IPv4` comme seule adresse utilisée par l’agent.

   Amazon EKS applique les modifications aux modules complémentaires EKS à l’aide d’un *déploiement* du DaemonSet Kubernetes pour l’Agent d’identité du pod EKS. Vous pouvez suivre l’état du déploiement dans l’**Historique des mises à jour** du module complémentaire, dans AWS Management Console, ainsi qu’à l’aide de `kubectl rollout status daemonset/eks-pod-identity-agent --namespace kube-system`.

    L’outil `kubectl rollout` propose les commandes suivantes :

   ```
   kubectl rollout
   
   history  -- View rollout history
   pause    -- Mark the provided resource as paused
   restart  -- Restart a resource
   resume   -- Resume a paused resource
   status   -- Show the status of the rollout
   undo     -- Undo a previous rollout
   ```

   Si le déploiement prend trop de temps, Amazon EKS annule automatiquement le déploiement, et un message indiquant un type de **Mise à jour du module complémentaire** avec un état **Échec** est ajouté à l’**Historique des mises à jour** du module complémentaire. Pour examiner tout problème, commencez par l’historique du déploiement, puis journalisez `kubectl logs` sur un pod de l’agent d’identité du pod EKS pour afficher les journaux de l’agent d’identité du pod EKS.

# Créer un rôle IAM avec la politique d’approbation requise par l’identité du pod EKS
Rôle de l’identité du pod EKS

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowEksAuthToAssumeRoleForPodIdentity",
            "Effect": "Allow",
            "Principal": {
                "Service": "pods.eks.amazonaws.com"
            },
            "Action": [
                "sts:AssumeRole",
                "sts:TagSession"
            ]
        }
    ]
}
```

 ** `sts:AssumeRole` **   
L’identité du pod EKS utilise `AssumeRole` pour assumer le rôle IAM avant de transmettre les informations d’identification temporaires à vos pods.

 ** `sts:TagSession` **   
EKS Pod `TagSession` Identity inclut des *balises de session* dans les demandes adressées à AWS STS.

 **Conditions de configuration**   
Vous pouvez utiliser ces balises dans les *clés de condition* de la politique d’approbation pour restreindre les comptes de service, les espaces de noms et les clusters pouvant utiliser ce rôle. Pour obtenir la liste des balises de requête ajoutées par l’identité du pod, consultez [Activer ou désactiver les balises de session](pod-id-abac.md#pod-id-abac-tags).  
Par exemple, vous pouvez limiter les pods pouvant assumer le rôle IAM d’identité du pod à un `ServiceAccount` et un `Namespace` spécifiques à l’aide de la politique d’approbation suivante avec la `Condition` ajoutée :

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowEksAuthToAssumeRoleForPodIdentity",
            "Effect": "Allow",
            "Principal": {
                "Service": "pods.eks.amazonaws.com"
            },
            "Action": [
                "sts:AssumeRole",
                "sts:TagSession"
            ],
            "Condition": {
                "StringEquals": {
                    "aws:RequestTag/kubernetes-namespace": [
                        "Namespace"
                    ],
                    "aws:RequestTag/kubernetes-service-account": [
                        "ServiceAccount"
                    ]
                }
            }
        }
    ]
}
```

Pour obtenir la liste des clés de condition Amazon EKS, consultez la rubrique [Conditions définies par Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html#amazonelastickubernetesservice-policy-keys) de la *Référence de l'autorisation de service*. Pour savoir avec quelles actions et ressources vous pouvez utiliser une clé de condition, consultez la rubrique [Actions définies par Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html#amazonelastickubernetesservice-actions-as-permissions).