Questo tutorial utilizza Kueue per mostrarti come implementare un sistema di code dei job, configurare la condivisione delle risorse dei carichi di lavoro e della quota tra diversi spazi dei nomi su Google Kubernetes Engine (GKE) e massimizzare l'utilizzo del cluster.
Contesto
Per un ingegnere dell'infrastruttura o un amministratore del cluster, massimizzare l'utilizzo tra gli spazi dei nomi è molto importante. Un batch di job in uno spazio dei nomi potrebbe non utilizzare completamente la quota assegnata allo spazio dei nomi, mentre un altro potrebbe avere più job in attesa. Per utilizzare in modo efficiente le risorse dei cluster tra i job in diversi spazi dei nomi e per aumentare la flessibilità della gestione della quota, puoi configurare le coorti in Kueue. Una coorte è un gruppo di ClusterQueue che possono prendere in prestito una quota inutilizzata l'uno dall'altro. Un ClusterQueue gestisce un pool di risorse come CPU, memoria e acceleratori hardware.
Puoi trovare una definizione più dettagliata di tutti questi concetti nella documentazione di Kuue
Obiettivi
Questo tutorial è rivolto agli ingegneri dell'infrastruttura o agli amministratori di cluster che vogliono implementare un sistema di coda dei job su Kubernetes utilizzando Kueue con condivisione della quota.Questo tutorial imita due team in due spazi dei nomi diversi, in cui ogni team ha le proprie risorse dedicate, ma può prendere in prestito l'uno dall'altro. Un terzo insieme di risorse può essere utilizzato come spillover in caso di accumulo di posti di lavoro.
Utilizza l'operatore Prometheus per monitorare l'allocazione dei job e delle risorse in spazi dei nomi diversi.
Questo tutorial illustra i seguenti passaggi:
- crea un cluster GKE
- Crea ResourceFlavors
- Per ogni team, crea ClusterQueue e LocalQueue
- (Facoltativo) Esegui il deployment di kube-prometheus e monitora i carichi di lavoro utilizzando Prometheus
- crea i job e osserva i carichi di lavoro ammessi
- Prendi in prestito la quota inutilizzata con coorti
- Aggiungi un ClusterQueue di spillover che gestisce le VM spot
Costi
Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:Utilizza il Calcolatore prezzi per generare una stima dei costi in base all'utilizzo previsto.
Al termine di questo tutorial, puoi evitare di continuare la fatturazione eliminando le risorse che hai creato. Per ulteriori informazioni, consulta Pulizia.
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 the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Attiva l'API GKE.
-
In the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Attiva l'API GKE.
Configura i valori predefiniti per Google Cloud CLI
Nella console Google Cloud, 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
Imposta le variabili di ambiente predefinite:
gcloud config set project PROJECT_ID gcloud config set compute/region COMPUTE_REGION
Sostituisci i seguenti valori:
- PROJECT_ID: il tuo ID progetto Google Cloud.
- COMPUTE_REGION: la regione di Compute Engine.
crea un cluster GKE
Crea un cluster GKE denominato
kueue-cohort
:Creerai un cluster con 6 nodi (2 per zona) nel pool predefinito e senza scalabilità automatica. Queste saranno tutte le risorse disponibili all'inizio per i team, quindi dovranno competere per loro.
Vedrai più avanti come Kueue gestisce i carichi di lavoro che entrambi i team invieranno alle rispettive code.
gcloud container clusters create kueue-cohort --region COMPUTE_REGION \ --release-channel rapid --machine-type e2-standard-4 --num-nodes 2
Una volta creato il cluster, il risultato è simile al seguente:
kubeconfig entry generated for kueue-cohort. NAME: kueue-cohort LOCATION: us-central1 MASTER_VERSION: 1.26.2-gke.1000 MASTER_IP: 35.224.108.58 MACHINE_TYPE: e2-medium NODE_VERSION: 1.26.2-gke.1000 NUM_NODES: 6 STATUS: RUNNING
Dove
STATUS
èRUNNING
perkueue-cluster
.Crea un pool di nodi denominato
spot
.Questo pool di nodi utilizza la VM spot e la scalabilità automatica è abilitata. Inizia con 0 nodi, ma in seguito la metterai a disposizione dei team per l'uso come capacità di overspill.
gcloud container node-pools create spot --cluster=kueue-cohort --region COMPUTE_REGION \ --spot --enable-autoscaling --max-nodes 20 --num-nodes 0 \ --machine-type e2-standard-4
Installa la versione di rilascio di Kueue nel cluster:
VERSION=VERSION kubectl apply -f \ https://github.com/kubernetes-sigs/kueue/releases/download/$VERSION/manifests.yaml
Sostituisci VERSION con la lettera V che segue l'ultima versione di Kueue, ad esempio
v0.4.0
. Per ulteriori informazioni sulle versioni di Kueue, consulta la pagina sulle versioni di Kueue.Attendi che il controller Kueue sia pronto:
watch kubectl -n kueue-system get pods
Per poter continuare, l'output dovrebbe essere simile al seguente:
NAME READY STATUS RESTARTS AGE kueue-controller-manager-6cfcbb5dc5-rsf8k 2/2 Running 0 3m
Crea due nuovi spazi dei nomi denominati
team-a
eteam-b
:kubectl create namespace team-a kubectl create namespace team-b
I job verranno generati in ogni spazio dei nomi.
Crea ResourceFlavors
Un oggetto ResourceFlavor rappresenta le variazioni delle risorse nei nodi dei cluster, ad esempio VM diverse (ad esempio spot o on demand), architetture (ad esempio CPU x86 e ARM), brand e modelli (ad esempio GPU Nvidia A100 e GPU T4).
ResourceFlavors utilizza le etichette dei nodi e le incompatibilità per trovare corrispondenze con un set di nodi nel cluster.
In questo file manifest:
- L'etichetta di ResourceFlavor
on-demand
è impostata sucloud.google.com/gke-provisioning: standard
. - L'etichetta di ResourceFlavor
spot
è impostata sucloud.google.com/gke-provisioning: spot
.
Quando a un carico di lavoro viene assegnato un ResourceFlavor, Kueue assegna i pod del carico di lavoro ai nodi che corrispondono alle etichette dei nodi definite per ResourceFlavor.
Esegui il deployment di ResourceFlavor:
kubectl apply -f flavors.yaml
Creazione di ClusterQueue e LocalQueue
Crea due ClusterQueue cq-team-a
e cq-team-b
e le rispettive
LocalQueues lq-team-a
e lq-team-b
corrispondenti con spazio dei nomi rispettivamente in team-a
e team-b
.
I ClusterQueues sono oggetti con ambito cluster che controllano un pool di risorse come CPU, memoria e acceleratori hardware. Gli amministratori batch possono limitare la visibilità di questi oggetti agli utenti del batch.
Le code locali sono oggetti con spazio dei nomi che gli utenti in batch possono elencare. Puntano a CluterQueues, da cui vengono allocate le risorse per l'esecuzione dei carichi di lavoro LocalQueue.
ClusterQueues consente alle risorse di avere più tipi. In questo caso, entrambe le istanze ClusterQueue hanno due versioni, on-demand
e spot
, ciascuna delle quali fornisce risorse cpu
.
La quota di ResourceFlavor spot
è impostata su 0
e non verrà utilizzata per ora.
Entrambi ClusterQueue condividono la stessa coorte denominata all-teams
, definita in .spec.cohort
.
Quando due o più ClusterQueue condividono la stessa coorte, possono prendere in prestito la quota inutilizzata l'uno dall'altro.
Per saperne di più sul funzionamento delle coorti e sulla semantica che viene preso in prestito, consulta la documentazione di Kuue
Esegui il deployment di ClusterQueues e LocalQueues:
kubectl apply -f cq-team-a.yaml
kubectl apply -f cq-team-b.yaml
(Facoltativo) Esegui il deployment di kube-prometheus e monitora i carichi di lavoro utilizzando Prometheus
Puoi utilizzare Prometheus per monitorare i carichi di lavoro in sospeso e attivi di Kueue. Per monitorare i carichi di lavoro visualizzati e osservare il carico in ogni ClusterQueue, configura Prometheus per il cluster nel monitoraggio dello spazio dei nomi.
Scarica il codice sorgente per l'operatore Prometheus per il monitoraggio:
cd git clone https://github.com/prometheus-operator/kube-prometheus.git
Crea le CustomResourceDefinitions(CRD):
kubectl create -f kube-prometheus/manifests/setup
Crea i componenti di monitoraggio:
kubectl create -f kube-prometheus/manifests
Consenti a prometheus-operator di estrarre le metriche dai componenti Kueue:
kubectl apply -f https://github.com/kubernetes-sigs/kueue/releases/download/$VERSION/prometheus.yaml
Passa alla directory di lavoro:
cd kubernetes-engine-samples/batch/kueue-cohort
Avvia un nuovo terminale per accedere a Prometheus eseguendo il port forwarding del servizio:
kubectl --namespace monitoring port-forward svc/prometheus-k8s 9090
Apri Prometheus su localhost:9090 nel browser
Se utilizzi Cloud Shell, fai clic su Anteprima web, seleziona Modifica porta, imposta il numero di porta su 9090 e seleziona
Change and Preview
.Inserisci la query per il primo riquadro che monitora il ClusterQueue attivo
cq-team-a
:kueue_pending_workloads{cluster_queue="cq-team-a", status="active"} or kueue_admitted_active_workloads{cluster_queue="cq-team-a"}
Aggiungi un altro riquadro e inserisci la query che monitora la ClusterQueue attivo
cq-team-b
:kueue_pending_workloads{cluster_queue="cq-team-b", status="active"} or kueue_admitted_active_workloads{cluster_queue="cq-team-b"}
Aggiungi un altro riquadro e inserisci la query che monitora il numero di nodi nel cluster:
count(kube_node_info)
crea i job e osserva i carichi di lavoro ammessi
Genera job in entrambi i ClusterQueue che dormono per 10 secondi, con tre job in parallelo e verranno completati con tre completamenti. Poi verrà rimossa dopo 60 secondi.
job-team-a.yaml
crea job nello spazio dei nomi team-a
e punta a
LocalQueue lq-team-a
e ClusterQueue cq-team-a
.
Allo stesso modo, job-team-b.yaml
crea job nello spazio dei nomi team-b
e punta
a LocalQueue lq-team-b
e ClusterQueue cq-team-b
.
Avvia un nuovo terminale ed esegui questo script per generare un job ogni secondo:
./create_jobs.sh job-team-a.yaml 1
Avvia un altro terminale e crea job per lo spazio dei nomi
team-b
:./create_jobs.sh job-team-b.yaml 1
Osserva i job in coda in Prometheus. Oppure con questo comando:
watch -n 2 kubectl get clusterqueues -o wide
L'output dovrebbe essere simile al seguente:
NAME COHORT STRATEGY PENDING WORKLOADS ADMITTED WORKLOADS
cq-team-a all-teams BestEffortFIFO 0 5
cq-team-b all-teams BestEffortFIFO 0 4
Prendere in prestito la quota inutilizzata con le coorti
ClusterQueues potrebbe non essere sempre al massimo della capacità. L'utilizzo delle quote non è massimizzato quando i carichi di lavoro non sono distribuiti uniformemente tra ClusterQueue. Se ClusterQueues condivide la stessa coorte tra loro, ClusterQueues può trasferire le quote da altri ClusterQueue per massimizzare l'utilizzo della quota.
Quando i job sono in coda sia per i ClusterQueues
cq-team-a
che percq-team-b
, interrompi lo script per lo spazio dei nomiteam-b
premendoCTRL+c
sul terminale corrispondente.Una volta elaborati tutti i job in attesa dello spazio dei nomi
team-b
, i job dello spazio dei nomiteam-a
possono prendere in prestito le risorse disponibili incq-team-b
:kubectl describe clusterqueue cq-team-a
Poiché
cq-team-a
ecq-team-b
condividono la stessa coorte denominataall-teams
, questi ClusterQueue sono in grado di condividere risorse non utilizzate.Flavors Usage: Name: on-demand Resources: Borrowed: 5 Name: cpu Total: 15 Borrowed: 5Gi Name: memory Total: 15Gi
Riprendi lo script per lo spazio dei nomi
team-b
../create_jobs.sh job-team-b.yaml 3
Osserva come le risorse prese in prestito da
cq-team-a
tornano a0
, mentre le risorse dacq-team-b
vengono utilizzate per i propri carichi di lavoro:kubectl describe clusterqueue cq-team-a
Flavors Usage: Name: on-demand Resources: Borrowed: 0 Name: cpu Total: 9 Borrowed: 0 Name: memory Total: 9Gi
Aumenta la quota con le VM spot
Quando la quota deve essere aumentata temporaneamente, ad esempio per soddisfare una domanda elevata nei carichi di lavoro in attesa, puoi configurare Kueue in modo da soddisfare la domanda aggiungendo altre ClusterQueue alla coorte. Le istanze ClusterQueues con risorse inutilizzate possono condividerle con altri ClusterQueues che appartengono alla stessa coorte.
All'inizio del tutorial, hai creato un pool di nodi denominato spot
utilizzando le VM spot e un ResourceFlavor denominato spot
con l'etichetta impostata su cloud.google.com/gke-provisioning: spot
. Crea un ClusterQueue per utilizzare questo pool di nodi e il ResourceFlavor che lo rappresenta:
Crea una nuova ClusterQueue denominata
cq-spot
con la coorte impostata suall-teams
:Poiché questo ClusterQueue condivide la stessa coorte con
cq-team-a
ecq-team-b
, sia ClusterQueuecq-team-a
checq-team-b
possono prendere in prestito risorse fino a 15 richieste di CPU e 15 Gi di memoria.kubectl apply -f cq-spot.yaml
In Prometheus, osserva il picco dei carichi di lavoro ammessi sia per
cq-team-a
che percq-team-b
grazie alla quota aggiunta dicq-spot
che condivide la stessa coorte. Oppure con questo comando:watch -n 2 kubectl get clusterqueues -o wide
In Prometheus, osserva il numero di nodi nel cluster. Oppure con questo comando:
watch -n 2 kubectl get nodes -o wide
Interrompi entrambi gli script premendo
CTRL+c
per lo spazio dei nomiteam-a
eteam-b
.
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.
Elimina il progetto
- Nella console Google Cloud, vai alla pagina Gestisci risorse.
- Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
- Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.
Elimina la singola risorsa
Elimina il sistema di quote Kueue:
kubectl delete -n team-a localqueue lq-team-a kubectl delete -n team-b localqueue lq-team-b kubectl delete clusterqueue cq-team-a kubectl delete clusterqueue cq-team-b kubectl delete clusterqueue cq-spot kubectl delete resourceflavor default kubectl delete resourceflavor on-demand kubectl delete resourceflavor spot
Elimina il manifest Kueue:
VERSION=VERSION kubectl delete -f \ https://github.com/kubernetes-sigs/kueue/releases/download/$VERSION/manifests.yaml
Elimina il cluster:
gcloud container clusters delete kueue-cohort --region=COMPUTE_REGION
Passaggi successivi
Scopri di più su come eseguire il deployment di un sistema batch con Kueue.
Scopri di più sui job su GKE.