← Back to Blog

Self-Host Your Docker Infrastructure with Arcane — A Modern Docker Management UI

Self-Host Your Docker Infrastructure with Arcane — A Modern Docker Management UI

Managing Docker containers from the command line is powerful, but as your homelab grows — with dozens of containers, networks, volumes, and compose stacks — you start wishing for a visual dashboard. Enter Arcane: a modern, self-hosted Docker management UI built with a SvelteKit frontend and a Go backend.

Arcane (5,400+ ⭐ on GitHub) is designed to be the open-source alternative to Portainer that feels modern, fast, and developer-friendly. It supports container management, compose stacks, image management, volume browsing, Git-based deployments, Docker Swarm, and even agent-based remote host management — all from a beautiful dark-themed dashboard.

Why Arcane Is Trending

The self-hosted ecosystem has long relied on Portainer for Docker management, but Arcane brings a fresh perspective:

  • Modern tech stack — SvelteKit frontend (same stack as this blog!), Go backend, SQLite (via Turso/LibSQL)
  • Beautiful UI — Dark theme, clean layout, responsive design
  • GitOps-ready — Deploy compose stacks directly from Git repositories with automatic sync
  • Docker Swarm support — Manage Swarm stacks and services alongside regular containers
  • Agent mode — Remotely manage multiple Docker hosts via a lightweight agent
  • Security-first — Supports Docker Socket Proxy for secure socket access, JWT auth, encryption keys
  • Active development — v1.18.x with releases every few weeks, 50+ contributors

Architecture Overview

Arcane Architecture

Arcane follows a clean client-server architecture. The Go backend serves as the API gateway, interacting directly with the Docker daemon via its socket (or a TCP proxy). It maintains its own SQLite database for user accounts, preferences, and project configurations. The SvelteKit frontend communicates with the backend through a REST API, providing the management dashboard in your browser. For multi-host setups, Arcane Agents can be deployed on remote Docker hosts, connecting back to the primary Arcane instance.

Prerequisites

Before you begin, make sure you have:

  • A Linux server (or VM) with Docker installed (v24.0+)
  • Docker Compose (v2.0+)
  • A domain name pointing to your server (optional but recommended for HTTPS)
  • Basic familiarity with Docker and the terminal

Step 1 — Generate Secrets

Arcane requires two secrets: an ENCRYPTION_KEY and a JWT_SECRET. Generate them with OpenSSL:

openssl rand -base64 32
# Copy the output — this is your ENCRYPTION_KEY

openssl rand -base64 32
# Copy the output — this is your JWT_SECRET

Keep these values safe — they're used to encrypt sensitive data and sign authentication tokens.

Step 2 — Deploy Arcane with Docker Compose

Create a directory for Arcane and a docker-compose.yml file:

mkdir -p ~/arcane && cd ~/arcane

Create the docker-compose.yml:

services:
  arcane:
    image: ghcr.io/getarcaneapp/arcane:latest
    container_name: arcane
    ports:
      - "3552:3552"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - arcane-data:/app/data
      - ~/arcane-projects:/app/data/projects
    environment:
      - ENCRYPTION_KEY=your-32-char-encryption-key-here
      - JWT_SECRET=your-super-secret-jwt-key-change-this
      - TZ=UTC
    cgroup: host
    healthcheck:
      test: ["CMD-SHELL", "curl -fsS http://localhost:3552/api/health >/dev/null || exit 1"]
      interval: 10s
      timeout: 3s
      retries: 5
      start_period: 15s
    restart: unless-stopped

volumes:
  arcane-data:

Security tip: For production, use a Docker Socket Proxy instead of mounting the Docker socket directly. See the proxy example in Arcane's GitHub repo.

Start Arcane:

docker compose up -d

Wait a few seconds, then check the logs:

docker compose logs arcane

You should see output indicating the server started successfully on port 3552.

Step 3 — Set Up Your First Admin User

Open your browser and go to http://your-server-ip:3552. You'll be greeted by Arcane's setup wizard:

  1. Create your admin account — username, email, and password
  2. Review the dashboard — your Docker host's containers, images, volumes, and networks will appear automatically
  3. Configure settings — optional: set up a custom APP_URL, configure backups, or enable auto-login for development

Step 4 — Deploy Your First Stack

Arcane makes deploying compose stacks trivial:

  1. Click Stacks in the sidebar
  2. Click Create Stack
  3. Give it a name (e.g., nginx-test)
  4. Paste your compose YAML or choose a Git repository
  5. Click Deploy

Arcane will parse the compose file, create the resources, and show live deployment logs — all from the browser.

Step 5 — Configure GitOps Deployment

For production workflows, connect Arcane to a Git repository:

  1. Go to Settings → Git Sync
  2. Add your repository URL and credentials (or use a deploy token)
  3. Select the branch and compose file path
  4. Enable Auto Sync — Arcane will automatically redeploy when changes are pushed

This is perfect for managing infrastructure-as-code workflows where compose files live in Git.

Step 6 — Secure with a Reverse Proxy (Optional)

For production, expose Arcane behind a reverse proxy with SSL termination:

# docker-compose.override.yml or a separate proxy compose
services:
  nginx:
    image: nginx:alpine
    container_name: arcane-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - arcane

Then set APP_URL=https://arcane.yourdomain.com in Arcane's environment.

Feature Comparison

Feature Arcane Portainer Dockge
Tech Stack SvelteKit + Go Angular + Go Node.js + EJS
Docker Compose ✅ Full ✅ Full ✅ Full
Docker Swarm
GitOps Sync
Agent Mode ✅ (Business)
Remote Hosts ✅ Agent-based ✅ Agent-based
Image Scanning ✅ (Trivy)
Dark Theme ✅ Native
Self-contained ✅ Single binary

Resources


Arcane makes Docker management feel modern and accessible. Whether you're running a single Raspberry Pi or a full homelab cluster, it's a worthy addition to your self-hosted toolkit.

← Retour au Blog

Auto-hébergez votre infrastructure Docker avec Arcane — Une interface Docker moderne

Auto-hébergez votre infrastructure Docker avec Arcane — Une interface Docker moderne

Gérer les conteneurs Docker en ligne de commande est puissant, mais quand votre homelab grandit — avec des dizaines de conteneurs, réseaux, volumes et stacks compose — vous commencez à rêver d'un tableau de bord visuel. Voici Arcane : une interface de gestion Docker moderne, auto-hébergée, construite avec un frontend SvelteKit et un backend Go.

Arcane (5 400+ ⭐ sur GitHub) est conçu pour être l'alternative open-source à Portainer, moderne, rapide et conviviale pour les développeurs. Il gère les conteneurs, les stacks compose, les images, les volumes, les déploiements Git, Docker Swarm, et même la gestion d'hôtes distants via des agents — le tout dans un magnifique tableau de bord sombre.

Pourquoi Arcane est tendance

L'écosystème auto-hébergé a longtemps utilisé Portainer pour la gestion Docker, mais Arcane apporte un regard neuf :

  • Stack technique moderne — Frontend SvelteKit (comme ce blog !), backend Go, SQLite (via Turso/LibSQL)
  • Interface magnifique — Thème sombre, layout épuré, design responsive
  • Prêt pour le GitOps — Déployez des stacks compose directement depuis des dépôts Git avec synchronisation automatique
  • Support Docker Swarm — Gérez les stacks et services Swarm aux côtés des conteneurs classiques
  • Mode Agent — Gérez à distance plusieurs hôtes Docker via un agent léger
  • Sécurité avant tout — Support du Docker Socket Proxy, authentification JWT, clés de chiffrement
  • Développement actif — v1.18.x avec des versions toutes les deux semaines, 50+ contributeurs

Architecture

Architecture Arcane

Arcane suit une architecture client-serveur classique. Le backend Go sert de passerelle API, interagissant directement avec le démon Docker via sa socket (ou un proxy TCP). Il maintient sa propre base de données SQLite pour les comptes utilisateurs, les préférences et les configurations de projet. Le frontend SvelteKit communique avec le backend via une API REST, offrant le tableau de bord de gestion dans votre navigateur. Pour les configurations multi-hôtes, des Agents Arcane peuvent être déployés sur des hôtes Docker distants, se connectant à l'instance Arcane principale.

Prérequis

Avant de commencer, assurez-vous d'avoir :

  • Un serveur Linux (ou VM) avec Docker installé (v24.0+)
  • Docker Compose (v2.0+)
  • Un nom de domaine pointant vers votre serveur (optionnel mais recommandé pour HTTPS)
  • Une familiarité de base avec Docker et le terminal

Étape 1 — Générer les clés secrètes

Arcane nécessite deux secrets : une ENCRYPTION_KEY et un JWT_SECRET. Générez-les avec OpenSSL :

openssl rand -base64 32
# Copiez la sortie — c'est votre ENCRYPTION_KEY

openssl rand -base64 32
# Copiez la sortie — c'est votre JWT_SECRET

Conservez ces valeurs précieusement — elles servent à chiffrer les données sensibles et signer les jetons d'authentification.

Étape 2 — Déployer Arcane avec Docker Compose

Créez un répertoire pour Arcane et un fichier docker-compose.yml :

mkdir -p ~/arcane && cd ~/arcane

Créez le docker-compose.yml :

services:
  arcane:
    image: ghcr.io/getarcaneapp/arcane:latest
    container_name: arcane
    ports:
      - "3552:3552"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - arcane-data:/app/data
      - ~/arcane-projects:/app/data/projects
    environment:
      - ENCRYPTION_KEY=votre-clé-de-chiffrement-32-caractères
      - JWT_SECRET=votre-super-secret-jwt-a-changer
      - TZ=Europe/Paris
    cgroup: host
    healthcheck:
      test: ["CMD-SHELL", "curl -fsS http://localhost:3552/api/health >/dev/null || exit 1"]
      interval: 10s
      timeout: 3s
      retries: 5
      start_period: 15s
    restart: unless-stopped

volumes:
  arcane-data:

Conseil sécurité : En production, utilisez un Docker Socket Proxy au lieu de monter directement la socket Docker. Voir l'exemple proxy dans le dépôt GitHub d'Arcane.

Lancez Arcane :

docker compose up -d

Attendez quelques secondes, puis vérifiez les logs :

docker compose logs arcane

Vous devriez voir une sortie indiquant que le serveur a démarré sur le port 3552.

Étape 3 — Créer votre premier compte administrateur

Ouvrez votre navigateur et allez sur http://votre-serveur-ip:3552. L'assistant de configuration d'Arcane vous accueillera :

  1. Créez votre compte administrateur — nom d'utilisateur, email et mot de passe
  2. Explorez le tableau de bord — vos conteneurs, images, volumes et réseaux Docker apparaîtront automatiquement
  3. Configurez les paramètres — optionnel : définissez une APP_URL personnalisée, configurez les sauvegardes

Étape 4 — Déployer votre première stack

Arcane rend le déploiement de stacks compose trivial :

  1. Cliquez sur Stacks dans la barre latérale
  2. Cliquez sur Créer une Stack
  3. Donnez-lui un nom (ex : nginx-test)
  4. Collez votre YAML compose ou choisissez un dépôt Git
  5. Cliquez sur Déployer

Arcane analysera le fichier compose, créera les ressources et affichera les logs de déploiement en direct.

Étape 5 — Configurer le déploiement GitOps

Pour les workflows de production, connectez Arcane à un dépôt Git :

  1. Allez dans Paramètres → Synchronisation Git
  2. Ajoutez l'URL de votre dépôt et vos identifiants
  3. Sélectionnez la branche et le chemin du fichier compose
  4. Activez la Synchro Auto — Arcane redéploiera automatiquement lors des pushs

Étape 6 — Sécuriser avec un proxy inverse (Optionnel)

En production, exposez Arcane derrière un proxy inverse avec terminaison SSL :

services:
nginx:
  image: nginx:alpine
  container_name: arcane-proxy
  ports:
    - "80:80"
    - "443:443"
  volumes:
    - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
    - ./ssl:/etc/nginx/ssl:ro
  depends_on:
    - arcane

Définissez ensuite APP_URL=https://arcane.votredomaine.com dans les variables d'environnement d'Arcane.

Comparaison des fonctionnalités

Fonctionnalité Arcane Portainer Dockge
Stack technique SvelteKit + Go Angular + Go Node.js + EJS
Docker Compose ✅ Complet ✅ Complet ✅ Complet
Docker Swarm
Synchronisation Git
Mode Agent ✅ (Business)
Hôtes distants ✅ par Agent ✅ par Agent
Scan d'images ✅ (Trivy)
Thème sombre ✅ Natif
Autonome ✅ Binaire unique

Ressources


Arcane rend la gestion Docker moderne et accessible. Que vous utilisiez un Raspberry Pi ou un cluster complet, c'est un excellent ajout à votre boîte à outils auto-hébergée.