---
title: Deploy Uptime Kuma
url: "/guides/uptime-kuma/"
canonical_url: https://docs.blossom88.com/guides/uptime-kuma/
markdown_url: https://docs.blossom88.com/guides/uptime-kuma.md
summary: Deploy Uptime Kuma on your own cloud with Blossom BYOC, Shared MariaDB, a
  private HTTPS dashboard, and uptime checks for your apps.
categories:
- deployment
- monitoring
---

# Deploy Uptime Kuma

Run [Uptime Kuma](https://github.com/louislam/uptime-kuma) on Blossom and keep
your monitors and history in managed MariaDB. Your dashboard gets HTTPS and
Account member access.

Connect your cloud provider and save a
[Blossom BYOC (bring your own cloud) Location](/learn/getting-started/choose-your-cloud/#blossom-byoc).
Then [install the Blossom CLI and skill](/learn/getting-started/install/)
on your coding agent's machine. Choose that BYOC Location when you log in.
The same deployment steps work on Blossom Cloud if you want Blossom to supply
the infrastructure.

## Ask Your Agent


> **Ask your AI agent:** Deploy https://github.com/louislam/uptime-kuma on Blossom and help me monitor
> my apps. Show me the setup before deploying.



Your agent checks the Account and Location, then works through the setup with
you. For this guide, choose Shared MariaDB to keep the monitors and history in
a managed database, and Account member access for the dashboard.

| Choice | Setup in this guide |
|---|---|
| Image | Official Uptime Kuma 2 Docker image |
| Web Service | One Micro Container: 0.25 vCPU / 437.5 MB |
| Saved data | Shared MariaDB |
| Dashboard access | Account members, then your Kuma login |
| Scaling | One active Container |

Run one active Kuma Container. Each Kuma process schedules its own monitors,
so adding replicas repeats the probes rather than sharing them. Keep
autoscaling off for this app.

Our deployment with 17 HTTPS monitors averaged about **204 MB of web
Container memory** in a short sample after resizing to Micro. MariaDB runs
separately in Shared Data. Adjust the allocation as your monitor count and
types change.

The agent follows the deployment and gives you the HTTPS URL. Open it, sign
in to Blossom, and create your Kuma administrator username and password.

<details class="optional-reading" markdown="1">
<summary>Commands behind the deployment</summary>

Here are the commands behind that setup. Use the IDs returned by Blossom
in place of the example IDs below. The saved profile selects the Location
for the App and database:

    blossom profile:show
    blossom location:list

### Create the App and Database

    blossom app:create --data '{"app":{"name":"uptime-kuma"}}'

Write environment.yml with the returned App ID:

```yaml
environment:
  app_id: app-100
  name: production
  source_type: prebuilt_image
  prebuilt_image: louislam/uptime-kuma:2
  access_mode: members
```

    blossom environment:create --data environment.yml

This uses the official Uptime Kuma 2 image. Review image updates with your
agent before redeploying.

Write database_instance.yml:

```yaml
database_instance:
  name: uptime-kuma-production
  engine: mariadb
  engine_version: "12"
  availability: shared
  size: small
  storage_gib: 10
  database_name: uptime_kuma
  backup_storage_id: blossom_cloud
```

    blossom database_instance:create --data database_instance.yml --follow

Shared MariaDB runs alongside your other Shared Data in the same Account.
It keeps its own storage and has
[recovery backups](/docs/backups/managed-database/).

### Connect MariaDB and Configure the Web Service

Write environment_link.yml with the returned Environment and Database
instance IDs:

```yaml
environment_link:
  environment_id: environment-100
  target_type: DatabaseInstance
  target_id: database_instance-100
  var_name: DATABASE_URL
```

    blossom environment_link:create --data environment_link.yml

Blossom supplies the private database connection as `DATABASE_URL`. Kuma
reads separate database settings, so the startup command maps that URL into
the settings Kuma expects.

service.yml:

```yaml
service:
  environment_id: environment-100
  name: web
  entrypoint: /usr/bin/dumb-init
  command: >-
    -- node -e 'const u=new URL(process.env.DATABASE_URL);
    Object.assign(process.env,{
      UPTIME_KUMA_DB_TYPE:"mariadb",
      UPTIME_KUMA_DB_HOSTNAME:u.hostname,
      UPTIME_KUMA_DB_PORT:u.port||"3306",
      UPTIME_KUMA_DB_NAME:decodeURIComponent(u.pathname.slice(1)),
      UPTIME_KUMA_DB_USERNAME:decodeURIComponent(u.username),
      UPTIME_KUMA_DB_PASSWORD:decodeURIComponent(u.password)
    });
    require("./server/server.js");'
  port: 3001
  publicly_exposed: true
  desired_size: 1
  resources:
    preset: micro
  health_check:
    enabled: true
    kind: http
    path: /api/entry-page
    traffic: true
```

Keep the explicit entrypoint so the prebuilt image runs this command. Use
one replica, with autoscaling off. MariaDB stores monitor configuration,
administrator state and history. Add
[persistent Service storage](/docs/blossom-cli/service-yml/#persistent-services)
if you want to keep local files such as uploaded status-page images.

Save service.yml, then create the Service and deploy:

    blossom service:create --data service.yml
    blossom environment:deploy --id environment-100 --follow
    blossom environment:show --id environment-100

</details>

## Add Your Domain


> **Ask your AI agent:** Add uptime.example.com as the primary domain for uptime-kuma. Show me the DNS
> record to add, then check HTTPS when I have pointed DNS at Blossom.



The agent adds the domain with your Environment ID:

    blossom domain:create --data '{"domain":{"environment_id":"environment-100","dns_name":"uptime.example.com","main":true}}'

Add the returned DNS record at your provider. Blossom's
[domain setup](/learn/domains/) handles HTTPS. In Kuma's
**Settings → General**, set **Primary Base URL** to your custom HTTPS URL.
Account member access applies to the custom domain too.

## Start Monitoring Your Apps


> **Ask your AI agent:** List my Blossom Apps and their public URLs so I can choose which ones to
> monitor in Uptime Kuma.



The agent reads the inventory with:

    blossom app:list
    blossom environment:list

In Kuma, choose **Add New Monitor** and use these starting settings:

| Setting | Value |
|---|---|
| Monitor type | HTTP(s) |
| URL | The App's public HTTPS URL or health endpoint |
| Heartbeat interval | 60 seconds |
| Retries | 2 |
| Request timeout | 20 seconds |
| Accepted status codes | 200–299 for a public page |

For an endpoint whose intended anonymous response is 401, accept 401 and
label it as an **access gate** check. To check a protected page's content,
configure its authentication in Kuma. Blossom
[Environment access tokens](/docs/apps/environment-access/#environment-access-tokens)
let a monitor reach an App restricted to Account members.

Add your preferred destination under Kuma's **Settings → Notifications**,
send a test notification, and attach it to the monitors you want alerts for.

For a real example, read [how we deployed Uptime Kuma with AI](https://blog.boltops.com/2026/11/17/deploy-uptime-kuma-with-ai-on-your-own-cloud/),
including the database choice and custom domain.

## What You Get

- An HTTPS monitoring dashboard for your Account members
- Monitor settings and history in private managed MariaDB, with recovery backups
- A custom domain and uptime checks for your Apps
- Notifications through the channels you configure in Kuma
