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 i carichi di lavoro batch a tolleranza di errore mantenendo bassi i costi. Segui questo tutorial per scoprire come utilizzare i job e i pod spot ottimizzati per i costi , nonché come configurare una coda di job Redis nel cluster su GKE.

Sfondo

Un carico di lavoro batch è un processo in genere progettato per avere un punto di inizio e un punto di completamento. Dovresti prendere in considerazione i carichi di lavoro batch su GKE se la tua architettura prevede l'importazione, l'elaborazione e l'output dei dati anziché l'utilizzo di dati non elaborati. Aree come il machine learning, l'intelligenza artificiale e il computing ad alte prestazioni (HPC) presentano diversi tipi di carichi di lavoro batch, come l'addestramento di modelli offline, la previsione in batch, l'analisi dei dati, la simulazione di sistemi fisici e l'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 dei costi grazie all'orchestrazione efficace dei carichi di lavoro e dell'infrastruttura e alle risorse di calcolo specializzate.
• Isolamento e portabilità della containerizzazione, che consente di utilizzare il cloud come capacità di overflow mantenendo la sicurezza dei dati.
• Disponibilità della capacità di burst, seguita da una rapida fare lo scale down dei cluster GKE.

Obiettivi

Questo tutorial è rivolto ai machine learning engineer o ai data scientist che vogliono imparare a eseguire carichi di lavoro batch di machine learning su GKE, con la seguente architettura scalabile ed economica:

Questo tutorial illustra i seguenti passaggi:

1. Crea un cluster GKE Autopilot. In alternativa, puoi utilizzare un cluster GKE standard per questo tutorial.
2. Crea un volume NFS Filestore.
3. Crea una coda di job Redis nel cluster.
4. Trasferisci i set di dati nel volume NFS e accodali per l'utilizzo da parte del carico di lavoro.
5. Esegui un carico di lavoro batch di machine learning di esempio nel 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 in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi Google Cloud utenti potrebbero avere diritto a una prova senza costi.

---

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

Procedura guidata

---

Prima di iniziare

Accedi al tuo Google Cloud account. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Verify that billing is enabled for your Google Cloud project.

Enable the Compute Engine, GKE, and Filestore APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Verify that billing is enabled for your Google Cloud project.

Enable the Compute Engine, GKE, and Filestore APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

1. Nella Google Cloud console, attiva Cloud Shell.

   Attiva Cloud Shell

   Nella parte inferiore della Google Cloud console, viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già incluso e installato e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.

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 \
       --location=us-central1
   

   Il completamento di questo passaggio può richiedere fino a 5 minuti.

Configura l'archiviazione dei set di dati con un Network File System (NFS)

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

Per saperne di più, scopri 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 di 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 di base. Per scoprire le altre opzioni, consulta Livelli di servizio.

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

   • capacity: la dimensione desiderata del volume. Specifica il valore di archiviazione in una delle unità supportate descritte in Quantità di risorse.

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

2. Verifica che l'istanza Filestore sia stata eseguita il deployment:

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

   Sostituisci PROJECT_ID con il tuo Google Cloud 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 oggetto PersistentVolume

Una specifica PersistentVolume di Kubernetes consente al cluster GKE di connettersi all' istanza Filestore.

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

   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 crei l'istanza Filestore nella sezione precedente.

2. Esegui il deployment dell'oggetto PersistentVolume:

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

Crea un oggetto PersistentVolumeClaim

Una richiesta di volume permanente di Kubernetes PersistentVolumeClaim PersistentVolume.

Esegui il deployment dell'oggetto PersistentVolumeClaim:

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

Utilizza l'oggetto PersistentVolumeClaim

Dopo aver configurato l'oggetto PersistentVolume e l'oggetto PersistentVolumeClaim nel cluster GKE, puoi configurare il server Redis e i job batch in modo che utilizzino l'oggetto PersistentVolumeClaim. Viene visualizzato come un volume di archiviazione montabile.

Esamina i kubernetes-manifests/redis-pod.yaml e i kubernetes-manifests/workload.yaml file. Le configurazioni dei 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 l'oggetto PersistentVolumeClaim da utilizzare.
• spec.containers.volumeMounts specifica il percorso del file locale in cui il pod può accedere alla condivisione file Filestore.

Configura una coda di job Redis

Il carico di lavoro elabora i dati in batch per addestrare in modo iterativo un modello di rilevamento di attività fraudolente. Per gestire i set di dati attualmente in fase di elaborazione o ancora in coda, esegui il deployment del server Redis nel cluster GKE.

Per questo tutorial, avvierai una singola istanza di Redis. Per eseguire il deployment di Redis in modo scalabile e ridondante, consulta Creare un'applicazione web multilivello 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'avvio 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. Esegui il deployment del servizio per rendere il server Redis rilevabile all'interno del 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 di job Redis e la condivisione file. Ora puoi eseguire il carico di lavoro batch.

In questa sezione, utilizzerai un'immagine container di un carico di lavoro di esempio per addestrare un modello di rilevamento di attività fraudolente utilizzando batch di dati di transazioni finanziarie. Il processo di addestramento può essere sintetizzato in questo modo:

1. Un client Redis richiede i job (percorsi di file ai set di dati) nella coda Redis e al termine li rimuove dalla coda.

2. La classe di gestione dell'addestramento di 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 "addestramento ad avvio lento").

3. Il nuovo stato del modello e un report con i dettagli e i punteggi delle prestazioni del batch vengono salvati nel volume NFS Filestore, a cui è possibile accedere nel cluster GKE utilizzando un oggetto PersistentVolumeClaim.

Per saperne di più, esplora il codice sorgente.

Definisci il job

Il seguente manifest descrive il job Kubernetes per l'immagine del carico di lavoro batch. Un controller Job in Kubernetes crea uno o più pod e contribuisce a garantire che eseguano correttamente un'attività specifica.

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 di parallelism per consentire l'esecuzione simultanea del job da parte di un numero di pod pari al valore specificato fino a quando non viene soddisfatta la condizione di completamento. La specifica nodeSelector indica a GKE di utilizzare i pod spot.

Esegui il deployment del carico di lavoro

1. Esegui il deployment del job:

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

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

   watch kubectl get pods
   

   Questa 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 transazioni con carta di credito, contrassegnate come valide o fraudolente. Il job workload esegue l'iterazione di questi file, decomponendo i set di dati e utilizzandoli per addestrare il modello di machine learning prima di rimuoverli dalla coda Redis. Il carico di lavoro continua a elaborare i dati in batch, fino a quando la coda Redis non viene svuotata, prima di uscire con esito positivo.

Esplora il volume NFS

Durante il funzionamento, il carico di lavoro crea file nel volume NFS montato, accessibili in tutto il 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
   

   Nella directory /mnt/fileserver/output sul volume NFS sono stati creati i checkpoint per il modello addestrato (nomi di file come model_cpt_XXX.pkl) e un report sulle prestazioni del modello (report.txt).

2. Esamina il report sul rendimento 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 saperne di più sui volumi NFS, consulta le guide di Filestore.

Libera spazio

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.

Rimuovi le singole risorse

Per rimuovere le singole risorse create per questo tutorial, esegui i seguenti comandi.

1. Elimina il cluster:

   gcloud container clusters delete batch-aiml \
       --location=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 per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto 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 URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

1. Nella Google Cloud console, vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID progetto e fai clic su Chiudi per eliminare il progetto.

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 architetture, diagrammi e best practice di riferimento su Google Cloud. Consulta il nostro Cloud Architecture Center.