Usa l'affinità del nodo in Kubernetes

L'affinità del nodo è un insieme di regole. Viene utilizzato dallo scheduler per decidere dove posizionare un pod nel cluster. Le regole vengono definite utilizzando le etichette sui nodi e i selettori di etichette specificati nella definizione dei pod. L'affinità del nodo consente a un pod di specificare un'affinità verso un gruppo di nodi su cui può essere programmato. Possiamo limitare un pod in modo che possa essere eseguito solo su un particolare nodo.

nodeSelector è la forma più semplice di vincolo di selezione del nodo. nodeSelector è una proprietà di PodSpec. Affinché il pod possa essere eseguito su un nodo, il nodo deve avere ciascuna delle etichette indicate.

L'affinità del nodo è concettualmente simile a nodeSelector - ci consente di limitare i nodi su cui il nostro pod può essere pianificato, in base alle etichette sul nodo.

Attualmente esistono due tipi di affinità di nodo, 

1. requiredDuringSchedulingIgnoredDuringExecution e 
2. preferredDuringSchedulingIgnoredDuringExecution.

Cos'è durante la pianificazione

• Qui, il pod non è ancora stato creato e verrà creato per la prima volta.
• Di solito quando viene creato il pod verranno applicate le regole di affinità.

Cos'è durante l'esecuzione

• Qui, il pod è stato in esecuzione e la modifica è stata apportata nell'ambiente che interessa nodeAffinity.

Per conoscere in dettaglio Node Affinity, visita kubernete.io la documentazione ufficiale di Kubernetes.

In questo articolo, vedremo come assegnare un pod Kubernetes a un particolare nodo utilizzando l'affinità del nodo "requiredDuringSchedulingIgnoredDuringExecution" in un cluster Kubernetes.

Prerequisiti

1. Cluster Kubernetes con almeno 1 nodo di lavoro.
   Se vuoi imparare a creare un Cluster Kubernetes, fai clic qui. Questa guida ti aiuterà a creare un cluster Kubernetes con 1 master e 2 nodi su istanze AWS Ubuntu 18.04 EC2.

Cosa faremo?

1. Configura l'affinità dei nodi

Configura l'affinità del nodo

Prima di tutto, otteniamo un elenco di nodi disponibili nel cluster.

kubectl get nodes #Get all the nodes in the cluster

Controlla se i nodi hanno Tants su di essi.

kubectl describe node node01 | grep Taints #Describe the node node01 and grep Taints

kubectl describe node master | grep Taints #Describe the node master and grep Taints

Aggiungi un'etichetta a un nodo di lavoro node01.

kubectl label node node01 app=qa #Add a label

Crea un file di definizione della distribuzione e aggiungi la seguente definizione al suo interno.

vim my-deployment-without-affinity.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-without-affinity
spec:
  replicas: 20
  selector:
    matchLabels:
      run: nginx
  template:
    metadata:
      labels:
        run: nginx
    spec:
      containers:
      - image: nginx
        imagePullPolicy: Always
        name: nginx

Ottieni un elenco di Pod e implementazioni.

kubectl get pods #Get pods in the default namespace

kubectl get deployment #Get deployments in the default namespace

Crea una distribuzione dalla definizione che abbiamo creato.

kubectl create -f my-deployment-without-affinity.yml #Create a deployment object

kubectl get deployment #Get deployments in the default namespace

kubectl get pods #Get pods in the default namespace

Ottieni i dettagli dei Pod creati dalla distribuzione.

Qui si può vedere che anche i Pod stanno ottenendo posti nel nodo principale. La ragione di ciò è che i nodi non hanno Taint su di essi, quindi i pod possono ottenere posti su qualsiasi nodo disponibile.

kubectl get pods -o wide #Get pods in the default namespace with more information about them using -o wide

Ora, crea una definizione di distribuzione con l'affinità del nodo definita.

vim my-deployment-with-affinity.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-with-afiinity
spec:
  replicas: 6
  selector:
    matchLabels:
      run: nginx
  template:
    metadata:
      labels:
        run: nginx
    spec:
      containers:
      - image: nginx
        imagePullPolicy: Always
        name: nginx
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: app
                operator: In
                values:
                - qa

Ottieni un elenco della distribuzione esistente e crea una nuova distribuzione con affinità utilizzando il file creato nel passaggio precedente.

kubectl get deployments #Get deployments in the default namespace

kubectl create -f my-deployment-with-affinity.yml #Create a deployment object

kubectl get deployments #Get deployments in the default namespace

Ora, si può vedere che i Pod questa volta sono stati posizionati solo sul nodo di lavoro node01. Il motivo è che abbiamo definito un'affinità di nodo nella definizione di distribuzione che assicura che i pod vengano distribuiti sui nodi che corrispondono alla condizione/etichetta definita.

kubectl  get pods -o wide | grep app-with-afiinity #Get pods in the default namespace with more information about them using -o wide and grep app-with-afiinity

Conclusione

In questo articolo, abbiamo imparato ad aggiungere etichette ai nodi e abbiamo visto come è possibile limitare i pod per essere programmati sui nodi richiesti utilizzando Node Affinity. Abbiamo anche visto che i pod possono anche essere distribuiti sul nodo master se non presenta alcun taint su di esso.