How to Install Wallos ‘Open-Source Personal Subscription Tracker’ on Proxmox Container Running on Ubuntu Server

Wallos is an open-source personal subscription tracker you can self-host to keep tabs on recurring payments, renewal dates, categories, currencies, and what’s coming up next on your bill calendar. This guide walks through installing Wallos on a Proxmox LXC container running Ubuntu Server, using Docker Compose to keep everything clean, portable, and simple to update.

Quick Answer: The most practical way to get Wallos running on a Proxmox Ubuntu container is to spin up a dedicated Ubuntu LXC, flip on nesting for Docker, install Docker Engine plus the Docker Compose plugin, then fire up the official Wallos container with persistent bind-mounted folders for the database and uploaded logos. Wallos listens on port 8282 by default in the standard Compose setup, so you can reach it from your browser at http://CONTAINER-IP:8282.

What We’re Building

This setup gives you a compact, self-hosted subscription dashboard tucked inside your Proxmox homelab. Wallos runs as a Docker container inside an Ubuntu Server LXC container. Proxmox manages the container lifecycle, snapshots, and resource caps; Docker Compose handles the Wallos app itself.

Wallos is built as a self-hostable finance tool for tracking subscriptions, categories, currencies, stats, logos, and notifications. The project bills itself as an open-source personal subscription tracker, and the official site mentions support for multi-currency tracking, statistics, responsive mobile layout, and notification agents like email, Telegram, and Discord through supported integrations. You can check out the project directly on the official Wallos repository.

This guide zeroes in on a practical homelab deployment, not a public SaaS-style installation. If you’re already running Docker services on Proxmox, the pattern will feel familiar. If you’re still working out your container networking, my earlier notes on Proxmox Docker networking might help you sidestep overcomplicating a small app like Wallos.

Recommended Setup

Should You Use an LXC Container or a VM?

For Wallos, an LXC container usually does the job. The app is lightweight, doesn’t need kernel modules, GPU access, or heavy isolation, and works fine as a small internal service. Proxmox uses Linux Containers through its container toolkit, which is exactly the kind of lightweight virtualization model that fits simple homelab utilities. The Proxmox Linux Container documentation explains that Proxmox VE uses LXC as its container technology and manages it through tools like pct.

The catch is Docker inside LXC. It works well for homelab use, but it needs the right container features, especially nesting. If this Wallos instance will be exposed directly to the public internet, a small Ubuntu VM is the safer and cleaner boundary. For a private LAN or VPN-only subscription tracker, LXC is a practical pick.

Create the Ubuntu LXC Container in Proxmox

You can spin up the container from the Proxmox web interface or with the command line. The web interface is easier if this is your first time setting up Wallos.

Option 1: Create the Container from the Proxmox UI

1. Download an Ubuntu template: In Proxmox, head to your storage, open CT Templates, and grab an Ubuntu Server template. Ubuntu 24.04 LTS is a solid default for a fresh install.
2. Create a new CT: Click Create CT and pick a container ID, hostname like wallos, and a strong root password or SSH key.
3. Select the Ubuntu template: Choose the Ubuntu template you just downloaded.
4. Set disk size: Use at least 8 GB. I lean toward 16 GB for small Docker apps so updates and image layers don’t turn into a constant cleanup chore.
5. Assign CPU and memory: Use 1-2 CPU cores and 1024-2048 MB RAM.
6. Configure networking: Use DHCP with a router-side static lease, or assign a fixed IP directly. Wallos is easier to wrangle when the IP doesn’t shift around.
7. Enable nesting: After creating the container, open Options and flip on Nesting. Docker typically needs this inside LXC.
8. Start the container: Boot the container and open its console or SSH into it.

Option 2: Create the Container with pct

If you’d rather use the Proxmox shell, the flow looks like this. Adjust the storage name, template path, IP address, gateway, and container ID for your server.

pct create 210 local:vztmpl/ubuntu-24.04-standard_24.04-2_amd64.tar.zst \
  --hostname wallos \
  --cores 2 \
  --memory 2048 \
  --swap 512 \
  --rootfs local-lvm:16 \
  --net0 name=eth0,bridge=vmbr0,ip=192.168.0.210/24,gw=192.168.0.1 \
  --features nesting=1 \
  --unprivileged 0 \
  --start 1

For Docker-in-LXC, plenty of homelab users go with a privileged container because it dodges several Docker storage and permission edge cases. That said, privileged containers reduce isolation. If you want the safer route, use a VM instead of trying to force every Docker feature into an unprivileged LXC.

Prepare Ubuntu Server Inside the Container

Log in to the container and update the base system first. Keeping this clean matters because Docker will add its own repository and packages.

apt update
apt upgrade -y
apt install -y ca-certificates curl gnupg nano unzip

Check the Ubuntu version:

cat /etc/os-release

You should see Ubuntu 22.04, 24.04, or another supported release. For a new setup, Ubuntu 24.04 LTS makes sense.

Install Docker Engine and Docker Compose

Use Docker’s official apt repository rather than Ubuntu’s older distro packages. Docker’s documentation recommends setting up the apt repository first, then installing docker-ce, docker-ce-cli, containerd.io, Buildx, and the Compose plugin from that repository. The current Docker docs also show the Compose plugin as the supported Linux CLI path, verified with docker compose version. Use the Docker Ubuntu installation instructions as the source of truth if package names change later.

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

tee /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
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Now confirm Docker is running:

systemctl status docker --no-pager
docker --version
docker compose version

Run a quick test container:

docker run hello-world

If the test completes successfully, the container can run Docker workloads.

Create a Clean Directory for Wallos

I like keeping self-hosted app stacks under /opt or /srv/apps. For a single-purpose Wallos container, this structure is clean and predictable:

mkdir -p /opt/wallos/{db,logos}
cd /opt/wallos

The two important persistent folders are:

• /opt/wallos/db — stores the Wallos database files.
• /opt/wallos/logos — stores uploaded subscription logos.

These folders are what separate a disposable container from a usable personal finance app. If you remove the Wallos container later, your data sticks around on disk as long as you keep these folders.

Install Wallos with Docker Compose

The official Wallos Compose example uses the bellamy/wallos:latest image, publishes container port 80 to host port 8282, sets a timezone, and mounts persistent folders for the database and uploaded logos. The current Compose file in the project maps ./db to /var/www/html/db and ./logos to /var/www/html/images/uploads/logos. You can compare this with the Wallos Compose example.

Create the Compose file:

nano /opt/wallos/docker-compose.yml

Paste this configuration:

services:
  wallos:
    image: bellamy/wallos:latest
    container_name: wallos
    restart: unless-stopped
    ports:
      - "8282:80/tcp"
    environment:
      TZ: "Asia/Kolkata"
    volumes:
      - "./db:/var/www/html/db"
      - "./logos:/var/www/html/images/uploads/logos"

Change TZ to your own timezone if needed. For India, Asia/Kolkata works.

Start Wallos:

cd /opt/wallos
docker compose up -d

Check that the container is running:

docker ps

You should see a container named wallos with a port mapping similar to:

0.0.0.0:8282->80/tcp

Open Wallos in Your Browser

Find the container IP if you don’t already know it:

ip addr show eth0

Then open Wallos from a browser on the same network:

http://192.168.0.210:8282

Replace 192.168.0.210 with your container IP. On first launch, Wallos should present its setup or login flow. Create your user account, then start adding subscriptions.

First Things to Configure in Wallos

After the application loads, don’t jump straight into adding every subscription. Spend a few minutes setting up the basics so your dashboard stays useful down the road.

• Main currency: Set the currency you use for budgeting. Wallos handles multiple currencies and can show subscriptions across currencies when configured right.
• Categories: Create practical groups like Streaming, Cloud, Domains, AI Tools, Hosting, Mobile, Banking, and Productivity.
• Payment cycles: Add monthly, yearly, quarterly, and custom cycles accurately. This is where subscription trackers beat spreadsheets.
• Notification preferences: Set up reminders if you want alerts before renewals. Wallos lists notification support for agents like email, Telegram, and Discord on its official site.
• Logos: Upload or search for service logos so the dashboard is easier to scan visually.

Optional: Put Wallos Behind a Reverse Proxy

For LAN-only use, http://CONTAINER-IP:8282 does the job. If you’re already running Caddy, Nginx Proxy Manager, Traefik, or another reverse proxy, you can give Wallos a cleaner hostname like wallos.home.arpa or subscriptions.example.com.

With Caddy running on another reverse proxy host, a simple internal configuration looks like this:

wallos.home.arpa {
    reverse_proxy 192.168.0.210:8282
}

If you expose Wallos outside your LAN, put it behind HTTPS and an authentication layer where possible. Wallos contains personal financial metadata: service names, billing amounts, renewal dates, and sometimes payment notes. Treat it as private data, not as a casual dashboard.

If you’re already experimenting with Caddy and private service exposure, the pattern is similar to the one I used for Caddy reverse proxying local services without opening unnecessary ports.

How to Update Wallos

Because this setup uses Docker Compose, updating Wallos is pretty straightforward. Head to the Wallos directory, pull the latest image, recreate the container, and remove unused layers if needed.

cd /opt/wallos
docker compose pull
docker compose up -d
docker image prune -f

Before updating, make a backup of the persistent folders:

cd /opt
tar -czf wallos-backup-$(date +%F).tar.gz wallos/db wallos/logos

You can also use Proxmox container backups or snapshots, but I still like having an app-level archive before major upgrades. Wallos has active releases, with the GitHub repository showing frequent tagged versions, so a backup-before-update habit is worth keeping.

Backup Strategy for Wallos on Proxmox

There are three backup layers worth thinking about:

A simple local backup script could look like this:

nano /usr/local/bin/backup-wallos.sh

#!/usr/bin/env bash
set -euo pipefail

BACKUP_DIR="/opt/backups/wallos"
APP_DIR="/opt/wallos"
DATE="$(date +%F-%H%M)"

mkdir -p "$BACKUP_DIR"

tar -czf "$BACKUP_DIR/wallos-$DATE.tar.gz" \
  -C /opt \
  wallos/db wallos/logos docker-compose.yml 2>/dev/null || \
tar -czf "$BACKUP_DIR/wallos-$DATE.tar.gz" \
  -C /opt \
  wallos

find "$BACKUP_DIR" -type f -name "wallos-*.tar.gz" -mtime +30 -delete

Make it executable:

chmod +x /usr/local/bin/backup-wallos.sh

Run it manually:

/usr/local/bin/backup-wallos.sh

For a small app like this, a daily cron job usually does the trick:

crontab -e

15 2 * * * /usr/local/bin/backup-wallos.sh

If you store backups on NFS or a NAS, test restores once in a while. A backup that’s never been restored is just a theory.

Troubleshooting Common Wallos Installation Issues

Docker Doesn’t Start Inside the LXC Container

If systemctl status docker shows failures, first confirm that nesting is enabled for the Proxmox container.

From the Proxmox host:

pct config 210

Look for:

features: nesting=1

If it’s missing, shut down the container and enable it:

pct shutdown 210
pct set 210 -features nesting=1
pct start 210

If Docker still fails because of storage driver or permission issues, think about using a small Ubuntu VM instead. It’s often cleaner than spending hours fighting nested container edge cases.

Wallos Container Keeps Restarting

Check the logs:

cd /opt/wallos
docker compose logs -f

Common causes include broken YAML indentation, incorrect volume permissions, disk full errors, or a bad image pull. Validate the Compose file:

docker compose config

If the output shows a parsed configuration without errors, Compose syntax is probably fine.

Port 8282 Is Already in Use

Check what’s listening on that port:

ss -tulpn | grep 8282

If another service already uses 8282, change the left side of the port mapping in docker-compose.yml:

ports:
  - "8383:80/tcp"

Then recreate the container:

docker compose up -d

You’d then access Wallos at:

http://CONTAINER-IP:8383

Wallos Loads, but Data Disappears After Recreating the Container

This almost always means persistence wasn’t set up right. Confirm the bind mounts exist:

ls -la /opt/wallos
ls -la /opt/wallos/db
ls -la /opt/wallos/logos

Then inspect the running container:

docker inspect wallos | grep -A 20 Mounts

You should see host paths for /opt/wallos/db and /opt/wallos/logos. If you started Wallos before adding volumes, stop it, fix the Compose file, and restore from backup if needed.

You Can’t Access Wallos from Another Device

Check four things in order:

1. Container IP: Run ip addr inside the LXC and confirm the address.
2. Docker port mapping: Run docker ps and confirm 8282->80 is listed.
3. Local firewall: If you installed UFW, allow the port with ufw allow 8282/tcp.
4. Network path: From another machine, test ping CONTAINER-IP and then open the browser URL.

If you’re using VLANs, macvlan, or a more advanced Proxmox network, test basic routing before blaming Wallos. For small internal apps, the simplest bridge network is usually the least painful option.

Security Notes for a Personal Finance Dashboard

Wallos might not store your bank login, but it still holds sensitive information. A list of your subscriptions can reveal your tools, hosting providers, domains, entertainment services, work apps, and spending habits.

• Don’t expose it directly by IP: Use a reverse proxy with HTTPS if remote access is needed.
• Prefer VPN access: Tailscale, WireGuard, or another private tunnel is safer than opening the app to the public internet.
• Use strong credentials: Skip reusing passwords from other homelab tools.
• Back up before updates: Wallos is easy to redeploy, but your subscription data is the valuable part.
• Keep Docker updated: Use the official Docker repository so security updates are easier to apply.

If you care about image provenance and supply-chain risk in self-hosted stacks, my article on Docker image signing goes deeper into the limits of trusting public images and why update workflows need more than blind latest pulls.

Useful Maintenance Commands

These are the commands you’ll use most often after installing Wallos.

Final Thoughts

Installing Wallos on a Proxmox Ubuntu container is a good fit for a homelab because the application is lightweight, the data is easy to persist, and Docker Compose keeps the deployment understandable. The trick is to avoid treating it as a throwaway container: enable Docker support properly in LXC, mount the database and logo folders, give the container a stable IP, and back up the persistent data before updates.

For a private home setup, this Wallos installation gives you a clean subscription tracker without leaning on a third-party budgeting app. Start with the basic Docker Compose deployment, add a reverse proxy only if you need a nicer hostname, and keep the service reachable through your LAN or VPN unless you’ve got a strong reason to expose it publicly.