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

# Esegui carichi di lavoro con stato con storage persistente dei dati utilizzando Amazon EFS su Amazon EKS con 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 e Lucio Pereira, Amazon Web Services*

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

Questo modello fornisce indicazioni per abilitare Amazon Elastic File System (Amazon EFS) come dispositivo di storage per contenitori in esecuzione su Amazon Elastic Kubernetes Service (Amazon EKS) utilizzando AWS Fargate per il provisioning delle risorse di calcolo.

La configurazione descritta in questo modello segue le migliori pratiche di sicurezza e fornisce sicurezza a riposo e sicurezza in transito per impostazione predefinita. Per crittografare il tuo file system Amazon EFS, utilizza una chiave AWS Key Management Service (AWS KMS), ma puoi anche specificare un alias chiave che esegua il processo di creazione di una chiave KMS.

Puoi seguire i passaggi di questo schema per creare uno spazio dei nomi e un profilo Fargate per un'applicazione proof-of-concept (PoC), installare il driver Amazon EFS Container Storage Interface (CSI) utilizzato per integrare il cluster Kubernetes con Amazon EFS, configurare la classe di storage e distribuire l'applicazione PoC. Questi passaggi portano a un file system Amazon EFS condiviso tra più carichi di lavoro Kubernetes, in esecuzione su Fargate. Lo schema è accompagnato da script che automatizzano questi passaggi.

È possibile utilizzare questo modello se si desidera la persistenza dei dati nelle applicazioni containerizzate ed evitare la perdita di dati durante le operazioni di scalabilità. Esempio:
+ **DevOps strumenti** — Uno scenario comune è lo sviluppo di uno strumento di integrazione e distribuzione continua (strumento). 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/CD
+ **Server Web**: uno scenario comune consiste nell'utilizzare Apache come server Web HTTP. Puoi usare Amazon EFS come file system condiviso per archiviare file statici condivisi tra diverse istanze del server Web. In questo scenario di esempio, le modifiche vengono applicate direttamente al file system anziché inserire file statici in un'immagine Docker.

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

**Prerequisiti**
+ Un account AWS attivo
+ Un cluster Amazon EKS esistente con Kubernetes versione 1.17 o successiva (testato fino alla versione 1.27)
+ Un file system Amazon EFS esistente per associare un Kubernetes StorageClass e fornire i file system in modo dinamico
+ Autorizzazioni di amministrazione del cluster
+ Contesto configurato per puntare al cluster Amazon EKS desiderato

**Limitazioni**
+ Ci sono alcune limitazioni da considerare quando usi Amazon EKS con Fargate. Ad esempio, l'uso di alcuni costrutti Kubernetes, come DaemonSets i contenitori privilegiati, non è supportato. Per ulteriori informazioni sulle limitazioni di Fargate, consulta le [considerazioni su AWS Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate.html#fargate-considerations) nella documentazione di Amazon EKS.
+ Il codice fornito con questo pattern supporta le workstation che eseguono Linux o macOS.

**Versioni del prodotto**
+ AWS Command Line Interface (AWS CLI) versione 2 o successiva
+ Driver Amazon EFS CSI versione 1.0 o successiva (testato fino alla versione 2.4.8)
+ eksctl versione 0.24.0 o successiva (testato fino alla versione 0.158.0)
+ jq versione 1.6 o successiva
+ kubectl versione 1.17 o successiva (testata fino alla versione 1.27)
+ Kubernetes versione 1.17 o successiva (testato fino alla versione 1.27)

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

![\[Diagramma dell'architettura dell'esecuzione di carichi di lavoro con stato con storage persistente dei dati utilizzando Amazon EFS\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/2487e285-269b-415b-a270-877f973e3aaf/images/ec8de63c-3307-4010-9e03-2bd7b9881fff.png)


L'architettura di destinazione è composta dalla seguente infrastruttura:
+ Un cloud privato virtuale (VPC)
+ Due zone di disponibilità
+ Una sottorete pubblica con un gateway NAT che fornisce l'accesso a Internet
+ Una sottorete privata con un cluster Amazon EKS e target di montaggio Amazon EFS (noti anche come *punti di montaggio*)
+ Amazon EFS a livello di VPC

Di seguito è riportata l'infrastruttura ambientale per il cluster Amazon EKS:
+ Profili AWS Fargate che supportano i costrutti Kubernetes a livello di namespace
+ Uno spazio dei nomi Kubernetes con:
  + Due pod applicativi distribuiti tra le zone di disponibilità
  + Una dichiarazione di volume persistente (PVC) associata a un volume persistente (PV) a livello di cluster
+ Un PV a livello di cluster associato al PVC nello spazio dei nomi e che punta alle destinazioni di montaggio di Amazon EFS nella sottorete privata, all'esterno del cluster

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

**Servizi AWS**
+ [AWS Command Line Interface (AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)) è uno strumento open source che puoi usare per interagire con i servizi AWS dalla riga di comando.
+ [Amazon Elastic File System (Amazon EFS)](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html) ti aiuta a creare e configurare file system condivisi nel cloud AWS. In questo modello, fornisce un file system semplice, scalabile, completamente gestito e condiviso da utilizzare con Amazon EKS.
+ [Amazon Elastic Kubernetes Service (Amazon](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) EKS) ti aiuta a eseguire Kubernetes su AWS senza dover installare o gestire i tuoi cluster.
+ [AWS Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate.html) è un motore di elaborazione serverless per Amazon EKS. Crea e gestisce risorse di calcolo per le tue applicazioni Kubernetes.
+ [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) ti aiuta a creare e controllare chiavi crittografiche per proteggere i tuoi dati.

**Altri strumenti**
+ [Docker](https://www.docker.com/) è un insieme di prodotti Platform as a Service (PaaS) che utilizzano la virtualizzazione a livello di sistema operativo per fornire software in container.
+ [eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) è un'utilità da riga di comando per la creazione e la gestione di cluster Kubernetes su Amazon EKS.
+ [kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) è un'interfaccia a riga di comando che ti aiuta a eseguire comandi sui cluster Kubernetes.
+ [jq è uno strumento a riga di comando per l'analisi di JSON.](https://stedolan.github.io/jq/download/)

**Codice**

Il codice per questo pattern è fornito nella [configurazione di GitHub persistenza con Amazon EFS su Amazon EKS utilizzando il repository AWS Fargate](https://github.com/aws-samples/eks-efs-share-within-fargate). Gli script sono organizzati da epic, nelle cartelle `epic01` Through`epic06`, corrispondenti all'ordine nella sezione [Epics](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-epics) di questo schema.

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

L'architettura di destinazione include i seguenti servizi e componenti e segue le best practice di [AWS Well-Architected](https://aws.amazon.com/architecture/well-architected/) Framework:
+ Amazon EFS, che fornisce un file system NFS elastico semplice, scalabile e completamente gestito. Viene utilizzato come file system condiviso tra tutte le repliche dell'applicazione PoC in esecuzione nei pod, distribuiti nelle sottoreti private del cluster Amazon EKS scelto.
+ Una destinazione di montaggio Amazon EFS per ogni sottorete privata. Ciò fornisce ridondanza per zona di disponibilità all'interno del cloud privato virtuale (VPC) del cluster.
+ Amazon EKS, che esegue i carichi di lavoro Kubernetes. È necessario effettuare il provisioning di un cluster Amazon EKS prima di utilizzare questo modello, come descritto nella sezione [Prerequisiti](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-prereqs).
+ AWS KMS, che fornisce la crittografia a riposo per i contenuti archiviati nel file system Amazon EFS.
+ Fargate, che gestisce le risorse di elaborazione per i container in modo che tu possa concentrarti sui requisiti aziendali anziché sul carico dell'infrastruttura. Il profilo Fargate viene creato per tutte le sottoreti private. Fornisce ridondanza per zona di disponibilità all'interno del cloud privato virtuale (VPC) del cluster.
+ Kubernetes Pods, per verificare che i contenuti possano essere condivisi, consumati e scritti da diverse istanze di un'applicazione.

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

### Esegui il provisioning di un cluster Amazon EKS (opzionale)
<a name="provision-an-amazon-eks-cluster-optional"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Crea un cluster Amazon EKS. | Se hai già un cluster distribuito, passa alla prossima epopea. Crea un cluster Amazon EKS nel tuo account AWS esistente. Nella [GitHub directory](https://github.com/aws-samples/eks-efs-share-within-fargate/tree/master/bootstrap), utilizza uno dei modelli per distribuire un cluster Amazon EKS utilizzando Terraform o eksctl. Per ulteriori informazioni, consulta [Creazione di un cluster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html) nella documentazione di Amazon EKS. Nel modello Terraform, ci sono anche esempi che mostrano come: collegare i profili Fargate al cluster Amazon EKS, creare un file system Amazon EFS e distribuire il driver CSI Amazon EFS nel cluster Amazon EKS. | Amministratore AWS, amministratore Terraform o eksctl, amministratore Kubernetes | 
| Esporta variabili di ambiente. | Esegui lo script env.sh. Ciò fornisce le informazioni richieste nei passaggi successivi.<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>Se non ancora indicato, puoi ottenere tutte le informazioni richieste sopra con i seguenti comandi CLI.<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> | Amministratore di sistema AWS | 

### Crea un namespace Kubernetes e un profilo Fargate collegato
<a name="create-a-kubernetes-namespace-and-a-linked-fargate-profile"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Crea uno spazio dei nomi Kubernetes e un profilo Fargate per i carichi di lavoro delle applicazioni. | Crea uno spazio dei nomi per ricevere i carichi di lavoro delle applicazioni che interagiscono con Amazon EFS. Eseguire lo script `create-k8s-ns-and-linked-fargate-profile.sh`. Puoi scegliere di utilizzare un nome di namespace personalizzato o lo spazio dei nomi fornito di default. `poc-efs-eks-fargate`**Con un nome di namespace dell'applicazione personalizzato:**<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>**Senza un nome di namespace dell'applicazione personalizzato:**<pre>./scripts/epic01/create-k8s-ns-and-linked-fargate-profile.sh \<br />    -c "$CLUSTER_NAME"</pre>`$CLUSTER_NAME`dov'è il nome del tuo cluster Amazon EKS. Il `-n <NAMESPACE>` parametro è facoltativo; se non viene informato, verrà fornito un nome di namespace generato di default. | Utente Kubernetes con autorizzazioni concesse | 

### Creare un file system Amazon EFS
<a name="create-an-amazon-efs-file-system"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Genera un token unico. | Amazon EFS richiede un token di creazione per garantire un funzionamento idempotente (la chiamata all'operazione con lo stesso token di creazione non ha alcun effetto). Per soddisfare questo requisito, è necessario generare un token univoco utilizzando una tecnica disponibile. Ad esempio, è possibile generare un identificatore univoco universale (UUID) da utilizzare come token di creazione. | Amministratore di sistema AWS | 
| Crea un file system Amazon EFS. | Crea il file system per ricevere i file di dati letti e scritti dai carichi di lavoro dell'applicazione. È possibile creare un file system crittografato o non crittografato. (Come procedura ottimale, il codice di questo modello crea un sistema crittografato per abilitare la crittografia a riposo per impostazione predefinita.) Puoi utilizzare una chiave AWS KMS unica e simmetrica per crittografare il tuo file system. Se non viene specificata una chiave personalizzata, viene utilizzata una chiave gestita AWS.Utilizza lo script create-efs.sh per creare un file system Amazon EFS crittografato o non crittografato, dopo aver generato un token univoco per Amazon EFS.**Con crittografia inattiva, senza chiave KMS:**<pre>./scripts/epic02/create-efs.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN"</pre>dove `$CLUSTER_NAME` è il nome del tuo cluster Amazon EKS ed `$EFS_CREATION_TOKEN` è un token di creazione univoco per il file system.**Con crittografia inattiva, con una chiave KMS:**<pre>./scripts/epic02/create-efs.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN" \<br />    -k "$KMS_KEY_ALIAS"</pre>dove `$CLUSTER_NAME` è il nome del cluster Amazon EKS, `$EFS_CREATION_TOKEN` è un token di creazione univoco per il file system ed `$KMS_KEY_ALIAS` è l'alias per la chiave KMS.**Senza crittografia:**<pre>./scripts/epic02/create-efs.sh -d \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN"</pre>dove `$CLUSTER_NAME` è il nome del tuo cluster Amazon EKS, `$EFS_CREATION_TOKEN` è un token di creazione univoco per il file system e `–d` disabilita la crittografia a riposo. | Amministratore di sistema AWS | 
| Creare un gruppo di sicurezza. | Crea un gruppo di sicurezza per consentire al cluster Amazon EKS di accedere al file system Amazon EFS. | Amministratore di sistema AWS | 
| Aggiorna la regola in entrata per il gruppo di sicurezza. | Aggiorna le regole in entrata del gruppo di sicurezza per consentire il traffico in entrata per le seguenti impostazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate.html) | Amministratore di sistema AWS | 
| Aggiungi una destinazione di montaggio per ogni sottorete privata. | Per ogni sottorete privata del cluster Kubernetes, crea una destinazione di montaggio per il file system e il gruppo di sicurezza. | Amministratore di sistema AWS | 

### Installa i componenti Amazon EFS nel cluster Kubernetes
<a name="install-amazon-efs-components-into-the-kubernetes-cluster"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Implementa il driver CSI di Amazon EFS. | Implementa il driver CSI Amazon EFS nel cluster. Il driver effettua il provisioning dello storage in base alle dichiarazioni di volume persistenti create dalle applicazioni. Esegui lo `create-k8s-efs-csi-sc.sh` script per distribuire il driver CSI di Amazon EFS e la classe di storage nel cluster.<pre>./scripts/epic03/create-k8s-efs-csi-sc.sh</pre>Questo script utilizza l'`kubectl`utilità, quindi assicurati che il contesto sia stato configurato e punti al cluster Amazon EKS desiderato. | Utente Kubernetes con autorizzazioni concesse | 
| Implementare la classe di archiviazione. | Implementa la classe di storage nel cluster per il provisioner Amazon EFS (efs.csi.aws.com). | Utente Kubernetes con autorizzazioni concesse | 

### Installa l'applicazione PoC nel cluster Kubernetes
<a name="install-the-poc-application-into-the-kubernetes-cluster"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Distribuisci il volume persistente. | Implementa il volume persistente e collegalo alla classe di storage creata e all'ID del file system Amazon EFS. L'applicazione utilizza il volume persistente per leggere e scrivere contenuti. È possibile specificare qualsiasi dimensione per il volume persistente nel campo di archiviazione. Kubernetes richiede questo campo, ma poiché Amazon EFS è un file system elastico, non impone alcuna capacità del file system. Puoi distribuire il volume persistente con o senza crittografia. (Il driver CSI di Amazon EFS abilita la crittografia per impostazione predefinita, come best practice.) Esegui lo `deploy-poc-app.sh` script per distribuire il volume persistente, l'attestazione del volume persistente e i due carichi di lavoro.**Con crittografia in transito:**<pre>./scripts/epic04/deploy-poc-app.sh \<br />    -t "$EFS_CREATION_TOKEN"</pre>`$EFS_CREATION_TOKEN`dov'è il token di creazione univoco per il file system.**Senza crittografia in transito:**<pre>./scripts/epic04/deploy-poc-app.sh -d \<br />    -t "$EFS_CREATION_TOKEN"</pre>dove `$EFS_CREATION_TOKEN` è il token di creazione univoco per il file system e `–d` disabilita la crittografia in transito. | Utente Kubernetes con autorizzazioni concesse | 
| Implementa la dichiarazione di volume persistente richiesta dall'applicazione. | Implementate la dichiarazione di volume persistente richiesta dall'applicazione e collegatela alla classe di archiviazione. Utilizza la stessa modalità di accesso del volume persistente creato in precedenza. È possibile specificare qualsiasi dimensione per l'attestazione del volume persistente nel campo di archiviazione. Kubernetes richiede questo campo, ma poiché Amazon EFS è un file system elastico, non impone alcuna capacità del file system. | Utente Kubernetes con autorizzazioni concesse | 
| Distribuisci il carico di lavoro 1. | Distribuisci il pod che rappresenta il carico di lavoro 1 dell'applicazione. Questo carico di lavoro scrive il contenuto nel file. `/data/out1.txt` | Utente Kubernetes con autorizzazioni concesse | 
| Implementa il carico di lavoro 2. | Implementa il pod che rappresenta il carico di lavoro 2 dell'applicazione. Questo carico di lavoro scrive il contenuto nel file. `/data/out2.txt` | Utente Kubernetes con autorizzazioni concesse | 

### Convalida la persistenza, la durabilità e la condivisibilità del file system
<a name="validate-file-system-persistence-durability-and-shareability"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Controlla lo stato di`PersistentVolume`. | Immettere il seguente comando per verificare lo stato di`PersistentVolume`.<pre>kubectl get pv</pre>Per un esempio di output, vedere la sezione [Informazioni aggiuntive](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-additional). | Utente Kubernetes con autorizzazioni concesse | 
| Controlla lo stato di. `PersistentVolumeClaim` | Immettere il seguente comando per verificare lo stato di`PersistentVolumeClaim`.<pre>kubectl -n poc-efs-eks-fargate get pvc</pre>Per un esempio di output, vedere la sezione [Informazioni aggiuntive](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-additional). | Utente Kubernetes con autorizzazioni concesse | 
| Verifica che il workload 1 possa scrivere sul file system. | Immetti il comando seguente per convalidare il carico di lavoro 1 su cui sta scrivendo. `/data/out1.txt`<pre>kubectl exec -ti poc-app1 -n poc-efs-eks-fargate -- tail -f /data/out1.txt</pre>I risultati sono simili ai seguenti:<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> | Utente Kubernetes con autorizzazioni concesse | 
| Verifica che Workload 2 sia in grado di scrivere sul file system. | Immetti il comando seguente per convalidare il workload 2 su cui sta scrivendo. `/data/out2.txt`<pre>kubectl -n $APP_NAMESPACE exec -ti poc-app2 -- tail -f /data/out2.txt</pre>I risultati sono simili ai seguenti:<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> | Utente Kubernetes con autorizzazioni concesse | 
| Verifica che il carico di lavoro 1 sia in grado di leggere il file scritto da workload 2. | Immetti il seguente comando per verificare che il carico di lavoro 1 sia in grado di leggere il `/data/out2.txt` file scritto dal carico di lavoro 2.<pre>kubectl exec -ti poc-app1 -n poc-efs-eks-fargate -- tail -n 3 /data/out2.txt</pre>I risultati sono simili ai seguenti:<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> | Utente Kubernetes con autorizzazioni concesse | 
| Verifica che il carico di lavoro 2 sia in grado di leggere il file scritto dal carico di lavoro 1. | Immetti il seguente comando per verificare che il carico di lavoro 2 sia in grado di leggere il `/data/out1.txt` file scritto dal carico di lavoro 1.<pre>kubectl -n $APP_NAMESPACE exec -ti poc-app2 -- tail -n 3 /data/out1.txt</pre>I risultati sono simili ai seguenti:<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> | Utente Kubernetes con autorizzazioni concesse | 
| Verifica che i file vengano conservati dopo aver rimosso i componenti dell'applicazione. | Successivamente, utilizzate uno script per rimuovere i componenti dell'applicazione (persistent volume, persistent volume claim e pods) e verificare che i file `/data/out2.txt` vengano conservati nel file `/data/out1.txt` system. Eseguire lo script `validate-efs-content.sh` utilizzando il comando seguente.<pre>./scripts/epic05/validate-efs-content.sh \<br />    -t "$EFS_CREATION_TOKEN"</pre>`$EFS_CREATION_TOKEN`dov'è il token di creazione univoco per il file system.I risultati sono simili ai seguenti:<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> | Utente Kubernetes con autorizzazioni concesse, amministratore di sistema | 

### Monitora le operazioni
<a name="monitor-operations"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Monitora i registri delle applicazioni. | Nell'ambito di un'operazione che dura il secondo giorno, spedisci i log delle applicazioni ad Amazon CloudWatch per il monitoraggio. | Amministratore di sistema AWS, utente Kubernetes con autorizzazioni concesse | 
| Monitora i contenitori Amazon EKS e Kubernetes con Container Insights. | Nell'ambito di un'operazione del secondo giorno, monitora i sistemi Amazon EKS e Kubernetes utilizzando Amazon Container Insights. CloudWatch Questo strumento raccoglie, aggrega e riepiloga i parametri delle applicazioni containerizzate a diversi livelli e dimensioni. [Per ulteriori informazioni, consulta la sezione Risorse correlate.](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-resources) | Amministratore di sistema AWS, utente Kubernetes con autorizzazioni concesse | 
| Monitora Amazon EFS con CloudWatch. | Nell'ambito di un'operazione del secondo giorno, monitora i file system utilizzando Amazon CloudWatch, che raccoglie ed elabora i dati grezzi da Amazon EFS in metriche leggibili quasi in tempo reale. [Per ulteriori informazioni, consulta la sezione Risorse correlate.](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-resources) | Amministratore di sistema AWS | 

### Eseguire la pulizia delle risorse
<a name="clean-up-resources"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Pulisci tutte le risorse create per il pattern. | Dopo aver completato questo schema, pulisci tutte le risorse per evitare di incorrere in costi AWS. Esegui lo `clean-up-resources.sh` script per rimuovere tutte le risorse dopo aver finito di utilizzare l'applicazione PoC. Completate una delle seguenti opzioni.**Con crittografia inattiva, con una chiave KMS:**<pre>./scripts/epic06/clean-up-resources.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN" \<br />    -k "$KMS_KEY_ALIAS"</pre>dove `$CLUSTER_NAME` è il nome del cluster Amazon EKS, `$EFS_CREATION_TOKEN` è il token di creazione per il file system ed `$KMS_KEY_ALIAS` è l'alias per la chiave KMS.**Senza crittografia a riposo:**<pre>./scripts/epic06/clean-up-resources.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN"</pre>dove `$CLUSTER_NAME` è il nome del cluster Amazon EKS ed `$EFS_CREATION_TOKEN` è il token di creazione per il file system. | Utente Kubernetes con autorizzazioni concesse, amministratore di sistema | 

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

**Riferimenti**
+ [AWS Fargate per Amazon EKS ora supporta Amazon EFS (annuncio](https://aws.amazon.com/blogs/aws/new-aws-fargate-for-amazon-eks-now-supports-amazon-efs/))
+ [Come acquisire i log delle applicazioni quando si utilizza Amazon EKS su AWS Fargate](https://aws.amazon.com/blogs/containers/how-to-capture-application-logs-when-using-amazon-eks-on-aws-fargate/) (post sul blog)
+ [Utilizzo di Container Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContainerInsights.html) ( CloudWatch documentazione Amazon)
+ [Configurazione di Container Insights su Amazon EKS e Kubernetes (documentazione Amazon)](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/deploy-container-insights-EKS.html) CloudWatch 
+ [Metriche di Amazon EKS e Kubernetes Container Insights (documentazione](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Container-Insights-metrics-EKS.html) Amazon) CloudWatch 
+ [Monitoraggio di Amazon EFS con Amazon CloudWatch](https://docs.aws.amazon.com/efs/latest/ug/monitoring-cloudwatch.html) (documentazione Amazon EFS)

**GitHub tutorial ed esempi**
+ [Provisioning statico](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/static_provisioning/README.md)
+ [Crittografia in transito](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/encryption_in_transit/README.md)
+ [Accesso al file system da più pod](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/multiple_pods/README.md)
+ [Consumo di Amazon EFS in StatefulSets](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/statefulset/README.md)
+ [Montaggio dei sottopercorsi](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/volume_path/README.md)
+ [Utilizzo dei punti di accesso Amazon EFS](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/access_points/README.md)
+ [Progetti Amazon EKS per Terraform](https://aws-ia.github.io/terraform-aws-eks-blueprints/)

**Strumenti necessari**
+ [Installazione della versione 2 dell'interfaccia a riga di comando di AWS](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html)
+ [Installazione di eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)
+ [Installare kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
+ [Installazione di jq](https://stedolan.github.io/jq/download/)

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

Di seguito è riportato un esempio di output del `kubectl get pv` comando.

```
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
```

Di seguito è riportato un esempio di output del `kubectl -n poc-efs-eks-fargate get pvc` comando.

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