Kubernetes (K8s)

Vad är Kubernetes?

Kubernetes (ofta förkortat K8s) är en öppen källkod-plattform för att hantera driftsättning, skalning och administration av containerbaserade applikationer. Kubernetes används ofta när det inte längre räcker att köra applikationen som några separata containrar på en eller två servrar.

Kubernetes utvecklades ursprungligen av Google och förvaltas numera av Cloud Native Computing Foundation (CNCF).

Namnets ursprung: "Kubernetes" kommer från grekiskan och betyder "rorsman" eller "pilot". Förkortningen K8s står för bokstaven K, följt av åtta bokstäver, och sedan s.

Varför behövs Kubernetes?

Problemet med att bara förlita sig på Docker

Docker är mycket användbart för att köra containrar, men när antalet tjänster och servrar ökar växer även det operativa arbetet.

Utan Kubernetes måste teamet vanligtvis hantera följande manuellt:

• Starta och stoppa containrar på flera servrar
• Starta om containrar som kraschar
• Fördela trafik mellan flera applikationsinstanser
• Öka kapaciteten när trafiken ökar
• Hantera kommunikation mellan tjänster
• Rulla tillbaka driftsättningen när en ny version orsakar problem

Kubernetes hjälper till att strukturera allt detta med funktioner som:

• Auto-healing - Poddar som fallerar kan startas om automatiskt
• Auto-scaling - Antalet instanser kan anpassas efter belastningen
• Load balancing - Trafiken fördelas mellan flera poddar
• Rolling updates - Nya versioner släpps stegvis
• Service discovery - Tjänster hittar varandra via internt DNS
• Secret management - Autentiseringsuppgifter och känslig konfiguration kan hållas separat från koden

Kubernetes-arkitektur

Control Plane (Master Node)

Klustrets "hjärna" som hanterar alla operationer:

1. API Server

• Ingångspunkt för alla kommandon
• Hanterar REST-operationer
• Validerar och bearbetar förfrågningar

2. etcd

• Nyckel-värde-lager för klustrets tillstånd
• Distribuerat och mycket tillgängligt

3. Scheduler

• Tilldelar poddar till noder
• Tar hänsyn till resurskrav och begränsningar

4. Controller Manager

• Kör controllers (Deployment, ReplicaSet, med flera)
• Säkerställer att önskat tillstånd matchar det faktiska tillståndet

Worker Nodes

Maskinerna som kör dina applikationer:

1. kubelet

• Agent på varje nod
• Hanterar poddar och containrar
• Rapporterar status till control plane

2. kube-proxy

• Nätverksproxy på varje nod
• Upprätthåller nätverksregler
• Hanterar lastbalansering

3. Container Runtime

• Docker, containerd, eller CRI-O
• Kör faktiskt containrarna

┌─────────────────────────────────────┐
│         Control Plane               │
│  ┌──────────┐  ┌────────┐          │
│  │API Server│  │  etcd  │          │
│  └──────────┘  └────────┘          │
│  ┌──────────┐  ┌─────────────────┐ │
│  │Scheduler │  │Controller Manager│ │
│  └──────────┘  └─────────────────┘ │
└─────────────────────────────────────┘
           │
     ┌─────┴─────┐
     │           │
┌────▼────┐ ┌────▼────┐
│ Node 1  │ │ Node 2  │
│┌───────┐│ │┌───────┐│
││kubelet││ ││kubelet││
│└───────┘│ │└───────┘│
│┌───────┐│ │┌───────┐│
││kube-  ││ ││kube-  ││
││proxy  ││ ││proxy  ││
│└───────┘│ │└───────┘│
│ Pods... │ │ Pods... │
└─────────┘ └─────────┘

Viktiga Kubernetes-koncept

1. Pod

Den minsta driftsättningsenheten i K8s. Kan innehålla en eller flera containrar som delar nätverk och lagring.

apiVersion: v1
kind: Pod
metadata:
  name: myapp-pod
  labels:
    app: myapp
spec:
  containers:
  - name: myapp
    image: myapp:v1
    ports:
    - containerPort: 3000

2. Deployment

Hanterar ReplicaSets och poddar. Används för tillståndslösa (stateless) applikationer.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:v1
        ports:
        - containerPort: 3000
        resources:
          requests:
            memory: "128Mi"
            cpu: "250m"
          limits:
            memory: "256Mi"
            cpu: "500m"

3. Service

Exponerar poddar mot nätverket. Ger en stabil IP-adress och DNS-namn.

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  type: LoadBalancer
  selector:
    app: myapp
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000

Servicetyper:

• ClusterIP - Endast internt (standard)
• NodePort - Exponeras på en port på varje nod
• LoadBalancer - Extern lastbalanserare (moln)
• ExternalName - Mappar till externt DNS

4. ConfigMap

Lagrar konfigurationsdata som nyckel-värde-par.

apiVersion: v1
kind: ConfigMap
metadata:
  name: myapp-config
data:
  DATABASE_HOST: postgres.default.svc.cluster.local
  DATABASE_PORT: "5432"
  ENVIRONMENT: production

5. Secret

Lagrar känslig data (krypterad i vila).

apiVersion: v1
kind: Secret
metadata:
  name: myapp-secret
type: Opaque
data:
  # base64-kodat
  database-password: cGFzc3dvcmQxMjM=
  api-key: c2VjcmV0a2V5MTIz

6. Ingress

HTTP/HTTPS-routning till tjänster. Hanterar SSL-terminering.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp-ingress
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  tls:
  - hosts:
    - myapp.example.com
    secretName: myapp-tls
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: myapp-service
            port:
              number: 80

7. StatefulSet

För tillståndsfulla (stateful) applikationer, till exempel databaser. Ger en stabil nätverksidentitet.

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
spec:
  serviceName: postgres
  replicas: 3
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: postgres:15
        volumeMounts:
        - name: data
          mountPath: /var/lib/postgresql/data
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 10Gi

8. Namespace

Virtuella kluster för att isolera resurser.

# Skapa namespace
kubectl create namespace production
kubectl create namespace staging

# Driftsätt till namespace
kubectl apply -f deployment.yaml -n production

kubectl: Kubernetes CLI

Grundläggande kommandon

# Hämta klusterinfo
kubectl cluster-info
kubectl get nodes

# Hämta resurser
kubectl get pods
kubectl get deployments
kubectl get services
kubectl get all

# Beskriv resurs (detaljerad info)
kubectl describe pod myapp-pod

# Loggar
kubectl logs myapp-pod
kubectl logs -f myapp-pod  # Följ loggarna
kubectl logs myapp-pod -c container-name  # Pod med flera containrar

# Kör kommando i podden
kubectl exec -it myapp-pod -- /bin/sh
kubectl exec myapp-pod -- env

# Portvidarebefordran (lokal testning)
kubectl port-forward pod/myapp-pod 8080:3000
kubectl port-forward service/myapp-service 8080:80

Apply och Delete

# Skapa/uppdatera resurser
kubectl apply -f deployment.yaml
kubectl apply -f ./k8s-manifests/

# Ta bort resurser
kubectl delete -f deployment.yaml
kubectl delete pod myapp-pod
kubectl delete deployment myapp-deployment

# Ta bort allt i ett namespace
kubectl delete all --all -n staging

Skalning

# Manuell skalning
kubectl scale deployment myapp-deployment --replicas=5

# Autoskalning
kubectl autoscale deployment myapp-deployment \
  --cpu-percent=70 \
  --min=2 \
  --max=10

Uppdateringar och återställning

# Uppdatera image
kubectl set image deployment/myapp-deployment \
  myapp=myapp:v2

# Status för utrullningen
kubectl rollout status deployment/myapp-deployment

# Historik för utrullningen
kubectl rollout history deployment/myapp-deployment

# Återställ (rollback)
kubectl rollout undo deployment/myapp-deployment
kubectl rollout undo deployment/myapp-deployment --to-revision=2

Driftsättningsstrategier

1. Rolling Update (Standard)

Uppdaterar poddar stegvis.

spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0

2. Recreate

Avslutar alla gamla poddar och startar därefter de nya. Kort driftstopp.

spec:
  strategy:
    type: Recreate

3. Blue-Green (manuellt)

Kör två versioner samtidigt och växlar trafiken.

# Driftsätt green-versionen
kubectl apply -f green-deployment.yaml

# Testa green
kubectl port-forward service/myapp-green 8080:80

# Växla trafiken (uppdatera service-selectorn)
kubectl patch service myapp -p '{"spec":{"selector":{"version":"green"}}}'

4. Canary

Stegvis utrullning till en delmängd av användarna.

# Stabil driftsättning: 90 % av trafiken
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-stable
spec:
  replicas: 9
  # ...

---
# Canary-driftsättning: 10 % av trafiken
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-canary
spec:
  replicas: 1
  # ...

Resurshantering

Resursförfrågningar och gränser

resources:
  requests:
    memory: "128Mi"  # Garanterat minimum
    cpu: "250m"      # 0,25 CPU-kärna
  limits:
    memory: "256Mi"  # Maximalt tillåtet
    cpu: "500m"      # 0,5 CPU-kärna

Quality of Service (QoS)

1. Guaranteed - requests = limits
2. Burstable - requests < limits
3. BestEffort - inga requests/limits

Hälsokontroller

Liveness Probe

Kontrollerar om containern lever. Startas om vid fel.

livenessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 30
  periodSeconds: 10
  timeoutSeconds: 3
  failureThreshold: 3

Readiness Probe

Kontrollerar om containern är redo att ta emot trafik.

readinessProbe:
  httpGet:
    path: /ready
    port: 3000
  initialDelaySeconds: 5
  periodSeconds: 5
  failureThreshold: 3

Startup Probe

För containrar med långsam start.

startupProbe:
  httpGet:
    path: /startup
    port: 3000
  initialDelaySeconds: 0
  periodSeconds: 10
  failureThreshold: 30  # 300s totalt

Persistent lagring

PersistentVolume (PV)

En lagringsresurs på klusternivå.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-data
spec:
  capacity:
    storage: 10Gi
  accessModes:
  - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: standard
  hostPath:
    path: /data

PersistentVolumeClaim (PVC)

En podds begäran om lagring.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-data
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
  storageClassName: standard

Användning i en pod

spec:
  containers:
  - name: myapp
    volumeMounts:
    - mountPath: /app/data
      name: data
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: pvc-data

Helm: Kubernetes pakethanterare

Paketerar K8s-applikationer som "charts".

# Installera Helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Lägg till repository
helm repo add bitnami https://charts.bitnami.com/bitnami

# Sök efter charts
helm search repo postgres

# Installera ett chart
helm install my-postgres bitnami/postgresql

# Lista releaser
helm list

# Avinstallera
helm uninstall my-postgres

Skapa ett eget chart

# Skapa chart-struktur
helm create myapp

myapp/
├── Chart.yaml
├── values.yaml
├── templates/
│   ├── deployment.yaml
│   ├── service.yaml
│   └── ingress.yaml

Hanterade Kubernetes-tjänster

Google Kubernetes Engine (GKE)

gcloud container clusters create mycluster \
  --num-nodes=3 \
  --zone=asia-southeast1-a

Amazon EKS

eksctl create cluster \
  --name mycluster \
  --region ap-southeast-1 \
  --nodes 3

Azure AKS

az aks create \
  --resource-group mygroup \
  --name mycluster \
  --node-count 3

DigitalOcean Kubernetes

doctl kubernetes cluster create mycluster \
  --region sgp1 \
  --node-pool "name=worker;size=s-2vcpu-4gb;count=3"

Bästa praxis

1. Resursgränser

Ange alltid requests och limits för ett förutsägbart beteende.

2. Hälsokontroller

Implementera liveness- och readiness-probes.

3. Använd namespaces

Isolera miljöer (dev, staging, prod).

4. ConfigMaps & Secrets

Hårdkoda aldrig konfiguration.

5. Etiketter och annoteringar

Organisera och dokumentera resurser.

metadata:
  labels:
    app: myapp
    version: v1
    environment: production
    team: backend
  annotations:
    description: "Main application deployment"
    contact: "team@example.com"

6. Podd-säkerhet

securityContext:
  runAsNonRoot: true
  runAsUser: 1000
  fsGroup: 1000
  capabilities:
    drop:
    - ALL
  readOnlyRootFilesystem: true

7. Nätverkspolicyer

Begränsar trafiken mellan poddar.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-policy
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 8080

Kubernetes för utvecklare

När behövs K8s?

Kubernetes är oftast motiverat om:

• Applikationen redan är uppbyggd som mikrotjänster
• Hög tillgänglighet verkligen behövs
• Autoskalning börjar bli viktigt
• Du hanterar flera miljöer samtidigt
• Teamet och antalet tjänster redan är ganska stort

Kubernetes behövs oftast inte om:

• Applikationen fortfarande är en enkel monolit
• Trafiken fortfarande är låg
• Du jobbar ensam eller i ett litet team
• Budget och operativ tid är begränsad

Enklare alternativ

För många startups och småföretag är en enklare plattform ofta mer realistisk i ett tidigt skede:

• smbCloud - PaaS med en lättare installation
• Heroku - Lättanvänd PaaS
• Railway - Ganska utvecklarvänlig
• Fly.io - Passar bra för edge-nära driftsättning
• Render - Ett relativt enkelt molnalternativ

Felsökning av vanliga problem

Pod fastnar i Pending

kubectl describe pod myapp-pod
# Kontrollera: Otillräckliga resurser, PVC inte bunden, problem med nodselektor

CrashLoopBackOff

kubectl logs myapp-pod --previous
# Kontrollera: Applikationsfel, saknade beroenden, felkonfiguration

ImagePullBackOff

kubectl describe pod myapp-pod
# Kontrollera: Fel image-namn, autentiseringsproblem, nätverksproblem

Service inte åtkomlig

kubectl get endpoints myapp-service
# Kontrollera: Label-selector, portkonfiguration, poddens readiness

Inlärningsväg

Nybörjare (1–2 månader)

• Förstå containrar (Docker)
• Grunderna i K8s-arkitektur
• Driftsätt en enkel app med Deployment + Service
• Grundläggande kubectl-kommandon

Mellannivå (3–6 månader)

• ConfigMaps & Secrets
• Hälsokontroller
• Ingress och nätverk
• Persistent lagring
• Helm charts

Avancerat (6+ månader)

• StatefulSets
• Custom Resource Definitions (CRDs)
• Operatorer
• Service mesh (Istio/Linkerd)
• Hantering av flera kluster

Sammanfattning

Kubernetes är mycket användbart när en containeriserad applikation har blivit så stor att det operativa arbetet är svårt att hantera manuellt. Med Kubernetes kan teamet hantera driftsättning, skalning, nätverk och återställning av tjänster på ett mer konsekvent sätt.

Det finns dock ett pris: Kubernetes lägger till ett extra lager av komplexitet. Välj därför Kubernetes när systemets behov verkligen pekar åt det hållet, inte bara för att det är populärt.

Om du precis har börjat lära dig, ta det från grunden: förstå container, pod, deployment, service och kubectl. Gå därefter vidare till ämnen som ingress, Helm, autoskalning och observability.