Managed Lustre in GKE mit XPK bereitstellen

In diesem Dokument wird beschrieben, wie Sie Managed Lustre in GKE einbinden, um eine optimierte Umgebung für anspruchsvolle, datenintensive Arbeitslasten wie künstliche Intelligenz (KI), maschinelles Lernen (ML) und Hochleistungs-Computing (HPC) zu erstellen.

In diesem Dokument stellen Sie einen GKE-Cluster mit XPK bereit, erstellen eine Managed Lustre-Instanz und hängen sie an den Cluster an. Um diese Konfiguration zu testen, führen Sie eine Arbeitslast auf Knoten aus, die mit Flex-Start bereitgestellt werden.

Dieses Dokument richtet sich an ML-Entwickler und Daten- und KI-Spezialisten , die die Kubernetes-Containerorchestrierungsfunktionen mit Managed Lustre-Instanzen kennenlernen möchten. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die in den Google Cloud Inhalten verwiesen wird, finden Sie unter Häufig verwendete GKE-Nutzerrollen und -Aufgaben.

Hintergrund

In diesem Abschnitt werden die in diesem Dokument verwendeten Schlüsseltechnologien beschrieben:

XPK

XPK ist ein Tool, das die Bereitstellung und Verwaltung von GKE-Clustern und -Arbeitslasten vereinfacht, insbesondere für KI/ML-Aufgaben. Mit XPK können vorkonfigurierte, für das Training optimierte Infrastrukturen generiert werden. Daher ist es eine gute Option für Machbarkeitsstudien und Testumgebungen.

Sie können einen Cluster mit TPUs über die Google Cloud CLI oder ein Accelerated Processing Kit (XPK) erstellen.

  • Verwenden Sie die gcloud CLI, um Ihre GKE-Clusterinstanz manuell zu erstellen und so vorhandene GKE-Produktionsumgebungen präzise anzupassen oder zu erweitern.
  • Mit XPK können Sie schnell GKE-Cluster erstellen und Arbeitslasten für Machbarkeitsstudien und Tests ausführen. Weitere Informationen finden Sie in der XPK-README-Datei.

In diesem Dokument wird XPK ausschließlich für die Bereitstellung und Verwaltung von Ressourcen verwendet.

Weitere Informationen finden Sie in der Dokumentation zum Accelerated Processing Kit (XPK).

Flex-Start

Mit Flex-Start können Sie die TPU-Bereitstellung optimieren, indem Sie nur für die Ressourcen bezahlen, die Sie benötigen. Flex-Start wird empfohlen, wenn Ihre Arbeitslast dynamisch bereitgestellte Ressourcen nach Bedarf für bis zu sieben Tage und kostengünstigen Zugriff erfordert.

In diesem Dokument wird Flex-Start als Beispiel für eine Verbrauchsoption verwendet. Sie können aber auch andere Optionen wie Reservierungen oder Spot-VMs verwenden. Weitere Informationen finden Sie unter Optionen für den Verbrauch von Beschleunigern für KI/ML-Arbeitslasten in GKE.

Managed Lustre

Managed Lustre ist ein leistungsstarker, paralleler Dateisystemdienst, der für anspruchsvolle Arbeitslasten entwickelt wurde. Mit dem Managed Lustre CSI-Treiber können Sie Managed Lustre-Instanzen in GKE einbinden und dabei standardmäßige Kubernetes-PVCs (PersistentVolumeClaims) und PVs (PersistentVolumes) verwenden. Dieser Treiber ist besonders nützlich für KI-, ML- und HPC-Arbeitslasten, die nichtflüchtigen, skalierbaren Speicher mit hohem Durchsatz erfordern.

Weitere Informationen finden Sie unter Managed Lustre CSI-Treiber.

Hinweis

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

  • Aktivieren Sie die Google Cloud Managed Lustre API und die Google Kubernetes Engine API.
    • APIs aktivieren
  • Wenn Sie die Google Cloud CLI für diesen Task verwenden möchten, installieren und dann initialisieren Sie die gcloud CLI. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem gcloud components update Befehl ab. Ältere gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.

Umgebung vorbereiten

In diesem Abschnitt wird beschrieben, wie Sie Ihre Clusterumgebung vorbereiten.

  1. Erstellen Sie im neuen Terminalfenster eine virtuelle Umgebung:

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

  2. Folgen Sie der Anleitung in der XPK-Installations datei, um XPK zu installieren. Verwenden Sie pip install anstelle des Klonens aus der Quelle.

  3. Legen Sie die Standardumgebungsvariablen fest:

    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

    Ersetzen Sie die folgenden Werte:

    Mit den vorherigen Befehlen wird ein Beschleunigertyp v6e-16 konfiguriert. Diese Konfiguration enthält die folgenden Variablen:

    • ACCELERATOR_TYPE=v6e-16: entspricht TPU Trillium mit einer 4x4-Topologie. Diese TPU-Version weist GKE an, einen Knotenpool mit mehreren Hosts bereitzustellen. v6e-16 wird in GKE dem Maschinentyp ct6e-standard-4t zugeordnet.
    • NUM_SLICES=1: die Anzahl der TPU-Slice-Knotenpools, die XPK für den ausgewählten ACCELERATOR_TYPE erstellt.

    Wenn Sie die Variablen ACCELERATOR_TYPE und NUM_SLICES anpassen möchten, finden Sie in den folgenden Dokumenten die verfügbaren Kombinationen:

    • Informationen zur TPU-Version, zum Maschinentyp für GKE, zur Topologie und zur verfügbaren Zone, die Sie verwenden möchten, finden Sie unter TPUs in GKE planen.
    • Informationen zum Zuordnen des GKE-Maschinentyps zum Beschleunigertyp in der Cloud TPU API finden Sie in der Dokumentation zu TPU Trillium (v6e).

VPC-Netzwerk vorbereiten

Bereiten Sie ein VPC-Netzwerk (Virtual Private Cloud) für Ihre Managed Lustre-Instanz und Ihren GKE-Cluster vor.

  1. Aktivieren Sie die Service Networking API:

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

  2. Erstellen Sie ein VPC-Netzwerk:

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

  3. Erstellen Sie einen IP-Adressbereich für das VPC-Peering:

    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. Rufen Sie den CIDR-Bereich des IP-Adressbereichs ab:

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

  5. Erstellen Sie eine Firewallregel, um TCP-Traffic aus dem IP-Adressbereich zuzulassen:

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

  6. Verbinden Sie das VPC-Peering:

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

Managed Lustre-Speicherinstanz erstellen

Erstellen Sie eine Managed Lustre-Speicherinstanz.

  1. Legen Sie Variablen für die Speicherinstanz fest:

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

    Ersetzen Sie die folgenden Werte:

    • STORAGE_NAME: der Name Ihrer Managed Lustre-Instanz.
    • STORAGE_THROUGHPUT: der Durchsatz der Managed Lustre-Instanz in MiB/s pro TiB. Gültige Durchsatzwerte finden Sie unter Neue Kapazität berechnen.
    • STORAGE_CAPACITY_GIB: die Kapazität der Managed Lustre-Instanz in GiB. Gültige Kapazitäts werte finden Sie unter Zulässige Kapazitäts- und Durchsatzwerte.

  2. Erstellen Sie die Managed Lustre-Instanz:

    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

    Mit dem Flag --async wird die Instanz asynchron erstellt und eine Vorgangs-ID zur Nachverfolgung des Status bereitgestellt.

  3. Prüfen Sie den Status des Vorgangs:

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

    Ersetzen Sie OPERATION_ID durch die ID aus der Ausgabe des vorherigen asynchronen Befehls. Wenn Sie die ID nicht haben, können Sie alle Vorgänge auflisten:

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

    Die Instanz ist bereit, wenn in der Befehlsausgabe done: true angezeigt wird.

GKE-Cluster mit XPK erstellen

Erstellen Sie mit XPK einen GKE-Cluster mit einem Knotenpool.

GKE-Cluster erstellen:

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

Mit diesem Befehl wird ein GKE-Cluster mit XPK erstellt. Der Cluster ist für die Verwendung von Flex-Start für die Knotenbereitstellung konfiguriert und der Managed Lustre CSI-Treiber ist aktiviert.

Speicherinstanz an den Cluster anhängen

In diesem Abschnitt wird der XPK-Befehl zum Anhängen von Speicher (xpk storage attach) mit einer Manifestdatei verwendet, um das PersistentVolume (PV) und den PersistentVolumeClaim (PVC) zu konfigurieren. In diesem Abschnitt wird eine Beispielmanifestdatei aus dem XPK-Quellcode verwendet.

Führen Sie die folgenden Schritte aus, um die Managed Lustre-Speicherinstanz an Ihren GKE-Cluster anzuhängen:

  1. Laden Sie die Beispielmanifestdatei in Ihr aktuelles Arbeitsverzeichnis herunter und speichern Sie sie als lustre-manifest-attach.yaml.

  2. Aktualisieren Sie die Manifestdatei mit den Informationen Ihrer Managed Lustre-Instanz:

    1. Ersetzen Sie im Abschnitt PersistentVolume die folgenden Werte:

      • STORAGE_SIZE: die Größe der Managed Lustre-Instanz in GiB.
      • PROJECT_ID/ZONE/INSTANCE_NAME: der vollständige Ressourcenpfad Ihrer Managed Lustre-Instanz.
      • IP_ADDRESS: die IP-Adresse der Managed Lustre-Instanz.
      • FILE_SYSTEM: der Dateisystemtyp, der lfs ist.

    2. Ersetzen Sie im Abschnitt PersistentVolumeClaim die folgenden Werte:

      • STORAGE_SIZE: die Größe des PersistentVolumeClaim in GiB.

  3. Hängen Sie die Speicherinstanz an den Cluster an:

    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. Prüfen Sie, ob Sie den Speicher für den Cluster angehängt haben:

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

Arbeitslast ausführen

Führen Sie eine Arbeitslast mit der angehängten Managed Lustre-Instanz aus . Mit dem folgenden Beispielbefehl werden die verfügbaren Laufwerke aufgelistet und eine Datei „hello“ im Verzeichnis der Managed Lustre-Instanz erstellt.

Arbeitslast erstellen und ausführen:

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

Bereinigen

Wenn Sie die Schritte in diesem Dokument ausgeführt haben, löschen Sie den Cluster, um unerwünschte Kosten für Ihr Konto zu vermeiden:

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

Nächste Schritte