

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

# Utilizzo dell’archiviazione di file system elastici con Amazon EFS
<a name="efs-csi"></a>

 [Amazon Elastic File System](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html) (Amazon EFS) fornisce un'archiviazione di file serverless e completamente elastica in modo da poter condividere i dati dei file senza dover fornire o gestire la capacità e le prestazioni di archiviazione. Il [driver Amazon EFS Container Storage Interface (CSI)](https://github.com/kubernetes-sigs/aws-efs-csi-driver) consente ai cluster Kubernetes in esecuzione di montare i file system AWS Amazon EFS come volumi persistenti. Questo argomento illustra come implementare il driver CSI per Amazon EBS nel cluster Amazon EKS.

## Considerazioni
<a name="efs-csi-considerations"></a>
+ Il driver CSI per Amazon EFS non è compatibile con le immagini di container basate su Windows.
+ Non è possibile utilizzare il [provisioning dinamico](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/efs/dynamic_provisioning/README.md) dei volumi persistenti con nodi Fargate, ma è possibile utilizzare il [provisioning statico](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/efs/static_provisioning/README.md).
+  Il [provisioning dinamico](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/efs/dynamic_provisioning/README.md) richiede un driver versione [1.2](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-1.x.md#v12) o successiva. È possibile eseguire il [provisioning statico](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/efs/static_provisioning/README.md) di volumi persistenti utilizzando la versione `1.1` del driver su qualsiasi versione del cluster Amazon EKS supportata (consultare la pagina [Amazon EKS supported versions](https://docs.aws.amazon.com/eks/latest/userguide/kubernetes-versions.html)).
+ La versione [1.3.2](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-1.x.md#v132) o successiva di questo driver supporta l’architettura Arm64, incluse le istanze basate su Graviton di Amazon EC2.
+ La versione [1.4.2](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-1.x.md#v142) o successiva di questo driver supporta l’uso di FIPS per il montaggio di file system.
+ Osserva le quote delle risorse per Amazon EFS. Per ulteriori informazioni, consulta le [quote di Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/limits.html).
+ A partire dalla versione [2.0.0](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-2.x.md#v200), questo driver è passato dall’utilizzo di `stunnel` a `efs-proxy` per le connessioni TLS. Quando viene utilizzato `efs-proxy`, aprirà un numero di thread pari a uno più il numero di core del nodo su cui è in esecuzione.
+ Il driver CSI per Amazon EFS non è compatibile con Amazon EKS Hybrid Nodes.

## Prerequisiti
<a name="efs-csi-prereqs"></a>
+ Il driver CSI Amazon EFS necessita delle autorizzazioni AWS Identity and Access Management (IAM).
  +  AWS suggerisce di utilizzare EKS Pod Identities. Per ulteriori informazioni, consulta [Panoramica sulla configurazione delle associazioni EKS Pod Identity](pod-identities.md#pod-id-setup-overview).
  + Per informazioni sui ruoli IAM per gli account di servizio e su come configurare un gestore OpenID Connect (OIDC) IAM per il cluster, consultare [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md).
+ Versione `2.12.3` o successiva o versione `1.27.160` o successiva dell'interfaccia a riga di AWS comando (AWS CLI) installata e configurata sul dispositivo o. AWS CloudShell Per verificare la versione attuale, usa `aws --version | cut -d / -f2 | cut -d ' ' -f1`. I gestori di pacchetti come `yum``apt-get`, o Homebrew per macOS sono spesso diverse versioni dell'ultima versione della CLI AWS . Per installare la versione più recente, consulta [Installazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [configurazione rapida con aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) nella Guida per l'utente dell'*interfaccia a riga di AWS comando*. La versione AWS CLI installata in AWS CloudShell potrebbe anche contenere diverse versioni precedenti alla versione più recente. Per aggiornarlo, consulta [Installazione della AWS CLI nella tua home directory nella Guida per](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) l'* AWS CloudShell utente*.
+ Lo strumento a riga di comando `kubectl` è installato sul dispositivo o AWS CloudShell. La versione può essere uguale oppure immediatamente precedente o successiva alla versione di Kubernetes del cluster. Ad esempio, se la versione del cluster è `1.29`, puoi usare `kubectl` versione `1.28`, `1.29` o `1.30`. Per installare o aggiornare `kubectl`, consulta [Impostazione di `kubectl` e `eksctl`](install-kubectl.md):

**Nota**  
Un pod in esecuzione su Fargate monta automaticamente un file system Amazon EFS senza bisogno della procedura di installazione manuale del driver.

## Passaggio 1: Creazione di un ruolo IAM
<a name="efs-create-iam-resources"></a>

Il driver CSI per Amazon EFS richiede le autorizzazioni IAM per interagire con il file system. Crea un ruolo IAM e allega ad esso la policy ` arn:aws: iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy` gestita.

**Nota**  
Se desideri utilizzare lo storage di file system Amazon EFS e Amazon S3, devi collegare sia le policy `AmazonS3FilesCSIDriverPolicy` gestite che quelle gestite al tuo ruolo IAM. `AmazonEFSCSIDriverPolicy` Per ulteriori informazioni sullo storage del file system Amazon S3, consulta. [Usa lo storage del file system Amazon S3 con il driver CSI Amazon EFS](s3files-csi.md)

Per implementare questa procedura, è possibile utilizzare uno dei seguenti strumenti:
+  [`eksctl`](#eksctl_efs_store_app_data) 
+  [Console di gestione AWS](#console_efs_store_app_data) 
+  [AWS CLI](#awscli_efs_store_app_data) 

**Nota**  
I passaggi specifici di questa procedura sono stati scritti per l'utilizzo del driver come componente aggiuntivo di Amazon EKS. Per informazioni dettagliate sulle installazioni autogestite, consulta [Set up driver permission](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/install.md#set-up-driver-permission) su GitHub.

### `eksctl`
<a name="eksctl_efs_store_app_data"></a>

#### Se si utilizza Pod Identity
<a name="efs-eksctl-pod-identities"></a>

Eseguire i seguenti comandi per creare un ruolo IAM e un’associazione Pod Identity con `eksctl`. Sostituisci `my-cluster` con il nome del cluster. È anche possibile sostituire `AmazonEKS_EFS_CSI_DriverRole` con un nome diverso.

```
export cluster_name=my-cluster
export role_name=AmazonEKS_EFS_CSI_DriverRole
eksctl create podidentityassociation \
    --service-account-name efs-csi-controller-sa \
    --namespace kube-system \
    --cluster $cluster_name \
    --role-name $role_name \
    --permission-policy-arns arn:aws: iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy
```

#### Se si utilizzano ruoli IAM per gli account di servizio
<a name="efs-eksctl-irsa"></a>

Eseguire i seguenti comandi per creare un ruolo IAM con `eksctl`. Sostituisci `my-cluster` con il nome del cluster. È anche possibile sostituire `AmazonEKS_EFS_CSI_DriverRole` con un nome diverso.

```
export cluster_name=my-cluster
export role_name=AmazonEKS_EFS_CSI_DriverRole
eksctl create iamserviceaccount \
    --name efs-csi-controller-sa \
    --namespace kube-system \
    --cluster $cluster_name \
    --role-name $role_name \
    --role-only \
    --attach-policy-arn arn:aws: iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy \
    --approve
TRUST_POLICY=$(aws iam get-role --output json --role-name $role_name --query 'Role.AssumeRolePolicyDocument' | \
    sed -e 's/efs-csi-controller-sa/efs-csi-*/' -e 's/StringEquals/StringLike/')
aws iam update-assume-role-policy --role-name $role_name --policy-document "$TRUST_POLICY"
```

### Console di gestione AWS
<a name="console_efs_store_app_data"></a>

Esegui quanto segue per creare un ruolo IAM con Console di gestione AWS.

1. Apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

1. Nel pannello di navigazione a sinistra, seleziona **Ruoli**.

1. Nella pagina **Ruoli**, seleziona **Crea ruolo**.

1. Nella pagina **Seleziona un’entità attendibile**, esegui le operazioni seguenti:

   1. Se si utilizza EKS Pod Identity:

      1. Nella sezione **Tipo di entità affidabile**, scegli ** AWS servizio**.

      1. Nel menu a discesa **Servizio o caso d’uso**, scegliere **EKS**.

      1. Nella sezione **Caso d’uso**, scegliere **EKS - Pod Identity**.

      1. Scegli **Next (Successivo)**.

   1. Se si utilizzano ruoli IAM per gli account di servizio:

      1. Nella sezione **Tipo di identità attendibile**, scegli **Identità Web**.

      1. Per **Identity provider** (Provider di identità), scegli **URL del provider OpenID Connect** per il cluster (come mostrato nella scheda **Overview** (Panoramica) in Amazon EKS).

      1. Per **Pubblico**, scegli `sts.amazonaws.com`.

      1. Scegli **Next (Successivo)**.

1. Nella pagina **Add permissions** (Aggiungi autorizzazioni), esegui le operazioni seguenti:

   1. Nella casella **Filtra policy**, inserisci `AmazonEFSCSIDriverPolicy`.

   1. Seleziona la casella di controllo a sinistra della `AmazonEFSCSIDriverPolicy` restituita dalla ricerca.

   1. Scegli **Next (Successivo)**.

1. Nella pagina **Name, review, and create** (Assegna un nome, rivedi e crea), esegui le operazioni seguenti:

   1. Per **Nome ruolo**, inserisci un nome univoco per il ruolo, ad esempio `AmazonEKS_EFS_CSI_DriverRole`.

   1. In **Aggiungi tag (facoltativo)**, aggiungi metadati al ruolo collegando i tag come coppie chiave-valore. Per ulteriori informazioni sull’utilizzo di tag in IAM, consulta la sezione [Tagging IAM resources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) nella *Guida per l’utente di IAM*.

   1. Scegli **Crea ruolo**.

1. Dopo aver creato il ruolo:

   1. Se si utilizza EKS Pod Identity:

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

      1. Nel riquadro di navigazione a sinistra, selezionare **Cluster**, quindi selezionare il nome del cluster per cui configurare l’associazione EKS Pod Identity.

      1. Scegliere la scheda **Accesso**.

      1. In **Associazioni Pod Identity**, scegliere **Crea**.

      1. Scegliere il menu a discesa **Ruolo IAM** e selezionare il ruolo appena creato.

      1. Scegliere il campo **Namespace Kubernetes** e inserire `kube-system`.

      1. Scegliere il campo **Account del servizio Kubernetes** e inserire `efs-csi-controller-sa`.

      1. Scegli **Create** (Crea).

      1. Per ulteriori informazioni sulla creazione di associazioni Pod Identity, consultare [Crea un'associazione Pod Identity (AWS Console)](pod-id-association.md#pod-id-association-create).

   1. Se si utilizzano ruoli IAM per gli account di servizio:

      1. Scegliere il ruolo per aprirlo per la modifica.

      1. Scegli la scheda **Relazioni di attendibilità** e quindi **Modifica policy di attendibilità**.

      1. Trova la riga simile alla seguente:

         ```
         "oidc.eks.region-code.amazonaws.com/id/<EXAMPLED539D4633E53DE1B71EXAMPLE>:aud": "sts.amazonaws.com"
         ```

         Aggiungi la riga seguente sopra la riga precedente. Sostituiscilo `<region-code>` con la AWS regione in cui si trova il cluster. Sostituire `<EXAMPLED539D4633E53DE1B71EXAMPLE>` con l’ID del gestore OIDC del cluster.

         ```
         "oidc.eks.<region-code>.amazonaws.com/id/<EXAMPLED539D4633E53DE1B71EXAMPLE>:sub": "system:serviceaccount:kube-system:efs-csi-*",
         ```

      1. Modifica l'operatore `Condition` da `"StringEquals"` a `"StringLike"`.

      1. Scegli **Aggiorna policy** per concludere.

### AWS CLI
<a name="awscli_efs_store_app_data"></a>

Esegui i seguenti comandi per creare un ruolo IAM con AWS CLI.

#### Se si utilizza Pod Identity
<a name="efs-cli-pod-identities"></a>

1. Creare il ruolo IAM che concede le operazioni `AssumeRole` e `TagSession` al servizio `pods.eks.amazonaws.com`.

   1. Copiare i seguenti contenuti in un file denominato `aws-efs-csi-driver-trust-policy-pod-identity.json`.

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

   1. Crea il ruolo. Sostituisci `my-cluster` con il nome del cluster. È anche possibile sostituire `AmazonEKS_EFS_CSI_DriverRole` con un nome diverso.

      ```
      export cluster_name=my-cluster
      export role_name=AmazonEKS_EFS_CSI_DriverRole
      aws iam create-role \
        --role-name $role_name \
        --assume-role-policy-document file://"aws-efs-csi-driver-trust-policy-pod-identity.json"
      ```

1. Allega la policy AWS gestita richiesta al ruolo con il comando seguente.

   ```
   aws iam attach-role-policy \
     --policy-arn arn:aws: iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy \
     --role-name $role_name
   ```

1. Eseguire il seguente comando per creare l’associazione Pod Identity. Sostituisci `<111122223333>` con l'ID del tuo account.

   ```
   aws eks create-pod-identity-association --cluster-name $cluster_name --role-arn {arn-aws}iam::<111122223333>:role/$role_name --namespace kube-system --service-account efs-csi-controller-sa
   ```

1. Per ulteriori informazioni sulla creazione di associazioni Pod Identity, consultare [Crea un'associazione Pod Identity (AWS Console)](pod-id-association.md#pod-id-association-create).

#### Se si utilizzano ruoli IAM per gli account di servizio
<a name="efs-cli-irsa"></a>

1. Visualizzare l’URL del gestore OIDC del cluster. Sostituisci `my-cluster` con il nome del cluster. È anche possibile sostituire `AmazonEKS_EFS_CSI_DriverRole` con un nome diverso.

   ```
   export cluster_name=my-cluster
   export role_name=AmazonEKS_EFS_CSI_DriverRole
   aws eks describe-cluster --name $cluster_name --query "cluster.identity.oidc.issuer" --output text
   ```

   Di seguito viene riportato un output di esempio.

   ```
   https://oidc.eks.<region-code>.amazonaws.com/id/<EXAMPLED539D4633E53DE1B71EXAMPLE>
   ```

   Se l'output dal comando è `None`, rivedi i **Prerequisiti**.

1. Crea il ruolo IAM che concede l'autorizzazione per l'operazione `AssumeRoleWithWebIdentity`.

   1. Copia i seguenti contenuti in un file denominato `aws-efs-csi-driver-trust-policy.json`. Sostituisci `<111122223333>` con l'ID del tuo account. Sostituire `<EXAMPLED539D4633E53DE1B71EXAMPLE>` e `<region-code>` con i valori restituiti nella fase precedente.

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Effect": "Allow",
            "Principal": {
              "Federated": "arn:aws:iam::123456789012:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
            },
            "Action": "sts:AssumeRoleWithWebIdentity",
            "Condition": {
              "StringLike": {
                "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:efs-csi-*",
                "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
              }
            }
          }
        ]
      }
      ```

   1. Creare il ruolo.

      ```
      aws iam create-role \
        --role-name $role_name \
        --assume-role-policy-document file://"aws-efs-csi-driver-trust-policy.json"
      ```

1. Allega la politica AWS gestita richiesta al ruolo con il comando seguente.

   ```
   aws iam attach-role-policy \
     --policy-arn arn:aws: iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy \
     --role-name $role_name
   ```

## Fase 2: ottenere il driver CSI per Amazon EFS
<a name="efs-install-driver"></a>

Consigliamo di installare il driver Amazon EFS CSI attraverso il componente aggiuntivo di Amazon EKS. Per aggiungere un componente aggiuntivo di Amazon EKS al cluster, consulta [Creare un componente aggiuntivo Amazon EKS](creating-an-add-on.md). Per ulteriori informazioni sui componenti aggiuntivi, consulta [Componenti aggiuntivi Amazon EKS](eks-add-ons.md). Se non riesci a utilizzare il componente aggiuntivo Amazon EKS, ti consigliamo di segnalare un problema sul motivo per cui non puoi farlo all'archivio della [roadmap GitHub di Containers](https://github.com/aws/containers-roadmap/issues).

**Importante**  
Prima di aggiungere il driver Amazon EFS come componente aggiuntivo di Amazon EKS, verificare che nel cluster non sia installata una versione autogestita del driver. In tal caso, consulta [Disinstallazione del driver Amazon EFS CSI](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/install.md#uninstalling-the-amazon-efs-csi-driver) su. GitHub

In alternativa, se desideri un'installazione autogestita del driver Amazon EFS CSI, consulta [Installazione](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/install.md)su GitHub.

## Fase 3: Creazione di un file system Amazon EFS
<a name="efs-create-filesystem"></a>

Per creare un file system Amazon EFS, consulta [Creazione di un sistema di file  Amazon EFS per Amazon EKS](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/efs-create-filesystem.md) su  GitHub.

## Fase 4: implementazione di un’applicazione di esempio
<a name="efs-sample-app"></a>

Puoi implementare diverse app di esempio e modificarle in base alle tue esigenze. Per ulteriori informazioni, consulta [Esempi](https://github.com/kubernetes-sigs/aws-efs-csi-driver/tree/master/examples/kubernetes) su. GitHub