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 schaffen.

In diesem Dokument stellen Sie einen GKE-Cluster mit XPK bereit, erstellen eine verwaltete 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 Data & AI-Spezialisten, die sich für die Funktionen zur Kubernetes-Containerorchestrierung interessieren, die von verwalteten Lustre-Instanzen unterstützt werden. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die in 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. XPK hilft bei der Generierung vorkonfigurierter, für das Training optimierter Infrastruktur. Daher ist es eine gute Option für Proof-of-Concepts und Testumgebungen.

Sie können einen Cluster erstellen, in dem TPUs verwendet werden. Verwenden Sie dazu die Google Cloud CLI oder ein Accelerated Processing Kit (XPK).

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

In diesem Dokument wird XPK ausschließlich zum Bereitstellen und Verwalten 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, da Sie nur für die Ressourcen zahlen, die Sie benötigen. Flex-Start wird empfohlen, wenn für Ihre Arbeitslast Ressourcen nach Bedarf für bis zu sieben Tage dynamisch bereitgestellt werden müssen und Sie kostengünstigen Zugriff benötigen.

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

Managed Lustre

Managed Lustre ist ein paralleles Hochleistungs-Dateisystem, das für anspruchsvolle Arbeitslasten entwickelt wurde. Mit dem Managed Lustre-CSI-Treiber können Sie Managed Lustre-Instanzen in GKE einbinden. Dazu verwenden Sie standardmäßige Kubernetes-Anforderungen an nichtflüchtige Volumes (PersistentVolumeClaims, PVCs) und nichtflüchtige Volumes (PersistentVolumes, PVs). Dieser Treiber ist besonders nützlich für KI-, ML- und HPC-Arbeitslasten, die einen persistenten, skalierbaren Speicher mit hohem Durchsatz erfordern.

Weitere Informationen finden Sie unter Informationen zum verwalteten Lustre-CSI-Treiber.

Hinweise

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, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem Befehl gcloud components update ab. In früheren gcloud CLI-Versionen werden die Befehle in diesem Dokument möglicherweise nicht unterstützt.

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. Installieren Sie XPK gemäß der Anleitung in der Datei XPK installation. 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 vom Typ v6e-16 konfiguriert. Diese Konfiguration umfasst 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 entspricht dem Maschinentyp ct6e-standard-4t in GKE.
    • NUM_SLICES=1: Die Anzahl der TPU-Slice-Knotenpools, die von XPK für die ausgewählte ACCELERATOR_TYPE erstellt werden.

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

    • Informationen zum Ermitteln der TPU-Version, des Maschinentyps für GKE, der Topologie und der 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

VPC-Netzwerk für Ihre verwaltete Lustre-Instanz und Ihren GKE-Cluster vorbereiten

  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. IP-Adressbereich für VPC-Peering erstellen:

    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 den 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. Stellen Sie die VPC-Peering-Verbindung her.

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

Managed Lustre-Speicherinstanz erstellen

Managed Lustre-Speicherinstanz erstellen

  1. Variablen für die Speicherinstanz festlegen:

    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ätswerte 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

    Das Flag --async erstellt die Instanz asynchron und stellt eine Vorgangs-ID zum Verfolgen des Status bereit.

  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

Mit XPK einen GKE-Cluster mit einem Knotenpool erstellen

Erstellen Sie einen GKE-Cluster.

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 verwaltete Lustre-CSI-Treiber ist aktiviert.

Speicherinstanz an den Cluster anhängen

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

So hängen Sie die Managed Lustre-Speicherinstanz an Ihren GKE-Cluster an:

  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 verwalteten 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 Festplatten aufgelistet und eine Datei namens „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