

 **Ayude a mejorar esta página** 

Para contribuir a esta guía del usuario, elija el enlace **Edit this page on GitHub** que se encuentra en el panel derecho de cada página.

# Utilice el almacenamiento del sistema de archivos de Amazon S3 con el controlador de CSI de Amazon EFS
<a name="s3files-csi"></a>

S3 Files es un sistema de archivos compartidos que conecta cualquier proceso de AWS directamente con los datos de Amazon S3. Proporciona un acceso rápido y directo a todos sus datos de S3 en forma de archivos con una semántica completa del sistema de archivos y un rendimiento de baja latencia, sin que sus datos salgan nunca de S3. Esto significa que las aplicaciones, los agentes y los equipos basados en archivos pueden acceder a los datos de S3 y trabajar con ellos como un sistema de archivos mediante las herramientas de las que ya dependen. El [controlador de Container Storage Interface (CSI) de Amazon EFS](https://github.com/kubernetes-sigs/aws-efs-csi-driver) permite a los clústeres de Kubernetes que se ejecutan en AWS montar sistemas de archivos de Amazon S3 como volúmenes persistentes a partir de la versión [3.0.0](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-3.x.md#v300). En este tema se muestra cómo utilizar el controlador de CSI de Amazon EFS para administrar el sistema de archivos de Amazon S3 en su clúster de Amazon EKS.

## Consideraciones
<a name="s3files-csi-considerations"></a>
+ El controlador CSI de Amazon EFS no es compatible con imágenes de contenedores basadas en Windows.
+ EKS Fargate no admite archivos de S3.
+ El controlador CSI de Amazon EFS no es compatible con los nodos híbridos de Amazon EKS.
+ La compatibilidad con Amazon S3 Files en el controlador de CSI de Amazon EFS comienza a partir de la versión [3.0.0](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-3.x.md#v300).

## Requisitos previos
<a name="s3files-csi-prereqs"></a>
+ El controlador CSI de Amazon EFS necesita los permisos de AWS Identity and Access Management (IAM).
  +  AWS sugiere usar Pod Identities de EKS. Para obtener más información, consulte [Información general de configuración de las Pod Identities de EKS](pod-identities.md#pod-id-setup-overview).
  + Para obtener más información sobre los roles de IAM para las cuentas de servicio y la configuración de un proveedor de OpenID Connect (OIDC) de IAM para el clúster, consulte [Crear un proveedor de OIDC de IAM para su clúster](enable-iam-roles-for-service-accounts.md).
+ La versión `2.12.3` o posterior, o bien, la versión `1.27.160` o posterior de la AWS interfaz de la línea de comandos (AWS CLI) instalada y configurada en su dispositivo o AWS CloudShell. Para comprobar su versión actual, utilice `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Los administradores de paquetes, como `yum`, `apt-get` o Homebrew para macOS, suelen estar atrasados varias versiones respecto de la versión de la AWS CLI más reciente. Para instalar la versión más reciente, consulte [Instalación](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) y [Configuración rápida con aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) en la *Guía del usuario de la interfaz de la línea de comandos de AWS*. La versión de AWS CLI instalada en AWS CloudShell también puede estar atrasada varias versiones respecto de la versión más reciente. Para actualizarla, consulte [Instalación de la CLI de AWS en su directorio principal](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) en la *Guía del usuario de AWS CloudShell*.
+ La herramienta de línea de comandos de `kubectl` está instalada en su dispositivo o AWS CloudShell. La versión puede ser la misma o hasta una versión secundaria anterior o posterior a la versión de Kubernetes de su clúster. Por ejemplo, si la versión del clúster es `1.29`, puede usar la versión `1.28`, `1.29` o `1.30` de `kubectl` con él. Para instalar o actualizar `kubectl`, consulte [Configuración de `kubectl` y `eksctl`](install-kubectl.md).

## Paso 1: crear roles de IAM
<a name="s3files-create-iam-resources"></a>

El controlador CSI de Amazon EFS requiere permisos de IAM para interactuar con el sistema de archivos. El controlador de CSI de EFS utiliza dos cuentas de servicio con roles de IAM independientes:
+  `efs-csi-controller-sa`: utilizado por el controlador, requiere `AmazonS3FilesCSIDriverPolicy`.
+  `efs-csi-node-sa`: utilizado por el nodo daemonset, requiere:
  +  `AmazonS3ReadOnlyAccess`: permite transmitir las lecturas directamente desde su bucket de S3 para lograr un mayor rendimiento.
  +  `AmazonElasticFileSystemsUtils`: permite publicar los registros de efs-utils en Amazon CloudWatch para obtener visibilidad de las operaciones de montaje y facilitar la solución de problemas.

**nota**  
Si desea utilizar tanto el sistema de archivos de Amazon S3 como el almacenamiento de Amazon EFS, debe adjuntar las políticas administradas `AmazonS3FilesCSIDriverPolicy` y `AmazonEFSCSIDriverPolicy` al rol de controlador. Para obtener más información sobre el almacenamiento de Amazon EFS, consulte [Uso del almacenamiento del sistema de archivos elástico con Amazon EFS](efs-csi.md).

Para implementar este procedimiento, puede utilizar una de las siguientes herramientas:
+  [`eksctl`](#eksctl_s3files_store_app_data) 
+  [Consola de administración de AWS](#console_s3files_store_app_data) 
+  [AWS CLI](#awscli_s3files_store_app_data) 

**nota**  
Los pasos específicos de este procedimiento están diseñados para usar el controlador como complemento de Amazon EKS. Para obtener más información sobre las instalaciones autoadministradas, consulte [Set up driver permission](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/install.md#set-up-driver-permission) en GitHub.

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

#### Si se utiliza Pod Identities
<a name="s3files-eksctl-pod-identities"></a>

Ejecute los siguientes comandos para crear roles de IAM y asociaciones de Pod Identity con `eksctl`. Reemplace *my-cluster* por su valor.

```
export cluster_name=my-cluster

# Create the controller role
eksctl create podidentityassociation \
    --service-account-name efs-csi-controller-sa \
    --namespace kube-system \
    --cluster $cluster_name \
    --role-name AmazonEKS_EFS_CSI_ControllerRole \
    --permission-policy-arns arn:aws:iam::aws:policy/service-role/AmazonS3FilesCSIDriverPolicy

# Create the node role
eksctl create podidentityassociation \
    --service-account-name efs-csi-node-sa \
    --namespace kube-system \
    --cluster $cluster_name \
    --role-name AmazonEKS_EFS_CSI_NodeRole \
    --permission-policy-arns arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess,arn:aws:iam::aws:policy/AmazonElasticFileSystemsUtils
```

#### Si se utilizan roles de IAM para cuentas de servicio
<a name="s3files-eksctl-irsa"></a>

Ejecute los siguientes comandos para crear roles de IAM con `eksctl`. Reemplace *my-cluster* por el nombre de su clúster y *region-code* por su código de región de AWS.

```
export cluster_name=my-cluster
export region_code=region-code

# Create the controller role
export controller_role_name=AmazonEKS_EFS_CSI_ControllerRole
eksctl create iamserviceaccount \
    --name efs-csi-controller-sa \
    --namespace kube-system \
    --cluster $cluster_name \
    --role-name $controller_role_name \
    --attach-policy-arn arn:aws:iam::aws:policy/service-role/AmazonS3FilesCSIDriverPolicy \
    --approve \
    --region $region_code

# Create the node role
export node_role_name=AmazonEKS_EFS_CSI_NodeRole
eksctl create iamserviceaccount \
    --name efs-csi-node-sa \
    --namespace kube-system \
    --cluster $cluster_name \
    --role-name $node_role_name \
    --attach-policy-arn arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess \
    --attach-policy-arn arn:aws:iam::aws:policy/AmazonElasticFileSystemsUtils \
    --approve \
    --region $region_code
```

### Consola de administración de AWS
<a name="console_s3files_store_app_data"></a>

Ejecute lo siguiente para crear un rol de IAM con la Consola de administración de AWS.

1. Abra la consola de IAM en https://console.aws.amazon.com/iam/.

1. En el panel de navegación izquierdo, elija **Roles**.

1. En la página **Roles**, elija **Crear rol**.

1. En la página **Seleccionar entidad de confianza**, haga lo siguiente:

   1. Si se utiliza Pod Identities de EKS:

      1. En la sección **Tipo de entidad de confianza**, elija **Servicio de AWS**.

      1. En el menú desplegable **Servicio o caso de uso**, seleccione **EKS**.

      1. En la sección **Caso de uso**, seleccione **EKS: Pod Identity**.

      1. Elija **Siguiente**.

   1. Si se utilizan roles de IAM para cuentas de servicio:

      1. En la sección **Tipo de entidad de confianza**, elija **Identidad web**.

      1. Para **Identity provider** (Proveedor de identidades), elija **OpenID Connect provider URL** (URL del proveedor de OpenID Connect) para el clúster, como se muestra en **Overview** (Resumen) en Amazon EKS.

      1. En **Audiencia**, elija `sts.amazonaws.com`.

      1. Elija **Siguiente**.

1. En la página **Agregar permisos**, haga lo siguiente:

   1. En el cuadro **Filtrar políticas**, escriba `AmazonS3FilesCSIDriverPolicy`.

   1. Marque la casilla situada a la izquierda del nombre de la política que obtuvo en la búsqueda.

   1. Elija **Siguiente**.

1. En la página **Nombrar, revisar y crear**, haga lo siguiente:

   1. En **Nombre del rol**, ingrese un nombre único para su rol, por ejemplo, `AmazonEKS_EFS_CSI_ControllerRole`.

   1. En **Agregar etiquetas (Opcional)**, de manera opcional, agregue metadatos al rol asociando etiquetas como pares de clave-valor. Para obtener más información sobre el uso de etiquetas en IAM, consulte [Etiquetado de recursos de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) en la *Guía de usuario de IAM*.

   1. Elija **Creación de rol**.

1. Una vez creado el rol:

   1. Si se utiliza Pod Identities de EKS:

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

      1. En el panel de navegación izquierdo, seleccione **Clústeres** y, a continuación, seleccione el nombre del clúster para el que desea configurar la asociación de Pod Identity de EKS.

      1. Elija la pestaña **Acceso**.

      1. En **Asociaciones de Pod Identity**, elija **Crear**.

      1. Elija el menú desplegable **Rol de IAM** y seleccione el rol recién creado.

      1. Elija el campo del **espacio de nombres de Kubernetes** e introduzca `kube-system`.

      1. Elija el campo de la **cuenta de servicio de Kubernetes** e introduzca `efs-csi-controller-sa`.

      1. Seleccione **Crear**.

      1. Para obtener más información sobre la creación de asociaciones de Pod Identity, consulte [Creación de una asociación de Pod Identity (consola de AWS)](pod-id-association.md#pod-id-association-create).

      1. Repita los pasos anteriores para crear un segundo rol para la cuenta de servicio del nodo. En la página **Agregar permisos**, adjunte `AmazonS3ReadOnlyAccess` y `AmazonElasticFileSystemsUtils` en su lugar. A continuación, cree una asociación de Pod Identity con `efs-csi-node-sa` para el campo **cuenta de servicio de Kubernetes**.

   1. Si se utilizan roles de IAM para cuentas de servicio:

      1. Elija el rol para abrirlo y editarlo.

      1. Elija la pestaña **Relaciones de confianza** y, a continuación, **Editar política de confianza**.

      1. Busque la línea que se parezca a la siguiente:

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

         Añada la siguiente línea por encima de la línea anterior. Reemplace `<region-code>` con la región de AWS en la que se encuentra el clúster. Reemplace `<EXAMPLED539D4633E53DE1B71EXAMPLE>` con el ID del proveedor OIDC del clúster.

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

      1. Elija **Actualizar política** para terminar.

      1. Repita los pasos anteriores para crear un segundo rol para la cuenta de servicio del nodo. En la página **Agregar permisos**, adjunte `AmazonS3ReadOnlyAccess` y `AmazonElasticFileSystemsUtils` en su lugar. En la política de confianza, utilice `efs-csi-node-sa` como valor de condición `:sub`.

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

Ejecute los siguientes comandos para crear roles de IAM con la CLI de AWS.

#### Si se utiliza Pod Identities
<a name="s3files-cli-pod-identities"></a>

1. Cree el rol de IAM que otorga las acciones `AssumeRole` y `TagSession` al servicio `pods.eks.amazonaws.com`.

   1. Copie el siguiente contenido en un archivo denominado `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. Cree el rol. Sustituya *my-cluster* por el nombre del clúster.

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

1. Adjunte las políticas administradas por AWS necesarias al rol del controlador.

   ```
   aws iam attach-role-policy \
     --policy-arn arn:aws:iam::aws:policy/service-role/AmazonS3FilesCSIDriverPolicy \
     --role-name $controller_role_name
   ```

1. Cree el rol de IAM del nodo mediante la política de confianza.

   ```
   export node_role_name=AmazonEKS_EFS_CSI_NodeRole
   aws iam create-role \
     --role-name $node_role_name \
     --assume-role-policy-document file://"aws-efs-csi-driver-trust-policy-pod-identity.json"
   ```

1. Asocie las políticas administradas por AWS necesarias al rol.

   ```
   aws iam attach-role-policy \
     --policy-arn arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess \
     --role-name $node_role_name
   
   aws iam attach-role-policy \
     --policy-arn arn:aws:iam::aws:policy/AmazonElasticFileSystemsUtils \
     --role-name $node_role_name
   ```

1. Ejecute los siguientes comandos para crear la asociación de Pod Identity. Reemplace `<111122223333>` por su ID de cuenta.

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

1. Para obtener más información sobre la creación de asociaciones de Pod Identity, consulte [Creación de una asociación de Pod Identity (consola de AWS)](pod-id-association.md#pod-id-association-create).

#### Si se utilizan roles de IAM para cuentas de servicio
<a name="s3files-cli-irsa"></a>

1. Visualización de la URL del proveedor de OIDC de su clúster. Sustituya *my-cluster* por el nombre del clúster.

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

   Un ejemplo de salida sería el siguiente.

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

   Si la salida del comando es `None`, revise los **Requisitos previos**.

1. Crear el rol de IAM para la cuenta de servicio del controlador.

   1. Copie el siguiente contenido en un archivo denominado `controller-trust-policy.json`. Reemplace `<111122223333>` por su ID de cuenta. Reemplace `<EXAMPLED539D4633E53DE1B71EXAMPLE>` y `<region-code>` por los valores que se devolvieron en el paso anterior.

      ```
      {
          "Version": "2012-10-17", 		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "Federated": "arn:aws:iam::<111122223333>:oidc-provider/oidc.eks.<region-code>.amazonaws.com/id/<EXAMPLED539D4633E53DE1B71EXAMPLE>"
                  },
                  "Action": "sts:AssumeRoleWithWebIdentity",
                  "Condition": {
                      "StringEquals": {
                          "oidc.eks.<region-code>.amazonaws.com/id/<EXAMPLED539D4633E53DE1B71EXAMPLE>:aud": "sts.amazonaws.com",
                          "oidc.eks.<region-code>.amazonaws.com/id/<EXAMPLED539D4633E53DE1B71EXAMPLE>:sub": "system:serviceaccount:kube-system:efs-csi-controller-sa"
                      }
                  }
              }
          ]
      }
      ```

   1. Creación del rol.

      ```
      export controller_role_name=AmazonEKS_EFS_CSI_ControllerRole
      aws iam create-role \
        --role-name $controller_role_name \
        --assume-role-policy-document file://"controller-trust-policy.json"
      ```

1. Adjunte las políticas administradas por AWS necesarias al rol del controlador.

   ```
   aws iam attach-role-policy \
     --policy-arn arn:aws:iam::aws:policy/service-role/AmazonS3FilesCSIDriverPolicy \
     --role-name $controller_role_name
   ```

1. Cree el rol de IAM para la cuenta de servicio del nodo.

   1. Copie el siguiente contenido en un archivo denominado `node-trust-policy.json`. Reemplace `<111122223333>` por su ID de cuenta. Reemplace `<EXAMPLED539D4633E53DE1B71EXAMPLE>` y `<region-code>` por los valores que se devolvieron en el paso 1.

      ```
      {
          "Version": "2012-10-17", 		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "Federated": "arn:aws:iam::<111122223333>:oidc-provider/oidc.eks.<region-code>.amazonaws.com/id/<EXAMPLED539D4633E53DE1B71EXAMPLE>"
                  },
                  "Action": "sts:AssumeRoleWithWebIdentity",
                  "Condition": {
                      "StringEquals": {
                          "oidc.eks.<region-code>.amazonaws.com/id/<EXAMPLED539D4633E53DE1B71EXAMPLE>:sub": "system:serviceaccount:kube-system:efs-csi-node-sa",
                          "oidc.eks.<region-code>.amazonaws.com/id/<EXAMPLED539D4633E53DE1B71EXAMPLE>:aud": "sts.amazonaws.com"
                      }
                  }
              }
          ]
      }
      ```

   1. Creación del rol.

      ```
      export node_role_name=AmazonEKS_EFS_CSI_NodeRole
      aws iam create-role \
        --role-name $node_role_name \
        --assume-role-policy-document file://"node-trust-policy.json"
      ```

1. Asocie las políticas administradas por AWS necesarias al rol.

   ```
   aws iam attach-role-policy \
     --policy-arn arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess \
     --role-name $node_role_name
   
   aws iam attach-role-policy \
     --policy-arn arn:aws:iam::aws:policy/AmazonElasticFileSystemsUtils \
     --role-name $node_role_name
   ```

**nota**  
La política `AmazonS3ReadOnlyAccess` concede acceso de lectura a todos los buckets de S3. Para restringir el acceso a buckets específicos, puede separarlos y sustituirlos por una política en línea basada en etiquetas. Consulte la [documentación de la política de IAM del controlador de CSI de Amazon EFS](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/iam-policy-create.md) en GitHub para obtener más información.

## Paso 2: obtención del controlador de CSI de Amazon EFS
<a name="s3files-install-driver"></a>

Le recomendamos que instale el controlador CSI de Amazon EFS a través del complemento Amazon EKS. Para agregar un complemento de Amazon EKS al clúster, consulte [Cómo crear un complemento de Amazon EKS](creating-an-add-on.md). Para obtener más información sobre los complementos, consulte [Complementos de Amazon EKS](eks-add-ons.md). Si no puede utilizar el complemento de Amazon EKS, le recomendamos que envíe una pregunta sobre los motivos por los que no puede hacerlo al [repositorio de GitHub de la hoja de ruta de contenedores](https://github.com/aws/containers-roadmap/issues).

**importante**  
Antes de agregar el controlador de Amazon EBS como complemento de Amazon EKS, asegúrese de que no haya una versión autoadministrada del controlador instalada en el clúster. Si es así, consulte [Desinstalar el controlador CSI de Amazon EFS](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/install.md#uninstalling-the-amazon-efs-csi-driver) en GitHub.

Como alternativa, si desea una instalación autoadministrada del controlador CSI de Amazon EFS, consulte [Installation](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/install.md) en GitHub.

## Paso 3: creación de un sistema de archivos de Amazon S3
<a name="s3files-create-filesystem"></a>

Para crear un sistema de archivos de Amazon S3, consulte [Crear un sistema de archivos de Amazon S3 para Amazon EKS](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/s3files-create-filesystem.md) en GitHub.

## Paso 4: implementación de una aplicación de muestra
<a name="s3files-sample-app"></a>

Puede implementar una variedad de aplicaciones de muestra y modificarlas según sea necesario. Para obtener más información, consulte [Ejemplos](https://github.com/kubernetes-sigs/aws-efs-csi-driver/tree/master/examples/kubernetes) en GitHub.