Arcane: Docker Management UI Modern untuk Homelab

Gambar: GitHub

Pendahuluan

Halo teman-teman! 👋

Kalau kamu punya homelab atau server yang jalanin Docker, pasti pernah merasakan frustrasi harus buka terminal terus-terusan buat manage container, image, volume, dan sebagainya. Terminal memang powerful, tapi kadang kita cuma butuh UI yang bagus, cepat, dan gampang dipahami — tanpa harus menghafal serangkaian command docker, docker-compose, atau docker network.

Nah, kali ini gue mau kenalin salah satu project yang belakangan ini cukup bikin heboh di komunitas homelab: Arcane.

Arcane itu apa? Singkatnya, ini adalah Docker management UI modern yang self-hosted, open-source, dan dibangun dengan teknologi Go (backend) + SvelteKit (frontend). Dengan 7.000+ stars di GitHub, project ini udah jadi salah satu alternatif terbaik buat manage Docker dari browser — tanpa terminal, tanpa ribet.

Di artikel ini, kita bakal bahas tuntas tentang Arcane: apa itu, fitur-fiturnya, cara instalasi, cara pakai, perbandingan dengan tools sejenis, sampai use case untuk homelab. Yuk, langsung aja!

Apa Itu Arcane?

Arcane adalah aplikasi web-based untuk mengelola Docker secara visual. Bayangkan kamu punya sebuah dashboard cantik yang bisa kamu akses dari browser, dan dari situ kamu bisa:

• Melihat semua container yang lagi jalan
• Start, stop, restart, atau hapus container
• Manage image, network, dan volume
• Monitoring resource usage secara real-time
• Scan vulnerability di container
• Generate Docker Compose file

Semua itu dilakukan tanpa harus buka terminal satu kalipun!

Tech Stack

Arcane dibangun dengan kombinasi teknologi yang menarik:

• Backend: Go — ringan, cepat, dan efisien dalam resource
• Frontend: SvelteKit — framework modern yang menghasilkan UI yang responsif dan cepat
• License: BSD-3-Clause — free untuk digunakan, dimodifikasi, dan didistribusikan

Kenapa Arcane Menarik?

Ada beberapa alasan kenapa Arcane layak dicoba:

1. UI Modern & Cantik — Tampilannya clean, modern, dan intuitif. Gak kalah dari aplikasi komersial.
2. Self-Hosted — Kamu host sendiri di server kamu, data gak pernah keluar dari jaringan lokal.
3. No Terminal Required — Semua operasi bisa dilakukan dari browser. Cocok banget buat yang belum nyaman dengan CLI.
4. Lightweight — Dibangun dengan Go, Arcane konsumsi resource yang sangat minim.
5. Open Source — Gratis, transparan, dan bisa dimodifikasi sesuai kebutuhan.
6. Multi-Platform — Berjalan di Linux, macOS, Windows, dan bisa juga di container Docker itu sendiri.

Fitur Utama Arcane

Arcane punya segudang fitur yang membuatnya jadi Docker management UI yang sangat capable. Yuk kita bahas satu per satu:

1. Container Management

Fitur paling dasar tapi paling penting: mengelola container Docker. Dari Arcane, kamu bisa:

• Melihat daftar semua container (running & stopped)
• Start, stop, restart, atau remove container
• Melihat logs secara real-time
• Masuk ke shell container (exec)
• Melihat detail konfigurasi container

Contoh container management yang bisa kamu lakukan dari UI:

# Biasanya di terminal kamu harus lakukan:
docker ps -a                          # List semua container
docker start my-container             # Start container
docker stop my-container              # Stop container
docker logs -f my-container           # Lihat logs
docker exec -it my-container bash     # Masuk ke container
 
# Dengan Arcane, semua ini dilakukan dari klik tombol di browser!

2. Image Management

Kamu bisa manage Docker image langsung dari Arcane:

• Melihat semua image yang tersedia
• Pull image dari registry (Docker Hub, GHCR, dll)
• Remove image yang tidak terpakai
• Melihat detail image (size, layers, tags)
• Build image dari Dockerfile

# Di terminal:
docker images                           # List semua image
docker pull nginx:latest                # Pull image
docker rmi nginx:old                    # Remove image
docker image inspect nginx:latest       # Inspect image
 
# Semua bisa dilakukan dari Arcane UI!

3. Network Management

Manage Docker network jadi lebih mudah:

• Melihat semua network (bridge, host, overlay, custom)
• Create network baru
• Hubungkan/putuskan container dari network
• Inspect detail konfigurasi network

# Command terminal yang setara:
docker network ls                       # List network
docker network create my-network        # Buat network baru
docker network connect my-network c1    # Hubungkan container
docker network inspect bridge           # Inspect network

4. Volume Management

Data di Docker container harus persistent, dan Arcane memudahkan kamu mengelola volume:

• Melihat semua volume
• Create volume baru
• Remove volume yang tidak terpakai
• Melihat detail volume (mount point, driver, labels)

# Terminal equivalent:
docker volume ls                        # List volume
docker volume create my-data            # Buat volume
docker volume rm my-data                # Hapus volume
docker volume inspect my-data           # Inspect volume

5. Real-Time Monitoring

Salah satu fitur paling keren dari Arcane adalah real-time monitoring. Kamu bisa melihat:

• CPU usage per container
• Memory usage per container
• Network I/O
• Disk usage

Semua ditampilkan dalam bentuk grafik yang mudah dibaca, sehingga kamu bisa langsung tahu container mana yang makan resource terlalu banyak.

6. Vulnerability Scanning

Fitur keamanan yang sangat berguna: Arcane bisa melakukan vulnerability scanning pada Docker image kamu. Ini penting banget buat memastikan image yang kamu pakai gak punya celah keamanan yang bisa dieksploitasi.

7. REST API

Arcane juga menyediakan REST API yang bisa kamu gunakan untuk integrasi dengan tools lain atau membuat automasi sendiri. Ini bagus banget buat kamu yang mau build workflow custom di atas Arcane.

8. Docker Compose Generator

Salah satu fitur yang paling gue suka: Compose Generator. Kalau kamu belum terlalu familiar dengan menulis docker-compose.yml secara manual, Arcane bisa membantu generate file tersebut berdasarkan konfigurasi yang kamu pilih melalui UI.

# Contoh docker-compose.yml yang bisa di-generate:
version: '3.8'
services:
  webapp:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html
    restart: unless-stopped
  
  database:
    image: postgres:15
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - pgdata:/var/lib/postgresql/data
    restart: unless-stopped
 
volumes:
  pgdata:

Instalasi Docker

Sebelum kita bisa pakai Arcane, tentu saja kita harus punya Docker yang sudah terinstall di mesin kita. Kalau belum, berikut cara install Docker:

Install Docker di Ubuntu/Debian

# Update package index
sudo apt update
 
# Install dependencies
sudo apt install -y \
    ca-certificates \
    curl \
    gnupg \
    lsb-release
 
# Add Docker's official GPG key
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
    sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
 
# Set up repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
 
# Install Docker Engine
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io \
    docker-buildx-plugin docker-compose-plugin
 
# Add your user to docker group (agar gak perlu sudo)
sudo usermod -aG docker $USER
 
# Apply group changes (atau logout-login)
newgrp docker
 
# Verifikasi instalasi
docker --version
docker compose version

Install Docker di CentOS/RHEL

# Install dependencies
sudo yum install -y yum-utils
 
# Add Docker repository
sudo yum-config-manager --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
 
# Install Docker Engine
sudo yum install -y docker-ce docker-ce-cli containerd.io \
    docker-buildx-plugin docker-compose-plugin
 
# Start and enable Docker
sudo systemctl start docker
sudo systemctl enable docker
 
# Add user to docker group
sudo usermod -aG docker $USER
newgrp docker

Install Docker di macOS/Windows

Untuk macOS dan Windows, cara paling gampang adalah install Docker Desktop:

• macOS: Download dari docker.com/products/docker-desktop
• Windows: Download dari link yang sama, pastikan WSL 2 sudah aktif

Instalasi Arcane

Setelah Docker terinstall, saatnya install Arcane! Ada beberapa cara untuk install Arcane:

Cara 1: Docker Run (Paling Gampang)

# Run Arcane dengan Docker
docker run -d \
    --name arcane \
    --restart unless-stopped \
    -p 3000:3000 \
    -v /var/run/docker.sock:/var/run/docker.sock \
    ghcr.io/getarcaneapp/arcane:latest

Penjelasan flag yang digunakan:

• -d — Jalankan di background (detached mode)
• --name arcane — Beri nama container "arcane"
• --restart unless-stopped — Auto-restart kecuali di-stop manual
• -p 3000:3000 — Map port 3000 container ke port 3000 host
• -v /var/run/docker.sock:/var/run/docker.sock — Mount Docker socket agar Arcane bisa mengontrol Docker daemon

Cara 2: Docker Compose

Buat file docker-compose.yml:

version: '3.8'
services:
  arcane:
    image: ghcr.io/getarcaneapp/arcane:latest
    container_name: arcane
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - ARCANE_PORT=3000

Lalu jalankan:

# Buat direktori untuk Arcane
mkdir -p ~/arcane && cd ~/arcane
 
# Simpan file docker-compose.yml (paste konten di atas)
 
# Jalankan Arcane
docker compose up -d
 
# Cek status
docker compose ps
 
# Lihat logs
docker compose logs -f

Cara 3: Build dari Source

Kalau kamu mau build sendiri dari source code:

# Clone repository
git clone https://github.com/getarcaneapp/arcane.git
cd arcane
 
# Build dan jalankan dengan Docker
docker build -t arcane .
docker run -d \
    --name arcane \
    --restart unless-stopped \
    -p 3000:3000 \
    -v /var/run/docker.sock:/var/run/docker.sock \
    arcane

Verifikasi Instalasi

Setelah Arcane berjalan, buka browser dan akses:

http://localhost:3000

Kalau semuanya berjalan dengan benar, kamu akan melihat dashboard Arcane yang cantik dan siap digunakan!

Cara Pakai Arcane

Setelah berhasil di-install, berikut panduan lengkap cara pakai Arcane:

Dashboard Utama

Saat pertama kali membuka Arcane, kamu akan melihat dashboard utama yang menampilkan:

• Ringkasan Container — Jumlah container yang running, stopped, dan paused
• Resource Usage — CPU, memory, dan disk usage secara real-time
• Quick Actions — Tombol cepat untuk operasi umum

Mengelola Container

1. Melihat Container: Klik menu "Containers" di sidebar. Semua container (running dan stopped) akan ditampilkan dalam bentuk daftar.

2. Start Container: Klik tombol "Play" pada container yang ingin dijalankan.

3. Stop Container: Klik tombol "Stop" pada container yang ingin dihentikan.

4. Restart Container: Klik tombol "Restart" untuk me-restart container.

5. View Logs: Klik container → pilih tab "Logs" untuk melihat log secara real-time.

6. Exec into Container: Klik container → pilih "Exec" untuk masuk ke shell container.

# Yang biasanya kamu ketik di terminal:
docker exec -it my-container /bin/bash
# Sekarang cukup klik tombol di Arcane UI!

Mengelola Image

1. Pull Image Baru: Klik menu "Images" → "Pull Image" → masukkan nama image (misal: nginx:latest).

2. Hapus Image: Pilih image yang ingin dihapus → klik tombol "Remove".

3. Inspect Image: Klik image untuk melihat detail seperti size, layers, dan configuration.

Mengelola Network

1. Lihat Network: Klik menu "Networks" untuk melihat semua Docker network.

2. Buat Network Baru: Klik "Create Network" → isi nama dan driver (bridge, overlay, host).

3. Connect Container: Pilih network → klik "Connect Container" → pilih container yang ingin dihubungkan.

Mengelola Volume

1. Lihat Volume: Klik menu "Volumes" untuk melihat semua Docker volume.

2. Buat Volume Baru: Klik "Create Volume" → isi nama volume.

3. Hapus Volume: Pilih volume → klik "Remove".

Monitoring Real-Time

Arcane menyediakan dashboard monitoring yang menampilkan:

• CPU Usage: Persentase CPU yang digunakan setiap container
• Memory Usage: RAM yang dikonsumsi oleh setiap container
• Network I/O: Traffic masuk dan keluar per container
• Disk Usage: Penggunaan storage oleh container dan image

Grafik ini di-update secara real-time sehingga kamu bisa memantau kondisi server kamu setiap saat.

Docker Compose Generator

Untuk menggunakan fitur Compose Generator:

1. Klik menu "Compose" di sidebar
2. Klik "New Compose Project"
3. Tambahkan services satu per satu melalui UI
4. Konfigurasi image, ports, volumes, environment variables
5. Klik "Generate" untuk membuat file docker-compose.yml
6. Deploy langsung dari Arcane!

Perbandingan: Arcane vs Portainer vs CasaOS

Ada beberapa Docker management UI yang populer di komunitas homelab. Berikut perbandingan Arcane dengan dua yang paling banyak dipakai:

Tabel Perbandingan

Arcane vs Portainer

Portainer sudah lama jadi pilihan utama untuk Docker management UI. Tapi Arcane punya beberapa keunggulan:

• Lebih Ringan: Arcane konsumsi resource jauh lebih sedikit dibanding Portainer
• UI Lebih Modern: Desain UI Arcane lebih fresh dan modern
• Vulnerability Scanning: Fitur ini built-in di Arcane, sementara di Portainer hanya di versi Business
• Compose Generator: Arcane punya fitur generate Compose yang lebih user-friendly

Portainer masih unggul di:

• Multi-host management (mengelola beberapa Docker host sekaligus)
• RBAC (Role-Based Access Control)
• Kubernetes support
• Community yang lebih besar dan lebih matang

Arcane vs CasaOS

CasaOS lebih fokus sebagai operating system untuk home server, bukan murni Docker management UI.

• Arcane: Spesialis di Docker management, fitur lebih lengkap
• CasaOS: Lebih ke "home server OS" dengan app store, cocok buat yang mau semua-serba-mudah
• Arcane: Cocok untuk yang sudah punya server dan cuma butuh Docker management
• CasaOS: Cocok untuk yang mau set-up home server dari nol dengan sedikit CLI

Kapan Harus Pilih Arcane?

Pilih Arcane kalau kamu:

• Butuh Docker management UI yang ringan dan cepat
• Ingin fitur lengkap tanpa ribet
• Suka dengan UI modern dan clean
• Gak butuh multi-host management
• Ingin vulnerability scanning built-in
• Baru mulai pakai Docker dan butuh UI yang intuitif

Use Case untuk Homelab

Arcane sangat cocok untuk berbagai use case di homelab. Berikut beberapa skenario yang bisa kamu coba:

1. Media Server Management

# docker-compose.yml untuk Jellyfin media server
version: '3.8'
services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    ports:
      - "8096:8096"
    volumes:
      - jellyfin-config:/config
      - jellyfin-cache:/cache
      - /media:/media:ro
    restart: unless-stopped
 
volumes:
  jellyfin-config:
  jellyfin-cache:

Dengan Arcane, kamu bisa deploy compose ini langsung dari UI, monitor resource usage, dan manage container tanpa buka terminal.

2. Home Automation (Home Assistant)

# docker-compose.yml untuk Home Assistant
version: '3.8'
services:
  homeassistant:
    image: ghcr.io/home-assistant/home-assistant:stable
    container_name: homeassistant
    volumes:
      - /opt/homeassistant:/config
      - /etc/localtime:/etc/localtime:ro
    restart: unless-stopped
    network_mode: host
    privileged: true

Arcane memudahkan kamu untuk:

• Deploy Home Assistant dari Compose
• Monitor resource usage
• Restart container kalau ada masalah
• Lihat logs untuk debugging

3. Development Stack

# docker-compose.yml untuk full-stack development
version: '3.8'
services:
  frontend:
    build: ./frontend
    ports:
      - "3001:3000"
    depends_on:
      - backend
  
  backend:
    build: ./backend
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://admin:secret@database:5432/myapp
    depends_on:
      - database
  
  database:
    image: postgres:15
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - pgdata:/var/lib/postgresql/data
  
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
 
volumes:
  pgdata:

Dengan Arcane, kamu bisa:

• Generate Compose file dari UI
• Deploy seluruh stack sekaligus
• Monitor semua service
• Manage network antar service

4. Monitoring Stack

# docker-compose.yml untuk monitoring dengan Prometheus + Grafana
version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    restart: unless-stopped
 
  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana-data:/var/lib/grafana
    restart: unless-stopped
 
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    restart: unless-stopped
 
volumes:
  prometheus-data:
  grafana-data:

Arcane sangat membantu untuk:

• Deploy monitoring stack dengan mudah
• Monitor container monitoring itu sendiri
• Scale services kalau diperlukan

5. Backup Solution

# docker-compose.yml untuk automated backup dengan Duplicati
version: '3.8'
services:
  duplicati:
    image: linuxserver/duplicati:latest
    container_name: duplicati
    ports:
      - "8200:8200"
    environment:
      - PUID=1000
      - PGID=1000
    volumes:
      - duplicati-config:/config
      - /backup-source:/source:ro
      - /backup-destination:/backups
    restart: unless-stopped
 
volumes:
  duplicati-config:

6. Reverse Proxy dengan Nginx Proxy Manager

# docker-compose.yml untuk Nginx Proxy Manager
version: '3.8'
services:
  nginx-proxy-manager:
    image: jc21/nginx-proxy-manager:latest
    container_name: nginx-proxy-manager
    ports:
      - "80:80"
      - "443:443"
      - "81:81"
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    restart: unless-stopped

Tips dan Best Practices

Berikut beberapa tips saat menggunakan Arcane di homelab:

1. Selalu Gunakan Docker Socket dengan Hati-hati

# Mount Docker socket memberikan kontrol penuh ke Docker daemon.
# Pastikan Arcane hanya diakses dari jaringan trusted!
 
# Untuk keamanan tambahan, kamu bisa mount socket sebagai read-only:
docker run -d \
    --name arcane \
    -p 3000:3000 \
    -v /var/run/docker.sock:/var/run/docker.sock:ro \
    ghcr.io/getarcaneapp/arcane:latest

2. Gunakan Restart Policy

# Selalu set restart policy agar container otomatis start saat reboot:
# --restart unless-stopped (recommended)
# --restart always
# --restart on-failure:3

3. Monitor Resource Usage Secara Berkala

Gunakan fitur real-time monitoring di Arcane untuk memantau:

• Container yang menggunakan CPU berlebihan
• Memory leak pada aplikasi
• Network traffic yang tidak wajar

4. Backup Configuration

# Backup Docker Compose files dan configuration:
tar -czf docker-backup-$(date +%Y%m%d).tar.gz \
    ~/arcane/docker-compose.yml \
    ~/docker-stacks/ \
    /opt/*/docker-compose.yml

5. Gunakan Docker Networks yang Terpisah

# Pisahkan network untuk setiap stack/app:
docker network create frontend
docker network create backend
docker network create monitoring

Troubleshooting Umum

Arcane Tidak Bisa Akses Docker

# Pastikan Docker socket tersedia:
ls -la /var/run/docker.sock
 
# Pastikan user ada di docker group:
groups $USER
 
# Kalau belum, tambahkan:
sudo usermod -aG docker $USER

Port 3000 Sudah Dipakai

# Cek port yang sedang dipakai:
sudo lsof -i :3000
 
# Gunakan port lain:
docker run -d \
    --name arcane \
    -p 3001:3000 \
    -v /var/run/docker.sock:/var/run/docker.sock \
    ghcr.io/getarcaneapp/arcane:latest

Container Arcane Restart Terus

# Cek logs untuk debugging:
docker logs arcane
 
# Restart container:
docker restart arcane
 
# Kalau masih gagal, remove dan buat ulang:
docker stop arcane && docker rm arcane
# Jalankan ulang perintah docker run

Kesimpulan

Arcane adalah pilihan yang sangat menarik untuk Docker management UI di homelab. Dengan UI yang modern, fitur yang lengkap, dan resource usage yang ringan, Arcane layak menjadi alternatif dari Portainer maupun CasaOS.

Keunggulan utama Arcane:

• ✅ UI modern dan intuitif
• ✅ Sangat ringan dalam penggunaan resource
• ✅ Self-hosted dan open source
• ✅ Fitur vulnerability scanning built-in
• ✅ Docker Compose generator yang mudah digunakan
• ✅ Real-time monitoring

Kekurangan yang perlu diperhatikan:

• ⚠️ Masih相对 baru, community belum sebesar Portainer
• ⚠️ Belum support multi-host management
• ⚠️ Belum ada RBAC (Role-Based Access Control)
• ⚠️ Belum support Kubernetes

Secara keseluruhan, kalau kamu mencari Docker management UI yang modern, ringan, dan mudah digunakan untuk homelab kamu, Arcane sangat recommended untuk dicoba! 🚀

Link dan Referensi

• GitHub: github.com/getarcaneapp/arcane
• Homepage: getarcane.app
• Docker Hub: ghcr.io/getarcaneapp/arcane

Artikel ini ditulis dalam rangka memperkenalkan project open-source menarik kepada komunitas homelab Indonesia. Kalau kamu punya pengalaman pakai Arcane atau mau share setup homelab kamu, jangan ragu untuk berbagi di kolom komentar!