Kubernetes är programvara med öppen källkod som automatiserar distribution, hantering och skalning av containerbaserade program. Den orkestrerar kluster med virtuella datorer, schemalägger containrar och tillhandahåller självåterställning, belastningsutjämning och portabilitet mellan miljöer.
Kubernetes är programvara med öppen källkod DevOps använder för att distribuera, hantera och skala containrar i ett kluster. Docker—en annan teknik med öppen källkod—är standardformatet för containerfiler som ofta används tillsammans med Kubernetes.
Containers paketera en app med dess beroenden och konfiguration så att den kan köras konsekvent i olika miljöer. När en app utvecklas kan du köra många containrar på många servrar, och att samordna allt det för hand blir komplicerat. Kubernetes hanterar den här komplexiteten med ett API med öppen källkod och ett kontrollsystem som avgör vad som ska köras var, och ser till att det fortsätter att köras.
Kubernetes orkestrerar kluster med virtuella datorer och schemalägger containrar så att de körs baserat på tillgängliga beräkningsresurser och resursbehoven för varje container.
Kubernetes hanterar tjänstidentifiering och lastbalansering så att trafik kan dirigeras till rätt poddar, även när poddar ändras över tid.
Kubernetes skalar arbetsbelastningar baserat på beräkningsanvändning och önskat tillstånd som du anger.
Kubernetes kontrollerar resurshälsan och kan starta om eller replikera containrar när det uppstår problem. Den startar om eller ersätter misslyckade containrar och undanhåller trafik tills arbetsbelastningarna är klara.
Kubernetes stöder distributionsmönster för program som körs, inklusive automatiserade distributioner och återställningar baserat på önskat tillstånd som du beskriver.
Kubernetes tillhandahåller hemlighets- och konfigurationshantering för känslig information som lösenord eller token.
Kubernetes kan montera de lagringssystem du väljer (till exempel lokal lagring eller alternativ i offentliga moln), baserat på Kubernetess lagringsorkestreringsmodell.
Kubernetes är uppbyggt kring API-objekt – resurser som du deklarerar och hanterar. Här är några:
Pod: Den grundläggande enhet som kör en eller flera containrar.
Service: Ett stabilt sätt att exponera en app och dirigera trafik till föränderliga poddar.
Distribution: Ett sätt att beskriva ett önskat apptillstånd och uppdatera det över tid (ofta kopplat till distributioner och återställningar).
Nod: En dator i klustret där poddar körs.
Kontrollplan: Komponenter som hanterar klustertillstånd och schemaläggningsbeslut.
Du deklarerar önskat tillstånd för ditt program (vad som ska köras, hur många kopior, resursbehov).
Kontrollplanet registrerar och agerar på begäran via Kubernetes-API:et och lagringsplatsen för säkerhetskopiering.
Schemaläggaren placerar poddar på noder med tillräckliga resurser.
Nodkomponenter kör arbetsbelastningen.
Kontrollanter synkroniserar kontinuerligt så att det faktiska tillståndet matchar det önskade tillståndet – de skalar, ersätter och uppdaterar arbetslaster vid behov.
Ett Kubernetes-kluster beskrivs vanligtvis i två delar: ett kontrollplan som hanterar klustret och arbetsnoder som kör dina arbetsbelastningar.
Dessa komponenter hanterar klustrets övergripande tillstånd:
kube-apiserver: Exponerar Kubernetes HTTP API (front door för begäranden).
etcd: Ett konsekvent nyckelvärdeslager med hög tillgänglighet för klusterdata.
kube-scheduler: Hittar poddar som behöver placering och tilldelar dem till en nod.
kube-controller-manager: Kör kontrollanter som stämmer av det faktiska tillståndet till önskat tillstånd.
cloud-controller-manager (valfritt): Ansluter Kubernetes till molnleverantörsspecifik kontrolllogik.
Varje arbetsnod kör programvara som underhåller poddar och nätverksregler:
kubelet: Säkerställer att poddar körs på noden, inklusive deras containrar.
kube-proxy (valfritt): Underhåller nätverksregler för att stödja tjänster.
containerkörning: Kör containrar på noden.
Kubernetes schemalägger inte enskilda containrar direkt i det abstrakta. Den grupperar en eller flera containrar i en podd, som blir den grundläggande driftenheten. Poddar skalar sedan upp eller ned mot önskat tillstånd som du definierar.
I praktiken innebär detta:
Du beskriver appen som du vill köra.
Kubernetes schemalägger poddar till datorer med tillgänglig beräkning.
Kontrollanter håller klustret i rörelse mot det tillstånd som du bad om.
Poddar kan komma och gå, så Kubernetes tillhandahåller primitiver – grundläggande byggblock som du kombinerar för att beskriva och köra appar i ett kluster – som erbjuder stabila sätt att nå arbetslaster.
Varje podd får sin egen klusteromfattande IP-adress och poddar kan kommunicera mellan noder utan NAT (Network Address Translation) i Kubernetes-nätverksmodellen.
Tjänst-API:et tillhandahåller en stabil IP-adress eller ett värdnamn för en uppsättning serverdelspoddar, även när enskilda poddar ändras över tid.
Kubernetes underhåller slutpunktssektorobjekt för att spåra vilka poddar som för närvarande stöder en tjänst.
För att exponera tjänster för klienter utanför klustret stöder Kubernetes gateway-API:et (och ingress som dess föregående).
Vissa miljöer kan exponera en tjänst externt med hjälp av loadbalancer-tjänsttypen.
Kubernetes-kluster innehåller ofta tillägg som utökar funktioner utöver kärnkomponenterna. Till exempel:
DNS för klusteromfattande namnmatchning.
Webbgränssnitt (instrumentpanel) för klusterhantering.
Övervakning av containerresurser för insamling av mätvärden.
Loggning på klusternivå att samla in loggar centralt.
Kubernetes kör containeriserade appar på ett kluster av datorer och håller dem i det tillstånd du beskriver. Det gör du genom att placera arbete på rätt datorer, dirigera trafik till rätt platser och söka efter fel och ändringar.
De flesta Kubernetes-arbetsbelastningar börjar som ett deklarerat “önskat tillstånd” (vad som ska köras, hur många kopior och hur de ska exponeras). Kubernetes bygger på deklarativ konfiguration och automatisering.
Kubernetes schemalägger containrar till datorer i klustret baserat på tillgängliga beräkningsresurser och vad varje container behöver. Containrar körs i poddar, vilket är enheten kubernetes placerar på en dator.
Kontrollanter tittar på klustret och arbetar med att flytta det aktuella tillståndet närmare önskat tillstånd med hjälp av API-servern för att göra ändringar.
Schemaläggning är var ska den här körningen “vara?” beslut.
Kubernetes grupperar containrar i poddar och placerar sedan poddarna på datorer.
Kube-scheduler söker efter poddar som’inte har tilldelats ännu och väljer en nod för dem.
På varje nod ser kubelet till att poddarna körs (inklusive deras containrar).
Containrar och poddar kan skapas, flyttas eller ersättas, så program behöver stabila sätt att hitta varandra.
Kubernetes hanterar tjänstidentifiering och använder belastningsutjämning så att trafiken kan dirigeras även när poddar ändras över tid.
Tjänst-API:et tillhandahåller en stabil IP-adress eller ett värdnamn för en tjänst som backas upp av en eller flera poddar, och Kubernetes spårar poddar som backas upp via EndpointSlice-objekt.
När poddar bakom en tjänst ändras anpassas tjänstdirigeringen så att trafiken fortsätter att nå aktuella serverdelar.
Kubernetes kan skala arbetsbelastningar mot det tillstånd du anger, inklusive skalning baserat på beräkningsanvändning.
Vanliga skalningsidéer är:
Fler repliker (fler poddar) för att hantera högre efterfrågan.
Färre repliker när efterfrågan sjunker.
Resursspårning så att placeringsbesluten återspeglar processor- och minnesbehoven.
Detta binder tillbaka till den “önskade tillståndsmodellen”: du anger målet och kontrollanterna fortsätter att arbeta mot det.
Kubernetes innehåller självåterställningsbeteenden som syftar till att upprätthålla arbetsbelastningens hälsa och tillgänglighet. Dessa är:
Omstart av misslyckade containrar (omstarter på containernivå).
Det gick inte att ersätta poddar för att behålla det begärda antalet repliker (replikbyte).
Omplanera arbetsbelastningar när noder blir otillgängliga.
Att ta bort misslyckade poddar från tjänstslutpunkter så att trafiken endast går till felfria poddar (belastningsutjämning för tjänster).
Självåterställning kontrollerar containerhälsan och startar om eller replikerar dem när det uppstår problem.
Nyckeltal (KPI:er eller mått) används för att förstå klustrets hälsa och arbetsbelastningsbeteende.
Kubernetes-systemkomponenter genererar mått (Prometheus-format) som är användbara för instrumentpaneler och aviseringar.
Mått är vanligtvis tillgängliga på en HTTP-slutpunkt för komponent/mått, inklusive komponenter som kube-apiserver, kube-scheduler, kubelet, kube-proxy och kube-controller-manager.
Signaler om klusterhälsa (mätvärden på komponentnivå och felmönster)
Arbetsbelastningsstabilitet (till exempel frekventa omstarter eller ersättningar)
Kapacitetspress (resursallokering jämfört med efterfrågan, kopplat till skalningsbeslut)
Övervakning ger team en mer komplett vy över klusterresurser, Kubernetes-API:et, containrar och loggar, vilket förkortar återkopplingsloopen mellan problem och åtgärder.
Kubernetes väljs ofta när team behöver ett konsekvent sätt att köra många containrar på många datorer, samtidigt som trafikroutning, skalning och återställning hanteras av plattformen.
Kubernetes kan skala arbetsbelastningar, vilket innebär att de växer eller krymps när efterfrågan ändras, mot ett måltillstånd och kan skalas baserat på beräkningsanvändning.
Webbappar med variabel trafik (kampanjer, säsongstoppar): Justera repliker när belastningen ändras.
Batch- eller händelsestyrd bearbetning: Lägg till kapacitet för toppar och skala sedan ned igen.
Mikrotjänster: Skala specifika tjänster utan att skala hela appen.
Kubernetes stöder automatisk bin packning, vilket innebär att containrar placeras på noder baserat på CPU- och minnesbehov för att bättre utnyttja tillgängliga resurser. Det spårar också resursallokering när det hanterar arbetsbelastningar.
Delade kluster för flera team: Minska bortkastad kapacitet genom att placera arbetsbelastningar där resurser är tillgängliga.
Kluster med blandade arbetsbelastningar (tjänster plus jobb): Håll noderna sysselsatta utan manuell placering.
Kubernetes kan exponera arbetsbelastningar med hjälp av DNS eller en IP-adress, och det kan distribuera nätverkstrafik för att hålla distributionerna stabila. Det hanterar också tjänstidentifiering och har lastbalansering inbyggt när arbetsbelastningar ändras.
Mikrotjänstkommunikation: Tjänster hittar varandra via stabila namn medan Pod:ar ändras.
Interna API:er bakom en stabil slutpunkt: Riktar trafik bara till aktuella backends.
Kubernetes är utformat för att ersätta misslyckade containrar, schemalägga om arbetsbelastningar när noder blir otillgängliga och upprätthålla det önskade tillståndet. Exempel är omstarter av containrar, replikeringsbyte och borttagning av felaktiga poddar från tjänstslutpunkter så att trafiken bara går till felfria poddar.
Always-on-tjänster: Starta om eller ersätt misslyckade instanser utan manuella åtgärder.
Kluster med frekvent nodomsättning: Schemalägg om arbetsbelastningar när en nod slutar fungera.
Tjänster bakom en tjänst: Stoppa routning av trafik till poddar som inte är felfria.
Kubernetes stöder automatiserade distributioner och återställningar. Du beskriver det önskade tillståndet och Kubernetes flyttar det faktiska tillståndet mot det med en kontrollerad hastighet.
Frekventa programuppdateringar: Rulla ändringar gradvis och återställ sedan om det behövs.
Teams levererar flera tjänster: Se till att versionsmekaniken är konsekvent i alla appar.
Containerbaserade appar är åtskilda från infrastrukturen och Kubernetes hjälper till att flytta dem från lokala datorer till produktion lokalt, serverlösa, hybridmolnoch miljöer med flera moln samtidigt som konsekvensen bevaras i olika miljöer.
Dev/test/prod-paritet: Behåll samma paketerings- och schemaläggningsmodell i olika miljöer.
Hybriddistributioner: Kör delar av ett system lokalt och delar i molnet med samma orkestreringsmetod.
Kubernetes tillhandahåller ett gemensamt sätt att köra containerbaserade arbetsbelastningar med deklarativ konfiguration och maskininlärningsautomatisering, med stöd av ett stort och växande antal verktyg och community-stöd.
När team skapar system som består av många tjänster, kortvariga arbetsbelastningar och frekventa uppdateringar förblir Kubernetes en praktisk grund eftersom det fokuserar på upprepningsbara åtgärder:
Konsekventa åtgärder mellan miljöer (containrar som paketeras med beroenden, körs på samma sätt i olika miljöer).
Ett brett och aktivt ekosystem med allmänt tillgängliga tjänster, support och verktyg.
Utökningsbarhet via community-byggda tillägg, plugin-program och ett efterlevnadsprogram som håller kärn-API:er konsekventa mellan olika versioner.
Om du skapar eller kör arbetsbelastningar hjälper Azure Kubernetes Service (AKS) dig att distribuera och hantera containerbaserade program med Azure som hanterar kontrollplanet.
Skaffa Azure-mobilappen 
