Crea un clúster de GKE personalizado y optimizado para IA que use A4 o A3 Ultra

En esta página, se muestra cómo crear un clúster de Google Kubernetes Engine (GKE) optimizado para IA que use máquinas virtuales (VM) A4 o A3 Ultra para admitir tus cargas de trabajo de IA y AA. En el caso de A4X, consulta Crea un clúster de GKE personalizado optimizado para IA que use A4X.

Las series de máquinas A4 y A3 Ultra están diseñadas para permitirte ejecutar clústeres de IA/AA a gran escala con funciones como la colocación de cargas de trabajo segmentadas, controles avanzados de mantenimiento de clústeres y programación que considera la topología. Para obtener más información, consulta la descripción general de la administración de clústeres.

GKE proporciona una sola plataforma para ejecutar un conjunto diverso de cargas de trabajo para tus organizaciones, lo que reduce la carga operativa de administrar varias plataformas. Puedes ejecutar cargas de trabajo, como el entrenamiento previo distribuido de alto rendimiento, el ajuste de modelos, la inferencia de modelos, la entrega de aplicaciones y los servicios de asistencia.

En esta página, aprenderás a crear un clúster de GKE con Google Cloud CLI para tener la máxima flexibilidad a la hora de configurar tu clúster según las necesidades de tu carga de trabajo. Como alternativa, puedes usar Cluster Toolkit para implementar rápidamente tu clúster con la configuración predeterminada que refleja las prácticas recomendadas para muchos casos de uso. Para obtener instrucciones sobre cómo hacerlo, consulta Crea un clúster de GKE optimizado para IA con la configuración predeterminada.

Opciones de configuración del clúster con GPUDirect RDMA

Para crear tu clúster con Google Cloud CLI, puedes elegir una de las siguientes opciones de configuración del clúster:

Si no planeas ejecutar cargas de trabajo de IA distribuidas, crea un clúster de GKE sin usar GPUDirect RDMA.
Si planeas ejecutar cargas de trabajo de IA distribuidas, crea un clúster de GKE con GPUDirect RDMA.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos que se describen en este documento.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar la propiedad compute/region. Si usas principalmente clústeres zonales, configura compute/zone en su lugar. Cuando configuras una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que debas especificar la ubicación en ciertos comandos si la ubicación de tu clúster difiere de la predeterminada que estableciste.

Roles obligatorios

Para obtener los permisos que necesitas para crear y administrar un clúster de GKE, pídele a tu administrador que te otorgue los siguientes roles de IAM en el proyecto:

Administrador de Kubernetes Engine (roles/container.admin)
Editor de Cloud Build (roles/cloudbuild.builds.editor)
Administrador de Compute (roles/compute.admin)
Administrador de IAM de proyecto (roles/resourcemanager.projectIamAdmin)
Administrador de cuenta de servicio (roles/iam.serviceAccountAdmin)
Usuario de la cuenta de servicio (roles/iam.serviceAccountUser)
Consumidor de Service Usage (roles/serviceusage.serviceUsageConsumer)
Administrador de almacenamiento (roles/storage.admin)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Elige una opción de consumo y obtén capacidad

Elige una opción de consumo. Elige en función de cómo deseas obtener y usar los recursos de GPU. Para obtener más información, consulta Elige una opción de consumo.

En el caso de GKE, ten en cuenta la siguiente información adicional cuando elijas una opción de consumo:
- Para obtener más información sobre el inicio flexible (versión preliminar) y GKE, consulta Acerca de la disponibilidad de GPU con inicio flexible.
- El inicio flexible usa la posición compacta según el criterio del mejor esfuerzo. Para examinar tu topología, consulta Cómo ver la topología física de los nodos en tu clúster de GKE.
- Solo puedes obtener información de la topología cuando usas VMs Spot si configuras la posición compacta.
Obtener capacidad Obtén más información para obtener capacidad para tu opción de consumo.

Requisitos

Se aplican los siguientes requisitos a un clúster de GKE optimizado para IA:

Para usar el modelo de aprovisionamiento de inicio flexible, debes usar la versión 1.32.2-gke.1652000 de GKE o una posterior.
Asegúrate de usar la versión mínima del controlador de GPU, según el tipo de máquina:
- A4: Las GPUs B200 en las VMs A4 requieren una versión mínima del controlador de GPU R570. De forma predeterminada, GKE instala automáticamente esta versión del controlador en todos los nodos A4 que ejecutan la versión mínima requerida para A4, que es 1.32.1-gke.1729000 o posterior.
- A3 Ultra: Las GPU H200 en las VMs A3 Ultra requieren, como mínimo, la versión del controlador de GPU R550, que está disponible en la versión 1.31 de GKE como la versión del controlador latest. En el caso de las VMs A3 Ultra, debes establecer el valor del campo gpu-driver-version=latest con la versión 1.31 de GKE. En la versión 1.31.5-gke.1169000 o posterior de GKE, GKE instala automáticamente las versiones del controlador de GPU R550 en los nodos A3 Ultra de forma predeterminada, incluso cuando omites la marca gpu-driver-version.
Para usar GPUDirect RDMA, se aplican los siguientes requisitos adicionales:
- Usa las siguientes versiones mínimas, según el tipo de máquina:
  - A4: Usa la versión 1.32.2-gke.1475000 o posterior.
  - A3 Ultra: Usa la versión 1.31.4-gke.1183000 o posterior.
- Los nodos de GKE deben usar una imagen de nodo de Container-Optimized OS. No se admiten las imágenes de nodos de Ubuntu ni Windows.
- Tu carga de trabajo de GKE debe usar todas las GPUs disponibles, y tu Pod debe usar todas las tarjetas de interfaz de red (NIC) secundarias disponibles en un solo nodo de GKE. Varios Pods no pueden compartir RDMA en un solo nodo de GKE.
- Esta configuración ejecuta una prueba de NCCL. Para ejecutar esta prueba de NCCL, debes tener una cuota mínima de VM de 2 (es decir, 16 GPUs si usas los tipos de máquina a4-highgpu-8g o a3-ultragpu-8g).
- GPUDirect RDMA no es compatible con NCCL Fast Socket ni con GPUDirect TCPX/TCPXO. No habilites NCCL Fast Socket ni instales el complemento TCPX/TCPXO en clústeres que usen GPUDirect RDMA.
Asegúrate de usar una ubicación que tenga disponibilidad para el tipo de máquina que elijas. Para obtener más información, consulta Ubicaciones de GPU.

Crea un clúster de GKE optimizado para IA

Sigue las instrucciones de esta sección para crear un clúster de GKE que cumpla con los requisitos de los clústeres de GKE optimizados para IA. Puedes elegir entre crear un clúster con o sin GPUDirect RDMA.

Consideraciones para crear un clúster

Cuando crees un clúster, ten en cuenta la siguiente información:

Elige la ubicación de un clúster:
- Asegúrate de usar una ubicación que tenga disponibilidad para el tipo de máquina que elijas. Para obtener más información, consulta Ubicaciones de GPU.
- Para las reservas densas, puedes crear un clúster zonal. En este caso, reemplaza la marca --region por la marca --zone=COMPUTE_ZONE, en la que COMPUTE_ZONE es la zona de tu plano de control.
- Para las cargas de trabajo que se ejecutan en más de 1,000 nodos y que requieren una latencia de red baja entre los nodos, puedes crear un clúster regional. Para colocar físicamente tus nodos sensibles al rendimiento en la misma ubicación, crea tus grupos de nodos de GPU en una sola zona con la marca --node-locations.
Elige una versión del controlador:
- La versión del controlador puede ser uno de los siguientes valores:
  - default: Instala la versión predeterminada del controlador para tu versión de nodo de GKE. Para obtener más información sobre los requisitos de las versiones predeterminadas de los controladores, consulta la sección Requisitos.
  - latest: Instala la última versión del controlador disponible para tu versión de GKE. Esta opción solo está disponible para los nodos que usan Container-Optimized OS.
  - disabled: Omite la instalación automática del controlador. Debes instalar un controlador de forma manual después de crear el grupo de nodos.
- Para obtener más información sobre las versiones de controladores de GPU predeterminadas y más recientes para las versiones de nodos de GKE, consulta Instala controladores de GPU de NVIDIA de forma manual.
Elige una afinidad de reserva:
- Puedes encontrar información sobre tu reserva, como el nombre de la reserva o el nombre de un bloque específico en ella. Para encontrar estos valores, consulta Cómo ver las solicitudes de reserva futuras.
- La marca --reservation-affinity puede tomar los valores specific o any. Sin embargo, para las cargas de trabajo de IA distribuidas de alto rendimiento, te recomendamos que uses una reserva específica.
- Cuando usas una reserva específica, incluidas las reservas compartidas, especifica el valor de la marca --reservation en el siguiente formato:
```
projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME
```
  Reemplaza lo siguiente:
  - PROJECT_ID: Es el ID del proyecto de Google Cloud .
  - RESERVATION_NAME: Es el nombre de tu reserva.
  - BLOCK_NAME: Es el nombre de un bloque específico dentro de la reserva.
Nota: Si la reserva se encuentra en el proyecto actual, puedes omitir projects/PROJECT_ID/reservations/ del valor de la reserva.

Crea un clúster sin GPUDirect RDMA

Para crear un clúster sin GPUDirect RDMA, sigue las instrucciones que se indican a continuación para crear un clúster con un grupo de nodos predeterminado basado en CPU y grupos de nodos adicionales con GPUs. Este enfoque permite que el grupo de nodos predeterminado ejecute otros servicios.

Crea el clúster:
```
  gcloud container clusters create CLUSTER_NAME \
      --cluster-version=CLUSTER_VERSION \
      --region=COMPUTE_REGION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: Es el nombre del clúster nuevo.
- CLUSTER_VERSION: es la versión del clúster nuevo. Para obtener más información sobre qué versión de GKE admite tu configuración, consulta la sección Requisitos.
- COMPUTE_REGION: Es la región del clúster nuevo. Si planeas crear un clúster zonal, usa la marca --zone en lugar de la marca --region, por ejemplo: --zone=COMPUTE_ZONE. Reemplaza COMPUTE_ZONE por la zona del plano de control.
Crea el grupo de nodos basado en GPU con uno de los siguientes comandos. El comando que debes ejecutar depende de la opción de consumo que uses para tu implementación. Selecciona la pestaña que corresponda al modelo de aprovisionamiento de tu opción de consumo.
Con reserva
Para el aprovisionamiento vinculado a la reserva, ejecuta el siguiente comando:
```
  gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --num-nodes=NUM_NODES \
      --reservation-affinity=specific \
      --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME
```
Reemplaza lo siguiente:
- NODE_POOL_NAME: el nombre del grupo de nodos
- COMPUTE_REGION: Es la región del clúster nuevo.
- CLUSTER_NAME: Es el nombre del clúster nuevo.
- COMPUTE_ZONE: Es la zona de tu grupo de nodos.
- GPU_TYPE: Es el tipo de acelerador de GPU:
  - VMs de A4: Ingresa nvidia-b200.
  - VMs A3 Ultra: Ingresa nvidia-h200-141gb.
- AMOUNT: Es la cantidad de GPUs que se deben adjuntar a los nodos del grupo de nodos. Por ejemplo, para las VMs a4-highgpu-8g y a3-ultragpu-8g, la cantidad de GPUs es 8.
- DRIVER_VERSION: Es la versión del controlador NVIDIA que se instalará. Puede ser uno de los siguientes valores: default, latest o disabled.
- MACHINE_TYPE: Es el tipo de máquina de Compute Engine para los nodos. Por ejemplo, usa a4-highgpu-8g para las VMs A4 y a3-ultragpu-8g para las VMs A3 Ultra.
- NUM_NODES: Es la cantidad de nodos del grupo de nodos.
- RESERVATION_NAME: El nombre de tu reserva. Para encontrar este valor, consulta Cómo ver solicitudes de reserva futuras.
- BLOCK_NAME: Es el nombre de un bloque específico dentro de la reserva. Para encontrar este valor, consulta Cómo ver solicitudes de reserva futuras.
Inicio flexible

Versión preliminar

Este producto o función está con sujeción a las "Condiciones de las Ofertas de la Fase Previa a la DG" de la sección de Términos Generales del Servicio de los Términos Específicos del Servicio. Los productos y las funciones de la fase previa a la DG están disponibles sin modificaciones y pueden estar sujetos a asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Para el aprovisionamiento de inicio flexible, ejecuta el siguiente comando:
```
  gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --flex-start --enable-autoscaling --num-nodes=0 \
      --total-max-nodes TOTAL_MAX_NODES \
      --no-enable-autorepair --location-policy=ANY \
      --reservation-affinity=none [\
      --enable-queued-provisioning]
```
Reemplaza lo siguiente:
- NODE_POOL_NAME: el nombre del grupo de nodos
- COMPUTE_REGION: Es la región del clúster nuevo.
- CLUSTER_NAME: Es el nombre del clúster nuevo.
- COMPUTE_ZONE: Es la zona de tu grupo de nodos.
- GPU_TYPE: Es el tipo de acelerador de GPU:
  - VMs de A4: Ingresa nvidia-b200.
  - VMs A3 Ultra: Ingresa nvidia-h200-141gb.
- AMOUNT: Es la cantidad de GPUs que se deben adjuntar a los nodos del grupo de nodos. Por ejemplo, para las VMs a4-highgpu-8g y a3-ultragpu-8g, la cantidad de GPUs es 8.
- DRIVER_VERSION: Es la versión del controlador NVIDIA que se instalará. Puede ser uno de los siguientes valores: default, latest o disabled.
- MACHINE_TYPE: Es el tipo de máquina de Compute Engine para los nodos. Por ejemplo, usa a4-highgpu-8g para las VMs A4 y a3-ultragpu-8g para las VMs A3 Ultra.
- TOTAL_MAX_NODES: Es la cantidad máxima de nodos que se escalarán de forma automática para todo el grupo de nodos.
  
  Si deseas usar flex-start con el aprovisionamiento en cola, incluye la marca --enable-queued-provisioning.
  
  Para obtener más información sobre el uso de flex-start, consulta Ejecuta cargas de trabajo a gran escala con flex-start y aprovisionamiento en cola.
Spot
Para el aprovisionamiento de instancias temporales, ejecuta el siguiente comando:
```
  gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --num-nodes=NUM_NODES \
      --spot
```
Reemplaza lo siguiente:
- NODE_POOL_NAME: el nombre del grupo de nodos
- COMPUTE_REGION: Es la región del clúster nuevo.
- CLUSTER_NAME: Es el nombre del clúster nuevo.
- COMPUTE_ZONE: Es la zona de tu grupo de nodos.
- GPU_TYPE: Es el tipo de acelerador de GPU:
  - VMs de A4: Ingresa nvidia-b200.
  - VMs A3 Ultra: Ingresa nvidia-h200-141gb.
- AMOUNT: Es la cantidad de GPUs que se deben adjuntar a los nodos del grupo de nodos. Por ejemplo, para las VMs a4-highgpu-8g y a3-ultragpu-8g, la cantidad de GPUs es 8.
- DRIVER_VERSION: Es la versión del controlador NVIDIA que se instalará. Puede ser uno de los siguientes valores: default, latest o disabled.
- MACHINE_TYPE: Es el tipo de máquina de Compute Engine para los nodos. Por ejemplo, usa a4-highgpu-8g para las VMs A4 y a3-ultragpu-8g para las VMs A3 Ultra.
- NUM_NODES: Es la cantidad de nodos del grupo de nodos.
  
  Si deseas obtener más información para crear clústeres con VMs Spot, consulta Ejecuta cargas de trabajo tolerantes a errores a costos más bajos con VMs Spot.
Conéctate a tu clúster para poder ejecutar los comandos de kubectl en las siguientes secciones:
```
  gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: El nombre de tu clúster.
- COMPUTE_REGION: Es el nombre de la región de procesamiento.
  
  Para obtener más información, consulta Cómo instalar kubectl y configurar el acceso al clúster.

Crea un clúster con RDMA de GPUDirect

En el caso de las cargas de trabajo de IA distribuidas, a menudo se vinculan varios nodos de GPU para que funcionen como una sola computadora. Las VMs A4 y las VMs A3 Ultra incluyen el adaptador de red Titanium ML, que se basa en las NIC NVIDIA ConnectX-7 (CX7). Tanto las VMs A4 como las VMs A3 Ultra proporcionan 3.2 Tbps sin bloqueo de tráfico entre nodos de GPU a GPU con RDMA a través de Ethernet convergente (RoCE). RoCE permite el escalamiento y la colaboración en múltiples GPUs, ya que ofrece una experiencia de nube de alto rendimiento para las cargas de trabajo de IA.

Si quieres obtener más información para crear tus clústeres de GKE con Google Cloud CLI y GPUDirect TCPX (VMs A3 High) o TCPXO (VMs A3 Mega), consulta cómo maximizar el ancho de banda de red de la GPU en clústeres del modo Autopilot o cómo maximizar el ancho de banda de red de la GPU en clústeres del modo estándar.

Para crear tus clústeres de GKE en modo Autopilot o estándar con GPUDirect RDMA, completa los siguientes pasos, que se describen en las próximas secciones:

Crea VPC y subredes
Crea el clúster de GKE con varias redes
Crea objetos de red de GKE
Instala el objeto binario de RDMA y configura NCCL
Implementa y ejecuta una prueba de NCCL
Configura tus manifiestos de Pod para GPUDirect-RDMA

Crea VPC y subredes

Tanto las VMs A4 como las VMs A3 Ultra tienen la siguiente configuración:

Ocho GPU NVIDIA B200 (A4) o H200 (A3 Ultra) por máquina virtual conectadas con NVLink
Dos CPU Intel Emerald Rapids
Ocho NIC CX-7 de 400 Gbps para redes de GPU a GPU
Dos NICs Google Titanium de 200 Gbps para servicios externos

Las cargas de trabajo de IA y AA, como el entrenamiento distribuido, requieren una aceleración potente para optimizar el rendimiento reduciendo los tiempos de finalización de los trabajos. Para las cargas de trabajo que requieren alto rendimiento, alta capacidad de procesamiento y baja latencia, GPUDirect RDMA reduce los saltos de red necesarios para transferir cargas útiles hacia y desde las GPUs, lo que usa de manera más eficiente el ancho de banda de red disponible. GPUDirect RDMA está diseñado para mejorar significativamente la capacidad de procesamiento a gran escala en comparación con las GPUs que no usan GPUDirect.

Una de las NIC de Google Titanium asociadas con la CPU usa la red predeterminada en GKE. No es necesario que crees una VPC nueva para esta NIC si tienes suficientes rangos de direcciones IP para la red predeterminada.

Puedes crear una VPC para la segunda NIC Titanium de CPU (gVNIC) y otra VPC para las ocho NIC RDMA CX-7 con estos comandos.

Configura las variables de entorno para que coincidan con tu implementación:
```
export REGION="COMPUTE_REGION"
export ZONE="COMPUTE_ZONE"
export PROJECT="PROJECT_ID"
export GVNIC_NETWORK_PREFIX="GVNIC_NETWORK_PREFIX"
export RDMA_NETWORK_PREFIX="RDMA_NETWORK_PREFIX"
```
Reemplaza las siguientes variables:
- COMPUTE_REGION: Es la región del clúster.
- COMPUTE_ZONE: Es la zona de tu grupo de nodos.
- PROJECT_ID: Es el ID del proyecto de Google Cloud .
- GVNIC_NETWORK_PREFIX: Puede ser a4high-gvnic para VMs A4 o a3ultra-gvnic para VMs A3 Ultra.
- RDMA_NETWORK_PREFIX: Puede ser a4high-rdma para VMs A4 o a3ultra-rdma para VMs A3 Ultra.

Crea dos redes de VPC:

# Create a VPC for the additional Google Titanium CPU NIC
gcloud compute --project=${PROJECT} \
  networks create \
  ${GVNIC_NETWORK_PREFIX}-net \
  --subnet-mode=custom

gcloud compute --project=${PROJECT} \
  networks subnets create \
  ${GVNIC_NETWORK_PREFIX}-sub \
  --network=${GVNIC_NETWORK_PREFIX}-net \
  --region=${REGION} \
  --range=192.168.0.0/24

gcloud compute --project=${PROJECT} \
  firewall-rules create \
  ${GVNIC_NETWORK_PREFIX}-internal \
  --network=${GVNIC_NETWORK_PREFIX}-net \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=192.168.0.0/16

# Create HPC VPC for the RDMA NICs with 8 subnets.
gcloud beta compute --project=${PROJECT} \
  networks create ${RDMA_NETWORK_PREFIX}-net \
  --network-profile=${ZONE}-vpc-roce \
  --subnet-mode=custom

# Create subnets for the HPC VPC.
for N in $(seq 0 7); do
  gcloud compute --project=${PROJECT} \
    networks subnets create \
    ${RDMA_NETWORK_PREFIX}-sub-$N \
    --network=${RDMA_NETWORK_PREFIX}-net \
    --region=${REGION} \
    --range=192.168.$((N+1)).0/24 &  # offset to avoid overlap with gvnics
done

Crea el clúster de GKE con varias redes

Autopilot

Crea un clúster de GKE Autopilot con varias redes:
```
gcloud container clusters create-auto CLUSTER_NAME \
    --enable-multi-networking \
    --cluster-version=CLUSTER_VERSION \
    --region=COMPUTE_REGION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: El nombre de tu clúster.
- CLUSTER_VERSION: Es la versión del clúster nuevo. Para saber qué versión de GKE admite tu configuración, consulta la sección Requisitos.
- COMPUTE_REGION: Es el nombre de la región de procesamiento.
Conéctate a tu clúster para poder ejecutar los comandos de kubectl en las siguientes secciones:
```
gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: El nombre de tu clúster.
- COMPUTE_REGION: Es el nombre de la región de procesamiento.
Para obtener más información, consulta Cómo instalar kubectl y configurar el acceso al clúster.

Estándar

Crea un clúster de GKE Standard y un grupo de nodos de GPU con varias redes:

Crea el clúster:
```
gcloud container clusters create CLUSTER_NAME \
  --region=COMPUTE_REGION \
  --cluster-version=CLUSTER_VERSION \
  --enable-dataplane-v2 --enable-ip-alias --enable-multi-networking [\
  --services-ipv4-cidr=SERVICE_CIDR \
  --cluster-ipv4-cidr=POD_CIDR]
```
Reemplaza lo siguiente:
- CLUSTER_NAME: El nombre de tu clúster.
- CLUSTER_VERSION: Es la versión del clúster nuevo. Para saber qué versión de GKE admite tu configuración, consulta la sección Requisitos.
- COMPUTE_REGION: Es el nombre de la región de procesamiento.
De manera opcional, puedes proporcionar de forma explícita los rangos de CIDR secundarios para los servicios y los Pods. Si usas estas marcas opcionales, reemplaza las siguientes variables:
- SERVICE_CIDR: Es el rango de CIDR secundario para los servicios.
- POD_CIDR: Es el rango de CIDR secundario para los Pods.
Cuando uses estas marcas, debes verificar que los rangos CIDR no se superpongan con los rangos de subredes para redes de nodos adicionales. Por ejemplo, los rangos de los valores SERVICE_CIDR=10.65.0.0/19 y POD_CIDR=10.64.0.0/19 no se superponen. Para obtener más información, consulta Cómo agregar rangos de direcciones IPv4 de Pod.
Crea el grupo de nodos. El comando que debes ejecutar depende de la opción de consumo que uses para tu implementación. Selecciona la pestaña que corresponde al modelo de aprovisionamiento de tu opción de consumo.
Con reserva
Para el aprovisionamiento vinculado a la reserva, ejecuta el siguiente comando:
```
gcloud container node-pools create NODE_POOL_NAME \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type MACHINE_TYPE \
  --num-nodes=NUM_NODES \
  --reservation-affinity=specific \
  --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME  \
  --additional-node-network network=${GVNIC_NETWORK_PREFIX}-net,subnetwork=${GVNIC_NETWORK_PREFIX}-sub \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-0 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-1 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-2 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-3 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-4 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-5 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-6 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-7
```
Reemplaza lo siguiente:
- NODE_POOL_NAME: el nombre del grupo de nodos
- COMPUTE_REGION: Es la región del clúster nuevo.
- CLUSTER_NAME: Es el nombre del clúster nuevo.
- COMPUTE_ZONE: Es la zona de tu grupo de nodos.
- GPU_TYPE: Es el tipo de acelerador de GPU:
  - VMs de A4: Ingresa nvidia-b200.
  - VMs A3 Ultra: Ingresa nvidia-h200-141gb.
- AMOUNT: Es la cantidad de GPUs que se deben adjuntar a los nodos del grupo de nodos. Por ejemplo, para las VMs a4-highgpu-8g y a3-ultragpu-8g, la cantidad de GPUs es 8.
- DRIVER_VERSION: Es la versión del controlador NVIDIA que se instalará. Puede ser uno de los siguientes valores: default, latest o disabled.
- MACHINE_TYPE: Es el tipo de máquina de Compute Engine para los nodos. Por ejemplo, usa a4-highgpu-8g para las VMs A4 y a3-ultragpu-8g para las VMs A3 Ultra.
- MACHINE_TYPE: Es el tipo de máquina de Compute Engine para los nodos. Por ejemplo, usa a4-highgpu-8g para las VMs A4 y a3-ultragpu-8g para las VMs A3 Ultra.
- NUM_NODES: Es la cantidad de nodos del grupo de nodos. Para flex-start, este valor debe establecerse en 0.
- RESERVATION_NAME: El nombre de tu reserva. Para encontrar este valor, consulta Cómo ver solicitudes de reserva futuras.
- BLOCK_NAME: Es el nombre de un bloque específico dentro de la reserva. Para encontrar este valor, consulta Cómo ver solicitudes de reserva futuras.
Inicio flexible

Versión preliminar

Este producto o función está con sujeción a las "Condiciones de las Ofertas de la Fase Previa a la DG" de la sección de Términos Generales del Servicio de los Términos Específicos del Servicio. Los productos y las funciones de la fase previa a la DG están disponibles sin modificaciones y pueden estar sujetos a asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Para el aprovisionamiento de inicio flexible, ejecuta el siguiente comando:
```
gcloud container node-pools create NODE_POOL_NAME \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type MACHINE_TYPE \
  --num-nodes=NUM_NODES \
  --flex-start --num-nodes=0 --enable-autoscaling \
  --total-max-nodes TOTAL_MAX_NODES \
  --no-enable-autorepair --location-policy=ANY \
  --reservation-affinity=none \
  [--enable-queued-provisioning \]
  --additional-node-network network=${GVNIC_NETWORK_PREFIX}-net,subnetwork=${GVNIC_NETWORK_PREFIX}-sub \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-0 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-1 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-2 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-3 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-4 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-5 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-6 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-7
```
Reemplaza lo siguiente:
- NODE_POOL_NAME: el nombre del grupo de nodos
- COMPUTE_REGION: Es la región del clúster nuevo.
- CLUSTER_NAME: Es el nombre del clúster nuevo.
- COMPUTE_ZONE: Es la zona de tu grupo de nodos.
- GPU_TYPE: Es el tipo de acelerador de GPU:
  - VMs de A4: Ingresa nvidia-b200.
  - VMs A3 Ultra: Ingresa nvidia-h200-141gb.
- AMOUNT: Es la cantidad de GPUs que se deben adjuntar a los nodos del grupo de nodos. Por ejemplo, para las VMs a4-highgpu-8g y a3-ultragpu-8g, la cantidad de GPUs es 8.
- DRIVER_VERSION: Es la versión del controlador NVIDIA que se instalará. Puede ser uno de los siguientes valores: default, latest o disabled.
- MACHINE_TYPE: Es el tipo de máquina de Compute Engine para los nodos. Por ejemplo, usa a4-highgpu-8g para las VMs A4 y a3-ultragpu-8g para las VMs A3 Ultra.
- MACHINE_TYPE: Es el tipo de máquina de Compute Engine para los nodos. Por ejemplo, usa a4-highgpu-8g para las VMs A4 y a3-ultragpu-8g para las VMs A3 Ultra.
- NUM_NODES: Es la cantidad de nodos del grupo de nodos. Para flex-start, este valor debe establecerse en 0.
- TOTAL_MAX_NODES: Es la cantidad máxima de nodos que se escalarán de forma automática para todo el grupo de nodos.
Si deseas usar flex-start con el aprovisionamiento en cola, incluye la marca --enable-queued-provisioning.

Para obtener más información sobre el uso de flex-start, consulta Ejecuta cargas de trabajo a gran escala con flex-start y aprovisionamiento en cola.
Conéctate a tu clúster para poder ejecutar los comandos de kubectl en las siguientes secciones:
```
gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: El nombre de tu clúster.
- COMPUTE_REGION: Es el nombre de la región de procesamiento.
Para obtener más información, consulta Cómo instalar kubectl y configurar el acceso al clúster.

Crea los objetos de red de GKE

Las redes de VPC creadas en la sección anterior deben configurarse a través de conjuntos de parámetros de red de GKE. Específicamente, la segunda NIC de Titanium de CPU (gVNIC) debe configurarse en modo NetDevice, y cada una de las ocho NIC de RDMA CX-7 debe configurarse en modo RDMA.

Este comando usa los siguientes nombres:

La VPC de la NIC de CPU Titanium (gVNIC) se llama ${GVNIC_NETWORK_PREFIX}-net con la subred llamada ${GVNIC_NETWORK_PREFIX}-sub.
La VPC de las NIC de RDMA de CX-7 se llama ${RDMA_NETWORK_PREFIX}-net y tiene subredes llamadas ${RDMA_NETWORK_PREFIX}-sub-[0…7].

Ejecuta el siguiente comando para crear los objetos de red de GKE:

kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: gvnic-1
spec:
  vpc: ${GVNIC_NETWORK_PREFIX}-net
  vpcSubnet: ${GVNIC_NETWORK_PREFIX}-sub
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: gvnic-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: gvnic-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-0
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-0
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-0
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-0
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-1
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-1
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-2
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-2
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-2
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-2
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-3
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-3
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-3
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-3
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-4
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-4
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-4
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-4
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-5
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-5
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-5
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-5
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-6
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-6
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-6
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-6
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-7
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-7
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-7
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-7
EOF

Instala el objeto binario de RDMA y configura NCCL

Aplica el siguiente DaemonSet para instalar los archivos binarios de RDMA y la biblioteca de NCCL en cada nodo. En cada VM subyacente, los objetos binarios de RDMA se instalan en el directorio /home/kubernetes/bin/gib y la biblioteca de NCCL se instala en el directorio /home/kubernetes/bin/nvidia/lib64.

Autopilot

Para el modo GKE Autopilot, ejecuta el siguiente comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/gpudirect-rdma/nccl-rdma-installer-autopilot.yaml

Estándar

Para el modo estándar de GKE, ejecuta el siguiente comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/gpudirect-rdma/nccl-rdma-installer.yaml

Ejecuta pruebas de NCCL

Para validar la funcionalidad del clúster aprovisionado, puedes ejecutar una prueba de NCCL. Para obtener instrucciones, consulta Implementa y ejecuta una prueba de NCCL.

Configura tus manifiestos de Pod para RDMA de GPUDirect

Para ejecutar tus cargas de trabajo con GPUDirect RDMA, configura tus manifiestos de Pods con los siguientes pasos:

Agrega las siguientes anotaciones a los metadatos del Pod.

Autopilot

Usa la siguiente anotación para el modo de GKE Autopilot:

metadata:
annotations:
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth1","network":"gvnic-1"},
      {"interfaceName":"eth2","network":"rdma-0"},
      {"interfaceName":"eth3","network":"rdma-1"},
      {"interfaceName":"eth4","network":"rdma-2"},
      {"interfaceName":"eth5","network":"rdma-3"},
      {"interfaceName":"eth6","network":"rdma-4"},
      {"interfaceName":"eth7","network":"rdma-5"},
      {"interfaceName":"eth8","network":"rdma-6"},
      {"interfaceName":"eth9","network":"rdma-7"}
    ]

Estándar

La siguiente anotación para el modo GKE Standard no incluye una especificación degvnic-1, pero puedes agregarla si tus cargas de trabajo lo requieren.

Usa la siguiente anotación para el modo estándar de GKE:

metadata:
annotations:
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth2","network":"rdma-0"},
      {"interfaceName":"eth3","network":"rdma-1"},
      {"interfaceName":"eth4","network":"rdma-2"},
      {"interfaceName":"eth5","network":"rdma-3"},
      {"interfaceName":"eth6","network":"rdma-4"},
      {"interfaceName":"eth7","network":"rdma-5"},
      {"interfaceName":"eth8","network":"rdma-6"},
      {"interfaceName":"eth9","network":"rdma-7"}
    ]

Especifica el tipo de GPU elegido y la reserva específica con selectores de nodos:
```
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: ACCELERATOR
    cloud.google.com/reservation-name: RESERVATION_NAME
    cloud.google.com/reservation-affinity: "specific"
```
Reemplaza lo siguiente:
- ACCELERATOR: es el acelerador que reservaste en la reserva de capacidad de Compute Engine. Debes usar uno de los siguientes valores:
  - nvidia-b200: NVIDIA B200 (180 GB) para VMs A4
  - nvidia-h200-141gb: NVIDIA H200 (141 GB) para VMs A3 Ultra
- RESERVATION_NAME es el nombre de la reserva de capacidad de Compute Engine.
Para consumir reservas compartidas o bloques y subbloques específicos de reservas, consulta las secciones correspondientes en Consume recursos de ruta zonales reservados.

Agrega los siguientes volúmenes a la especificación del Pod:

spec:
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib

Agrega las siguientes activaciones de volumen, variables de entorno y recursos al contenedor que solicita GPUs. El contenedor de carga de trabajo debe solicitar las ocho GPUs:

Autopilot

Para el modo Autopilot de GKE, configura los siguientes recursos:

containers:
  - name: my-container
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia
        readOnly: true
      - name: gib
        mountPath: /usr/local/gib
        readOnly: true
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 8

Estándar

Para el modo de GKE Standard, configura los siguientes recursos:

containers:
  - name: my-container
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia
      - name: gib
        mountPath: /usr/local/gib
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 8

Configura todas las variables de entorno necesarias para configurar NCCL con la siguiente secuencia de comandos de shell del contenedor de la carga de trabajo:
```
source /usr/local/gib/scripts/set_nccl_env.sh
```

En las siguientes pestañas, se incluyen ejemplos de manifiestos de Pods completados.

Autopilot

En el modo Autopilot de GKE, un manifiesto de Pod completo debería verse similar al siguiente:

apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"gvnic-1"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
        {"interfaceName":"eth6","network":"rdma-4"},
        {"interfaceName":"eth7","network":"rdma-5"},
        {"interfaceName":"eth8","network":"rdma-6"},
        {"interfaceName":"eth9","network":"rdma-7"}
      ]
spec:
  ...
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
          readOnly: true
        - name: gib
          mountPath: /usr/local/gib
          readOnly: true
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 8
          ...

Estándar

En el modo Standard de GKE, un manifiesto de Pod completo debería verse de la siguiente manera:

apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
        {"interfaceName":"eth6","network":"rdma-4"},
        {"interfaceName":"eth7","network":"rdma-5"},
        {"interfaceName":"eth8","network":"rdma-6"},
        {"interfaceName":"eth9","network":"rdma-7"}
      ]
spec:
  ...
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
        - name: gib
          mountPath: /usr/local/gib
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 8
          ...

Prueba el rendimiento de la red para los clústeres que usan RDMA de GPUDirect

Te recomendamos que valides la funcionalidad de los clústeres aprovisionados. Para ello, usa las pruebas de NCCL/gIB, que son pruebas de la biblioteca de comunicación colectiva de NVIDIA (NCCL) optimizadas para el entorno de Google.

¿Qué sigue?

Para obtener más información sobre la programación de cargas de trabajo en tus clústeres de GKE con la programación consciente de la topología (TAS) y Kueue, consulta Programa cargas de trabajo de GKE con la programación consciente de la topología.
Para obtener más información sobre cómo administrar eventos comunes relevantes para los clústeres de GKE y las cargas de trabajo de IA, consulta Administra clústeres de GKE optimizados para IA.
Para obtener información sobre cómo probar tu entorno para verificar la configuración y la optimización adecuadas, consulta Optimiza las redes de clústeres con NCCL/gIB.

Crea un clúster de GKE personalizado y optimizado para IA que use A4 o A3 Ultra Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Opciones de configuración del clúster con GPUDirect RDMA

Antes de comenzar

Roles obligatorios

Elige una opción de consumo y obtén capacidad

Requisitos

Crea un clúster de GKE optimizado para IA

Consideraciones para crear un clúster

Crea un clúster sin GPUDirect RDMA

Con reserva

Inicio flexible

Spot

Crea un clúster con RDMA de GPUDirect

Crea VPC y subredes

Crea el clúster de GKE con varias redes

Autopilot

Estándar

Con reserva

Inicio flexible

Crea los objetos de red de GKE

Instala el objeto binario de RDMA y configura NCCL

Autopilot

Estándar

Ejecuta pruebas de NCCL

Configura tus manifiestos de Pod para RDMA de GPUDirect

Autopilot

Estándar

Autopilot

Estándar

Autopilot

Estándar

Prueba el rendimiento de la red para los clústeres que usan RDMA de GPUDirect

¿Qué sigue?

Crea un clúster de GKE personalizado y optimizado para IA que use A4 o A3 Ultra