Esta documentación es para la versión actual de GKE en AWS, publicada en noviembre de 2021. Consulta las notas de la versión para obtener más información.

Aprovisiona un volumen persistente con EFS

En esta página, se describe cómo configurar un modelo de PersistentVolume para usar en GKE en AWS con el controlador CSI de EFS. El Elastic File System (EFS) es el mecanismo subyacente de AWS que proporciona sistemas de archivos de red a tu clúster. Un PersistentVolume basado en EFS es un recurso de clúster que hace que el almacenamiento esté disponible para tus cargas de trabajo a través de un punto de acceso de EFS y garantiza que el almacenamiento persista incluso cuando no haya cargas de trabajo conectadas a él.

GKE en AWS admite el aprovisionamiento estático y dinámico de PersistentVolumes. El aprovisionamiento dinámico usa una configuración un poco diferente, pero luego requiere menos esfuerzo administrativo.

Antes de comenzar

Para realizar los pasos de esta página, primero completa lo siguiente:

Familiarízate con la forma en que Kubernetes y GKE en AWS manejan el almacenamiento de la carga de trabajo. Para obtener información sobre estos temas, consulta Usa almacenamiento persistente en tus cargas de trabajo de GKE en AWS y Crea recursos de Amazon EFS.
Actualiza a la versión 1.25 o posterior de Kubernetes para usar el aprovisionamiento dinámico de PersistentVolumes con EFS. Si usas la versión 1.24 de Kubernetes, comunícate con el equipo de asistencia para acceder a esta función.

Descripción general del aprovisionamiento estático

Crear un Elastic File System (EFS) y hacer que esté disponible para las cargas de trabajo en tu clúster a través del aprovisionamiento estático tiene cuatro pasos:

Crea tu recurso de EFS
Configurar la red
Crea un destino de activación
Crea una PersistentVolume

El último paso es la carga de trabajo: para solicitar el almacenamiento continuo mediante la emisión de una PersistentVolumeClaim.

Descripción general del aprovisionamiento dinámico

Crear un recurso de EFS y hacer que esté disponible a través del aprovisionamiento dinámico también tiene cuatro pasos:

Crea tu recurso de EFS
Configurar la red
Crea un destino de activación
Crea una StorageClass

Crear la StorageClass es una operación que se ejecuta una sola vez. Una vez que se define una clase de almacenamiento con características determinadas, la carga de trabajo puede emitir una PersistentVolumeClaim o una solicitud de almacenamiento continuo. Todas las PersistentVolumeClaims para el almacenamiento con esas características pueden solicitar el mismo StorageClass.

Pasos comunes

Ya sea que uses el aprovisionamiento estático o dinámico en tu clúster, debes comenzar con los pasos de configuración que se enumeran aquí y, luego, continuar con los pasos de aprovisionamiento estático o dinámico según corresponda. Una vez que hayas creado tu EFS y lo hayas hecho accesible, la carga de trabajo debe tomar los pasos finales para acceder a ella. Los pasos para hacerlo se describen en Usa el almacenamiento de EFS.

Crea un recurso de EFS de AWS

Se requiere un recurso EFS ya sea que uses el aprovisionamiento estático o dinámico. Si tu clúster usa ambos, puedes crear recursos de EFS separados para ellos o usar el mismo para ambos. Consulta Crea sistemas de archivos EFS de Amazon para obtener más información sobre cómo crear un recurso de EFS.

También puedes volver a usar un EFS existente, en cuyo caso puedes omitir esta sección y continuar con Crea objetivos de activación.

Obtén la región de AWS en la que se ejecuta tu clúster.
```
gcloud container aws clusters describe CLUSTER_NAME \
  --location=LOCATION \
  --format="value(awsRegion)"
```
Reemplaza lo siguiente:
- CLUSTER_NAME: es el nombre del clúster de AWS.
- LOCATION: es la ubicación de Google Cloud del clúster de AWS
Crea un sistema de archivos EFS en la misma región de AWS con el siguiente comando.
```
aws efs create-file-system \
  --region AWS_REGION \
  --performance-mode generalPurpose \
  --query 'FileSystemId' \
  --output text
```
Reemplaza lo siguiente:
- AWS_REGION: es la región de AWS en la que se ejecuta el clúster

El resultado incluye el ID del sistema de archivos. Guarda este valor. Lo necesitarás más tarde.

Crea objetivos de activación

El controlador de CSI para EFS accede a los sistemas de archivos a través de destinos de activación de EFS. Un destino de activación es una dirección IP privada que usa grupos de seguridad de AWS para controlar el acceso al EFS subyacente.

Si los grupos de nodos de tu clúster se ejecutan en subredes diferentes, debes crear un destino de activación separado en cada subred de grupo de nodos.

En este ejemplo, un grupo de seguridad único que incluye los destinos de activación y las máquinas del grupo de nodos protege el acceso a cada destino de activación. Según la configuración de VPC y los requisitos de seguridad, puedes dividir esta configuración en dos (o más) grupos de seguridad; por ejemplo, uno para los destinos de activación y otro para los nodos trabajadores del grupo de nodos.

Crea un grupo de seguridad dedicado para controlar el acceso al EFS

Obtén el ID de la VPC de AWS en la que se ejecuta el clúster.
```
gcloud container aws clusters describe CLUSTER_NAME \
  --location=LOCATION \
  --format="value(networking.vpcId)"
```
Reemplaza lo siguiente:
- CLUSTER_NAME
- LOCATION
El resultado incluye el ID de tu VPC. Guarda este valor. Lo necesitarás más tarde.
Crea un grupo de seguridad para controlar el acceso a tu destino de activación de EFS.
```
aws ec2 create-security-group \
  --group-name gke-efs-security-group \
  --description "EFS security group" \
  --vpc-id VPC_ID \
  --output text
```
Reemplaza VPC_ID por el ID de la VPC de AWS en la que se ejecuta el clúster.

El resultado incluye el ID del grupo de seguridad nuevo. Guarda este valor. Lo necesitarás más tarde.
De forma predeterminada, AWS crea grupos de seguridad con una regla predeterminada que permite todo el tráfico saliente. Quita la regla de salida predeterminada.
```
aws ec2 revoke-security-group-egress \
  --group-id SECURITY_GROUP_ID
  --ip-permissions '[{"IpProtocol":"-1","FromPort":-1,"ToPort":-1,"IpRanges":[{"CidrIp":"0.0.0.0/0"}]}]'
```
Reemplaza SECURITY_GROUP_ID por el ID del grupo de seguridad de AWS.

Autoriza el tráfico de entrada y salida de EFS (puerto 2049).

aws ec2 authorize-security-group-ingress \
    --group-id SECURITY_GROUP_ID \
    --protocol tcp \
    --port 2049 \
    --source-group SECURITY_GROUP_ID

aws ec2 authorize-security-group-egress \
    --group-id SECURITY_GROUP_ID \
    --protocol tcp \
    --port 2049 \
    --source-group SECURITY_GROUP_ID

Crea un destino de activación de EFS en cada subred del grupo de nodos.

Enumera las subredes asociadas con todos los grupos de nodos.
```
gcloud container aws node-pools list \
  --cluster=CLUSTER_NAME \
  --location=LOCATION \
  --format="value(subnetId)"
```
Reemplaza lo siguiente:
- CLUSTER_NAME
- LOCATION
El resultado es una lista de ID de subredes. Guarda este valor. Lo necesitarás más tarde.
Por cada subred, crea un objetivo de activación de EFS asociado con el grupo de seguridad aplicado.
```
aws efs create-mount-target \
    --file-system-id EFS_ID \
    --subnet-id SUBNET_ID \
    --security-groups SECURITY_GROUP_ID
```
Reemplaza lo siguiente:
- EFS_ID: es el ID del recurso de EFS.
- SUBNET_ID: es el ID de la subred del grupo de nodos.
- SECURITY_GROUP_ID
Agrega el grupo de seguridad de EFS a todos los grupos de nodos del clúster.

Obtén la lista de todos tus grupos de nodos.
```
gcloud container aws node-pools list \
  --cluster=CLUSTER_NAME \
  --location=LOCATION
```
Reemplaza lo siguiente:
- CLUSTER_NAME
- LOCATION
El resultado incluye los nombres de los grupos de nodos del clúster. Guarda este valor. Lo necesitarás más tarde.
Actualiza cada grupo de nodos para que incluya el grupo de seguridad EFS nuevo.
```
gcloud container aws node-pools update NODE_POOL_NAME \
  --cluster=CLUSTER_NAME \
  --location=LOCATION  \
  --security-group-ids=SECURITY_GROUP_IDS
```
Reemplaza lo siguiente:
- NODE_POOL_NAME: el nombre del grupo de nodos
- CLUSTER_NAME: El nombre de tu clúster.
- LOCATION
- SECURITY_GROUP_IDS es la lista de los ID de los grupos de seguridad para los nodos trabajadores.

Crea un PersistentVolume (estático) o una StorageClass (dinámica)

Si usas aprovisionamiento estático, el siguiente paso es crear un PersistentVolume. Si usas aprovisionamiento dinámico, el controlador EFS lo hace por ti. en su lugar, defines una StorageClass para que las cargas de trabajo especifiquen en su PersistentVolumeClaim. Elige la pestaña que coincide con tu método de aprovisionamiento elegido.

Aprovisionamiento estático

Si usas el aprovisionamiento estático, el siguiente paso es crear un PersistentVolume que active un recurso compartido de EFS.

Elige la pestaña adecuada según si te conectas directamente al recurso compartido de EFS o a través de un punto de acceso.
Conexión directa
Copia el siguiente YAML en un archivo llamado efs-volume.yaml. El manifiesto hace referencia a la clase de almacenamiento de EFS que creaste antes.
```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: VOLUME_NAME
spec:
  capacity:
    # Note: storage capacity is not used by the EFS CSI driver.
    # It is required by the PersistentVolume spec.
    storage: 5Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  storageClassName: "" # storageClassName is not required, see note in the following section.
  claimRef:
    name: CLAIM_NAME
    namespace: default
  csi:
    driver: efs.csi.aws.com
    volumeHandle: EFS_ID
```
Reemplaza lo siguiente:
- VOLUME_NAME con un nombre para el volumen persistente.
- CLAIM_NAME con el nombre que deseas usar para la PersistentVolumeClaim.
- EFS_ID con tu ID de recurso de EFS. Por ejemplo, fs-12345678a.
Punto de acceso
Para crear un volumen basado en puntos de acceso, debes aprovisionarlo de forma manual. Consulta Trabaja con puntos de acceso de EFS para obtener más información.

Copia el siguiente YAML en un archivo llamado efs-volume.yaml. El manifiesto hace referencia a la clase de almacenamiento de EFS que creaste antes.
```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: VOLUME_NAME
spec:
  capacity:
    # Note: storage capacity is not used by the EFS CSI driver.
    # It is required by the PersistentVolume spec.
    storage: 5Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  # Set storageClassName to empty string for static provisioning. See [Use an EFS resource](/kubernetes-engine/multi-cloud/docs/aws/how-to/use-efs)
  storageClassName: ""
  claimRef:
    name: CLAIM_NAME
    namespace: default
  csi:
    driver: efs.csi.aws.com
    volumeHandle: EFS_ID::ACCESS_POINT_ID
```
Reemplaza lo siguiente:
- VOLUME_NAME con un nombre para el volumen persistente.
- CLAIM_NAME con el nombre que deseas usar para la PersistentVolumeClaim.
- EFS_ID con tu ID de recurso de EFS. Por ejemplo, fs-12345678a.
- ACCESS_POINT_ID con el ID de tu punto de acceso. Por ejemplo, fsap-1234567890abcde
Nota: Debes usar el mismo valor storageClassName para tus recursos PersistentVolume y PersistentVolumeClaim.
Aplica el YAML a tu clúster.
```
kubectl apply -f efs-volume.yaml
```
El resultado confirma la creación de PersistentVolume.
```
persistentvolume/VOLUME_NAME created
```

Aprovisionamiento dinámico

En esta sección, se describe cómo crear una StorageClass que haga referencia al recurso EFS que creaste antes. Una vez hecho esto, los desarrolladores pueden acceder al recurso de EFM si siguen los pasos descritos en Usa un recurso de EFS.

Crea una StorageClass que haga referencia al ID de recurso de EFS.

Copia el siguiente fragmento de yaml en un archivo nuevo llamado efs-storage-class.yaml. Para obtener más información sobre cómo ajustar las características de StorageClass que se describen en este archivo, consulta la documentación sobre los parámetros de StorageClass de EFM.
```
kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: EFS_STORAGE_CLASS_NAME
provisioner: efs.csi.aws.com
mountOptions:
  - tls
parameters:
  provisioningMode: efs-ap
  fileSystemId: EFS_ID
  directoryPerms: "700"
```
Reemplaza lo siguiente:
- EFS_STORAGE_CLASS_NAME con el nombre que elegiste para la StorageClass.
- EFS_ID por el ID de recurso de EFS, por ejemplo, fs-12345678a.
Aplica el YAML a tu clúster.
```
kubectl apply -f efs-storage-class.yaml
```
Si se ejecuta de forma correcta, el resultado de este comando contendrá una línea similar a la siguiente:

storageclass/EFS_STORAGE_CLASS_NAME created

Realiza una limpieza

Para quitar los recursos que creaste en las secciones anteriores, ejecuta los siguientes comandos:

Usa kubectl para quitar el recurso de la reclamación de EFS de tu clúster:
```
kubectl delete -f efs-claim.yaml
```
Si usas el aprovisionamiento estático, usa kubectl para quitar los recursos asociados del clúster:
```
kubectl delete -f efs-volume.yaml
```
Si usas el aprovisionamiento dinámico, usa kubectl para quitar los recursos asociados del clúster:
```
kubectl delete -f efs-storage-class.yaml
```
Encuentra el ID de tu destino de activación:
```
aws efs describe-mount-targets \
--file-system-id EFS_ID \
--profile adminuser \
--region AWS_REGION
```
Reemplaza lo siguiente:
- EFS_ID: el ID de tu recurso de EFS
- AWS_REGION: es la región de AWS en la que se ejecuta el clúster
El resultado incluye el ID del destino de activación. Guarda este valor. Lo necesitarás más tarde.
Borra tu destino de activación de EFS:
```
aws efs delete-mount-target \
--mount-target-id MOUNT_TARGET_ID \
--profile adminuser \
--region AWS_REGION
```
Reemplaza lo siguiente:
- MOUNT_TARGET_ID: es el ID del destino de activación de EFS
- AWS_REGION: Es la región de AWS de tu destino de activación.
Borra cualquier grupo de seguridad que hayas creado.
Borra el sistema de archivos mediante el comando delete-file-system de la CLI. Puedes obtener una lista de tus sistemas de archivos mediante el comando describe-file-systems de la CLI. El ID del sistema de archivos se encuentra en la respuesta.
```
aws efs delete-file-system \
  --file-system-id EFS_ID \
  --profile adminuser \
  --region AWS_REGION
```
Reemplaza lo siguiente:
- EFS_ID
- AWS_REGION

¿Qué sigue?

Obtén más información sobre cómo usar una PersistentVolumeClaim de una carga de trabajo para acceder a un volumen de EFS.
Obtén más información sobre otras formas de usar los volúmenes de EFS en los ejemplos de aws-efs-csi-driver.