1~
2Om du arbetar inom mjukvaruutveckling har du säkert hört talas om Kubernetes. Men vad är det exakt, och varför har det blivit de facto-standarden för att hantera containeriserade applikationer? Denna guide tar dig från grunderna till de fundamentala koncepten, med praktiska exempel och diagram.
3~
4## Före Kubernetes: Lite Historik
5~
61.  **Traditionell Deployment**: Initialt kördes applikationer på fysiska servrar. Dyrt, svårt att skala och benäget för resurskonflikter.
72.  **Virtualiserad Deployment**: Sedan kom Virtual Machines (VM). VM:ar möjliggjorde flera isolerade applikationer på samma hårdvara, men varje VM kör ett helt operativsystem.
83.  **Containeriserad Deployment**: Containrar (som Docker) delar samma värd-OS men kör isolerade processer. De är lättviktiga, snabba att starta och portabla.
9~
10Containrar löste portabilitetsproblemet men skapade ett annat: hur hanterar man hundratals (eller tusentals) containrar i produktion?
11~
12Det är här **Kubernetes** kommer in.
13~
14## Vad är Kubernetes?
15~
16Kubernetes (ofta förkortat **K8s**) är en plattform med öppen källkod för containerorkestrering. Det automatiserar deployment, skalning och hantering av containeriserade applikationer. Skapat av Google och nu underhållet av Cloud Native Computing Foundation (CNCF).
17~
18## Arkitekturen i ett Kubernetes-kluster
19~
20```mermaid
21graph TD
22    subgraph "Control Plane (Master)"
23        A["API Server"]
24        B["etcd"]
25        C["Scheduler"]
26        D["Controller Manager"]
27    end
28~
29    subgraph "Worker Node 1"
30        E["Kubelet"] --- F["Container Runtime"]
31        G["Kube-proxy"]
32        F --- H["Pod"]
33        F --- I["Pod"]
34    end
35~
36    subgraph "Worker Node 2"
37        J["Kubelet"] --- K["Container Runtime"]
38        L["Kube-proxy"]
39        K --- M["Pod"]
40    end
41~
42    A -- "Communicates with" --> E
43    A -- "Communicates with" --> J
44    User -- "kubectl" --> A
45    C -- "Assigns Pods to Nodes" --> E
46    D -- "Maintains state" --> A
47    A -- "Saves/Reads state" --> B
48```
49~
50### Control Plane
51~
52Control Plane är klustrets "hjärna". Dess huvudkomponenter:
53~
54-   **API Server (`kube-apiserver`)**: Porten till klustret. Exponerar Kubernetes API.
55-   **etcd**: En konsekvent nyckel-värde-databas som lagrar all klusterdata.
56-   **Scheduler (`kube-scheduler`)**: Tilldelar nya Pods till tillgängliga Worker Nodes.
57-   **Controller Manager (`kube-controller-manager`)**: Kör kontrollöglor som övervakar klustrets tillstånd.
58~
59### Worker Node
60~
61Worker Nodes är maskinerna där applikationerna faktiskt körs:
62~
63-   **Kubelet**: En agent som säkerställer att containrar körs och är friska.
64-   **Kube-proxy**: En nätverksproxy som hanterar nätverksregler.
65-   **Container Runtime**: Programvaran som kör containrar (Docker, `containerd`, `CRI-O`).
66~
67## Grundläggande Kubernetes-objekt
68~
69### Pod
70~
71**Pod** är den minsta exekveringsenheten. Den representerar en eller flera containrar som körs tillsammans.
72~
73### Deployment
74~
75En **Deployment** beskriver det önskade tillståndet för en grupp identiska Pods.
76~
77```yaml
78# nginx-deployment.yaml
79apiVersion: apps/v1
80kind: Deployment
81metadata:
82  name: nginx-deployment
83spec:
84  replicas: 3
85  selector:
86    matchLabels:
87      app: nginx
88  template:
89    metadata:
90      labels:
91        app: nginx
92    spec:
93      containers:
94      - name: nginx
95        image: nginx:1.14.2
96        ports:
97        - containerPort: 80
98```
99~
100### Service
101~
102En **Service** ger en **stabil åtkomstpunkt** för en grupp Pods.
103~
104```mermaid
105graph TD
106    subgraph "Service (nginx-service)"
107        A["ClusterIP: 10.96.0.10"]
108    end
109~
110    subgraph "Pods"
111        B("Pod 1 - IP: 192.168.1.2")
112        C("Pod 2 - IP: 192.168.1.3")
113        D("Pod 3 - IP: 192.168.1.4")
114    end
115~
116    A -- "Selector: app=nginx" --> B
117    A -- "Selector: app=nginx" --> C
118    A -- "Selector: app=nginx" --> D
119~
120    Client -- "Request to nginx-service" --> A
121```
122~
123```yaml
124# nginx-service.yaml
125apiVersion: v1
126kind: Service
127metadata:
128  name: nginx-service
129spec:
130  selector:
131    app: nginx
132  ports:
133    - protocol: TCP
134      port: 80
135      targetPort: 80
136  type: ClusterIP # Default - exposes the service only within the cluster
137```
138~
139Typer av Services:
140- `ClusterIP`: Exponerar tjänsten på ett kluster-internt IP (standard).
141- `NodePort`: Exponerar tjänsten på en statisk port på varje Worker Node.
142- `LoadBalancer`: Skapar en extern lastbalanserare hos molnleverantören.
143~
144### Ingress
145~
146En **Ingress** fungerar som en "intelligent router" för extern trafik.
147~
148```mermaid
149graph LR
150    User -- "mysite.com/api" --> Ingress
151    User -- "mysite.com/ui" --> Ingress
152~
153    subgraph "Cluster"
154        Ingress -- "/api" --> ServiceA("api-service")
155        Ingress -- "/ui" --> ServiceB("ui-service")
156~
157        ServiceA --> PodA1("API Pod 1")
158        ServiceA --> PodA2("API Pod 2")
159~
160        ServiceB --> PodB1("UI Pod 1")
161        ServiceB --> PodB2("UI Pod 2")
162    end
163```
164~
165```yaml
166# example-ingress.yaml
167apiVersion: networking.k8s.io/v1
168kind: Ingress
169metadata:
170  name: example-ingress
171spec:
172  rules:
173  - host: mysite.com
174    http:
175      paths:
176      - path: /api
177        pathType: Prefix
178        backend:
179          service:
180            name: api-service
181            port:
182              number: 8080
183      - path: /ui
184        pathType: Prefix
185        backend:
186          service:
187            name: ui-service
188            port:
189              number: 3000
190```
191~
192### Andra Användbara Objekt
193~
194-   **Namespace**: Skapar "virtuella kluster" inuti ett fysiskt kluster.
195-   **ConfigMap och Secret**: För att hantera konfigurationsdata och hemligheter.
196-   **StatefulSet**: Likt en Deployment, men specifikt för tillståndsbaserade applikationer.
197-   **PersistentVolume (PV) och PersistentVolumeClaim (PVC)**: För att hantera beständig lagring.
198~
199## Slutsats
200~
201Kubernetes är ett otroligt kraftfullt verktyg, men inlärningskurvan kan vara brant.
202~
203**Vad ska du göra nu?**
204- **Experimentera lokalt**: Installera [Minikube](https://minikube.sigs.k8s.io/docs/start/) eller [Kind](https://kind.sigs.k8s.io/docs/user/quick-start/).
205- **Använd `kubectl`**: Bekanta dig med `kubectl`-kommandot.
206- **Utforska officiella tutorials**: [Kubernetes-dokumentationen](https://kubernetes.io/docs/tutorials/) är en fantastisk resurs.
207~
208Containerorkestrering är en grundläggande färdighet i cloud-native-världen. Ha det kul!
209~