Kubernetes er programvare med åpen kildekode som automatiserer distribusjon, administrasjon og skalering av beholderbaserte programmer. Den iverksetter klynger av virtuelle maskiner, planlegger beholdere og gir selvreparasjon, belastningsfordeling og portabilitet på tvers av miljøer.
Kubernetes er åpen kilde-programvare som DevOps bruker til å distribuere, administrere og skalere beholdere på tvers av en klynge. Docker – en annen åpen kilde-teknologi – er standard beholderfilformatet som vanligvis brukes sammen med Kubernetes.
Beholdere pakker en app med avhengigheter og konfigurasjon, slik at den kan kjøre konsekvent i forskjellige miljøer. Etter hvert som et program utvikler seg, kan du kjøre mange beholdere på tvers av mange servere – og det blir komplisert å koordinere alt dette for hånd. Kubernetes tar for seg kompleksiteten med en åpen kilde-API og et kontrollsystem som bestemmer hva som skal kjøre hvor, og holder det i gang.
Kubernetes orkestrerer klynger av virtuelle maskiner og planlegger at beholdere skal kjøre basert på tilgjengelige databehandlingsressurser og ressursbehovene til hver beholder.
Kubernetes administrerer tjenesteoppdagelse og belastningsfordeling slik at trafikken kan rutes til de riktige poddene, selv om poddene endres over tid.
Kubernetes skalerer arbeidsbelastninger basert på databehandlingsutnyttelse og den ønskede tilstanden du angir.
Kubernetes kontrollerer ressurstilstanden og kan starte på nytt eller replikere beholdere når det oppstår problemer. Den starter på nytt eller erstatter mislykkede beholdere og holder tilbake trafikk til arbeidsbelastningene er klare.
Kubernetes støtter distribusjonsmønstre for å kjøre programmer, inkludert automatisert utrulling og tilbakerulling basert på den ønskede tilstanden du beskriver.
Kubernetes gir hemmelig administrasjon og konfigurasjonsadministrasjon for sensitiv informasjon, for eksempel passord eller tokener.
Kubernetes kan montere lagringssystemene du velger (for eksempel lokal lagring eller alternativer for offentlig sky), basert på Kubernetes' modell for iverksetting av lagring.
Kubernetes er bygget rundt API-objekter – ressurser du erklærer og administrerer. Her er noen:
Podd: Den grunnleggende enheten som kjører én eller flere beholdere.
Tjeneste: En stabil måte å eksponere en app og rute trafikk til skiftende podder på.
Distribusjon: En metode for å beskrive ønsket apptilstand og oppdatere den over tid (ofte knyttet til utrullinger og tilbakerullinger).
Node: En maskin i klyngen der podder kjører.
Kontrollplan: Komponenter som administrerer klyngetilstand og planleggingsbeslutninger.
Du erklærer den ønskede tilstanden for programmet (hva som skal kjøres, hvor mange eksemplarer, ressursbehov).
Kontrollplanet registrerer og fungerer på denne forespørselen via Kubernetes API og lager for sikkerhetskopiering.
Planleggeren plasserer podder på noder med tilstrekkelige ressurser.
Nodekomponenter kjører arbeidsbelastningen.
Kontrollere avstemmer kontinuerlig slik at faktisk tilstand samsvarer med ønsket tilstand – skalering, utskifting og oppdatering av arbeidsbelastninger etter behov.
En Kubernetes-klynge beskrives vanligvis i to deler: et kontrollplan som administrerer klyngen og arbeidsnoder som kjører arbeidsbelastningene.
Disse komponentene administrerer den generelle tilstanden til klyngen:
kube-apiserver: Eksponerer Kubernetes HTTP API (inngangsdør for forespørsler).
etcd: Et konsekvent, høyt tilgjengelig nøkkelverdilager for klyngedata.
kube-scheduler: Finner podder som trenger plassering og tilordner dem til en node.
kube-controller-manager: Kjører kontrollere som avstemmer faktisk tilstand til ønsket tilstand.
cloud-controller-manager (valgfritt): Kobler Kubernetes til skyleverandørspesifikk kontroll-logikk.
Hver arbeidernode kjører programvare som vedlikeholder podder og nettverksregler:
kubelet: Sikrer at podder kjører på noden, inkludert beholderne deres.
kube-proxy (valgfritt): Opprettholder nettverksregler for å støtte tjenester.
beholderkjøretid: Kjører beholdere på noden.
Kubernetes planlegger ikke individuelle beholdere direkte i sammendraget. Den grupperer én eller flere beholdere i en podd, som blir den grunnleggende driftsenheten. Podder skalerer deretter opp eller ned mot den ønskede tilstanden du definerer.
I praksis betyr dette:
Du beskriver appen du vil kjøre.
Kubernetes planlegger podder på maskiner med tilgjengelig databehandling.
Kontrollere holder klyngen i bevegelse mot tilstanden du ba om.
Podder kan komme og gå, så Kubernetes tilbyr primitive – grunnleggende byggeklosser du kombinerer for å beskrive og kjøre programmer på en klynge – som tilbyr stabile måter å nå arbeidsbelastninger på.
Hver podd får sin egen IP-adresse for hele klyngen, og podder kan kommunisere på tvers av noder uten NAT (network address translation) i Kubernetes-nettverksmodellen.
Tjeneste-API-en gir en stabil IP-adresse eller et vertsnavn for et sett med serverdel-podder, selv når individuelle podder endres over tid.
Kubernetes vedlikeholder sliceobjekter for endepunkt for å spore hvilke podder som for øyeblikket støtter en tjeneste.
Kubernetes støtter gateway-API-en (og inngang som foregående) for å eksponere tjenester for klienter utenfor klyngen.
Noen miljøer kan eksponere en tjeneste eksternt ved hjelp av LoadBalancer-tjenestetypen.
Kubernetes-klynger inkluderer ofte tillegg som utvider funksjonaliteten utover kjernekomponentene. Eksempler inkluderer:
DNS for navneløsing for hele klyngen.
Nettgrensesnitt (instrumentbord) for klyngebehandling.
Beholderressursovervåking for måledatainnsamling.
Logging på klyngenivå for å samle inn logger sentralt.
Kubernetes kjører beholderbaserte programmer på en klynge av maskiner og holder dem i tilstanden du beskriver. Den gjør dette ved å plassere arbeid på de rette maskinene, rute trafikk til de rette stedene og se etter feil og endringer.
De fleste Kubernetes-arbeidsbelastninger starter som en erklært «ønsket tilstand» (hva som skal kjøres, hvor mange eksemplarer og hvordan de skal eksponeres). Kubernetes er bygget rundt deklarativ konfigurasjon og automatisering.
Kubernetes planlegger beholdere på maskiner i klyngen basert på tilgjengelige databehandlingsressurser og hva hver beholder trenger. Beholdere kjører i podder, som er enheten Kubernetes plasserer på en maskin.
Kontrollere ser på klyngen og arbeider med å flytte den gjeldende tilstanden nærmere ønsket tilstand ved hjelp av API-serveren for å gjøre endringer.
Planlegging er «hvor skal dette kjøres?» beslutning.
Kubernetes grupperer beholdere i podder og plasserer deretter poddene på maskiner.
Kube-planleggeren ser etter podder som ikke er tilordnet ennå, og velger en node for dem.
På hver node sørger kubelet for at poddene kjører (inkludert beholderne deres).
Beholdere og podder kan opprettes, flyttes eller erstattes, slik at programmer trenger stabile måter å finne hverandre på.
Kubernetes administrerer tjenesteoppdagelse og bruker belastningsfordeling slik at trafikken kan rutes selv om podder endres over tid.
Tjeneste-API-en tilbyr en stabil IP-adresse eller et vertsnavn for en tjeneste som støttes av én eller flere podder, og Kubernetes sporer de sikkerhetskopierte poddene gjennom EndpointSlice-objekter.
Når podder bak en tjeneste endres, tilpasses tjenesterutingen slik at trafikken fortsetter å nå gjeldende serverdeler.
Kubernetes kan skalere arbeidsbelastninger mot tilstanden du angir, inkludert skalering basert på databehandlingsutnyttelse.
Vanlige skaleringsideer inkluderer:
Flere replikaer (flere podder) for å håndtere høyere etterspørsel.
Færre replikaer når etterspørselen faller.
Ressurssporing slik at plasseringsbeslutninger gjenspeiler CPU- og minnebehov.
Dette knytter seg til «ønsket tilstand»-modellen: du angir målet, og kontrollerne fortsetter å arbeide mot det.
Kubernetes inkluderer selvreparasjonsatferd som har som mål å opprettholde arbeidsbelastningens helse og tilgjengelighet. Disse inkluderer:
Starter mislykkede beholdere på nytt (omstarter på beholdernivå).
Erstatte mislykkede podder for å beholde det forespurte antallet replikaer (replikaerstatning).
Planlegge arbeidsbelastninger på nytt når noder blir utilgjengelige.
Fjerning av mislykkede podder fra tjenesteendepunkter, slik at trafikken bare går til sunne podder (belastningsfordeling for tjenester).
Selvreparasjon kontrollerer beholdertilstanden og starter på nytt eller replikerer dem når det oppstår problemer.
Nøkkelindikatorer (KPI-er eller måledata) brukes til å forstå klyngetilstand og arbeidsbelastningsatferd.
Kubernetes-systemkomponenter avgir måledata (Prometheus-format) som er nyttige for instrumentbord og varsler.
Måledata er vanligvis tilgjengelige på en komponents / måledata-HTTP-endepunkt, inkludert komponenter som kube-apiserver, kube-scheduler, kubelet, kube-proxy og kube-controller-manager.
Klyngetilstandssignaler (måledata på komponentnivå og feilmønstre)
Stabilitet for arbeidsbelastning (for eksempel hyppige omstarter eller erstatninger)
Kapasitetsbelastning (ressursallokering kontra etterspørsel, knyttet til skaleringsbeslutninger)
Overvåking gir teamene en mer fullstendig oversikt over klyngeressurser, Kubernetes API, beholdere og logger, noe som forkorter tilbakemeldingssløyfen mellom problemer og løsninger.
Kubernetes velges ofte når team trenger en konsekvent måte å kjøre mange beholdere på tvers av mange maskiner, samtidig som trafikkruting, skalering og gjenoppretting håndteres av plattformen.
Kubernetes kan skalere arbeidsbelastninger, noe som betyr å vokse eller redusere dem etter hvert som etterspørselen endres, mot en måltilstand og kan skaleres basert på databehandlingsutnyttelse.
Nettapper med variabel trafikk (kampanjer, sesongtopper): Juster replikaer etter hvert som belastningen endres.
Bunke- eller hendelsesdrevet behandling: Legg til kapasitet for serier, og skaler deretter tilbake.
Mikrotjenester: Skaler spesifikke tjenester uten å skalere hele programmet.
Kubernetes støtter automatisk bin-pakking, som er å plassere beholdere på noder basert på CPU- og minnebehov for å gjøre bedre bruk av tilgjengelige ressurser. Den sporer også ressursallokering når den administrerer arbeidsbelastninger.
Delte klynger for flere team: Reduser bortkastet kapasitet ved å plassere arbeidsbelastninger der ressurser er tilgjengelige.
Blandede arbeidsbelastningsklynger (tjenester pluss jobber): Hold noder opptatt uten manuell plassering.
Kubernetes kan eksponere arbeidsbelastninger ved hjelp av DNS eller en IP-adresse, og den kan distribuere nettverkstrafikk for å holde distribusjonene stabile. Den administrerer også tjenesteoppdagelse og inkluderer belastningsfordeling etter hvert som arbeidsbelastningene endres.
Mikrotjenestekommunikasjon: Tjenester finner hverandre gjennom stabile navn mens podder endres.
Interne API-er bak et stabilt endepunkt: Rute trafikk bare til gjeldende serverdel.
Kubernetes er utformet for å erstatte mislykkede beholdere, planlegge arbeidsbelastninger på nytt når noder blir utilgjengelige og opprettholde ønsket tilstand. Eksempler inkluderer omstart av beholdere, replikaerstatning og fjerning av ugyldige podder fra tjenesteendepunkter, slik at trafikken bare går til sunne podder.
Always-on-tjenester: Start på nytt eller erstatt mislykkede forekomster uten manuell innblanding.
Klynger med hyppig nodefrafall: Planlegg arbeidsbelastninger på nytt når en node går ned.
Tjenester bak en tjeneste: Stopp ruting av trafikk til usunne podder.
Kubernetes støtter automatisert utrulling og tilbakerulling. Du beskriver ønsket tilstand, og Kubernetes flytter den faktiske tilstanden mot den med en kontrollert hastighet.
Hyppige programoppdateringer: Rull endringer gradvis, og gå deretter tilbake om nødvendig.
Team sender flere tjenester: Hold utgivelsesmekanikken konsekvente på tvers av apper.
Beholderbaserte apper er atskilt fra infrastruktur, og Kubernetes bidrar til å flytte dem fra lokale maskiner til produksjon på tvers av lokale miljøer, serverløse miljøer, hybride skymiljøer og miljøer med flere skyer, samtidig som de beholder konsekvens på tvers av miljøer.
Paritet for utvikling/testing/prod: Behold samme pakke- og planleggingsmodell på tvers av miljøer.
Hybriddistribusjoner: Kjør deler av et system lokalt og deler i skyen med samme iverksettingstilnærming.
Kubernetes er en vanlig måte å kjøre beholderbaserte arbeidsbelastninger på med deklarativ konfigurasjon og maskinlæringsautomatisering, støttet av et stort og voksende sett med verktøy og fellesskapsstøtte.
Etter hvert som team bygger systemer som består av mange tjenester, kortvarige arbeidsbelastninger og hyppige oppdateringer, forblir Kubernetes et praktisk grunnlag fordi det fokuserer på repeterbare operasjoner:
Konsekvente operasjoner på tvers av miljøer (beholdere pakket med avhengigheter, kjører på samme måte på tvers av miljøer).
Et bredt, aktivt økosystem med allment tilgjengelige tjenester, støtte og verktøy.
Utvidbarhet via fellesskapsbygde tillegg, programtillegg og et samsvarsprogram som holder kjerne-API-er konsekvente på tvers av versjoner.
Hvis du bygger eller kjører arbeidsbelastninger, hjelper Azure Kubernetes Service (AKS) deg med å distribuere og administrere beholderbaserte programmer, der Azure administrerer kontrollplanet.
Skaff deg Azure-mobilappen 
