{"id":2623,"date":"2026-11-01T00:20:03","date_gmt":"2026-10-31T21:20:03","guid":{"rendered":"https:\/\/www.fibacloud.com\/community\/tutorials\/?p=2623"},"modified":"2026-11-01T00:20:03","modified_gmt":"2026-10-31T21:20:03","slug":"install-uptime-kuma","status":"publish","type":"post","link":"https:\/\/www.fibacloud.com\/community\/tutorials\/en\/install-uptime-kuma\/","title":{"rendered":"Install Uptime Kuma: Website Monitoring and Status Pages"},"content":{"rendered":"<p>Uptime Kuma is an open-source monitoring tool that checks your websites and services at regular intervals and can notify you when a check fails. In this guide, we will add Uptime Kuma to an existing Coolify server, sign in over HTTPS, and configure an HTTP monitor, a webhook notification and a public status page. We will then observe a controlled application failure and recovery, back up the persistent data and test restoring it.<\/p>\n<p>A green indicator on a dashboard is only part of the job. You also need to check that the monitor uses the right target, changes state during a failure and delivers its notification. The practical sections below cover those steps together.<\/p>\n<h2 id=\"test-environment\">Test environment and prerequisites<\/h2>\n<p>This installation path requires a working Coolify dashboard and server connection. If you are starting with a fresh VPS, complete <a href=\"https:\/\/www.fibacloud.com\/community\/tutorials\/en\/install-coolify-vps\/\">Install Coolify on a VPS and Deploy Your First App<\/a> first. We will use the existing proxy; a second web server will not be bound to the same ports 80 and 443.<\/p>\n<p>The installation was performed on 31 October 2026 on a FibaCloud VPS running Ubuntu 24.04.5 LTS, with 2 vCPUs and a 4 GB memory plan. It used the existing Coolify installation; the monitored test application was installed on a separate VPS. This setup is not a capacity limit or a guarantee for a particular number of websites.<\/p>\n<table>\n<thead>\n<tr>\n<th>Component<\/th>\n<th>Verified version or selection<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Uptime Kuma<\/td>\n<td>2.5.9; official rootless image pinned by digest.<\/td>\n<\/tr>\n<tr>\n<td>Database<\/td>\n<td>SQLite selected in the first-run setup screen.<\/td>\n<\/tr>\n<tr>\n<td>Coolify<\/td>\n<td>4.5.3.<\/td>\n<\/tr>\n<tr>\n<td>Docker \/ Compose<\/td>\n<td>29.9.2 \/ 5.6.1.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>Verified outcome:<\/strong> the lab checked HTTPS and two-factor login, the live WebSocket connection, two HTTP\/HTTPS monitors, Down\/Up webhook delivery during a real HTTP 503 drill, a public status page, and same-host restoration from a full data backup. Installation began on 31 October; final checks completed on 1 November 2026 in Turkey time.<\/p>\n<ul>\n<li>Permission to create projects and resources in Coolify, plus SSH and administrative access to the VPS.<\/li>\n<li>A subdomain pointing to the VPS public IP address. Replace <code>uptime.example.com<\/code> with your own hostname. Correct any AAAA record that points to an unrelated IPv6 address.<\/li>\n<li>A web address you own and a separate test application that you can safely interrupt.<\/li>\n<li>A webhook receiver under your control for notification testing. This guide does not use another person&#8217;s notification address or a public webhook collection service.<\/li>\n<li>Enough disk space for a data backup and a private location for a copy outside the server.<\/li>\n<\/ul>\n<p>For remote access, see <a href=\"https:\/\/www.fibacloud.com\/community\/tutorials\/en\/how-to-connect-to-a-remote-server-via-ssh\/\">How to Connect to a Remote Server with SSH<\/a>. If images, containers and volumes are new to you, <a href=\"https:\/\/www.fibacloud.com\/community\/tutorials\/en\/how-to-deploy-an-application-with-docker-docker-installation-and-management\/\">Install Docker and Deploy an App on Ubuntu<\/a> explains those building blocks.<\/p>\n<h2 id=\"monitor-placement\">Where should Uptime Kuma run?<\/h2>\n<p>Uptime Kuma sends each check from the server where it runs. If it shares a VPS with the application, it can observe an application failure. If that VPS shuts down entirely, the monitor also stops and cannot send a new alert. To monitor external availability, run Kuma on a server independent of the target, preferably somewhere that does not share the same likely network or provider failure.<\/p>\n<p>An HTTP check measures the response from a particular address. A home page returning 200 does not prove that sign-in, checkout or database writes work. If your application has a health endpoint that checks its real dependencies without exposing sensitive data, you can monitor that endpoint separately.<\/p>\n<table>\n<thead>\n<tr>\n<th>Check<\/th>\n<th>What it shows<\/th>\n<th>What it does not establish by itself<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>HTTP\/HTTPS<\/td>\n<td>Whether the selected URL returns an accepted HTTP response.<\/td>\n<td>That every user workflow succeeds.<\/td>\n<\/tr>\n<tr>\n<td>Application health endpoint<\/td>\n<td>The state of dependencies actually checked by that endpoint.<\/td>\n<td>Workflows omitted from its health check.<\/td>\n<\/tr>\n<tr>\n<td>Status page<\/td>\n<td>The monitors you choose to share and the incident updates you publish.<\/td>\n<td>Independent incident communication when the monitoring server is unreachable.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>In this guide&#8217;s test, Kuma and its target application run on separate VPSs. Access from the monitoring server to the target&#8217;s <code>\/health<\/code> address was verified with an HTTP 200 response. We will trigger the controlled failure on that target. Separate servers can still share a provider or common network dependencies.<\/p>\n<h2 id=\"compose-installation\">Create the Uptime Kuma service in Coolify<\/h2>\n<p>We will enter a Docker Compose definition in Coolify so the selected image and persistent data mount are visible in one resource. HTTP monitoring does not require access to the Docker socket.<\/p>\n<ol>\n<li>Open <strong>Projects<\/strong> and create a monitoring project or select an existing one. The test used a new project named <code>FibaCloud Monitoring Lab<\/code>; its <code>production<\/code> environment was created automatically.<\/li>\n<li>Select <strong>New Resource<\/strong> in that environment.<\/li>\n<li>Choose <strong>Deploy<\/strong> on the <strong>Docker Compose<\/strong> card. This creates a service from a Compose definition without connecting a Git repository.<\/li>\n<\/ol>\n<figure><img loading=\"lazy\" src=\"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-project.png\" alt=\"The empty production environment in FibaCloud Monitoring Lab and its New Resource button.\" width=\"1152\" height=\"321\"  decoding=\"async\"><figcaption>The monitoring service will be added to the new project&#8217;s production environment.<\/figcaption><\/figure>\n<figure><img loading=\"lazy\" src=\"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-compose-resource.png\" alt=\"The Docker Compose resource card and Deploy button in Coolify.\" width=\"380\" height=\"219\"  decoding=\"async\"><figcaption>Use Docker Compose to enter the service definition directly.<\/figcaption><\/figure>\n<p>Paste the following definition into <strong>Docker Compose file<\/strong> and select <strong>Create Service<\/strong>. It is intended for a fresh installation with a new volume. The initial configuration publishes no hostname and binds port 13001 only to the VPS loopback address.<\/p>\n<div class=\"fc-code-example\">\n<pre><code>services:\n  uptime-kuma:\n    image: louislam\/uptime-kuma:2.5.9-rootless@sha256:ea1b2ceb6ef710a3d0d994debcc8cded062e534fb901f6e895f59caad68e0a9e\n    restart: unless-stopped\n    ports:\n      - \"127.0.0.1:13001:3001\"\n    volumes:\n      - uptime-kuma-data:\/app\/data\n    security_opt:\n      - no-new-privileges:true\n    labels:\n      - \"traefik.enable=false\"\n\nvolumes:\n  uptime-kuma-data:\n<\/code><\/pre>\n<\/div>\n<p>Choose a descriptive name under <strong>General \u2192 Service name<\/strong>; the test used <code>FibaCloud Uptime Kuma<\/code>. Select <strong>Save changes<\/strong>. Leave <strong>Network attachment<\/strong> set to <strong>Use the stack network only<\/strong>.<\/p>\n<p>Check that <strong>Domains<\/strong> has no configured hostname. Keep <code>traefik.enable=false<\/code> for this step, then select <strong>Deploy<\/strong>. Watch <strong>Runtime Logs<\/strong> and the resource status until the service starts. On the first run, waiting for a user to choose the database is expected.<\/p>\n<p>The test confirmed that the image ran as <code>node<\/code> with UID\/GID <code>1000:1000<\/code>, the new data volume was writable and the service health check passed. No additional root container or manual ownership change was needed. This result does not cover moving an existing v1 data directory to a rootless image.<\/p>\n<p><code>\/app\/data<\/code> contains Uptime Kuma&#8217;s persistent data. Keep the same volume attached when recreating the container. Do not leave the data in the container&#8217;s disposable filesystem; the official installation instructions do not support network filesystems such as NFS for this data.<\/p>\n<h3 id=\"first-account\">Protect the first administrator setup<\/h3>\n<p>Do not leave a fresh installation&#8217;s first-account form publicly accessible. Create the administrator through a connection restricted to you, then publish the HTTPS hostname. Choose a unique password and save it in a password manager.<\/p>\n<p>Run the following command on your own computer, not on the VPS. Replace <code>203.0.113.10<\/code> with the IP address of the Kuma server and, if necessary, replace <code>root<\/code> with your SSH user. Keep the terminal open:<\/p>\n<div class=\"fc-code-example\">\n<pre><code>ssh -N -L 127.0.0.1:13001:127.0.0.1:13001 root@203.0.113.10\n<\/code><\/pre>\n<\/div>\n<p>Open <code>http:\/\/localhost:13001<\/code> in your browser. Access between your computer and the remote server goes through this SSH tunnel. If local port 13001 is already in use, change only the first local port number and use that new port in the browser.<\/p>\n<ol>\n<li>The first screen asks <strong>Which database would you like to use?<\/strong> Select <strong>SQLite<\/strong> for the single-database-file setup used here.<\/li>\n<li>Select <strong>Next<\/strong>. After database preparation, the <strong>Create your admin account<\/strong> form opens.<\/li>\n<li>Fill in <strong>Username<\/strong>, <strong>Password<\/strong> and <strong>Repeat Password<\/strong>, then select <strong>Create<\/strong>.<\/li>\n<li>Confirm that <strong>Dashboard<\/strong> opens. A fresh installation shows <strong>No Monitors, please add one<\/strong> because you have not created any monitors yet.<\/li>\n<\/ol>\n<figure><img loading=\"lazy\" src=\"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-database-sqlite.png\" alt=\"SQLite selected in Uptime Kuma's first-run database screen, with the Next button below.\" width=\"640\" height=\"665\"  decoding=\"async\"><figcaption>This installation selected SQLite before creating the administrator account.<\/figcaption><\/figure>\n<p>The test completed this sequence and opened an empty Dashboard after administrator creation. During initial setup, direct access remained bound to <code>127.0.0.1:13001<\/code> and no public proxy route had been added.<\/p>\n<p>After creating the account, open <strong>Settings \u2192 Security \u2192 2FA Settings<\/strong>. Enter your password in <strong>Current Password<\/strong> and click <strong>Enable 2FA<\/strong>. Scan the generated QR code with your authenticator, enter its current code, and complete <strong>Verify Token \u2192 Save \u2192 Yes<\/strong>. The tested account changed to <strong>Active<\/strong>. Keep the QR code and setup secret out of shared documents.<\/p>\n<p>Check a fresh login separately. In this test, a new HTTPS session asked for a <strong>Token<\/strong> after the username and password; entering the valid code and selecting <strong>Log in<\/strong> opened the Dashboard.<\/p>\n<h3 id=\"domain-and-https\">Finish the hostname and HTTPS configuration<\/h3>\n<p>Point your subdomain&#8217;s DNS record to the Kuma VPS. Open the service&#8217;s <strong>Domains \u2192 Add Domain<\/strong> screen in Coolify and enter:<\/p>\n<table>\n<thead>\n<tr>\n<th>Field<\/th>\n<th>Value<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Service application<\/td>\n<td><code>uptime-kuma<\/code><\/td>\n<\/tr>\n<tr>\n<td>Protocol<\/td>\n<td><code>https<\/code><\/td>\n<\/tr>\n<tr>\n<td>Domain<\/td>\n<td>Your hostname, such as <code>uptime.example.com<\/code>, without a scheme or port.<\/td>\n<\/tr>\n<tr>\n<td>Port<\/td>\n<td><code>3001<\/code><\/td>\n<\/tr>\n<tr>\n<td>Path<\/td>\n<td>Leave empty.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Select <strong>Save<\/strong>. In <strong>General \u2192 Edit Compose File<\/strong>, remove the bootstrap-only <code>traefik.enable=false<\/code> label and the <code>labels:<\/code> line if it would otherwise be empty. Preserve the other image, volume and port settings, save the Compose change and redeploy the service.<\/p>\n<figure><img loading=\"lazy\" src=\"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-https-domain.png\" alt=\"Coolify Add domain dialog with the HTTPS protocol, Uptime Kuma hostname and internal port 3001.\" width=\"896\" height=\"362\"  decoding=\"async\"><figcaption>3001 is the container port reached by the proxy; the browser uses the normal HTTPS address.<\/figcaption><\/figure>\n<p>Open <code>https:\/\/uptime.example.com<\/code> in the browser without adding <code>:3001<\/code>. The <code>127.0.0.1:13001<\/code> binding can remain for private maintenance access; it does not need to be published on <code>0.0.0.0<\/code>.<\/p>\n<p>The tested hostname, <code>docs-uptime.fibacloud.com<\/code>, served a trusted Let\u2019s Encrypt certificate on port 443 and redirected HTTP to HTTPS. A fresh browser session completed two-factor login, and its <code>wss:\/\/<\/code> WebSocket exchanged data. This checked the dashboard\u2019s live connection as well as its HTML response.<\/p>\n<p>The Uptime Kuma dashboard uses a live connection. If the page loads but reports connection errors, check more than the HTML response: the proxy must also pass WebSocket traffic. Use a dedicated subdomain instead of mounting the application under a subdirectory such as <code>\/uptime<\/code>.<\/p>\n<p>The dashboard and status page can share a hostname. Your account protects the management area while only the selected status page is public. Check that distinction in a separate browser window without an authenticated session.<\/p>\n<h2 id=\"test-target\">Prepare a separate HTTP target for the failure test<\/h2>\n<p>You can monitor your own website without this small application. To test failure and recovery under controlled conditions, run the target below on a separate test VPS. Its <code>\/health<\/code> address normally returns 200 and returns 503 only while a maintenance file created through SSH is present.<\/p>\n<p><a href=\"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-examples.zip\">Download the test target and webhook receiver source package<\/a>. It contains the Python sources, Dockerfiles and Compose definitions used in this guide, without passwords, real event logs or application backups. The command below verifies the archive hash and its source-file checksums.<\/p>\n<p>Run this step on the <strong>second VPS<\/strong>, with Docker, Compose, <code>curl<\/code> and <code>unzip<\/code> available. It stops if the directory, container, network or port 18889 is already in use; inspect an existing installation instead of deleting it to proceed.<\/p>\n<div class=\"fc-code-example\">\n<pre><code>sudo bash &lt;&lt;'TARGET_SETUP'\nset -euo pipefail\numask 077\nif [ -e \/root\/fibacloud-uptime-target ] || \\\n   docker container inspect fibacloud-uptime-target &gt;\/dev\/null 2&gt;&amp;1 || \\\n   docker image inspect fibacloud-uptime-target:20261031 &gt;\/dev\/null 2&gt;&amp;1 || \\\n   docker network inspect fibacloud-uptime-target_default &gt;\/dev\/null 2&gt;&amp;1; then\n  echo 'Example namespace already exists; inspect it before continuing.' &gt;&amp;2\n  exit 1\nfi\nif [ -n \"$(ss -H -ltn 'sport = :18889')\" ]; then\n  echo 'TCP 18889 is already in use.' &gt;&amp;2\n  exit 1\nfi\ninstall -d -m 0700 \/root\/fibacloud-uptime-target\ncd \/root\/fibacloud-uptime-target\ncurl -fSL 'https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-examples.zip' -o examples.zip\nprintf '%s  examples.zip\\n' '74f3d8808903f7d53266ebff1ce056fc5185eae1027031b190a688c57b9e959d' | sha256sum -c -\nunzip -q examples.zip -d package\n(cd package &amp;&amp; sha256sum -c SHA256SUMS)\ninstall -m 0600 package\/target\/Dockerfile package\/target\/compose.yaml package\/target\/target.py .\ninstall -d -m 0755 state\ndocker compose config --quiet\ndocker compose up -d --build\ndocker compose ps\nTARGET_SETUP\n<\/code><\/pre>\n<\/div>\n<p>Check the HTTP response on the target server:<\/p>\n<div class=\"fc-code-example\">\n<pre><code>curl --retry 10 --retry-connrefused --retry-delay 1 --retry-max-time 30 -fsS http:\/\/127.0.0.1:18889\/health\n<\/code><\/pre>\n<\/div>\n<p>The running target returns <code>{\"status\":\"ok\",\"service\":\"fibacloud-uptime-target\"}<\/code>. Next, test access <strong>from the Kuma VPS<\/strong> using the target&#8217;s public IP address. Replace the example IP below with your second VPS:<\/p>\n<div class=\"fc-code-example\">\n<pre><code>curl -fsS -w '\\nHTTP %{http_code}\\n' http:\/\/203.0.113.20:18889\/health\n<\/code><\/pre>\n<\/div>\n<p>The separate-server check returned HTTP 200 in this test. If it cannot connect, check access to 18889\/TCP in the target server&#8217;s and provider&#8217;s network rules. This port serves only a fixed test response; monitor your real application&#8217;s health endpoint through its own HTTPS configuration.<\/p>\n<h2 id=\"http-monitor\">Add the first HTTP\/HTTPS monitor<\/h2>\n<p>Give the monitor a descriptive name. When you monitor several applications, names such as <code>Customer portal \u2014 sign-in page<\/code> or <code>API \u2014 health endpoint<\/code> make a notification easier to identify than a generic <code>Website<\/code> label.<\/p>\n<p>Select <strong>Add New Monitor<\/strong>, choose <strong>HTTP(s)<\/strong> under <strong>Monitor Type<\/strong>, and enter a <strong>Friendly Name<\/strong> and your target <strong>URL<\/strong>. The test created two separate monitors:<\/p>\n<table>\n<thead>\n<tr>\n<th>Monitor<\/th>\n<th>Target<\/th>\n<th>Scope<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Independent HTTP endpoint<\/td>\n<td><code>http:\/\/194.116.236.155:18889\/health<\/code> on a separate VPS<\/td>\n<td>The controlled 503 failure test. This public HTTP endpoint carries no confidential data and does not test certificates.<\/td>\n<\/tr>\n<tr>\n<td>Coolify HTTPS application<\/td>\n<td><code>https:\/\/docs-coolify-app.fibacloud.com\/health<\/code><\/td>\n<td>The HTTPS response of the application from our previous Coolify guide. This application shares the Kuma VPS, so this monitor cannot independently detect that entire VPS shutting down.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>These addresses identify the guide&#8217;s test environment. Use your own targets in your installation; you can use the separate target created above for the first monitor.<\/p>\n<table>\n<thead>\n<tr>\n<th>Setting<\/th>\n<th>Value used in the test<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Heartbeat Interval<\/td>\n<td><code>60<\/code> seconds<\/td>\n<\/tr>\n<tr>\n<td>Retries<\/td>\n<td><code>1<\/code><\/td>\n<\/tr>\n<tr>\n<td>Heartbeat Retry Interval<\/td>\n<td><code>20<\/code> seconds<\/td>\n<\/tr>\n<tr>\n<td>Request Timeout<\/td>\n<td><code>5<\/code> seconds<\/td>\n<\/tr>\n<tr>\n<td>Resend Notification if Down X times consecutively<\/td>\n<td><code>0<\/code>; repeated notifications during an ongoing failure are disabled.<\/td>\n<\/tr>\n<tr>\n<td>HTTP Options \u2192 Method<\/td>\n<td><code>GET<\/code><\/td>\n<\/tr>\n<tr>\n<td>Accepted Status Codes<\/td>\n<td><code>200-299<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<figure><img loading=\"lazy\" src=\"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-monitor-settings.png\" alt=\"Actual HTTP monitor settings with a 60-second interval, one retry, a 20-second retry interval and a 5-second timeout.\" width=\"475\" height=\"855\"  decoding=\"async\"><figcaption>The outage test uses these explicitly selected check and retry settings.<\/figcaption><\/figure>\n<p>For the HTTPS target, <strong>Certificate Expiry Notification<\/strong> was enabled and <strong>Ignore TLS\/SSL errors for HTTPS websites<\/strong> was left off. Do not hide certificate errors just to obtain a green state. This guide did not create an expired certificate to test its alert; it verified real HTTPS access with these settings. <strong>Domain Name Expiry Notification<\/strong> is disabled for both monitors.<\/p>\n<p>Select <strong>Save<\/strong> and wait for the first check. Set the fields explicitly instead of assuming which defaults a new monitor uses.<\/p>\n<p>The check interval determines how often a new request is sent. The timeout limits how long an individual request can wait, while retries affect additional attempts before a failed check changes the state. Shorter intervals generate more requests. Choose values that fit your expected response times and alerting needs; overly aggressive values can turn brief network delays into noisy alarms.<\/p>\n<p>If the target normally returns 200, verify that behavior. An application that serves its error page with status 200 can still look healthy to a basic HTTP check. Use a meaningful health endpoint or a separate response-content check for that case.<\/p>\n<p>Both monitors reached <strong>Up<\/strong> with an HTTP 200 response on their first check. The screenshot below shows the independent VPS target&#8217;s first successful check.<\/p>\n<figure><img loading=\"lazy\" src=\"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-monitor-up.png\" alt=\"The actual Independent HTTP endpoint URL, 60-second check interval and Up state.\" width=\"950\" height=\"350\"  decoding=\"async\"><figcaption>The first successful check confirms that the HTTP target is reachable.<\/figcaption><\/figure>\n<p>A newly created monitor&#8217;s percentage figures are not a long-term service history. Labels such as 24 hours, 30 days or one year do not mean that measurements have already been collected for those periods.<\/p>\n<h2 id=\"webhook-notification\">Add a webhook notification and verify delivery<\/h2>\n<p>A webhook sends an HTTP request to the address you configure when the monitor changes state. Saving a notification in Kuma and processing that request at the receiver are separate steps. Check the test both in the Kuma interface and in the receiver&#8217;s records.<\/p>\n<h3 id=\"webhook-receiver\">Start the private test receiver<\/h3>\n<p>Install the receiver from the source package on the <strong>Kuma VPS<\/strong>. This small service runs only on a private Docker network and publishes no host port. It records the notification type, time and state so that we can verify actual arrival.<\/p>\n<div class=\"fc-code-example\">\n<pre><code>sudo bash &lt;&lt;'RECEIVER_SETUP'\nset -euo pipefail\numask 077\nif [ -e \/root\/fibacloud-uptime-lab ] || \\\n   docker container inspect fibacloud-uptime-webhook &gt;\/dev\/null 2&gt;&amp;1 || \\\n   docker image inspect fibacloud-uptime-webhook:20261031 &gt;\/dev\/null 2&gt;&amp;1 || \\\n   docker network inspect fibacloud-uptime-webhook &gt;\/dev\/null 2&gt;&amp;1 || \\\n   docker volume inspect fibacloud-uptime-webhook-events &gt;\/dev\/null 2&gt;&amp;1; then\n  echo 'Example namespace already exists; inspect it before continuing.' &gt;&amp;2\n  exit 1\nfi\ninstall -d -m 0700 \/root\/fibacloud-uptime-lab\/receiver\ncd \/root\/fibacloud-uptime-lab\/receiver\ncurl -fSL 'https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-examples.zip' -o examples.zip\nprintf '%s  examples.zip\\n' '74f3d8808903f7d53266ebff1ce056fc5185eae1027031b190a688c57b9e959d' | sha256sum -c -\nunzip -q examples.zip -d package\n(cd package &amp;&amp; sha256sum -c SHA256SUMS)\ninstall -m 0600 package\/receiver\/Dockerfile package\/receiver\/compose.yaml package\/receiver\/receiver.py .\ndocker compose config --quiet\ndocker compose up -d --build\ndocker compose ps\nRECEIVER_SETUP\n<\/code><\/pre>\n<\/div>\n<p>Once <code>docker compose ps<\/code> reports the receiver as <code>healthy<\/code>, open <strong>General \u2192 Edit Compose File<\/strong> for the Kuma service in Coolify. With the administrator already created, preserve the HTTPS domain setting and save the following complete Compose definition:<\/p>\n<div class=\"fc-code-example\">\n<pre><code>services:\n  uptime-kuma:\n    image: louislam\/uptime-kuma:2.5.9-rootless@sha256:ea1b2ceb6ef710a3d0d994debcc8cded062e534fb901f6e895f59caad68e0a9e\n    restart: unless-stopped\n    ports:\n      - \"127.0.0.1:13001:3001\"\n    volumes:\n      - uptime-kuma-data:\/app\/data\n    security_opt:\n      - no-new-privileges:true\n    networks:\n      - webhook\nvolumes:\n  uptime-kuma-data:\nnetworks:\n  webhook:\n    external: true\n    name: fibacloud-uptime-webhook\n<\/code><\/pre>\n<\/div>\n<p>Leave <strong>Network attachment<\/strong> set to <strong>Use the stack network only<\/strong>. Select <strong>Save changes<\/strong> and redeploy the service. Kuma keeps its existing persistent volume; the added <code>webhook<\/code> network lets it reach the private receiver. Coolify manages the connection to its proxy network.<\/p>\n<p>The receiver&#8217;s container health check and HTTP 200 response were verified in the test. It has no publicly published port. The <code>webhook-receiver<\/code> name is therefore resolved by Kuma on the shared Docker network, not by your browser.<\/p>\n<h3 id=\"notification-settings\">Attach the notification to the monitor<\/h3>\n<p>Open <strong>Settings \u2192 Notifications \u2192 Set Up Notification<\/strong> and enter these settings:<\/p>\n<table>\n<thead>\n<tr>\n<th>Field<\/th>\n<th>Tested selection<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Notification Type<\/td>\n<td>Webhook<\/td>\n<\/tr>\n<tr>\n<td>Friendly Name<\/td>\n<td>Docs Lab Webhook<\/td>\n<\/tr>\n<tr>\n<td>Post URL<\/td>\n<td><code>http:\/\/webhook-receiver:8080\/events<\/code><\/td>\n<\/tr>\n<tr>\n<td>HTTP Method<\/td>\n<td>POST<\/td>\n<\/tr>\n<tr>\n<td>Request Body<\/td>\n<td><strong>Preset &#8211; application\/json<\/strong><\/td>\n<\/tr>\n<tr>\n<td>Additional Headers<\/td>\n<td>Off; this receiver is reachable only through its private Docker network.<\/td>\n<\/tr>\n<tr>\n<td>Default enabled<\/td>\n<td>Off; new monitors do not inherit this notification automatically.<\/td>\n<\/tr>\n<tr>\n<td>Apply on all existing monitors<\/td>\n<td>On; assigns the notification to the two existing test monitors.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Explicitly select <strong>Preset &#8211; application\/json<\/strong> in <strong>Request Body<\/strong>. In the first form opened during the test, this required field was empty: a <strong>Test<\/strong> request arrived, but browser validation blocked <strong>Save<\/strong>. Selecting the option allowed the notification to be saved.<\/p>\n<figure><img loading=\"lazy\" src=\"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-webhook-settings.png\" alt=\"Uptime Kuma Webhook form with POST, JSON request body and assignment to existing monitors.\" width=\"500\" height=\"922\"  decoding=\"async\"><figcaption>This receiver URL is for the private Docker network created in this guide.<\/figcaption><\/figure>\n<p>Click <strong>Test<\/strong>, confirm success, then click <strong>Save<\/strong>. On the Kuma VPS, read the receiver\u2019s event records:<\/p>\n<div class=\"fc-code-example\">\n<pre><code>sudo docker exec fibacloud-uptime-webhook cat \/data\/events.jsonl\n<\/code><\/pre>\n<\/div>\n<p>The actual test request reached the receiver at <code>20:53:25 UTC<\/code> on 31 October 2026 and was recorded as <code>kind: test<\/code>. That proves the connection test; the outage drill below separately checks Down and Up delivery. If you do not want to assign it to every existing monitor, leave the bulk option off and enable the intended notification in each relevant monitor\u2019s edit screen.<\/p>\n<p>If the webhook URL or an additional header contains an access token, keep it out of screenshots and shared documents. When you connect the receiver to another automation, check more than its HTTP success response: confirm the correct service, state and timestamp reached the intended workflow.<\/p>\n<p>This guide tests delivery to a controlled webhook receiver. If you choose Telegram, Discord, SMTP or another notification method, configure your own account details and perform a separate real delivery test for that channel.<\/p>\n<h2 id=\"outage-test\">Test a controlled failure and recovery<\/h2>\n<p>Use a dedicated test target for this step, away from customer traffic. Temporarily make that target return a failing response. Stopping Kuma itself or the shared proxy would change the scope of an application-failure test.<\/p>\n<p>If you installed this guide\u2019s target, run the following command on the <strong>second VPS<\/strong>. It creates one maintenance file in the dedicated test directory without restarting the target container:<\/p>\n<div class=\"fc-code-example\">\n<pre><code>sudo python3 - &lt;&lt;&#x27;PYTHON&#x27;\nfrom pathlib import Path\nroot = Path(&#x27;\/root\/fibacloud-uptime-target\/state&#x27;)\nassert root.is_dir() and not root.is_symlink()\nflag = root \/ &#x27;maintenance&#x27;\nassert not flag.exists() and not flag.is_symlink()\nwith flag.open(&#x27;x&#x27;) as stream:\n    stream.write(&#x27;Controlled FibaCloud documentation test\\n&#x27;)\nflag.chmod(0o644)\nPYTHON\ncurl -sS -w &#x27;\\nHTTP %{http_code}\\n&#x27; http:\/\/127.0.0.1:18889\/health\n<\/code><\/pre>\n<\/div>\n<p>The response should show <code>HTTP 503<\/code>. Keep <strong>Independent HTTP endpoint<\/strong> open in Kuma. After the configured retry, wait for <strong>Down<\/strong> and a <code>status: 0<\/code> event at the receiver. Then remove only this drill\u2019s maintenance file on the same target VPS:<\/p>\n<div class=\"fc-code-example\">\n<pre><code>sudo python3 - &lt;&lt;&#x27;PYTHON&#x27;\nfrom pathlib import Path\nroot = Path(&#x27;\/root\/fibacloud-uptime-target\/state&#x27;)\nassert root.is_dir() and not root.is_symlink()\nflag = root \/ &#x27;maintenance&#x27;\nassert flag.is_file() and not flag.is_symlink()\nassert flag.read_text() == &#x27;Controlled FibaCloud documentation test\\n&#x27;\nflag.unlink()\nPYTHON\ncurl -fsS -w &#x27;\\nHTTP %{http_code}\\n&#x27; http:\/\/127.0.0.1:18889\/health\n<\/code><\/pre>\n<\/div>\n<p>Once the target returns <code>HTTP 200<\/code>, wait for Kuma\u2019s next check. Seeing <strong>Up<\/strong> and receiving <code>status: 1<\/code> are separate checks. Read the receiver records with the <code>docker exec<\/code> command from the previous section.<\/p>\n<p>The first check after a failure, any retries and notification delivery happen at separate times. The results below describe this experiment with the selected settings; they are not a promise that every outage will be detected in the same number of seconds.<\/p>\n<table>\n<thead>\n<tr>\n<th>Observed event<\/th>\n<th>31 October 2026, UTC<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Target switched to HTTP 503.<\/td>\n<td>20:56:41.362<\/td>\n<\/tr>\n<tr>\n<td>Kuma recorded Down.<\/td>\n<td>20:57:36.285<\/td>\n<\/tr>\n<tr>\n<td>Receiver recorded the Down webhook.<\/td>\n<td>20:57:36.348<\/td>\n<\/tr>\n<tr>\n<td>Target restored to HTTP 200.<\/td>\n<td>20:58:36.690<\/td>\n<\/tr>\n<tr>\n<td>Kuma recorded Up.<\/td>\n<td>20:59:36.289<\/td>\n<\/tr>\n<tr>\n<td>Receiver recorded the Up webhook.<\/td>\n<td>20:59:36.333<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Using the timestamps recorded by the hosts, Down appeared after about <strong>55 seconds<\/strong> and Up after about <strong>60 seconds<\/strong>. These are observations from one controlled run, not a general latency bound or SLA. The table uses UTC; the dashboard screenshots display Turkey time, UTC+3.<\/p>\n<figure><img loading=\"lazy\" src=\"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-monitor-down.png\" alt=\"Actual Uptime Kuma monitor showing Down after the controlled HTTP 503 response.\" width=\"940\" height=\"350\"  decoding=\"async\"><figcaption>The monitor changed to Down when the separate test target returned an error.<\/figcaption><\/figure>\n<figure><img loading=\"lazy\" src=\"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-recovery-history.png\" alt=\"Uptime Kuma history showing initial Up, Down caused by HTTP 503, and recovery to Up with HTTP 200.\" width=\"940\" height=\"560\"  decoding=\"async\"><figcaption>History retains both the outage and recovery; the receiver independently recorded both notifications.<\/figcaption><\/figure>\n<p>Return the target to a healthy state when the test is complete. Confirm that the monitor reports <strong>Up<\/strong> again and that a recovery notification reaches the receiver. A working initial alert does not by itself verify the recovery path.<\/p>\n<h2 id=\"public-status-page\">Create a public status page<\/h2>\n<p>Only add monitors that are appropriate to share. Review names containing internal hostnames, private administration endpoints or customer names before publishing them. A service name and its current state are often enough for your users.<\/p>\n<ol>\n<li>Open <strong>Status Pages<\/strong> in the top menu and create a new status page.<\/li>\n<li>In <strong>Add New Status Page<\/strong>, enter <strong>Name<\/strong> and <strong>Slug<\/strong>, then click <strong>Next<\/strong>. The test used <code>FibaCloud Docs Lab Status<\/code> and slug <code>docs-lab<\/code>.<\/li>\n<li>Review <strong>Title<\/strong> and <strong>Description<\/strong> in the editor. The test description explicitly identifies a documentation lab and says it does not represent FibaCloud service availability.<\/li>\n<li>Select a monitor from <strong>Add a monitor<\/strong>; repeat for the second one. The test automatically created a <strong>Services<\/strong> group containing both monitors.<\/li>\n<li>Click <strong>Save<\/strong>. Check <code>https:\/\/uptime.example.com\/status\/docs-lab<\/code> in a signed-out browser, replacing the hostname with your own.<\/li>\n<\/ol>\n<p>In the test, administration still required login while a separate anonymous browser could open the status page. Both initial monitors were healthy and the page showed <strong>All Systems Operational<\/strong>. A few minutes of new history is not evidence of long-term availability.<\/p>\n<p>You can add a short incident update for planned maintenance or an outage under investigation. State the affected service, start time and what is known. Avoid an unconfirmed root cause or a promised resolution time, and update the notice when the issue is resolved.<\/p>\n<p>During the drill, <strong>Create Incident<\/strong> was selected in the status-page editor. The <strong>Title<\/strong> and <strong>Content<\/strong> identified a controlled outage on a separate test target, then <strong>Post<\/strong> published the notice. After recovery, <strong>Edit<\/strong> updated the text, <strong>Post<\/strong> saved it, and <strong>Resolve<\/strong> closed the incident.<\/p>\n<p>The final anonymous-browser check showed <strong>All Systems Operational<\/strong>, with the completed notice under <strong>Past Incidents<\/strong>. It recorded the target\u2019s return to HTTP 200 at 20:58:36 UTC and the verified Kuma and webhook recovery at 20:59:36 UTC.<\/p>\n<figure><img loading=\"lazy\" src=\"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-content\/uploads\/2026\/10\/fibacloud-uptime-kuma-20261031\/uptime-kuma-status-page.png\" alt=\"Public status page with two healthy monitors, visible outage history, and the completed test notice under Past Incidents.\" width=\"1300\" height=\"770\"  decoding=\"async\"><figcaption>Actual anonymous status-page capture. Percentages cover only this roughly 18-minute test history; they do not measure FibaCloud service availability.<\/figcaption><\/figure>\n<p>If Kuma and the status page share a server, that server&#8217;s failure also takes the page offline. Plan an independent status page or another communication channel if you need to communicate during a complete infrastructure outage.<\/p>\n<h2 id=\"backup-and-restore\">Back up persistent data and test a restore<\/h2>\n<p>A persistent volume keeps data across container replacements; it is not a second copy you can use after losing the server disk. Uptime Kuma 2 removed the old JSON import\/export feature. This procedure takes a consistent backup of the complete <code>\/app\/data<\/code> contents.<\/p>\n<p>The backup can contain the administrator account, monitor settings, history and notification credentials. Keep it private, restrict access and retain a protected copy outside the server. Screenshots or a Compose file alone are not an application-data backup.<\/p>\n<p>First match the Coolify resource to its running container. On the Kuma VPS, list the containers:<\/p>\n<div class=\"fc-code-example\">\n<pre><code>sudo docker ps --format &#x27;table {{.Names}}\\t{{.Image}}\\t{{.Status}}&#x27;\n<\/code><\/pre>\n<\/div>\n<p>Replace <code>REPLACE_WITH_YOUR_RESOURCE_ID<\/code> below with your actual resource ID. This recipe adapts the tested stop, full-volume archive and same-container start operations for readers. It targets SQLite and Docker\u2019s default local-volume path; do not apply it directly to another database or data location. Avoid concurrent Coolify deployments while it runs.<\/p>\n<div class=\"fc-code-example\">\n<pre><code>sudo bash &lt;&lt;&#x27;KUMA_BACKUP&#x27;\nset -euo pipefail\numask 077\nKUMA_CONTAINER=&#x27;uptime-kuma-REPLACE_WITH_YOUR_RESOURCE_ID&#x27;\n[[ &quot;$KUMA_CONTAINER&quot; != *REPLACE* ]]\nKUMA_ID=&quot;$(docker container inspect --format &#x27;{{.Id}}&#x27; &quot;$KUMA_CONTAINER&quot;)&quot;\nKUMA_VOLUME=&quot;$(docker container inspect --format &#x27;{{range .Mounts}}{{if and (eq .Destination &quot;\/app\/data&quot;) (eq .Type &quot;volume&quot;)}}{{println .Name}}{{end}}{{end}}&#x27; &quot;$KUMA_ID&quot;)&quot;\n[[ &quot;$KUMA_VOLUME&quot; =~ ^[a-zA-Z0-9][a-zA-Z0-9_.-]+$ ]]\nKUMA_DATA=&quot;$(docker volume inspect --format &#x27;{{.Mountpoint}}&#x27; &quot;$KUMA_VOLUME&quot;)&quot;\n[[ &quot;$KUMA_DATA&quot; == &quot;\/var\/lib\/docker\/volumes\/$KUMA_VOLUME\/_data&quot; ]]\n[[ &quot;$(realpath &quot;$KUMA_DATA&quot;)&quot; == &quot;$KUMA_DATA&quot; ]]\n[[ -f &quot;$KUMA_DATA\/kuma.db&quot; &amp;&amp; -f &quot;$KUMA_DATA\/db-config.json&quot; ]]\n[[ &quot;$(docker ps -aq --no-trunc --filter &quot;volume=$KUMA_VOLUME&quot;)&quot; == &quot;$KUMA_ID&quot; ]]\n[[ &quot;$(docker container inspect --format &#x27;{{.State.Running}}&#x27; &quot;$KUMA_ID&quot;)&quot; == true ]]\nKUMA_BACKUP_DIR=&quot;$(mktemp -d \/root\/kuma-backup-XXXXXXXX)&quot;\nprintf &#x27;%s\\n&#x27; &quot;$KUMA_CONTAINER&quot; &gt; &quot;$KUMA_BACKUP_DIR\/container-name.txt&quot;\nprintf &#x27;%s\\n&#x27; &quot;$KUMA_ID&quot; &gt; &quot;$KUMA_BACKUP_DIR\/container-id.txt&quot;\ndocker container inspect --format &#x27;{{.Image}}&#x27; &quot;$KUMA_ID&quot; &gt; &quot;$KUMA_BACKUP_DIR\/image-id.txt&quot;\nprintf &#x27;%s\\n&#x27; &quot;$KUMA_VOLUME&quot; &gt; &quot;$KUMA_BACKUP_DIR\/volume-name.txt&quot;\ndocker container inspect --format &#x27;{{.Config.Image}}&#x27; &quot;$KUMA_ID&quot; &gt; &quot;$KUMA_BACKUP_DIR\/image.txt&quot;\ntrap &#x27;if [[ &quot;$(docker container inspect --format &quot;{{.State.Running}}&quot; &quot;$KUMA_ID&quot;)&quot; == false ]]; then docker start &quot;$KUMA_ID&quot; &gt;\/dev\/null; fi&#x27; EXIT\ndocker stop --time 30 &quot;$KUMA_ID&quot;\n[[ &quot;$(docker container inspect --format &#x27;{{.State.Running}}&#x27; &quot;$KUMA_ID&quot;)&quot; == false ]]\n[[ -z &quot;$(docker ps -q --filter &quot;volume=$KUMA_VOLUME&quot;)&quot; ]]\ntar --numeric-owner --acls --xattrs --one-file-system \\\n  -czpf &quot;$KUMA_BACKUP_DIR\/data.tar.gz&quot; -C &quot;$KUMA_DATA&quot; .\nchmod 0600 &quot;$KUMA_BACKUP_DIR\/data.tar.gz&quot;\n(cd &quot;$KUMA_BACKUP_DIR&quot; &amp;&amp; sha256sum data.tar.gz &gt; data.sha256)\ntar -tzf &quot;$KUMA_BACKUP_DIR\/data.tar.gz&quot; &gt; &quot;$KUMA_BACKUP_DIR\/members.txt&quot;\ndocker start &quot;$KUMA_ID&quot;\ntrap - EXIT\nKUMA_HEALTHY=false\nfor attempt in {1..60}; do\n  if [[ &quot;$(docker container inspect --format &#x27;{{.State.Running}} {{.State.Health.Status}}&#x27; &quot;$KUMA_ID&quot;)&quot; == &quot;true healthy&quot; ]]; then\n    KUMA_HEALTHY=true\n    break\n  fi\n  sleep 2\ndone\nif [[ &quot;$KUMA_HEALTHY&quot; != true ]]; then\n  docker container inspect --format &#x27;{{json .State}}&#x27; &quot;$KUMA_ID&quot;\n  exit 1\nfi\nprintf &#x27;Backup directory: %s\\n&#x27; &quot;$KUMA_BACKUP_DIR&quot;\nKUMA_BACKUP\n<\/code><\/pre>\n<\/div>\n<p>The command resolves the actual volume from the container\u2019s <code>\/app\/data<\/code> mount instead of guessing its name. It stops if another container also uses that volume. Kuma and the status page on this server are briefly unavailable during the backup. If archive reading fails, the exit handler tries to restart the same container; check the output and resulting service state.<\/p>\n<p>Keep the printed <code>\/root\/kuma-backup-\u2026<\/code> directory. Its <code>data.tar.gz<\/code>, checksum and resource-identity files are used together during restoration. The recipe waits up to roughly two minutes for <strong>healthy<\/strong>; if that wait fails, it exits with an error and displays the container state.<\/p>\n<p>The real backup included <code>kuma.db<\/code>, <code>db-config.json<\/code>, <code>docker-tls<\/code>, <code>screenshots<\/code>, <code>upload<\/code> and the data-directory metadata, preserving ownership and permissions. An encrypted copy was also stored privately on another server, then decrypted and verified against the file hashes and archive members. Use your own backup system to keep an encrypted off-host copy and test reading it; the command above creates only the local backup.<\/p>\n<h3 id=\"restore-test\">Restore on the same server<\/h3>\n<p>A restore returns the data to the state in the chosen backup. Records created after that backup may not survive. Before starting, take a separate copy of the current data and verify that you selected the correct volume.<\/p>\n<p>After the backup, the test created a third monitor named <code>Restore canary - created after backup<\/code>, left its notifications disabled, and paused it. This provides a recovery marker that a simple restart cannot reproduce: loading the earlier backup must remove the newly created monitor.<\/p>\n<p>Replace both variables below with your container and the backup directory created above. This recipe requires the same container ID, image and volume; it is not a migration to another server. Use only your own trusted archive with its verified checksum.<\/p>\n<div class=\"fc-code-example\">\n<pre><code>sudo bash &lt;&lt;&#x27;KUMA_RESTORE&#x27;\nset -euo pipefail\numask 077\nKUMA_CONTAINER=&#x27;uptime-kuma-REPLACE_WITH_YOUR_RESOURCE_ID&#x27;\nKUMA_BACKUP_DIR=&#x27;\/root\/kuma-backup-REPLACE_WITH_YOUR_DIRECTORY&#x27;\n[[ &quot;$KUMA_CONTAINER$KUMA_BACKUP_DIR&quot; != *REPLACE* ]]\n[[ -d &quot;$KUMA_BACKUP_DIR&quot; &amp;&amp; ! -L &quot;$KUMA_BACKUP_DIR&quot; ]]\n[[ &quot;$(realpath &quot;$KUMA_BACKUP_DIR&quot;)&quot; == &quot;$KUMA_BACKUP_DIR&quot; ]]\n[[ &quot;$(cat &quot;$KUMA_BACKUP_DIR\/container-name.txt&quot;)&quot; == &quot;$KUMA_CONTAINER&quot; ]]\n(cd &quot;$KUMA_BACKUP_DIR&quot; &amp;&amp; sha256sum -c data.sha256)\nKUMA_ID=&quot;$(docker container inspect --format &#x27;{{.Id}}&#x27; &quot;$KUMA_CONTAINER&quot;)&quot;\n[[ &quot;$KUMA_ID&quot; == &quot;$(cat &quot;$KUMA_BACKUP_DIR\/container-id.txt&quot;)&quot; ]]\n[[ &quot;$(docker container inspect --format &#x27;{{.Image}}&#x27; &quot;$KUMA_ID&quot;)&quot; == &quot;$(cat &quot;$KUMA_BACKUP_DIR\/image-id.txt&quot;)&quot; ]]\n[[ &quot;$(docker container inspect --format &#x27;{{.Config.Image}}&#x27; &quot;$KUMA_ID&quot;)&quot; == &quot;$(cat &quot;$KUMA_BACKUP_DIR\/image.txt&quot;)&quot; ]]\nKUMA_VOLUME=&quot;$(docker container inspect --format &#x27;{{range .Mounts}}{{if and (eq .Destination &quot;\/app\/data&quot;) (eq .Type &quot;volume&quot;)}}{{println .Name}}{{end}}{{end}}&#x27; &quot;$KUMA_ID&quot;)&quot;\n[[ &quot;$KUMA_VOLUME&quot; =~ ^[a-zA-Z0-9][a-zA-Z0-9_.-]+$ ]]\n[[ &quot;$KUMA_VOLUME&quot; == &quot;$(cat &quot;$KUMA_BACKUP_DIR\/volume-name.txt&quot;)&quot; ]]\nKUMA_DATA=&quot;$(docker volume inspect --format &#x27;{{.Mountpoint}}&#x27; &quot;$KUMA_VOLUME&quot;)&quot;\n[[ &quot;$KUMA_DATA&quot; == &quot;\/var\/lib\/docker\/volumes\/$KUMA_VOLUME\/_data&quot; ]]\n[[ &quot;$(realpath &quot;$KUMA_DATA&quot;)&quot; == &quot;$KUMA_DATA&quot; ]]\n[[ &quot;$(docker ps -aq --no-trunc --filter &quot;volume=$KUMA_VOLUME&quot;)&quot; == &quot;$KUMA_ID&quot; ]]\npython3 - &quot;$KUMA_BACKUP_DIR\/data.tar.gz&quot; &lt;&lt;&#x27;ARCHIVE_CHECK&#x27;\nimport sys, tarfile\nfrom pathlib import PurePosixPath\nwith tarfile.open(sys.argv[1], &#x27;r:gz&#x27;) as archive:\n    seen = set()\n    for member in archive.getmembers():\n        path = PurePosixPath(member.name)\n        assert not path.is_absolute() and &#x27;..&#x27; not in path.parts\n        assert member.isfile() or member.isdir()\n        assert str(path) not in seen\n        seen.add(str(path))\n    assert &#x27;kuma.db&#x27; in seen and &#x27;db-config.json&#x27; in seen\nARCHIVE_CHECK\nKUMA_RESCUE_DIR=&quot;$(mktemp -d \/root\/kuma-before-restore-XXXXXXXX)&quot;\ndocker stop --time 30 &quot;$KUMA_ID&quot;\n[[ &quot;$(docker container inspect --format &#x27;{{.State.Running}}&#x27; &quot;$KUMA_ID&quot;)&quot; == false ]]\n[[ -z &quot;$(docker ps -q --filter &quot;volume=$KUMA_VOLUME&quot;)&quot; ]]\ntar --numeric-owner --acls --xattrs --one-file-system \\\n  -czpf &quot;$KUMA_RESCUE_DIR\/newer-data.tar.gz&quot; -C &quot;$KUMA_DATA&quot; .\n(cd &quot;$KUMA_RESCUE_DIR&quot; &amp;&amp; sha256sum newer-data.tar.gz &gt; newer-data.sha256)\ntar -tzf &quot;$KUMA_RESCUE_DIR\/newer-data.tar.gz&quot; &gt; &quot;$KUMA_RESCUE_DIR\/members.txt&quot;\nmkdir -m 0700 &quot;$KUMA_RESCUE_DIR\/quarantine&quot;\nfind &quot;$KUMA_DATA&quot; -mindepth 1 -maxdepth 1 \\\n  -exec mv -t &quot;$KUMA_RESCUE_DIR\/quarantine&quot; -- {} +\ntar --same-owner --acls --xattrs \\\n  -xzpf &quot;$KUMA_BACKUP_DIR\/data.tar.gz&quot; -C &quot;$KUMA_DATA&quot;\ntar --compare --gzip --file &quot;$KUMA_BACKUP_DIR\/data.tar.gz&quot; --directory &quot;$KUMA_DATA&quot;\ndocker start &quot;$KUMA_ID&quot;\nKUMA_HEALTHY=false\nfor attempt in {1..60}; do\n  if [[ &quot;$(docker container inspect --format &#x27;{{.State.Running}} {{.State.Health.Status}}&#x27; &quot;$KUMA_ID&quot;)&quot; == &quot;true healthy&quot; ]]; then\n    KUMA_HEALTHY=true\n    break\n  fi\n  sleep 2\ndone\nif [[ &quot;$KUMA_HEALTHY&quot; != true ]]; then\n  docker container inspect --format &#x27;{{json .State}}&#x27; &quot;$KUMA_ID&quot;\n  exit 1\nfi\nprintf &#x27;Newer state preserved in: %s\\n&#x27; &quot;$KUMA_RESCUE_DIR&quot;\nKUMA_RESTORE\n<\/code><\/pre>\n<\/div>\n<p>The procedure first backs up the newer state and moves its current files into <code>quarantine<\/code>. It then extracts the earlier archive into the same volume and requires <code>tar --compare<\/code> to pass before starting Kuma. A failure after stopping does not force continuation or delete the preserved state: inspect Kuma\u2019s status and resolve the error using the retained current copy.<\/p>\n<p>The real restore used the verified decrypted copy of the encrypted backup stored on the other server. Before the service started, file contents, UID\/GID values and permissions matched the earlier backup; the paused monitor created after that backup was absent. The same Kuma container became healthy, and the existing Coolify application remained intact.<\/p>\n<table>\n<thead>\n<tr>\n<th>Post-restore check<\/th>\n<th>Observed result<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Fresh browser login<\/td>\n<td>Password and TOTP opened the Dashboard.<\/td>\n<\/tr>\n<tr>\n<td>Monitors<\/td>\n<td>The two original monitors were Up; the paused test monitor created after the backup was absent.<\/td>\n<\/tr>\n<tr>\n<td>Earlier outage history<\/td>\n<td>The 20:57:36 UTC Down and 20:59:36 UTC Up events remained.<\/td>\n<\/tr>\n<tr>\n<td>Notification<\/td>\n<td>Test succeeded with the restored webhook configuration; the receiver recorded a new test event at 21:05:32 UTC.<\/td>\n<\/tr>\n<tr>\n<td>Public status page<\/td>\n<td>An anonymous browser opened both monitors and the completed notice under Past Incidents.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>This demonstrates restoration of the earlier application state as well as a successful service start. Loss of the server, migration to another VPS, and rollback after a version upgrade were outside this drill\u2019s scope.<\/p>\n<p>A disaster-recovery plan must also account for hostname routing, Coolify access and proxy configuration. Rehearse replacement-server recovery separately from the restore scope demonstrated here.<\/p>\n<h2 id=\"maintenance-and-troubleshooting\">Maintenance and troubleshooting<\/h2>\n<table>\n<thead>\n<tr>\n<th>Symptom<\/th>\n<th>What to check<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>The hostname does not load or the proxy returns an error.<\/td>\n<td>Check A\/AAAA records, the running Kuma service and the internal port selected for the domain. Do not bind a second service to the same host port.<\/td>\n<\/tr>\n<tr>\n<td>The page loads but the live connection fails.<\/td>\n<td>Check WebSocket forwarding and the browser&#8217;s network records. Publish on a subdomain rather than a subdirectory.<\/td>\n<\/tr>\n<tr>\n<td>The site loads in your browser but its monitor fails.<\/td>\n<td>The request comes from the Kuma server. Check that server&#8217;s DNS, IPv4\/IPv6, TLS and access through the target firewall.<\/td>\n<\/tr>\n<tr>\n<td>The monitor stays Up on an error page.<\/td>\n<td>Inspect the response status code. An error served as 200 needs a more meaningful health endpoint or content check.<\/td>\n<\/tr>\n<tr>\n<td>The state changes but no notification arrives.<\/td>\n<td>Verify that the notification is assigned to that monitor, its test succeeds and the receiver records the actual event.<\/td>\n<\/tr>\n<tr>\n<td>Redeployment opens the first-account form again.<\/td>\n<td>Check the <code>\/app\/data<\/code> mount and actual volume name before creating another account. An empty or different volume may be attached.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Read the release notes before changing the image tag, take a consistent backup and account for monitoring pauses during maintenance. Recheck sign-in, monitors, notifications and the status page afterward. Returning to an older image alone is not a recovery plan if the database schema has changed.<\/p>\n<p>Track disk usage and choose a history-retention period that fits your needs. Uptime Kuma focuses on service availability; the <a href=\"https:\/\/www.fibacloud.com\/community\/tutorials\/en\/installing-grafana-on-ubuntu\/\">Grafana guide<\/a> covers a different layer for detailed infrastructure and application metrics.<\/p>\n<h2 id=\"frequently-asked-questions\">Frequently asked questions<\/h2>\n<h3 id=\"is-uptime-kuma-free\">Is Uptime Kuma free?<\/h3>\n<p>Uptime Kuma is open source. When you host it yourself, you still pay for the server, storage and any notification provider you choose.<\/p>\n<h3 id=\"install-without-coolify\">Can I install it without Coolify?<\/h3>\n<p>Yes. The project also supports direct Docker installation. This article uses an existing Coolify proxy and service management; a bare-metal or separate Nginx installation is outside this procedure.<\/p>\n<h3 id=\"monitoring-on-the-same-vps\">Is running it on the same VPS as my application enough?<\/h3>\n<p>It can help detect a failing application response. Independent detection of that VPS or its network becoming unreachable requires a separate monitoring server.<\/p>\n<h3 id=\"single-monitor-scope\">Can one monitor cover everything?<\/h3>\n<p>Each monitor tests only the target and conditions you configure. Create separate checks for the web interface, API or dependencies as needed, while avoiding duplicate alarms that add no useful information.<\/p>\n<h2 id=\"sources\">Sources<\/h2>\n<ul>\n<li><a href=\"https:\/\/github.com\/louislam\/uptime-kuma\/releases\/tag\/2.5.9\" rel=\"nofollow noopener\" target=\"_blank\">Uptime Kuma 2.5.9 release<\/a><\/li>\n<li><a href=\"https:\/\/github.com\/louislam\/uptime-kuma\/blob\/2.5.9\/README.md\" rel=\"nofollow noopener\" target=\"_blank\">Uptime Kuma installation and features<\/a><\/li>\n<li><a href=\"https:\/\/github.com\/louislam\/uptime-kuma\/wiki\/Reverse-Proxy\" rel=\"nofollow noopener\" target=\"_blank\">Uptime Kuma reverse proxy documentation<\/a><\/li>\n<li><a href=\"https:\/\/github.com\/louislam\/uptime-kuma\/wiki\/Migration-From-v1-To-v2\" rel=\"nofollow noopener\" target=\"_blank\">Uptime Kuma v2 changes and data backup<\/a><\/li>\n<li><a href=\"https:\/\/coolify.io\/docs\/applications\/builds\/docker-compose\" rel=\"nofollow noopener\" target=\"_blank\">Coolify Docker Compose documentation<\/a><\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>Install Uptime Kuma with Coolify. Set up HTTPS, website checks, webhook alerts and a status page, then test a controlled outage and data restoration.<\/p>\n","protected":false},"author":1,"featured_media":2625,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[7],"tags":[261,100,296],"class_list":["post-2623","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-tutorials-en","tag-docker","tag-ubuntu","tag-uptime-kuma-en"],"lang":"en","translations":{"en":2623,"tr":2622},"pll_sync_post":[],"_links":{"self":[{"href":"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-json\/wp\/v2\/posts\/2623","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-json\/wp\/v2\/comments?post=2623"}],"version-history":[{"count":1,"href":"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-json\/wp\/v2\/posts\/2623\/revisions"}],"predecessor-version":[{"id":2627,"href":"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-json\/wp\/v2\/posts\/2623\/revisions\/2627"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-json\/wp\/v2\/media\/2625"}],"wp:attachment":[{"href":"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-json\/wp\/v2\/media?parent=2623"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-json\/wp\/v2\/categories?post=2623"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.fibacloud.com\/community\/tutorials\/wp-json\/wp\/v2\/tags?post=2623"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}