DevOps
DevOpsFortgeschritten

Apples native Container-Runtime & Kubernetes auf dem Mac: Der DevOps-Leitfaden zu container cluster

Praxisnaher DevOps-Leitfaden zu Apples Open-Source-Container-Runtime und experimenteller Kubernetes-Unterstützung auf Apple Silicon: Micro-VM-Architektur, alle CLI-Befehle, Cilium-CNI-Setup, Sicherheitsrisiken von --shared-image-store sowie der Vergleich mit Docker Desktop und OrbStack.

Titelbild: Apples native Container-Runtime & Kubernetes auf dem Mac: Der DevOps-Leitfaden zu container cluster
Inhalt

Apples Open-Source-Projekt apple/container startete als schlanke Swift-Runtime, um Linux-Container als leichtgewichtige Micro-VMs direkt auf Apple Silicon auszuführen. Mit container cluster (ursprünglich als container k8s gestartet und ab Release 1.6.1 zu container cluster umbenannt) liefert Apple nun native Kubernetes-Cluster auf macOS – ganz ohne Docker Desktop.

Viele Social-Media-Posts belassen es bei der Schlagzeile „Apple schafft Docker Desktop ab“. Für DevOps- und Platform-Teams steckt der eigentliche Mehrwert jedoch in den technischen Details: wie die Micro-VM-Topologie pro Node funktioniert, wie sich heterogene Worker und Cilium CNI konfigurieren lassen, warum Apple vor --shared-image-store warnt und welche Grenzen im Alltag noch gelten.

Apple Container & Kubernetes auf dem Mac Titelbild: Gefräster Aluminium-Sockel mit schwebenden blauen Container-Micro-VM-Würfeln und Kubernetes-Prisma im hellen Tageslichtstudio.

Das kurze DevOps-Fazit. container cluster ist schnell, nativ und sauber für ephemere Multi-Node-Tests, eigene CNI-Labs (wie Cilium) und Versions-Checks mit verschiedenen kindest/node-Images auf Apple Silicon + macOS 26+. Für langlebige lokale Umgebungen taugt es aber noch nicht: Gestoppte Cluster lassen sich nicht wieder aufnehmen, sondern müssen neu angelegt werden – und --shared-image-store gehört nicht in Cluster mit nicht vertrauenswürdigen Manifesten.

Wie sich Apples Architektur von Docker Desktop und Lima unterscheidet

Klassische Mac-Container-Tools (Docker Desktop, Colima, Lima, Rancher Desktop) starten eine einzige große Linux-VM und betreiben darin containerd oder Docker. Ein 3-Node-kind-Cluster schachtelt dann Kubernetes-Nodes als Container innerhalb derselben VM.

apple/container dreht dieses Prinzip über macOS’ natives Virtualization.framework und Apples Swift-Paket Containerization um (ähnlich der Micro-VM-Isolation aus unserem Vergleich microVMs: Firecracker vs. gVisor):

Architekturvergleich zwischen klassischem Docker Desktop + kind (eine gemeinsame Linux-VM) und Apples nativem apple/container cluster, bei dem jeder Kubernetes-Node als eigene isolierte Linux-Micro-VM über Virtualization.framework läuft.
  • Eigene Micro-VM pro Node (vminitd, kein Idle-RAM-Ballast): Control Plane und jeder Worker-Node starten mit Apples schlankem Swift-Init (vminitd) als isolierte Linux-Micro-VM direkt über Virtualization.framework – ohne QEMU, ohne Lima-Wrapper, ohne geteilten Kernel und ohne dauerhaft laufende Monolith-VM, die im Leerlauf 2–4 GB RAM blockiert.
  • Schutz vor versehentlichem container stop: Technisch ist jeder Node ein Container, doch container list blendet Cluster-Nodes selbst mit --all aus. container stop oder container delete auf einen Node-Namen melden „not found“, damit die Control Plane nicht aus Versehen abgeschossen wird. (Lese- und Debug-Befehle wie container logs, container exec, container inspect und container stats funktionieren weiterhin.)
  • Standard-kindest/node-Kompatibilität: Standardmäßig nutzt der Cluster kindest/node:v1.35.5 und schreibt den Kontext automatisch in ~/.kube/config, sodass kubectl, helm und k9s sofort funktionieren.

Voraussetzungen und Einrichtung (geprüfte Befehle)

Apple beschränkt apple/container ausdrücklich auf Macs mit Apple Silicon ab macOS 26 – Intel-Macs und ältere macOS-Releases werden nicht unterstützt, da neue Virtualisierungs- und Netzwerk-APIs von macOS 26 vorausgesetzt werden.

1. Installation und Start des Systemdienstes

Lade das signierte .pkg-Paket von der apple/container Release-Seite herunter, installiere es unter /usr/local und starte den Dienst:

Terminal window
container system start

2. Ersten Cluster starten

Terminal window
# Standard-Cluster anlegen (Name: "cluster-dev")
container cluster create
# Cluster-Status prüfen (--nodes zeigt einzelne Nodes)
container cluster list --nodes
# Automatisch eingetragenen kubectl-Kontext testen
kubectl --context cluster-dev get nodes -o wide

Ohne weitere Flags kombiniert der Standard-Node Control Plane und Worker und erhält 1/4 der Host-CPUs (mindestens 2) sowie 1/4 des Host-RAMs (mindestens 2 GB).

3. Multi-Node-Cluster mit unterschiedlich dimensionierten Workern

Für Platform-Engineers, die Taints, Pod-Scheduling oder Affinity realistisch testen wollen, ist --workers besonders praktisch. Sobald --workers > 0 gesetzt ist, taintet apple/container die Control Plane automatisch, sodass Pods nur auf Workern eingeplant werden:

Terminal window
# Control Plane (2 vCPU, 4 GB) + 2 große Worker + 1 kleiner Worker
container cluster create --name staging \
--cpus 2 --memory 4g \
--workers count=2,cpus=4,memory=8g \
--workers count=1,cpus=2,memory=4g
# Taints und Node-Größen prüfen
kubectl --context staging get nodes -o wide
# Cluster-Node direkt inspizieren (stop/delete sind blockiert, logs/stats/exec funktionieren)
container stats staging-worker-1
container logs staging-control-plane

Worker-Nodes heißen <cluster-name>-worker-<n> und übernehmen das --node-image der Control Plane. Für kurzlebige Wegwerf-Runs empfiehlt sich --rm (container cluster create --name temp --rm). Zudem pflegt Apple im offiziellen Repository ein Referenz-Setup für eine Three-Tier-App hinter einem Gateway (container-cluster-gateway).

4. Mehrere Kubernetes-Versionen parallel testen

Um Helm-Charts oder API-Deprecations gegen verschiedene Kubernetes-Releases zu prüfen, lässt sich --node-image pro Cluster überschreiben:

Terminal window
container cluster create --name k8s-134 --node-image docker.io/kindest/node:v1.34.11
container cluster create --name k8s-135 --node-image docker.io/kindest/node:v1.35.5
kubectl config get-contexts

kindnet durch Cilium CNI ersetzen

Standardmäßig installiert container cluster das einfache CNI kindnet. Wer in Produktion Cilium als CNI nutzt und eBPF-NetworkPolicies lokal testen möchte, kann über --cni ein eigenes Manifest übergeben.

Wichtiger Stolperstein: --cni erwartet eine fertige Kubernetes-YAML-Datei (kein Helm-Chart), und Ciliums Standard-IPAM (cluster-pool, 10.0.0.0/8) kollidiert mit den Pod-/Service-CIDRs von kubeadm. Deshalb muss das Chart vorab mit ipam.mode=kubernetes gerendert werden:

Terminal window
helm repo add cilium https://helm.cilium.io/
helm repo update
helm template cilium cilium/cilium \
--version 1.20.1 \
--namespace kube-system \
--set ipam.mode=kubernetes > cilium.yaml
container cluster create --name cilium-lab --cni ./cilium.yaml
kubectl --context cilium-lab get pods -n kube-system

Die --shared-image-store-Sicherheitsfalle

Ein oft genannter Vorteil von apple/container ist die direkte Nutzung lokal gebauter Images (container build) im Cluster – ohne Push in Docker Hub, GHCR oder eine lokale Registry.

Dafür muss beim Anlegen des Clusters explizit --shared-image-store gesetzt werden:

Terminal window
container cluster create --name dev --shared-image-store
container build -t my-service:dev .
kubectl --context dev run my-service --image=my-service:dev
Sicherheits- und Pull-Policy-Ablauf für –shared-image-store in apple/container: Im Standardmodus ziehen Nodes isoliert aus der Registry; mit shared-image-store können privilegierte oder hostPath-Pods alle privaten lokalen Images lesen und lokale Tags überschreiben Registry-Pulls ohne imagePullSecrets.

Aus gutem Grund ist diese Option standardmäßig deaktiviert. Apples Dokumentation nennt zwei kritische Risiken:

  1. Alle privaten lokalen Images werden für Root auf dem Node lesbar: Jeder privilegierte Pod oder Pod mit hostPath-Mount kann sämtliche Images in deinem lokalen Image-Store auslesen – inklusive privater Images, die zuvor mit Firmen-Credentials gepullt wurden.
  2. Lokale Tags übersteuern Registry-Pulls ohne Secrets: Existiert ein Image mit gleichem Namen im lokalen Store, zieht der Node immer zuerst das lokale Image – unabhängig von der imagePullPolicy und ohne Prüfung von imagePullSecrets.
  3. Tag-Wiederverwendung: Wird my-service:dev unter demselben Tag neu gebaut, behalten Nodes bei imagePullPolicy: IfNotPresent die alte Version. Entweder einen neuen Tag vergeben oder imagePullPolicy: Always setzen.

Faustregel: --shared-image-store nur in vertrauenswürdigen Inner-Loop-Clustern verwenden, in denen du jedes Manifest selbst kontrollierst.

Ehrlicher Vergleich: apple/container vs. OrbStack vs. Docker Desktop + kind vs. Lima

Wie schlägt sich apple/container im Vergleich zu den etablierten Mac-Werkzeugen (oder Rootless-Alternativen wie Podman)?

Ehrlicher Vergleich: apple/container vs. OrbStack vs. Docker Desktop + kind vs. Lima
Kriterium apple/container (cluster) OrbStack Docker Desktop + kind Lima / Colima
Isolationsmodell Eigene Micro-VM pro Kubernetes-Node (Virtualization.framework) Eine extrem schnelle Linux-VM Eine schwere Linux-VM + verschachtelte kind-Container Eine Linux-VM (VZ oder QEMU)
OS-Anforderung Apple Silicon + macOS 26+ macOS 12.3+ (Apple Silicon & Intel) macOS 12+ macOS 12+
Multi-Node & Sizing Nativ über --workers count=...,cpus=...,memory=... + Auto-Taint Single-Node-K8s Multi-Node über kind-Config Eine VM (Multi-Node über kind)
Eigenes CNI (Cilium) Nativ via --cni ./cilium.yaml Begrenzte Anpassung Über kind (disableDefaultCNI) Über k3s / kind
Stop / Resume (Persistenz) Nein (gestoppter Cluster muss gelöscht & neu erstellt werden) Ja (sofortiges Pausieren) Ja (übersteht Neustarts) Ja
Lizenz & Reifegrad Open Source (Apache 2.0) · Experimentell Kommerziell (privat kostenlos) · Ausgereift Kommerziell (kostenpflichtig >250 MA / >10 Mio. $) · Ausgereift Open Source (Apache 2.0 / MIT) · Ausgereift
DevOps-Vergleichsmatrix für lokales Kubernetes auf macOS: apple/container cluster gegen OrbStack, Docker Desktop + kind und Lima/Colima bei Isolation, Multi-Node, eigenem CNI, Persistenz und Lizenz.

Vier reale Einschränkungen vor dem Umstieg

  1. Kein Pause/Resume für Cluster: Nach container system stop, einem Reboot oder einem Stopp der Control Plane lässt sich ein Cluster nicht einfach fortsetzen – er muss per container cluster delete und container cluster create neu aufgebaut werden. Auch --rm-Cluster hinterlassen nach dem Stopp zunächst einen stopped-Eintrag bis zum Löschen oder Überschreiben.
  2. Experimenteller Status: Apple garantiert für container cluster noch keine CLI-Abwärtskompatibilität über Major-Releases hinweg (wie bereits die Umbenennung von container k8s zu container cluster in Version 1.6.1 zeigte).
  3. Harte Grenze macOS 26+: Gemischte Teams mit Intel-Macs oder älteren macOS-Versionen können apple/container noch nicht als einheitlichen Standard ausrollen.
  4. Kein eingebauter LoadBalancer / Ingress (und kein natives Compose): Wie bei reinem kind stehen zunächst nur Cluster, DNS und kindnet (bzw. das eigene --cni) bereit – für LoadBalancer-Services oder Ingress braucht es weiterhin Tools wie Envoy Gateway, ingress-nginx oder Community-Wrapper wie kiac. Ebenso fehlt außerhalb von Kubernetes ein eingebautes docker compose-Äquivalent (nötig sind Drittanbieter-Wrapper wie container-compose).

Was Entwickler in der Praxis berichten

In Erfahrungsberichten auf Reddit (r/MacOS, r/kubernetes, r/docker), Dev.to und Substack zeichnen frühe Nutzer ein sehr klares Bild zwischen Begeisterung und typischen V1-Kanten:

  • Was gelobt wird: Wegfall der Docker-Desktop-Lizenzkosten und der schweren Dauer-VM, schnelle Bootzeiten auf Apple Silicon, saubere Kernel-Isolation pro Node sowie das schnelle Wachstum von Community-Projekten wie kiac (Multi-Node-k3s/kubeadm mit Cilium eBPF und LoadBalancer) und rke2-silicon.
  • Was im Alltag stört: Eigenheiten beim Host-Container-Netzwerk und Dateisystem-Mounts im Vergleich zum extrem runden OrbStack, fehlendes Pause/Resume nach einem Neustart sowie CLI-Umbrüche im experimentellen Stadium (wie die Umbenennung von container k8s zu container cluster in 1.6.1).

Wann sich der Einsatz jetzt schon lohnt

  • Ideal für: schnelle, wegzwerfbare Multi-Node-Tests auf Apple Silicon, Kubernetes-Versionsvergleiche (v1.34 vs. v1.35), Cilium-CNI-Labs und Inner-Loop-Entwicklung ohne Docker-Desktop-Lizenzkosten.
  • Noch bei OrbStack oder Colima + kind bleiben, wenn lokale Cluster Neustarts überdauern müssen, das Team noch auf älteren macOS-Versionen/Intel arbeitet oder stabile Compose- und K8s-Workflows ohne experimentelle CLI-Änderungen Pflicht sind.

Häufig gestellte Fragen

Ersetzt apple/container Docker Desktop für Kubernetes auf dem Mac vollständig?

Für zustandslose lokale Cluster-Tests, Helm-Chart-Validierung und CNI-Experimente auf Apple Silicon ab macOS 26 ja – container cluster erzeugt Single- und Multi-Node-Cluster direkt auf Virtualization.framework samt automatischem kubectl-Kontext. Da das Feature noch experimentell ist und kein Pause/Resume unterstützt, bleiben OrbStack, kind oder Lima für persistente Umgebungen und ältere macOS-Versionen relevant.

Welche Systemvoraussetzungen gelten für container cluster?

Erforderlich ist ein Mac mit Apple Silicon und macOS 26 oder neuer. Apple weist explizit darauf hin, dass Intel-Macs und ältere macOS-Versionen nicht unterstützt werden.

Wie nutze ich lokal gebaute Images ohne Registry-Push?

Erstelle den Cluster mit --shared-image-store (container cluster create --shared-image-store), baue das Image mit container build -t my-app:dev . und referenziere my-app:dev im Pod. Bei gleichem Tag nach einem Rebuild ist ein neuer Tag oder imagePullPolicy: Always nötig.

Kann ich Cilium statt des Standard-CNI kindnet verwenden?

Ja. Rendere Cilium zuerst als einfaches YAML-Manifest mit helm template cilium cilium/cilium --namespace kube-system --set ipam.mode=kubernetes > cilium.yaml und übergib --cni ./cilium.yaml an container cluster create.

Was passiert beim Stoppen von container system oder einem Mac-Neustart?

Gestoppte Cluster lassen sich aktuell nicht fortsetzen. Laut Apples Dokumentation muss nach einem Stopp der Control Plane container cluster delete und anschließend container cluster create ausgeführt werden.

ENDE