How to Install CasaOS on Ubuntu 24.04 VPS: Simple Self-Hosted Cloud OS

CasaOS turns a plain Ubuntu VPS into a friendly, browser-based home cloud in about fifteen minutes. Instead of wrangling Docker Compose files, volume mounts, and reverse proxy configs from the command line, you browse an app store, click Install, and watch Jellyfin, Nextcloud, Home Assistant, or Syncthing come online with sensible defaults. This guide walks you through installing CasaOS on Ubuntu 24.04, deploying your first self-hosted apps, wiring up remote access, and keeping everything patched.

Skip the setup? Our CloudCore Starter plan comes with a one-click CasaOS image pre-configured for remote access. Launch a ready-to-use personal cloud in under 90 seconds.

Table of Contents

What is CasaOS?

CasaOS is an open-source personal cloud operating system built by IceWhale Technology, the same team behind the ZimaBoard, ZimaBlade, and ZimaCube home-server hardware. Although CasaOS is hardware-branded by IceWhale, it runs on any reasonably modern Linux box — from a Raspberry Pi to an Ubuntu 24.04 VPS.

Under the hood, CasaOS is a collection of Go microservices that sit on top of Docker. It does not replace the kernel or the package manager; it installs alongside your existing Ubuntu system, provisions a Docker daemon if one is not already present, and exposes a clean web UI at port 80. Every "app" you install through CasaOS is simply a Docker container (or a small Compose stack) with a curated set of environment variables, volume mounts, and port mappings. The MIT license means you can self-host it for personal or commercial use without worrying about royalties or restrictive terms.

The project's stated goal is to make self-hosting approachable for non-engineers. If you have ever tried to explain docker-compose up -d, bind mounts, and user-defined networks to a friend who just wants their own Netflix, CasaOS is the answer. It ships with a visual dashboard, an app store with one-click installs for dozens of popular services, a file manager, and a simple widget system for RAM, CPU, network, and storage stats.

The app catalog covers the most common self-hosting use cases:

• Media: Jellyfin, Plex, Emby, Navidrome, PhotoPrism
• Productivity: Nextcloud, Vaultwarden, Joplin, Trilium, Memos
• Automation: Home Assistant, Node-RED, n8n, Zigbee2MQTT
• Sync and backup: Syncthing, Duplicati, Kopia
• Download and networking: qBittorrent, Transmission, AdGuard Home, Pi-hole
• Developer tools: Gitea, Code Server, Portainer, Uptime Kuma

Why Self-Host with CasaOS?

Running your own cloud on a VPS instead of paying for Google Drive, iCloud, Netflix, Dropbox, and half a dozen SaaS subscriptions is easier than it has ever been. CasaOS is the glue that makes it accessible:

• One-click installs -- Install Jellyfin, Nextcloud, or Home Assistant without touching a terminal. CasaOS generates the Docker run command, creates volumes, and opens the right ports for you.
• Real cost savings -- A single 4 GB VPS at EUR 7.99/month can comfortably replace Google Drive (2 TB = EUR 9.99/mo), Netflix (EUR 13.49/mo), and a password manager subscription (EUR 3+/mo). The break-even is roughly week one.
• Data ownership -- Your photos, videos, documents, and smart-home telemetry live in volumes you control. No algorithmic scanning, no feature paywalls, no account lockouts.
• Visual dashboard -- A friendly home screen shows CPU, RAM, disk, and network widgets plus app tiles you can click to launch. Family members can use it without ever seeing a command line.
• Beginner on-ramp, power-user escape hatch -- Click-install today, edit the underlying Compose file tomorrow. CasaOS does not hide Docker from you; it just does not require it.
• MIT licensed and open source -- No paid tier, no telemetry that cannot be disabled, no vendor lock-in. If the project ever changes direction, your containers and data remain untouched.
• Works on cheap hardware -- 2 GB RAM is enough for the OS and several small apps. That maps to the cheapest CloudCore tier on any provider.

What a CasaOS VPS Replaces

Prerequisites

Before you begin, make sure you have:

• A VPS running Ubuntu 24.04 LTS (22.04 and Debian 11/12 also work) with root or sudo access
• SSH access to your server (PuTTY on Windows, built-in terminal on macOS/Linux)
• At least 2 GB of RAM (4 GB+ recommended if you plan to run Jellyfin transcoding or Nextcloud with a few users)
• At least 20 GB of free disk space for CasaOS, Docker images, and app data (100 GB+ if you plan to store media locally)
• Port 80 free on the server -- CasaOS binds to port 80 for its dashboard. If you already run Nginx, Apache, or Caddy on that port, either stop them first or follow Step 8 to remap CasaOS.

Recommended Plan: CloudCore Starter

For a first personal cloud running CasaOS plus 3-5 apps (Nextcloud, Jellyfin, Vaultwarden, Home Assistant, Syncthing), we recommend the CloudCore Starter plan:

- 2-4 vCPU cores

- 4 GB RAM

- 100 GB NVMe SSD

- Unmetered bandwidth

- From EUR 7.99/month

Need more media storage? Upgrade to CloudCore Plus or attach a block-storage volume for your Jellyfin library.

Connect to your server via SSH to get started:

ssh root@your-server-ip

Step 1: Update System Packages

Refresh the package index and upgrade installed packages so the CasaOS installer starts from a clean baseline.

sudo apt update && sudo apt upgrade -y

Expected output (abbreviated):

Hit:1 http://archive.ubuntu.com/ubuntu noble InRelease
Reading package lists... Done
Building dependency tree... Done
0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.

Install a few helper packages CasaOS benefits from:

sudo apt install -y curl wget ca-certificates smartmontools udisks2

The smartmontools and udisks2 packages let CasaOS display disk health and mount external volumes. Reboot if the kernel was upgraded:

sudo reboot

Step 2: Install CasaOS

CasaOS ships a single install script that detects your distro, installs Docker if it is missing, pulls the CasaOS containers, and wires everything to systemd.

Run the installer:

curl -fsSL https://get.casaos.io | sudo bash

Expected output (abbreviated):

_____                    _____ _____
|     |___ ___ ___ ___   |     |   __|
|   --| .'|_ -| .'| . |  |  |  |__   |
|_____|__,|___|__,|___|  |_____|_____|
Start Installation:
 - [✔] Check OS
 - [✔] Check Architecture
 - [✔] Install Docker
 - [✔] Install Required Packages
 - [✔] Install CasaOS
 - [✔] Start CasaOS Service
CasaOS is running at:
http://192.0.2.10

Behind the scenes the installer:

Installation usually completes in 3-5 minutes depending on network speed.

Verify services are running:

sudo systemctl status casaos-gateway --no-pager

Expected output:

● casaos-gateway.service - CasaOS Gateway Service
     Loaded: loaded (/etc/systemd/system/casaos-gateway.service; enabled)
     Active: active (running) since Wed 2026-04-16 10:00:00 UTC; 1min ago

Step 3: First Login and Admin Account

Open your browser and visit http://your-server-ip/ (port 80, no TLS yet). You should see the CasaOS welcome screen.

Click Go and create your administrator account:

• Username: choose something other than admin -- CasaOS does not enforce complex usernames but you should
• Password: use a 16+ character passphrase. This account has full control over Docker on the server.

• Top-left: user avatar and settings
• Top row of widgets: CPU, RAM, storage, network
• Main tiles: App Store, Files, and any apps you install later
• Bottom tray: running app shortcuts

sudo ufw allow OpenSSH
sudo ufw enable
sudo ufw status

Port 80 is not allowed by default with this UFW config, so only local and SSH-tunnel access works until you explicitly open it or route through Tailscale.

Step 4: Tour the App Store

Click the App Store tile. You will see a curated list of one-click apps grouped by category. Each listing shows:

• Logo and app name (for example, Jellyfin)
• A short description
• CPU and RAM estimates
• The Docker image tag that will be pulled
• An Install button

To add a community store:

https://casaos-appstore.paodayag.dev/zip

https://github.com/bigbeartechworld/big-bear-casaos/archive/refs/heads/master.zip

Step 5: Install Your First Apps

Let's deploy four common self-hosted apps. Each takes one click.

Jellyfin -- Your Personal Netflix

After installation the Jellyfin tile appears on your dashboard. Click it to launch the Jellyfin setup wizard on port 8096. Point it at the /media volume to start indexing your library. For a deeper Jellyfin walkthrough see our Jellyfin install guide.

Nextcloud -- Your Private Drive

Once installed, open the Nextcloud tile and complete the first-run wizard. The Nextcloud install guide covers tuning for more than a handful of users.

Home Assistant -- Smart Home Hub

Home Assistant binds to port 8123 by default. See the Home Assistant install guide for integrations and automations.

Syncthing -- Dropbox Replacement

Syncthing runs on port 8384. Pair it with your phone using the Syncthing install guide for bidirectional file sync without any cloud middleman.

After installing these four, your CasaOS dashboard shows four clickable tiles, each launching directly into the app's web UI.

Step 6: Use the File Manager (SMB and WebDAV)

Click the Files tile. CasaOS presents a dual-pane file manager rooted at /DATA. This is the canonical location for all app data, media, and shared files. From here you can:

• Upload and download files in the browser
• Create folders, rename, move, copy, and delete
• Preview images, videos, PDFs, and text files
• Extract ZIP and TAR archives

Share over SMB (Windows/macOS network drive)

CasaOS does not ship Samba by default. Install and configure it manually:

sudo apt install -y samba
sudo tee -a /etc/samba/smb.conf > /dev/null <<EOF
[casaos]
   path = /DATA
   browseable = yes
   read only = no
   guest ok = no
   valid users = @casaos
EOF

Create a Samba user matching your CasaOS admin:

sudo smbpasswd -a your-username
sudo systemctl restart smbd

Now map \\your-server-ip\casaos on Windows (File Explorer → Map Network Drive) or smb://your-server-ip/casaos on macOS (Finder → Go → Connect to Server).

Share over WebDAV

WebDAV is easier to expose through a reverse proxy. CasaOS's Files app already speaks WebDAV internally. To enable external WebDAV access, install the community WebDAV Server app from BigBear's store, point it at /DATA, and expose it via your Tailscale tunnel (see next section).

Step 7: Import Existing Docker Containers

If you already run containers on this server — perhaps you followed our Docker install guide before discovering CasaOS — you can adopt them into the CasaOS dashboard without recreating them.

CasaOS uses a Docker label to recognize which containers belong to its UI:

casaos=<app-name>

To import an existing container, restart it with the label:

docker stop my-existing-app
docker rm my-existing-app
docker run -d \
  --name my-existing-app \
  --label casaos=my-existing-app \
  -p 9000:9000 \
  -v /DATA/AppData/my-app:/config \
  ghcr.io/example/my-app:latest

CasaOS picks up the container on its next scan (typically within 30 seconds) and shows a tile on the dashboard. You can also import a full Docker Compose stack via App Store → Install a customized app → Import. Paste a Compose YAML and CasaOS converts it to an app entry.

The Portainer app (one-click install) gives you a full Docker UI alongside CasaOS if you need fine-grained network, volume, and image management.

Step 8: Change the Default Port (Optional)

CasaOS binds to port 80 out of the box. If you already run Nginx, Caddy, or Apache on that port, or you want CasaOS behind a reverse proxy, change its listening port.

Edit the gateway config:

sudo nano /etc/casaos/gateway.ini

Find and change:

[gateway]
port = 80

to:

[gateway]
port = 8099

Restart the gateway:

sudo systemctl restart casaos-gateway

CasaOS is now at http://your-server-ip:8099/. Port 80 is free for your existing web server. From there you can proxy casa.yourdomain.com to 127.0.0.1:8099 via Nginx or Caddy with standard reverse-proxy config — just remember to forward the Host, X-Real-IP, and X-Forwarded-Proto headers and enable WebSocket upgrades for the file manager.

Step 9: Remote Access with Tailscale and TLS

Exposing CasaOS directly to the public internet is risky -- the dashboard is a single credential away from full Docker control. Use Tailscale for private remote access, and add Let's Encrypt only if you truly need public DNS.

Option A (Recommended): Tailscale Private Network

Tailscale builds a zero-config WireGuard mesh between your devices. Your VPS becomes reachable only by machines signed into your Tailscale tailnet.

Install Tailscale on the VPS:

curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

Follow the authentication URL and sign in. Note the Tailscale IP (usually 100.x.y.z) shown at the end.

CasaOS ships a Tailscale integration as a one-click app as well (App Store → Tailscale) if you prefer to manage it from the UI rather than the CLI. Either route, once Tailscale is up you access the dashboard at http://100.x.y.z/ from any device on the tailnet -- no public port, no TLS cert required. For an extra niceness layer, enable MagicDNS in the Tailscale admin console and visit http://casaos/ directly.

IceWhale also bundles ZeroTier configuration snippets in the CasaOS installer for users who prefer ZeroTier over Tailscale. Both work; Tailscale tends to be simpler for first-timers.

Option B: Public Access with Caddy and Let's Encrypt

If you need public access (for example, to share a Jellyfin library with family), put Caddy in front with automatic TLS.

First, change CasaOS to port 8099 as shown in Step 8. Then install Caddy:

sudo apt install -y caddy

Create /etc/caddy/Caddyfile:

casa.yourdomain.com {
    reverse_proxy 127.0.0.1:8099
    encode gzip
}

Point an A record for casa.yourdomain.com at your server IP, then reload:

sudo systemctl reload caddy

Caddy provisions a Let's Encrypt certificate automatically on first request. Your dashboard is now at https://casa.yourdomain.com/ with a valid certificate and HTTP-to-HTTPS redirect.

Before exposing publicly: ensure you have a strong admin password, consider adding fail2ban (see Fail2ban install guide), and ideally add Caddy basic auth as a second layer.

Step 10: Backups and Updates

Backup Strategy

CasaOS stores everything you care about in two places:

A simple nightly backup with Restic to an S3-compatible bucket:

sudo apt install -y restic
export RESTIC_REPOSITORY="s3:https://your-s3-endpoint/casaos-backups"
export RESTIC_PASSWORD="your-strong-passphrase"
restic init
restic backup /DATA /var/lib/casaos /etc/casaos

Add it to cron via sudo crontab -e:

0 3   * /usr/bin/restic backup /DATA /var/lib/casaos /etc/casaos

For point-in-time Docker volume backups, install the Duplicati app from the store and configure it through the GUI.

Updates

CasaOS has a built-in updater. Open Settings → System → Check for Updates and click Update when one is available. Alternatively, run the same installer script; it detects an existing install and upgrades in place:

curl -fsSL https://get.casaos.io | sudo bash

Individual apps update from the App Store: click an app tile → Settings → Update. Watch the Docker image tag; CasaOS pins to latest by default, which is fine for most apps but worth reviewing for anything mission-critical (Nextcloud, Vaultwarden).

CasaOS vs. Umbrel, Cosmos, Runtipi, and Yunohost

Several projects compete in the "friendly self-hosted OS" space. Quick comparison:

Pick Cosmos if security-by-default (auth, TLS, WAF out of the box) matters more than catalog size.

Pick Umbrel if you primarily want a Bitcoin/Lightning node with a side of media apps.

Pick Yunohost if you want a turnkey email + groupware server and do not mind a Debian-only, non-Docker stack.

Troubleshooting

Viewing Logs

Tail the gateway and app-management logs while reproducing an issue:

sudo journalctl -u casaos-gateway -u casaos -u casaos-app-management -f

For a specific app container:

docker logs -f <container-name>

FAQ

Is CasaOS safe to expose to the internet?

Not directly. The default install serves its dashboard over HTTP on port 80 and relies entirely on the password you set at first login. Always front it with a reverse proxy that terminates TLS, and ideally only expose CasaOS via a private network like Tailscale. If you must expose it publicly, add Caddy or Nginx with Let's Encrypt, enable fail2ban, and consider HTTP basic auth as a second factor.

How much RAM do I need for CasaOS plus apps?

CasaOS itself uses about 150-250 MB of RAM idle. Each app adds its own overhead: Jellyfin 200-500 MB idle (more while transcoding), Nextcloud 300-500 MB, Home Assistant 300-600 MB, Vaultwarden 50-100 MB, Syncthing 80-150 MB. A 2 GB VPS comfortably runs CasaOS plus 3-4 lightweight apps; upgrade to 4 GB if you plan to run Jellyfin, Nextcloud, and Home Assistant simultaneously.

Can I run CasaOS alongside an existing Docker setup?

Yes. CasaOS installs Docker only if it is missing, and it does not take over existing containers unless they carry the casaos=<name> label. Your current Compose projects keep working exactly as before. You can even surface them in the CasaOS dashboard by adding the label without recreating the containers from scratch, as shown in Step 7.

Does CasaOS work on a Raspberry Pi as well as a VPS?

Yes. CasaOS officially supports ARM64 (Raspberry Pi 4/5, ZimaBoard, Rock Pi, Orange Pi) and x86_64 architectures. The installer detects the architecture automatically. The same guide above works on a Pi with Ubuntu 24.04 ARM; swap the VPS for your Pi's IP and you are done. That said, VPS deployments give you better uptime, static IPs, faster bandwidth, and no power/network concerns at home.

How does CasaOS compare to TrueNAS Scale or Unraid?

TrueNAS Scale and Unraid are NAS operating systems first, with apps bolted on. They manage ZFS pools, RAID, and user quotas, and they replace your entire OS installation. CasaOS is the opposite: it is an app layer that sits on top of any existing Linux install, and it does not touch your storage layout. If you want the NAS features (ZFS scrubs, SMB quotas, snapshot replication), pick TrueNAS or Unraid. If you already have a VPS or a Linux server and just want a friendly app store and dashboard, pick CasaOS.

Can I install custom Docker Compose apps?

Yes. In the App Store click Install a customized app. You can either paste a Docker image name and configure ports/volumes through a form, or click Import and paste a docker-compose.yml. CasaOS translates the Compose file into its internal app format and starts the stack. This is the fastest way to deploy anything not in the store, and you can edit the YAML later from the app's Settings → Compose tab.

Next Steps

Now that CasaOS is running, here are productive directions to take your personal cloud:

• Harden the VPS -- Install fail2ban and CrowdSec to block SSH and web brute-force attempts before they reach CasaOS.
• Add a reverse proxy -- Deploy Caddy for automatic HTTPS in front of every CasaOS app, so each service gets its own https://jellyfin.yourdomain.com-style URL.
• Set up off-site backups -- Install Duplicati from the App Store and point it at Backblaze B2 or an S3-compatible bucket for nightly encrypted backups of /DATA.
• Expand your media library -- Install Radarr, Sonarr, Prowlarr, and qBittorrent from the App Store to automate your Jellyfin library (and always respect the licensing of content you add).
• Self-host your passwords -- Add Vaultwarden from the App Store. It speaks the Bitwarden protocol, so all official Bitwarden clients work against it -- pointed at https://vault.yourdomain.com via Caddy.
• Build a smart home -- Pair the Home Assistant install guide with Zigbee2MQTT in the CasaOS App Store to control lights, sensors, and thermostats from anywhere over Tailscale.

Skip the Manual Install -- Get CasaOS Pre-Installed

Our CloudCore Starter VPS plans ship with a one-click CasaOS image pre-configured for remote access via Tailscale and HTTPS via Caddy. Deploy a complete personal cloud in 90 seconds.

- CasaOS dashboard pre-installed and hardened

- Caddy reverse proxy with Let's Encrypt wired up

- Tailscale ready to authenticate on first boot

- /DATA mounted on a 100 GB NVMe volume

- systemd services tuned for low-memory VPS

Launch Your CasaOS VPS Now -- Plans start at EUR 7.99/month.