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.

# Exécutez des charges de travail dynamiques avec un stockage de données persistant en utilisant Amazon EFS sur Amazon EKS avec AWS Fargate
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate"></a>

*Ricardo Morais, Rodrigo Bersa et Lucio Pereira, Amazon Web Services*

## Résumé
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-summary"></a>

Ce modèle fournit des conseils pour activer Amazon Elastic File System (Amazon EFS) en tant que périphérique de stockage pour les conteneurs exécutés sur Amazon Elastic Kubernetes Service (Amazon EKS) en utilisant AWS Fargate pour provisionner vos ressources informatiques.

La configuration décrite dans ce modèle suit les meilleures pratiques en matière de sécurité et assure la sécurité au repos et la sécurité en transit par défaut. Pour chiffrer votre système de fichiers Amazon EFS, celui-ci utilise une clé AWS Key Management Service (AWS KMS), mais vous pouvez également spécifier un alias de clé qui gère le processus de création d'une clé KMS.

Vous pouvez suivre les étapes de ce modèle pour créer un espace de noms et un profil Fargate pour proof-of-concept une application (PoC), installer le pilote Amazon EFS Container Storage Interface (CSI) utilisé pour intégrer le cluster Kubernetes à Amazon EFS, configurer la classe de stockage et déployer l'application PoC. Ces étapes aboutissent à un système de fichiers Amazon EFS partagé entre plusieurs charges de travail Kubernetes et exécuté sur Fargate. Le modèle est accompagné de scripts qui automatisent ces étapes.

Vous pouvez utiliser ce modèle si vous souhaitez conserver les données dans vos applications conteneurisées et éviter toute perte de données lors des opérations de dimensionnement. Par exemple :
+ **DevOps outils** — Un scénario courant consiste à développer un outil d'intégration et de livraison continues (CI/CD) strategy. In this case, you can use Amazon EFS as a shared file system to store configurations among different instances of the CI/CD tool or to store a cache (for example, an Apache Maven repository) for pipeline stages among different instances of the CI/CDoutil).
+ **Serveurs Web** — Un scénario courant consiste à utiliser Apache comme serveur Web HTTP. Vous pouvez utiliser Amazon EFS en tant que système de fichiers partagé pour stocker des fichiers statiques partagés entre différentes instances du serveur Web. Dans cet exemple de scénario, les modifications sont appliquées directement au système de fichiers au lieu d'intégrer des fichiers statiques dans une image Docker.

## Conditions préalables et limitations
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-prereqs"></a>

**Conditions préalables**
+ Un compte AWS actif
+ Un cluster Amazon EKS existant avec Kubernetes version 1.17 ou ultérieure (testé jusqu'à la version 1.27)
+ Un système de fichiers Amazon EFS existant pour lier un Kubernetes StorageClass et approvisionner des systèmes de fichiers de manière dynamique
+ Autorisations d'administration du cluster
+ Contexte configuré pour pointer vers le cluster Amazon EKS souhaité

**Limites**
+ Certaines limites doivent être prises en compte lorsque vous utilisez Amazon EKS avec Fargate. Par exemple, l'utilisation de certaines constructions Kubernetes, telles que les conteneurs privilégiés, n'est DaemonSets pas prise en charge. Pour plus d'informations sur les limites de Fargate, consultez les considérations relatives à [AWS Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate.html#fargate-considerations) dans la documentation Amazon EKS.
+ Le code fourni avec ce modèle prend en charge les postes de travail qui exécutent Linux ou macOS.

**Versions du produit**
+ Interface de ligne de commande AWS (AWS CLI) version 2 ou ultérieure
+ pilote Amazon EFS CSI version 1.0 ou ultérieure (testé jusqu'à la version 2.4.8)
+ eksctl version 0.24.0 ou ultérieure (testé jusqu'à la version 0.158.0)
+ jq version 1.6 ou ultérieure
+ kubectl version 1.17 ou ultérieure (testé jusqu'à la version 1.27)
+ Kubernetes version 1.17 ou ultérieure (testé jusqu'à la version 1.27)

## Architecture
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-architecture"></a>

![\[Schéma d'architecture de l'exécution de charges de travail dynamiques avec stockage de données persistant à l'aide d'Amazon EFS\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/2487e285-269b-415b-a270-877f973e3aaf/images/ec8de63c-3307-4010-9e03-2bd7b9881fff.png)


L'architecture cible comprend l'infrastructure suivante :
+ Un cloud privé virtuel (VPC)
+ Deux zones de disponibilité
+ Un sous-réseau public avec une passerelle NAT qui fournit un accès à Internet
+ Un sous-réseau privé avec un cluster Amazon EKS et des cibles de montage Amazon EFS (également appelées *points de montage*)
+ Amazon EFS au niveau du VPC

L'infrastructure environnementale du cluster Amazon EKS est la suivante :
+ Profils AWS Fargate adaptés aux constructions Kubernetes au niveau de l'espace de noms
+ Un espace de noms Kubernetes avec :
  + Deux modules d'applications répartis dans les zones de disponibilité
  + Une réclamation de volume persistant (PVC) liée à un volume persistant (PV) au niveau du cluster
+ Un PV à l'échelle du cluster qui est lié au PVC dans l'espace de noms et qui pointe vers les cibles de montage Amazon EFS dans le sous-réseau privé, en dehors du cluster

## Outils
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-tools"></a>

**Services AWS**
+ [L'interface de ligne de commande AWS (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) est un outil open source que vous pouvez utiliser pour interagir avec les services AWS depuis la ligne de commande.
+ [Amazon Elastic File System (Amazon EFS)](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html) vous aide à créer et à configurer des systèmes de fichiers partagés dans le cloud AWS. Dans ce modèle, il fournit un système de fichiers simple, évolutif, entièrement géré et partagé à utiliser avec Amazon EKS.
+ [Amazon Elastic Kubernetes Service (Amazon](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) EKS) vous permet d'exécuter Kubernetes sur AWS sans avoir à installer ou à exploiter vos propres clusters.
+ [AWS Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate.html) est un moteur de calcul sans serveur pour Amazon EKS. Il crée et gère les ressources de calcul pour vos applications Kubernetes.
+ [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) vous aide à créer et à contrôler des clés cryptographiques afin de protéger vos données.

**Autres outils**
+ [Docker](https://www.docker.com/) est un ensemble de produits de plateforme en tant que service (PaaS) qui utilisent la virtualisation au niveau du système d'exploitation pour fournir des logiciels dans des conteneurs.
+ [eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) est un utilitaire de ligne de commande permettant de créer et de gérer des clusters Kubernetes sur Amazon EKS.
+ [kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) est une interface de ligne de commande qui vous permet d'exécuter des commandes sur des clusters Kubernetes.
+ [jq](https://stedolan.github.io/jq/download/) est un outil en ligne de commande pour analyser le JSON.

**Code**

Le code de ce modèle est fourni dans la [configuration de GitHub persistance avec Amazon EFS sur Amazon EKS à l'aide du référentiel AWS Fargate.](https://github.com/aws-samples/eks-efs-share-within-fargate) Les scripts sont organisés par épopée, dans les dossiers `epic01` suivants`epic06`, conformément à l'ordre indiqué dans la section [Epics](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-epics) de ce modèle.

## Bonnes pratiques
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-best-practices"></a>

L'architecture cible inclut les services et composants suivants, et elle suit les meilleures pratiques d'[AWS Well-Architected Framework](https://aws.amazon.com/architecture/well-architected/) :
+ Amazon EFS, qui fournit un système de fichiers NFS élastique simple, évolutif et entièrement géré. Il est utilisé comme système de fichiers partagé entre toutes les réplications de l'application PoC exécutées dans des pods, qui sont distribués dans les sous-réseaux privés du cluster Amazon EKS choisi.
+ Une cible de montage Amazon EFS pour chaque sous-réseau privé. Cela fournit une redondance par zone de disponibilité au sein du cloud privé virtuel (VPC) du cluster.
+ Amazon EKS, qui exécute les charges de travail Kubernetes. Vous devez provisionner un cluster Amazon EKS avant d'utiliser ce modèle, comme décrit dans la section [Conditions préalables](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-prereqs).
+ AWS KMS, qui fournit un chiffrement au repos pour le contenu stocké dans le système de fichiers Amazon EFS.
+ Fargate, qui gère les ressources de calcul des conteneurs afin que vous puissiez vous concentrer sur les exigences de l'entreprise plutôt que sur la charge de l'infrastructure. Le profil Fargate est créé pour tous les sous-réseaux privés. Il fournit une redondance par zone de disponibilité au sein du cloud privé virtuel (VPC) du cluster.
+ Kubernetes Pods, pour valider que le contenu peut être partagé, consommé et écrit par différentes instances d'une application.

## Épopées
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-epics"></a>

### Provisionner un cluster Amazon EKS (facultatif)
<a name="provision-an-amazon-eks-cluster-optional"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Créez un cluster Amazon EKS. | Si vous avez déjà déployé un cluster, passez à l'épopée suivante. Créez un cluster Amazon EKS dans votre compte AWS existant. Dans le [GitHub répertoire](https://github.com/aws-samples/eks-efs-share-within-fargate/tree/master/bootstrap), utilisez l'un des modèles pour déployer un cluster Amazon EKS à l'aide de Terraform ou eksctl. Pour plus d'informations, consultez la section [Création d'un cluster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html) dans la documentation Amazon EKS. Le modèle Terraform contient également des exemples montrant comment : lier des profils Fargate à votre cluster Amazon EKS, créer un système de fichiers Amazon EFS et déployer le pilote Amazon EFS CSI dans votre cluster Amazon EKS. | Administrateur AWS, administrateur Terraform ou eksctl, administrateur Kubernetes | 
| Exportez les variables d'environnement. | Exécutez le script env.sh. Cela fournit les informations requises lors des prochaines étapes.<pre>source ./scripts/env.sh<br />Inform the AWS Account ID:<br /><13-digit-account-id><br />Inform your AWS Region:<br /><aws-Region-code><br />Inform your Amazon EKS Cluster Name:<br /><amazon-eks-cluster-name><br />Inform the Amazon EFS Creation Token:<br /><self-genereated-uuid></pre>Si ce n'est pas encore le cas, vous pouvez obtenir toutes les informations demandées ci-dessus à l'aide des commandes CLI suivantes.<pre># ACCOUNT ID<br />aws sts get-caller-identity --query "Account" --output text</pre><pre># REGION CODE<br />aws configure get region</pre><pre># CLUSTER EKS NAME<br />aws eks list-clusters --query "clusters" --output text</pre><pre># GENERATE EFS TOKEN<br />uuidgen</pre> | Administrateur système AWS | 

### Création d'un espace de noms Kubernetes et d'un profil Fargate lié
<a name="create-a-kubernetes-namespace-and-a-linked-fargate-profile"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Créez un espace de noms Kubernetes et un profil Fargate pour les charges de travail des applications. | Créez un espace de noms pour recevoir les charges de travail des applications qui interagissent avec Amazon EFS. Exécutez le script `create-k8s-ns-and-linked-fargate-profile.sh`. Vous pouvez choisir d'utiliser un nom d'espace de noms personnalisé ou l'espace de noms `poc-efs-eks-fargate` fourni par défaut.**Avec un nom d'espace de noms d'application personnalisé :**<pre>export $APP_NAMESPACE=<CUSTOM_NAME><br />./scripts/epic01/create-k8s-ns-and-linked-fargate-profile.sh \<br />-c "$CLUSTER_NAME" -n "$APP_NAMESPACE"</pre>**Sans nom d'espace de noms d'application personnalisé :**<pre>./scripts/epic01/create-k8s-ns-and-linked-fargate-profile.sh \<br />    -c "$CLUSTER_NAME"</pre>où `$CLUSTER_NAME` est le nom de votre cluster Amazon EKS. Le `-n <NAMESPACE>` paramètre est facultatif ; si vous n'en êtes pas informé, un nom d'espace de noms généré par défaut sera fourni. | Utilisateur Kubernetes disposant des autorisations accordées | 

### Créer un système de fichiers Amazon EFS
<a name="create-an-amazon-efs-file-system"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Générez un jeton unique. | Amazon EFS nécessite un jeton de création pour garantir un fonctionnement idempotent (appeler l'opération avec le même jeton de création n'a aucun effet). Pour répondre à cette exigence, vous devez générer un jeton unique à l'aide d'une technique disponible. Par exemple, vous pouvez générer un identifiant unique universel (UUID) à utiliser comme jeton de création. | Administrateur système AWS | 
| Créez un système de fichiers Amazon EFS. | Créez le système de fichiers pour recevoir les fichiers de données lus et écrits par les charges de travail de l'application. Vous pouvez créer un système de fichiers chiffré ou non chiffré. (Il est recommandé que le code de ce modèle crée un système crypté pour activer le chiffrement au repos par défaut.) Vous pouvez utiliser une clé AWS KMS unique et symétrique pour chiffrer votre système de fichiers. Si aucune clé personnalisée n'est spécifiée, une clé gérée par AWS est utilisée.Utilisez le script create-efs.sh pour créer un système de fichiers Amazon EFS chiffré ou non chiffré, après avoir généré un jeton unique pour Amazon EFS.**Avec le chiffrement au repos, sans clé KMS :**<pre>./scripts/epic02/create-efs.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN"</pre>où `$CLUSTER_NAME` est le nom de votre cluster Amazon EKS et `$EFS_CREATION_TOKEN` est un jeton de création unique pour le système de fichiers.**Avec le chiffrement au repos, avec une clé KMS :**<pre>./scripts/epic02/create-efs.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN" \<br />    -k "$KMS_KEY_ALIAS"</pre>où `$CLUSTER_NAME` est le nom de votre cluster Amazon EKS, `$EFS_CREATION_TOKEN` est un jeton de création unique pour le système de fichiers et `$KMS_KEY_ALIAS` est l'alias de la clé KMS.**Sans cryptage :**<pre>./scripts/epic02/create-efs.sh -d \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN"</pre>où `$CLUSTER_NAME` est le nom de votre cluster Amazon EKS, `$EFS_CREATION_TOKEN` est un jeton de création unique pour le système de fichiers et `–d` désactive le chiffrement au repos. | Administrateur système AWS | 
| Créez un groupe de sécurité. | Créez un groupe de sécurité pour autoriser le cluster Amazon EKS à accéder au système de fichiers Amazon EFS. | Administrateur système AWS | 
| Mettez à jour la règle de trafic entrant pour le groupe de sécurité. | Mettez à jour les règles entrantes du groupe de sécurité pour autoriser le trafic entrant pour les paramètres suivants :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate.html) | Administrateur système AWS | 
| Ajoutez une cible de montage pour chaque sous-réseau privé. | Pour chaque sous-réseau privé du cluster Kubernetes, créez une cible de montage pour le système de fichiers et le groupe de sécurité. | Administrateur système AWS | 

### Installation des composants Amazon EFS dans le cluster Kubernetes
<a name="install-amazon-efs-components-into-the-kubernetes-cluster"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Déployez le pilote Amazon EFS CSI. | Déployez le pilote Amazon EFS CSI dans le cluster. Le pilote provisionne le stockage en fonction des demandes de volume persistantes créées par les applications. Exécutez le `create-k8s-efs-csi-sc.sh` script pour déployer le pilote Amazon EFS CSI et la classe de stockage dans le cluster.<pre>./scripts/epic03/create-k8s-efs-csi-sc.sh</pre>Ce script utilise l'`kubectl`utilitaire. Assurez-vous donc que le contexte a été configuré et qu'il pointe vers le cluster Amazon EKS souhaité. | Utilisateur Kubernetes disposant des autorisations accordées | 
| Déployez la classe de stockage. | Déployez la classe de stockage dans le cluster pour le fournisseur Amazon EFS (efs.csi.aws.com). | Utilisateur Kubernetes disposant des autorisations accordées | 

### Installez l'application PoC dans le cluster Kubernetes
<a name="install-the-poc-application-into-the-kubernetes-cluster"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Déployez le volume persistant. | Déployez le volume persistant et liez-le à la classe de stockage créée et à l'ID du système de fichiers Amazon EFS. L'application utilise le volume persistant pour lire et écrire du contenu. Vous pouvez spécifier n'importe quelle taille pour le volume persistant dans le champ de stockage. Kubernetes requiert ce champ, mais Amazon EFS étant un système de fichiers élastique, il n'impose aucune capacité du système de fichiers. Vous pouvez déployer le volume persistant avec ou sans chiffrement. (Le pilote Amazon EFS CSI active le chiffrement par défaut, conformément aux meilleures pratiques.) Exécutez le `deploy-poc-app.sh` script pour déployer le volume persistant, la demande de volume persistant et les deux charges de travail.**Avec le chiffrement en transit :**<pre>./scripts/epic04/deploy-poc-app.sh \<br />    -t "$EFS_CREATION_TOKEN"</pre>où `$EFS_CREATION_TOKEN` est le jeton de création unique pour le système de fichiers.**Sans chiffrement pendant le transport :**<pre>./scripts/epic04/deploy-poc-app.sh -d \<br />    -t "$EFS_CREATION_TOKEN"</pre>où se `$EFS_CREATION_TOKEN` trouve le jeton de création unique pour le système de fichiers et `–d` désactive le chiffrement en transit. | Utilisateur Kubernetes disposant des autorisations accordées | 
| Déployez la réclamation de volume persistante demandée par l'application. | Déployez la demande de volume persistant demandée par l'application et liez-la à la classe de stockage. Utilisez le même mode d'accès que le volume persistant que vous avez créé précédemment. Vous pouvez spécifier n'importe quelle taille pour la réclamation de volume persistant dans le champ de stockage. Kubernetes requiert ce champ, mais Amazon EFS étant un système de fichiers élastique, il n'impose aucune capacité du système de fichiers. | Utilisateur Kubernetes disposant des autorisations accordées | 
| Déployer la charge de travail 1. | Déployez le pod qui représente la charge de travail 1 de l'application. Cette charge de travail écrit du contenu dans le fichier`/data/out1.txt`. | Utilisateur Kubernetes disposant des autorisations accordées | 
| Déployer la charge de travail 2. | Déployez le pod qui représente la charge de travail 2 de l'application. Cette charge de travail écrit du contenu dans le fichier`/data/out2.txt`. | Utilisateur Kubernetes disposant des autorisations accordées | 

### Validation de la persistance, de la durabilité et de la capacité de partage du système de fichiers
<a name="validate-file-system-persistence-durability-and-shareability"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Vérifiez l'état du`PersistentVolume`. | Entrez la commande suivante pour vérifier l'état du`PersistentVolume`.<pre>kubectl get pv</pre>Pour un exemple de sortie, consultez la section [Informations supplémentaires](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-additional). | Utilisateur Kubernetes disposant des autorisations accordées | 
| Vérifiez l'état du`PersistentVolumeClaim`. | Entrez la commande suivante pour vérifier l'état du`PersistentVolumeClaim`.<pre>kubectl -n poc-efs-eks-fargate get pvc</pre>Pour un exemple de sortie, consultez la section [Informations supplémentaires](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-additional). | Utilisateur Kubernetes disposant des autorisations accordées | 
| Vérifiez que la charge de travail 1 peut écrire dans le système de fichiers. | Entrez la commande suivante pour vérifier que le workload 1 écrit sur`/data/out1.txt`.<pre>kubectl exec -ti poc-app1 -n poc-efs-eks-fargate -- tail -f /data/out1.txt</pre>Les résultats sont similaires aux suivants :<pre>...<br />Thu Sep  3 15:25:07 UTC 2023 - PoC APP 1<br />Thu Sep  3 15:25:12 UTC 2023 - PoC APP 1<br />Thu Sep  3 15:25:17 UTC 2023 - PoC APP 1<br />...</pre> | Utilisateur Kubernetes disposant des autorisations accordées | 
| Vérifiez que la charge de travail 2 peut écrire dans le système de fichiers. | Entrez la commande suivante pour vérifier que le workload 2 écrit sur`/data/out2.txt`.<pre>kubectl -n $APP_NAMESPACE exec -ti poc-app2 -- tail -f /data/out2.txt</pre>Les résultats sont similaires aux suivants :<pre>...<br />Thu Sep  3 15:26:48 UTC 2023 - PoC APP 2<br />Thu Sep  3 15:26:53 UTC 2023 - PoC APP 2<br />Thu Sep  3 15:26:58 UTC 2023 - PoC APP 2<br />...</pre> | Utilisateur Kubernetes disposant des autorisations accordées | 
| Vérifiez que la charge de travail 1 peut lire le fichier écrit par la charge de travail 2. | Entrez la commande suivante pour vérifier que la charge de travail 1 peut lire le `/data/out2.txt` fichier écrit par la charge de travail 2.<pre>kubectl exec -ti poc-app1 -n poc-efs-eks-fargate -- tail -n 3 /data/out2.txt</pre>Les résultats sont similaires aux suivants :<pre>...<br />Thu Sep  3 15:26:48 UTC 2023 - PoC APP 2<br />Thu Sep  3 15:26:53 UTC 2023 - PoC APP 2<br />Thu Sep  3 15:26:58 UTC 2023 - PoC APP 2<br />...</pre> | Utilisateur Kubernetes disposant des autorisations accordées | 
| Vérifiez que la charge de travail 2 peut lire le fichier écrit par la charge de travail 1. | Entrez la commande suivante pour vérifier que la charge de travail 2 peut lire le `/data/out1.txt` fichier écrit par la charge de travail 1.<pre>kubectl -n $APP_NAMESPACE exec -ti poc-app2 -- tail -n 3 /data/out1.txt</pre>Les résultats sont similaires aux suivants :<pre>...<br />Thu Sep  3 15:29:22 UTC 2023 - PoC APP 1<br />Thu Sep  3 15:29:27 UTC 2023 - PoC APP 1<br />Thu Sep  3 15:29:32 UTC 2023 - PoC APP 1<br />...</pre> | Utilisateur Kubernetes disposant des autorisations accordées | 
| Vérifiez que les fichiers sont conservés après avoir supprimé les composants de l'application. | Ensuite, vous utilisez un script pour supprimer les composants de l'application (volume persistant, réclamation de volume persistant et pods) et pour vérifier que les fichiers `/data/out1.txt` `/data/out2.txt` sont conservés dans le système de fichiers. Exécutez le script `validate-efs-content.sh` à l'aide de la commande suivante.<pre>./scripts/epic05/validate-efs-content.sh \<br />    -t "$EFS_CREATION_TOKEN"</pre>où `$EFS_CREATION_TOKEN` est le jeton de création unique pour le système de fichiers.Les résultats sont similaires aux suivants :<pre>pod/poc-app-validation created<br />Waiting for pod get Running state...<br />Waiting for pod get Running state...<br />Waiting for pod get Running state...<br />Results from execution of 'find /data' on validation process pod:<br />/data<br />/data/out2.txt<br />/data/out1.txt</pre> | Utilisateur Kubernetes avec autorisations accordées, administrateur système | 

### Surveiller les opérations
<a name="monitor-operations"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Surveillez les journaux des applications. | Dans le cadre d'une opération du deuxième jour, envoyez les journaux des applications à Amazon CloudWatch pour surveillance. | Administrateur système AWS, utilisateur de Kubernetes avec autorisations accordées | 
| Surveillez les conteneurs Amazon EKS et Kubernetes avec Container Insights. | Dans le cadre d'une opération de deux jours, surveillez les systèmes Amazon EKS et Kubernetes à l'aide d'Amazon Container Insights. CloudWatch Cet outil collecte, agrège et résume les métriques des applications conteneurisées à différents niveaux et dimensions. Pour plus d'informations, consultez la section [Ressources connexes](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-resources). | Administrateur système AWS, utilisateur de Kubernetes avec autorisations accordées | 
| Surveillez Amazon EFS avec CloudWatch. | Dans le cadre d'une opération de deux jours, surveillez les systèmes de fichiers à l'aide d'Amazon CloudWatch, qui collecte et traite les données brutes d'Amazon EFS pour en faire des métriques lisibles en temps quasi réel. Pour plus d'informations, consultez la section [Ressources connexes](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-resources). | Administrateur système AWS | 

### nettoyer des ressources ;
<a name="clean-up-resources"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Nettoyez toutes les ressources créées pour le modèle. | Une fois ce schéma terminé, nettoyez toutes les ressources afin d'éviter d'avoir à payer des frais AWS. Exécutez le `clean-up-resources.sh` script pour supprimer toutes les ressources une fois que vous avez fini d'utiliser l'application PoC. Complétez l'une des options suivantes.**Avec le chiffrement au repos, avec une clé KMS :**<pre>./scripts/epic06/clean-up-resources.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN" \<br />    -k "$KMS_KEY_ALIAS"</pre>où `$CLUSTER_NAME` est le nom de votre cluster Amazon EKS, `$EFS_CREATION_TOKEN` le jeton de création du système de fichiers et `$KMS_KEY_ALIAS` l'alias de la clé KMS.**Sans chiffrement au repos :**<pre>./scripts/epic06/clean-up-resources.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN"</pre>où `$CLUSTER_NAME` est le nom de votre cluster Amazon EKS et `$EFS_CREATION_TOKEN` le jeton de création du système de fichiers. | Utilisateur Kubernetes avec autorisations accordées, administrateur système | 

## Ressources connexes
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-resources"></a>

**Références**
+ [AWS Fargate pour Amazon EKS est désormais compatible avec Amazon](https://aws.amazon.com/blogs/aws/new-aws-fargate-for-amazon-eks-now-supports-amazon-efs/) EFS (annonce)
+ [Comment capturer les journaux d'applications lors de l'utilisation d'Amazon EKS sur AWS Fargate](https://aws.amazon.com/blogs/containers/how-to-capture-application-logs-when-using-amazon-eks-on-aws-fargate/) (article de blog)
+ [Utilisation de Container Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContainerInsights.html) ( CloudWatch documentation Amazon)
+ [Configuration de Container Insights sur Amazon EKS et Kubernetes (documentation Amazon)](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/deploy-container-insights-EKS.html) CloudWatch 
+ [Métriques Amazon EKS et Kubernetes Container Insights (documentation Amazon)](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Container-Insights-metrics-EKS.html) CloudWatch 
+ [Surveillance d'Amazon EFS avec Amazon CloudWatch](https://docs.aws.amazon.com/efs/latest/ug/monitoring-cloudwatch.html) (documentation Amazon EFS)

**GitHub tutoriels et exemples**
+ [Provisionnement statique](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/static_provisioning/README.md)
+ [Chiffrement en transit](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/encryption_in_transit/README.md)
+ [Accès au système de fichiers à partir de plusieurs modules](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/multiple_pods/README.md)
+ [Utilisation d'Amazon EFS dans StatefulSets](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/statefulset/README.md)
+ [Sous-chemins de montage](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/volume_path/README.md)
+ [Utilisation des points d'accès Amazon EFS](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/access_points/README.md)
+ [Blueprints Amazon EKS pour Terraform](https://aws-ia.github.io/terraform-aws-eks-blueprints/)

**Outils nécessaires**
+ [Installation de la version 2 de l'interface de ligne de commande AWS](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html)
+ [Installation d'eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)
+ [Installation de kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
+ [Installation de jq](https://stedolan.github.io/jq/download/)

## Informations supplémentaires
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-additional"></a>

Voici un exemple de sortie de la `kubectl get pv` commande.

```
NAME         CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                             STORAGECLASS   REASON   AGE
poc-app-pv   1Mi        RWX            Retain           Bound    poc-efs-eks-fargate/poc-app-pvc   efs-sc                  3m56s
```

Voici un exemple de sortie de la `kubectl -n poc-efs-eks-fargate get pvc` commande.

```
NAME          STATUS   VOLUME       CAPACITY   ACCESS MODES   STORAGECLASS   AGE
poc-app-pvc   Bound    poc-app-pv   1Mi        RWX            efs-sc         4m34s
```