Aprovisiona Managed Lustre en GKE con XPK

En este documento, se explica cómo integrar Managed Lustre con GKE para crear un entorno optimizado para cargas de trabajo exigentes y con uso intensivo de datos, como la inteligencia artificial (IA), el aprendizaje automático (AA) y la computación de alto rendimiento (HPC).

En este documento, aprovisionarás un clúster de GKE con XPK, crearás una instancia de Lustre administrada y la conectarás al clúster. Para probar esta configuración, ejecuta una carga de trabajo en nodos que se aprovisionan con inicio flexible.

Este documento está dirigido a ingenieros de aprendizaje automático (AA) y especialistas en datos y en IA que deseen explorar las capacidades de organización de contenedores de Kubernetes respaldadas por instancias de Lustre administradas. Para obtener más información sobre los roles comunes y las tareas de ejemplo a las que se hace referencia en el contenido de Google Cloud , consulta Roles y tareas comunes del usuario de GKE.

Fondo

En esta sección, se describen las tecnologías clave que se usan en este documento:

XPK

XPK es una herramienta que simplifica el aprovisionamiento y la administración de clústeres y cargas de trabajo de GKE, en especial para las tareas de IA/AA. XPK ayuda a generar infraestructura previamente configurada y optimizada para el entrenamiento, lo que la convierte en una buena opción para pruebas de concepto y entornos de prueba.

Puedes crear un clúster que use TPU con Google Cloud CLI o un kit de procesamiento acelerado (XPK).

  • Usa gcloud CLI para crear manualmente la instancia de tu clúster de GKE y personalizar o expandir con precisión los entornos de producción de GKE existentes.
  • Usa XPK para crear clústeres de GKE con rapidez y ejecutar cargas de trabajo para pruebas de concepto y pruebas. Para obtener más información, consulta el README de XPK.

En este documento, se usa XPK exclusivamente para aprovisionar y administrar recursos.

Para obtener más información, consulta la documentación del Accelerated Processing Kit (XPK).

Inicio flexible

Inicio flexible te permite optimizar el aprovisionamiento de TPU, ya que pagas solo por los recursos que necesitas. Se recomienda el inicio flexible si tu carga de trabajo requiere recursos aprovisionados de forma dinámica según sea necesario, durante un máximo de siete días y con acceso rentable.

En este documento, se usa el inicio flexible como ejemplo de opción de consumo, pero también puedes usar otras opciones, como las reservas o las instancias Spot. Para obtener más información, consulta Acerca de las opciones de consumo de aceleradores para cargas de trabajo de IA/AA en GKE.

Managed Lustre

Managed Lustre es un servicio de sistema de archivos paralelo de alto rendimiento diseñado para cargas de trabajo exigentes. El controlador de CSI de Managed Lustre te permite integrar instancias de Managed Lustre con GKE, utilizando reclamos de volúmenes persistentes (PVC) y volúmenes persistentes (PV) estándar de Kubernetes. Este controlador es especialmente beneficioso para las cargas de trabajo de IA, AA y HPC que requieren almacenamiento persistente, escalable y de alto rendimiento.

Para obtener más información, consulta Acerca del controlador CSI de Lustre administrado.

Antes de comenzar

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

  • Habilita la API de Google Cloud Managed Lustre y la API de Google Kubernetes Engine.
    • Habilita las APIs
  • 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.

Prepara el entorno

En esta sección, se muestra cómo preparar tu entorno de clúster.

  1. En la nueva ventana de la terminal, crea un entorno virtual:

    VENV_DIR=~/venvp4;python3 -m venv $VENV_DIR;source $VENV_DIR/bin/activate

  2. Para instalar XPK, sigue los pasos del archivo de instalación de XPK. Usa pip install en lugar de clonar desde la fuente.

  3. Configura las variables de entorno predeterminadas:

    gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export LOCATION=LOCATION
export CLUSTER_NAME=CLUSTER_NAME
export GKE_VERSION=VERSION
export NETWORK_NAME=NETWORK_NAME
export IP_RANGE_NAME=IP_RANGE_NAME
export FIREWALL_RULE_NAME=FIREWALL_RULE_NAME
export ACCELERATOR_TYPE=v6e-16
export NUM_SLICES=1

    Reemplaza los siguientes valores:

    Los comandos anteriores configuran un tipo de acelerador v6e-16. Esta configuración incluye las siguientes variables:

    • ACCELERATOR_TYPE=v6e-16: Corresponde a la TPU Trillium con una topología 4x4. Esta versión de TPU le indica a GKE que aprovisione un grupo de nodos de porción de varios hosts. v6e-16 se asigna al tipo de máquina ct6e-standard-4t en GKE.
    • NUM_SLICES=1: Es la cantidad de grupos de nodos de porción de TPU que crea XPK para el ACCELERATOR_TYPE que seleccionas.

    Si deseas personalizar las variables ACCELERATOR_TYPE y NUM_SLICES, consulta los siguientes documentos para encontrar las combinaciones disponibles:

    • Para identificar la versión de TPU, el tipo de máquina para GKE, la topología y la zona disponible que deseas usar, consulta Planifica las TPU en GKE.
    • Para correlacionar el tipo de máquina de GKE con el tipo de acelerador en la API de Cloud TPU, consulta la documentación de TPU Trillium (v6e).

Prepara una red de VPC

Prepara una red de nube privada virtual para tu instancia de Lustre administrada y tu clúster de GKE.

  1. Habilita la API de Service Networking:

    gcloud services enable servicenetworking.googleapis.com \
        --project=${PROJECT_ID}

  2. Crea una red de VPC:

    gcloud compute networks create ${NETWORK_NAME} \
        --subnet-mode=auto --project=${PROJECT_ID} \
        --mtu=8896

  3. Crea un rango de direcciones IP para el intercambio de tráfico entre VPCs:

    gcloud compute addresses create ${IP_RANGE_NAME} \
        --global \
        --purpose=VPC_PEERING \
        --prefix-length=20 \
        --description="Managed Lustre VPC Peering" \
        --network=${NETWORK_NAME} \
        --project=${PROJECT_ID}

  4. Obtén el rango de CIDR del rango de direcciones IP:

    CIDR_RANGE=$(
    gcloud compute addresses describe ${IP_RANGE_NAME} \
            --global  \
            --format="value[separator=/](address, prefixLength)" \
            --project=${PROJECT_ID}
)

  5. Crea una regla de firewall para permitir el tráfico de TCP desde el rango de direcciones IP:

    gcloud compute firewall-rules create ${FIREWALL_RULE_NAME} \
        --allow=tcp:988,tcp:6988 \
        --network=${NETWORK_NAME} \
        --source-ranges=${CIDR_RANGE} \
        --project=${PROJECT_ID}

  6. Conecta el intercambio de tráfico entre VPC.

    gcloud services vpc-peerings connect \
        --network=${NETWORK_NAME} \
        --project=${PROJECT_ID} \
        --ranges=${IP_RANGE_NAME} \
        --service=servicenetworking.googleapis.com

Crea una instancia de almacenamiento de Managed Lustre

Crea una instancia de almacenamiento de Managed Lustre.

  1. Establece variables de instancia de almacenamiento:

    export STORAGE_NAME=STORAGE_NAME
export STORAGE_THROUGHPUT=STORAGE_THROUGHPUT
export STORAGE_CAPACITY=STORAGE_CAPACITY_GIB
export STORAGE_FS=lfs

    Reemplaza los siguientes valores:

    • STORAGE_NAME: Es el nombre de tu instancia de Managed Lustre.
    • STORAGE_THROUGHPUT: Es la capacidad de procesamiento de la instancia de Managed Lustre, en MiB/s por TiB. Para conocer los valores de capacidad de procesamiento válidos, consulta Cómo calcular tu nueva capacidad.
    • STORAGE_CAPACITY_GIB: Es la capacidad de la instancia de Managed Lustre, en GiB. Para conocer los valores de capacidad válidos, consulta Valores de capacidad y procesamiento permitidos.

  2. Crea la instancia de Managed Lustre:

    gcloud lustre instances create ${STORAGE_NAME} \
        --per-unit-storage-throughput=${STORAGE_THROUGHPUT} \
        --capacity-gib=${STORAGE_CAPACITY} \
        --filesystem=${STORAGE_FS} \
        --location=${LOCATION} \
        --network=projects/${PROJECT_ID}/global/networks/${NETWORK_NAME} \
        --project=${PROJECT_ID} \
        --async # Creates the instance asynchronously

    La marca --async crea la instancia de forma asíncrona y proporciona un ID de operación para hacer un seguimiento de su estado.

  3. Verifica el estado de la operación:

    gcloud lustre operations describe OPERATION_ID  \
        --location=${LOCATION} \
        --project=${PROJECT_ID}

    Reemplaza OPERATION_ID por el ID del resultado del comando asíncrono anterior. Si no tienes el ID, puedes enumerar todas las operaciones:

    gcloud lustre operations list \
        --location=${LOCATION} \
        --project=${PROJECT_ID}

    La instancia está lista cuando el resultado del comando muestra done: true.

Usa XPK para crear un clúster de GKE

Usa XPK para crear un clúster de GKE con un grupo de nodos.

Crea un clúster de GKE:

xpk cluster create --cluster ${CLUSTER_NAME} \
        --num-slices=${NUM_SLICES} \
        --tpu-type=${ACCELERATOR_TYPE} \
        --zone=${LOCATION} \
        --project=${PROJECT_ID} \
        --gke-version=${GKE_VERSION} \
        --custom-cluster-arguments="--network=${NETWORK_NAME}" \
        --enable-lustre-csi-driver \
        --flex

Este comando crea un clúster de GKE con XPK. El clúster está configurado para usar el inicio flexible para el aprovisionamiento de nodos y tiene habilitado el controlador CSI de Lustre administrado.

Conecta la instancia de almacenamiento al clúster

Para configurar PersistentVolume (PV) y PersistentVolumeClaim (PVC), en esta sección, se usa el comando de adjuntar almacenamiento de XPK (xpk storage attach) con un archivo de manifiesto. En esta sección, se usa un manifiesto de ejemplo del código fuente de XPK.

Para adjuntar la instancia de almacenamiento de Managed Lustre a tu clúster de GKE, completa estos pasos:

  1. Descarga el archivo de manifiesto de ejemplo en tu directorio de trabajo actual y guárdalo como lustre-manifest-attach.yaml.

  2. Actualiza el archivo de manifiesto con la información de tu instancia de Managed Lustre:

    1. En la sección PersistentVolume, reemplaza los siguientes valores:

      • STORAGE_SIZE: Es el tamaño de la instancia de Managed Lustre, expresado en GiB.
      • PROJECT_ID/ZONE/INSTANCE_NAME: Es la ruta de acceso completa al recurso de tu instancia de Lustre administrado.
      • IP_ADDRESS: Es la dirección IP de la instancia de Lustre administrada.
      • FILE_SYSTEM: Es el tipo de sistema de archivos, que es lfs.

    2. En la sección PersistentVolumeClaim, reemplaza los siguientes valores:

      • STORAGE_SIZE: Es el tamaño del PersistentVolumeClaim, en GiB.

  3. Adjunta la instancia de almacenamiento al clúster:

    xpk storage attach ${STORAGE_NAME} \
        --cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION} \
        --type=lustre \
        --mount-point='/lustre-data' \
        --readonly=false \
        --auto-mount=true \
        --manifest='./lustre-manifest-attach.yaml'

  4. Verifica que hayas adjuntado el almacenamiento para el clúster:

    xpk storage list \
        --cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION}

Ejecuta una carga de trabajo

Ejecuta una carga de trabajo con la instancia de Managed Lustre adjunta . En el siguiente comando de ejemplo, se enumeran los discos disponibles y se crea un archivo "hello" en el directorio de la instancia de Managed Lustre.

Crea y ejecuta la carga de trabajo:

xpk workload create --workload test-lustre \
--cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION} \
--command="df -h && echo 'hello' > /lustre-data/hello.txt && cat /lustre-data/hello.txt" \
--tpu-type=${ACCELERATOR_TYPE} \
--num-slices=1 \
--flex

Realiza una limpieza

Después de completar los pasos de este documento, borra el clúster para evitar que se generen cargos no deseados en tu cuenta:

  xpk cluster delete --cluster ${CLUSTER_NAME} \
        --zone ${LOCATION} \
        --project ${PROJECT_ID}

¿Qué sigue?