Come impostare le tolleranze Kubernetes

Cosa sono le tolleranze e i difetti in Kubernetes?

La tolleranza e la contaminazione in Kubernetes vengono utilizzate per garantire che i pod siano posizionati nel nodo corretto. La tolleranza è definita nella specifica del pod mentre le contaminazioni sono definite nella specifica del nodo. Quando applichi la tolleranza su un pod, consente allo scheduler di pianificare i pod su un nodo specifico. Tuttavia, le contaminazioni funzionano in modo opposto alla tolleranza. Consente al nodo di rifiutare i pod da programmare su di esso. I pod possono essere pianificati solo sul nodo se hanno tolleranze applicate con contaminazioni corrispondenti.

Kubernetes funziona con pod, cluster, nodi, eventi, ecc. In alcuni casi, per gestire queste cose, Kubernetes ha bisogno di tolleranze e contaminazioni. La tolleranza è l'implementazione del processo di pianificazione. I pod devono essere pianificati in modo che possano funzionare correttamente e possano disporre di risorse sufficienti quando necessario per eseguire la loro operazione. Le tolleranze vengono applicate ai pod contro la contaminazione in modo che non abbiano alcuna interruzione o interruzione durante il lavoro.

I difetti in Kubernetes consentono a un pod di rifiutare la pianificazione di un pod. Viene applicato a un nodo utilizzando la specifica del nodo 'NodeSpec'. Lo scheduler non è in grado di inserire un pod su un nodo che presenta una contaminazione. Tuttavia, se devi pianificare i pod su un nodo in cui è già applicata una contaminazione, devi dichiarare la tolleranza nei confronti di essa.

La tolleranza in Kubernetes consente di pianificare un pod su un nodo in cui è già applicata una contaminazione. La tolleranza su un pod viene applicata utilizzando la specifica del pod 'PodSpec'. Quando applichi la tolleranza su un pod con contaminazione corrispondente, lo schedular può facilmente programmare i pod su un nodo specifico.

Ora, presentiamo uno scenario per aiutarti a capire come implementare la tolleranza su un pod in Kubernetes. Prima di procedere alla sezione sull'implementazione, assicurati di disporre di tutti i prerequisiti.

Prerequisito:

Di seguito sono riportati gli elementi necessari per implementare la tolleranza su un nodo in Kubernetes:

• Ubuntu 20.04 o qualsiasi altra versione più recente di qualsiasi sistema Linux
• Minikube (ultima versione)
• Macchina virtuale installata nel tuo sistema Linux/Unix
• Strumento da riga di comando Kubectl

Supponendo che il tuo sistema soddisfi tutte le esigenze dei prerequisiti, iniziamo a impostare la tolleranza Kubernetes.

Passaggio 1: avviare il terminale Minikube

La prima cosa che devi fare è avviare il terminale minikube in modo da poter utilizzare i comandi kubectl per l'implementazione della tolleranza Kubernetes su un nodo. Per avviare il minikube, viene utilizzato il seguente comando:

Dopo l'esecuzione di questo comando, ottieni il seguente output nel tuo terminale:

Passaggio 2: ottenere l'elenco dei nodi attivi

Ora che abbiamo avviato il minikube, il nostro sistema è pronto per impostare la tolleranza sui pod in Kubernetes. Prima di impostare la tolleranza sui pod, controlliamo quanti nodi e che tipo di nodi abbiamo già. Per fare ciò, usiamo il seguente comando successivo:

Questa istruzione elenca tutti i nodi contaminati dall'installazione predefinita di Kubernetes. Vediamo prima l'output di questo comando. Quindi, discutiamo l'elenco dei nodi:

Poiché non ci sono nodi creati e contaminati dall'installazione predefinita di Kubernetes e inoltre non abbiamo creato alcun nodo in modo specifico, il risultato è . Dall'output precedente, possiamo vedere che non esiste alcun nodo. Quindi, prima creiamo il nodo e poi impostiamo la tolleranza. Per impostare la tolleranza su un pod in Kubernetes, dobbiamo prima distribuire un'applicazione su un cluster. I passaggi successivi mostrano come distribuire un'applicazione in un cluster.

Passaggio 3: creare uno spazio dei nomi

Innanzitutto, creiamo uno spazio dei nomi per distribuire un'app su un cluster. Qui, creiamo un'app con il valore 'frontend' con l'aiuto del seguente comando:

Questo comando crea lo spazio dei nomi con il valore 'frontend'. Vedere il seguente output:

Passaggio 4: distribuisci il pod Nginx nello spazio dei nomi

Ora distribuisci il pod nginx nello spazio dei nomi che abbiamo appena creato. Usiamo il seguente comando per distribuire nginx:

In questo modo viene distribuita un'app in un cluster senza configurazione di tolleranza nella specifica della distribuzione dell'app. Utilizzando il comando kubectl, distribuiamo il pod nginx sul frontend dello spazio dei nomi:

Passaggio 5: ottieni l'elenco dei pod

Ora controlliamo i pod creati per vedere i loro stati. Il comando dato elenca anche tutti i pod e i loro stati:

Poiché abbiamo creato solo nginx, questo comando dovrebbe elencare quel pod con il suo stato. Vedere il seguente output:

Passaggio 6: analizza gli eventi Kubernetes

Analizziamo ora gli eventi in Kubernetes in modo da poter impostare la tolleranza sui pod di conseguenza. Utilizziamo il seguente comando kubectl per ottenere l'elenco degli eventi in Kubernetes:

Questo elenca tutti gli eventi associati al valore front-end insieme alle loro proprietà come tipo, motivo, oggetto e messaggio. Vedere l'elenco fornito nel seguente output:

Come puoi vedere dall'output precedente, il pod nginx è pianificato con la tolleranza specifica. La proprietà 'messaggio' mostra l'elenco delle azioni eseguite durante il processo.

Passaggio 7: controlla lo stato dei pod

Il passaggio finale consiste nel ricontrollare lo stato del pod che abbiamo creato in precedenza per assicurarci che sia pianificato correttamente su un nodo specifico e corretto. Per fare ciò, usiamo il seguente comando kubectl:

Come si può vedere nell'output precedente, il pod può ora essere eseguito sul nodo contaminato poiché la tolleranza è impostata su di esso.

Conclusione

In questa guida, abbiamo esplorato le contaminazioni e la tolleranza. Abbiamo imparato a conoscere il funzionamento di base delle contaminazioni e della tolleranza. Quindi, abbiamo implementato la tolleranza su un pod. Con l'aiuto di un semplice esempio, abbiamo imparato come impostare la tolleranza su un nodo in Kubernetes.