Kubernetes er software med åben kildekode, der automatiserer udrulning, administration og skalering af programmer i objektbeholdere. Den orkestrerer klynger af virtuelle maskiner, planlægger objektbeholdere og tilbyder selvheling, justering af belastning og portabilitet på tværs af miljøer.
Kubernetes er software med åben kildekode, som DevOps bruger til udrulning, administration og skalering af objektbeholdere på tværs af en klynge. Docker – en anden teknologi med åben kildekode – er standardfilformatet for objektbeholdere, der ofte bruges sammen med Kubernetes.
Objektbeholdere pakker en app med dens afhængigheder og konfiguration, så den kan køre ensartet i forskellige miljøer. I takt med at et program udvikler sig, vil du måske køre mange objektbeholdere på tværs af mange servere – og det bliver kompliceret at koordinere det hele manuelt. Kubernetes løser denne kompleksitet med en API med åben kildekode og et kontrolsystem, der bestemmer, hvad der skal køre hvor, og holder det kørende.
Kubernetes organiserer klynger af virtuelle maskiner og planlægger at køre objektbeholdere baseret på tilgængelige beregningsressourcer og ressourcebehovene for hver objektbeholder.
Kubernetes administrerer tjenesteregistrering og justering af belastning, så trafikken kan dirigeres til de rette pods, selv når pods ændres over tid.
Kubernetes skalerer arbejdsbelastninger baseret på beregningsudnyttelse og den ønskede tilstand, du angiver.
Kubernetes kontrollerer ressourcens tilstand og kan genstarte eller replikere objektbeholdere, når der opstår problemer. Den genstarter eller erstatter mislykkede objektbeholdere og tilbageholder trafik, indtil arbejdsbelastningerne er klar.
Kubernetes understøtter udrulningsmønstre for kørende programmer, herunder automatiserede udrulninger og tilbagerulninger baseret på den ønskede tilstand, du beskriver.
Kubernetes tilbyder administration af hemmeligheder og konfiguration til følsomme oplysninger, f.eks. adgangskoder eller tokens.
Kubernetes kan montere de lagersystemer, du vælger (f.eks. lokale lagerløsninger eller offentlige cloudmiljøer), baseret på Kubernetes' model til orkestrering af lager.
Kubernetes er bygget op omkring API-objekter – ressourcer, du erklærer og administrerer. Her er et par stykker:
Pod: Den grundlæggende enhed, der kører en eller flere objektbeholdere.
Tjeneste: En stabil metode til at eksponere en app og dirigere trafik til skiftende pods.
Udrulning: En metode til at beskrive en ønsket apptilstand og opdatere den over tid (ofte knyttet til udrulninger og tilbagerulninger).
Node: En maskine i klyngen, hvor pods kører.
Kontrolniveau: Komponenter, der administrerer klyngetilstand og planlægningsbeslutninger.
Du erklærer den ønskede tilstand for dit program (hvad der skal køre, hvor mange kopier, ressourcebehov).
Kontrolniveauet registrerer og reagerer på denne anmodning via Kubernetes-API'en og det bagvedliggende lager.
Planlæggeren placerer pods på noder med tilstrækkelige ressourcer.
Nodekomponenter kører arbejdsbelastningen.
Controllere afstemmer løbende, så den faktiske tilstand matcher den ønskede tilstand – skalering, udskiftning og opdatering af arbejdsbelastninger efter behov.
En Kubernetes-klynge beskrives typisk i to dele: et kontrolniveau, der administrerer klyngen, og arbejdsnoder, der kører dine arbejdsbelastninger.
Disse komponenter administrerer klyngens overordnede tilstand:
kube-apiserver: viser Kubernetes HTTP-API'en (indgangen til anmodninger).
etcd: et konsistent, yderst tilgængeligt nøgleværdilager til klyngedata.
kube-scheduler: finder pods, der skal placeres, og tildeler dem til en node.
kube-controller-manager: kører controllere, der afstemmer den faktiske tilstand med den ønskede tilstand.
cloud-controller-manager (valgfrit): forbinder Kubernetes med cloududbyderspecifik kontrollogik.
Hver arbejdsnode kører software, der vedligeholder pods og netværksregler:
kubelet: sikrer, at pods kører på noden, herunder deres objektbeholdere.
kube-proxy (valgfrit): vedligeholder netværksregler for at understøtte tjenester.
objektbeholderkørsel: kører objektbeholdere på noden.
Kubernetes planlægger ikke individuelle objektbeholdere direkte i abstrakt form. Den grupperer en eller flere objektbeholdere i en pod, som bliver den grundlæggende driftsenhed. Pods skalerer derefter op eller ned mod den ønskede tilstand, du definerer.
I praksis betyder det:
Du beskriver den app, du vil køre.
Kubernetes planlægger pods på maskiner med tilgængelig beregning.
Controllere holder klyngen i bevægelse mod den tilstand, du har anmodet om.
Pods kan komme og gå, så Kubernetes indeholder primitiver – grundlæggende byggesten, du kombinerer for at beskrive og køre programmer på en klynge – der tilbyder stabile måder at nå arbejdsbelastninger på.
Hver pod får sin egen IP-adresse for hele klyngen, og pods kan kommunikere på tværs af noder uden NAT (oversættelse af netværksadresser) i Kubernetes-netværksmodellen.
Tjeneste-API'en giver en stabil IP-adresse eller et værtsnavn til et sæt back end-pods, selv når individuelle pods ændres over tid.
Kubernetes vedligeholder EndpointSlice-objekter for at spore, hvilke pods der i øjeblikket sikkerhedskopierer en tjeneste.
Kubernetes understøtter gateway-API'en (og indgående data som den foregående) for at eksponere tjenester for klienter uden for klyngen.
Nogle miljøer kan eksponere en tjeneste eksternt ved hjælp af tjenestetypen LoadBalancer.
Kubernetes-klynger omfatter ofte tilføjelsesprogrammer, der udvider funktionaliteten ud over kernekomponenterne. For eksempel:
DNS til navneoversættelse for hele klyngen.
Webbrugergrænseflade (dashboard) til klyngeadministration.
Overvågning af objektbeholderressource til indsamling af målepunkter.
Logføring på klyngeniveau til central indsamling af logge.
Kubernetes kører programmer i objektbeholdere på en klynge af maskiner og holder dem i den tilstand, du beskriver. Det gør den ved at placere arbejde på de rigtige maskiner, dirigere trafik til de rigtige steder og holde øje med fejl og ændringer.
De fleste Kubernetes-arbejdsbelastninger starter som en deklareret "ønsket tilstand" (hvad der skal køre, hvor mange kopier, og hvordan de skal eksponeres). Kubernetes er bygget op omkring deklarativ konfiguration og automatisering.
Kubernetes planlægger objektbeholdere på maskiner i klyngen baseret på tilgængelige beregningsressourcer, og hvad hver objektbeholder har brug for. Objektbeholdere kører i pods, som er den enhed, Kubernetes placerer på en maskine.
Controllers holder øje med klyngen og arbejder på at bringe den aktuelle tilstand tættere på den ønskede tilstand ved hjælp af API-serveren for at foretage ændringer.
Planlægning er "hvor skal den køres?" beslutning.
Kubernetes grupperer objektbeholdere i pods og placerer derefter disse pods på maskiner.
Kube-scheduler søger efter pods, der endnu ikke er tildelt, og vælger en node til dem.
På hver node sikrer kubelet, at pods kører (herunder deres objektbeholdere).
Objektbeholdere og pods kan oprettes, flyttes eller erstattes, så programmer har brug for stabile måder at finde hinanden på.
Kubernetes administrerer tjenesteregistrering og bruger justering af belastning, så trafikken kan dirigeres, selv når pods ændres over tid.
Tjeneste-API'en leverer en stabil IP-adresse eller et værtsnavn til en tjeneste, der understøttes af en eller flere pods, og Kubernetes sporer de sikkerhedskopierede pods via EndpointSlice-objekter.
Når pods bag en tjeneste ændres, tilpasses tjenesterouting, så trafikken fortsat når de aktuelle back-ends.
Kubernetes kan skalere arbejdsbelastninger mod den tilstand, du angiver, herunder skalering baseret på beregningsudnyttelse.
Almindelige skaleringsforslag omfatter:
Flere replikaer (flere pods) til at håndtere større efterspørgsel.
Færre replikaer, når efterspørgslen falder.
Ressourcesporing, så placeringsbeslutninger afspejler CPU- og hukommelsesbehov.
Det hænger sammen med modellen for "ønsket tilstand": Du angiver målet, og controllere fortsætter med at arbejde hen imod det.
Kubernetes omfatter selvheling, der har til formål at opretholde arbejdsbelastningens tilstand og tilgængelighed. Disse omfatter:
Genstart af mislykkede objektbeholdere (genstart på objektbeholderniveau).
Erstatning af mislykkede pods for at bevare det ønskede antal replikaer (replikaerstatning).
Omplanlægning af arbejdsbelastninger, når noder bliver utilgængelige.
Fjernelse af mislykkede pods fra tjenesteslutpunkter, så trafikken kun går til sunde pods (justering af belastning for tjenester).
Selvheling kontrollerer objektbeholdernes tilstand og genstarter eller replikerer dem, når der opstår problemer.
Nøgletal (KPI'er eller målepunkter) bruges til at forstå klyngens tilstand og funktionsmåde for arbejdsbelastninger.
Kubernetes-systemkomponenter udsender målepunkter (Prometheus-format), der er nyttige for dashboards og beskeder.
Målepunkter er typisk tilgængelige på HTTP-slutpunktet for en komponents/et målepunkt, herunder komponenter som kube-apiserver, kube-scheduler, kubelet, kube-proxy og kube-controller-manager.
Klyngens tilstandssignaler (målepunkter og fejlmønstre på komponentniveau)
Arbejdsbelastningens stabilitet (f.eks. hyppige genstarter eller udskiftninger)
Kapacitetstryk (ressourceallokering i forhold til efterspørgsel, knyttet til skaleringsbeslutninger)
Overvågning giver teams en mere komplet visning af klyngeressourcer, Kubernetes-API'en, objektbeholdere og logge, hvilket forkorter feedbackløkken mellem problemer og rettelser.
Kubernetes vælges ofte, når teams har brug for en ensartet måde at køre mange objektbeholdere på på tværs af mange maskiner, samtidig med at trafikrouting, skalering og genoprettelse håndteres af platformen.
Kubernetes kan skalere arbejdsbelastninger, altså øge eller reducere dem, efterhånden som efterspørgslen ændrer sig, mod en måltilstand og kan skalere baseret på udnyttelse af beregningsressourcer.
Webapps med variabel trafik (kampagner, sæsonmæssige spidsbelastninger): Juster replikaer, efterhånden som belastningen ændres.
Batch- eller hændelsesdrevet behandling: Tilføj kapacitet for serier, og skaler derefter tilbage.
Mikrotjenester: Skaler specifikke tjenester uden at skalere hele programmet.
Kubernetes understøtter automatisk placeringspakning, som placerer objektbeholdere på noder baseret på CPU- og hukommelsesbehov for at gøre bedre brug af tilgængelige ressourcer. Den sporer også ressourceallokering, når den administrerer arbejdsbelastninger.
Delte klynger til flere teams: Reducer spildt kapacitet ved at placere arbejdsbelastninger, hvor der er tilgængelige ressourcer.
Klynger med blandede arbejdsbelastninger (tjenester og job): Hold noder optaget uden manuel placering.
Kubernetes kan eksponere arbejdsbelastninger ved hjælp af DNS eller en IP-adresse, og den kan distribuere netværkstrafik for at holde udrulninger stabile. Den administrerer også tjenesteregistrering og inkorporerer justering af belastning i takt med, at arbejdsbelastninger ændres.
Kommunikation med mikrotjenester: Tjenester finder hinanden via stabile navne, mens pods ændres.
Interne API'er bag et stabilt slutpunkt: Omdiriger kun trafik til aktuelle backends.
Kubernetes er udviklet til at erstatte mislykkede objektbeholdere, omplanlægge arbejdsbelastninger, når noder bliver utilgængelige, og bevare den ønskede tilstand. Eksempler omfatter genstart af objektbeholdere, erstatning af replikaer og fjernelse af beskadigede pods fra tjenesteslutpunkter, så trafikken kun går til sunde pods.
Tjenester, der altid kører: Genstart eller erstat mislykkede forekomster uden manuel indgriben.
Klynger med hyppig nodeafgang: Omlæg arbejdsbelastninger, når en node går ned.
Tjenester bag en tjeneste: Stop routing af trafik til usunde pods.
Kubernetes understøtter automatiserede udrulninger og tilbagerulninger. Du beskriver den ønskede tilstand, og Kubernetes flytter den faktiske tilstand mod den i et kontrolleret tempo.
Hyppige programopdateringer: Udrul ændringer gradvist, og vend derefter tilbage, hvis det er nødvendigt.
Teams leverer flere tjenester: Hold udgivelsesteknikker konsekvente på tværs af apps.
Apps i objektbeholdere er adskilt fra infrastruktur, og Kubernetes hjælper med at flytte dem fra lokale maskiner til produktion på tværs af det lokale miljø, serveruafhængige miljøer, hybridcloudmiljøerog multicloudmiljøer, samtidig med at konsistensen bevares på tværs af miljøer.
Udviklings-/test-/produktionsparitet: Bevar den samme pakke- og planlægningsmodel på tværs af miljøer.
Hybridinstallationer: Kør dele af et system i det lokale miljø og dele i cloudmiljøet med den samme orkestreringstilgang.
Kubernetes er en fælles måde at køre arbejdsbelastninger i objektbeholdere på med deklarativ konfiguration og automatisering via maskinel indlæring, der understøttes af et stort og voksende sæt værktøjer og communitysupport.
Efterhånden som teams bygger systemer, der består af mange tjenester, kortvarige arbejdsbelastninger og hyppige opdateringer, forbliver Kubernetes et praktisk fundament, fordi det fokuserer på gentagne handlinger:
Ensartede handlinger på tværs af miljøer (objektbeholdere, der er pakket med afhængigheder, kører på samme måde på tværs af miljøer).
Et bredt, aktivt økosystem med tjenester, support og værktøjer, der er alment tilgængelige.
Udvidelse via communitybyggede tilføjelsesprogrammer, plug-ins og et overholdelsesprogram, der sørger for, at kerne-API'er er konsekvente på tværs af versioner.
Hvis du bygger eller kører arbejdsbelastninger, hjælper Azure Kubernetes Service (AKS) dig med at udrulle og administrere programmer i objektbeholdere med Azure, der administrerer kontrolniveauet.
Få Azure-mobilappen 
