Batcharbeitslast für maschinelles Lernen bereitstellen

Autopilot Standard

---

In dieser Anleitung wird gezeigt, wie Sie mit Google Kubernetes Engine (GKE) fehlertolerante Batcharbeitslasten verwalten und gleichzeitig Ihre Kosten niedrig halten. In dieser Anleitung wird die Verwendung von Jobs und kostenoptimierten Spot-Pods sowie die Konfiguration eines In-ClustersRedis-Jobwarteschlange in GKE beschrieben.

Hintergrund

Eine Batcharbeitslast ist ein Prozess, der in der Regel aus einem Start- und einem Abschlusspunkt besteht. Sie sollten Batch-Arbeitslasten in GKE in Betracht ziehen, wenn Ihre Architektur Daten aufnimmt, verarbeitet und ausgibt, anstatt Rohdaten zu verwenden. Bereiche wie maschinelles Lernen, künstliche Intelligenz und Hochleistungs-Computing bieten verschiedene Arten von Batcharbeitslasten, z. B. Offline-Modelltraining, Batchvorhersage, Datenanalyse, Simulation physischer Systeme und Video-Verarbeitung.

Durch das Entwerfen von containerisierten Batcharbeitslasten können Sie die folgenden GKE-Vorteile nutzen:

• Eine umfassende Community mit offenem Standard und ein verwalteter Dienst.
• Kosteneffizienz durch effektive Orchestrierung von Arbeitslasten und Infrastrukturen sowie spezielle Computing-Ressourcen.
• Isolation und Portabilität der Containerisierung, wodurch die Nutzung der Cloud als Überlaufkapazität bei gleichzeitiger Wahrung der Datensicherheit ermöglicht wird.
• Verfügbarkeit der Burst-Kapazität gefolgt von einer schnellen Herunterskalierung von GKE-Clustern.

Ziele

Diese Anleitung richtet sich an Entwickler von maschinellem Lernen oder Data Scientists, die lernen möchten, wie sie ML-Batch-Arbeitslasten in GKE auf der folgenden kostengünstigen und skalierbaren Architektur ausführen:

Diese Anleitung umfasst die folgenden Schritte:

1. Erstellen Sie einen GKE Autopilot-Cluster. Alternativ können Sie für diese Anleitung einen GKE Standard-Cluster verwenden.
2. Erstellen Sie ein Filestore-NFS-Volume.
3. eine Redis-Jobwarteschlange im Cluster erstellen
4. Übertragen Sie Datasets auf das NFS-Volume und stellen Sie sie in die Warteschlange, damit sie von der Arbeitslast konsumiert werden.
5. Führen Sie ein Beispiel für eine ML-Batch-Arbeitslast im GKE-Cluster aus.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

• Compute Engine
• GKE Autopilot
• Filestore

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

---

Klicken Sie auf Anleitung, um eine detaillierte Anleitung für diese Aufgabe direkt in der Google Cloud Console aufzurufen.

Anleitung

---

Vorbereitung

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Compute Engine, GKE, and Filestore APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the Compute Engine, GKE, and Filestore APIs.

   Enable the APIs

8. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Umgebung vorbereiten

1. Klonen Sie das in dieser Anleitung verwendete Beispiel-Repository:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   cd kubernetes-engine-samples/batch/aiml-workloads
   

2. Erstellen Sie einen GKE Autopilot-Cluster:

   gcloud container clusters create-auto batch-aiml \
       --region=us-central1
   

   Dieser Schritt kann bis zu fünf Minuten dauern.

Dataset-Speicher mit einem Netzwerk-Dateisystem (NFS) einrichten

Die Arbeitslast für maschinelles Lernen erfordert eine Speicherlösung für die Datasets und Ausgabedateien. In diesem Abschnitt erstellen Sie eine Filestore-Instanz und gewähren Zugriff auf die Instanz mithilfe eines PersistentVolume und eines PersistentVolumeClaim.

Weitere Informationen finden Sie unter Optimale Speicherstrategie entwerfen und Auf Filestore-Instanzen von GKE-Clustern aus zugreifen.

Filestore-Instanz erstellen

1. Filestore-Instanz erstellen:

   gcloud filestore instances create batch-aiml-filestore \
       --zone=us-central1-b \
       --tier=BASIC_HDD \
       --file-share=name="NFSVol",capacity=1TB \
       --network=name="default"
   

   Dieser Befehl gibt die folgenden Optionen an:

   • tier: Die Dienststufe für die Filestore-Instanz. In diesem Beispiel wird die Basis-Stufe verwendet. Informationen zu den anderen Optionen finden Sie unter Dienststufen.

   • network=name: Der Name des VPC-Netzwerks (Virtual Private Cloud) für die Filestore-Instanz. Der GKE-Cluster muss sich im selben VPC-Netzwerk wie die Filestore-Instanz befinden.

   • capacity: Die gewünschte Größe des Volumes. Geben Sie den Speicherwert in einer der unterstützten Einheiten an, die unter Ressourcenmengen beschrieben sind.

   Hinweis: Dieser Schritt kann bis zu fünf Minuten dauern.

2. Prüfen Sie, ob die Filestore-Instanz bereitgestellt wurde:

   gcloud filestore instances list \
       --project=PROJECT_ID \
       --zone=us-central1-b
   

   Ersetzen Sie PROJECT_ID durch die Google Cloud-Projekt-ID.

   Die Ausgabe sieht in etwa so aus:

   INSTANCE_NAME: batch-aiml-filestore
   LOCATION: us-central1-b
   TIER: BASIC_HDD
   CAPACITY_GB: 1024
   FILE_SHARE_NAME: NFSVol
   IP_ADDRESS: 203.0.113.54
   STATE: READY
   CREATE_TIME: 2022-03-15T18:23:51
   

3. Notieren Sie sich den Wert im Feld IP_ADDRESS, da er im folgenden Abschnitt verwendet werden soll.

PersistentVolume erstellen

Eine Kubernetes-PersistentVolume-Spezifikation ermöglicht dem GKE-Cluster, eine Verbindung zur Filestore-Instanz herzustellen.

1. Aktualisieren Sie die Datei kubernetes-manifests/persistent-volume.yaml mit der IP-Adresse der Filestore-Instanz:

   sed -i "\
     s/<FILESTORE_IP_ADDRESS>/IP_ADDRESS/g" \
     kubernetes-manifests/persistent-volume.yaml
   

   Ersetzen Sie IP_ADDRESS durch die IP-Adresse, die Sie beim Erstellen der Filestore-Instanz im vorherigen Abschnitt notiert haben.

2. Stellen Sie das PersistentVolume bereit:

   kubectl apply -f kubernetes-manifests/persistent-volume.yaml
   

PersistentVolumeClaim erstellen

Ein Kubernetes-PersistentVolumeClaim ermöglicht Kubernetes-Pods und -Jobs den Zugriff auf die Speicherressourcen eines PersistentVolume.

Stellen Sie den PersistentVolumeClaim bereit:

kubectl apply -f kubernetes-manifests/persistent-volume-claim.yaml

PersistentVolumeClaim nutzen

Wenn das PersistentVolume und der PersistentVolumeClaim im GKE-Cluster eingerichtet sind, können Sie den Redis-Server und die Batchjobs so konfigurieren, dass sie den PersistentVolumeClaim nutzen. Dies wird als bereitstellbares Speicher-Volume angezeigt.

Prüfen Sie die Dateien kubernetes-manifests/redis-pod.yaml und kubernetes-manifests/workload.yaml. Die Manifestkonfigurationen sehen in etwa so aus:

  spec:
  …
  containers:
  - name: workload
    image: "us-central1-docker.pkg.dev/gke-batch-aiml/batch-aiml-docker-repo/workload"
    volumeMounts:
    - mountPath: /mnt/fileserver
      name: workload-pvc
  volumes:
  - name: workload-pvc
    persistentVolumeClaim:
      claimName: fileserver-claim
      readOnly: false

In diesem Manifest:

• spec.volumes gibt den zu nutzenden PersistentVolumeClaim an.
• spec.containers.volumeMounts gibt den lokalen Dateipfad an, unter dem der Pod auf die Filestore-Dateifreigabe zugreifen kann.

Redis-Jobwarteschlange einrichten

Die Arbeitslast verarbeitet Daten in Batches, um iterativ ein Betrugserkennungsmodell zu trainieren. Zum Verwalten der aktuell verarbeiteten oder noch in der Warteschlange enthaltenen Datasets stellen Sie den Redis-Server im GKE-Cluster bereit.

Für diese Anleitung starten Sie eine einzelne Instanz von Redis. Informationen zur skalierbaren und redundanten Bereitstellung von Redis finden Sie unter Mehrstufige Webanwendung mit Redis und PHP erstellen.

1. Stellen Sie die Spezifikation des Redis-Servers bereit.

   kubectl apply -f kubernetes-manifests/redis-pod.yaml
   

2. Prüfen Sie, ob der Pod ausgeführt wird:

   kubectl get pods
   

   Die Ausgabe sieht in etwa so aus:

   NAME           READY   STATUS    RESTARTS   AGE
   redis-leader   1/1     Running   0          118s
   

   Es kann bis zu zwei Minuten dauern, bis der Pod ausgeführt wird.

3. Übertragen Sie die Dateien mit den Trainings- und Test-Datasets auf das NFS-Volume.

   sh scripts/transfer-datasets.sh
   

   Dieses Script kopiert die Dateien aus dem Beispielcode-Repository in das Verzeichnis /mnt/fileserver/datasets/ auf dem Pod redis-leader.

4. Füllen Sie die Redis-Warteschlange aus.

   sh scripts/queue-jobs.sh
   

   Dieses Script überträgt die Dateipfade für die Trainings-Datasets per Push in eine Liste mit dem Namen datasets in der Redis-Datenbank. Diese Warteschlange wird von der Arbeitslast verwendet, um das nächste zu verarbeitende Dataset zu ermitteln.

5. Stellen Sie den Dienst bereit, damit der Redis-Server im GKE-Cluster gefunden werden kann.

   kubectl apply -f ./kubernetes-manifests/redis-service.yaml
   

Batch-Arbeitslast ausführen

Jetzt haben Sie den GKE-Cluster, die Redis-Jobwarteschlange und die Dateifreigabe vorbereitet. Jetzt können Sie Ihre Batch-Arbeitslast ausführen.

In diesem Abschnitt verwenden Sie ein Container-Image einer Beispielarbeitslast, um ein Betrugserkennungsmodell mithilfe von Batches an Finanztransaktionsdaten zu trainieren. Der Trainingsprozess kann so zusammengefasst werden:

1. Ein Redis-Client beansprucht Jobs (Dateipfade zu Datasets) in der Redis-Warteschlange und entfernt sie nach dem Abschluss aus der Warteschlange.

2. Die Modelltrainingadministratorklasse FraudDetectionModelTrainer lädt einen neuen Datenbatch und optional einen gespeicherten Zustand eines ML-Modells. Das Dataset wird zur Verfeinerung des Modells verwendet (ein Prozess, der als „Warmstart”-Training bezeichnet wird).

3. Der neue Status des Modells und ein Bericht der Batchdetails und Leistungspunktzahlen werden im Filestore-NFS-Volume gespeichert, auf das im GKE-Cluster mit einem PersistentVolumeClaim zugegriffen werden kann.

Weitere Informationen finden Sie wenn Sie Quellcode erkunden.

Job definieren

Das folgende Manifest beschreibt den Kubernetes-Job für das Batch-Arbeitslast-Image.

apiVersion: batch/v1
kind: Job
metadata:
  name: workload
spec:
  parallelism: 1
  template:
    metadata:
      name: workload
    spec:
      nodeSelector:
        cloud.google.com/gke-spot: "true"
      containers:
      - name: workload
        image: "us-docker.pkg.dev/google-samples/containers/gke/batch-ml-workload"
        volumeMounts:
        - mountPath: /mnt/fileserver
          name: workload-pvc
      volumes:
      - name: workload-pvc
        persistentVolumeClaim:
          claimName: fileserver-claim
          readOnly: false
      restartPolicy: OnFailure

Hinweis: Wenn Sie eine Arbeitslast konfigurieren, bei der Batches parallel ausgeführt werden können (z. B. Klassifizierungen von Images, lang andauernde Datenanalyse usw.), können Sie den Wert parallelism erhöhen, damit viele Pods den Job gleichzeitig ausführen können, bis die Abschlussbedingung erfüllt ist. Die Spezifikation nodeSelector weist GKE an, Spot-Pods zu verwenden.

Arbeitslast bereitstellen

1. Stellen Sie den Job bereit:

   kubectl apply -f ./kubernetes-manifests/workload.yaml
   

2. Prüfen Sie, ob der Pods workload-XXX den Status Completed hat:

   watch kubectl get pods
   

   Dies kann einige Sekunden dauern. Sie können zur Befehlszeile zurückkehren, indem Sie Ctrl+C drücken.

   Die entsprechende Ausgabe sieht etwa so aus:

   NAME             READY   STATUS      RESTARTS   AGE
   redis-leader     1/1     Running     0          16m
   workload-4p55d   0/1     Completed   0          83s
   

3. Prüfen Sie die Logs des Jobs workload:

   kubectl logs job/workload
   

   Die entsprechende Ausgabe sieht etwa so aus:

   Worker with sessionID: b50f9459-ce7f-4da8-9f84-0ab5c3233a72
   Initial queue state: empty=False
   Processing dataset: datasets/training/2018-04-04.pkl
   Processing dataset: datasets/training/2018-04-03.pkl
   Processing dataset: datasets/training/2018-04-02.pkl
   Processing dataset: datasets/training/2018-04-01.pkl
   Queue empty, exiting
   

   Die .pkl-Dateien sind Serialisierung von Datasets mit einem Batch von Kreditkartentransaktionen, die als gültig oder betrügerisch markiert sind. Der workload-Job durchläuft diese Dateien, entpackt die Datasets und verwendet sie zum Trainieren des Modells für maschinelles Lernen, bevor sie aus der Redis-Warteschlange entfernt werden. Die Arbeitslast verarbeitet die Daten weiterhin in Batches, bis die Redis-Warteschlange geleert wird, bevor sie erfolgreich beendet wird.

NFS-Volume ansehen

Während des Vorgangs erstellt die Arbeitslast Dateien im bereitgestellten NFS-Volume, auf die im Cluster durch andere Batchjobs oder Onlineanwendungen zugegriffen werden kann.

1. Listen Sie die von der Arbeitslast erstellten Dateien auf:

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "ls -1 /mnt/fileserver/output"
   

   Die Ausgabe sollte so aussehen:

   model_cpt_2018-04-01.pkl
   model_cpt_2018-04-02.pkl
   model_cpt_2018-04-03.pkl
   model_cpt_2018-04-04.pkl
   report.txt
   

   Prüfpunkte für das trainierte Modell (Dateinamen wie model_cpt_XXX.pkl) und ein Bericht zur Modellleistung (report.txt) wurden im Verzeichnis /mnt/fileserver/output auf dem NFS-Volume erstellt.

2. Sehen Sie sich den Modellleistungsbericht an:

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "cat /mnt/fileserver/output/report.txt"
   

   Folgendes ist ein Snippet aus der Ausgabe:

   Report generated on: 2022-02-09 14:19:42.303619
   Training dataset: 2018-04-04.pkl
   Model checkpoint: model_cpt_2018-04-04.pkl
   ---
   Accuracy on training data: 0.9981112277019937
   Accuracy on testing data: 0.9977204434773599
   

   Die Datei enthält Einträge, die die Zeit des Trainings, das verwendete Dataset, die erreichte Genauigkeit und den Dateinamen des mit dem Training assoziierten Modellprüfpunkts enthalten.

Weitere Informationen zu NFS-Volumes finden Sie in den Filestore-Leitfäden.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Einzelne Ressourcen entfernen

Führen Sie die folgenden Befehle aus, um die für diese Anleitung erstellten einzelnen Ressourcen zu entfernen.

1. Löschen Sie den Cluster:

   gcloud container clusters delete batch-aiml \
       --region=us-central1
   

2. Löschen Sie die Filestore-Instanz.

   gcloud filestore instances delete batch-aiml-filestore \
       --zone=us-central1-b
   

Projekt löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

• Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
• Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Nächste Schritte

• GKE-Dokumentation nutzen

• Mehr über nichtflüchtige Volumes erfahren

• Mehr über Jobs in GKE erfahren

• Spot-VMs zum Ausführen fehlertoleranter Arbeitslasten verwenden

• Weitere Kubernetes-Anleitungen

• Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center