Arcane Docker installieren: Self-Hosted-Container-Manager

Ich betreibe Arcane inzwischen seit Monaten auf meinen Servern. Es hat Portainer ersetzt, und ich habe nicht zurückgeschaut. Das Ganze läuft auf Go – das heißt: schnell, sparsam mit Speicher und ohne komplizierte Runtime. Wenn du es einfach nur laufen lassen willst, deckt diese Arcane-Docker-Installationsanleitung alles ab, von der Basisinstallation bis zur Socket-Proxy-Absicherung.

Wenn du einen Vergleich mit einem anderen neueren Docker-Manager suchst, schau dir meinen Artikel Arcane vs. Dockhand an.

Diese Anleitung wurde am 2026-10-26 für Arcane 2.17 aktualisiert. Neu seit der letzten Revision: natives Podman, OpenTelemetry, Auto-Update-Verzögerungen, Registry-Browsing und Mobile-Apps. Eine v3-Beta existiert auf Docker Hub. Bleib für Produktion auf v2-Tags. Wenn du einer älteren Version dieser Anleitung gefolgt bist: Das Image ist von ghcr.io/getarcaneapp/arcane nach ghcr.io/getarcaneapp/manager umgezogen, JWT_SECRET ist weg, und der Headless-Agent heißt jetzt arcane-agent. Details unten.

Was Arcane macht

Arcane ist eine webbasierte Docker-Verwaltungs-UI und eine Alternative zu Portainer. Du bekommst Container-Verwaltung, Compose-Stack-Bearbeitung, Echtzeit-Logs, ein Web-Terminal und GitOps – alles in einer einzigen Self-Hosted-Container-Manager-Oberfläche. Es läuft als einzelner Container.

Die Dauer-Features, die mich zum Wechsel gebracht haben:

Neu seit 2.12 (der Release-Zug ist schnell, 110 Releases bisher):

Das Projekt steht bei 8.071 GitHub-Stars mit 344 Forks und ~95 Contributors und hat 110 Releases seit Erstellung des aktuellen Repos im April 2025 geshipt. Das Tempo ist echt.

Registry-Wahl: Die Docs nutzen ghcr.io/getarcaneapp/manager, und sowohl getarcaneapp/manager auf Docker Hub als auch quay.io/getarcaneapp/manager sind offiziell. Such dir eins aus und pinne einen Versions-Tag (ich pinne v2; mehr dazu im Install-Abschnitt).

Voraussetzungen

Bevor du anfängst, brauchst du:

Kostencheck: Ein 4–6-€/Monat-VPS fährt Arcane plus einen kleinen Stack locker. Ich empfehle Hetzner und Hostinger für VPS-Hosting.

VPS-Preise sind 2026 überall gestiegen. Wenn du eine gemietete Kiste überdenkst: Was sich geändert hat und wann ein Mini-PC gewinnt.

Oder betreib es zu Hause. Siehe den Guide Mini-PC als Home Server. Ich mag die ASUS-Mini-PC-Hardwareklasse dafür: leise, wenig Strom, genug RAM für Docker plus ein Dutzend Services.

Docker installieren

Wenn du Docker noch nicht hast, nutze Dockers Convenience-Skript. Es erkennt die Distro und richtet das richtige Repo ein:

curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
# log out and back in for the group to apply

Verifiziere sowohl die Engine als auch das Compose-Plugin:

docker version
docker compose version

„Kaputt” sieht aus wie permission denied while trying to connect to the Docker daemon socket. Das heißt, die Gruppenmitgliedschaft ist noch nicht aktiv geworden. Neu einloggen – nicht ewig mit sudo dagegen ankämpfen. Kompletter Walkthrough: Docker & Docker-Compose für Ubuntu installieren.

Arcane mit Docker Compose installieren

Es gibt zwei Wege, Arcane zu installieren. Das Convenience-Skript ist am schnellsten, aber ich bevorzuge die Compose-Methode, weil du genau siehst und kontrollierst, was passiert.

Schnellinstallation (Convenience-Skript)

Wenn du in 30 Sekunden laufen willst:

curl -fsSL https://getarcane.app/install.sh | sudo bash

Prüfen:

systemctl status arcane

Dann http://deine-server-ip:3552 öffnen. Zum späteren Entfernen gibt es einen Uninstaller. Er ist interaktiv, und --force --remove-all nimmt Docker gleich mit – also die Prompts lesen:

curl -fsSL https://getarcane.app/uninstall.sh | sudo bash

Docker-Compose-Installation (empfohlen)

Erstelle zuerst ein Verzeichnis für Arcane:

mkdir -p /opt/arcane
cd /opt/arcane

Generiere den ENCRYPTION_KEY:

openssl rand -hex 32

Offizielle Alternativen, falls du Arcanes eigenen Generator bevorzugst:

docker run --rm ghcr.io/getarcaneapp/manager:latest /app/arcane generate secret
# or: arcane-cli generate secret

Jetzt deine compose.yaml erstellen:

services:
  arcane:
    image: ghcr.io/getarcaneapp/manager:v2
    container_name: arcane
    ports:
      - "3552:3552"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - arcane-data:/app/data
      - /opt/stacks:/opt/stacks
    environment:
      - APP_URL=http://localhost:3552
      - PUID=1000
      - PGID=1000
      - ENCRYPTION_KEY=your-generated-encryption-key
      - PROJECTS_DIRECTORY=/opt/stacks
      - TZ=Europe/Bucharest
    cgroup: host
    healthcheck:
      test: ["CMD", "./arcane", "health", "--timeout", "2s"]
      interval: 10s
      timeout: 3s
      retries: 5
      start_period: 15s
    restart: unless-stopped
    stop_grace_period: 15s
volumes:
  arcane-data:

Ersetze ENCRYPTION_KEY durch den Wert, den du generiert hast. Setze APP_URL auf deine tatsächliche Server-Adresse, wenn du remote zugreifst. Die Zeile cgroup: host lässt Arcane seine eigene Container-ID erkennen – wichtig für Self-Upgrades.

Ein paar Notizen zu dieser Datei:

• Pinne den Image-Tag. :v2 beschert dir Patch-Releases auf der 2.x-Linie. :latest kann dich an einem Montagmorgen überraschen. Rollback ist der umgekehrte Weg: den vorherigen Tag neu pinnen (v2.16.1 oder was immer du hattest), dann docker compose pull && docker compose up -d. Siehe wie man einen Container mit Docker Compose aktualisiert für den kompletten Tanz.
• Die Zeilen healthcheck und stop_grace_period: 15s stammen aus den offiziellen Beispielen. Der Healthcheck gibt depends_on etwas Echtes, worauf es warten kann, sobald du einen Socket-Proxy hinzufügst.
• Optionale Mounts: /builds für Arcanes Build Workspace (Image-Builds) und /backups für exportierte Backups. Füg sie hinzu, wenn du die Features nutzt.
• Secrets: Jede sensible Variable unterstützt das _FILE-Suffix, falls du lieber aus einer gemounteten Datei lesen willst statt Werte inline zu übergeben. Siehe Docker-Compose-Secrets für Muster, die mit Compose funktionieren.

Starten:

docker compose up -d

Die Installation verifizieren

Nicht überspringen. Zwei Minuten hier ersparen später eine Debug-Session.

Wenn der Container in einer Schleife neu startet, ist das Erste, was du prüfst, ENCRYPTION_KEY. Ein leerer oder malformed Wert ist der übliche Übeltäter. Wenn auf 3552 gar nichts lauscht, prüfe die Firewall oder die Security Group deines Providers, bevor du Arcane die Schuld gibst. Beide Fälle sind im Troubleshooting am Ende abgedeckt.

Härtung: Docker-Socket-Proxy

Den Docker-Socket direkt zu mounten, gibt Arcane volle Kontrolle über deinen Docker-Daemon. Das ist ein Sicherheitsrisiko. Wird Arcane irgendwie kompromittiert, hat ein Angreifer Root-äquivalenten Zugriff auf deinen Host. Der Socket ist eine Root-Level-API, verkleidet als Unix-Datei.

Der Fix ist ein Socket-Proxy, der filtert, welche Docker-API-Calls Arcane machen darf. Die Form:

Arcanes Docs empfehlen jetzt wollomatic/socket-proxy als Default. Das ist es, was der offizielle Instance Generator produziert. Wenn du Tecnativas docker-socket-proxy schon fährst, behalte ihn; die korrigierte Allowlist steht in Option 2. Für neue Setups nimm Option 1.

Option 1: wollomatic Socket-Proxy (empfohlen)

Der Generator schreibt diese Datei für dich. Hier die Form, damit du weißt, was du deployst:

services:
  arcane:
    image: ghcr.io/getarcaneapp/manager:v2
    container_name: arcane
    ports:
      - "3552:3552"
    volumes:
      - arcane-data:/app/data
      - /opt/stacks:/opt/stacks
    environment:
      - APP_URL=https://arcane.yourdomain.com
      - PUID=1000
      - PGID=1000
      - ENCRYPTION_KEY=your-generated-encryption-key
      - PROJECTS_DIRECTORY=/opt/stacks
      - TZ=Europe/Bucharest
      - DOCKER_HOST=tcp://docker-socket-proxy:2375
    cgroup: host
    depends_on:
      docker-socket-proxy:
        condition: service_healthy
    networks:
      - arcane-net
    restart: unless-stopped
    stop_grace_period: 15s

  docker-socket-proxy:
    image: wollomatic/socket-proxy:1.13.1
    container_name: arcane-docker-proxy
    user: "0:0"
    command:
      - "-listenip=0.0.0.0"
      - "-allowfrom=arcane,arcane-upgrader"
      - "-allowhealthcheck"
      # method+path allow rules (allowGET/allowPOST/allowPUT/allowDELETE)
      # go here. See the note below before starting this
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    read_only: true
    cap_drop: [ALL]
    security_opt: ["no-new-privileges:true"]
    healthcheck:
      test: ["CMD", "./healthcheck"]
      interval: 2s
      timeout: 5s
      retries: 15
    networks:
      - arcane-net
    restart: unless-stopped

networks:
  arcane-net:
    driver: bridge

volumes:
  arcane-data:

Zu den Allow-Regeln: wollomatic ist deny-by-default, ohne sie kann Arcane also nichts. Die Regeln sind method+path-Paare, die als Flags übergeben werden (Syntax-Form: -allowGET=/v1.*/containers/*). Die komplette aktuelle Liste ist versionsspezifisch und lebt in Arcanes Socket-Proxy-Docs. Der Instance Generator schreibt den kompletten Command-Block für dich. Nutze eine dieser beiden Quellen statt einer aus einem Blogpost kopierten Liste (diesem hier eingeschlossen).

Drei Dinge, die in dieser Config zählen:

• -allowfrom=arcane,arcane-upgrader braucht beide Namen. arcane-upgrader ist der Alias, den Arcanes Self-Upgrade-Helfer nutzen.
• Der Socket ist :ro gemountet, und der Proxy-Container läuft read_only mit allen Capabilities gedroppt und no-new-privileges. Der Proxy ist der einzige Container, der den Socket anfasst; Arcane spricht über das interne Bridge-Netzwerk mit ihm.
• DOCKER_HOST=tcp://docker-socket-proxy:2375 auf der Arcane-Seite ist der ganze Schalter: Arcane mountet den Socket selbst nie.

Verifiziere, dass der Schalter funktioniert hat:

docker compose ps          # proxy shows healthy
docker compose logs arcane # no Docker API errors in the UI's log stream

Dann durch die UI klicken: Container-Liste lädt, Logs streamen, Terminal öffnet sich. Jedes davon ist ein API-Pfad, den die Allowlist erlauben muss. Wenn etwas vor dem Schalter funktionierte und danach nicht mehr, fehlt dir eine Allow-Regel.

Option 2: Tecnativa docker-socket-proxy

Nutze das nur, wenn du Tecnativa schon anderswo auf dem Host fährst. Die Allowlist unten ist die aktuelle aus Arcanes Docs (DISTRIBUTION und SYSTEM wurden im Doc-Update 2.13.1 auf 1 gedreht):

services:
  arcane:
    image: ghcr.io/getarcaneapp/manager:v2
    container_name: arcane
    ports:
      - "3552:3552"
    volumes:
      - arcane-data:/app/data
      - /opt/stacks:/opt/stacks
    environment:
      - APP_URL=https://arcane.yourdomain.com
      - PUID=1000
      - PGID=1000
      - ENCRYPTION_KEY=your-generated-encryption-key
      - PROJECTS_DIRECTORY=/opt/stacks
      - DOCKER_HOST=tcp://docker-socket-proxy:2375
    cgroup: host
    depends_on:
      - docker-socket-proxy
    networks:
      - arcane-net
    restart: unless-stopped

  docker-socket-proxy:
    image: tecnativa/docker-socket-proxy:latest
    container_name: arcane-socket-proxy
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      - EVENTS=1
      - PING=1
      - VERSION=1
      - POST=1
      - AUTH=0
      - SECRETS=0
      - BUILD=0
      - COMMIT=0
      - CONFIGS=0
      - CONTAINERS=1
      - DISTRIBUTION=1
      - EXEC=1
      - IMAGES=1
      - INFO=1
      - NETWORKS=1
      - NODES=0
      - PLUGINS=0
      - SERVICES=0
      - SESSION=0
      - SWARM=0
      - SYSTEM=1
      - TASKS=0
      - VOLUMES=1
    networks:
      - arcane-net
    security_opt:
      - no-new-privileges:true
    restart: unless-stopped

networks:
  arcane-net:
    driver: bridge

volumes:
  arcane-data:

Arcane mountet den Docker-Socket nicht mehr direkt. Es verbindet sich über DOCKER_HOST=tcp://docker-socket-proxy:2375 mit dem Proxy. Der Socket ist auf dem Proxy read-only gemountet, und beide Container sitzen in einem internen Bridge-Netzwerk.

Die Flags steuern, welche Docker-API-Endpunktgruppen erreichbar sind. Dieses Set ist das, was Arcanes Docs aktuell empfehlen, mit Swarm, Auth und Secrets aus. Wenn du Arcanes Swarm-Lesezugriff nutzt, drehe SWARM, SERVICES, TASKS und NODES auf 1. Behalte AUTH=0 und SECRETS=0, außer du hast einen konkreten Grund dagegen.

OIDC/SSO einrichten

Wenn du schon einen Identity Provider wie Authentik, Keycloak oder Authelia fährst, kannst du Arcane für Single Sign-On anbinden.

https://your-arcane-url/auth/oidc/callback

environment:
  - OIDC_ENABLED=true
  - OIDC_CLIENT_ID=your-client-id
  - OIDC_CLIENT_SECRET=your-client-secret
  - OIDC_ISSUER_URL=https://your-idp.example.com
  - OIDC_SCOPES=openid email profile groups
  - OIDC_GROUPS_CLAIM=groups
  - OIDC_ROLE_MAPPINGS=[{"claimValue":"arcane-admins","roleId":"role_admin"}]

Sobald die Grundlagen laufen, sind das die Variablen, die man kennen sollte:

• OIDC_AUTO_REDIRECT_TO_PROVIDER=true überspringt das lokale Login-Formular komplett. Bevor du es umdrehst, bestätige, dass die Notfall-Login-Seite https://your-arcane-url/login/backup funktioniert. Das ist dein Notausgang, wenn der IdP ausfällt.
• OIDC_MERGE_ACCOUNTS verknüpft eine OIDC-Identität per E-Mail mit einem bestehenden lokalen Account. Seit 2.16.0 erfordert der Merge eine verifizierte E-Mail vom Provider – genau das Verhalten, das du willst.
• OIDC_SKIP_TLS_VERIFY existiert für Lab-IdPs mit self-signed Certs. Nicht in Produktion setzen.
• Provider-Name-/Logo-Variablen und manuelle Endpoint-Overrides sind für Nicht-Discovery-Provider verfügbar.

Verifizieren: Einmal über den IdP einloggen, bestätigen, dass der User mit der richtigen Rolle in Arcane landet – und erst dann (und wirklich erst dann) überlegen, den lokalen Login zu deaktivieren.

Reverse-Proxy-Setup

Du willst einen Reverse Proxy vor Arcane für SSL und einen sauberen Domainnamen. Arcane nutzt WebSockets für Echtzeit-Updates, deine Proxy-Config muss das also unterstützen.

server {
    listen 443 ssl http2;
    server_name arcane.yourdomain.com;

    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;

    location / {
        proxy_pass http://127.0.0.1:3552;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

labels:
  - "traefik.enable=true"
  - "traefik.http.routers.arcane.rule=Host(`arcane.yourdomain.com`)"
  - "traefik.http.routers.arcane.entrypoints=websecure"
  - "traefik.http.routers.arcane.tls.certresolver=letsencrypt"
  - "traefik.http.services.arcane.loadbalancer.server.port=3552"

# Traefik static/command config: entrypoint level, not router level
- "--entrypoints.websecure.transport.respondingtimeouts.readtimeout=0s"

Aktualisiere die APP_URL-Umgebungsvariable in deiner Compose-Datei auf deine tatsächliche Domain (z. B. https://arcane.yourdomain.com, ohne :3552; der Proxy terminiert den Port).

Wenn du den Reverse Proxy lieber komplett überspringen willst, kann Arcane TLS selbst ausliefern: setze TLS_ENABLED=true, TLS_CERT_FILE und TLS_KEY_FILE. Es spricht HTTP/2 über TLS direkt. Okay fürs Lab; ich bevorzuge trotzdem einen Proxy davor.

Remote-Hosts verwalten

Arcane kann Docker auf anderen Maschinen über den Arcane-Agent verwalten. Praktisch, wenn du mehrere Server hast, aber ein Dashboard willst. Wenn du eine ältere Version dieses Stacks installiert hast: Der Agent hieß früher arcane-headless; das aktuelle Image ist ghcr.io/getarcaneapp/agent, und die Binary heißt arcane-agent. Aktualisiere alte Compose-Dateien auf die neuen Namen.

Es gibt zwei Verbindungsmodi:

Direct heißt, der Manager erreicht den Agent auf TCP-Port 3553. Edge heißt, der Agent wählt sich über einen mTLS-Tunnel beim Manager ein – der Remote-Host braucht also keinen offenen Inbound-Port. Edge ist der Modus, den du für alles hinter NAT oder einer Firewall willst. Das mTLS-Setup ist in Arcanes Edge-mTLS-Docs dokumentiert.

In beiden Fällen erstelle zuerst das Environment: Öffne Environments → Add Environment in der Arcane-UI, wähle Direct oder Edge, und es generiert den Token plus ein startfertiges Snippet für dich. Die Edge-Compose sieht so aus:

services:
  arcane-edge-agent:
    image: ghcr.io/getarcaneapp/agent:v2
    container_name: arcane-edge-agent
    environment:
      - EDGE_AGENT=true
      - EDGE_TRANSPORT=poll
      - AGENT_TOKEN=arc_your-generated-token
      - MANAGER_API_URL=https://arcane.yourdomain.com
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - agent-data:/app/data
    cgroup: host
    restart: unless-stopped
    stop_grace_period: 15s
volumes:
  agent-data:

EDGE_TRANSPORT-Optionen:

Auf Poll-Environments siehst du die Status Online / Standby / Pending / Offline in der Verbindungsansicht. Standby heißt gesund: Der Agent idled und wartet auf den nächsten Poll, er ist nicht down. Die erste Aktion gegen ein Idle-Poll-Environment kann einen Moment dauern, während die Verbindung aufwacht. Stelle die Erwartungen richtig ein, bevor du annimmst, es sei kaputt.

Der Agent kann auch als Standalone-Binary laufen, wenn du auf dem Remote-Host keinen Container willst.

Ein Ops-Detail gegen Verwirrung: Es gibt zwei verschiedene „Update All”-Buttons. Updates → Update All aktualisiert Container und Projekte. Environments → Update All aktualisiert erst die Agents, dann den Manager. Flotten-Upgrades sind ein einzelner Klick statt einer Per-Host-Pflicht.

Arcane auf Podman betreiben

Neu in 2.17.0 (21. Oktober 2026): Arcane verwaltet Podman nativ. Wenn deine Hosts Podman statt Docker fahren, ist dies das erste Release, in dem der Support echt statt experimentell ist.

Das Repo liefert die Beispiele: compose.podman-rootful.yaml, compose.podman-rootless.yaml und Quadlet-Dateien unter docker/examples/quadlet/. Die praktischen Unterschiede zur Docker-Installation sind der Socket-Pfad (Podmans Socket, rootless vs. rootful) und das Rootless-Permission-Modell. Es gibt außerdem eine eigene Docs-Sektion (docs/podman/) für Quadlets, Kube, Secrets und Auto-Update.

Dieser Support ist zum Schreiben Wochen alt. Ich würde ihn jetzt auf einem Lab-Host einsetzen und ein paar Release-Zyklen warten, bevor ich eine Produktiv-Podman-Flotte drauf ziehe. Wenn du bei der Container-Engine selbst noch am Entscheiden bist: Wie Podman im Vergleich zu Docker abschneidet.

Umgebungsvariablen-Referenz

Das sind die Variablen, nach denen ich am häufigsten greife. Für das Gesamtbild, wie Docker Config in Container reicht: Wie Docker-Umgebungsvariablen funktionieren.

JWT_SECRET taucht weiterhin in alten Docs und Compose-Dateien auf, ist aber in 2.x ungenutzt. Nicht setzen. GPU-Monitoring-Variablen (GPU_MONITORING_ENABLED, GPU_TYPE) tauchen in manchen älteren Guides auf, fehlen aber in der aktuellen .env.example. Prüfe die Environment-Variables-Doku deiner Version, bevor du dich darauf verlässt.

Troubleshooting

volumes:
  - /opt/stacks:/opt/stacks

environment:
  - PROJECTS_DIRECTORY=/app/data/projects:/opt/stacks

proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";

docker compose up -d --force-recreate docker-socket-proxy

Was ich mag und was fehlt

Ich betreibe Arcane inzwischen lange genug, um Meinungen zu haben.

Die GitOps-Integration ist das Feature, das ich am meisten nutze. Ich halte meine Compose-Dateien in einem privaten Git-Repo, und wenn ich Änderungen pushe, pickt Arcane sie auf und deployt neu. Keine Webhook-Config, keine CI-Pipeline nötig.

Die REST-API ist das andere, auf das ich mich stütze. Ich habe ein kleines Skript geschrieben, das Container-Health prüft und alles Unhealthy neu startet. Hat etwa 20 Minuten gedauert, weil die API geradlinig ist.

Die Lücken, über die ich mich in der ersten Version dieser Anleitung beschwert habe, sind größtenteils geschlossen: Trivy-Scanning, geplante Auto-Updates und Backups kamen alle in den Releases 2.9 bis 2.12, und 2.14 bis 2.17 brachten den Prozesse-Tab, eine risikobasierte Security-Ansicht und Registry-Browsing. Die neue Update Delay ist der Teil, den ich für alles Internet-facing aktivieren würde. Sie ist eine Supply-Chain-Abkühlphase, damit ein frisch veröffentlichter bösartiger Tag nicht in der Sekunde gepullt wird, in der er erscheint:

x-arcane:
  updater:
    delay: 72          # project default, hours
services:
  cache:
    image: redis:7
    x-arcane:
      updater:
        delay: 0       # opt a service out of the cool-down
# or label: com.getarcaneapp.arcane.updater.delay=72

Was mit Stand v2.17.1 noch fehlt: Dockhand-artiges Scan-before-Swap-Gating, bei dem ein Update nur durchläuft, wenn das neue Image sauber scannt (zum Schreibzeitpunkt nicht in den Docs), und ein richtiger Datei-Browser innerhalb von Containern. Keins davon ist ein Dealbreaker, aber beide würden Arcane angenehmer machen. Wenn Auto-Updates generell dein Ding sind, ist Tugtainers Auto-Update-Ansatz ebenfalls lesenswert.

Wenn du diese konkreten Features heute willst, schau dir wie man Dockhand installiert an. Und für das breitere Feld: Mein Portainer-Alternativen-Vergleich deckt Sencho, Dockge, Komodo und den Rest ab.

Verwandte Artikel

• Beste Portainer-Alternativen 2026 – der komplette Vergleich der Docker-Verwaltungs-UIs
• Arcane vs. Dockhand – der direkte Vergleich beider Tools
• Dockhand installieren – der andere Docker-Manager, der sich lohnt
• Dockge installieren – eine weitere Docker-Verwaltungs-UI
• UsulNet, eine All-in-one-Container-Management-Plattform – eine andere Sicht aufs Docker-Dashboard
• Beste Docker-Container für den Home Server – was du laufen lässt, sobald dein Manager steht
• Beste Self-Hosted-Panels – Server-Verwaltungspanels im Vergleich
• Traefik-Reverse-Proxy für Docker – sauberes Reverse-Proxy-Setup
• Docker-Auto-Update mit Tugtainer – Container aktuell halten
• Server-Monitoring-Tools – deinen Docker-Host überwachen