Grunderna i Docker och DevOps · Lektion

Pods: de minsta enheterna

Lär dig om Pods, de grundläggande byggstenarna i Kubernetes, och hur du definierar och hanterar dem.

Lektion 2 av 411 steg

Pods: de minsta enheterna är en gratis lektion i Grunderna i Docker och DevOps på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Grunderna i Docker och DevOps, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Grunderna i Docker och DevOps innehåller totalt 4 lektioner.

Vad är en Kubernetes Pod?

I Kubernetes är den minsta och mest grundläggande enheten som Ni kan distribuera en Pod. Tänk på en Pod som ett enda ”hus” som rymmer en eller flera containrar.

Pods är en abstraktion ovanpå containrar. De representerar en process som körs i klustret och kapslar in applikationscontainrar, lagringsresurser, en unik nätverks-IP-adress och alternativ som styr hur containrarna ska köras.

Pods: de minsta enheterna — illustration 1

Pod jämfört med container: skillnaden

Ni kanske undrar: ”Varför behöver jag en Pod om jag redan har containrar?” Här är den viktigaste skillnaden:

En Container (till exempel en Docker-container) är ett paket som innehåller en applikation och dess beroenden.
En Pod är den Kubernetes-abstraktion som kapslar in en eller flera containrar och förser dem med delade resurser samt en gemensam nätverksidentitet.

Medan en container är det som faktiskt körs, är en Pod det sätt på vilket Kubernetes hanterar och orkestrerar dessa körbara enheter.

Varför använda Pods?

Pods erbjuder flera viktiga fördelar:

Delat nätverksnamnutrymme: Alla containrar i en Pod delar samma IP-adress och nätverksportar. De kan kommunicera med varandra med hjälp av localhost.
Delad lagring: Pods kan dela lagringsvolymer, vilket gör att containrar i samma Pod kan komma åt gemensamma data.
Samlokalisering och gemensam schemaläggning: Containrar som behöver samarbeta nära (till exempel en applikation och en loggningsagent) kan garanteras köras på samma nod och schemaläggs alltid tillsammans.

En Pod-definitions anatomi

Pods definieras med YAML-konfigurationsfiler. Här är de centrala komponenterna som Ni hittar:

apiVersion: Anger Kubernetes API-version (till exempel v1).
kind: Typen av Kubernetes-objekt, vilket är Pod.
metadata: Information som Podens name och labels.
spec: Podens önskade tillstånd, inklusive containers som ska köras, volumes och andra inställningar.

Definiera en Pod med en container

De flesta Pods innehåller en enda container. Det är vanligt för enkla applikationer. Här är en grundläggande YAML-definition för en Pod som kör en Nginx-webbserver:

apiVersion: v1
kind: Pod
metadata:
  name: my-nginx-pod
  labels:
    app: webserver
spec:
  containers:
  - name: nginx-container
    image: nginx:latest
    ports:
    - containerPort: 80

Distribuera Er första Pod

Om Ni vill skapa en Pod från en YAML-fil använder Ni kommandot kubectl apply. Det instruerar Kubernetes att skapa eller uppdatera resurser utifrån Er definition.

Anta att Ni sparar den föregående Nginx-Pod-definitionen som nginx-pod.yaml. Då distribuerar Ni den så här:

kubectl apply -f nginx-pod.yaml

Kubernetes schemalägger sedan denna Pod så att den körs på en av dess worker-noder.

Inspektera Pods: Get och Describe

När Podsen har distribuerats vill Ni kontrollera deras status. Här är två viktiga kubectl-kommandon:

kubectl get pods: Visar alla Pods i det aktuella namnutrymmet, inklusive namn, status och nod.
kubectl describe pod <pod-name>: Ger detaljerad information om en specifik Pod, inklusive händelser, containerstatus och tilldelade resurser.

Dessa kommandon är viktiga för övervakning och felsökning.

Pods med flera containrar: sidecars

Även om Pods med en enda container är vanliga finns det scenarier där Pods med flera containrar är fördelaktiga. Ett klassiskt exempel är Sidecar Pattern.

En sidecar-container körs tillsammans med Er huvudsakliga applikationscontainer i samma Pod och utför kompletterande uppgifter som:

Loggnings- och övervakningsagenter
Datasynkronisering
Proxyhantering av nätverkstrafik

De delar Podens nätverk och lagring, vilket gör kommunikationen effektiv.

Exempel: Pod med flera containrar

Här är ett exempel på en Pod med flera containrar. Den innehåller en Nginx-webbserver och en busybox-sidecar-container som skriver loggar till en delad volym.

apiVersion: v1
kind: Pod
metadata:
  name: multi-container-pod
spec:
  volumes:
  - name: shared-log-volume
    emptyDir: {}
  containers:
  - name: web-server
    image: nginx:latest
    ports:
    - containerPort: 80
    volumeMounts:
    - name: shared-log-volume
      mountPath: /var/log/nginx
  - name: log-writer
    image: busybox:latest
    command: ["/bin/sh", "-c", "while true; do echo 'Hello from sidecar!' >> /var/log/app.log; sleep 5; done"]
    volumeMounts:
    - name: shared-log-volume
      mountPath: /var/log/app

Testa Era Pod-kunskaper

Vilket av följande påståenden om Kubernetes Pods är SANT?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Pods – kärnenheten

Ni har precis lärt Er om Kubernetes Pods, de grundläggande byggstenarna för Era applikationer i ett kluster.

Pods kapslar in en eller flera containrar och förser dem med delade resurser.
De erbjuder delat nätverk och delad lagring samt garanterar samlokalisering för relaterade containrar.
Ni definierar Pods med YAML och distribuerar dem med kubectl apply.
kubectl get pods och kubectl describe pod hjälper Er att övervaka dem.

Härnäst utforskar vi fler kubectl-kommandon för att interagera med Ert kluster!

Gratis att börja

Lär dig Grunderna i Docker och DevOps 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 ”Pods: de minsta enheterna” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Grunderna i Docker och DevOps, inklusive ”Pods: de minsta enheterna”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Grunderna i Docker och DevOps innehåller totalt 4 lektioner.

Vad lär jag mig i ”Pods: de minsta enheterna”?

Lär dig om Pods, de grundläggande byggstenarna i Kubernetes, och hur du definierar och hanterar dem. Ni övar på Grunderna i Docker och DevOps 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 Grunderna i Docker och DevOps?

Du behöver inga förkunskaper. Utbildningen i Grunderna i Docker och DevOps 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 2 av 4.

Hur lång tid tar lektionen ”Pods: de minsta enheterna”?

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 Grunderna i Docker och DevOps-lektionen?

Ja. Varje Grunderna i Docker och DevOps-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

← Tillbaka till Grunderna i Docker och DevOps