Hvordan sette Kubernetes -tolerasjonen
Hva er tolerasjoner og taints i Kubernetes?
Toleranse og smekk i Kubernetes brukes for å sikre at belgene er plassert i riktig node. Toleranse er definert i POD -spesifikasjonen mens smaken er definert i nodespesifikasjonen. Når du bruker toleransen på en pod, lar den planleggeren planlegge belgene på en spesifikk node. Taints fungerer imidlertid motsatt av toleransen. Det gjør at noden kan avvise belgene som kan planlegges på den. Pods har bare lov til å være planlagt på noden hvis de har tolerasjoner brukt på dem med matchende taints.
Kubernetes jobber med belter, klynger, noder, hendelser osv. I noen tilfeller, for å håndtere disse tingene, trenger Kubernetes tolerasjoner og taints. Toleranse er implementeringen av planleggingsprosessen. Pods må planlegges slik at de kan fungere ordentlig, og de kan ha nok ressurser når det trengs for å utføre sin drift. Tolerasjoner brukes på belgene mot Taint, slik at de ikke har noe avbrudd eller forstyrrelse mens de jobber.
Taints i Kubernetes gjør det mulig for en pod å avvise planleggingen av en pod. Den brukes på en node ved hjelp av “Nodespec” -nodespesifikasjonen. Planleggeren klarer ikke å sette en pod på en node som har en smakebit på den. Imidlertid, hvis du trenger å planlegge belgene på en node der en smekk allerede er brukt, må du erklære toleransen mot den.
Toleranse i Kubernetes gjør det mulig å planlegge en pod på en node der en smekk allerede er brukt. Toleransen på en pod brukes ved hjelp av “Podspec” POD -spesifikasjonen. Når du bruker toleransen på en pod med matchende taint, kan planen enkelt planlegge belgene på en spesifikk node.
La oss nå presentere et scenario for å hjelpe deg med å forstå hvordan du kan implementere toleransen på en pod i Kubernetes. Før du går videre til implementeringsdelen, må du sørge for at du har alle forutsetningskravene.
Forutsetning:
Følgende er de tingene du trenger for å implementere toleransen på en node i Kubernetes:
- Ubuntu 20.04 eller noen annen siste versjon av et hvilket som helst Linux -system
- Minikube (siste versjon)
- Installert virtuell maskin i Linux/Unix -systemet ditt
- Kubectl kommandolinjeverktøy
Forutsatt at systemet ditt oppfyller alle behovene til forutsetninger, la oss begynne å sette Kubernetes -toleransen.
Trinn 1: Start Minikube -terminalen
Det første du trenger å gjøre er å starte Minikube -terminalen, slik at du kan bruke Kubectl -kommandoene for implementering av Kubernetes -toleranse på en node. For å starte Minikube brukes følgende kommando:
> Minikube Start
Ved utførelsen av denne kommandoen får du følgende utgang i terminalen:
Trinn 2: Få listen over aktive noder
Nå som vi startet Minikube, er systemet vårt klart til å sette toleransen på belg i Kubernetes. Før vi setter toleransen på belgene, 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 Get Nodes -O = Custom -Columns = NodeName:.metadata.Navn, Taintkey:.spesifikasjon.Taints [*].Nøkkel, taintvalue:.spesifikasjon.Taints [*].Verdi, taindeffect:.spesifikasjon.Taints [*].effekt
Denne instruksjonen viser alle nodene som er besatt av Kubernetes standardinstallasjon. La oss først se utdataene fra denne kommandoen. Deretter diskuterer vi listen over noder:
Siden det ikke er noen noder som er opprettet og besatt av Kubernetes standardinstallasjon, og vi også spesifikt opprettet noen node, er resultatet . Fra forrige utgang kan vi se at det ikke er noen node. Derfor lager vi først noden og setter deretter toleransen. For å sette toleransen på en pod i Kubernetes, må vi først distribuere en app på en klynge. De neste trinnene viser hvordan du distribuerer en app på en klynge.
Trinn 3: Lag et navneområde
Først oppretter vi et navneområde for å distribuere en app på en klynge. Her oppretter vi en app med "frontend" -verdien ved hjelp av følgende kommando:
> Kubectl Lag NS Frontend
Denne kommandoen oppretter navneområdet med "frontend" -verdien. Se følgende utgang:
Trinn 4: Distribuer Nginx Pod på navneområdet
Distribuer nå Nginx Pod på navneområdet som vi nettopp opprettet. Vi bruker følgende kommando for å distribuere Nginx:
> Kubectl Run Nginx -Image = Nginx -Namespace Frontend
Dette distribuerer en app på en klynge uten tolerasjonskonfigurasjon i spesifikasjonen av APP -distribusjonen. Ved hjelp av KUBECTL -kommandoen distribuerer vi Nginx Pod på navneområdet frontend:
Trinn 5: Få listen over pods
La oss nå sjekke de opprettede belgene for å se statusene deres. Den gitte kommandoen lister ned alle belg og statuser også:
> kubectl få pods -n frontend
Siden vi bare opprettet Nginx, bør denne kommandoen liste ned den pod med statusen. Se følgende utgang:
Trinn 6: Analyser Kubernetes -hendelsene
La oss nå analysere hendelsene i Kubernetes slik at vi kan sette toleransen på belgene deretter. Vi bruker følgende Kubectl -kommando for å få listen over hendelser i Kubernetes:
> Kubectl Få hendelser -N Frontend
Dette lister ned alle hendelsene som er tilknyttet frontendverdien sammen med deres egenskaper som type, grunn, objekt og melding. Se den gitte listen i følgende utdata:
Som du ser fra forrige utgang, er Nginx POD planlagt med den spesifikke toleransen. Egenskapen "melding" viser listen over handlinger som utføres langs prosessen.
Trinn 7: Sjekk statusen til pods
Det siste trinnet er å sjekke 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 det kan sees i forrige utgang, har poden nå lov til å kjøre på den beslaglagte noden siden toleransen er satt mot den.
Konklusjon
I denne guiden utforsket vi om taints og toleranse. Vi lærte om grunnleggende arbeid med taints og toleranse. Deretter implementerte vi toleransen på en pod. Ved hjelp av et enkelt eksempel lærte vi hvordan vi kan sette toleransen på en node i Kubernetes.