Sådan indstilles Kubernetes-tolerationerne

Hvad er tolerationer og pletter i Kubernetes?

Toleration og taint i Kubernetes bruges til at sikre, at pods er placeret i den korrekte node. Toleration er defineret i pod-specifikationen, mens pletterne er defineret i nodespecifikationen. Når du anvender tolerationen på en pod, giver det planlæggeren mulighed for at planlægge pods på en specifik node. Imidlertid virker pletterne modsat toleransen. Det gør det muligt for noden at afvise de pods, der skal planlægges på den. Bælgene må kun planlægges på noden, hvis de har tolerancer påført dem med matchende pletter.

Kubernetes arbejder med pods, klynger, noder, begivenheder osv. I nogle tilfælde har Kubernetes brug for tolerancer og pletter for at håndtere disse ting. Toleration er implementeringen af ​​planlægningsprocessen. Poderne skal planlægges, så de kan fungere korrekt, og de kan have tilstrækkelige ressourcer, når det er nødvendigt, til at udføre deres operation. Der påføres tolerancer på bælgerne mod snavs, så de ikke har nogen afbrydelser eller forstyrrelser under arbejdet.

Skaderne i Kubernetes gør det muligt for en pod at afvise planlægningen af ​​en pod. Den anvendes på en node ved hjælp af 'NodeSpec' Node-specifikationen. Planlæggeren er ikke i stand til at sætte en pod på en node, der har en skamplet. Men hvis du har brug for at planlægge pods på en node, hvor en taint allerede er påført, skal du erklære tolerancen imod det.

Toleration i Kubernetes gør det muligt at planlægge en pod på en node, hvor en taint allerede er påført. Tolerationen på en pod anvendes ved hjælp af 'PodSpec' Pod-specifikationen. Når du anvender tolerancen på en pod med matchende farve, kan skemaet nemt planlægge pods på en specifik node.

Lad os nu præsentere et scenario for at hjælpe dig med at forstå, hvordan du kan implementere tolerancen på en pod i Kubernetes. Før du fortsætter til implementeringssektionen, skal du sikre dig, at du har alle forudsætningskravene.

Forudsætning:

Følgende er de ting, du skal bruge for at implementere tolerancen på en node i Kubernetes:

• Ubuntu 20.04 eller enhver anden nyeste version af ethvert Linux-system
• Minikube (seneste version)
• Installeret virtuel maskine i dit Linux/Unix-system
• Kubectl kommandolinjeværktøj

Hvis vi antager, at dit system opfylder alle forudsætningernes behov, så lad os begynde at indstille Kubernetes-tolerancen.

Trin 1: Start Minikube Terminal

Den første ting, du skal gøre, er at starte minikube-terminalen, så du kan bruge kubectl-kommandoerne til implementering af Kubernetes-toleration på en node. For at starte minikuben bruges følgende kommando:

Ved udførelse af denne kommando får du følgende output i din terminal:

Trin 2: Få listen over aktive noder

Nu hvor vi startede minikuben, er vores system klar til at indstille tolerancen på pods i Kubernetes. Før vi indstiller tolerancen på bælgerne, lad os tjekke, hvor mange noder og hvilken slags noder vi allerede har. For at gøre det bruger vi følgende efterfølgende kommando:

Denne instruktion viser alle de noder, som er plettet af Kubernetes standardinstallation. Lad os først se outputtet af denne kommando. Derefter diskuterer vi listen over noder:

Da der ikke er nogen noder, der er oprettet og plettet af Kubernetes standardinstallation, og vi heller ikke specifikt oprettede nogen node, er resultatet . Fra det tidligere output kan vi se, at der ikke er nogen node. Derfor opretter vi først noden og indstiller derefter tolerancen. For at indstille tolerancen på en pod i Kubernetes skal vi først implementere en app på en klynge. De næste par trin viser, hvordan man implementerer en app på en klynge.

Trin 3: Opret et navneområde

Først opretter vi et navneområde til at implementere en app på en klynge. Her opretter vi en app med 'frontend'-værdien ved hjælp af følgende kommando:

Denne kommando opretter navneområdet med 'frontend'-værdien. Se følgende output:

Trin 4: Implementer Nginx Pod'en på navneområdet

Nu skal du implementere nginx-poden på det navneområde, som vi lige har oprettet. Vi bruger følgende kommando til at implementere nginx:

Dette implementerer en app på en klynge uden tolerationskonfiguration i specifikationen for appimplementeringen. Ved at bruge kommandoen kubectl implementerer vi nginx-pod'en på navneområdets frontend:

Trin 5: Hent listen over pods

Lad os nu tjekke de oprettede pods for at se deres status. Den givne kommando viser også alle pods og deres status:

Da vi kun oprettede nginx, skulle denne kommando liste den pod med dens status. Se følgende output:

Trin 6: Analyser Kubernetes-begivenhederne

Lad os nu analysere begivenhederne i Kubernetes, så vi kan indstille tolerancen på bælgerne i overensstemmelse hermed. Vi bruger følgende kubectl-kommando til at få listen over begivenheder i Kubernetes:

Dette viser alle de hændelser, der er forbundet med frontend-værdien, sammen med deres egenskaber som type, årsag, objekt og besked. Se den givne liste i følgende output:

Som du kan se fra det forrige output, er nginx-poden planlagt med den specifikke tolerance. Egenskaben 'meddelelse' viser listen over handlinger, der udføres under processen.

Trin 7: Tjek status for pods

Det sidste trin er igen at kontrollere status for den pod, som vi oprettede tidligere, for at sikre, at den er planlagt på en specifik og korrekt node. For at gøre det bruger vi følgende kubectl-kommando:

Som det kan ses i det forrige output, får poden nu lov til at køre på den plettede node, da tolerationen er sat i forhold til den.

Konklusion

I denne guide udforskede vi pletter og tolerance. Vi lærte om den grundlæggende funktion af pletter og tolerance. Derefter implementerede vi tolerancen på en pod. Ved hjælp af et simpelt eksempel lærte vi, hvordan man indstiller tolerancen på en node i Kubernetes.