Hva er tolerasjoner og flekker i Kubernetes?
Tolerasjon og smuss i Kubernetes brukes for å sikre at podene plasseres i riktig node. Tolerasjon er definert i pod-spesifikasjonen, mens flekker er definert i nodespesifikasjonen. Når du bruker tolerasjonen på en pod, lar den planleggeren planlegge podene på en bestemt node. Imidlertid virker plettene motsatt av toleransen. Det lar noden avvise podene som skal planlegges på den. Podene er kun tillatt å planlegges på noden hvis de har tolerasjoner påført dem med matchende flekker.
Kubernetes jobber med pods, klynger, noder, hendelser osv. I noen tilfeller, for å administrere disse tingene, trenger Kubernetes tolerasjoner og flekker. Tolerasjon er implementeringen av planleggingsprosessen. Podene må planlegges slik at de kan fungere ordentlig og de kan ha nok ressurser når det er nødvendig for å utføre operasjonen. Toleranser påføres belgene mot smuss slik at de ikke har noen avbrudd eller forstyrrelser under arbeid.
Skattene i Kubernetes gjør at en pod kan avvise planleggingen av en pod. Den brukes på en node ved å bruke 'NodeSpec'-nodespesifikasjonen. Planleggeren er ikke i stand til å sette en pod på en node som har en flekker. Men hvis du trenger å planlegge podene på en node der en smuss allerede er påført, må du erklære toleransen mot det.
Tolerasjon i Kubernetes gjør at en pod kan planlegges på en node der en taint allerede er påført. Tolerasjonen på en pod brukes ved å bruke 'PodSpec' Pod-spesifikasjonen. Når du bruker toleransen på en pod med matchende smak, kan tidsplanen enkelt planlegge podene på en spesifikk node.
La oss nå presentere et scenario for å hjelpe deg å forstå hvordan du kan implementere toleransen på en pod i Kubernetes. Før du fortsetter til implementeringsdelen, sørg for at du har alle forutsetningene.
Forutsetning:
Følgende er tingene du trenger for å implementere tolerasjonen på en node i Kubernetes:
- Ubuntu 20.04 eller en annen nyeste versjon av et hvilket som helst Linux-system
- Minikube (nyeste versjon)
- Installert virtuell maskin i ditt Linux/Unix-system
- Kubectl kommandolinjeverktøy
Forutsatt at systemet ditt oppfyller alle behovene til forutsetninger, la oss begynne å angi Kubernetes-toleransen.
Trinn 1: Start Minikube-terminalen
Det første du må gjøre er å starte minikube-terminalen slik at du kan bruke kubectl-kommandoene for implementering av Kubernetes-tolerasjon på en node. For å starte minikuben brukes følgende kommando:
> start minikubeVed kjøring av denne kommandoen får du følgende utgang i terminalen din:
Trinn 2: Få listen over aktive noder
Nå som vi startet minikuben, er systemet vårt klart til å stille inn toleransen på pods i Kubernetes. Før vi setter toleransen på podene, la oss sjekke hvor mange noder og hva slags noder vi allerede har. For å gjøre det bruker vi følgende påfølgende kommando:
> kubectl får noder -De =custom-columns=Nodenavn:.metadata.navn,TaintKey:.spec.taints [ * ] .key,TaintValue:.spec.taints [ * ] .value,TaintEffect:.spec.taints [ * ] .effektDenne instruksjonen viser alle nodene som er forurenset av Kubernetes standardinstallasjon. La oss først se resultatet av denne kommandoen. Deretter diskuterer vi listen over noder:
Siden det ikke er noen noder som er opprettet og tilsmusset av Kubernetes standardinstallasjon, og vi heller ikke spesifikt opprettet noen node, er resultatet
Trinn 3: Opprett et navneområde
Først oppretter vi et navneområde for å distribuere en app på en klynge. Her lager vi en app med 'frontend'-verdien ved hjelp av følgende kommando:
> kubectl opprette ns frontendDenne kommandoen oppretter navneområdet som har verdien 'frontend'. Se følgende utgang:
Trinn 4: Distribuer Nginx Pod på navneområdet
Distribuer nå nginx-poden på navneområdet som vi nettopp opprettet. Vi bruker følgende kommando for å distribuere nginx:
> kubectl kjøre nginx – bilde =nginx –navneområdegrensesnittDette distribuerer en app på en klynge uten tolerasjonskonfigurasjon i spesifikasjonen for app-implementeringen. Ved å bruke kubectl-kommandoen distribuerer vi nginx-poden på navneområdets grensesnitt:
Trinn 5: Få listen over pods
La oss nå sjekke de opprettede podene for å se statusene deres. Den gitte kommandoen viser også alle podene og statusene deres:
> kubectl få pods -n frontendSiden vi bare opprettet nginx, bør denne kommandoen liste ned den poden med dens status. Se følgende utgang:
Trinn 6: Analyser Kubernetes-hendelsene
La oss nå analysere hendelsene i Kubernetes slik at vi kan sette toleransen på podene deretter. Vi bruker følgende kubectl-kommando for å få listen over hendelser i Kubernetes:
> kubectl få hendelser -n frontendDette viser ned alle hendelsene som er knyttet til grenseverdien sammen med egenskapene deres som type, årsak, objekt og melding. Se den gitte listen i følgende utgang:
Som du kan se fra forrige utgang, er nginx-poden planlagt med den spesifikke tolerasjonen. 'Message'-egenskapen viser listen over handlinger som utføres under prosessen.
Trinn 7: Sjekk statusen til pods
Det siste trinnet er å sjekke igjen statusen til poden som vi opprettet tidligere for å sikre at den er vellykket planlagt på en spesifikk og riktig node. For å gjøre det bruker vi følgende kubectl-kommando:
> kubectl få pods -n frontend 
Som man kan se i forrige utgang, tillates poden nå å kjøre på den skjemmede noden siden tolerasjonen er satt opp mot den.
Konklusjon
I denne guiden utforsket vi om smuss og toleranse. Vi lærte om det grunnleggende arbeidet med smuss og toleranse. Deretter implementerte vi toleransen på en pod. Ved hjelp av et enkelt eksempel lærte vi hvordan man setter toleransen på en node i Kubernetes.