Provisionner Managed Lustre sur GKE à l'aide de XPK

Ce document explique comment intégrer Managed Lustre à GKE pour créer un environnement optimisé pour les charges de travail exigeantes et gourmandes en données, telles que l'intelligence artificielle (IA), le machine learning (ML) et le calcul hautes performances (HPC).

Dans ce document, vous provisionnez un cluster GKE avec XPK, créez une instance Lustre gérée et l'associez au cluster. Pour tester cette configuration, vous exécutez une charge de travail sur des nœuds qui provisionnent le démarrage flexible.

Ce document s'adresse aux ingénieurs en machine learning (ML) et aux spécialistes des données et de l'IA qui souhaitent explorer les fonctionnalités d'orchestration de conteneurs Kubernetes reposant sur des instances Lustre gérées. Pour en savoir plus sur les rôles courants et les exemples de tâches que nous citons dans le contenu Google Cloud , consultez Rôles utilisateur et tâches courantes de GKE.

Arrière-plan

Cette section décrit les principales technologies utilisées dans ce document :

XPK

XPK est un outil qui simplifie le provisionnement et la gestion des clusters et des charges de travail GKE, en particulier pour les tâches d'IA/ML. XPK aide à générer une infrastructure préconfigurée et optimisée pour l'entraînement, ce qui en fait une bonne option pour les environnements de tests et de validation de concept.

Vous pouvez créer un cluster qui utilise des TPU à l'aide de la Google Cloud CLI ou d'un kit de traitement accéléré (XPK).

  • Utilisez la gcloud CLI pour créer manuellement votre instance de cluster GKE afin de personnaliser précisément ou d'étendre les environnements GKE de production existants.
  • Utilisez XPK pour créer rapidement des clusters GKE et exécuter des charges de travail pour les preuves de concept et les tests. Pour en savoir plus, consultez le fichier README XPK.

Ce document utilise XPK exclusivement pour provisionner et gérer les ressources.

Pour en savoir plus, consultez la documentation sur l'Accelerated Processing Kit (XPK).

Démarrage flexible

Le démarrage flexible vous permet d'optimiser le provisionnement de TPU en ne payant que les ressources dont vous avez besoin. Le démarrage flexible est recommandé si votre charge de travail nécessite des ressources provisionnées de manière dynamique selon les besoins, pendant sept jours maximum, et un accès économique.

Ce document utilise le démarrage flexible comme exemple d'option de consommation, mais vous pouvez également utiliser d'autres options, par exemple les réservations ou les instances Spot. Pour en savoir plus, consultez À propos des options de consommation d'accélérateurs pour les charges de travail d'IA/ML dans GKE.

Managed Lustre

Managed Lustre est un service de système de fichiers parallèles hautes performances conçu pour les charges de travail exigeantes. Le pilote CSI Managed Lustre vous permet d'intégrer des instances Managed Lustre à GKE à l'aide de volumes persistants (PV) et de revendications de volumes persistants (PVC) Kubernetes standards. Ce pilote est particulièrement utile pour les charges de travail d'IA, de ML et de HPC nécessitant un stockage persistant, évolutif et à haut débit.

Pour en savoir plus, consultez À propos du pilote CSI Lustre géré.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

  • Activez l'API Google Cloud Managed Lustre et l'API Google Kubernetes Engine.
    • Activer les API
  • Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé la gcloud CLI, obtenez la dernière version en exécutant la commande gcloud components update. Il est possible que les versions antérieures de la gcloud CLI ne permettent pas d'exécuter les commandes de ce document.

Préparer votre environnement

Cette section vous explique comment préparer l'environnement de votre cluster.

  1. Dans la nouvelle fenêtre de terminal, créez un environnement virtuel :

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

  2. Installez XPK en suivant les étapes du fichier Installation de XPK. Utilisez pip install au lieu de cloner à partir de la source.

  3. Définissez les variables d'environnement par défaut :

    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

    Remplacez les valeurs suivantes :

    Les commandes précédentes configurent un type d'accélérateur v6e-16. Cette configuration inclut les variables suivantes :

    • ACCELERATOR_TYPE=v6e-16 : correspond à un TPU Trillium avec une topologie 4x4. Cette version de TPU indique à GKE de provisionner un pool de nœuds de tranche multi-hôte. v6e-16 correspond au type de machine ct6e-standard-4t dans GKE.
    • NUM_SLICES=1 : nombre de pools de nœuds de tranche TPU que XPK crée pour le ACCELERATOR_TYPE que vous sélectionnez.

    Si vous souhaitez personnaliser les variables ACCELERATOR_TYPE et NUM_SLICES, consultez les documents suivants pour trouver les combinaisons disponibles :

Préparer un réseau VPC

Préparez un réseau de cloud privé virtuel pour votre instance Managed Lustre et votre cluster GKE.

  1. Activez l'API Service Networking :

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

  2. Créez un réseau VPC :

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

  3. Créez une plage d'adresses IP pour l'appairage de VPC :

    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. Obtenez la plage CIDR de la plage d'adresses IP :

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

  5. Créez une règle de pare-feu pour autoriser le trafic TCP à partir de la plage d'adresses 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. Connectez l'appairage de VPC.

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

Créer une instance de stockage Managed Lustre

Créez une instance de stockage Managed Lustre.

  1. Définissez les variables d'instance de stockage :

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

    Remplacez les valeurs suivantes :

    • STORAGE_NAME : nom de votre instance Managed Lustre.
    • STORAGE_THROUGHPUT : débit de l'instance Managed Lustre, en Mio/s par Tio. Pour connaître les valeurs de débit valides, consultez Calculer votre nouvelle capacité.
    • STORAGE_CAPACITY_GIB : capacité de l'instance Managed Lustre, en Gio. Pour connaître les valeurs de capacité valides, consultez Valeurs de capacité et de débit autorisées.

  2. Créez l'instance 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

    L'indicateur --async crée l'instance de manière asynchrone et fournit un ID d'opération pour suivre son état.

  3. Vérifiez l'état de l'opération :

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

    Remplacez OPERATION_ID par l'ID du résultat de la commande asynchrone précédente. Si vous ne disposez pas de l'ID, vous pouvez lister toutes les opérations :

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

    L'instance est prête lorsque le résultat de la commande affiche done: true.

Utiliser XPK pour créer un cluster GKE

Utilisez XPK pour créer un cluster GKE avec un pool de nœuds.

Créez un cluster 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

Cette commande crée un cluster GKE à l'aide de XPK. Le cluster est configuré pour utiliser le démarrage flexible pour le provisionnement des nœuds et le pilote CSI Lustre géré est activé.

Associer l'instance de stockage au cluster

Pour configurer PersistentVolume (PV) et PersistentVolumeClaim (PVC), cette section utilise la commande d'association de stockage XPK (xpk storage attach) avec un fichier manifeste. Cette section utilise un exemple de fichier manifeste issu du code source XPK.

Associez l'instance de stockage Managed Lustre à votre cluster GKE en procédant comme suit :

  1. Téléchargez l'exemple de fichier manifeste dans votre répertoire de travail actuel et enregistrez-le sous le nom lustre-manifest-attach.yaml.

  2. Mettez à jour le fichier manifeste avec les informations de votre instance Managed Lustre :

    1. Dans la section PersistentVolume, remplacez les valeurs suivantes :

      • STORAGE_SIZE : taille de l'instance Managed Lustre, en Gio.
      • PROJECT_ID/ZONE/INSTANCE_NAME : chemin d'accès complet à la ressource de votre instance Managed Lustre.
      • IP_ADDRESS : adresse IP de l'instance Managed Lustre.
      • FILE_SYSTEM : le type de système de fichiers, qui est lfs.

    2. Dans la section PersistentVolumeClaim, remplacez les valeurs suivantes :

      • STORAGE_SIZE : taille du PersistentVolumeClaim, en Gio.

  3. Associez l'instance de stockage au cluster :

    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. Vérifiez que vous avez associé le stockage au cluster :

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

Exécuter une charge de travail

Exécutez une charge de travail avec l'instance Managed Lustre associée . L'exemple de commande suivant liste les disques disponibles et crée un fichier "hello" dans le répertoire de l'instance Managed Lustre.

Créez et exécutez la charge de travail :

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

Effectuer un nettoyage

Une fois les étapes de ce document terminées, supprimez le cluster pour éviter que des frais inutiles ne vous soient facturés sur votre compte :

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

Étapes suivantes