Formación en machine learning con Elastic Fabric Adapter - Amazon EKS
Crear un grupo de nodos(Opcional) Implementar una aplicación de ejemplo compatible con EFA

Ayude a mejorar esta página

¿Quiere contribuir a esta guía del usuario? Desplácese hasta el final de esta página y seleccione Editar esta página en GitHub. Sus contribuciones ayudarán a que nuestra guía del usuario sea mejor para todos.

Formación en machine learning con Elastic Fabric Adapter

En este tema se describe cómo integrar Elastic Fabric Adapter (EFA) con los Pods implementados en el clúster de Amazon EKS. Elastic Fabric Adapter (EFA) es una interfaz de red para instancias de Amazon EC2 que le permite ejecutar aplicaciones que requieren altos niveles de comunicaciones entre nodos a escala en AWS. Su interfaz de hardware de bypass del sistema operativo diseñada a medida mejora el rendimiento de las comunicaciones entre instancias, lo que es fundamental para ajustar la escala de estas aplicaciones. Con EFA, las aplicaciones de High Performance Computing (HPC, informática de alto rendimiento) que utilizan la Message Passing Interface (MPI, interfaz de paso de mensajes) y las aplicaciones de Machine Learning (ML) que utilizan NVIDIA Collective Communications Library (NCCL, Biblioteca de comunicación colectiva de NVIDIA) pueden aumentar su escala a miles de CPU o GPU. Como resultado, obtiene el rendimiento de las aplicaciones de los clústeres HPC en las instalaciones con la elasticidad y flexibilidad bajo demanda de la nube de AWS. La integración de Elastic Fabric Adapter (EFA) con aplicaciones que se ejecutan en clústeres de Amazon EKS puede reducir el tiempo necesario para completar cargas de trabajo de formación distribuidas a gran escala sin tener que agregar instancias adicionales al clúster. Para obtener más información sobre EFA, consulte Elastic Fabric Adapter.

El complemento de EFA descrito en este tema es totalmente compatible con las instancias de Amazon EC2 P4d, que representan la tecnología de vanguardia en machine learning distribuido en la nube. Cada instancia p4d.24xlarge tiene ocho GPU NVIDIA A100 y GPUDirectRDMA de 400 Gbps sobre EFA. GPUDirectRDMA le permite tener comunicación directa de GPU a GPU a través de nodos con bypass de CPU, lo que aumenta el ancho de banda de comunicación colectiva y reduce la latencia. La integración de Amazon EKS y EFA con instancias P4d proporciona un método perfecto para aprovechar la instancia informática de Amazon EC2 de mayor rendimiento para la formación de machine learning distribuido.

Requisitos previos

  • Un clúster existente de Amazon EKS. Si no dispone de un clúster existente, utilice una de nuestras guías Introducción a Amazon EKS para crear uno. El clúster debe implementarse en una VPC que tenga al menos una subred privada con suficientes direcciones IP disponibles para implementar nodos en ella. La subred privada debe tener acceso a Internet saliente proporcionado por un dispositivo externo, como una puerta de enlace NAT.

    Si planea usar eksctl para crear su grupo de nodos, eksctl también puede crear un clúster por usted.

  • La versión 2.12.3 o posterior, o bien, la versión 1.27.160 o posterior de la AWS Command Line Interface (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 tales 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 Instalar, actualizar y desinstalar la AWS CLI y Configuración rápida con aws configure en la Guía del usuario de AWS Command Line Interface. 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 AWS CLI en el directorio de inicio 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 Instalación o actualización del kubectl.

  • Debe tener instalada la versión Amazon VPC CNI plugin for Kubernetes 1.7.10 o posterior antes de lanzar nodos de trabajo que admitan varios Elastic Fabric Adapters, como la p4d.24xlarge. Para obtener más información sobre cómo actualizar Amazon VPC CNI plugin for Kubernetes, consulte Trabajar con el complemento Amazon VPC CNI plugin for Kubernetes de Amazon EKS.

Crear un grupo de nodos

El procedimiento siguiente ayuda a crear un grupo de nodos con un grupo de nodos con respaldo de p4d.24xlarge con interfaces EFA y RDMA GPUDirect. También lo ayuda a ejecutar una prueba de ejemplo de NVIDIA Collective Communications Library (NCCL) para descubrir el rendimiento NCCL de varios nodos mediante el uso de EFA. El ejemplo se puede utilizar en una plantilla para la formación de aprendizaje profundo distribuida en Amazon EKS mediante EFA.

  1. Determine qué tipos de instancias de Amazon EC2 compatibles con EFA están disponibles en la Región de AWS en la que desea implementar los nodos. Reemplace region-code por la Región de AWS en la que desea implementar su grupo de nodos.

    aws ec2 describe-instance-types --region region-code --filters Name=network-info.efa-supported,Values=true \
    --query "InstanceTypes[*].[InstanceType]" --output text

    Al implementar nodos, el tipo de instancia que desea implementar debe estar disponible en la Región de AWS en el que está su clúster.

  2. Determine en qué zonas de disponibilidad está disponible el tipo de instancia que desea implementar. En este tutorial, el tipo de instancia p4d.24xlarge se utiliza el tipo de instancia y se debe devolver en la salida de la Región de AWS que especificó en el paso anterior. Cuando implemente nodos en un clúster de producción, sustituya p4d.24xlarge con cualquier tipo de instancia que se devolvió en el paso anterior. 

    aws ec2 describe-instance-type-offerings --region region-code --location-type availability-zone --filters Name=instance-type,Values=p4d.24xlarge \
    --query 'InstanceTypeOfferings[*].Location' --output text

    Un ejemplo de salida sería el siguiente.

    us-west-2a    us-west-2c    us-west-2b

    Tenga en cuenta las zonas de disponibilidad devueltas para su uso en pasos posteriores. Al implementar nodos en un clúster, la VPC debe tener subredes con direcciones IP disponibles en una de las zonas de disponibilidad que se muestran en el resultado.

  3. Cree un grupo de nodos mediante eksctl o la AWS CLI y AWS CloudFormation.

    eksctl
    Requisito previo

    La versión 0.183.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 en la documentación de eksctl.

    1. Copie el siguiente contenido en un archivo denominado efa-cluster.yaml. Reemplace los example values por los de su propiedad. Puede reemplazar p4d.24xlarge por una instancia diferente, pero si lo hace, asegúrese de que los valores de availabilityZones sean zonas de disponibilidad que se devolvieron para el tipo de instancia en el paso uno.

      apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: my-efa-cluster
  region: region-code
  version: "1.XX"

iam:
  withOIDC: true

availabilityZones: ["us-west-2a", "us-west-2c"]  

managedNodeGroups:
  - name: my-efa-ng
    instanceType: p4d.24xlarge
    minSize: 1
    desiredCapacity: 2
    maxSize: 3
    availabilityZones: ["us-west-2a"]
    volumeSize: 300
    privateNetworking: true
    efaEnabled: true

    2. Cree un grupo de nodos administrados en un clúster existente.

      eksctl create nodegroup -f efa-cluster.yaml

      Si no dispone de un clúster existente, puede ejecutar el siguiente comando para crear un clúster y el grupo de nodos.

      eksctl create cluster -f efa-cluster.yaml
      nota

      Como el tipo de instancia que se usa en este ejemplo tiene GPU,eksctl instala automáticamente el complemento de dispositivo NVIDIA Kubernetes en cada instancia por ti.

    AWS CLI and AWS CloudFormation

    Existen varios requisitos para las redes de EFA, entre ellos la creación de un grupo de seguridad específico de EFA, la creación de un grupo de ubicación de Amazon EC2 y la creación de una plantilla de lanzamiento que especifique una o varias interfaces de EFA e incluya la instalación del controlador de EFA como parte de los datos del usuario de Amazon EC2. Para obtener más información sobre los requisitos de EFA, consulte Introducción a EFA y MPI en la Guía del usuario de Amazon EC2. Los siguientes pasos crean todo esto. Sustituya los valores de ejemplo por sus propios valores.

    1. Defina algunas variables que se utilizan en pasos posteriores. Sustituya todos los example values con los suyos propios. Reemplace my-cluster por el nombre de su clúster existente. El valor de node_group_resources_name se utiliza más tarde para crear una pila de AWS CloudFormation. El valor de node_group_name se utiliza más tarde para crear el grupo de nodos en el clúster.

      cluster_name="my-cluster"
cluster_region="region-code"
node_group_resources_name="my-efa-nodegroup-resources"
node_group_name="my-efa-nodegroup"

    2. Identifique una subred privada de la VPC que se encuentre en la misma zona de disponibilidad en la que está disponible el tipo de instancia en el que desea implementar.

      1. Recupere la versión del clúster y guárdela en una variable para utilizarla en un paso posterior.

        cluster_version=$(aws eks describe-cluster \
    --name $cluster_name \
    --query "cluster.version" \
    --output text)

      2. Recupere el ID de VPC en el que se encuentra el clúster y guárdelo en una variable para utilizarlo en un paso posterior.

        vpc_id=$(aws eks describe-cluster \
    --name $cluster_name \
    --query "cluster.resourcesVpcConfig.vpcId" \
    --output text)

      3. Recupere el ID del grupo de seguridad del plano de control del clúster y guárdelo en una variable para utilizarlo en un paso posterior.

        control_plane_security_group=$(aws eks describe-cluster \
    --name $cluster_name \
    --query "cluster.resourcesVpcConfig.clusterSecurityGroupId" \
    --output text)

      4. Obtenga la lista de ID de subred de la VPC que se encuentran en una zona de disponibilidad devuelta en el paso uno.

        aws ec2 describe-subnets \
    --filters "Name=vpc-id,Values=$vpc_id" "Name=availability-zone,Values=us-west-2a" \
    --query 'Subnets[*].SubnetId' \
    --output text

        Si no se devuelve ninguna salida, pruebe con una zona de disponibilidad diferente que se devuelve en el paso uno. Si ninguna de las subredes se encuentra en una zona de disponibilidad devuelta en el paso 1, deberá crear una subred en una zona de disponibilidad devuelta en el paso uno. Si no tiene espacio en la VPC para crear otra subred, puede agregar un bloque de CIDR a la VPC y crear subredes en el nuevo bloque de CIDR, o bien crear un nuevo clúster en una VPC nueva.

      5. Para determinar si la subred es una subred privada, verifique la tabla de enrutamiento de la subred.

        aws ec2 describe-route-tables \
    --filter Name=association.subnet-id,Values=subnet-0d403852a65210a29 \
    --query "RouteTables[].Routes[].GatewayId" \
    --output text

        Un ejemplo de salida sería el siguiente.

        local

        Si la salida es local igw-02adc64c1b72722e2, entonces la subred es una subred pública. Debe seleccionar una subred privada en una zona de disponibilidad devuelta en el paso uno. Una vez que ha identificado una subred privada, tenga en cuenta su ID para su uso en un paso posterior.

      6. Establezca una variable con el ID de subred privada del paso anterior para utilizarla en pasos posteriores.

        subnet_id=your-subnet-id

    3. Descargue la plantilla de AWS CloudFormation.

      curl -O https://raw.githubusercontent.com/aws-samples/aws-efa-eks/main/cloudformation/efa-p4d-managed-nodegroup.yaml

    4. Copie el siguiente texto en el equipo. Reemplace p4d.24xlarge por un tipo de instancia del paso uno. Reemplace subnet-0d403852a65210a29 con el ID de la subred privada que identificó en el paso 2.b.v. Reemplace path-to-downloaded-cfn-template por la ruta al archivo efa-p4d-managed-nodegroup.yaml que descargó en el paso anterior. Reemplace your-public-key-name con el nombre de su clave pública. Una vez que haya realizado las sustituciones, ejecute el comando modificado.

      aws cloudformation create-stack \
    --stack-name ${node_group_resources_name} \
    --capabilities CAPABILITY_IAM \
    --template-body file://path-to-downloaded-cfn-template \
    --parameters \
       ParameterKey=ClusterName,ParameterValue=${cluster_name} \
       ParameterKey=ClusterControlPlaneSecurityGroup,ParameterValue=${control_plane_security_group} \
       ParameterKey=VpcId,ParameterValue=${vpc_id} \
       ParameterKey=SubnetId,ParameterValue=${subnet_id} \
       ParameterKey=NodeGroupName,ParameterValue=${node_group_name} \
       ParameterKey=NodeImageIdSSMParam,ParameterValue=/aws/service/eks/optimized-ami/${cluster_version}/amazon-linux-2-gpu/recommended/image_id \
       ParameterKey=KeyName,ParameterValue=your-public-key-name \
       ParameterKey=NodeInstanceType,ParameterValue=p4d.24xlarge

    5. Determine cuándo se implementa la pila que implementó en el paso anterior.

      aws cloudformation wait stack-create-complete --stack-name $node_group_resources_name

      No hay salida del comando anterior, pero el símbolo del intérprete de comandos no regresa hasta que se crea la pila.

    6. Cree su grupo de nodos utilizando los recursos creados por la pila de AWS CloudFormation en el paso anterior.

      1. Recupere información de la pila de AWS CloudFormation implementada y almacénela en variables.

        node_instance_role=$(aws cloudformation describe-stacks \
    --stack-name $node_group_resources_name \
    --query='Stacks[].Outputs[?OutputKey==`NodeInstanceRole`].OutputValue' \
    --output text)
launch_template=$(aws cloudformation describe-stacks \
    --stack-name $node_group_resources_name \
    --query='Stacks[].Outputs[?OutputKey==`LaunchTemplateID`].OutputValue' \
    --output text)

      2. Cree un grupo de nodos administrados que utilice la plantilla de lanzamiento y el rol de IAM de nodo que se crearon en el paso anterior.

        aws eks create-nodegroup \
    --cluster-name $cluster_name \
    --nodegroup-name $node_group_name \
    --node-role $node_instance_role \
    --subnets $subnet_id \
    --launch-template id=$launch_template,version=1

      3. Confirme que se crearon los nodos.

        aws eks describe-nodegroup \
   --cluster-name ${cluster_name} \
   --nodegroup-name ${node_group_name} | jq -r .nodegroup.status

        No continúe hasta que el estado devuelto por el comando anterior sea ACTIVE. Los nodos pueden tardar varios minutos en estar listos.

    7. Si elige un tipo de instancia de GPU, debe implementar el Plugin de dispositivo NVIDIA para Kubernetes. Reemplace vX.X.X con la versión Plugin de dispositivo NVidia/K8S deseada antes de ejecutar el siguiente comando.

      kubectl apply -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/vX.X.X/nvidia-device-plugin.yml

  4. Implemente el complemento de EFA del dispositivo de Kubernetes.

    El complemento de EFA del dispositivo de Kubernetes detecta y anuncia interfaces de EFA como recursos asignables a Kubernetes. Una aplicación puede consumir el tipo de recurso ampliado vpc.amazonaws.com/efa en una especificación de solicitud de Pod al igual que la CPU y la memoria. Para obtener más información, consulte Consumir recursos ampliados en la documentación de Kubernetes. Una vez solicitado, el complemento asigna automáticamente una interfaz de EFA al Pod y la monta en él. El uso del complemento del dispositivo simplifica la configuración de EFA y no requiere que un Pod se ejecute en modo privilegiado.

    helm repo add eks https://aws.github.io/eks-chart
helm install aws-efa-k8s-device-plugin --namespace kube-system eks/aws-efa-k8s-device-plugin

(Opcional) Implementar una aplicación de ejemplo compatible con EFA

Implementar el operador MPI de Kubeflow

Para las pruebas NCCL puede aplicar el operador MPI de Kubeflow. El operador Message Passing Interface (MPI, interfaz de paso de mensajes) facilita la ejecución de la formación distribuida de estilo AllReduce en Kubernetes. Para obtener más información, consulte Operador de MPI en GitHub.

kubectl apply -f https://raw.githubusercontent.com/kubeflow/mpi-operator/master/deploy/v2beta1/mpi-operator.yaml
Ejecutar la prueba de rendimiento NCCL de varios nodos para verificar GPUDirectRDMA/EFA

Para verificar el rendimiento de NCCL con GPUDirectRDMA sobre EFA, ejecute la prueba de rendimiento de NCCL estándar. Para obtener más información, consulte el repositorio oficial Pruebas de NCCL en GitHub. Puede utilizar la muestra Dockerfile que ya está incluida en esta prueba para NVIDIA CUDA 11.2 y la última versión de EFA.

Como alternativa, puede descargar una imagen de Docker de AWS disponible desde un repositorio de Amazon ECR.

importante

Una consideración importante que se requiere para adoptar EFA con Kubernetes es configurar y administrar Huge Pages como un recurso en el clúster. Para obtener más información, consulte Administración de Huge Pages en la documentación de Kubernetes. Las instancias de Amazon EC2 con el controlador de EFA instalado preasignan 5128 Huge Pages de 2 M, que puede solicitar como recursos para utilizar en sus especificaciones de trabajo.

Complete los pasos que se indican a continuación para ejecutar una prueba de rendimiento de NCCL de dos nodos. En el trabajo de prueba NCCL de ejemplo, cada trabajo solicita ocho GPU, 5210 MiB de HugePages de 2 Mi, cuatro EFA y 8000 MiB de memoria, lo que significa que cada trabajo consume todos los recursos de una instancia p4d.24xlarge.

  1. Cree el trabajo de pruebas NCCL.

    kubectl apply -f https://raw.githubusercontent.com/aws-samples/aws-efa-eks/main/examples/simple/nccl-efa-tests.yaml

    Un ejemplo de salida sería el siguiente.

    mpijob.kubeflow.org/nccl-tests-efa creado

  2. Consulte su ejecución Pods.

    kubectl get pods

    Un ejemplo de salida sería el siguiente.

    NAME                             READY   STATUS     RESTARTS   AGE
nccl-tests-efa-launcher-nbql9  0/1     Init:0/1   0          2m49s
nccl-tests-efa-worker-0          1/1     Running    0          2m49s
nccl-tests-efa-worker-1          1/1     Running    0          2m49s

    El operador MPI crea un Pod de lanzamiento y dos Pods de trabajo (uno en cada nodo).

  3. Consulte el registro del Pod de efa-launcher. Sustituya wzr8j con el valor de su salida.

    kubectl logs -f nccl-tests-efa-launcher-nbql9

Para obtener más ejemplos, consulte Muestras de EFA del repositorio de Amazon EKS en GitHub.