Hva er en Pod, og hvorfor er den den minste utrullbare enheten i Kubernetes?

Question

IT Interview Practice · Accepted Answer

En **Pod** er den minste utrullbare enheten i Kubernetes: en innpakning rundt **én eller flere containere** som deler samme network namespace (én IP) og kan dele storage-volumer. Du ruller ikke ut containere direkte — du ruller ut Pods.

## Hva er inne i en Pod

```text
┌───────────────── Pod (has ONE shared IP) ─────────────────┐
│                                                            │
│   ┌──────────────┐   ┌──────────────┐   shared:           │
│   │  container A  │   │  container B  │    • network (IP)   │
│   │  (app)        │   │  (sidecar)    │    • localhost      │
│   └──────────────┘   └──────────────┘    • volumes         │
│         │ talk to each other via localhost:port            │
└────────────────────────────────────────────────────────────┘
```

Containere i samme Pod er **alltid samlokalisert** på samme node, schedulert sammen, og kan nå hverandre over `localhost`.

## En minimal Pod

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: web
  labels: { app: web }
spec:
  containers:
    - name: web
      image: nginx:1.27
      ports:
        - containerPort: 80
```

## Hvorfor en Pod, ikke bare en container?

```text
Pod-en er en abstraksjon som lar en "logisk applikasjon" være mer enn én
container som MÅ kjøre sammen og dele ressurser:
  → en hoved-app-container + en hjelpe-"sidecar" (log shipper, proxy, osv.)
  → de deler samme IP og kan bruke delte volumer for å utveksle filer
De fleste Pods har ÉN container. Fler-container-Pods er kun for tett kobling.
```

## Pods er flyktige — ikke administrer dem direkte

```text
En Pod er ENGANGS:
  → den får en ny IP hver gang den (gjen)opprettes
  → hvis noden dør, er Pod-en BORTE (den reschedules ikke av seg selv)
→ Du oppretter nesten aldri bare Pods i produksjon.
→ I stedet oppretter og ERSTATTER en controller (Deployment / StatefulSet / Job)
  Pods for deg, og holder ønsket antall i live.
```

```bash
kubectl get pods -o wide          # se Pods, noden deres og IP
kubectl describe pod web          # hendelser, status, restarts
kubectl logs web -c web           # logger for en spesifikk container
kubectl exec -it web -- sh        # åpne shell inn i containeren
```

## Hvorfor det er viktig

Pod-en er den grunnleggende byggeklossen i Kubernetes, så å forstå hva den er og hvorfor den finnes er essensiell kunnskap du må ha. Kubernetes scheduler ikke bare containere; den scheduler **Pods** — en tynn innpakning rundt én eller flere containere som deler et network namespace (én enkelt IP, nåbar seg imellom over `localhost`) og kan dele storage-volumer. Å forstå at containere i en Pod **alltid er samlokalisert og schedulert sammen** på én node forklarer hva en Pod er *til for*: å gruppere containere som må kjøre sammen og dele ressurser, som en hovedapplikasjon pluss en tett koblet **sidecar** (en log shipper, proxy eller adapter) — samtidig som man erkjenner at de fleste Pods i praksis bare har én container. Like viktig er det å fatte at Pods er **flyktige og engangs**: de får en ny IP ved hver gjenopprettelse og gjenoppstår ikke av seg selv hvis en node dør, som er nøyaktig hvorfor du sjelden oppretter bare Pods og i stedet stoler på controllere på høyere nivå (**Deployments**, **StatefulSets**, **Jobs**) som oppretter og erstatter Pods for å opprettholde en desired state. Dette skillet — Pod-en som den atomære enheten, administrert av controllere i stedet for for hånd — er den begrepsmessige broen fra enkeltcontainere til ekte Kubernetes-workloads, og hverdagskunnskap for alle som ruller ut, feilsøker (via `kubectl logs`, `describe`, `exec`) eller resonnerer om applikasjoner på en klynge.

Hva er inne i en Pod

En minimal Pod

Hvorfor en Pod, ikke bare en container?

Pods er flyktige — ikke administrer dem direkte

Hvorfor det er viktig

Relaterte spørsmål