---
title: "Apples native Container-Runtime & Kubernetes auf dem Mac: Der DevOps-Leitfaden zu container cluster"
description: "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."
author: Aleksei Aleinikov
date: 2026-11-19
lang: de
tags: [apple container kubernetes, container cluster create, apple container vs docker desktop, kubernetes auf mac apple silicon, apple container cilium, shared-image-store, virtualization framework kubernetes]
canonical: https://www.alekseialeinikov.com/de/blog/topics/devops/apple-container-kubernetes-mac-cluster-anleitung
source: alekseialeinikov.com
---

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

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.](https://media.alekseialeinikov.com/devops/e91b4c7a2d5f/cover-1200.ff9f8c7bf4b87c6e.webp)

> [!NOTE]
> **Gegen die offizielle Quelle geprüft.** Alle CLI-Befehle, Flags (`container cluster`, `--workers`, `--shared-image-store`, `--cni`, `--node-image`), Standard-Ressourcenformeln und Sicherheitshinweise stammen direkt aus [Apples offiziellem `apple/container`-Repository](https://github.com/apple/container/blob/main/docs/cluster.md) und den Release Notes (aktuell Version `1.7.1`).

> [!KEY]
> **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](https://www.alekseialeinikov.com/de/blog/topics/devops/microvms-firecracker-vs-gvisor-sichere-workloads-2026)):

![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.](https://media.alekseialeinikov.com/devops/e91b4c7a2d5f/apple-container-k8s-architecture-1200.6594b63de3eaf9f8.webp)

- **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](https://github.com/apple/container/releases) herunter, installiere es unter `/usr/local` und starte den Dienst:

```bash
container system start
```

### 2. Ersten Cluster starten

```bash
# 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:

```bash
# 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`](https://github.com/apple/container-examples/tree/main/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:

```bash
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](https://www.alekseialeinikov.com/de/blog/topics/devops/cilium-vs-calico-kubernetes-cni-vergleich) 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:

```bash
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:

```bash
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.](https://media.alekseialeinikov.com/devops/e91b4c7a2d5f/apple-container-shared-store-security-1200.6c4237c4dfba67de.webp)

**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](https://www.alekseialeinikov.com/de/blog/topics/devops/podman-2026-rootless-daemonlose-container-ohne-docker))?

| 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.](https://media.alekseialeinikov.com/devops/e91b4c7a2d5f/apple-container-k8s-comparison-1200.7290b6f45146df66.webp)

## 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.
