**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.

# Déployer un exemple de charge de travail avec état dans le mode automatique EKS
<a name="sample-storage-workload"></a>

Ce tutoriel vous guidera dans le déploiement d’un exemple d’application avec état dans votre cluster du mode automatique EKS. L’application écrit des horodatages dans un volume persistant, démontrant ainsi les capacités de provisionnement et de persistance automatiques des volumes EBS du mode automatique EKS.

## Prérequis
<a name="_prerequisites"></a>
+ Un cluster du mode automatique EKS
+ L’interface AWS CLI configurée avec les autorisations appropriées
+  `kubectl` installé et configuré
  + Pour de plus amples informations, consultez [Configuration pour utiliser Amazon EKS](setting-up.md).

## Étape 1 : configurer votre environnement
<a name="_step_1_configure_your_environment"></a>

1. Définissez vos variables d’environnement :

   ```
   export CLUSTER_NAME=my-auto-cluster
   export AWS_REGION="us-west-2"
   ```

1. Mettez à jour votre kubeconfig :

   ```
   aws eks update-kubeconfig --name "${CLUSTER_NAME}"
   ```

## Étape 2 : créer la classe de stockage
<a name="_step_2_create_the_storage_class"></a>

La `StorageClass` définit la manière dont le mode automatique EKS provisionnera les volumes EBS.

Le mode automatique EKS ne crée pas de `StorageClass` pour vous. Vous devez créer une `StorageClass` faisant référence à `ebs.csi.eks.amazonaws.com` pour utiliser les fonctionnalités de stockage du mode automatique EKS.

1. Créez un fichier nommé `storage-class.yaml`:

   ```
   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: auto-ebs-sc
     annotations:
       storageclass.kubernetes.io/is-default-class: "true"
   provisioner: ebs.csi.eks.amazonaws.com
   volumeBindingMode: WaitForFirstConsumer
   parameters:
     type: gp3
     encrypted: "true"
   ```

1. Appliquez le `StorageClass` :

   ```
   kubectl apply -f storage-class.yaml
   ```

 **Composants clés :** 
+  `provisioner: ebs.csi.eks.amazonaws.com` : utilise le mode automatique EKS
+  `volumeBindingMode: WaitForFirstConsumer` : retarde la création du volume jusqu’à ce qu’un pod en ait besoin
+  `type: gp3` : spécifie le type de volume EBS
+  `encrypted: "true"` : EBS utilisera la clé `aws/ebs` par défaut pour activer le chiffrement sur les volumes créés avec cette classe. Cette action est facultative, mais recommandée.
+  `storageclass.kubernetes.io/is-default-class: "true"` : Kubernetes utilisera cette classe de stockage par défaut, à moins que vous ne spécifiiez une autre classe de volume dans une demande de volume persistant. Soyez prudent lorsque vous définissez cette valeur si vous migrez depuis un autre contrôleur de stockage. (facultatif)

## Étape 3 : créer la revendication de volume persistant
<a name="_step_3_create_the_persistent_volume_claim"></a>

La PVC demande du stockage à la `StorageClass`.

1. Créez un fichier nommé `pvc.yaml`:

   ```
   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: auto-ebs-claim
   spec:
     accessModes:
       - ReadWriteOnce
     storageClassName: auto-ebs-sc
     resources:
       requests:
         storage: 8Gi
   ```

1. Appliquez le PVC :

   ```
   kubectl apply -f pvc.yaml
   ```

 **Composants clés :** 
+  `accessModes: ReadWriteOnce` : le volume peut être monté par un nœud à la fois
+  `storage: 8Gi` : demande un volume de 8 Gio
+  `storageClassName: auto-ebs-sc` : fait référence à la `StorageClass` que nous avons créée

## Étape 4 : déployer l’application
<a name="_step_4_deploy_the_application"></a>

Le déploiement exécute un conteneur qui écrit des horodatages sur le volume persistant.

1. Créez un fichier nommé `deployment.yaml`:

   ```
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: inflate-stateful
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: inflate-stateful
     template:
       metadata:
         labels:
           app: inflate-stateful
       spec:
         terminationGracePeriodSeconds: 0
         nodeSelector:
           eks.amazonaws.com/compute-type: auto
         containers:
           - name: bash
             image: public.ecr.aws/docker/library/bash:4.4
             command: ["/usr/local/bin/bash"]
             args: ["-c", "while true; do echo $(date -u) >> /data/out.txt; sleep 60; done"]
             resources:
               requests:
                 cpu: "1"
             volumeMounts:
               - name: persistent-storage
                 mountPath: /data
         volumes:
           - name: persistent-storage
             persistentVolumeClaim:
               claimName: auto-ebs-claim
   ```

1. Appliquez le déploiement :

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

 **Composants clés :** 
+ Conteneur bash simple qui écrit des horodatages dans un fichier
+ Monte le PVC à `/data` 
+ Demande 1 cœur de processeur
+ Utilise le sélecteur de nœuds pour les nœuds gérés par EKS

## Étape 5 : vérifier la configuration
<a name="_step_5_verify_the_setup"></a>

1. Vérifiez que le pod est en cours d’exécution :

   ```
   kubectl get pods -l app=inflate-stateful
   ```

1. Vérifiez que le PVC est lié :

   ```
   kubectl get pvc auto-ebs-claim
   ```

1. Vérifiez le volume EBS :

   ```
   # Get the PV name
   PV_NAME=$(kubectl get pvc auto-ebs-claim -o jsonpath='{.spec.volumeName}')
   # Describe the EBS volume
   aws ec2 describe-volumes \
     --filters Name=tag:CSIVolumeName,Values=${PV_NAME}
   ```

1. Vérifiez que les données sont écrites :

   ```
   kubectl exec "$(kubectl get pods -l app=inflate-stateful \
     -o=jsonpath='{.items[0].metadata.name}')" -- \
     cat /data/out.txt
   ```

## Étape 6 : nettoyage
<a name="_step_6_cleanup"></a>

Exécutez la commande suivante pour supprimer toutes les ressources créées dans ce tutoriel :

```
# Delete all resources in one command
kubectl delete deployment/inflate-stateful pvc/auto-ebs-claim storageclass/auto-ebs-sc
```

## Ce qui se passe dans les coulisses
<a name="_whats_happening_behind_the_scenes"></a>

1. Le PVC demande du stockage à la `StorageClass` 

1. Lorsque le pod est planifié :

   1. Le mode automatique EKS provisionne un volume EBS

   1. Crée un PersistentVolume

   1. Attache le volume au nœud

1. Le pod monte le volume et commence à écrire les horodatages

## Contrôleur d’instantané
<a name="_snapshot_controller"></a>

Le mode automatique EKS est compatible avec le Kubernetes CSI Snapshotter, également appelé contrôleur d’instantané. Cependant, le mode automatique EKS n’inclut pas le contrôleur d’instantané. Vous êtes responsable de l’installation et de la configuration du contrôleur d’instantané. Pour de plus amples informations, consultez [Activer la fonctionnalité d’instantané pour les volumes CSI](csi-snapshot-controller.md).

Veuillez consulter la classe `VolumeSnapshotClass` suivante qui fait référence à la capacité de stockage du mode automatique EKS.

```
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: auto-ebs-vsclass
driver: ebs.csi.eks.amazonaws.com
deletionPolicy: Delete
```

 [En savoir plus sur le contrôleur de snapshots CSI Kubernetes.](https://github.com/kubernetes-csi/external-snapshotter/blob/master/README.md#usage)