Lightweight, self-hosted Docker management panel.
No Docker Desktop. No cloud. No registration. Just run and manage.

Quick Start · Screenshots · Features · Architecture · API Reference · WebSocket · Contributing

Azərbaycanca

DockGate is a browser-based Docker control panel that runs as a single container. It connects directly to your Docker socket (/var/run/docker.sock) and gives you full control over containers, images, volumes, networks, and compose stacks — all from a clean, macOS-inspired UI.

• Zero config — no .env files, API keys, or accounts
• Ultra-lightweight — ~30-80 MB RAM, <5% CPU at idle
• Real-time — live logs, stats, events, and terminal via WebSocket
• Self-contained — everything runs inside a single Docker container
• ~5,300 lines of code — easy to read, easy to contribute

Prerequisites: Docker Engine + Docker Compose plugin

git clone https://github.com/Ali7Zeynalli/dockgate.git
cd dockgate
docker compose up -d --build

Open http://localhost:7077 — that's it.

Dashboard — Real-time overview: container counts, disk usage, system info, smart insights

Containers — List all containers with status filters, bulk actions, search, group by compose

Container Detail — 10-tab deep inspect: overview, logs, terminal, stats, environment, ports, volumes, network, inspect, history

Images — Pull, remove, tag images. Filter by in-use, unused, or dangling

Volumes — Track volume usage, see attached containers, prune unused

Networks — View all Docker networks with driver, subnet, gateway, container counts

Builds & Cache — Monitor build cache entries, clear history to reclaim disk space

Compose Projects — Auto-discover stacks, run up/down/restart/pull actions

Logs — Real-time log streaming with search, timestamps, auto-scroll, word-wrap

Terminal — Interactive shell (bash/sh/zsh) inside any running container via xterm.js

Cleanup — Preview what gets deleted before pruning. Reclaim disk space safely

Settings — Theme, default shell, log timestamps, default view, auto-start toggle

DockGate has 14 modules organized in 4 groups:

start · stop · restart · kill · pause · unpause · remove · rename

Browser (Vanilla JS + xterm.js + Chart.js)
    │
    ├── HTTP/REST ──► Express API Server
    │                   ├── /api/dashboard
    │                   ├── /api/containers
    │                   ├── /api/images
    │                   ├── /api/builds
    │                   ├── /api/volumes
    │                   ├── /api/networks
    │                   ├── /api/compose
    │                   ├── /api/cleanup
    │                   ├── /api/system
    │                   └── /api/meta
    │
    └── WebSocket ──► Socket.IO
                        ├── logs:subscribe    → real-time log stream
                        ├── stats:subscribe   → CPU/RAM/network/block I/O stream
                        ├── events:subscribe  → Docker daemon events
                        └── terminal:start    → interactive PTY session
                                │
                                ▼
                        Docker Engine (/var/run/docker.sock)

dockgate/
├── Dockerfile                    # Node.js 18 Alpine + docker-cli
├── docker-compose.yml            # Deployment with resource limits
├── package.json                  # 4 deps + 1 optional (node-pty)
├── server/
│   ├── index.js                  # Express + Socket.IO server (257 lines)
│   ├── docker.js                 # Docker API wrapper via dockerode (516 lines)
│   ├── db.js                     # SQLite schema & 22 prepared statements (108 lines)
│   └── routes/
│       ├── containers.js         # Container CRUD & actions
│       ├── images.js             # Image pull/remove/tag
│       ├── volumes.js            # Volume CRUD
│       ├── networks.js           # Network CRUD
│       ├── compose.js            # Compose stack orchestration
│       ├── builds.js             # Build cache list & prune
│       ├── cleanup.js            # Prune operations
│       ├── system.js             # System info/version/df
│       └── settings.js           # Favorites, notes, tags, activity, settings, autostart
├── public/
│   ├── index.html                # SPA shell
│   ├── css/
│   │   ├── design-system.css     # Color tokens, typography, spacing
│   │   ├── layout.css            # Sidebar, topbar, page layout
│   │   └── components.css        # Buttons, cards, tables, modals, toasts
│   └── js/
│       ├── app.js                # Sidebar & navigation
│       ├── router.js             # Client-side SPA router
│       ├── store.js              # Simple reactive state store
│       ├── api.js                # HTTP client + Socket.IO + UI utilities
│       └── pages/                # 14 page modules
│           ├── dashboard.js
│           ├── containers.js
│           ├── container-detail.js  # 10-tab detail view (506 lines)
│           ├── images.js
│           ├── volumes.js
│           ├── networks.js
│           ├── compose.js
│           ├── builds.js
│           ├── logs.js
│           ├── terminal.js
│           ├── events.js
│           ├── system.js
│           ├── cleanup.js
│           └── settings.js
└── data/
    └── docker-panel.db           # SQLite (auto-created at runtime)

All endpoints are prefixed with /api. All responses are JSON.

Note: Compose actions require the project's working_dir label to be set in containers. This is standard for Docker Compose-created containers.

DockGate uses Socket.IO for all real-time data. Connects on the same port (7077).

// Subscribe
socket.emit('logs:subscribe', { containerId, tail: 100, timestamps: false });

// Receive
socket.on('logs:data', ({ containerId, data }) => {});
socket.on('logs:end', ({ containerId }) => {});
socket.on('logs:error', ({ containerId, error }) => {});

// Unsubscribe
socket.emit('logs:unsubscribe');

// Subscribe — fires ~1/sec
socket.emit('stats:subscribe', { containerId });

// Receive
socket.on('stats:data', ({
  containerId,
  cpuPercent,       // 0-100
  memoryUsage,      // bytes
  memoryLimit,      // bytes
  memoryPercent,    // 0-100
  networkRx,        // bytes received
  networkTx,        // bytes transmitted
  blockRead,        // bytes read
  blockWrite,       // bytes written
  pids              // process count
}) => {});
socket.on('stats:end', ({ containerId }) => {});
socket.on('stats:error', ({ containerId, error }) => {});

// Unsubscribe
socket.emit('stats:unsubscribe');

socket.emit('events:subscribe');
socket.on('events:data', ({ Type, Action, Actor, time }) => {});
socket.on('events:error', ({ error }) => {});
socket.emit('events:unsubscribe');

// Start session
socket.emit('terminal:start', { containerId, shell: '/bin/sh' });

// Bidirectional data
socket.emit('terminal:input', rawKeyboardData);
socket.emit('terminal:resize', { cols: 80, rows: 24 });
socket.on('terminal:ready', ({ containerId }) => {});
socket.on('terminal:data', ({ containerId, data }) => {});
socket.on('terminal:end', ({ containerId }) => {});
socket.on('terminal:error', ({ containerId, error }) => {});

// Stop session
socket.emit('terminal:stop');

ports:
  - "8080:7077"    # Access on localhost:8080

Enforced via docker-compose.yml:

Typical usage: ~30-80 MB RAM, <5% CPU at idle.

SQLite (WAL mode) at data/docker-panel.db — auto-created, persisted via volume mount.

All Docker state is read live from the engine — nothing is cached in the database.

Warning: DockGate requires Docker socket access, which grants root-equivalent control over the host.

• Do not expose port 7077 to the public internet
• No built-in authentication (by design — it's a local tool)
• Socket.IO CORS is set to origin: '*' — safe for localhost, but restrict if deploying on a network
• For remote access, use a VPN or SSH tunnel
• Compose actions are executed via child_process.exec — only accessible through the API, not user-injectable

Contributions are welcome! Here's how:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/my-feature)
3. Make your changes
4. Test locally with docker compose up -d --build
5. Commit (git commit -m 'Add my feature')
6. Push (git push origin feature/my-feature)
7. Open a Pull Request

# Run locally without Docker (requires Docker socket access)
npm install
npm run dev
# Server starts at http://localhost:7077

MIT — free to use, modify, and distribute with attribution.

Original Author: Ali Zeynalli — this attribution must be preserved in all copies and derivative works.

Yungul, self-hosted Docker idarəetmə paneli.
Docker Desktop lazım deyil. Bulud lazım deyil. Qeydiyyat lazım deyil.

DockGate brauzerdə işləyən Docker idarəetmə panelidir. Tək bir konteyner olaraq işləyir və Docker soketinə (/var/run/docker.sock) birbaşa qoşularaq konteynerlər, imicler, volumlar, şəbəkələr və compose stekləri uzerindən tam nəzarəti təmin edir — hamısı macOS ilhamlı, muasir interfeysdən.

• Sıfır konfiqurasiya — .env faylı, API açarı və ya hesab tələb olunmur
• Ultra-yungul — ~30-80 MB RAM, boş vəziyyətdə <5% CPU
• Real-time — canlı loglar, statistika, hadisələr və terminal WebSocket vasitəsilə
• Mustəqil — hər şey tək bir Docker konteynerində işləyir
• ~5,300 sətir kod — oxumaq asan, tohnfə vermək asan

Tələblər: Docker Engine + Docker Compose plugin

git clone https://github.com/Ali7Zeynalli/dockgate.git
cd dockgate
docker compose up -d --build

http://localhost:7077 açın — vəssalam.

DockGate 4 qrupda 14 modula malikdir:

start · stop · restart · kill · pause · unpause · remove · rename

Brauzer (Vanilla JS + xterm.js + Chart.js)
    │
    ├── HTTP/REST ──► Express API Server
    │                   ├── /api/dashboard     (İcmal)
    │                   ├── /api/containers    (Konteynerlər)
    │                   ├── /api/images        (İmiclər)
    │                   ├── /api/builds        (Build keşi)
    │                   ├── /api/volumes       (Volumlar)
    │                   ├── /api/networks      (Şəbəkələr)
    │                   ├── /api/compose       (Compose steklər)
    │                   ├── /api/cleanup       (Təmizlik)
    │                   ├── /api/system        (Sistem)
    │                   └── /api/meta          (Metadata)
    │
    └── WebSocket ──► Socket.IO
                        ├── logs:subscribe    → real-time log axını
                        ├── stats:subscribe   → CPU/RAM/şəbəkə/blok I/O
                        ├── events:subscribe  → Docker daemon hadisələri
                        └── terminal:start    → interaktiv PTY sessiyası
                                │
                                ▼
                        Docker Engine (/var/run/docker.sock)

docker-compose.yml vasitəsilə tətbiq olunur:

Tipik istifadə: ~30-80 MB RAM, boş vəziyyətdə <5% CPU.

SQLite (WAL mode) data/docker-panel.db unvanında — avto-yaradılır, volume mount ilə saxlanılır.

Butun Docker vəziyyəti muhərrikdən canlı oxunur — verilənlər bazasında heç nə keşlənmir.

Xəbərdarlıq: DockGate Docker soket girişi tələb edir ki, bu da host uzərində root-ekvivalent nəzarət verir.

• 7077 portunu ictimai internetə açmayın
• Daxili autentifikasiya yoxdur (dizayn gərəyi — lokal alətdir)
• Socket.IO CORS origin: '*' olaraq qurulub — localhost ucun təhlukəsizdir, amma şəbəkədə yayımlayırsınızsa məhdudlaşdırın
• Uzaqdan giriş ucun VPN və ya SSH tunnel istifadə edin

Tohnfələr xoş qarşılanır!

1. Reponu fork edin
2. Feature branch yaradın (git checkout -b feature/menim-feature)
3. Dəyişikliklərinizi edin
4. Lokal olaraq test edin: docker compose up -d --build
5. Commit edin (git commit -m 'Feature əlavə et')
6. Push edin (git push origin feature/menim-feature)
7. Pull Request açın

# Docker olmadan lokal işə salma (Docker soket girişi tələb olunur)
npm install
npm run dev
# Server http://localhost:7077 unvanında başlayır

MIT — attribution ilə istifadə, dəyişdirmə və paylamaq üçün pulsuzdur.

Orijinal Müəllif: Ali Zeynalli — bu attribution bütün kopyalarda və törəmə işlərdə saxlanmalıdır.

DockGate — Docker management without the bloat.