Kubernetes auf macOS: Einstieg

Kubernetes ist extrem mächtig - und genauso einschüchternd am Anfang.
Als ich erstmals damit gearbeitet habe, fehlte mir ein einfacher, strukturierter Einstieg auf meinem Dev-Rechner.
Dieser Guide ist das, was ich damals gebraucht hätte.

Voraussetzung: Du solltest bereits mit Docker vertraut sein und die Grundlagen verstehen.

Kubernetes lokal installieren

Es gibt viele Tools für lokales Kubernetes - minikube, k3s, k0s, k3d, etc.
Für macOS empfehle ich Orbstack, das native Kubernetes-Unterstützung bietet.

Warum Orbstack?
Orbstack konfiguriert Service DNS automatisch (<service>.<namespace>.svc.cluster.local), du musst also nicht /etc/hosts anfassen. Das macht Testing, Debugging und Entwicklung deutlich einfacher.

Nach der Installation startest du Kubernetes so:

1
$ orb start k8s

Falls orb nicht gefunden wird, prüfe deine Orbstack Installation.

Prüfe, ob Kubernetes läuft:

1
$ kubectl config get-contexts
2
CURRENT   NAME       CLUSTER    AUTHINFO   NAMESPACE
3
*         orbstack   orbstack   orbstack

Dein erstes Deployment

Wenn du Podman genutzt hast, kennst du Pods bereits.
In Kubernetes liegen Pods meist hinter einer höheren Abstraktion: Deployments.

In Docker startest du einen Container so:

1
$ docker run nginx

In Kubernetes beschreibst du Container in YAML und wendest die Konfiguration mit kubectl an.

Erstelle eine Datei example.yaml:

1
apiVersion: apps/v1
2
kind: Deployment
3
metadata:
4
  name: example-deployment # deployment name
5
spec:
6
  selector:
7
    matchLabels:
8
      app: example-pod # -----
9
  template: #    |
10
    metadata: #    |
11
      labels: #    |
12
        app: example-pod # <--
13
    spec:
14
      containers:
15
        - name: example-container
16
          image: nginx
17
          imagePullPolicy: Always
18
          ports:
19
            - containerPort: 80
20
---
21
apiVersion: v1
22
kind: Service
23
metadata:
24
  name: example-service
25
spec:
26
  selector:
27
    app: example-pod # selector which pod
28
  ports:
29
    - protocol: TCP
30
      port: 8080 # exposed port
31
      targetPort: 80 # container port

Konfiguration anwenden:

1
$ kubectl apply -f example.yaml
2
deployment.apps/example created
3
service/example-service created

Deployment-Status prüfen:

1
$ kubectl get deployments --watch
2
NAME      READY   UP-TO-DATE   AVAILABLE   AGE
3
example   1/1     1            1

Warte bis READY 1/1 zeigt.

Pods prüfen:

1
$ kubectl get pods --watch
2
NAME                       READY   STATUS    RESTARTS   AGE
3
example-54c9b4c747-v7mbj   1/1     Running   0          10s

Zugriff auf deine Anwendung

Dein Service ist jetzt erreichbar unter:

http://example-service.default.svc.cluster.local:8080/

Oder via Cluster IP:

1
$ kubectl get svc
2
NAME              TYPE        CLUSTER-IP        EXTERNAL-IP   PORT(S)    AGE
3
example-service   ClusterIP   192.168.194.207   <none>        8080/TCP   2s

Hinweis: Cluster IPs ändern sich nach Neustarts. DNS-Zugriff über Orbstack bleibt stabil.

Aufräumen

Ressourcen löschen:

1
$ kubectl delete -f example.yaml

Prüfen, ob Pods weg sind:

1
$ kubectl get pods
2
No resources found in default namespace.

Kubernetes Ebenen verstehen

Level 1: Docker - direkter Container

1
docker run nginx  →  [ Container ]

Single Container, direkt gestartet.

Level 2: Podman - Pod-basierte Gruppierung

1
$ podman pod create --name mypod             →  [ Pod ]
2
$ podman run --pod mypod -p 8080:80 nginx    →     ├─ [ Container ]
3
$ podman run --pod mypod redis               →     └─ [ Container ]

Mehrere Container teilen sich einen Network Namespace.

Level 3: Kubernetes - deklaratives Deployment

1
YAML (Deployment) → kubectl apply → [ Deployment ]
2
                                        └─ [ Pod ]
3
                                             ├─ [ Container ]
4
                                             └─ [ Container ]

Deklarative Infrastruktur, automatisches Skalieren und Healing.

Was ist ein Deployment?

Ein Deployment verwaltet Pods und stellt sicher, dass die gewünschte Anzahl an Replicas immer läuft.

Du kannst skalieren, indem du replicas: 2 in deine example.yaml einträgst:

1
---
2
spec:
3
  replicas: 2

Änderungen anwenden:

1
$ kubectl apply -f example.yaml

Pods listen:

1
$ kubectl get pods
2
NAME                                  READY   STATUS    RESTARTS   AGE
3
example-deployment-779f6bb7dc-nvvq7   1/1     Running   0          4s
4
example-deployment-779f6bb7dc-wlfzg   1/1     Running   0          4s

Kubernetes verteilt Traffic automatisch auf beide Instanzen.

Mehr zu Deployments.

Was ist ein Service?

Ein Service bietet einen stabilen Zugriff auf einen oder mehrere Pods.
Er vergibt eine Cluster IP (interne virtuelle IP) und einen DNS Namen (z.B. example-service.default.svc.cluster.local) im Cluster.

Wichtig ist der Unterschied zwischen k3d (oder ähnlichen Tools) und Orbstack:

k3d

k3d läuft Kubernetes in einem Docker Container.
Interne DNS Namen (*.svc.cluster.local) sind nur im Cluster auflösbar (zwischen Pods).
Dein Host (macOS) ist nicht Teil des Cluster-Netzwerks.
Daher kannst du example-service.default.svc.cluster.local nicht direkt vom Mac aus erreichen, ohne extra DNS Routing oder Port-Forwarding.
Übliche Workarounds:
- kubectl port-forward
- Services als NodePort
- Ingress Controller

Orbstack

Orbstack integriert den Host eng in das Cluster-Netzwerk.
Es konfiguriert DNS automatisch, sodass .svc.cluster.local Namen vom Mac auflösbar sind.
Du kannst http://example-service.default.svc.cluster.local:8080/ direkt im Browser öffnen, ohne Zusatzkonfiguration.
Das macht Entwicklung und Debugging deutlich einfacher.

Orbstack bietet eine viel bessere lokale Dev Experience, weil es Cluster- und Host-DNS automatisch bridged. k3d braucht zusätzliches Setup, wenn du Services vom Mac aus erreichen willst.

Mehr zu Services.

Fazit

Kubernetes auf macOS muss nicht schmerzhaft sein.

Mit Orbstack, ein paar YAML Files und kubectl bist du schnell startklar - und kannst dich ohne Reibung aufs Lernen konzentrieren.

Was kommt als Nächstes?

Jetzt wo Kubernetes lokal läuft und deine erste App deployed ist, hier ein paar nächste Schritte:

kubectl Commands erkunden
Lerne Pods, Services und Deployments zu inspizieren und Fehler mit kubectl describe, kubectl logs und kubectl exec zu debuggen.
In Helm eintauchen
Helm ist der Package Manager für Kubernetes. Startpunkt: Helm Quickstart Guide
Ingress Controller verstehen
Gehe über ClusterIP und NodePort hinaus und setze einen Ingress (z.B. Traefik oder NGINX) auf.
StatefulSets, Jobs und CronJobs lernen
Deploye Workloads mit persistentem Storage oder Zeitplanung - nicht alles passt in stateless Deployments.
Lokale CI/CD Pipelines bauen
Integriere Kubernetes mit lokalen GitOps Tools wie ArgoCD oder einfachen CI Pipelines, die automatisch deployen.
Community beitreten
Tausche dich in Kubernetes Communities aus (Slack, Discord, CNCF Meetups).