Come impostare le tollerazioni di Kubernetes
Cosa sono tollerazioni e contatti in Kubernetes?
Tolerazione e contaminazione in Kubernetes sono usati per garantire che i pod siano posizionati nel nodo corretto. La tollerazione è definita nella specifica POD mentre i contatti sono definiti nella specifica del nodo. Quando si applica la tolleranza su un pod, consente allo scheduler di pianificare i pod su un nodo specifico. Tuttavia, i contatti funzionano di fronte alla tolleranza. Consente al nodo di rifiutare i pod di essere programmati su di esso. I pod possono essere programmati sul nodo solo se hanno tollerazioni applicate a loro con i contatti corrispondenti.
Kubernetes lavora con baccelli, cluster, nodi, eventi, ecc. In alcuni casi, per gestire queste cose, Kubernetes ha bisogno di tollerazioni e contatti. La tolleranza è l'implementazione del processo di pianificazione. I pod devono essere programmati in modo che possano funzionare correttamente e possono avere risorse sufficienti quando necessario per eseguire il loro funzionamento. Le tollerazioni vengono applicate ai baccelli contro la contaminazione in modo che non abbiano interruzione o interruzione durante il lavoro.
I contatti in Kubernetes consentono a un pod di rifiutare la pianificazione di un pod. Viene applicato a un nodo usando la specifica del nodo "NODESPEC". Lo scheduler non è in grado di mettere un pod su un nodo che ha una contaminazione su di esso. Tuttavia, se è necessario programmare i baccelli su un nodo in cui è già applicata una contaminazione, è necessario dichiarare la tolleranza contro di essa.
La tolleranza in Kubernetes consente di programmare un pod su un nodo in cui è già applicato una contaminazione. La tolleranza su un pod viene applicata utilizzando la specifica del pod "podspec". Quando si applica la tolleranza su un pod con contaminazione corrispondente, il programma può facilmente programmare i pod su un nodo specifico.
Ora, presentiamo uno scenario per aiutarti a capire come è possibile implementare la tolleranza su un pod in Kubernetes. Prima di procedere alla sezione di implementazione, assicurati di avere tutti i requisiti prerequisiti.
Prerequisito:
Le seguenti sono le cose di cui è necessario implementare la tolleranza su un nodo in Kubernetes:
- Ubuntu 20.04 o qualsiasi altra ultima versione di qualsiasi sistema Linux
- Minikube (ultima versione)
- Macchina virtuale installata nel sistema Linux/Unix
- Strumento di riga di comando kubectl
Supponendo che il tuo sistema soddisfi tutte le esigenze dei prerequisiti, iniziamo a impostare la tolleranza di Kubernetes.
Passaggio 1: avvia 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 di Kubernetes su un nodo. Per avviare il minikube, viene utilizzato il seguente comando:
> Minikube Start
All'esecuzione di questo comando, si ottiene il seguente output nel tuo terminale:
Passaggio 2: ottieni l'elenco dei nodi attivi
Ora che abbiamo iniziato il minikube, il nostro sistema è pronto a 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ò, utilizziamo il seguente comando successivo:
> kubectl GET nodi -o = colonne personalizzate = nodename:.metadati.nome, taintkey:.spec.TAINTS [*].Chiave, TaintValue:.spec.TAINTS [*].Valore, Tainteffect:.spec.TAINTS [*].effetto
Questa istruzione elenca tutti i nodi contaminati dall'installazione predefinita di Kubernetes. Vediamo prima l'output di questo comando. Quindi, discutiamo dell'elenco dei nodi:
Poiché non ci sono nodi che vengono creati e contaminati dall'installazione predefinita di Kubernetes e non abbiamo anche creato specificamente alcun nodo, il risultato è . Dall'output precedente, possiamo vedere che non c'è nodo. Quindi, prima creiamo il nodo e quindi impostiamo la tolleranza. Per impostare la tolleranza su un pod in Kubernetes, dobbiamo prima distribuire un'app su un cluster. I prossimi passaggi dimostrano come distribuire un'app su un cluster.
Passaggio 3: crea 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:
> kubectl crea il frontend ns
Questo comando crea lo spazio dei nomi con il valore "frontend". Vedi il seguente output:
Passaggio 4: distribuire il pod Nginx sullo spazio dei nomi
Ora, distribuire il pod Nginx sullo spazio dei nomi che abbiamo appena creato. Utilizziamo il seguente comando per distribuire NGINX:
> kubectl run nginx -image = nginx -namespace frontend
Ciò distribuisce un'app su un cluster senza configurazione di tolleranza nella specifica della distribuzione dell'app. Usando il comando KubeCtl, distribuiamo il pod Nginx sul frontend dello spazio dei nomi:
Passaggio 5: ottieni l'elenco dei baccelli
Ora, controlliamo i baccelli creati per vedere i loro stati. Il comando indicato elenca tutti i pod e i loro stati:
> kubectl ottieni baccelli -n frontend
Dato che abbiamo creato solo Nginx, questo comando dovrebbe elencare quel pod con il suo stato. Vedi il seguente output:
Passaggio 6: analizzare gli eventi Kubernetes
Ora, analizziamo gli eventi in Kubernetes in modo da poter impostare la tolleranza sui pod di conseguenza. Usiamo il seguente comando Kubectl per ottenere l'elenco degli eventi in Kubernetes:
> kubectl ottieni eventi -n frontend
Questo elenca tutti gli eventi associati al valore front-end insieme alle loro proprietà come tipo, ragione, oggetto e messaggio. Vedi l'elenco indicato nel seguente output:
Come puoi vedere dall'output precedente, il pod Nginx è programmato con la tolleranza specifica. La proprietà "Messaggio" mostra l'elenco delle azioni eseguite lungo il processo.
Passaggio 7: controllare lo stato dei pod
Il passaggio finale è verificare di nuovo lo stato del pod che abbiamo creato in precedenza per garantire che sia programmato correttamente su un nodo specifico e corretto. Per fare ciò, utilizziamo il seguente comando kubectl:
> kubectl ottieni baccelli -n frontend
Come si può vedere nell'output precedente, il pod è ora autorizzato a funzionare sul nodo contaminato poiché la tolleranza è impostata contro di esso.
Conclusione
In questa guida, abbiamo esplorato i contatti e la tolleranza. Abbiamo imparato a conoscere il funzionamento di base dei contatti e della tolleranza. Quindi, abbiamo implementato la tolleranza su un pod. Con l'aiuto di un semplice esempio, abbiamo imparato a impostare la tolleranza su un nodo in Kubernetes.