Docker och Kubernetes för utvecklare · Lektion

Skalning och självläkande applikationer

Implementera grundläggande skalningsstrategier för dina distributioner och förstå hur Kubernetes säkerställer applikationers tillgänglighet och motståndskraft.

Lektion 3 av 411 steg

Skalning och självläkande applikationer är en gratis lektion i Docker och Kubernetes för utvecklare på CoddyKit. Detta är lektion 3 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 Docker och Kubernetes för utvecklare, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Docker och Kubernetes för utvecklare innehåller totalt 4 lektioner.

Introduktion till skalning och självläkning

Välkommen! I den här lektionen går vi igenom hur du gör dina applikationer robusta och responsiva med Kubernetes.

Vi utforskar hur du kan skala dina applikationer för att hantera varierande belastning och hur Kubernetes möjliggör självläkning för att automatiskt återhämta sig från fel. Detta är avgörande för tillförlitliga tjänster med hög tillgänglighet.

Varför skalning är viktigt

Att skala en applikation innebär att anpassa dess kapacitet efter efterfrågan. Föreställ dig en plötslig ökning av antalet användare i din nätbutik – utan skalning kan applikationen bli långsam eller krascha.

Hantera trafik: Fördela belastningen mellan flera instanser.
Förbättra prestandan: Behåll god responsivitet vid hög belastning.
Öka tillgängligheten: Om en instans slutar fungera kan andra ta över.

Skala med Deployments

I Kubernetes är Deployments centrala för skalning. De hanterar en uppsättning identiska Pods och säkerställer att det önskade antalet repliker alltid körs.

Du kan skala en Deployment manuellt genom att ändra fältet replicas. Om du till exempel vill skala en app med namnet my-app till 3 Pods:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: nginx:latest
        ports:
        - containerPort: 80

Introduktion till Horizontal Pod Autoscaler

Manuell skalning fungerar, men är inte idealisk för dynamiska arbetsbelastningar. Det är här Horizontal Pod Autoscaler (HPA) kommer in!

HPA justerar automatiskt antalet Pods i en Deployment (eller StatefulSet) utifrån observerade mätvärden, till exempel CPU-användning eller anpassade mätvärden.

Konfigurera en HPA

En HPA-resurs definierar målet för applikationens skalning. Den övervakar mätvärden och ökar eller minskar antalet Pod-repliker inom angivna minimi- och maxgränser.

Här är ett grundläggande HPA-manifest som siktar på 50 % CPU-användning:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: my-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

Vad är självläkning?

Utöver skalning är Kubernetes också utmärkt på självläkning. Det innebär att systemet automatiskt kan upptäcka och återhämta sig från applikationsfel utan mänsklig inblandning.

Om en Pod kraschar, slutar svara eller avslutas arbetar Kubernetes-styrenheter (som Deployment-styrenheten) med att ersätta den och återställa det önskade tillståndet.

Liveness-prober: lever du?

Liveness-prober talar om för Kubernetes om applikationen i en container fortfarande körs och är frisk. Om en liveness-prob misslyckas startar Kubernetes om containern.

Detta är viktigt för appar som kan hamna i dödläge eller sluta svara utan att faktiskt ha kraschat.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: liveness-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: liveness-app
  template:
    metadata:
      labels:
        app: liveness-app
    spec:
      containers:
      - name: liveness-container
        image: busybox
        args:
        - /bin/sh
        - -c
        - touch /tmp/healthy; sleep 30; rm -f /tmp/healthy; sleep 600
        livenessProbe:
          exec:
            command:
            - cat
            - /tmp/healthy
          initialDelaySeconds: 5
          periodSeconds: 5

Readiness-prober: redo för trafik?

Readiness-prober talar om för Kubernetes om applikationen är redo att hantera nätverkstrafik. Om en readiness-prob misslyckas slutar Kubernetes att skicka trafik till den poden.

Detta förhindrar att nya förfrågningar går till en Pod som fortfarande startar, läser in data eller tillfälligt inte är frisk.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: readiness-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: readiness-app
  template:
    metadata:
      labels:
        app: readiness-app
    spec:
      containers:
      - name: readiness-container
        image: nginx:latest
        ports:
        - containerPort: 80
        readinessProbe:
          httpGet:
            path: /index.html
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 5

Synergi mellan skalning och självläkning

HPA samt liveness- och readiness-prober samarbetar för att göra applikationerna mycket tillgängliga och motståndskraftiga.

HPA hanterar varierande belastning genom att justera antalet repliker.
Liveness-prober säkerställer att containers startas om om de slutar svara.
Readiness-prober säkerställer att trafik endast går till fullt fungerande Pods.

Detta kombinerade tillvägagångssätt förbättrar applikationers tillförlitlighet avsevärt i dynamiska miljöer.

Snabb kontroll

Vilka av följande påståenden om Kubernetes mekanismer för skalning och självläkning är sanna?

Besvara frågan i den interaktiva lektionen

Sammanfattning och nästa steg

Bra jobbat! Du har lärt dig hur Kubernetes hjälper dina applikationer att förbli tillgängliga och ha god prestanda:

Skalning: Anpassning av kapaciteten med Deployments och HPA.
Självläkning: Automatisk återhämtning med liveness- och readiness-prober.

Dessa kraftfulla funktioner är grundläggande för att bygga robusta, molnbaserade applikationer. Fortsätt öva för att bemästra dem!

Gratis att börja

Lär dig Docker och Kubernetes för utvecklare 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 ”Skalning och självläkande applikationer” gratis?

Ja – hela texten till ”Skalning och självläkande applikationer” 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 Docker och Kubernetes för utvecklare, kan Ni uppgradera till CoddyKit PRO. Kursen i Docker och Kubernetes för utvecklare innehåller totalt 4 lektioner.

Vad lär jag mig i ”Skalning och självläkande applikationer”?

Implementera grundläggande skalningsstrategier för dina distributioner och förstå hur Kubernetes säkerställer applikationers tillgänglighet och motståndskraft. Ni övar på Docker och Kubernetes för utvecklare 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 Docker och Kubernetes för utvecklare?

Du behöver inga förkunskaper. Utbildningen i Docker och Kubernetes för utvecklare 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 3 av 4.

Hur lång tid tar lektionen ”Skalning och självläkande applikationer”?

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 Docker och Kubernetes för utvecklare-lektionen?

Ja. Varje Docker och Kubernetes för utvecklare-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

Förstå Kubernetes Deployments
Exponera applikationer med Services
Skalning och självläkande applikationer
Rullande uppdateringar och återställningar

← Tillbaka till Docker och Kubernetes för utvecklare