Esegui il deployment di un carico di lavoro di machine learning in batch

Autopilot . . Standard

---

Questo tutorial mostra come utilizzare Google Kubernetes Engine (GKE) per gestire carichi di lavoro batch a tolleranza di errore, mantenendo bassi i costi. Segui questo tutorial per imparare a usare Offerte di lavoro e con ottimizzazione dei costi Pod Spot, e come configurare un cluster in-cluster Coda di job Redis su GKE.

Sfondo

Un carico di lavoro batch è un processo generalmente progettato per punto di completamento. Dovresti prendere in considerazione carichi di lavoro batch su GKE implica l'importazione, l'elaborazione e l'output dei dati utilizzando dati non elaborati. Aree come machine learning, intelligenza artificiale, e il computing ad alte prestazioni (HPC) prevedono diversi tipi di carichi di lavoro in batch, ad esempio addestramento del modello offline, previsione in batch, analisi dei dati, simulazione di sistemi fisici ed elaborazione video.

Progettando carichi di lavoro batch containerizzati, puoi sfruttare i seguenti Vantaggi di GKE:

• Uno standard aperto, una vasta community e un servizio gestito.
• Efficienza in termini di costi grazie a un’orchestrazione efficace dei carichi di lavoro e dell’infrastruttura e risorse di calcolo specializzate.
• Isolamento e portabilità della containerizzazione, che consente l'uso del cloud come di overflow mantenendo la sicurezza dei dati.
• Disponibilità di capacità di burst, seguita da uno fare lo scale down rapido di GKE cluster.

Obiettivi

Questo tutorial è rivolto ai machine learning engineer o ai data scientist che vogliono imparerai a eseguire carichi di lavoro batch di machine learning su GKE, sulla seguente architettura scalabile e conveniente:

Questo tutorial illustra i seguenti passaggi:

1. Creare un cluster GKE Autopilot. In alternativa, puoi usa un cluster GKE Standard per questo tutorial.
2. Crea un Filestore NFS volume.
3. Creare una coda di job Redis nel cluster.
4. Trasferire i set di dati nel volume NFS e accodarli per l'utilizzo da parte del carico di lavoro.
5. Esegui un carico di lavoro batch di esempio per il machine learning sul cluster GKE.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

• Compute Engine
• GKE Autopilot
• Filestore

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

---

Per seguire le indicazioni dettagliate per questa attività direttamente nella console Google Cloud, fai clic su Procedura guidata:

Procedura guidata

---

Prima di iniziare

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.

prepara l'ambiente

1. Clona il repository di esempio utilizzato in questo tutorial:

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

2. Crea un cluster GKE Autopilot:

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

   Questo passaggio può richiedere fino a 5 minuti.

Configura l'archiviazione dei set di dati con un file system di rete (NFS)

Il carico di lavoro di machine learning richiede una soluzione di archiviazione per i set di dati e file di output. In questa sezione, creerai un Filestore e fornire l'accesso all'istanza utilizzando PersistentVolume e un PersistentVolumeClaim.

Per scoprire di più, leggi l'articolo Come progettare una strategia di archiviazione ottimale e come accedere alle istanze Filestore dai cluster GKE.

Crea un'istanza di Filestore

1. Crea un'istanza Filestore:

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

   Questo comando specifica le seguenti opzioni:

   • tier: il livello di servizio per l'istanza Filestore. Questo esempio utilizza il livello base. Per saperne di più sull'altro, vedi Livelli di servizio.

   • network=name: il nome del Rete Virtual Private Cloud (VPC) per l'istanza Filestore. Il cluster GKE deve trovarsi nella stessa rete VPC dell'istanza Filestore.

   • capacity: le dimensioni desiderate del volume. Specifica il valore di archiviazione in una delle unità supportate descritte in Quantità di risorse:

   di Gemini Advanced.
   Nota: il completamento di questo passaggio può richiedere fino a 5 minuti.

2. Verifica che sia stato eseguito il deployment dell'istanza Filestore:

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

   Sostituisci PROJECT_ID con il tuo Google Cloud dell'ID progetto.

   L'output è simile al seguente:

   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. Prendi nota del valore nel campo IP_ADDRESS da utilizzare nella sezione seguente.

crea un PersistentVolume

Un cluster Kubernetes PersistentVolume consente al cluster GKE di connettersi Filestore.

1. Aggiorna il file kubernetes-manifests/persistent-volume.yaml con Filestore indirizzo IP dell'istanza:

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

   Sostituisci IP_ADDRESS con l'indirizzo IP che hai annotato. quando creando l'istanza Filestore nella sezione precedente.

2. Esegui il deployment del PersistentVolume:

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

crea un PersistentVolumeClaim

Un cluster Kubernetes PersistentVolumeClaim consente a pod e job Kubernetes di accedere alle risorse di archiviazione da questo PersistentVolume.

Esegui il deployment di PersistentVolumeClaim:

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

utilizza l'oggetto PersistentVolumeClaim

Se PersistentVolume e PersistentVolumeClaim sono configurati cluster GKE, puoi configurare il server Redis e il cluster per utilizzare l'oggetto PersistentVolumeClaim. Appare come spazio di archiviazione montabile volume.

Controlla kubernetes-manifests/redis-pod.yaml e kubernetes-manifests/workload.yaml . Le configurazioni del file manifest sono simili alle seguenti:

  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 questo manifest:

• spec.volumes specifica che l'oggetto PersistentVolumeClaim consumare.
• spec.containers.volumeMounts specifica il percorso del file locale in cui il pod può accedere alla condivisione file di Filestore.

Configura una coda di job Redis

Il carico di lavoro elabora i dati in batch per addestrare iterativamente di rilevamento delle attività fraudolente. Per gestire i set di dati attualmente in fase di elaborazione ancora in coda, eseguirai il deployment del server Redis in GKE in un cluster Kubernetes.

Per questo tutorial, avvierai un'istanza singola di Redis. Per eseguire il deployment di Redis in modo scalabile e ridondante, consulta Crea un'applicazione web multi-livello con Redis e PHP.

1. Esegui il deployment della specifica del server Redis.

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

2. Verifica che il pod sia in esecuzione:

   kubectl get pods
   

   L'output è simile al seguente:

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

   L'esecuzione del pod potrebbe richiedere fino a due minuti.

3. Trasferisci i file contenenti i set di dati di addestramento e test nel volume NFS.

   sh scripts/transfer-datasets.sh
   

   Questo script copia i file dal repository del codice campione alla directory /mnt/fileserver/datasets/ nel pod redis-leader.

4. Popola la coda Redis.

   sh scripts/queue-jobs.sh
   

   Questo script esegue il push dei percorsi di file per i set di dati di addestramento in un elenco denominato datasets nel database Redis. Questa coda verrà utilizzata dal carico di lavoro per individuare il successivo set di dati da elaborare.

5. Eseguire il deployment del servizio per rendere il server Redis rilevabile all'interno cluster GKE.

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

Esegui il carico di lavoro batch

A questo punto, hai preparato il cluster GKE, la coda dei job Redis e la condivisione file. Ora puoi eseguire il carico di lavoro in batch.

In questa sezione utilizzerai l'immagine container di un carico di lavoro di esempio addestrare un modello di rilevamento delle frodi utilizzando batch di dati sulle transazioni finanziarie. Il processo di addestramento può essere riassunto come segue:

1. Un client Redis richiede i job (percorsi di file a set di dati) nella coda Redis, e li rimuove dalla coda al termine dell'operazione.

2. Un corso per il responsabile dell'addestramento dei modelli, FraudDetectionModelTrainer, carica un nuovo batch di dati e, facoltativamente, lo stato salvato di un modello di machine learning. Il set di dati viene utilizzato per perfezionare il modello (un processo noto come "avvio caldo" addestramento).

3. Il nuovo stato del modello e un report sui dettagli e sulle prestazioni del batch vengono salvati nel volume NFS di Filestore, a cui si accede nel cluster GKE tramite un PersistentVolumeClaim.

Per scoprire di più, esplora il codice sorgente.

Definisci il job

Il seguente manifest descrive il job Kubernetes per l'immagine del carico di lavoro batch.

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

Nota: se configuri un carico di lavoro in cui i batch possono essere eseguiti in parallelo (ad es. classificazione di batch di immagini, analisi dei dati a lunga esecuzione e così via), puoi aumentare il valore parallelism per consentire a quel numero di eseguire il job contemporaneamente fino a soddisfare la condizione di completamento. La specifica nodeSelector indica a GKE di utilizzare Spot.

esegui il deployment del carico di lavoro

1. Esegui il deployment del job:

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

2. Controlla se lo stato del pod workload-XXX è Completed:

   watch kubectl get pods
   

   L'operazione potrebbe richiedere alcuni secondi. Puoi tornare alla riga di comando premendo Ctrl+C.

   L'output è simile al seguente:

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

3. Controlla i log del job workload:

   kubectl logs job/workload
   

   L'output è simile al seguente:

   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
   

   I file .pkl sono serializzazioni di set di dati contenenti un batch di crediti transazioni con carta, contrassegnate come valide o fraudolente. Esegui l'iterazione del job workload su questi file, decomprimendo i set di dati e utilizzandoli per addestrare la macchina di machine learning prima di rimuoverli dalla coda Redis. Il carico di lavoro continua a elaborare i dati in batch, fino a svuotare la coda Redis, prima di uscire.

Esplorare il volume NFS

Durante il funzionamento, il carico di lavoro crea i file nel volume NFS montato, accessibile nel cluster da altri job batch o applicazioni online.

1. Elenca i file creati dal carico di lavoro:

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

   L'output dovrebbe essere simile all'esempio seguente:

   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
   

   Checkpoint per il modello addestrato (nomi di file come model_cpt_XXX.pkl) e un report del delle prestazioni del modello (report.txt) sono state create in /mnt/fileserver/output sul volume NFS.

2. Esamina il report sulle prestazioni del modello:

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

   Di seguito è riportato uno snippet dell'output:

   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
   

   Il file contiene le voci che descrivono nel dettaglio la data/ora di addestramento, il set di dati utilizzato, l'accuratezza raggiunta e il nome file del checkpoint del modello associato all'addestramento.

Per scoprire di più sui volumi NFS, consulta le guide di Filestore.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Rimuovere singole risorse

Per rimuovere le singole risorse create per questo tutorial, esegui questo comando: tramite comandi SQL.

1. Elimina il cluster:

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

2. Elimina l'istanza Filestore:

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

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente attività in questo documento, quando lo elimini, elimini anche qualsiasi altro lavoro nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se prevedi di esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti può aiutarti a evitare di superare i limiti di quota.

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.

Passaggi successivi

• Consulta la documentazione di GKE.

• Esplora i volumi permanenti in modo più dettagliato.

• Scopri di più sui job su GKE.

• Scopri come utilizzare le VM spot per eseguire carichi di lavoro a tolleranza di errore.

• Esplora altri tutorial su Kubernetes Engine.

• Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Dai un'occhiata al nostro Centro architetture cloud.