**Contribuisci a migliorare questa pagina** 

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Per contribuire a questa guida per l'utente, scegli il GitHub link **Modifica questa pagina** nel riquadro destro di ogni pagina.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Implementazione di un carico di lavoro stateful esemplificativo in modalità automatica EKS
<a name="sample-storage-workload"></a>

Questo tutorial ti guiderà nella distribuzione di un’applicazione stateful esemplificativa nel tuo cluster di modalità automatica EKS. L’applicazione scrive marche temporali su un volume persistente, dimostrando le funzionalità automatiche di provisioning e persistenza dei volumi EBS di modalità automatica EKS.

## Prerequisiti
<a name="_prerequisites"></a>
+ Un cluster in modalità automatica EKS
+ AWS CLI configurata con le autorizzazioni appropriate
+  Installazione e configurazione di `kubectl`.
  + Per ulteriori informazioni, consulta [Configurazione per l’utilizzo di Amazon EKS](setting-up.md).

## Passaggio 1: configurazione dell’ambiente
<a name="_step_1_configure_your_environment"></a>

1. Imposta le variabili di ambiente:

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

1. Aggiorna kubeconfig:

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

## Passaggio 2: creazione della classe di archiviazione
<a name="_step_2_create_the_storage_class"></a>

`StorageClass` definisce in che modo la modalità automatica EKS fornirà i volumi EBS.

Modalità automatica EKS non crea un `StorageClass` per te. Devi creare una `StorageClass` che faccia riferimento a `ebs.csi.eks.amazonaws.com` per utilizzare la funzionalità di archiviazione di modalità automatica EKS.

1. Creare un file denominato `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. Applica: `StorageClass`

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

 **componenti chiave** 
+  `provisioner: ebs.csi.eks.amazonaws.com`: utilizza modalità automatica EKS
+  `volumeBindingMode: WaitForFirstConsumer`: ritarda la creazione del volume fino a quando un pod non ne ha bisogno
+  `type: gp3`: specifica il tipo di volume EBS
+  `encrypted: "true"`: EBS utilizzerà la chiave `aws/ebs` predefinita per crittografare i volumi creati con questa classe. Questo passaggio è facoltativo, ma è consigliato.
+  `storageclass.kubernetes.io/is-default-class: "true"`: Kubernetes userà questa classe di archiviazione per impostazione predefinita, a meno che non sia specificata una classe di volume diversa su una dichiarazione di volume persistente. Fai attenzione quando imposti questo valore se stai migrando da un altro controller di archiviazione (facoltativo).

## Passaggio 3: creazione della dichiarazione di volume persistente
<a name="_step_3_create_the_persistent_volume_claim"></a>

Il PVC richiede l’archiviazione da `StorageClass`.

1. Creare un file denominato `pvc.yaml`:

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

1. Applica il PVC:

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

 **Componenti chiave:** 
+  `accessModes: ReadWriteOnce`: il volume può essere montato da un nodo alla volta
+  `storage: 8Gi`: richiede un volume da 8 GiB
+  `storageClassName: auto-ebs-sc`: riferimenti su `StorageClass` abbiamo creato

## Passaggio 4: implementare un’applicazione
<a name="_step_4_deploy_the_application"></a>

L’implementazione esegue un container che scrive marche temporali nel volume persistente.

1. Creare un file denominato `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. Applica l’implementazione:

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

 **Componenti chiave:** 
+ Semplice container bash che scrive una marca temporale su un file
+ Monta il PVC su `/data` 
+ Richiede 1 core CPU
+ Utilizza il selettore di nodi per i nodi gestiti da EKS

## Passaggio 5: verificare la configurazione
<a name="_step_5_verify_the_setup"></a>

1. Verifica che il pod sia in esecuzione:

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

1. Verifica che il PVC sia legato:

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

1. Controlla il 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. Verifica che i dati siano scritti:

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

## Passaggio 6: pulizia
<a name="_step_6_cleanup"></a>

Eseguire il comando riportato di seguito per rimuovere tutte le risorse create in questo tutorial:

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

## Cosa succede dietro le quinte
<a name="_whats_happening_behind_the_scenes"></a>

1. Il PVC richiede l’archiviazione da `StorageClass` 

1. Quando è il pod è pianificato:

   1. La modalità automatica EKS fornisce un volume EBS

   1. Crea PersistentVolume

   1. Collega il volume al nodo

1. Il pod monta il volume e inizia a scrivere le marche temporali

## Controller di snapshot
<a name="_snapshot_controller"></a>

La modalità automatica EKS è compatibile con lo Snapshotter di CSI Kubernetes, noto anche come controller di snapshot. Tuttavia, la modalità automatica EKS non include il controller di snapshot. L’utente è responsabile dell’installazione e della configurazione del controller di snapshot. Per ulteriori informazioni, consulta [Abilitare la funzionalità snapshot per i volumi CSI](csi-snapshot-controller.md).

Leggi quanto segue `VolumeSnapshotClass` che fa riferimento alla capacità di archiviazione della modalità automatica EKS.

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

 [Scopri di più su Snapshotter di CSI Kubernetes.](https://github.com/kubernetes-csi/external-snapshotter/blob/master/README.md#usage)