**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.
# Uso del almacenamiento de datos de aplicaciones para un clúster
Puede utilizar una gama de servicios de almacenamiento de AWS con Amazon EKS para satisfacer las necesidades de almacenamiento de las aplicaciones. Gracias a una amplia gama de controladores de interfaz de almacenamiento de contenedores (CSI) compatibles con AWS, puede utilizar fácilmente Amazon EBS, Amazon S3, Amazon EFS, Amazon FSX y Amazon File Cache para satisfacer las necesidades de almacenamiento de las aplicaciones que se ejecutan en Amazon EKS. Para administrar las copias de seguridad del clúster de Amazon EKS, consulte [Soporte de AWS Backup para Amazon EKS](https://docs.aws.amazon.com/aws-backup/latest/devguide/working-with-supported-services.html#working-with-eks).
En este capítulo se tratan las opciones de almacenamiento para clústeres de Amazon EKS.
**Topics**
+ [Uso del almacenamiento de volúmenes de Kubernetes con Amazon EBS](ebs-csi.md)
+ [Uso del almacenamiento del sistema de archivos elástico con Amazon EFS](efs-csi.md)
+ [Uso del almacenamiento de aplicaciones de alto rendimiento con Amazon FSx para Lustre](fsx-csi.md)
+ [Uso del almacenamiento de aplicaciones de alto rendimiento con FSx para NetApp ONTAP](fsx-ontap.md)
+ [Uso del almacenamiento de datos con Amazon FSx para OpenZFS](fsx-openzfs-csi.md)
+ [Minimización de la latencia con Amazon File Cache](file-cache-csi.md)
+ [Acceso a los objetos de Amazon S3 mediante Mountpoint para Amazon S3 con el controlador CSI](s3-csi.md)
+ [Habilitación de la funcionalidad de instantáneas para volúmenes de CSI](csi-snapshot-controller.md)
# Uso del almacenamiento de volúmenes de Kubernetes con Amazon EBS
**nota**
**Nuevo:** el modo automático de Amazon EKS automatiza las tareas rutinarias para el almacenamiento en bloque. Información sobre cómo [Implementación de una carga de trabajo con estado de ejemplo en el modo automático de EKS](sample-storage-workload.md).
El [controlador de la interfaz de almacenamiento de contenedores (CSI) de Amazon Elastic Block Store (Amazon EBS)](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/) administra el ciclo de vida de los volúmenes de Amazon EBS como almacenamiento para los volúmenes de Kubernetes que se creen. El controlador CSI de Amazon EBS crea volúmenes de Amazon EBS para estos tipos de volúmenes de Kubernetes: [volúmenes efímeros](https://kubernetes.io/docs/concepts/storage/ephemeral-volumes/) genéricos y [volúmenes persistentes](https://kubernetes.io/docs/concepts/storage/persistent-volumes/).
## Consideraciones
+ No necesita instalar el controlador de CSI de Amazon EBS en los clústeres de modo automático de EKS.
+ No puede montar volúmenes de Amazon EBS en los pods de Fargate.
+ Puede ejecutar el controlador CSI de Amazon EBS en nodos de Fargate, pero el nodo CSI de Amazon EBS `DaemonSet` solo se puede ejecutar en instancias de Amazon EC2.
+ Los volúmenes de Amazon EBS y el controlador CSI de Amazon EBS no son compatibles con los nodos híbridos de Amazon EKS.
+ Se ofrecerá soporte para la versión más reciente del complemento y para una versión anterior. Las correcciones para errores o vulnerabilidades encontrados en la versión más reciente se trasladarán a la versión anterior en una nueva versión menor.
+ El modo automático de EKS requiere que las clases de almacenamiento usen `ebs.csi.eks.amazonaws.com` como aprovisionador. El controlador de CSI estándar de Amazon EBS (`ebs.csi.aws.com`) administra sus propios volúmenes por separado. Para utilizar los volúmenes existentes con el modo automático de EKS, mígrelos mediante instantáneas de volumen a una clase de almacenamiento que utilice el aprovisionador de modo automático.
**importante**
Para utilizar la funcionalidad de instantáneas del controlador de CSI de Amazon EBS, primero deberá instalar el controlador de instantáneas de CSI. Para obtener más información, consulte [Habilitación de la funcionalidad de instantáneas para volúmenes de CSI](csi-snapshot-controller.md).
## Requisitos previos
+ Un clúster existente. Para ver la versión de plataforma requerida, ejecute el siguiente comando.
```
aws eks describe-addon-versions --addon-name aws-ebs-csi-driver
```
+ El controlador CSI de EBS necesita permisos de AWS 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 información sobre roles de IAM para cuentas de servicio, consulte [Crear un proveedor de OIDC de IAM para su clúster](enable-iam-roles-for-service-accounts.md).
## Paso 1: creación de un rol de IAM
El complemento CSI de Amazon EBS requiere permisos de IAM para realizar llamadas a las API de AWS en su nombre. Si no lleva a cabo estos pasos, aparecerá `failed to provision volume with StorageClass` con el error `could not create volume in EC2: UnauthorizedOperation` cuando intente instalar el complemento y ejecutar `kubectl describe pvc`. Para obtener más información, consulte [Configurar el permiso del controlador](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/blob/master/docs/install.md#set-up-driver-permissions) en GitHub.
**nota**
Los pods tendrán acceso a los permisos asignados al rol de IAM, a menos que bloquee el acceso al IMDS. Para obtener más información, consulte [Protección de los clústeres de Amazon EKS con las prácticas recomendadas](security-best-practices.md).
El siguiente procedimiento muestra cómo crear un rol de IAM y asociarle la política administrada de AWS. Para implementar este procedimiento, puede utilizar una de las siguientes herramientas:
+ [`eksctl`](#eksctl_store_app_data)
+ [Consola de administración de AWS](#console_store_app_data)
+ [AWS CLI](#awscli_store_app_data)
**nota**
Puede crear una política autoadministrada con permisos limitados. Consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEBSCSIDriverPolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEBSCSIDriverPolicy.html) y cree una política de IAM personalizada con permisos reducidos.
**nota**
Los pasos específicos de este procedimiento están diseñados para usar el controlador como complemento de Amazon EKS. Se necesitan diferentes pasos para usar el controlador como complemento autoadministrado. Para obtener más información, consulte [Set up driver permissions](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/blob/master/docs/install.md#set-up-driver-permissions) en GitHub.
### `eksctl`
1. Cree un rol de IAM y asóciele una política. AWS mantiene una política administrada de AWS, pero también puede crear su propia política personalizada. Puede crear un rol de IAM y asociar la política administrada de AWS con el siguiente comando. Reemplace *my-cluster* por el nombre de su clúster. El comando implementa una pila de AWS CloudFormation que crea un rol de IAM y le adjunta la política de IAM.
```
eksctl create iamserviceaccount \
--name ebs-csi-controller-sa \
--namespace kube-system \
--cluster my-cluster \
--role-name AmazonEKS_EBS_CSI_DriverRole \
--role-only \
--attach-policy-arn arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy \
--approve
```
1. Puede omitir este paso si no utiliza una [clave KMS](https://aws.amazon.com/kms/) personalizada. Si utiliza una para el cifrado en los volúmenes de Amazon EBS, personalice el rol de IAM según sea necesario. Por ejemplo, haga lo siguiente:
1. Copie y pegue el siguiente código en un nuevo archivo `kms-key-for-encryption-on-ebs.json`. Reemplace *custom-key-arn* por el [ARN de clave de KMS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awskeymanagementservice.html#awskeymanagementservice-key) personalizado.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:CreateGrant",
"kms:ListGrants",
"kms:RevokeGrant"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"],
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": "true"
}
}
},
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"]
}
]
}
```
1. Creación de la política. Puede cambiar *KMS\$1Key\$1For\$1Encryption\$1On\$1EBS\$1Policy* por un nombre diferente. Sin embargo, si lo hace, asegúrese de hacerlo también en pasos posteriores.
```
aws iam create-policy \
--policy-name KMS_Key_For_Encryption_On_EBS_Policy \
--policy-document file://kms-key-for-encryption-on-ebs.json
```
1. Adjunte una política de IAM y adjunte la política de IAM al rol con el siguiente comando. Reemplace *111122223333* por el ID de su cuenta.
```
aws iam attach-role-policy \
--policy-arn arn:aws:iam::111122223333:policy/KMS_Key_For_Encryption_On_EBS_Policy \
--role-name AmazonEKS_EBS_CSI_DriverRole
```
### 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. 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 `AmazonEBSCSIDriverPolicy`.
1. Marque la casilla situada a la izquierda del nombre de la `AmazonEBSCSIDriverPolicy` 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\$1EBS\$1CSI\$1DriverRole*.
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, seleccione el rol en la consola 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"
```
Agregue una coma al final de la línea anterior y, luego, agregue la siguiente línea después de la anterior. Reemplace *region-code* por la región de AWS en la que se encuentra el clúster. Reemplace *EXAMPLED539D4633E53DE1B71EXAMPLE* con el ID de proveedor de OIDC de su clúster.
```
"oidc.eks.region-code.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:ebs-csi-controller-sa"
```
1. Elija **Actualizar política** para terminar.
1. Si utiliza una [clave de KMS](https://aws.amazon.com/kms/) personalizada para el cifrado en los volúmenes de Amazon EBS, personalice el rol de IAM según sea necesario. Por ejemplo, haga lo siguiente:
1. En el panel de navegación izquierdo, elija **Políticas**.
1. En la página **Políticas**, seleccione **Crear una política**.
1. En la página **Crear política**, elija la pestaña **JSON**.
1. Copie y pegue el siguiente código en el editor y reemplace *custom-key-arn* por el [ARN de la clave de KMS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awskeymanagementservice.html#awskeymanagementservice-key) personalizado.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:CreateGrant",
"kms:ListGrants",
"kms:RevokeGrant"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"],
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": "true"
}
}
},
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"]
}
]
}
```
1. Elija **Siguiente: etiquetas**.
1. En la página **Agregar etiquetas (opcional)**, elija **Siguiente: revisar**.
1. En **Nombre**, introduzca un nombre exclusivo para la política (por ejemplo, *KMS\$1Key\$1For\$1Encryption\$1On\$1EBS\$1Policy*).
1. Elija **Crear política**.
1. En el panel de navegación izquierdo, elija **Roles**.
1. Elija ***AmazonEKS\$1EBS\$1CSI\$1DriverRole*** en la consola para abrirlo y editarlo.
1. En la lista desplegable **Agregar permisos**, seleccione **Asociar políticas**.
1. En el cuadro **Políticas de filtrado**, escriba *KMS\$1Key\$1For\$1Encryption\$1On\$1EBS\$1Policy*.
1. Seleccione la casilla situada a la izquierda del nombre de la *KMS\$1Key\$1For\$1Encryption\$1On\$1EBS\$1Policy* que obtuvo en la búsqueda.
1. Seleccione **Asociar políticas**.
### AWS CLI
1. Visualización de la URL del proveedor de OIDC de su clúster. Sustituya *my-cluster* por el nombre del clúster. Si la salida del comando es `None`, revise los **Requisitos previos**.
```
aws eks describe-cluster --name my-cluster --query "cluster.identity.oidc.issuer" --output text
```
Un ejemplo de salida sería el siguiente.
```
https://oidc.eks.region-code.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE
```
1. Creación del rol de IAM y otorgamiento de la acción `AssumeRoleWithWebIdentity`.
1. Copie el siguiente contenido en un archivo con el nombre `aws-ebs-csi-driver-trust-policy.json`. Reemplace *111122223333* por el ID de su 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.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com",
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:ebs-csi-controller-sa"
}
}
}
]
}
```
1. Creación del rol. Puede cambiar *AmazonEKS\$1EBS\$1CSI\$1DriverRole* a un nombre diferente. Si lo cambia, asegúrese de hacerlo también en pasos posteriores.
```
aws iam create-role \
--role-name AmazonEKS_EBS_CSI_DriverRole \
--assume-role-policy-document file://"aws-ebs-csi-driver-trust-policy.json"
```
1. Asocie una política. AWS mantiene una política administrada de AWS, pero también puede crear su propia política personalizada. Asocie la política administrada de AWS al rol con el siguiente comando.
```
aws iam attach-role-policy \
--policy-arn arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy \
--role-name AmazonEKS_EBS_CSI_DriverRole
```
1. Si utiliza una [clave de KMS](https://aws.amazon.com/kms/) personalizada para el cifrado en los volúmenes de Amazon EBS, personalice el rol de IAM según sea necesario. Por ejemplo, haga lo siguiente:
1. Copie y pegue el siguiente código en un nuevo archivo `kms-key-for-encryption-on-ebs.json`. Reemplace *custom-key-arn* por el [ARN de clave de KMS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awskeymanagementservice.html#awskeymanagementservice-key) personalizado.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:CreateGrant",
"kms:ListGrants",
"kms:RevokeGrant"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"],
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": "true"
}
}
},
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"]
}
]
}
```
1. Creación de la política. Puede cambiar *KMS\$1Key\$1For\$1Encryption\$1On\$1EBS\$1Policy* por un nombre diferente. Sin embargo, si lo hace, asegúrese de hacerlo también en pasos posteriores.
```
aws iam create-policy \
--policy-name KMS_Key_For_Encryption_On_EBS_Policy \
--policy-document file://kms-key-for-encryption-on-ebs.json
```
1. Adjunte una política de IAM y adjunte la política de IAM al rol con el siguiente comando. Reemplace *111122223333* por el ID de su cuenta.
```
aws iam attach-role-policy \
--policy-arn arn:aws:iam::111122223333:policy/KMS_Key_For_Encryption_On_EBS_Policy \
--role-name AmazonEKS_EBS_CSI_DriverRole
```
Ahora que ha creado el rol de IAM del controlador de CSI de Amazon EBS, puede continuar con la siguiente sección. Cuando implementa el complemento con este rol de IAM, se crea y se configura para utilizar una cuenta de servicio que se llama `ebs-csi-controller-sa`. La cuenta de servicio está vinculada a un `clusterrole` de Kubernetes al que se le asignan los permisos de Kubernetes necesarios.
## Paso 2: obtención del controlador de CSI de Amazon EBS
Le recomendamos que instale el controlador de CSI de Amazon EBS a través del complemento de Amazon EKS para mejorar la seguridad y reducir la cantidad de trabajo. 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).
**importante**
Antes de añadir el controlador de Amazon EBS como complemento de Amazon EKS, confirme que no tiene una versión autoadministrada del controlador instalada en su clúster. Si es así, consulte [Uninstalling a self-managed Amazon EBS CSI driver](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/blob/master/docs/install.md#uninstalling-the-ebs-csi-driver) en GitHub.
**nota**
De forma predeterminada, el rol de RBAC que utiliza la CSI de EBS tiene permisos para mutar nodos a fin de admitir la característica de eliminación de taints. Debido a las limitaciones de RBAC de Kubernetes, también le permite mutar cualquier otro nodo del clúster. El gráfico de Helm tiene un parámetro (`node.serviceAccount.disableMutation`) que desactiva los permisos de RBAC del nodo mutante para la cuenta de servicio ebs-csi-node. Cuando se activan, las características del controlador, como la eliminación de taints, no funcionarán.
Como alternativa, si desea una instalación autoadministrada del controlador CSI de Amazon EBS, consulte [Installation](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/blob/master/docs/install.md) en GitHub.
## Paso 3: implementación de una aplicación de muestra
Puede implementar una variedad de aplicaciones de muestra y modificarlas según sea necesario. Para obtener más información, consulte [Kubernetes Examples](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/tree/master/examples/kubernetes) en GitHub.
# Uso del almacenamiento del sistema de archivos elástico con Amazon EFS
[Amazon Elastic File System (Amazon EFS)](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html) proporciona un almacenamiento de archivos totalmente elástico y sin servidor para que pueda compartir datos de archivos sin aprovisionar ni administrar la capacidad de almacenamiento ni el rendimiento. El [controlador de Container Storage Interface (CSI) de Amazon EFS](https://github.com/kubernetes-sigs/aws-efs-csi-driver) proporciona una interfaz CSI que permite a los clústeres de Kubernetes que se ejecutan en AWS administrar el ciclo de vida de los sistemas de archivos de Amazon EFS. En este tema se muestra cómo implementar el controlador CSI de Amazon EFS en su clúster de Amazon EKS.
## Consideraciones
+ El controlador CSI de Amazon EFS no es compatible con imágenes de contenedores basadas en Windows.
+ No se puede utilizar el [aprovisionamiento dinámico](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/dynamic_provisioning/README.md) de volúmenes persistentes con los nodos de Fargate, pero sí se puede utilizar el [aprovisonamiento estático](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/static_provisioning/README.md).
+ El [aprovisionamiento dinámico](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/dynamic_provisioning/README.md) requiere la versión [1.2](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-1.x.md#v12) del controlador o posterior. Puede utilizar el [aprovisionamiento estático](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/static_provisioning/README.md) para volúmenes persistentes con la versión `1.1` del controlador en cualquier versión de clúster de Amazon EKS compatible (consulte las [versiones compatibles de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/kubernetes-versions.html)).
+ La versión [1.3.2](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-1.x.md#v132) y posteriores de este controlador son compatibles con la arquitectura Arm64, incluidas las instancias basadas en Graviton de Amazon EC2.
+ La versión [1.4.2](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-1.x.md#v142) o posterior de este controlador admite el uso de FIPS para montar sistemas de archivos.
+ Tome nota de las cuotas de recursos de Amazon EFS. Por ejemplo, hay una cuota de 1000 puntos de acceso que se pueden crear para cada sistema de archivos de Amazon EFS. Para obtener más información, consulte [Cuotas de recursos de Amazon EFS que no puede cambiar](https://docs.aws.amazon.com/efs/latest/ug/limits.html#limits-efs-resources-per-account-per-region).
+ A partir de la versión [2.0.0](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-2.x.md#v200), este controlador pasó de utilizar `stunnel` a `efs-proxy` para las conexiones TLS. Cuando se utiliza `efs-proxy`, se abrirá una cantidad de subprocesos igual a uno más la cantidad de núcleos del nodo en el que se ejecuta.
+ El controlador CSI de Amazon EFS no es compatible con los nodos híbridos de Amazon EKS.
## Requisitos previos
+ 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).
**nota**
Un pod que se ejecuta en Fargate monta automáticamente un sistema de archivos de Amazon EFS, sin necesidad de seguir pasos manuales para la instalación de controladores.
## Paso 1: creación de un rol de IAM
El controlador CSI de Amazon EFS requiere permisos de IAM para interactuar con el sistema de archivos. Cree un rol de IAM y adjúntelo a la política administrada de AWS requerida. Para implementar este procedimiento, puede utilizar una de las siguientes herramientas:
+ [`eksctl`](#eksctl_efs_store_app_data)
+ [Consola de administración de AWS](#console_efs_store_app_data)
+ [AWS CLI](#awscli_efs_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#set-up-driver-permission) en GitHub.
### `eksctl`
#### Si se utiliza Pod Identities
Ejecute los siguientes comandos para crear un rol de IAM y la asociación de Pod Identity con `eksctl`. Reemplace `my-cluster` por el nombre del clúster. También puede reemplazar `AmazonEKS_EFS_CSI_DriverRole` por un nombre diferente.
```
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
```
#### Si se utilizan roles de IAM para cuentas de servicio
Ejecute los siguientes comandos para crear el rol de IAM con `eksctl`. Reemplace `my-cluster` por el nombre del clúster. También puede reemplazar `AmazonEKS_EFS_CSI_DriverRole` por un nombre diferente.
```
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"
```
### Consola de administración de AWS
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 `AmazonEFSCSIDriverPolicy`.
1. Marque la casilla situada a la izquierda del nombre de la `AmazonEFSCSIDriverPolicy` 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_DriverRole`.
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. 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/:aud": "sts.amazonaws.com"
```
Añada la siguiente línea por encima de la línea anterior. Reemplace `` con la región de AWS en la que se encuentra el clúster. Reemplace `` con el ID del proveedor OIDC del clúster.
```
"oidc.eks..amazonaws.com/id/:sub": "system:serviceaccount:kube-system:efs-csi-*",
```
1. Modifique el operador `Condition` de `"StringEquals"` a `"StringLike"`.
1. Elija **Actualizar política** para terminar.
### AWS CLI
Ejecute los siguientes comandos para crear un rol de IAM con la CLI de AWS.
#### Si se utiliza Pod Identities
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. Reemplace `my-cluster` por el nombre del clúster. También puede reemplazar `AmazonEKS_EFS_CSI_DriverRole` por un nombre diferente.
```
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. Asocie el comando requerido administrado por AWS al rol con el siguiente comando.
```
aws iam attach-role-policy \
--policy-arn arn:aws:iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy \
--role-name $role_name
```
1. Ejecute el siguiente comando para crear la asociación de Pod Identity. Sustituya ` arn:aws:iam::<111122223333>:role/my-role` por el rol creado en los pasos anteriores.
```
aws eks create-pod-identity-association --cluster-name $cluster_name --role-arn {arn-aws}iam::<111122223333>:role/my-role --namespace kube-system --service-account efs-csi-controller-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
1. Visualización de la URL del proveedor de OIDC de su clúster. Reemplace `my-cluster` por el nombre del clúster. También puede reemplazar `AmazonEKS_EFS_CSI_DriverRole` por un nombre diferente.
```
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
```
Un ejemplo de salida sería el siguiente.
```
https://oidc.eks..amazonaws.com/id/
```
Si la salida del comando es `None`, revise los **Requisitos previos**.
1. Cree el rol de IAM que concede la acción `AssumeRoleWithWebIdentity`.
1. Copie el siguiente contenido en un archivo denominado `aws-efs-csi-driver-trust-policy.json`. Reemplace `<111122223333>` por su ID de cuenta. Reemplace `` y `` por los valores que se devolvieron en el paso anterior.
```
{
"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. Creación del rol.
```
aws iam create-role \
--role-name $role_name \
--assume-role-policy-document file://"aws-efs-csi-driver-trust-policy.json"
```
1. Asocie el comando requerido administrado por AWS al rol con el siguiente comando.
```
aws iam attach-role-policy \
--policy-arn arn:aws:iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy \
--role-name $role_name
```
## Paso 2: obtención del controlador de CSI de Amazon EFS
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/README.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/README.md#installation) en GitHub.
## Paso 3: creación de un sistema de archivos de Amazon EFS
Para crear un sistema de archivos de Amazon EFS, consulte [Crear un sistema de archivos de Amazon EFS para Amazon EKS](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/efs-create-filesystem.md) en GitHub.
## Paso 4: implementación de una aplicación de muestra
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/blob/master/docs/README.md#examples) en GitHub.
# Uso del almacenamiento de aplicaciones de alto rendimiento con Amazon FSx para Lustre
El [controlador de Container Storage Interface (CSI) de Amazon FSx for Lustre](https://github.com/kubernetes-sigs/aws-fsx-csi-driver) proporciona una interfaz CSI que permite a los clústeres de Amazon EKS administrar el ciclo de vida de los sistemas de archivos de Amazon FSx for Lustre. Para obtener más información, consulte la [Guía del usuario de Amazon FSx para Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html).
Para obtener detalles sobre cómo implementar el controlador de CSI de Amazon FSx para Lustre en el clúster de Amazon EKS y verificar su funcionamiento, consulte [Implementación del controlador de FSx para Lustre](fsx-csi-create.md).
# Implementación del controlador de FSx para Lustre
Este tema muestra cómo implementar el [controlador CSI de FSx para Lustre](fsx-csi.md) en el clúster de Amazon EKS y verificar que funcione correctamente. Siempre recomendamos usar la versión más reciente del controlador. Para ver las versiones disponibles, consulte [CSI Specification Compatibility Matrix](https://github.com/kubernetes-sigs/aws-fsx-csi-driver/blob/master/docs/README.md#csi-specification-compatibility-matrix) (Matriz de compatibilidad de especificaciones de CSI) en GitHub.
**nota**
El controlador no es compatible en Fargate ni en los Nodos híbridos de Amazon EKS.
Para obtener descripciones detalladas de los parámetros disponibles y ejemplos completos que demuestran las características del controlador, consulte el proyecto [FSx for Lustre Container Storage Interface (CSI) driver](https://github.com/kubernetes-sigs/aws-fsx-csi-driver) en GitHub.
## Requisitos previos
+ Un clúster existente.
+ El complemento de EKS del controlador de CSI de Amazon FSx requiere el agente de EKS Pod Identity para la autenticación. Sin este componente, se producirá el error `Amazon EKS Pod Identity agent is not installed in the cluster` en el complemento, que impedirá las operaciones de volumen. Instale el agente de Pod Identity antes o después de implementar el complemento del controlador de CSI de FSx. Para obtener más información, consulte [Configuración del agente de Pod Identity de Amazon EKS](pod-id-agent-setup.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 AWS CLI en su directorio de usuarios 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 versión `0.215.0` o posterior de la herramienta de línea de comandos `eksctl` instalada en su dispositivo o AWS CloudShell. Para instalar o actualizar `eksctl`, consulte la sección de [Instalación](https://eksctl.io/installation) en la documentación de `eksctl`.
+ 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: creación de un rol de IAM
El complemento de CSI de Amazon FSx requiere permisos de IAM para hacer llamadas a las API de AWS en su nombre.
**nota**
Los pods tendrán acceso a los permisos asignados al rol de IAM, a menos que bloquee el acceso al IMDS. Para obtener más información, consulte [Protección de los clústeres de Amazon EKS con las prácticas recomendadas](security-best-practices.md).
El siguiente procedimiento muestra cómo crear un rol de IAM y asociarle la política administrada de AWS.
1. Cree un rol de IAM y adjunte la política administrada de AWS con el siguiente comando. Sustituya `my-cluster` por el nombre del clúster que desea utilizar. El comando implementa una pila de AWS CloudFormation que crea un rol de IAM y le adjunta la política de IAM.
```
eksctl create iamserviceaccount \
--name fsx-csi-controller-sa \
--namespace kube-system \
--cluster my-cluster \
--role-name AmazonEKS_FSx_CSI_DriverRole \
--role-only \
--attach-policy-arn arn:aws:iam::aws:policy/AmazonFSxFullAccess \
--approve
```
Verá varias líneas de salida a medida que se crea la cuenta de servicio. Las últimas líneas de salida es similar a la siguiente línea de ejemplo.
```
[ℹ] 1 task: {
2 sequential sub-tasks: {
create IAM role for serviceaccount "kube-system/fsx-csi-controller-sa",
create serviceaccount "kube-system/fsx-csi-controller-sa",
} }
[ℹ] building iamserviceaccount stack "eksctl-my-cluster-addon-iamserviceaccount-kube-system-fsx-csi-controller-sa"
[ℹ] deploying stack "eksctl-my-cluster-addon-iamserviceaccount-kube-system-fsx-csi-controller-sa"
[ℹ] waiting for CloudFormation stack "eksctl-my-cluster-addon-iamserviceaccount-kube-system-fsx-csi-controller-sa"
[ℹ] created serviceaccount "kube-system/fsx-csi-controller-sa"
```
Apunte el nombre de la pila de AWS CloudFormation que se implementó. En la salida de ejemplo anterior, la pila se denomina `eksctl-my-cluster-addon-iamserviceaccount-kube-system-fsx-csi-controller-sa`.
Ahora que ha creado el rol de IAM del controlador de CSI de Amazon FSx, puede continuar con la siguiente sección. Cuando implementa el complemento con este rol de IAM, se crea y se configura para utilizar una cuenta de servicio que se llama `fsx-csi-controller-sa`. La cuenta de servicio está vinculada a un `clusterrole` de Kubernetes al que se le asignan los permisos de Kubernetes necesarios.
## Paso 2: instalación del controlador de CSI de Amazon FSx
Le recomendamos que instale el controlador de CSI de Amazon FSx a través del complemento de Amazon EKS para mejorar la seguridad y reducir la cantidad de trabajo. 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).
**importante**
Las instalaciones preexistentes del controlador de CSI de Amazon FSx en el clúster pueden provocar errores en la instalación de los complementos. Si intenta instalar la versión del complemento de Amazon EKS mientras existe un controlador de CSI de FSx que no es de EKS, se producirá un error en la instalación debido a conflictos de recursos. Utilice la marca `OVERWRITE` durante la instalación para resolver este problema.
```
aws eks create-addon --addon-name aws-fsx-csi-driver --cluster-name my-cluster --resolve-conflicts OVERWRITE
```
Como alternativa, si desea una instalación autoadministrada del controlador de CSI de Amazon FSx, consulte [Installation](https://github.com/kubernetes-sigs/aws-fsx-csi-driver/blob/master/docs/install.md) en GitHub.
## Paso 3: implementación de una clase de almacenamiento, una solicitud de volumen persistente y una aplicación de ejemplo
Este procedimiento utiliza el repositorio GitHub del [controlador de Container Storage Interface (CSI) de FSx para Lustre](https://github.com/kubernetes-sigs/aws-fsx-csi-driver) para utilizar un volumen de FSx for Lustre aprovisionado dinámicamente.
1. Anote el grupo de seguridad del clúster. Puede verlo en la Consola de administración de AWS en la sección **Redes** o utilizando el siguiente comando de AWS CLI. Sustituya `my-cluster` por el nombre del clúster que desea utilizar.
```
aws eks describe-cluster --name my-cluster --query cluster.resourcesVpcConfig.clusterSecurityGroupId
```
1. Cree un grupo de seguridad para su sistema de archivos Amazon FSx de acuerdo con los criterios que se muestran en [Grupos de seguridad de Amazon VPC](https://docs.aws.amazon.com/fsx/latest/LustreGuide/limit-access-security-groups.html#fsx-vpc-security-groups) en la Guía del usuario de Amazon FSx para Lustre. Para la **VPC**, seleccione la VPC de su clúster tal como se muestra en la sección **Networking** (Redes). Para “los grupos de seguridad asociados a los clientes de Lustre”, utilice el grupo de seguridad de clúster. Puede dejar solo las reglas de salida para permitir **All traffic** (Todo el tráfico).
1. Descargue el manifiesto de con el siguiente comando.
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-fsx-csi-driver/master/examples/kubernetes/dynamic_provisioning/specs/storageclass.yaml
```
1. Edite la sección de parámetros del archivo `storageclass.yaml`. Reemplace todos los valores de ejemplo por sus propios valores.
```
parameters:
subnetId: subnet-0eabfaa81fb22bcaf
securityGroupIds: sg-068000ccf82dfba88
deploymentType: PERSISTENT_1
automaticBackupRetentionDays: "1"
dailyAutomaticBackupStartTime: "00:00"
copyTagsToBackups: "true"
perUnitStorageThroughput: "200"
dataCompressionType: "NONE"
weeklyMaintenanceStartTime: "7:09:00"
fileSystemTypeVersion: "2.12"
```
+ ** `subnetId` ** – el ID de subred en el que se debe crear el sistema de archivos de Amazon FSx para Lustre. Amazon FSx para Lustre no se admite en todas las zonas de disponibilidad. Abra la consola de Amazon FSx para Lustre en https://console.aws.amazon.com/fsx/ para confirmar que la subred que desea utilizar se encuentra en una zona de disponibilidad compatible. La subred puede incluir sus nodos o puede ser una subred o VPC diferente:
+ Puede comprobar si hay subredes de nodos en la Consola de administración de AWS seleccionando el grupo de nodos en la sección **Compute** (Informática).
+ Si la subred que especifica no es la misma en la que tiene los nodos, las VPC deben estar [conectadas](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/amazon-vpc-to-amazon-vpc-connectivity-options.html) y debe asegurarse de que tiene abiertos los puertos necesarios en los grupos de seguridad.
+ ** `securityGroupIds` ** – el ID del grupo de seguridad que ha creado para el sistema de archivos.
+ ** `deploymentType` (opcional)**: el tipo de implementación del sistema de archivos. Los valores válidos son `SCRATCH_1`, `SCRATCH_2`, `PERSISTENT_1` y `PERSISTENT_2`. Para obtener más información sobre los tipos de implementación, consulte [cómo crear su sistema de archivos de Amazon FSx para Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/getting-started-step1.html).
+ **otros parámetros (opcionales)**: para obtener información acerca del resto de parámetros, consulte [Edit StorageClass](https://github.com/kubernetes-sigs/aws-fsx-csi-driver/tree/master/examples/kubernetes/dynamic_provisioning#edit-storageclass) (Editar StorageClass) en GitHub.
1. Cree el manifiesto de clase de almacenamiento.
```
kubectl apply -f storageclass.yaml
```
Un ejemplo de salida sería el siguiente.
```
storageclass.storage.k8s.io/fsx-sc created
```
1. Descargue el manifiesto de notificación de volumen persistente.
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-fsx-csi-driver/master/examples/kubernetes/dynamic_provisioning/specs/claim.yaml
```
1. (Opcional) Edite el archivo `claim.yaml`. Cambie `1200Gi` por uno de los valores de incremento que se indican a continuación, en función de los requisitos de almacenamiento y del `deploymentType` que seleccionó en los pasos anteriores.
```
storage: 1200Gi
```
+ `SCRATCH_2` y `PERSISTENT`: `1.2 TiB`, `2.4 TiB` o incrementos de 2.4 TiB sobre 2.4 TiB.
+ `SCRATCH_1` – `1.2 TiB`, `2.4 TiB`, `3.6 TiB`, o incrementos de 3.6 TiB sobre 3.6 TiB.
1. Cree la notificación de volumen persistente.
```
kubectl apply -f claim.yaml
```
Un ejemplo de salida sería el siguiente.
```
persistentvolumeclaim/fsx-claim created
```
1. Confirme que el sistema de archivos está aprovisionado.
```
kubectl describe pvc
```
Un ejemplo de salida sería el siguiente.
```
Name: fsx-claim
Namespace: default
StorageClass: fsx-sc
Status: Bound
[...]
```
**nota**
El `Status` puede aparecer como `Pending` durante 5-10 minutos, antes de cambiar a `Bound`. No continúe con el siguiente paso hasta que el `Status` sea `Bound`. Si el `Status` muestra `Pending` durante más de 10 minutos, utilice los mensajes de advertencia en los `Events` como referencia para abordar cualquier problema.
1. Implemente la aplicación de muestra.
```
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/aws-fsx-csi-driver/master/examples/kubernetes/dynamic_provisioning/specs/pod.yaml
```
1. Verifique que la aplicación de muestra se está ejecutando.
```
kubectl get pods
```
Un ejemplo de salida sería el siguiente.
```
NAME READY STATUS RESTARTS AGE
fsx-app 1/1 Running 0 8s
```
1. Verifique que la aplicación haya montado correctamente el sistema de archivos.
```
kubectl exec -ti fsx-app -- df -h
```
Un ejemplo de salida sería el siguiente.
```
Filesystem Size Used Avail Use% Mounted on
overlay 80G 4.0G 77G 5% /
tmpfs 64M 0 64M 0% /dev
tmpfs 3.8G 0 3.8G 0% /sys/fs/cgroup
192.0.2.0@tcp:/abcdef01 1.1T 7.8M 1.1T 1% /data
/dev/nvme0n1p1 80G 4.0G 77G 5% /etc/hosts
shm 64M 0 64M 0% /dev/shm
tmpfs 6.9G 12K 6.9G 1% /run/secrets/kubernetes.io/serviceaccount
tmpfs 3.8G 0 3.8G 0% /proc/acpi
tmpfs 3.8G 0 3.8G 0% /sys/firmware
```
1. Verifique que la aplicación de muestra haya escrito los datos en el sistema de archivos de FSx para Lustre.
```
kubectl exec -it fsx-app -- ls /data
```
Un ejemplo de salida sería el siguiente.
```
out.txt
```
En este resultado de ejemplo se muestra que la aplicación de ejemplo escribió correctamente el archivo `out.txt` en el sistema de archivos.
**nota**
Antes de eliminar el clúster, asegúrese de eliminar el sistema de archivos de FSx para Lustre. Para obtener más información, consulte [Limpiar recursos](https://docs.aws.amazon.com/fsx/latest/LustreGuide/getting-started-step4.html) en la *Guía de usuario de FSx para Lustre*.
## Ajuste del rendimiento para FSx para Lustre
Al utilizar FSx para Lustre con Amazon EKS, puede optimizar el rendimiento mediante la aplicación de ajustes de Lustre durante la inicialización del nodo. El enfoque recomendado consiste en utilizar los datos del usuario de la plantilla de lanzamiento para garantizar una configuración coherente en todos los nodos.
Estos ajustes incluyen lo siguiente:
+ Optimizaciones de red y RPC
+ Administración de módulos de Lustre
+ Ajustes de LRU (unidad de recurso de bloqueo)
+ Configuración de control de caché del cliente
+ Controles de RPC para OST y MDC
Para obtener instrucciones detalladas sobre cómo implementar estos ajustes de rendimiento:
+ Para optimizar el rendimiento de los nodos estándar (que no son EFA), consulte [Optimización del rendimiento de Amazon FSx para Lustre en nodos (sin EFA)](fsx-csi-tuning-non-efa.md) para obtener un script completo que puede agregarse a los datos de usuario de la plantilla de lanzamiento.
+ Para optimizar el rendimiento de los nodos compatibles con EFA, consulte [Optimización del rendimiento de Amazon FSx para Lustre en nodos (EFA)](fsx-csi-tuning-efa.md).
# Optimización del rendimiento de Amazon FSx para Lustre en nodos (EFA)
Este tema describe cómo configurar el ajuste de Elastic Fabric Adapter (EFA) con Amazon EKS y Amazon FSx para Lustre.
**nota**
Para obtener información sobre la creación e implementación del controlador de CSI de FSx para Lustre, consulte [Implementación del controlador de FSx para Lustre](fsx-csi-create.md).
Para optimizar los nodos estándar sin EFA, consulte [Optimización del rendimiento de Amazon FSx para Lustre en nodos (sin EFA)](fsx-csi-tuning-non-efa.md).
## Paso 1. Cómo crear un clúster de EKS
Cree un clúster con el archivo de configuración proporcionado:
```
# Create cluster using efa-cluster.yaml
eksctl create cluster -f efa-cluster.yaml
```
Ejemplo: `efa-cluster.yaml`:
```
#efa-cluster.yaml
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: csi-fsx
region: us-east-1
version: "1.30"
iam:
withOIDC: true
availabilityZones: ["us-east-1a", "us-east-1d"]
managedNodeGroups:
- name: my-efa-ng
instanceType: c6gn.16xlarge
minSize: 1
desiredCapacity: 1
maxSize: 1
availabilityZones: ["us-east-1b"]
volumeSize: 300
privateNetworking: true
amiFamily: Ubuntu2204
efaEnabled: true
preBootstrapCommands:
- |
#!/bin/bash
eth_intf="$(/sbin/ip -br -4 a sh | grep $(hostname -i)/ | awk '{print $1}')"
efa_version=$(modinfo efa | awk '/^version:/ {print $2}' | sed 's/[^0-9.]//g')
min_efa_version="2.12.1"
if [[ "$(printf '%s\n' "$min_efa_version" "$efa_version" | sort -V | head -n1)" != "$min_efa_version" ]]; then
sudo curl -O https://efa-installer.amazonaws.com/aws-efa-installer-1.37.0.tar.gz
tar -xf aws-efa-installer-1.37.0.tar.gz && cd aws-efa-installer
echo "Installing EFA driver"
sudo apt-get update && apt-get upgrade -y
sudo apt install -y pciutils environment-modules libnl-3-dev libnl-route-3-200 libnl-route-3-dev dkms
sudo ./efa_installer.sh -y
modinfo efa
else
echo "Using EFA driver version $efa_version"
fi
echo "Installing Lustre client"
sudo wget -O - https://fsx-lustre-client-repo-public-keys.s3.amazonaws.com/fsx-ubuntu-public-key.asc | gpg --dearmor | sudo tee /usr/share/keyrings/fsx-ubuntu-public-key.gpg > /dev/null
sudo echo "deb [signed-by=/usr/share/keyrings/fsx-ubuntu-public-key.gpg] https://fsx-lustre-client-repo.s3.amazonaws.com/ubuntu jammy main" > /etc/apt/sources.list.d/fsxlustreclientrepo.list
sudo apt update | tail
sudo apt install -y lustre-client-modules-$(uname -r) amazon-ec2-utils | tail
modinfo lustre
echo "Loading Lustre/EFA modules..."
sudo /sbin/modprobe lnet
sudo /sbin/modprobe kefalnd ipif_name="$eth_intf"
sudo /sbin/modprobe ksocklnd
sudo lnetctl lnet configure
echo "Configuring TCP interface..."
sudo lnetctl net del --net tcp 2> /dev/null
sudo lnetctl net add --net tcp --if $eth_intf
# For P5 instance type which supports 32 network cards,
# by default add 8 EFA interfaces selecting every 4th device (1 per PCI bus)
echo "Configuring EFA interface(s)..."
instance_type="$(ec2-metadata --instance-type | awk '{ print $2 }')"
num_efa_devices="$(ls -1 /sys/class/infiniband | wc -l)"
echo "Found $num_efa_devices available EFA device(s)"
if [[ "$instance_type" == "p5.48xlarge" || "$instance_type" == "p5e.48xlarge" ]]; then
for intf in $(ls -1 /sys/class/infiniband | awk 'NR % 4 == 1'); do
sudo lnetctl net add --net efa --if $intf --peer-credits 32
done
else
# Other instances: Configure 2 EFA interfaces by default if the instance supports multiple network cards,
# or 1 interface for single network card instances
# Can be modified to add more interfaces if instance type supports it
sudo lnetctl net add --net efa --if $(ls -1 /sys/class/infiniband | head -n1) --peer-credits 32
if [[ $num_efa_devices -gt 1 ]]; then
sudo lnetctl net add --net efa --if $(ls -1 /sys/class/infiniband | tail -n1) --peer-credits 32
fi
fi
echo "Setting discovery and UDSP rule"
sudo lnetctl set discovery 1
sudo lnetctl udsp add --src efa --priority 0
sudo /sbin/modprobe lustre
sudo lnetctl net show
echo "Added $(sudo lnetctl net show | grep -c '@efa') EFA interface(s)"
```
## Paso 2. Crear un grupo de nodos
Cree un grupo de nodos habilitado para EFA:
```
# Create node group using efa-ng.yaml
eksctl create nodegroup -f efa-ng.yaml
```
**importante**
=== Ajuste estos valores en función del entorno en la sección `# 5. Mount FSx filesystem`.
```
FSX_DNS="" # Needs to be adjusted.
MOUNT_NAME="" # Needs to be adjusted.
MOUNT_POINT="" # Needs to be adjusted.
```
===
Ejemplo: `efa-ng.yaml`:
```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: final-efa
region: us-east-1
managedNodeGroups:
- name: ng-1
instanceType: c6gn.16xlarge
minSize: 1
desiredCapacity: 1
maxSize: 1
availabilityZones: ["us-east-1a"]
volumeSize: 300
privateNetworking: true
amiFamily: Ubuntu2204
efaEnabled: true
preBootstrapCommands:
- |
#!/bin/bash
exec 1> >(logger -s -t $(basename $0)) 2>&1
#########################################################################################
# Configuration Section #
#########################################################################################
# File System Configuration
FSX_DNS="" # Needs to be adjusted.
MOUNT_NAME="" # Needs to be adjusted.
MOUNT_POINT="" # Needs to be adjusted.
# Lustre Tuning Parameters
LUSTRE_LRU_MAX_AGE=600000
LUSTRE_MAX_CACHED_MB=64
LUSTRE_OST_MAX_RPC=32
LUSTRE_MDC_MAX_RPC=64
LUSTRE_MDC_MOD_RPC=50
# File paths
FUNCTIONS_SCRIPT="/usr/local/bin/lustre_functions.sh"
TUNINGS_SCRIPT="/usr/local/bin/apply_lustre_tunings.sh"
SERVICE_FILE="/etc/systemd/system/lustre-tunings.service"
#EFA
MIN_EFA_VERSION="2.12.1"
# Function to check if a command was successful
check_success() {
if [ $? -eq 0 ]; then
echo "SUCCESS: $1"
else
echo "FAILED: $1"
return 1
fi
}
echo "********Starting FSx for Lustre configuration********"
# 1. Install Lustre client
if grep -q '^ID=ubuntu' /etc/os-release; then
echo "Detected Ubuntu, proceeding with Lustre setup..."
# Add Lustre repository
sudo wget -O - https://fsx-lustre-client-repo-public-keys.s3.amazonaws.com/fsx-ubuntu-public-key.asc | sudo gpg --dearmor | sudo tee /usr/share/keyrings/fsx-ubuntu-public-key.gpg > /dev/null
echo "deb [signed-by=/usr/share/keyrings/fsx-ubuntu-public-key.gpg] https://fsx-lustre-client-repo.s3.amazonaws.com/ubuntu jammy main" | sudo tee /etc/apt/sources.list.d/fsxlustreclientrepo.list
sudo apt-get update
sudo apt-get install -y lustre-client-modules-$(uname -r)
sudo apt-get install -y lustre-client
else
echo "Not Ubuntu, exiting"
exit 1
fi
check_success "Install Lustre client"
# Ensure Lustre tools are in the PATH
export PATH=$PATH:/usr/sbin
# 2. Apply network and RPC tunings
echo "********Applying network and RPC tunings********"
if ! grep -q "options ptlrpc ptlrpcd_per_cpt_max" /etc/modprobe.d/modprobe.conf; then
echo "options ptlrpc ptlrpcd_per_cpt_max=64" | sudo tee -a /etc/modprobe.d/modprobe.conf
check_success "Set ptlrpcd_per_cpt_max"
else
echo "ptlrpcd_per_cpt_max already set in modprobe.conf"
fi
if ! grep -q "options ksocklnd credits" /etc/modprobe.d/modprobe.conf; then
echo "options ksocklnd credits=2560" | sudo tee -a /etc/modprobe.d/modprobe.conf
check_success "Set ksocklnd credits"
else
echo "ksocklnd credits already set in modprobe.conf"
fi
# 3. Load Lustre modules
manage_lustre_modules() {
echo "Checking for existing Lustre modules..."
if lsmod | grep -q lustre; then
echo "Existing Lustre modules found."
# Check for mounted Lustre filesystems
echo "Checking for mounted Lustre filesystems..."
if mount | grep -q "type lustre"; then
echo "Found mounted Lustre filesystems. Attempting to unmount..."
mounted_fs=$(mount | grep "type lustre" | awk '{print $3}')
for fs in $mounted_fs; do
echo "Unmounting $fs"
sudo umount $fs
check_success "Unmount filesystem $fs"
done
else
echo "No Lustre filesystems mounted."
fi
# After unmounting, try to remove modules
echo "Attempting to remove Lustre modules..."
sudo lustre_rmmod
if [ $? -eq 0 ]; then
echo "SUCCESS: Removed existing Lustre modules"
else
echo "WARNING: Could not remove Lustre modules. They may still be in use."
echo "Please check for any remaining Lustre processes or mounts."
return 1
fi
else
echo "No existing Lustre modules found."
fi
echo "Loading Lustre modules..."
sudo modprobe lustre
check_success "Load Lustre modules" || exit 1
echo "Checking loaded Lustre modules:"
lsmod | grep lustre
}
# Managing Lustre kernel modules
echo "********Managing Lustre kernel modules********"
manage_lustre_modules
# 4. Initializing Lustre networking
echo "********Initializing Lustre networking********"
sudo lctl network up
check_success "Initialize Lustre networking" || exit 1
# 4.5 EFA Setup and Configuration
setup_efa() {
echo "********Starting EFA Setup********"
# Get interface and version information
eth_intf="$(/sbin/ip -br -4 a sh | grep $(hostname -i)/ | awk '{print $1}')"
efa_version=$(modinfo efa | awk '/^version:/ {print $2}' | sed 's/[^0-9.]//g')
min_efa_version=$MIN_EFA_VERSION
# Install or verify EFA driver
if [[ "$(printf '%s\n' "$min_efa_version" "$efa_version" | sort -V | head -n1)" != "$min_efa_version" ]]; then
echo "Installing EFA driver..."
sudo curl -O https://efa-installer.amazonaws.com/aws-efa-installer-1.37.0.tar.gz
tar -xf aws-efa-installer-1.37.0.tar.gz && cd aws-efa-installer
# Install dependencies
sudo apt-get update && apt-get upgrade -y
sudo apt install -y pciutils environment-modules libnl-3-dev libnl-route-3-200 libnl-route-3-dev dkms
# Install EFA
sudo ./efa_installer.sh -y
modinfo efa
else
echo "Using existing EFA driver version $efa_version"
fi
}
configure_efa_network() {
echo "********Configuring EFA Network********"
# Load required modules
echo "Loading network modules..."
sudo /sbin/modprobe lnet
sudo /sbin/modprobe kefalnd ipif_name="$eth_intf"
sudo /sbin/modprobe ksocklnd
# Initialize LNet
echo "Initializing LNet..."
sudo lnetctl lnet configure
# Configure TCP interface
echo "Configuring TCP interface..."
sudo lnetctl net del --net tcp 2> /dev/null
sudo lnetctl net add --net tcp --if $eth_intf
# For P5 instance type which supports 32 network cards,
# by default add 8 EFA interfaces selecting every 4th device (1 per PCI bus)
echo "Configuring EFA interface(s)..."
instance_type="$(ec2-metadata --instance-type | awk '{ print $2 }')"
num_efa_devices="$(ls -1 /sys/class/infiniband | wc -l)"
echo "Found $num_efa_devices available EFA device(s)"
if [[ "$instance_type" == "p5.48xlarge" || "$instance_type" == "p5e.48xlarge" ]]; then
# P5 instance configuration
for intf in $(ls -1 /sys/class/infiniband | awk 'NR % 4 == 1'); do
sudo lnetctl net add --net efa --if $intf --peer-credits 32
done
else
# Standard configuration
# Other instances: Configure 2 EFA interfaces by default if the instance supports multiple network cards,
# or 1 interface for single network card instances
# Can be modified to add more interfaces if instance type supports it
sudo lnetctl net add --net efa --if $(ls -1 /sys/class/infiniband | head -n1) --peer-credits 32
if [[ $num_efa_devices -gt 1 ]]; then
sudo lnetctl net add --net efa --if $(ls -1 /sys/class/infiniband | tail -n1) --peer-credits 32
fi
fi
# Configure discovery and UDSP
echo "Setting up discovery and UDSP rules..."
sudo lnetctl set discovery 1
sudo lnetctl udsp add --src efa --priority 0
sudo /sbin/modprobe lustre
# Verify configuration
echo "Verifying EFA network configuration..."
sudo lnetctl net show
echo "Added $(sudo lnetctl net show | grep -c '@efa') EFA interface(s)"
}
# Main execution
setup_efa
configure_efa_network
# 5. Mount FSx filesystem
if [ ! -z "$FSX_DNS" ] && [ ! -z "$MOUNT_NAME" ]; then
echo "********Creating mount point********"
sudo mkdir -p $MOUNT_POINT
check_success "Create mount point"
echo "Mounting FSx filesystem..."
sudo mount -t lustre ${FSX_DNS}@tcp:/${MOUNT_NAME} ${MOUNT_POINT}
check_success "Mount FSx filesystem"
else
echo "Skipping FSx mount as DNS or mount name is not provided"
fi
# 6. Applying Lustre performance tunings
echo "********Applying Lustre performance tunings********"
# Get number of CPUs
NUM_CPUS=$(nproc)
# Calculate LRU size (100 * number of CPUs)
LRU_SIZE=$((100 * NUM_CPUS))
#Apply LRU tunings
echo "Apply LRU tunings"
sudo lctl set_param ldlm.namespaces.*.lru_max_age=${LUSTRE_LRU_MAX_AGE}
check_success "Set lru_max_age"
sudo lctl set_param ldlm.namespaces.*.lru_size=$LRU_SIZE
check_success "Set lru_size"
# Client Cache Control
sudo lctl set_param llite.*.max_cached_mb=${LUSTRE_MAX_CACHED_MB}
check_success "Set max_cached_mb"
# RPC Controls
sudo lctl set_param osc.*OST*.max_rpcs_in_flight=${LUSTRE_OST_MAX_RPC}
check_success "Set OST max_rpcs_in_flight"
sudo lctl set_param mdc.*.max_rpcs_in_flight=${LUSTRE_MDC_MAX_RPC}
check_success "Set MDC max_rpcs_in_flight"
sudo lctl set_param mdc.*.max_mod_rpcs_in_flight=${LUSTRE_MDC_MOD_RPC}
check_success "Set MDC max_mod_rpcs_in_flight"
# 7. Verify all tunings
echo "********Verifying all tunings********"
# Function to verify parameter value
verify_param() {
local param=$1
local expected=$2
local actual=$3
if [ "$actual" == "$expected" ]; then
echo "SUCCESS: $param is correctly set to $expected"
else
echo "WARNING: $param is set to $actual (expected $expected)"
fi
}
echo "Verifying all parameters:"
# LRU tunings
actual_lru_max_age=$(lctl get_param -n ldlm.namespaces.*.lru_max_age | head -1)
verify_param "lru_max_age" "600000" "$actual_lru_max_age"
actual_lru_size=$(lctl get_param -n ldlm.namespaces.*.lru_size | head -1)
verify_param "lru_size" "$LRU_SIZE" "$actual_lru_size"
# Client Cache
actual_max_cached_mb=$(lctl get_param -n llite.*.max_cached_mb | grep "max_cached_mb:" | awk '{print $2}')
verify_param "max_cached_mb" "64" "$actual_max_cached_mb"
# RPC Controls
actual_ost_rpcs=$(lctl get_param -n osc.*OST*.max_rpcs_in_flight | head -1)
verify_param "OST max_rpcs_in_flight" "32" "$actual_ost_rpcs"
actual_mdc_rpcs=$(lctl get_param -n mdc.*.max_rpcs_in_flight | head -1)
verify_param "MDC max_rpcs_in_flight" "64" "$actual_mdc_rpcs"
actual_mdc_mod_rpcs=$(lctl get_param -n mdc.*.max_mod_rpcs_in_flight | head -1)
verify_param "MDC max_mod_rpcs_in_flight" "50" "$actual_mdc_mod_rpcs"
# Network and RPC configurations from modprobe.conf
actual_ptlrpc=$(grep "ptlrpc ptlrpcd_per_cpt_max" /etc/modprobe.d/modprobe.conf | awk '{print $3}')
verify_param "ptlrpcd_per_cpt_max" "ptlrpcd_per_cpt_max=64" "$actual_ptlrpc"
actual_ksocklnd=$(grep "ksocklnd credits" /etc/modprobe.d/modprobe.conf | awk '{print $3}')
verify_param "ksocklnd credits" "credits=2560" "$actual_ksocklnd"
# 8. Setup persistence
setup_persistence() {
# Create functions file
cat << EOF > $FUNCTIONS_SCRIPT
#!/bin/bash
apply_lustre_tunings() {
local NUM_CPUS=\$(nproc)
local LRU_SIZE=\$((100 * NUM_CPUS))
echo "Applying Lustre performance tunings..."
lctl set_param ldlm.namespaces.*.lru_max_age=$LUSTRE_LRU_MAX_AGE
lctl set_param ldlm.namespaces.*.lru_size=\$LRU_SIZE
lctl set_param llite.*.max_cached_mb=$LUSTRE_MAX_CACHED_MB
lctl set_param osc.*OST*.max_rpcs_in_flight=$LUSTRE_OST_MAX_RPC
lctl set_param mdc.*.max_rpcs_in_flight=$LUSTRE_MDC_MAX_RPC
lctl set_param mdc.*.max_mod_rpcs_in_flight=$LUSTRE_MDC_MOD_RPC
}
EOF
# Create tuning script
cat << EOF > $TUNINGS_SCRIPT
#!/bin/bash
exec 1> >(logger -s -t \$(basename \$0)) 2>&1
source $FUNCTIONS_SCRIPT
# Function to check if Lustre is mounted
is_lustre_mounted() {
mount | grep -q "type lustre"
}
# Function to mount Lustre
mount_lustre() {
echo "Mounting Lustre filesystem..."
mkdir -p $MOUNT_POINT
mount -t lustre ${FSX_DNS}@tcp:/${MOUNT_NAME} $MOUNT_POINT
return \$?
}
# Main execution
# Try to mount if not already mounted
if ! is_lustre_mounted; then
echo "Lustre filesystem not mounted, attempting to mount..."
mount_lustre
fi
# Wait for successful mount (up to 5 minutes)
for i in {1..30}; do
if is_lustre_mounted; then
echo "Lustre filesystem mounted, applying tunings..."
apply_lustre_tunings
exit 0
fi
echo "Waiting for Lustre filesystem to be mounted... (attempt $i/30)"
sleep 10
done
echo "Timeout waiting for Lustre filesystem mount"
exit 1
EOF
# Create systemd service
# Create systemd directory if it doesn't exist
sudo mkdir -p /etc/systemd/system/
# Create service file directly for Ubuntu
cat << EOF > $SERVICE_FILE
[Unit]
Description=Apply Lustre Performance Tunings
After=network.target remote-fs.target
[Service]
Type=oneshot
ExecStart=/bin/bash -c 'source $FUNCTIONS_SCRIPT && $TUNINGS_SCRIPT'
RemainAfterExit=yes
[Install]
WantedBy=multi-user.target
EOF
# Make scripts executable and enable service
sudo chmod +x $FUNCTIONS_SCRIPT
sudo chmod +x $TUNINGS_SCRIPT
systemctl enable lustre-tunings.service
systemctl start lustre-tunings.service
}
echo "********Setting up persistent tuning********"
setup_persistence
echo "FSx for Lustre configuration completed."
```
## (Opcional) Paso 3. Verificación de la configuración de EFA
Conexión al nodo mediante SSH:
```
# Get instance ID from EKS console or {aws} CLI
ssh -i /path/to/your-key.pem ec2-user@
```
Verificación de la configuración de EFA:
```
sudo lnetctl net show
```
Comprobación de los registros de configuración:
```
sudo cat /var/log/cloud-init-output.log
```
A continuación se muestra un ejemplo del resultado esperado para `lnetctl net show`:
```
net:
- net type: tcp
...
- net type: efa
local NI(s):
- nid: xxx.xxx.xxx.xxx@efa
status: up
```
## Implementaciones de ejemplo
### a. Creación de claim.yaml
```
#claim.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: fsx-claim-efa
spec:
accessModes:
- ReadWriteMany
storageClassName: ""
resources:
requests:
storage: 4800Gi
volumeName: fsx-pv
```
Aplicación del archivo claim:
```
kubectl apply -f claim.yaml
```
### b. Creación de pv.yaml
Actualización de ``:
```
#pv.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
name: fsx-pv
spec:
capacity:
storage: 4800Gi
volumeMode: Filesystem
accessModes:
- ReadWriteMany
mountOptions:
- flock
persistentVolumeReclaimPolicy: Recycle
csi:
driver: fsx.csi.aws.com
volumeHandle: fs-<1234567890abcdef0>
volumeAttributes:
dnsname: fs-<1234567890abcdef0>.fsx.us-east-1.amazonaws.com
mountname:
```
Aplicación del volumen persistente:
```
kubectl apply -f pv.yaml
```
### c. Creación de pod.yaml
```
#pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: fsx-efa-app
spec:
containers:
- name: app
image: amazonlinux:2
command: ["/bin/sh"]
args: ["-c", "while true; do dd if=/dev/urandom bs=100M count=20 > data/test_file; sleep 10; done"]
resources:
requests:
vpc.amazonaws.com/efa: 1
limits:
vpc.amazonaws.com/efa: 1
volumeMounts:
- name: persistent-storage
mountPath: /data
volumes:
- name: persistent-storage
persistentVolumeClaim:
claimName: fsx-claim-efa
```
Aplicación del pod:
```
kubectl apply -f pod.yaml
```
## Comandos de verificación adicionales
Verificación de que el Pod monta y escribe en el sistema de archivos:
```
kubectl exec -ti fsx-efa-app -- df -h | grep data
# Expected output:
# <192.0.2.0>@tcp:/ 4.5T 1.2G 4.5T 1% /data
kubectl exec -ti fsx-efa-app -- ls /data
# Expected output:
# test_file
```
Conexión mediante SSH al nodo para verificar que el tráfico circula a través de EFA:
```
sudo lnetctl net show -v
```
La salida esperada mostrará las interfaces EFA junto con las estadísticas de tráfico.
## Información relacionada
+ [Implementación del controlador de FSx para Lustre](fsx-csi-create.md)
+ [Optimización del rendimiento de Amazon FSx para Lustre en nodos (sin EFA)](fsx-csi-tuning-non-efa.md)
+ [Amazon FSx for Lustre Performance](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html)
+ [Elastic Fabric Adapter](https://docs.aws.amazon.com/ec2/latest/userguide/efa.html)
# Optimización del rendimiento de Amazon FSx para Lustre en nodos (sin EFA)
Es posible optimizar el rendimiento de Amazon FSx para Lustre mediante la aplicación de parámetros de ajuste durante la inicialización de los nodos, con datos de usuario de la plantilla de lanzamiento.
**nota**
Para obtener información sobre la creación e implementación del controlador de CSI de FSx para Lustre, consulte [Implementación del controlador de FSx para Lustre](fsx-csi-create.md). Para optimizar el rendimiento con nodos compatibles con EFA, consulte [Optimización del rendimiento de Amazon FSx para Lustre en nodos (EFA)](fsx-csi-tuning-efa.md).
## ¿Por qué usar los datos de usuario de la plantilla de lanzamiento?
+ Aplica ajustes de forma automática durante la inicialización del nodo.
+ Garantiza una configuración coherente en todos los nodos.
+ Elimina la necesidad de configurar los nodos de forma manual.
## Información general del script de ejemplo
El script de ejemplo definido en este tema realiza las siguientes operaciones:
### `# 1. Install Lustre client`
+ Detecta automáticamente la versión del sistema operativo de Amazon Linux (AL).
+ Instala el paquete de cliente de Lustre correspondiente.
### `# 2. Apply network and RPC tunings`
+ Configura `ptlrpcd_per_cpt_max=64` para el procesamiento paralelo de RPC.
+ Configura `ksocklnd credits=2560` para optimizar los búferes de red.
### `# 3. Load Lustre modules`
+ Elimina de forma segura los módulos Lustre existentes, si están presentes.
+ Se encarga del desmontaje de sistemas de archivos existentes.
+ Carga módulos Lustre nuevos.
### `# 4. Lustre Network Initialization`
+ Inicializa la configuración de red de Lustre.
+ Configura los parámetros de red requeridos.
### `# 5. Mount FSx filesystem`
+ Debe ajustar los valores de esta sección según el entorno.
### `# 6. Apply tunings`
+ Ajustes de LRU (unidad de recurso de bloqueo):
+ `lru_max_age=600000`
+ `lru_size` calculado con base en la cantidad de CPU
+ Control de caché del cliente: `max_cached_mb=64`
+ Controles de RPC:
+ OST `max_rpcs_in_flight=32`
+ MDC `max_rpcs_in_flight=64`
+ MDC `max_mod_rpcs_in_flight=50`
### `# 7. Verify tunings`
+ Verifica todos los ajustes aplicados.
+ Informa si cada parámetro se aplicó correctamente o si generó una advertencia.
### `# 8. Setup persistence`
+ También debe ajustar los valores de esta sección según el entorno.
+ Detecta automáticamente la versión del sistema operativo (AL2023) para determinar qué servicio de `Systemd` aplicar.
+ El sistema se inicia.
+ `Systemd` inicia el servicio `lustre-tunings` (debido a `WantedBy=multi-user.target`).
+ El servicio ejecuta `apply_lustre_tunings.sh`, que:
+ Verifica si el sistema de archivos está montado.
+ Monta el sistema de archivos si no está montado.
+ Espera a que se monte correctamente (hasta cinco minutos).
+ Aplica los parámetros de ajuste después de un montaje exitoso.
+ Los ajustes permanecen activos hasta el reinicio.
+ El servicio finaliza después de completar el script.
+ Systemd marca el servicio como “activo (finalizado)”.
+ El proceso se repite en el próximo reinicio.
## Crear una plantilla de lanzamiento
1. Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.
1. Seleccione **Plantillas de lanzamiento**.
1. Elija **Crear plantilla de inicialización**.
1. En **Detalles avanzados**, ubique la sección de **Datos de usuario**.
1. Pegue el siguiente script y actualice los valores según sea necesario.
**importante**
Ajuste estos valores según el entorno tanto en la sección `# 5. Mount FSx filesystem` como en la función `setup_persistence()` de `apply_lustre_tunings.sh` dentro de la sección `# 8. Setup persistence`:
```
FSX_DNS="" # Needs to be adjusted.
MOUNT_NAME="" # Needs to be adjusted.
MOUNT_POINT="" # Needs to be adjusted.
```
```
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="==MYBOUNDARY=="
--==MYBOUNDARY==
Content-Type: text/x-shellscript; charset="us-ascii"
#!/bin/bash
exec 1> >(logger -s -t $(basename $0)) 2>&1
# Function definitions
check_success() {
if [ $? -eq 0 ]; then
echo "SUCCESS: $1"
else
echo "FAILED: $1"
return 1
fi
}
apply_tunings() {
local NUM_CPUS=$(nproc)
local LRU_SIZE=$((100 * NUM_CPUS))
local params=(
"ldlm.namespaces.*.lru_max_age=600000"
"ldlm.namespaces.*.lru_size=$LRU_SIZE"
"llite.*.max_cached_mb=64"
"osc.*OST*.max_rpcs_in_flight=32"
"mdc.*.max_rpcs_in_flight=64"
"mdc.*.max_mod_rpcs_in_flight=50"
)
for param in "${params[@]}"; do
lctl set_param $param
check_success "Set ${param%%=*}"
done
}
verify_param() {
local param=$1
local expected=$2
local actual=$3
if [ "$actual" == "$expected" ]; then
echo "SUCCESS: $param is correctly set to $expected"
else
echo "WARNING: $param is set to $actual (expected $expected)"
fi
}
verify_tunings() {
local NUM_CPUS=$(nproc)
local LRU_SIZE=$((100 * NUM_CPUS))
local params=(
"ldlm.namespaces.*.lru_max_age:600000"
"ldlm.namespaces.*.lru_size:$LRU_SIZE"
"llite.*.max_cached_mb:64"
"osc.*OST*.max_rpcs_in_flight:32"
"mdc.*.max_rpcs_in_flight:64"
"mdc.*.max_mod_rpcs_in_flight:50"
)
echo "Verifying all parameters:"
for param in "${params[@]}"; do
name="${param%%:*}"
expected="${param#*:}"
actual=$(lctl get_param -n $name | head -1)
verify_param "${name##*.}" "$expected" "$actual"
done
}
setup_persistence() {
# Create functions file
cat << 'EOF' > /usr/local/bin/lustre_functions.sh
#!/bin/bash
apply_lustre_tunings() {
local NUM_CPUS=$(nproc)
local LRU_SIZE=$((100 * NUM_CPUS))
echo "Applying Lustre performance tunings..."
lctl set_param ldlm.namespaces.*.lru_max_age=600000
lctl set_param ldlm.namespaces.*.lru_size=$LRU_SIZE
lctl set_param llite.*.max_cached_mb=64
lctl set_param osc.*OST*.max_rpcs_in_flight=32
lctl set_param mdc.*.max_rpcs_in_flight=64
lctl set_param mdc.*.max_mod_rpcs_in_flight=50
}
EOF
# Create tuning script
cat << 'EOF' > /usr/local/bin/apply_lustre_tunings.sh
#!/bin/bash
exec 1> >(logger -s -t $(basename $0)) 2>&1
# Source the functions
source /usr/local/bin/lustre_functions.sh
# FSx details
FSX_DNS="" # Needs to be adjusted.
MOUNT_NAME="" # Needs to be adjusted.
MOUNT_POINT="" # Needs to be adjusted.
# Function to check if Lustre is mounted
is_lustre_mounted() {
mount | grep -q "type lustre"
}
# Function to mount Lustre
mount_lustre() {
echo "Mounting Lustre filesystem..."
mkdir -p ${MOUNT_POINT}
mount -t lustre ${FSX_DNS}@tcp:/${MOUNT_NAME} ${MOUNT_POINT}
return $?
}
# Main execution
# Try to mount if not already mounted
if ! is_lustre_mounted; then
echo "Lustre filesystem not mounted, attempting to mount..."
mount_lustre
fi
# Wait for successful mount (up to 5 minutes)
for i in {1..30}; do
if is_lustre_mounted; then
echo "Lustre filesystem mounted, applying tunings..."
apply_lustre_tunings
exit 0
fi
echo "Waiting for Lustre filesystem to be mounted... (attempt $i/30)"
sleep 10
done
echo "Timeout waiting for Lustre filesystem mount"
exit 1
EOF
# Create systemd service
cat << 'EOF' > /etc/systemd/system/lustre-tunings.service
[Unit]
Description=Apply Lustre Performance Tunings
After=network.target remote-fs.target
StartLimitIntervalSec=0
[Service]
Type=oneshot
ExecStart=/usr/local/bin/apply_lustre_tunings.sh
RemainAfterExit=yes
Restart=on-failure
RestartSec=30
[Install]
WantedBy=multi-user.target
EOF
chmod +x /usr/local/bin/lustre_functions.sh
chmod +x /usr/local/bin/apply_lustre_tunings.sh
systemctl enable lustre-tunings.service
systemctl start lustre-tunings.service
}
echo "Starting FSx for Lustre configuration..."
# 1. Install Lustre client
if grep -q 'VERSION="2"' /etc/os-release; then
amazon-linux-extras install -y lustre
elif grep -q 'VERSION="2023"' /etc/os-release; then
dnf install -y lustre-client
fi
check_success "Install Lustre client"
# 2. Apply network and RPC tunings
export PATH=$PATH:/usr/sbin
echo "Applying network and RPC tunings..."
if ! grep -q "options ptlrpc ptlrpcd_per_cpt_max" /etc/modprobe.d/modprobe.conf; then
echo "options ptlrpc ptlrpcd_per_cpt_max=64" | tee -a /etc/modprobe.d/modprobe.conf
echo "options ksocklnd credits=2560" | tee -a /etc/modprobe.d/modprobe.conf
fi
# 3. Load Lustre modules
modprobe lustre
check_success "Load Lustre modules" || exit 1
# 4. Lustre Network Initialization
lctl network up
check_success "Initialize Lustre networking" || exit 1
# 5. Mount FSx filesystem
FSX_DNS="" # Needs to be adjusted.
MOUNT_NAME="" # Needs to be adjusted.
MOUNT_POINT="" # Needs to be adjusted.
if [ ! -z "$FSX_DNS" ] && [ ! -z "$MOUNT_NAME" ]; then
mkdir -p $MOUNT_POINT
mount -t lustre ${FSX_DNS}@tcp:/${MOUNT_NAME} ${MOUNT_POINT}
check_success "Mount FSx filesystem"
fi
# 6. Apply tunings
apply_tunings
# 7. Verify tunings
verify_tunings
# 8. Setup persistence
setup_persistence
echo "FSx for Lustre configuration completed."
--==MYBOUNDARY==--
```
1. Al crear grupos de nodos de Amazon EKS, seleccione esta plantilla de lanzamiento. Para obtener más información, consulte [Creación de un grupo de nodos administrados para un clúster](create-managed-node-group.md).
## Información relacionada
+ [Implementación del controlador de FSx para Lustre](fsx-csi-create.md)
+ [Optimización del rendimiento de Amazon FSx para Lustre en nodos (EFA)](fsx-csi-tuning-efa.md)
+ [Amazon FSx for Lustre Performance](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html)
# Uso del almacenamiento de aplicaciones de alto rendimiento con FSx para NetApp ONTAP
NetApp Trident proporciona una orquestación dinámica del almacenamiento mediante un controlador compatible con la Interfaz de almacenamiento de contenedores (CSI). Esto permite a los clústeres de Amazon EKS administrar el ciclo de vida de los volúmenes persistentes (PV) respaldados por sistemas de archivos Amazon FSx para NetApp ONTAP. Tenga en cuenta que el controlador CSI de Amazon FSx para NetApp ONTAP no es compatible con los Nodos híbridos de Amazon EKS. Para comenzar, consulte [Use Trident with Amazon FSx for NetApp ONTAP](https://docs.netapp.com/us-en/trident/trident-use/trident-fsx.html) en la documentación de NetApp Trident.
Amazon FSx para ONTAP de NetApp es un servicio de almacenamiento que le permite lanzar y ejecutar sistemas de archivos ONTAP completamente administrados en la nube. ONTAP es la tecnología de sistema de archivos de NetApp que proporciona un conjunto ampliamente adoptado de capacidades de administración y de acceso a datos. FSx para ONTAP proporciona las características, el rendimiento y las API de los sistemas de archivos de NetApp en las instalaciones con la agilidad, escalabilidad y simplicidad de un servicio de completamente administrado de AWS. Para obtener más información, consulte la [Guía del usuario de FSx para ONTAP](https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/what-is-fsx-ontap.html).
**importante**
Si se utiliza Amazon FSx para NetApp ONTAP junto con el controlador CSI de Amazon EBS para aprovisionar volúmenes de EBS, es necesario especificar en el archivo `multipath.conf` que no se deben usar dispositivos EBS. Para conocer los métodos compatibles, consulte la [Lista de exclusión del archivo de configuración](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/dm_multipath/config_file_blacklist#config_file_blacklist). A continuación se muestra un ejemplo.
```
defaults {
user_friendly_names yes
find_multipaths no
}
blacklist {
device {
vendor "NVME"
product "Amazon Elastic Block Store"
}
}
```
# Uso del almacenamiento de datos con Amazon FSx para OpenZFS
Amazon FSx para OpenZFS es un servicio de almacenamiento de archivos completamente administrado que facilita el traslado de datos a AWS desde ZFS en las instalaciones u otros servidores de archivos basados en Linux. Puede hacerlo sin cambiar el código de la aplicación ni la forma en que administra los datos. Ofrece almacenamiento de archivos altamente confiable, escalable, eficiente y rico en características construido en el sistema de archivos OpenZFS de código abierto. Combina estas capacidades con la agilidad, la escalabilidad y la simplicidad de un servicio de AWS totalmente administrado. Para más información, consulte la [Guía del usuario de Amazon FSx para OpenZFS](https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/what-is-fsx.html).
El controlador de la interfaz de almacenamiento de contenedores (CSI) de FSx para OpenZFS proporciona una interfaz CSI que permite que los clústeres de Amazon EKS administren el ciclo de vida de los volúmenes de FSx para OpenZFS. Tenga en cuenta que el controlador de CSI de Amazon FSx para OpenZFS no es compatible con los Nodos híbridos de Amazon EKS. Para implementar el controlador CSI de FSx para OpenZFS en su clúster de Amazon EKS, consulte [aws-fsx-openzfs-csi-driver](https://github.com/kubernetes-sigs/aws-fsx-openzfs-csi-driver) en GitHub.
# Minimización de la latencia con Amazon File Cache
Amazon File Cache es una memoria caché de alta velocidad totalmente administrada en AWS que se utiliza para procesar datos de archivos, independientemente de dónde estén almacenados los datos. Amazon File Cache carga automáticamente los datos en la memoria caché cuando se accede a ella por primera vez y publica los datos cuando no se utilizan. Para obtener más información, consulte la [Guía del usuario de Amazon File Cache](https://docs.aws.amazon.com/fsx/latest/FileCacheGuide/what-is.html).
El controlador Container Storage Interface (CSI) de Amazon File Cache proporciona una interfaz CSI que permite a los clústeres de Amazon EKS administrar el ciclo de vida del almacenamiento caché de archivos de Amazon. Tenga en cuenta que el controlador CSI de Amazon File Cache no es compatible con los Nodos híbridos de Amazon EKS. Para implementar el controlador CSI de Amazon File Cache en su clúster de Amazon EKS, consulte [aws-file-cache-csi-driver](https://github.com/kubernetes-sigs/aws-file-cache-csi-driver) en GitHub.
# Acceso a los objetos de Amazon S3 mediante Mountpoint para Amazon S3 con el controlador CSI
Con el [controlador de interfaz de almacenamiento de contenedores (CSI) de Mountpoint para Amazon S3](https://github.com/awslabs/mountpoint-s3-csi-driver), las aplicaciones de Kubernetes pueden acceder a los objetos de Amazon S3 a través de una interfaz de sistema de archivos, lo que permite lograr un rendimiento total alto sin cambiar códigos de aplicaciones. Basado en [Mountpoint para Amazon S3](https://github.com/awslabs/mountpoint-s3), el controlador de CSI presenta un bucket de Amazon S3 como un volumen al que se puede acceder mediante contenedores de Amazon EKS y clústeres autoadministrados de Kubernetes.
## Consideraciones
+ El controlador de CSI de Mountpoint para Amazon S3 no es compatible con imágenes de contenedor basadas en Windows.
+ El controlador de CSI de Mountpoint para Amazon S3 no es compatible actualmente con los Nodos híbridos de Amazon EKS.
+ El controlador de CSI de Mountpoint para Amazon S3 no es compatible con AWS Fargate. Sin embargo, se admiten los contenedores que se ejecutan en Amazon EC2 (ya sea con Amazon EKS o con una instalación personalizada de Kubernetes).
+ El controlador de CSI de Mountpoint para Amazon S3 solo admite el aprovisionamiento estático. No se admite el aprovisionamiento dinámico o la creación de nuevos buckets.
**nota**
El aprovisionamiento estático se refiere al uso de un bucket de Amazon S3 existente que se especifica como `bucketName` en el `volumeAttributes` del objeto `PersistentVolume`. Para obtener más información, consulte [Static Provisioning](https://github.com/awslabs/mountpoint-s3-csi-driver/blob/main/examples/kubernetes/static_provisioning/README.md) en GitHub.
+ Los volúmenes montados con el controlador de CSI de Mountpoint para Amazon S3 no admiten todas las características del sistema de archivos POSIX. Para obtener más información sobre el comportamiento del sistema de archivos, consulte [Mountpoint for Amazon S3 file system behavior](https://github.com/awslabs/mountpoint-s3/blob/main/doc/SEMANTICS.md) en GitHub.
Para obtener información sobre la implementación del controlador, consulte [Implementación del controlador de Mountpoint para Amazon S3](s3-csi-create.md). Para obtener información sobre la eliminación del controlador, consulte [Cómo eliminar el complemento de Amazon EKS Mountpoint para Amazon S3](removing-s3-csi-eks-add-on.md).
# Implementación del controlador de Mountpoint para Amazon S3
Con el [controlador de interfaz de almacenamiento de contenedores (CSI) de Mountpoint para Amazon S3](https://github.com/awslabs/mountpoint-s3-csi-driver), las aplicaciones de Kubernetes pueden acceder a los objetos de Amazon S3 a través de una interfaz de sistema de archivos, lo que permite lograr un rendimiento total alto sin cambiar códigos de aplicaciones.
Este procedimiento muestra cómo implementar el [controlador de CSI de Mountpoint para Amazon S3 de Amazon EKS](s3-csi.md). Antes de continuar, revise las [Consideraciones](s3-csi.md#s3-csi-considerations).
## Requisitos previos
+ Un proveedor existente de OpenID Connect (OIDC) de AWS Identity and Access Management (IAM) para su clúster. Para determinar si ya tiene un proveedor o para crear uno, 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 de AWS CLI instalada y configurada en su dispositivo o 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 una política de IAM
El controlador de CSI de Mountpoint para Amazon S3 requiere permisos de Amazon S3 para interactuar con el sistema de archivos. En esta sección se muestra cómo crear una política de IAM que conceda los permisos necesarios.
El siguiente ejemplo de política sigue las recomendaciones de permisos de IAM para Mountpoint. Como alternativa, puede utilizar la política administrada de AWS [AmazonS3FullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonS3FullAccess$jsonEditor), pero esta política administrada concede más permisos de los necesarios para Mountpoint.
Para obtener más información sobre los permisos recomendados por Mountpoint, consulte [Mountpoint IAM permissions](https://github.com/awslabs/mountpoint-s3/blob/main/doc/CONFIGURATION.md#iam-permissions) en GitHub.
1. Abra la consola de IAM en https://console.aws.amazon.com/iam/.
1. En el panel de navegación izquierdo, elija **Políticas**.
1. En la página **Políticas**, seleccione **Crear una política**.
1. En el **editor de políticas**, seleccione **JSON**.
1. En el **editor de políticas**, copie y pegue lo siguiente:
**importante**
Reemplace `amzn-s3-demo-bucket1` por el nombre de su bucket de Amazon S3.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "MountpointFullBucketAccess",
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1"
]
},
{
"Sid": "MountpointFullObjectAccess",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
Los buckets de directorio, introducidos con la clase de almacenamiento Amazon S3 Express One Zone, utilizan un mecanismo de autenticación diferente al de los buckets de uso general. En lugar de utilizar acciones `s3:*`, debe utilizar la acción `s3express:CreateSession`. Para más información sobre los buckets de directorio, consulte [Buckets de directorio](https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html) en la *Guía de usuario de Amazon S3*.
A continuación, se muestra un ejemplo de política de privilegios mínimos que utilizaría para un bucket de directorios.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3express:CreateSession",
"Resource": "arn:aws:s3express:us-west-2:111122223333:bucket/amzn-s3-demo-bucket1--usw2-az1--x-s3"
}
]
}
```
1. Elija **Siguiente**.
1. En la página **Revisar y crear**, asigne un nombre a la política. En este tutorial de ejemplo se utiliza el nombre `AmazonS3CSIDriverPolicy`.
1. Elija **Crear política**.
## Paso 2: creación de un rol de IAM
El controlador de CSI de Mountpoint para Amazon S3 requiere permisos de Amazon S3 para interactuar con el sistema de archivos. En esta sección se muestra cómo crear un rol de IAM para delegar estos permisos. Para crear este rol, puede utilizar una de las siguientes herramientas:
+ [eksctl](#eksctl_s3_store_app_data)
+ [Consola de administración de AWS](#console_s3_store_app_data)
+ [AWS CLI](#awscli_s3_store_app_data)
**nota**
La política de IAM `AmazonS3CSIDriverPolicy` se creó en la sección anterior.
### eksctl
**Creación del rol de IAM del controlador de CSI de Mountpoint para Amazon S3 con `eksctl` **
Para crear el rol de IAM y la cuenta de servicio de Kubernetes, ejecute los siguientes comandos. Estos comandos también asocian la política de IAM `AmazonS3CSIDriverPolicy` al rol, anotan la cuenta de servicio de Kubernetes (`s3-csi-controller-sa`) con el Nombre de recurso de Amazon (ARN) del rol de IAM y agregan el nombre de la cuenta de servicio de Kubernetes a la política de confianza correspondiente al rol de IAM.
```
CLUSTER_NAME=my-cluster
REGION=region-code
ROLE_NAME=AmazonEKS_S3_CSI_DriverRole
POLICY_ARN=AmazonEKS_S3_CSI_DriverRole_ARN
eksctl create iamserviceaccount \
--name s3-csi-driver-sa \
--namespace kube-system \
--cluster $CLUSTER_NAME \
--attach-policy-arn $POLICY_ARN \
--approve \
--role-name $ROLE_NAME \
--region $REGION \
--role-only
```
### 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. 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.
Si no se muestra ninguna URL, consulte la sección [Requisitos previos](#s3-csi-prereqs).
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**, ingrese AmazonS3CSIDriverPolicy.
**nota**
Esta política se creó en la sección anterior.
1. Marque la casilla situada a la izquierda del resultado de `AmazonS3CSIDriverPolicy` 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\$1S3\$1CSI\$1DriverRole.
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, seleccione el rol en la consola 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"
```
Agregue una coma al final de la línea anterior y, luego, agregue la siguiente línea después de esta. Reemplace *region-code* por la región de AWS en la que se encuentra el clúster. Reemplace *EXAMPLED539D4633E53DE1B71EXAMPLE* con el ID de proveedor de OIDC de su clúster.
```
"oidc.eks.region-code.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:s3-csi-driver-sa"
```
1. Asegúrese de que el operador `Condition` esté configurado en `"StringEquals"`.
1. Elija **Actualizar política** para terminar.
### AWS CLI
1. Vea la URL del proveedor de OIDC para su clúster. Reemplace *my-cluster* por el nombre de su clúster. Si la salida del comando es `None`, revise los [Requisitos previos](#s3-csi-prereqs).
```
aws eks describe-cluster --name my-cluster --query "cluster.identity.oidc.issuer" --output text
```
Un ejemplo de salida sería el siguiente.
```
https://oidc.eks.region-code.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE
```
1. Cree el rol de IAM otorgándole a la cuenta de servicio de Kubernetes la acción `AssumeRoleWithWebIdentity`.
1. Copie los siguientes contenidos en un archivo denominado `aws-s3-csi-driver-trust-policy.json`. Reemplace *111122223333* por el ID de su 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.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:s3-csi-driver-sa",
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
}
}
}
]
}
```
1. Creación del rol. Puede cambiar el nombre de *AmazonEKS\$1S3\$1CSI\$1DriverRole*, pero si lo hace, asegúrese de cambiarlo también en los pasos posteriores.
```
aws iam create-role \
--role-name AmazonEKS_S3_CSI_DriverRole \
--assume-role-policy-document file://"aws-s3-csi-driver-trust-policy.json"
```
1. Cree un rol de IAM y adjunte la política de IAM creada previamente al rol con el siguiente comando.
```
aws iam attach-role-policy \
--policy-arn arn:aws:iam::aws:policy/AmazonS3CSIDriverPolicy \
--role-name AmazonEKS_S3_CSI_DriverRole
```
**nota**
La política de IAM `AmazonS3CSIDriverPolicy` se creó en la sección anterior.
1. Omita este paso si va a instalar el controlador como complemento de Amazon EKS. Para las instalaciones autoadministradas del controlador, cree cuentas de servicio de Kubernetes que estén anotadas con el ARN del rol de IAM que creó.
1. Guarde los siguientes contenidos en un archivo llamado `mountpoint-s3-service-account.yaml`. Reemplace *111122223333* por el ID de su cuenta.
```
---
apiVersion: v1
kind: ServiceAccount
metadata:
labels:
app.kubernetes.io/name: aws-mountpoint-s3-csi-driver
name: mountpoint-s3-csi-controller-sa
namespace: kube-system
annotations:
eks.amazonaws.com/role-arn: arn:aws:iam::111122223333:role/AmazonEKS_S3_CSI_DriverRole
```
1. Cree la cuenta de servicio de Kubernetes en el clúster. La cuenta de servicio de Kubernetes (`mountpoint-s3-csi-controller-sa`) está anotada con el rol de IAM que creó con el nombre *AmazonEKS\$1S3\$1CSI\$1DriverRole*.
```
kubectl apply -f mountpoint-s3-service-account.yaml
```
**nota**
Cuando implementa el complemento en este procedimiento, crea una cuenta de servicio que se llama `s3-csi-driver-sa` y se configura para utilizarla.
## Paso 3: instalación del controlador de CSI de Mountpoint para Amazon S3
Puede instalar el controlador de CSI de Mountpoint para Amazon S3 a través del complemento de Amazon EKS. Puede usar las herramientas a continuación para agregar el complemento a su clúster:
+ [eksctl](#eksctl_s3_add_store_app_data)
+ [Consola de administración de AWS](#console_s3_add_store_app_data)
+ [AWS CLI](#awscli_s3_add_store_app_data)
Como alternativa, puede instalar el controlador de CSI de Mountpoint para Amazon S3 como instalación autoadministrada. Para obtener instrucciones sobre cómo efectuar una instalación autoadministrada, consulte [Installation](https://github.com/awslabs/mountpoint-s3-csi-driver/blob/main/docs/install.md#deploy-driver) en GitHub.
A partir de la versión `v1.8.0`, es posible configurar taints para tolerar los pods del controlador de CSI. Para ello, especifique un conjunto personalizado de taints para tolerar con `node.tolerations` o tolere todas las taints con `node.tolerateAllTaints`. Para obtener más información, consulte [Taints y toleraciones](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/) en la documentación de Kubernetes.
### eksctl
**Agregar el complemento CSI de Amazon S3 con `eksctl` **
Ejecute el siguiente comando. Reemplace *my-cluster* por el nombre del clúster, *111122223333* por el ID de cuenta y *AmazonEKS\$1S3\$1CSI\$1DriverRole* por el nombre del [rol de IAM creado anteriormente](#s3-create-iam-role).
```
eksctl create addon --name aws-mountpoint-s3-csi-driver --cluster my-cluster \
--service-account-role-arn arn:aws:iam::111122223333:role/AmazonEKS_S3_CSI_DriverRole --force
```
Si quita la opción *--force* y cualquiera de las configuraciones del complemento de Amazon EKS entran en conflicto con la configuración existente, se produce un error al actualizar el complemento de Amazon EKS y recibe un mensaje de error para ayudarlo a resolver el conflicto. Antes de especificar esta opción, asegúrese de que el complemento de Amazon EKS no administra la configuración que necesita administrar, ya que dicha configuración se sobrescribe con esta opción. Para obtener más información acerca de otras opciones para este ajuste, consulte [Addons](https://eksctl.io/usage/addons/) (Complementos) en la documentación de `eksctl`. Para obtener más información sobre el campo de administración de Kubernetes de Amazon EKS, consulte [Determinación de los campos que se pueden personalizar para los complementos de Amazon EKS](kubernetes-field-management.md).
Puede personalizar `eksctl` mediante archivos de configuración. Para obtener más información, consulte [Trabajar con valores de configuración](https://eksctl.io/usage/addons/#working-with-configuration-values) en la documentación de `eksctl`. En el siguiente ejemplo se demuestra cómo tolerar todas las taints.
```
# config.yaml
...
addons:
- name: aws-mountpoint-s3-csi-driver
serviceAccountRoleARN: arn:aws:iam::111122223333:role/AmazonEKS_S3_CSI_DriverRole
configurationValues: |-
node:
tolerateAllTaints: true
```
### Consola de administración de AWS
1. Abra la [consola de Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).
1. En el panel de navegación izquierdo, elija **Clusters (Clústeres)**.
1. Seleccione el nombre del clúster para el cual desea configurar el complemento de CSI de Mountpoint para Amazon S3.
1. Elija la pestaña **Complementos**.
1. Escoja **Obtener más complementos**.
1. En la página **Seleccionar complementos**, haga lo siguiente:
1. En la sección **Complementos de Amazon EKS**, seleccione la casilla de verificación **Controlador de CSI de Mountpoint para Amazon S3**.
1. Elija **Siguiente**.
1. En la página **Configurar las opciones de complementos seleccionados**, haga lo siguiente:
1. Seleccione la **Versión** que desea utilizar.
1. En **Seleccionar rol de IAM**, seleccione el nombre de un rol de IAM al que le haya adjuntado la política de IAM del controlador de CSI de Mountpoint para Amazon S3.
1. (Opcional) Actualice el **método de resolución de conflictos** después de ampliar los **ajustes de configuración opcionales**. Si selecciona **Anular**, es posible que una o varias configuraciones del complemento existente se sobrescriban con la configuración del complemento de Amazon EKS. Si no habilita esta opción y hay un conflicto con la configuración existente, la operación falla. Puede utilizar el mensaje de error resultante para solucionar el conflicto. Antes de seleccionar esta opción, asegúrese de que el complemento de Amazon EKS no administra las configuraciones que se necesitan autoadministrar.
1. (Opcional) Configure las tolerancias en el campo **Valores de configuración** después de **ampliar los ajustes de configuración opcionales**.
1. Elija **Siguiente**.
1. En la página **Revisar y añadir**, elija **Crear**. Una vez finalizada la instalación del complemento, verá el complemento instalado.
### AWS CLI
**Adición del complemento de CSI de Mountpoint para Amazon S3 mediante la AWS CLI**
Ejecute el siguiente comando. Reemplace *my-cluster* por el nombre del clúster, *111122223333* por el ID de cuenta y *AmazonEKS\$1S3\$1CSI\$1DriverRole* por el nombre del rol creado anteriormente.
```
aws eks create-addon --cluster-name my-cluster --addon-name aws-mountpoint-s3-csi-driver \
--service-account-role-arn arn:aws:iam::111122223333:role/AmazonEKS_S3_CSI_DriverRole
```
Puede personalizar el comando con la marca `--configuration-values`. El siguiente ejemplo alternativo muestra cómo tolerar todas las taints.
```
aws eks create-addon --cluster-name my-cluster --addon-name aws-mountpoint-s3-csi-driver \
--service-account-role-arn arn:aws:iam::111122223333:role/AmazonEKS_S3_CSI_DriverRole \
--configuration-values '{"node":{"tolerateAllTaints":true}}'
```
## Paso 4: configuración de Mountpoint para Amazon S3
En la mayoría de los casos, puede configurar Mountpoint para Amazon S3 solo con un nombre de bucket. Para obtener instrucciones sobre la configuración de Mountpoint para Amazon S3, consulte [Configuring Mountpoint for Amazon S3](https://github.com/awslabs/mountpoint-s3/blob/main/doc/CONFIGURATION.md) en GitHub.
## Paso 5: implementación de una aplicación de muestra
Puede implementar el aprovisionamiento estático en el controlador de un bucket de Amazon S3 existente. Para obtener más información, consulte [Static provisioning](https://github.com/awslabs/mountpoint-s3-csi-driver/blob/main/examples/kubernetes/static_provisioning/README.md) en GitHub.
# Cómo eliminar el complemento de Amazon EKS Mountpoint para Amazon S3
Tiene dos opciones para eliminar el [controlador de CSI de Mountpoint para Amazon S3](s3-csi.md).
+ **Conservar el software del complemento en el clúster**: esta opción elimina la administración de Amazon EKS de cualquier configuración. También elimina la capacidad de Amazon EKS de notificarle las actualizaciones y actualizar de forma automática el complemento de Amazon EKS después de iniciar una actualización. Sin embargo, conserva el software del complemento en el clúster. Esta opción hace que la instalación sea autoadministrada, en lugar de un complemento de Amazon EKS. Con esta opción, no hay tiempo de inactividad para el complemento. Los comandos de este procedimiento utilizan esta opción.
+ **Eliminar por completo el software del complemento del clúster**: recomendamos que elimine el complemento de Amazon EKS del clúster solo si no hay recursos en el clúster que dependan de él. Para hacer esta opción, elimine `--preserve` del comando que utiliza en este procedimiento.
Si el complemento tiene una cuenta de IAM asociada, esta no se elimina.
Puede usar las herramientas a continuación para eliminar el complemento Amazon S3 CSI.
+ [eksctl](#eksctl_s3_remove_store_app_data)
+ [Consola de administración de AWS](#console_s3_remove_store_app_data)
+ [AWS CLI](#awscli_s3_remove_store_app_data)
## eksctl
**Eliminar el complemento Amazon S3 CSI con `eksctl` **
Reemplace *my-cluster* por el nombre de su clúster y ejecute el siguiente comando.
```
eksctl delete addon --cluster my-cluster --name aws-mountpoint-s3-csi-driver --preserve
```
## Consola de administración de AWS
1. Abra la [consola de Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).
1. En el panel de navegación izquierdo, elija **Clusters (Clústeres)**.
1. Elija el nombre del clúster para el que desea eliminar el complemento CSI de Amazon EBS.
1. Elija la pestaña **Complementos**.
1. Elija **Controlador de CSI de Mountpoint para Amazon S3**.
1. Elija **Eliminar**.
1. En el cuadro de diálogo de confirmación **Eliminar: aws-mountpoint-s3-csi-driver**, haga lo siguiente:
1. Si desea que Amazon EKS deje de administrar la configuración del complemento, seleccione **Conservar en clúster**. Haga esto si desea retener el software del complemento en el clúster. Esto es para que pueda administrar todas las configuraciones del complemento por su cuenta.
1. Escriba `aws-mountpoint-s3-csi-driver`.
1. Seleccione **Eliminar**.
## AWS CLI
**Eliminar el complemento Amazon S3 CSI con la AWS CLI**
Reemplace *my-cluster* por el nombre de su clúster y ejecute el siguiente comando.
```
aws eks delete-addon --cluster-name my-cluster --addon-name aws-mountpoint-s3-csi-driver --preserve
```
# Habilitación de la funcionalidad de instantáneas para volúmenes de CSI
La funcionalidad de instantáneas permite hacer copias de un momento dado de los datos. Para que esta capacidad funcione en Kubernetes, necesita un controlador de CSI compatible con instantáneas (como el controlador de CSI de Amazon EBS) y un controlador de instantáneas de CSI. El controlador de instantáneas está disponible como complemento administrado por Amazon EKS o como instalación autoadministrada.
Aquí se incluyen algunos aspectos que debe tener en cuenta cuando se utiliza el controlador de instantáneas CSI.
+ El controlador de instantáneas debe instalarse junto con un controlador de CSI con funcionalidad de captura de instantáneas. Para obtener instrucciones acerca de cómo instalar el controlador de CSI de Amazon EBS, consulte [Uso del almacenamiento de volúmenes de Kubernetes con Amazon EBS](ebs-csi.md).
+ Kubernetes no admite instantáneas de volúmenes que se entreguen mediante la migración de CSI, como los volúmenes de Amazon EBS que utilizan `StorageClass` con un aprovisionador `kubernetes.io/aws-ebs`. Los volúmenes deben crearse con un `StorageClass` que haga referencia al aprovisionador de controladores CSI `ebs.csi.aws.com`.
+ El modo automático de Amazon EKS no incluye el controlador de instantáneas. La capacidad de almacenamiento del modo automático de EKS es compatible con el controlador de instantáneas.
Le recomendamos que instale el controlador de instantáneas CSI a través del complemento administrado de Amazon EKS. Este complemento incluye las definiciones de recursos personalizadas (CRD) necesarias para crear y administrar instantáneas en 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).
Como alternativa, si prefiere una instalación autoadministrada del controlador de instantáneas CSI de Amazon EBS, consulte [Uso](https://github.com/kubernetes-csi/external-snapshotter/blob/master/README.md#usage) en la versión anterior de `external-snapshotter` de Kubernetes en GitHub.