Contesto
Un carico di lavoro batch è un processo generalmente progettato per avere un punto di inizio e di completamento. Ti conviene prendere in considerazione i carichi di lavoro in batch su GKE se la tua architettura prevede l'importazione, l'elaborazione e l'output dei dati, invece di utilizzare dati non elaborati. Aree come machine learning, intelligenza artificiale e computing ad alte prestazioni (HPC) presentano diversi tipi di carichi di lavoro in batch, come addestramento di modelli offline, previsioni in batch, analisi di dati, simulazione di sistemi fisici ed elaborazione video.
La progettazione di carichi di lavoro in batch containerizzati ti consente di sfruttare i seguenti vantaggi di GKE:
- Un servizio aperto, ampio e gestito dalla community.
- Efficienza in termini di costi grazie all'orchestrazione efficiente del carico di lavoro e dell'infrastruttura e a risorse di calcolo specializzate.
- Isolamento e portabilità della containerizzazione, che consente di utilizzare il cloud come capacità di overflow mantenendo al contempo la sicurezza dei dati.
- Disponibilità della capacità dei burst, seguita da una rapida scalabilità dei cluster GKE.
Obiettivi
Questo tutorial è rivolto agli ingegneri del machine learning o ai data scientist che vogliono imparare a eseguire carichi di lavoro di machine learning batch su GKE, sulla seguente architettura scalabile e conveniente:
Questo tutorial illustra i seguenti passaggi:
- Creare un cluster GKE con pool di nodi VM standard e Spot.
- Crea un volume Filestore NFS.
- Crea una coda di job Redis nel cluster.
- Trasferisci i set di dati al volume NFS e mettili in coda per utilizzarli al carico di lavoro.
- Esegui un carico di lavoro di machine learning in batch di esempio sul cluster GKE.
Costi
Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:
Per generare una stima dei costi in base all'utilizzo previsto,
utilizza il Calcolatore prezzi.
Prima di iniziare
Configura il progetto
- Accedi al tuo account Google Cloud. 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 gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
-
In Google Cloud Console, nella pagina del selettore dei progetti, fai clic su Crea progetto per iniziare a creare un nuovo progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.
-
Abilita le API Compute Engine, GKE, and Filestore.
-
In Google Cloud Console, nella pagina del selettore dei progetti, fai clic su Crea progetto per iniziare a creare un nuovo progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.
-
Abilita le API Compute Engine, GKE, and Filestore.
Configura l'ambiente
In questo tutorial, utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell viene fornito preinstallato con Docker e tramite l'interfaccia a riga di comando kubectl
e gcloud.
Per utilizzare Cloud Shell per configurare il tuo ambiente:
In Google Cloud Console, avvia un'istanza di Cloud Shell.
Apri Cloud ShellScarica il codice sorgente per questa app di esempio.
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples cd kubernetes-engine-samples/batch/aiml-workloads
Aggiorna il file
scripts/variables.sh
con le informazioni del progetto:sed -i "\ s/<YOUR_PROJECT_ID>/PROJECT_ID/g; \ s/<YOUR_REGION>/REGION/g; \ s/<YOUR_ZONE>/ZONE/g" \ scripts/variables.sh
Sostituisci quanto segue:
PROJECT_ID: il tuo ID progetto di Google Cloud.
REGION: l'area geografica di Compute Engine.
ZONE: la zona Compute Engine.
Imposta le variabili di ambiente e le impostazioni predefinite di
gcloud
necessarie.source scripts/variables.sh gcloud config set project ${PROJECT_ID} gcloud config set compute/region ${REGION} gcloud config set compute/zone ${ZONE} gcloud config set filestore/zone ${ZONE}
Crea un cluster GKE
Crea un cluster GKE con due pool di nodi in cui GKE ospita il volume permanente ed esegue il carico di lavoro con la coda dei job Redis.
Crea un cluster GKE standard. Questo cluster inizializza un pool di nodi con configurazioni predefinite.
gcloud container clusters create ${CLUSTER_NAME} \ --machine-type=e2-standard-2 --num-nodes=3
Verifica che il cluster GKE sia in esecuzione:
gcloud container clusters list
Il valore
STATUS
èRUNNING
per il clusterbatch-aiml
.Crea un secondo pool di nodi nel cluster GKE che verrà abilitato con le Spot VM:
gcloud beta container node-pools create batch-node-pool \ --cluster=${CLUSTER_NAME} --spot
Eseguirai il deployment del carico di lavoro in batch nel pool di nodi VM Spot in un secondo momento nel tutorial.
Configurare 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 i file di output. In questo tutorial, creerai un'istanza Filestore, accessibile da tutti i nodi (operazioni di lettura e scrittura) in un cluster GKE tramite un volume permanente (PV) e una rivendicazione del volume permanente (PVC).
Per saperne di più, scopri come progettare una strategia di archiviazione ottimale e come accedere alle condivisioni file dai cluster GKE.
Creazione di un'istanza Filestore
Crea un'istanza Filestore:
gcloud filestore instances create ${FILESTORE_ID} \ --tier=BASIC_HDD \ --file-share=name="NFSVol",capacity=1TB \ --network=name="default"
dove:
tier
è il livello di servizio per l'istanza Filestore. Questo esempio utilizza l'offerta di base, ma puoi scoprire le altre opzioni in Livelli di servizio.network=name
è il nome della rete Virtual Private Cloud (VPC) di Compute Engine a cui è collegata l'istanza. Il cluster GKE deve trovarsi nella stessa rete VPC dell'istanza Filestore.capacity
indica la dimensione del volume desiderata. Specifica il valore di archiviazione in una delle unità supportate descritte in Quantità delle risorse.
Verifica che sia stato eseguito il deployment dell'istanza Filestore:
gcloud filestore instances list --project=${PROJECT_ID} --zone=${ZONE}
L'output è simile al seguente, in cui il valore
STATE
èREADY
per l'istanzabatch-aiml-filestore
:INSTANCE_NAME: batch-aiml-filestore LOCATION: us-central1-b TIER: BASIC_HDD CAPACITY_GB: 1024 FILE_SHARE_NAME: NFSVol IP_ADDRESS: 10.152.101.10 STATE: READY CREATE_TIME: 2022-03-15T18:23:51
Dall'output, prendi nota del valore IP_ADDRESS, che verrà utilizzato nella sezione successiva.
Crea un volume permanente
Una specifica di Volume permanente (PV) di Kubernetes consente al cluster GKE di connettersi all'istanza di Filestore.
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 il valore indicato durante la creazione dell'istanza Filestore.
Esegui il deployment della specifica PV:
kubectl apply -f kubernetes-manifests/persistent-volume.yaml
Crea una richiesta di volume permanente
Una specifica di Richiesta di volume permanente (PVC) di Kubernetes consente ai pod e ai job di Kubernetes di accedere alle risorse di archiviazione di un volume permanente.
Esegui il deployment della specifica PVC:
kubectl apply -f kubernetes-manifests/persistent-volume-claim.yaml
Consuma la rivendicazione di volume permanente
Dopo aver configurato la richiesta di volumi permanenti sul cluster GKE, puoi configurare il server Redis e i job batch per consumare la PVC. Verrà visualizzato come volume di archiviazione montabile nella VM che esegue le risorse Kubernetes.
Esamina i file kubernetes-manifests/redis-pod.yaml
e kubernetes-manifests/workload.yaml
.
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
dove:
spec.volumes
specifica le richieste di volumi permanenti da consumare.spec.containers.volumeMounts
specifica il percorso del file locale sulla VM in cui è possibile accedere alla condivisione file di Filestore.
Configurare una coda di job Redis
Il carico di lavoro elabora i dati in batch per addestrare iterativo il modello di rilevamento delle frodi. 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 semplicità, avvii una singola istanza di Redis in questo esempio. Per un esempio di deployment di Redis scalabile e ridondante, scopri come creare un guestbook con Redis e PHP.
Esegui il deployment della specifica del server Redis.
kubectl apply -f kubernetes-manifests/redis-pod.yaml
Prima di procedere, verifica che il pod sia in esecuzione. Nell'output del comando seguente,
STATUS
per il podredis-leader
dovrebbe essereRunning
.kubectl get pods
L'output è simile al seguente:
NAME READY STATUS RESTARTS AGE redis-leader 1/1 Running 0 118s
Trasferisci i file contenenti i set di dati di addestramento e test al volume NFS.
sh scripts/transfer-datasets.sh
Questo script copia i file dal repository di codice di esempio nella directory
/mnt/fileserver/datasets/
del podredis-leader
.Completa la coda Redis.
sh scripts/queue-jobs.sh
Questo script esegue il push dei percorsi dei file per i set di dati di addestramento a un elenco denominato
datasets
nel database Redis. Questa coda verrà utilizzata dal carico di lavoro per individuare il set di dati successivo da elaborare.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 in batch
A questo punto, hai preparato il cluster GKE, la coda del job Redis e la condivisione file. Ora, puoi eseguire il tuo carico di lavoro in batch.
In questa sezione utilizzerai un'immagine container di un carico di lavoro di esempio per addestrare un modello di rilevamento delle attività fraudolente utilizzando gruppi di dati delle transazioni finanziarie. Il processo di formazione può essere riepilogati come:
Un client Redis rivendica i job (percorso dei file ai set di dati) nella coda Redis e li rimuove dalla coda una volta completata.
Una classe gestore di addestramento di modelli,
FraudDetectionModelTrainer
, carica un nuovo gruppo di dati e, facoltativamente, uno stato salvato di un modello di machine learning. Il set di dati viene utilizzato per perfezionare il modello (un processo noto come "warm-start" addestramento).Il nuovo stato del modello e un report dei dettagli dei batch e dei punteggi delle prestazioni vengono salvati nel volume NFS di Filestore, a cui è possibile accedere nel cluster GKE tramite una richiesta di volume permanente.
Per saperne di più, esplora il codice sorgente.
Definisci il job
Il file manifest seguente descrive la specifica del job batch per l'immagine del carico di lavoro. Questo manifest utilizza la risorsa del job Kubernetes.
Esegui il deployment del carico di lavoro
Applica la specifica per il job batch.
kubectl apply -f ./kubernetes-manifests/workload.yaml
Controlla che lo stato del pod
workload-XXX
sia completo.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
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 serie di set di dati contenenti un gruppo di transazioni con carta di credito contrassegnate come valide o fraudolente. Il jobworkload
ripete l'iterazione di questi file, decomprimendo i set di dati e utilizzandoli per l'addestramento del modello di machine learning, prima di rimuoverli dalla coda Redis. Prima di uscire con successo, il carico di lavoro continua a elaborare i dati in batch, fino all'svuotamento della coda Redis.
Esplora il volume NFS
Durante il suo funzionamento, il carico di lavoro crea file nel volume NFS montato, accessibile in tutto il cluster ad altri job batch o applicazioni online. Per esplorare i file nel volume NFS:
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 il 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
I punti di controllo per il modello addestrato (nomi di file come
model_cpt_XXX.pkl
) e un rapporto sulle prestazioni del modello (report.txt
) sono stati creati nella directory/mnt/fileserver/output
sul volume NFS.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 voci che descrivono i dettagli dell'ora per l'addestramento, il set di dati utilizzato, la precisione raggiunta e il nome file del checkpoint del modello associato all'addestramento.
Per ulteriori informazioni 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.
Per rimuovere le singole risorse create per questo tutorial:
sh scripts/cleanup.sh
Passaggi successivi
Consulta la documentazione di GKE.
Esplora i volumi permanenti in modo più dettagliato.
Scopri di più su Job su GKE.
Scopri come utilizzare le Spot VM per eseguire carichi di lavoro a tolleranza di errore.
Scopri come configurare un ambiente MLOps su Google Cloud.
Esplora altri tutorial su Kubernetes Engine.
Esplora architetture di riferimento, diagrammi, tutorial e best practice su Google Cloud. Dai un'occhiata al nostro Cloud Architecture Center.