Where are my stacks stored, and am I locked in?

Each stack is an ordinary directory under `/opt/stacks` on the host, containing a normal `compose.yaml`. Nothing is hidden in a proprietary database: you can edit the files over SSH, version them with Git, and run `docker compose up -d` in the directory to get exactly what the UI button does. Removing Dockge leaves every stack running — that is by design.

Is it safe to expose Dockge on the internet?

Only behind HTTPS, with a strong administrator password, and ideally not exposed at all. Dockge mounts the Docker socket (`/var/run/docker.sock`), which is by definition equivalent to root on the host: anyone who reaches the interface and logs in can run arbitrary containers on your VPS. Put it behind the HTTPS vhost, use a long unique password, and if you can, restrict access further — an authentication proxy such as Authelia in front of it, or a private network via WireGuard or Headscale, rather than a publicly reachable login page.

Can it manage several servers?

Yes. Dockge supports multiple agents: install it on each Docker host, connect them from the main instance, and you manage every host's stacks from a single interface. Each agent still runs its own containers locally — there is no central scheduler, so this is a unified view of several machines, not a cluster orchestrator.

Does it work with stacks I deployed before installing Dockge?

If their directory is moved (or symlinked) under `/opt/stacks`, yes — Dockge scans that directory and adopts anything with a `compose.yaml`. Containers started outside compose, from a plain `docker run`, are visible but not managed as stacks; converting them is exactly what the `docker run` → compose converter is for.

How much RAM does it need?

Dockge itself idles well under 200 MB with its SQLite database, so it is not what you size the VPS for — the stacks it manages are. A 2 GB VPS comfortably runs Dockge alongside several small self-hosted services; scale up according to what you actually deploy on the machine.

Deploy and manage modern applications.

Dockge

Visual manager for your Docker Compose stacks — edit `compose.yaml`, start, stop and watch live logs from a web UI instead of an SSH session.

512 MB RAM 1 vCPU Port 5001 Available

Source code

Tech stack

DockerNode.jsSQLite

Minimum RAM512 MB

Minimum CPU1 vCPU

Default port5001

Compatible OSubuntu-24.04

Dockge is an open-source, MIT-licensed manager for Docker Compose stacks, written by Louis Lam — the author of Uptime Kuma — and it shares that project's reputation for being immediately understandable. A stack is a directory containing a `compose.yaml`; Dockge gives you an editor for that file, buttons to bring the stack up and down, and a live view of container status and logs, all in one reactive page.

The design choice that matters is that Dockge stays out of the way. Stacks live as ordinary files under `/opt/stacks` on the host, not inside a proprietary database — so `docker compose up -d` in that directory does exactly what the button in the UI does, `git` can version the files, and uninstalling Dockge leaves every stack running. That is the difference between a control panel you can leave and one you are locked into.

On a ServOrbit VPS, Dockge runs as a single container on port 5001 with a SQLite database and idles on well under 200 MB of RAM. It also converts a `docker run …` command you found in a README into a proper `compose.yaml`, gives you an interactive terminal on any container, and can manage several Docker hosts from a single interface once you connect additional agents.

Key features

Interactive `compose.yaml` editor with syntax highlighting and validation — write the file in the browser, or edit it over SSH; both are the same file.

Start, stop, restart, update and delete stacks from the UI, with real-time progress rather than a spinner that hides what Docker is doing.

Live container logs and status, streamed into the page as they happen — no need to open an SSH session to run `docker compose logs -f`.

`docker run` → `compose.yaml` converter: paste the command from a project README and get a ready-to-edit stack definition.

File-based storage: stacks are plain directories under `/opt/stacks`, usable with the `docker compose` CLI and versionable with Git — no lock-in.

Interactive web terminal on the host or inside any container, for the times a UI button is not enough.

Multi-agent: connect several Docker hosts and manage all their stacks from one interface.

One container, SQLite, well under 200 MB of RAM — light enough to sit alongside the workloads it manages.

When to use this solution?

1

Run your VPS stacks without living in SSH

Bringing a service up, checking why a container restarted, or tailing logs no longer means opening a terminal, finding the right directory and remembering the flags. The same operations are two clicks away in a browser — including from a phone — while the underlying files stay exactly where the CLI expects them.

2

Hand day-to-day operations to a non-sysadmin

A colleague who has to restart an application after a configuration change should not need a shell account on the server. Dockge gives them a readable view of every stack, its status and its logs, with buttons for the routine operations — and the risky part of the machine stays behind SSH keys they do not have.

3

Turn a README into a running stack

Most self-hosted projects document a long `docker run` command. Paste it into Dockge's converter, get a `compose.yaml` you can actually read and version, adjust the volumes and ports, and start it — instead of keeping a shell-history one-liner as the only record of how the service was deployed.

Deploy Dockge on your VPS

Guide optimized for ServOrbit Cloud VPS.

01

Order a ServOrbit VPS

Dockge itself is negligible — well under 200 MB of RAM. Size the VPS for the stacks you intend to run on it, since Dockge manages containers on the machine it is installed on. A 2 GB VPS comfortably hosts Dockge plus several small self-hosted services.

02

Point a domain at the VPS

Dockge controls the Docker daemon, so its interface must never be reachable over plain HTTP. Create an A record such as dockge.example.com pointing to your VPS IP — the app is then served behind the nginx vhost with a certificate issued and renewed automatically.

03

One-click deploy from the marketplace

Open your ServOrbit dashboard → Marketplace → Deployment → Dockge → Deploy. Docker pulls louislam/dockge:1, mounts the Docker socket and the /opt/stacks directory, and the UI answers on port 5001 behind the HTTPS vhost within a few seconds.

04

Create the admin account

Open your domain in a browser: the first visit asks you to create the administrator account, and registration closes immediately afterwards. Choose a strong password — this account can start, stop and edit every container on the VPS.

05

Create your first stack

Click Compose, name the stack, and either write the compose.yaml directly or paste a docker run command and let Dockge convert it. Hit Deploy and watch the pull and start progress stream live. Existing stacks are adopted too: move an existing project directory into /opt/stacks and it appears in the list on the next refresh.

Frequently asked questions

Dockge is deliberately narrower: it manages Docker Compose stacks and does it well, where Portainer covers the whole Docker surface — standalone containers, images, networks, volumes, Swarm and Kubernetes. If your VPS is organised as a handful of compose stacks, Dockge is faster to learn and far lighter. If you need to administer individual containers, registries and cluster orchestration, Portainer is the tool for that job.