Configurare la separazione dei carichi di lavoro in GKE

Questa pagina mostra come indicare a Google Kubernetes Engine (GKE) di pianificare i pod insieme, separatamente o in località specifiche.

La separazione dei carichi di lavoro consente di utilizzare incompatibilità e tolleranze per indicare a GKE di separare i pod in nodi diversi, nodi che soddisfano criteri specifici o per pianificare carichi di lavoro specifici insieme. Le azioni da eseguire per configurare la separazione dei carichi di lavoro dipendono dalla configurazione del cluster GKE. La tabella seguente descrive le differenze:

Configurazione della separazione dei carichi di lavoro

Aggiungi una tolleranza per una coppia chiave:valore specifica alla specifica del pod e seleziona la coppia chiave:valore utilizzando un nodeSelector. GKE crea i nodi, applica le dall'incompatibilità del nodo e pianifica il pod sul nodo.

Per le istruzioni, consulta Separare i carichi di lavoro nei cluster Autopilot in questa pagina.
Standard senza provisioning automatico dei nodi
  1. Crea un pool di nodi con un'etichetta e un'alterazione del nodo
  2. Aggiungi una tolleranza per tale incompatibilità alla specifica del pod

Per istruzioni, consulta Isola i carichi di lavoro in pool di nodi dedicati.

Questa guida utilizza uno scenario di esempio in cui hai due carichi di lavoro, un job batch e un server web, che vuoi separare l'uno dall'altro.

Quando utilizzare la separazione dei carichi di lavoro in GKE

La separazione dei carichi di lavoro è utile quando hai carichi di lavoro che svolgono ruoli diversi e non devono essere eseguiti sulle stesse macchine di base. Alcuni esempi scenari includono i seguenti:

  • Hai un carico di lavoro del coordinatore batch che crea job che vuoi mantenere separati.
  • Esegui un server di gioco con un carico di lavoro di matchmaking che vuoi separare dai pod di sessione.
  • Vuoi separare le parti dello stack tra loro, ad esempio un server da un database.
  • Vuoi separare alcuni carichi di lavoro per motivi di conformità o relativi alle norme.

Prezzi

Nei cluster Autopilot, ti vengono addebitate le risorse che i tuoi pod durante l'esecuzione. Per maggiori dettagli, consulta Prezzi di Autopilot. Per i pod che utilizzano la separazione dei carichi di lavoro vengono applicate richieste di risorse minime più elevate rispetto ai pod normali.

Nei cluster Standard, gli addebiti vengono effettuati in base alla configurazione hardware e le dimensioni di ciascun nodo, indipendentemente dal fatto che i pod siano in esecuzione sui nodi. Per maggiori dettagli, consulta la sezione Prezzi standard.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

  • Attiva l'API Google Kubernetes Engine.
    • Attiva l'API Google Kubernetes Engine
  • Se vuoi utilizzare Google Cloud CLI per questa attività, installa e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo gcloud components update.

Separare i carichi di lavoro nei cluster Autopilot

Per separare i carichi di lavoro l'uno dall'altro, aggiungi una tolleranza e un selettore di nodi per la specifica di ogni carico di lavoro, che definisce il nodo su cui deve vengono eseguiti tutti i test delle unità. Questo metodo funziona anche su cluster Standard che dispongono di provisioning automatico abilitato.

  1. Salva il seguente manifest come web-server.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-server
spec:
  replicas: 6
  selector:
    matchLabels:
      pod: nginx-pod
  template:
    metadata:
      labels:
        pod: nginx-pod
    spec:
      tolerations:
      - key: group
        operator: Equal
        value: "servers"
        effect: NoSchedule
      nodeSelector:
        group: "servers"
      containers:
      - name: web-server
        image: nginx

    Questo manifest include i seguenti campi:

    • spec.tolerations: GKE può posizionare i pod sui nodi che hanno l'alterazione group=servers:NoSchedule. GKE non può pianificare pod che non hanno questa tolleranza sui nodi.
    • spec.nodeSelector: GKE deve posizionare i pod sui nodi che hanno l'etichetta del nodo group: servers.

    GKE aggiunge le etichette e le incompatibilità corrispondenti ai nodi GKE esegue automaticamente il provisioning per l'esecuzione dei pod.

  2. Salva il seguente manifest come batch-job.yaml:

    apiVersion: batch/v1
kind: Job
metadata:
  name: batch-job
spec:
  completions: 5
  backoffLimit: 3
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        pod: pi-pod
    spec:
      restartPolicy: Never
      tolerations:
      - key: group
        operator: Equal
        value: "jobs"
        effect: NoSchedule
      nodeSelector:
        group: "jobs"
      containers:
      - name: pi
        image: perl
        command: ["perl",  "-Mbignum=bpi", "-wle", "print bpi(2000)"]

    Questo manifest include i seguenti campi:

    • spec.tolerations: GKE può posizionare i pod su nodi che presentano l'incompatibilità group=jobs:NoSchedule. GKE non può pianificare pod che non hanno questa tolleranza sui nodi.
    • spec.nodeSelector: GKE deve posizionare i pod sui nodi che hanno l'etichetta del nodo group: jobs.

    GKE aggiunge le etichette e le incompatibilità corrispondenti ai nodi GKE esegue automaticamente il provisioning per l'esecuzione dei pod.

  3. Esegui il deployment dei carichi di lavoro:

    kubectl apply -f batch-job.yaml web-server.yaml

Quando esegui il deployment dei carichi di lavoro, GKE esegue le seguenti operazioni per ogni carico di lavoro:

  1. GKE cerca i nodi esistenti con l'etichetta e il taint del nodo corrispondenti specificati nel manifest. Se i nodi esistono risorse disponibili, GKE pianifica il carico di lavoro sul nodo.
  2. Se GKE non trova un nodo esistente idoneo per pianificare il workload, crea un nuovo nodo e applica il taint e l'etichetta del nodo corrispondenti in base al manifest. GKE posiziona il pod sul nuovo nodo.

La presenza dell'effetto NoSchedule nell'incompatibilità dei nodi assicura che i carichi di lavoro senza una tolleranza non vengono posizionati sul nodo.

Verifica la separazione dei carichi di lavoro

Elenca i tuoi pod per trovare i nomi dei nodi:

kubectl get pods --output=wide

L'output è simile al seguente:

NAME                          READY   ...   NODE
batch-job-28j9h               0/1     ...   gk3-sandbox-autopilot-nap-1hzelof0-ed737889-2m59
batch-job-78rcn               0/1     ...   gk3-sandbox-autopilot-nap-1hzelof0-ed737889-2m59
batch-job-gg4x2               0/1     ...   gk3-sandbox-autopilot-nap-1hzelof0-ed737889-2m59
batch-job-qgsxh               0/1     ...   gk3-sandbox-autopilot-nap-1hzelof0-ed737889-2m59
batch-job-v4ksf               0/1     ...   gk3-sandbox-autopilot-nap-1hzelof0-ed737889-2m59
web-server-6bb8cd79b5-dw4ds   1/1     ...   gk3-sandbox-autopilot-nap-1eurxgsq-f2f3c272-n6xm
web-server-6bb8cd79b5-g5ld6   1/1     ...   gk3-sandbox-autopilot-nap-1eurxgsq-9f447e18-275z
web-server-6bb8cd79b5-jcdx5   1/1     ...   gk3-sandbox-autopilot-nap-1eurxgsq-9f447e18-275z
web-server-6bb8cd79b5-pxdzw   1/1     ...   gk3-sandbox-autopilot-nap-1eurxgsq-ccd22fd9-qtfq
web-server-6bb8cd79b5-s66rw   1/1     ...   gk3-sandbox-autopilot-nap-1eurxgsq-ccd22fd9-qtfq
web-server-6bb8cd79b5-zq8hh   1/1     ...   gk3-sandbox-autopilot-nap-1eurxgsq-f2f3c272-n6xm

Questo output mostra che i pod batch-job e i pod web-server vengono sempre eseguiti su nodi diversi.

Limitazioni della separazione dei carichi di lavoro con incompatibilità e tolleranze

Non puoi utilizzare i seguenti prefissi chiave per la separazione dei carichi di lavoro:

  • Chiavi specifiche per GKE e Kubernetes
  • *cloud.google.com/
  • *kubelet.kubernetes.io/
  • *node.kubernetes.io/

Dovresti utilizzare chiavi personalizzate e univoche per la separazione dei carichi di lavoro.

Separare i carichi di lavoro nei cluster standard senza il provisioning automatico dei nodi

La separazione dei carichi di lavoro nei cluster standard senza il provisioning automatico dei nodi richiede la creazione manuale di pool di nodi con gli attributi di contaminazione e le etichette dei nodi appropriati per soddisfare le esigenze dei carichi di lavoro. Per istruzioni, consulta Isola i carichi di lavoro in pool di nodi dedicati. Utilizza questo approccio solo se hai requisiti specifici che richiedono la gestione manuale dei pool di nodi.

Crea un cluster con incompatibilità dei nodi

Quando crei un cluster in GKE, puoi assegnare al cluster delle contaminazioni dei nodi. Questo assegna le incompatibilità a tutti i nodi creati con il cluster.

Se crei un pool di nodi, quest'ultimo non eredita le incompatibilità in un cluster Kubernetes. Se vuoi utilizzare i taint nel pool di nodi, devi utilizzare il flag --node-taints quando crei il pool di nodi.

Se crei un cluster Standard con incompatibilità dei nodi con NoSchedule o NoExecute, GKE non può pianificare alcuni componenti gestiti da GKE, come kube-dns metrics-server sul pool di nodi predefinito creato da GKE quando devi creare il cluster. GKE non può pianificare questi componenti perché non hanno le tolleranze corrispondenti per le incompatibilità dei nodi. Devi aggiungere un nuovo pool di nodi che soddisfi una delle seguenti condizioni:

  • Nessuna incompatibilità
  • Un'incompatibilità con l'effetto PreferNoSchedule
  • Incompatibilità con components.gke.io/gke-managed-components=true:NoSchedule

Ognuna di queste condizioni consente a GKE di pianificare GKE i componenti gestiti nel nuovo pool di nodi.

Per le istruzioni, consulta Isolare i carichi di lavoro su nodi dedicati.

gcloud

Crea un cluster con incompatibilità dei nodi:

gcloud container clusters create CLUSTER_NAME \
    --node-taints KEY=VALUE:EFFECT

Sostituisci quanto segue:

  • CLUSTER_NAME: il nome del nuovo cluster.
  • EFFECT: uno dei seguenti effetti: PreferNoSchedule, NoSchedule o NoExecute.
  • KEY=VALUE: una coppia chiave-valore associata al EFFECT.

Console

Crea un cluster con incompatibilità dei nodi:

  1. Vai alla pagina Google Kubernetes Engine nella console Google Cloud.

    Vai a Google Kubernetes Engine

  2. Fai clic su Crea.

  3. Configura il cluster come preferisci.

  4. Nel riquadro di navigazione, in Pool di nodi, espandi il pool di nodi che vuoi modificare, quindi fai clic su Metadati.

  5. Nella sezione Incompatibilità dei nodi, fai clic su Aggiungi incompatibilità.

  6. Nell'elenco a discesa Effetto, seleziona l'effetto desiderato.

  7. Inserisci la coppia chiave-valore che ti interessa nei campi Chiave e Valore.

  8. Fai clic su Crea.

API

Quando utilizzi l'API per creare un cluster, includi il campo nodeTaints in "nodeConfig:

POST https://container.googleapis.com/v1/projects/PROJECT_ID/zones/COMPUTE_ZONE/clusters

{
  'cluster': {
    'name': 'example-cluster',
    'nodeConfig': {
      'nodeTaints': [
        {
          'key': 'special',
          'Value': 'gpu',
          'effect': 'PreferNoSchedule'
        }
      ]
      ...
    }
    ...
  }
}

Rimuovi tutte le incompatibilità da un pool di nodi

Per rimuovere tutte le incompatibilità da un pool di nodi, esegui questo comando:

gcloud beta container node-pools update POOL_NAME \
    --node-taints="" \
    --cluster=CLUSTER_NAME

Sostituisci quanto segue:

  • POOL_NAME: il nome del pool di nodi da modificare.
  • CLUSTER_NAME: il nome del cluster del pool di nodi.

Passaggi successivi