Intro

Hey there! Today, we’re going to walk through setting up your very own monitoring system using a cool open-source tool called Uptime Kuma.

You know how it is – after a while, using hosted platforms like UptimeRobot can feel limiting. You’re stuck with their subscription levels, and you don’t have full control over your data. But when you run everything yourself, those aren’t problems anymore. You get to control your metrics, have awesome dashboards, and set up alerts through things like Telegram.

We’re going to start with a fresh Ubuntu server and build our way up to a secure, ready-to-go monitoring setup.

By the end of this guide, you’ll have a service up and running behind HTTPS. It’ll start automatically if your server restarts, and you’ll be able to reach it through your own domain. Sounds good? Let’s start!

---

What We’re Going to Do

We’ll break this down into a few easy steps:

1. Get the server ready and install Docker.
2. Get Uptime Kuma going inside a Docker container.
3. Set up Nginx as a reverse proxy so you can use your domain.
4. Get a free Let’s Encrypt SSL certificate for secure HTTPS.

SPONSORED

Running Uptime Kuma reliably requires a stable VPS with full root access. A good option is Fornex VPS — a trusted hosting provider with 16 years of experience in infrastructure services.

• ⚡ High-performance NVMe storage
• 🌍 Multiple European data centers
• 🔒 Full root access for Docker deployments
• 💰 Affordable plans suitable for small monitoring setups

Even an entry-level VPS with 1–2 GB RAM is enough to run Uptime Kuma, Docker, and Nginx for monitoring multiple websites and services.

Learn more

What You’ll Need

Before we get started, here’s what you should have:

• A server with Ubuntu on it (any recent version should work).
• A domain name that’s already pointing to your server’s IP address.

For this example, we’ll use:

status.your-domain.com

Got those things ready? Let’s get started!

---

Step 1 — Get the Server Ready and Install Docker

First, we need to set up the basics.

If you already have Docker and Docker Compose installed, you can skip this part.

# First, let's update the package list and grab some dependencies:
sudo apt update
sudo apt install -y apt-transport-https ca-certificates curl software-properties-common

# Next, let's add Docker's official GPG key:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Now, let's add the Docker repository to your system
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Time to install the Docker engine and Compose
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

To save you from typing sudo all the time, add your user to the Docker group:

sudo usermod -aG docker ${USER}

⚠ Important: Log out and log back in for this to work!

---

Step 2 — Run Uptime Kuma in Docker

Using docker-compose is a good way to keep things organized. All of your settings will be in one easy-to-read file.

1. Let’s make a spot for our project:

mkdir uptime-kumacd uptime-kuma

2. Now for the config file:

nano docker-compose.yml

3. Paste in this:

   version: '3.3'

services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    volumes:
      - ./uptime-kuma-data:/app/data
    ports:
      - "3001:3001"
    restart: always

4. Volumes

This part’s important. The uptime-kuma-data folder on your server is linked to the container. This is where all your settings, monitoring info, and history goes. Even if the container goes away, your data sticks around.

5. Restart Policy

restart: always

This tells Docker to bring the container back up if it crashes or if the server restarts—exactly what we want.

6. Save the file and let’s get it going:

docker-compose up -d

In a few seconds, your monitoring platform should be up.

Go to:

http://-server-ip:3001

You should see Uptime Kuma’s setup screen.

---

Step 3 — Set Up Nginx as a Reverse Proxy

Instead of typing in raw IP addresses, let’s use a proper domain.

1. Install Nginx:

sudo apt install nginx -y

2. Time to allow web traffic through the firewall:

sudo ufw allow 'Nginx Full'

3. Let’s create a virtual host setup:

sudo nano /etc/nginx/sites-available/status.your-domain.com

4. Add this server block:

      server {
    listen 80;
    server_name status.your-domain.com;

    location / {
        proxy_pass http://localhost:3001;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        
        # Эти строки нужны для корректной работы WebSocket
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Those WebSocket settings are needed for the real-time updates in the monitoring UI.

5. Turn on the config:

sudo ln -s /etc/nginx/sites-available/status.your-domain.com /etc/nginx/sites-enabled/

6. Turn off the default Nginx site to avoid issues:

sudo rm /etc/nginx/sites-enabled/default

7. Test the setup:

sudo nginx -t
# Wenn wir „Syntax ist in Ordnung“ und „Test ist erfolgreich“ sehen, ist alles in Ordnung
sudo systemctl reload nginx 

Now you should be able to get to your monitoring dashboard at:

http://status.your-domain.com

One last thing – let’s secure it.

---

Step 4 — Turn on HTTPS with Let’s Encrypt

Browsers don’t like websites that aren’t secure. Good thing Let’s Encrypt gives out free certificates.

1. Install Certbot and its Nginx stuff:

sudo apt install certbot python3-certbot-nginx -y

2. Ask for the certificate:

sudo certbot --nginx -d status.your-domain.com

Certbot will ask for:

• your email address
• that you agree to their terms
• if you want to redirect HTTP traffic to HTTPS

Pick the redirect option for the best security.

Once it’s done, you’ll be able to get to your site via:

https://status.your-domain.com

The certificates will renew on their own.

Troubleshooting

Things don’t always go as planned. If something’s not working right, these tips can usually help.

Problem 1 — Site Doesn’t Load (Connection Timed Out)

This usually means traffic isn’t reaching your server.

Check DNS

Make sure your domain is pointing in the right place:

ping status.your-domain.com

The IP you get back should be your server’s IP.

If not, update the A record at your domain provider.

Check Firewall Rules

See what your firewall’s doing:

sudo ufw status

Make sure ports 80 and 443 are allowed.

If not:

sudo ufw allow 'Nginx Full'

Problem 2 — 502 Bad Gateway

This happens when Nginx can’t talk to the app behind it.

Check the Container

docker ps

Look for:

uptime-kuma

Okay, so in the list, you should see a container called uptime-kuma, and it should say Up. If it’s not there or keeps restarting, check its logs to see what’s up.

Check Container Logs

Logs can show you what went wrong.

docker-compose logs -f

or

docker logs -f uptime-kuma

Look for lines that include:

• error
• failed
• permission denied

File permissions are often the cause.

Check Internal Connectivity

See if the service is responding locally:

curl -I http://localhost:3001

You should see:

HTTP/1.1 200 OK

or

HTTP/1.1 302 Found

If you see Connection refused, the container isn’t working right.

Problem 3 — 400 Bad Request After Turning on HTTPS

This usually means the SSL setup isn’t quite done.

Check Nginx Config

Open:

/etc/nginx/sites-available/status.your-domain.com

Make sure you have:

listen 443 ssl;ssl_certificatessl_certificate_key

Check Nginx Error Logs

tail -f /var/log/nginx/error.log

Refresh your browser and watch the log.

Some common messages:

cannot load certificate

Make sure the certificate files are in:

/etc/letsencrypt/live/status.your-domain.com/

port 443 already in use

Find the process:

sudo ss -tlnp | grep ':443'

Stop the process if needed.

After any changes, reload Nginx:

sudo nginx -tsudo systemctl reload nginx

All Done!

You’re all set.

Go to:

https://status.your-domain.com

and you’ll see your monitoring interface.

What We Did:

• Got Uptime Kuma running in a Docker container
• Set up domain access with Nginx
• Secured it with HTTPS
• Made sure the container restarts if the server restarts
• Set up SSL certificates to renew automatically

Now you can set up your monitors, track uptime, and get alerts in Telegram, or whatever you use.

Your systems are now watching themselves!

Happy monitoring!