How to Install Dockge on Proxmox Container Running on Ubuntu Server

Installing Dockge on a Proxmox container running Ubuntu Server is a solid way to manage Docker Compose stacks through a clean web interface without migrating everything to a heavier platform. It works well for homelabs or private admin setups, but there’s one key decision to make upfront: Docker inside an LXC container is convenient, but it’s not the most isolated design.

In this guide, we’ll install Dockge inside an Ubuntu Server LXC container on Proxmox, configure Docker Engine, set up a proper stacks directory, deploy Dockge with Docker Compose, and tackle the common Proxmox-specific issues that typically break this setup.

What Dockge Does and When It Makes Sense

Dockge is a self-hosted Docker Compose stack manager. Instead of hiding your configuration behind a database-heavy abstraction, it works directly with compose.yaml files stored on disk. That’s the main reason I like it for small Proxmox and Docker homelab setups.

According to the Dockge Docker image page, Dockge focuses on managing Compose files, editing stacks, starting and stopping services, updating images, and using a file-based structure. It’s not trying to replace every Docker CLI feature.

That distinction matters. Dockge is a good fit when your services are already organized as Docker Compose stacks. It’s less useful if you mostly run one-off containers with docker run or need deep Docker network, volume, image, and registry administration from a full control panel.

Before You Install Dockge on Proxmox LXC

The core setup is simple, but Proxmox LXC adds a few wrinkles because Docker expects container features that aren’t always enabled by default inside an LXC container.

Recommended Environment

For a clean Dockge installation, I recommend starting with this baseline:

• Proxmox VE: Proxmox 8.x or newer
• Container OS: Ubuntu Server 22.04 LTS or 24.04 LTS
• CPU: 1–2 cores for a small stack manager
• Memory: 1 GB minimum, 2 GB preferred
• Disk: 8–16 GB minimum, more if stacks store local data
• Network: Static IP or DHCP reservation
• Access: SSH into the Ubuntu container

If you plan to run many stacks on the same LXC container, size it for the applications, not for Dockge. Dockge itself isn’t the heavy part; the containers it controls are.

Important Security Note About Docker Inside LXC

Running Docker inside a Proxmox LXC container is common in homelabs, but it weakens the isolation boundary. Docker needs nested namespaces and access to the Docker socket. When you enable LXC nesting, you’re allowing container-in-container behavior that reduces some of the security benefits of LXC.

For a private homelab, this trade-off may be acceptable. For public-facing or multi-tenant production workloads, a full Ubuntu VM running Docker is usually the cleaner option. This is similar to the trade-off discussed in this Docker-in-LXC analysis, where the main concern isn’t performance but isolation.

If you’ve already worked with Docker workloads on Proxmox, you may also find the same pattern in my article on Proxmox LXC automation, where Docker support inside LXC affects how the container should be designed.

Step 1: Create an Ubuntu LXC Container in Proxmox

Start from the Proxmox web interface and create a new container.

1. Open Proxmox: Go to your Proxmox web UI and select the node where you want to run Dockge.
2. Create CT: Click Create CT.
3. Choose hostname: Use a clear name such as dockge or docker-manager.
4. Select template: Choose an Ubuntu 22.04 or Ubuntu 24.04 LXC template.
5. Set disk: Use at least 8 GB. Use more if Docker data will live inside this container.
6. Assign CPU and RAM: Start with 2 cores and 2 GB RAM if you plan to run multiple stacks.
7. Configure network: Assign a static IP or configure a DHCP reservation from your router.
8. Finish creation: Create the container, but don’t install Dockge yet.

For example, if your container ID is 120 and its IP is 192.168.0.120, you’ll later access Dockge at:

http://192.168.0.120:5001

Step 2: Enable Nesting for Docker Inside the LXC Container

Docker inside Proxmox LXC normally needs nesting enabled. You can do this from either the Proxmox UI or the Proxmox host shell.

Option A: Enable Nesting from the Proxmox UI

1. Stop the LXC container.
2. Open the container in the Proxmox web UI.
3. Go to Options.
4. Find Features.
5. Enable Nesting.
6. Start the container again.

Option B: Enable Nesting from the Proxmox Host Shell

On the Proxmox host, replace 120 with your actual container ID:

pct stop 120
pct set 120 -features nesting=1,keyctl=1
pct start 120

Some setups may also need fuse=1, especially when storage drivers or mounted filesystems behave unexpectedly:

pct stop 120
pct set 120 -features nesting=1,keyctl=1,fuse=1
pct start 120

Step 3: Update Ubuntu Server Inside the Container

SSH into the Ubuntu LXC container:

ssh [email protected]

Then update the package list and installed packages:

apt update
apt upgrade -y

Install a few basic tools we’ll need:

apt install -y ca-certificates curl gnupg lsb-release nano

At this point, rebooting the container is a good idea if the upgrade pulled in core packages:

reboot

Reconnect after the container comes back online.

Step 4: Install Docker Engine on Ubuntu Server

Use Docker’s official apt repository rather than Ubuntu’s older docker.io package. The official Docker Engine documentation currently supports Ubuntu 22.04 LTS and 24.04 LTS, which are the two Ubuntu Server releases most people should use for this setup.

Remove Conflicting Docker Packages

If this is a fresh container, this command may not remove anything. That’s fine.

apt remove -y docker.io docker-compose docker-compose-v2 docker-doc podman-docker containerd runc

Add Docker’s Official Repository

apt update
apt install -y ca-certificates curl

install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc

cat > /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

apt update

Install Docker and Compose Plugin

apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Start and enable Docker:

systemctl enable --now docker

Check the Docker service:

systemctl status docker --no-pager

Verify Docker with a test container:

docker run hello-world

Now confirm that Docker Compose V2 is available:

docker compose version

Docker Compose is important because Dockge is built around Compose stack workflows. The Docker Compose documentation describes Compose as a way to define and run application stacks from a single YAML file, which is exactly the model Dockge uses.

Step 5: Create Dockge and Stacks Directories

Dockge needs two important directories:

• /opt/dockge — stores Dockge’s own Compose file and data
• /opt/stacks — stores the Compose stacks managed by Dockge

Create both directories:

mkdir -p /opt/dockge /opt/stacks
cd /opt/dockge

This directory layout keeps the manager separate from the applications it manages. It also makes backups easier because your stack definitions are in one predictable place.

Step 6: Download Dockge Compose File

Dockge provides an official Compose file. From inside /opt/dockge, run:

curl https://raw.githubusercontent.com/louislam/dockge/master/compose.yaml --output compose.yaml

You can inspect it before starting:

nano compose.yaml

A typical Dockge Compose setup uses the louislam/dockge:1 image, exposes port 5001, mounts the Docker socket, stores Dockge data in ./data, and maps /opt/stacks into the container.

If you prefer to write the file manually, use this clean version:

services:
  dockge:
    image: louislam/dockge:1
    container_name: dockge
    restart: unless-stopped
    ports:
      - "5001:5001"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./data:/app/data
      - /opt/stacks:/opt/stacks
    environment:
      - DOCKGE_STACKS_DIR=/opt/stacks

The Docker socket mount is what allows Dockge to control Docker on the host. In this case, the “host” is your Ubuntu LXC container, not the Proxmox host itself.

Step 7: Start Dockge

From /opt/dockge, start Dockge:

docker compose up -d

Check whether the container is running:

docker ps

You should see a container named dockge listening on port 5001.

Check logs if needed:

docker logs -f dockge

Now open Dockge in your browser:

http://192.168.0.120:5001

Replace the IP address with your own LXC container IP.

Step 8: Complete the Dockge Web Setup

When you open Dockge for the first time, create the admin account. Use a strong password because this interface can control your Docker environment.

After login, you should see an empty stack list. That’s expected. Dockge reads stacks from the configured stacks directory, which in this guide is:

/opt/stacks

From the UI, you can create a new stack, edit its compose.yaml, deploy it, stop it, restart it, and view logs. The workflow is close to using Docker Compose from the terminal, but with a browser-based editor and status view.

Step 9: Create a Test Stack in Dockge

To confirm everything’s working, create a small test stack from the Dockge UI.

1. Open Dockge in the browser.
2. Click Compose or New Stack, depending on your UI version.
3. Name the stack whoami.
4. Paste the Compose file below.
5. Deploy the stack.

services:
  whoami:
    image: traefik/whoami
    container_name: whoami-test
    restart: unless-stopped
    ports:
      - "8080:80"

After deployment, open:

http://192.168.0.120:8080

You should see a small response page from the whoami container. If that works, Dockge can create and run Compose stacks correctly.

How to Add Existing Docker Compose Stacks to Dockge

If you already have Compose files on the Ubuntu container, Dockge can manage them as long as they’re placed in the configured stacks directory.

The expected pattern is:

/opt/stacks/stack-name/compose.yaml

For example:

/opt/stacks/caddy/compose.yaml
/opt/stacks/uptime-kuma/compose.yaml
/opt/stacks/homepage/compose.yaml

To move an existing stack into Dockge:

1. Stop the existing stack: Run docker compose down from its current directory.
2. Create a Dockge stack folder: Use mkdir -p /opt/stacks/appname.
3. Move the Compose file: Place it at /opt/stacks/appname/compose.yaml.
4. Check volume paths: Make sure bind mounts still point to the correct absolute directories.
5. Scan stacks: Use Dockge’s stack scan option from the UI.
6. Deploy from Dockge: Start the stack again from the web interface.

This file-based approach is one of Dockge’s best features. Your Compose files remain normal files on disk, so you can still use Git, SSH, rsync, or your preferred backup system.

Recommended Directory Structure for a Proxmox Docker LXC

For a small Dockge-managed Proxmox container, this layout works well:

/opt/dockge
  compose.yaml
  data/

/opt/stacks
  caddy/
    compose.yaml
  uptime-kuma/
    compose.yaml
  homepage/
    compose.yaml

/srv/apps
  caddy/
    Caddyfile
    data/
  uptime-kuma/
    data/
  homepage/
    config/

The idea is simple: keep Compose definitions under /opt/stacks, but keep application state under /srv/apps. That makes it easier to back up configuration separately from larger runtime data.

If your stacks include reverse proxies, tunnels, or exposed services, the same pattern pairs well with a private access layer. For example, I used a similar Docker and Caddy approach in my guide on Tailscale Funnel Caddy for exposing local services without opening normal firewall ports.

Securing Dockge After Installation

Dockge shouldn’t be exposed casually to the public internet. It has access to the Docker socket, and Docker socket access is effectively administrative access to the Docker environment.

Use a Private Network First

The safest default is to keep Dockge available only on your LAN or VPN:

http://192.168.0.120:5001

If you need remote access, use a VPN such as WireGuard, Tailscale, or a private reverse proxy with proper authentication.

Put Dockge Behind a Reverse Proxy

If you want a hostname such as dockge.home.lan, place Dockge behind Caddy, Nginx, or Traefik. For Caddy on the same Docker host, a simple internal reverse proxy can look like this:

dockge.home.lan {
    reverse_proxy 192.168.0.120:5001
}

For public exposure, add an authentication layer. Don’t rely only on a hard-to-guess URL.

Back Up Dockge and Stack Files

Back up at least these paths:

/opt/dockge
/opt/stacks
/srv/apps

The first two preserve Dockge and your stack definitions. The third preserves the application data if you follow the directory structure above.

Common Errors and Fixes

Docker Service Does Not Start Inside the LXC Container

If Docker fails to start, first check the service logs:

journalctl -u docker --no-pager -n 100

Common causes include missing LXC nesting, incompatible storage settings, or a container template that doesn’t behave well with Docker. Stop the container from the Proxmox host and confirm features:

pct config 120

You should see something like:

features: keyctl=1,nesting=1

If not, set it again:

pct stop 120
pct set 120 -features nesting=1,keyctl=1
pct start 120

Dockge Starts but Cannot Control Docker

If Dockge opens in the browser but can’t deploy or manage stacks, check the Docker socket mount:

docker exec -it dockge ls -l /var/run/docker.sock

The Dockge Compose file should include:

- /var/run/docker.sock:/var/run/docker.sock

Without that mount, Dockge can’t talk to Docker.

Stacks Are Created in the Wrong Directory

Dockge is strict about stack paths. Your volume mapping and environment variable should point to the same path:

volumes:
  - /opt/stacks:/opt/stacks
environment:
  - DOCKGE_STACKS_DIR=/opt/stacks

Avoid mismatched paths such as:

- /opt/stacks:/app/stacks

That kind of mismatch can make stack files appear in unexpected places or fail to show correctly in Dockge.

Port 5001 Is Not Reachable

Check whether the container is running:

docker ps

Check whether port 5001 is listening inside Ubuntu:

ss -tulpn | grep 5001

If the port is listening but not reachable from your laptop, check:

• The LXC container IP address
• Proxmox firewall settings
• Ubuntu firewall rules, if you enabled UFW
• Router or VLAN rules between your client and Proxmox network

Also remember Docker can interact with firewall rules in ways that surprise people. Docker’s own documentation warns that exposed container ports can bypass some host firewall expectations, so don’t assume UFW alone is controlling every container path.

Containers Randomly Stop or OOM After Ubuntu 24.04 Upgrade

If you run Dockge-managed stacks inside Ubuntu 24.04 LXC, pay close attention to memory limits and cgroup behavior. Kernel 6.x and cgroup v2 can expose sloppy memory assumptions that worked on older setups.

I covered this in more detail in my article about cgroup v2 memory. The short version: set enough memory at the Proxmox LXC level, avoid unrealistic Compose limits, and monitor docker stats before blaming Dockge.

Updating Dockge

Dockge is easy to update because it’s running from a Compose file. SSH into the Ubuntu container and run:

cd /opt/dockge
docker compose pull
docker compose up -d

Then clean unused images if you want to reclaim space:

docker image prune -f

Before updating, it’s still smart to back up:

tar -czf /root/dockge-backup-$(date +%F).tar.gz /opt/dockge /opt/stacks

If your application data lives under /srv/apps, include that in your backup plan as well.

Uninstalling Dockge

If you only want to remove Dockge but keep your application stacks, stop the Dockge container and remove its directory:

cd /opt/dockge
docker compose down
cd /opt
rm -rf /opt/dockge

This doesn’t remove stacks under /opt/stacks. Your Compose files remain available, and you can still manage them manually with Docker Compose:

cd /opt/stacks/example-stack
docker compose up -d

If you want to remove Docker completely from the Ubuntu LXC container, use Docker’s uninstall process, but be careful: removing /var/lib/docker deletes Docker images, containers, and volumes.

Best Practices for Running Dockge on Proxmox

• Use a VM for sensitive workloads: Docker inside LXC is fine for controlled homelab use, but a VM is better for stronger isolation.
• Keep Dockge private: Access it over LAN, VPN, or an authenticated reverse proxy.
• Use absolute paths: Compose files are easier to debug when volumes point to clear host paths such as /srv/apps/appname/data.
• Back up stack files: The /opt/stacks directory is the heart of your Dockge-managed setup.
• Watch network changes: If you later move from Docker bridge to macvlan, test latency and routing carefully. I’ve seen network behavior change noticeably, as covered in my Docker macvlan latency write-up.
• Document your CT settings: Keep a note of the container ID, enabled features, mounted storage, IP address, and backup paths.

Final Thoughts

Installing Dockge on a Proxmox LXC container running Ubuntu Server gives you a clean, lightweight way to manage Docker Compose stacks without giving up file-based control. The key is to set up the LXC container correctly, install Docker from the official repository, keep your stack directory predictable, and treat Dockge as a powerful admin interface rather than a casual web app.

For a private homelab, this setup is practical and efficient. For anything exposed, sensitive, or multi-tenant, run Docker inside a proper Ubuntu VM instead. Either way, Dockge works best when your Compose files are clean, your directories are organized, and your backup strategy is already in place.