Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Crea un clúster de GKE con Pathways

En esta página, se muestra a los administradores de plataformas y a los ingenieros de aprendizaje automático (AA) cómo crear un clúster de Google Kubernetes Engine (GKE) configurado para cargas de trabajo basadas en Pathways. Puedes aprovisionar clústeres preconfigurados de forma automática con Cluster Toolkit o crearlos manualmente con Google Cloud CLI.

Antes de comenzar

Completa los siguientes requisitos previos antes de continuar:

Instala gcloud CLI.
Instala kubectl y el gke-gcloud-auth-plugin.
Si usas Cluster Toolkit, configúralo y actualízalo a la versión más reciente.
Habilita la API de Kubernetes Engine.
Verifica que tengas suficiente cuota de TPU o una reserva de TPU para las porciones de TPU que deseas crear.

Cómo configurar tu entorno local

Accede a gcloud CLI con tus credenciales de Google Cloud :

gcloud auth login

Si usas Cluster Toolkit, también genera credenciales predeterminadas de la aplicación (ADC), que usa Terraform:

gcloud auth application-default login

Crea un clúster de GKE

En el siguiente ejemplo, crearás un clúster con grupos de nodos TPU v6e 2x4. Puedes crear un clúster con Cluster Toolkit o gcloud CLI.

Cluster Toolkit

Implementa un clúster de TPU de GKE siguiendo las instrucciones que se indican en Implementa un clúster de TPU v6e de GKE. Para obtener una descripción general de todas las opciones de implementación de TPU, consulta Descripción general de las implementaciones de Cloud TPU.

Cuando configures tu plano de implementación, haz lo siguiente:
- Establece enable_pathways_for_tpus en true (habilitado de forma predeterminada en los planos de TPU de Cluster Toolkit). Este parámetro de configuración aprovisiona automáticamente el grupo de nodos de CPU cpu-np (n4-standard-64) y los parámetros de configuración de Kueue necesarios para el controlador de Pathways. Cluster Toolkit aplica la configuración predeterminada de Kueue de Pathways solo si no especificas un archivo de configuración de Kueue personalizado en la variable kueue_configuration_path.
- Establece num_slices en la cantidad de grupos de nodos de porción de TPU que se requieren para tu carga de trabajo.
- Establece tpu_topology en la topología de porción de TPU que seleccionaste (por ejemplo, 2x4 o 4x4).
- Elige una opción de consumo. De forma predeterminada, el archivo de implementación de TPU v6e consume una reserva de TPU específica, por lo que debes especificar el nombre de la reserva en la variable reservation_affinity. Para usar una opción de consumo diferente, consulta Opciones de consumo de GKE.
Verifica que los nodos del clúster tengan un STATUS de Ready:
```
kubectl get nodes
```
Después de crear el clúster, puedes enviar cargas de trabajo de Pathways con el comando gcluster job submit con las marcas --pathways y --pathways-gcs-location. Para obtener más información, consulta Ejecuta cargas de trabajo con Pathways.

gcloud

Para crear un clúster de GKE y configurarlo para ejecutar cargas de trabajo de Pathways, sigue estos pasos:

Configura las siguientes variables de entorno:
```
CLUSTER=GKE_CLUSTER_NAME
PROJECT=PROJECT_ID
ZONE=ZONE
REGION=REGION
CLUSTER_VERSION=GKE_CLUSTER_VERSION
PW_CPU_MACHINE_TYPE="n2-standard-64"
NETWORK=NETWORK
SUBNETWORK=SUB_NETWORK
CLUSTER_NODEPOOL_COUNT=3
TPU_MACHINE_TYPE="ct6e-standard-4t"
WORKERS_PER_SLICE=2
TOPOLOGY="2x4"
NUM_CPU_NODES=1
```
Reemplaza lo siguiente:
- GKE_CLUSTER_NAME: el nombre del clúster de GKE.
- PROJECT_ID: Es el ID del proyecto de Google Cloud .
- ZONE: Es la zona en la que creas el clúster. Elige una zona en la que esté disponible la TPU v6e. Para obtener más información, consulta Regiones y zonas de Cloud TPU.
- REGION: Es la región en la que creas recursos si usas un clúster regional (opcional).
- GKE_CLUSTER_VERSION: Es opcional y corresponde a la versión del clúster de GKE. Usa 1.32.2-gke.1475000 o una versión posterior, y elige una versión que tenga asistencia estándar. Para obtener más información, consulta el programa de lanzamientos de GKE. Si no especificas una versión, quita la marca --cluster-version del siguiente comando gcloud container clusters create.
- NETWORK: Es opcional y corresponde al nombre de una red de nube privada virtual (VPC). La red debe existir antes de que crees el clúster. Si no especificas una red, quita la marca --network del siguiente comando gcloud container clusters create.
- SUB_NETWORK: Es el nombre de una subred (opcional). La subred debe existir antes de crear el clúster. Si no especificas una subred, quita la marca --subnetwork del siguiente comando gcloud container clusters create.
En este ejemplo, se establecen valores predeterminados para las variables restantes, que puedes modificar para tu carga de trabajo:
- PW_CPU_MACHINE_TYPE: Es el tipo de máquina para el grupo de nodos predeterminado del clúster y para el grupo de nodos de CPU que ejecuta el encabezado de Pathways (el administrador de recursos y el proxy de Pathways).
- NUM_CPU_NODES: Es la cantidad de nodos en el grupo de nodos de CPU.
- CLUSTER_NODEPOOL_COUNT: Es la cantidad de porciones de TPU. Cada porción es un grupo de nodos independiente.
- TPU_MACHINE_TYPE y TOPOLOGY: el tipo de máquina de TPU y la topología de TPU de cada porción.
- WORKERS_PER_SLICE: Es la cantidad de nodos en cada porción, que es la cantidad de chips TPU en la topología dividida por la cantidad de chips por nodo. Por ejemplo, una topología 2x4 tiene 8 chips y un nodo ct6e-standard-4t tiene 4 chips, por lo que cada porción tiene 2 nodos.

Crea un clúster de GKE con el comando gcloud container clusters create:

gcloud container clusters create ${CLUSTER} \
    --project=${PROJECT} \
    --zone=${ZONE} \
    --cluster-version=${CLUSTER_VERSION} \
    --scopes=storage-full,gke-default,cloud-platform \
    --machine-type=${PW_CPU_MACHINE_TYPE} \
    --network=${NETWORK} \
    --subnetwork=${SUBNETWORK}

Crea los grupos de nodos de porción de TPU con el comando gcloud container node-pools create:

for i in $(seq 1 ${CLUSTER_NODEPOOL_COUNT}); do
    gcloud container node-pools create "tpu-np-${i}" \
        --project=${PROJECT} \
        --zone=${ZONE} \
        --cluster=${CLUSTER} \
        --machine-type=${TPU_MACHINE_TYPE} \
        --num-nodes=${WORKERS_PER_SLICE} \
        --placement-type=COMPACT \
        --tpu-topology=${TOPOLOGY} \
        --scopes=storage-full,gke-default,cloud-platform \
        --workload-metadata=GCE_METADATA
done

Estos comandos no se orientan a una reserva específica. Para consumir una reserva de TPU, agrega las marcas --reservation-affinity=specific y --reservation=RESERVATION_NAME, en las que RESERVATION_NAME es el nombre de tu reserva de TPU. Para usar las VMs Spot, agrega la marca --spot.

Crea un grupo de nodos de CPU para el encabezado de Pathways, que ejecuta el administrador de recursos y el proxy de Pathways. Asigna el nombre cpu-np al grupo de nodos para que el comando gcluster job submit --pathways pueda detectarlo:
```
gcloud container node-pools create cpu-np \
    --project=${PROJECT} \
    --zone=${ZONE} \
    --cluster=${CLUSTER} \
    --machine-type=${PW_CPU_MACHINE_TYPE} \
    --num-nodes=${NUM_CPU_NODES} \
    --scopes=storage-full,gke-default,cloud-platform \
    --workload-metadata=GCE_METADATA
```
Nota: Las cargas de trabajo de Pathways almacenan archivos temporales y código compilado almacenado en caché en un bucket de Cloud Storage. Debido a que los grupos de nodos de este ejemplo usan --workload-metadata=GCE_METADATA, los contenedores de Pathways acceden a Cloud Storage con la cuenta de servicio del nodo. De forma predeterminada, esta cuenta es la cuenta de servicio predeterminada de Compute Engine. Otorga a esta cuenta de servicio el rol de administrador de objetos de almacenamiento (roles/storage.objectAdmin) en el bucket.
Obtén credenciales para el clúster y establece el espacio de nombres predeterminado para kubectl:

Nota: Si usas un clúster zonal, como el de este ejemplo, especifica --zone. Si usas un clúster regional, reemplaza --zone=${ZONE} por --region=${REGION}.
```
gcloud container clusters get-credentials ${CLUSTER} \
    --zone=${ZONE} \
    --project=${PROJECT} \
    && kubectl config set-context --current --namespace=default
```

Para usar la arquitectura de Pathways en tu clúster de GKE, instala la API de JobSet:

kubectl apply --server-side -f https://github.com/kubernetes-sigs/jobset/releases/download/v0.12.0/manifests.yaml

Verifica que los nodos tengan un STATUS de Ready y que el Pod jobset-controller-manager tenga un STATUS de Running:

kubectl get nodes
kubectl get pods --namespace=jobset-system

El resultado es similar a lo siguiente:

NAME                                      STATUS   ROLES    AGE   VERSION
gke-cluster-cpu-np-12345678-abcd          Ready    <none>   5m    v1.32.2-gke.1475000
gke-cluster-tpu-np-1-12345678-efgh        Ready    <none>   5m    v1.32.2-gke.1475000
...
NAME                                         READY   STATUS    RESTARTS   AGE
jobset-controller-manager-6f7b8c9d4-xyz12    1/1     Running   0          2m

Realiza una limpieza

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página, borra el clúster cuando termines:

Cluster Toolkit: Destruye la implementación ejecutando el siguiente comando:
```
./gcluster destroy DEPLOYMENT_FOLDER_NAME
```
Reemplaza DEPLOYMENT_FOLDER_NAME por el nombre de tu carpeta de implementación.

gcloud CLI: Ejecuta el siguiente comando para borrar el clúster de GKE y sus grupos de nodos:

gcloud container clusters delete ${CLUSTER} \
    --project=${PROJECT} \
    --zone=${ZONE}