API-begränsning och skalbarhetsmönster · Lektion

Containrar och orkestrering med Kubernetes

Lär er hur containrar paketerar tjänster och hur Kubernetes schemalägger, skalar och återställer dem – grunden som gör mikrotjänst- och serverless-distributioner hanterbara.

Lektion 4 av 413 steg

Containrar och orkestrering med Kubernetes är en gratis lektion i API-begränsning och skalbarhetsmönster på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för API-begränsning och skalbarhetsmönster, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i API-begränsning och skalbarhetsmönster innehåller totalt 4 lektioner.

Varför containrar?

Mikrotjänster mångfaldigar antalet enheter som ska distribueras. Containrar paketerar varje tjänst med dess beroenden i en portabel, isolerad image som körs likadant överallt.

Image kontra container

En image är den oföränderliga ritningen; en container är en körande instans av den. Du bygger en image en gång och kör många identiska containrar från den.

FROM node:20-alpine
WORKDIR /app
COPY . .
RUN npm ci
CMD ["node", "server.js"]

Orkestreringsproblemet

Det är enkelt att köra några containrar för hand. För att köra hundratals över många maskiner — starta om krascher, balansera belastning och rulla ut uppdateringar — behövs en orkestrerare.

Grunderna i Kubernetes

Kubernetes schemalägger containrar på ett kluster av maskiner och ser till att de fortsätter köra. Centrala objekt:

Pod — en eller flera containrar som kör tillsammans
Deployment — deklarerar önskat antal repliker
Service — stabil nätverksslutpunkt

Deklarerat önskat tillstånd

Du deklarerar vad du vill ha; Kubernetes ser till att verkligheten motsvarar det. Be om 3 repliker så håller Kubernetes 3 igång och startar om dem som avslutas.

apiVersion: apps/v1
kind: Deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: orders

Självläkning

Om en nod slutar fungera eller en container kraschar schemalägger Kubernetes automatiskt podden på en annan plats. Systemet återgår till det deklarerade tillståndet utan manuella åtgärder.

Hälsokontroller

Kubernetes använder prober för att känna till containerns tillstånd:

liveness — starta om den om den har hängt sig
readiness — skicka endast trafik när den är redo

readinessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 5

Horisontell autoskalning av pods

Horizontal Pod Autoscaler lägger till eller tar bort pods baserat på mätvärden som CPU-användning, så att mikrotjänster kan skala ut under belastning och skala in igen när det är lugnt.

minReplicas: 2
maxReplicas: 20
targetCPUUtilizationPercentage: 70

Rullande uppdateringar

När en ny version distribueras ersätts pods gradvis, så att tjänsten förblir tillgänglig hela tiden. Om den nya versionen inte fungerar som den ska kan Kubernetes rulla tillbaka till den föregående.

Så här möjliggör detta serverless

Många serverless- och Functions-as-a-Service-plattformar körs ovanpå Kubernetes. Om ni förstår pods, autoskalning och prober blir det lättare att förstå vad som händer bakom en distribuerad funktion.

Resursförfrågningar och begränsningar

Varje container deklarerar en CPU- och minnesförfrågan (vad den behöver för att schemaläggas) och en gräns (dess absoluta tak). Korrekta värden låter schemaläggaren packa noder effektivt och hindrar en resurskrävande pod från att svälta ut sina grannar.

resources:
  requests:
    cpu: 250m
    memory: 256Mi
  limits:
    cpu: 500m
    memory: 512Mi

Snabbtest

Testa era kunskaper om orkestrering.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er om containerplattformen bakom skalbara tjänster:

Containers paketerar tjänster portabelt
Kubernetes schemalägger dem och reparerar dem automatiskt
Probes styr omstarter och trafik
Autoskalning och rullande uppdateringar håller tjänster elastiska och tillgängliga

Gratis att börja

Lär dig API-begränsning och skalbarhetsmönster med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Containrar och orkestrering med Kubernetes” gratis?

Ja – hela texten till ”Containrar och orkestrering med Kubernetes” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i API-begränsning och skalbarhetsmönster, kan Ni uppgradera till CoddyKit PRO. Kursen i API-begränsning och skalbarhetsmönster innehåller totalt 4 lektioner.

Vad lär jag mig i ”Containrar och orkestrering med Kubernetes”?

Lär er hur containrar paketerar tjänster och hur Kubernetes schemalägger, skalar och återställer dem – grunden som gör mikrotjänst- och serverless-distributioner hanterbara. Ni övar på API-begränsning och skalbarhetsmönster med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig API-begränsning och skalbarhetsmönster?

Du behöver inga förkunskaper. Utbildningen i API-begränsning och skalbarhetsmönster på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Containrar och orkestrering med Kubernetes”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här API-begränsning och skalbarhetsmönster-lektionen?

Ja. Varje API-begränsning och skalbarhetsmönster-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Skalning med mikrotjänstarkitektur
Serverlösa funktioner för händelsestyrda API:er
Begrepp och fördelar med service mesh
Containrar och orkestrering med Kubernetes

← Tillbaka till API-begränsning och skalbarhetsmönster