Crea difetti e tolleranze in Kubernetes

Su questa pagina

1. Prerequisiti
2. Cosa faremo
3. Crea contaminazioni e tolleranze

Taint e tolleranze lavorano insieme per garantire che i pod non siano pianificati su nodi inappropriati. È possibile applicare una o più contaminazioni a un nodo, ciò significa che il nodo non deve accettare alcun pod che non tolleri le contaminazioni. I pod che hanno tolleranza possono essere distribuiti solo su quei nodi con le contaminazioni.

Ad esempio, se desideri dedicare alcuni nodi per l'uso esclusivo da parte di un particolare set di pod, puoi aggiungere una contaminazione a tali nodi e quindi aggiungere la rispettiva tolleranza ai pod. I pod con le tolleranze potranno quindi utilizzare i nodi contaminati e qualsiasi altro nodo nel cluster. Questo assicura che i pod che non hanno tolleranza non possano mai essere distribuiti sui nodi con contaminazioni.

Le contaminazioni dei nodi sono coppie chiave-valore associate a un effetto. Ecco gli effetti disponibili:

• NoSchedule: i pod che non tollerano questa contaminazione non vengono pianificati sul nodo, ma i pod esistenti non vengono rimossi dal nodo.
• PreferNoSchedule: Kubernetes evita di programmare i pod che non tollerano questa contaminazione sul nodo.
• NoExecute: il pod viene rimosso dal nodo se è già in esecuzione sul nodo e non è pianificato sul nodo se non è ancora in esecuzione sul nodo.

In questo articolo, creeremo una contaminazione su un nodo di lavoro e aggiungeremo la tolleranza ai pod. Questo ci aiuterà a capire che il pod che non ha tolleranza non verrà distribuito sul nodo lavorato con la contaminazione.

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. Crea contaminazioni e tolleranze

Crea contaminazioni e tolleranze

Innanzitutto, controlliamo i nodi disponibili nel cluster.

kubectl  get nodes #Get current pods in the cluster.

Usa il comando \descrivi\ per controllare i tag al node01

kubectl describe node node01 #Describe node01 node to extract more details.

Nello screenshot sopra, si può vedere che il nodo non ha alcun Taint.

Aggiungiamo \app=fronend:NoSchedule\ Taint al Node01

kubectl taint nodes node01 app=fronend:NoSchedule #Add taint to the node01 node.

kubectl describe node node01 #Extract details of the node01 node.

Nello screenshot qui sopra, si può vedere che il Node01 ora ha un Taint.

Crea un file e aggiungi la seguente definizione di pod.

vim my-pod.yml #Create a pod definition.

apiVersion: v1
kind: Pod
metadata:
  name: frontend
spec:
  containers:
  - image: nginx
    name: frontend-nginx

Questa definizione di pod non contiene alcuna tolleranza.

Per creare un pod che non abbia alcuna tolleranza, esegui il seguente comando.

kubectl create -f my-pod.yml #Create a pod.

kubectl get pods #Get details of the pod.

Usa il comando \descrivi\ per ottenere maggiori dettagli sul pod.

kubectl get pods #Get details of the pod.

kubectl describe pod frontend #Extract more details of the Pod.

Nello screenshot sopra, si può vedere che il pod non è stato programmato. Il motivo è che il Node01 ha un Taint ma non c'è Tolleranza nel Pod. \

Per creare un altro file con la seguente definizione di pod. Questo pod ha una tolleranza al suo interno.

vim my-mysql-pod.yml #Create a pod definition.

apiVersion: v1
kind: Pod
metadata:
  name: backend
spec:
  containers:
    - name: mysql
      image: mysql:latest
      env:
        - name: "MYSQL_USER"
          value: "mysql"
        - name: "MYSQL_PASSWORD"
          value: "mysql"
        - name: "MYSQL_DATABASE"
          value: "sample"
        - name: "MYSQL_ROOT_PASSWORD"
          value: "supersecret"
      ports:
        - containerPort: 3306
  tolerations:
  - key: app
    value: fronend
    effect: NoSchedule
    operator: Equal

Ora crea un pod utilizzando \my-mysql-pod.yml\.

kubectl get pods #Get current pods in the cluster.

kubectl create -f my-mysql-pod.yml #Create a pod.

kubectl get pods #Get current pods in the cluster.

Nello screenshot sopra, si può vedere che è stato creato un nuovo \backend\ del pod ed è in stato di esecuzione.

La ragione di ciò è che il pod ha tolleranza al suo interno che gli consente di essere distribuito sul nodo con un Taint.

Utilizza il comando \descrivi\ per visualizzare ulteriori dettagli del pod.

kubectl  describe  pod backend #Describe the pod to get more details of it.

Conclusione

In questo articolo, abbiamo prima creato un Taint sul nodo e poi provato a eseguire il deployment di un pod che non ha tolleranza. Abbiamo visto che il pod non viene schierato. Successivamente abbiamo aggiunto un pod che contiene una tolleranza. Questa tolleranza consente il deployment del pod sul nodo node01 con Taint su di esso.