Deploy OneUptime | (Just Updated) Open-Source Datadog and Pingdom Alternative, Admin Login Pre-Created, Sign-up Closed

OneUptime uptime monitoring, status page, incidents, on-call and OTLP logs

Deploy OneUptime | (Just Updated) Open-Source Datadog and Pingdom Alternative, Admin Login Pre-Created, Sign-up Closed

/var/lib/clickhouse

Just deployed

Just deployed

/data

Just deployed

database

postgres:15

Just deployed

/var/lib/postgresql

Deploy and Host OneUptime on Railway

Built for an LLM agent to deploy and use. The deploy form has no fields to fill: the owner login, every secret and the three databases' credentials are generated, the first account is created before the site is reachable, and sign-up is switched off afterwards. OneUptime is an open-source observability platform with uptime monitoring, status pages, incident management, on-call, logs, traces, metrics and an OpenTelemetry (OTLP) ingest endpoint, a self-hosted alternative to Datadog, Pingdom and StatusPage.

About Hosting OneUptime

This template runs five services: oneuptime, the official oneuptime/app image (release 17.1.0) pinned by digest through a thin wrapper, which owns the one public domain on port 8080 with an HTTP healthcheck at /status/ready; probe, the stock OneUptime probe that runs the uptime checks; database, PostgreSQL 15 with a volume at /var/lib/postgresql; cache, Valkey with a volume at /data; and clickhouse, ClickHouse set up as a single node with a volume at /var/lib/clickhouse, where logs, traces and metrics live.

What the wrapper fixes. Stock OneUptime makes whoever reaches the sign-up form first the Master Admin, and its sign-up switch lives in a database row that the dashboard flips by hand. The wrapper runs the database migrations, creates the owner account from ADMIN_EMAIL and ADMIN_PASSWORD before the public port opens, turns sign-up off in the database, and only then lets traffic in through a small proxy on the injected PORT. A stranger who reaches the domain finds the account taken and registration closed. Redeploys keep the owner, the projects and the monitors.

Using it. Open your domain and sign in with the owner e-mail and password, then create a project; the probe in this template is already registered, so a monitor you add (a website, an API, a port) starts reporting at once. Applications send OpenTelemetry data to https://YOUR_DOMAIN/otlp with a project telemetry key made in the dashboard. An agent can create projects through the API as below. E-mail (invites, alerts by mail), SMS and OAuth sign-in are not configured; set their variables on the oneuptime service if you need them.

Agent contract

  • Public URL: https://RAILWAY_PUBLIC_DOMAIN (the generated domain of the oneuptime service)
  • Private URL: http://oneuptime.railway.internal:3002 (the app itself, without the sign-up guard; the public port 8080 is the guarded front door)
  • Credentials: the variables ADMIN_EMAIL and ADMIN_PASSWORD on the oneuptime service (plain text)
  • Auth: POST /api/identity/login with a JSON body of the e-mail and password wrapped in a data object sets the session cookies; send them on every API call, and API routes answer 401 without them
  • Health: GET /status/ready returns 200 without credentials
#!/bin/sh
# needs: RAILWAY_PUBLIC_DOMAIN, ADMIN_EMAIL, ADMIN_PASSWORD (variables of the oneuptime service); also curl, jq.
R="https://$RAILWAY_PUBLIC_DOMAIN"; H="content-type: application/json"; JAR=$(mktemp)
NOPE="not-the-real-one-1"
n=0; until [ "$(curl -s -o /dev/null -w '%{http_code}' "$R/status/ready")" = 200 ]; do n=$((n+1)); [ "$n" -le 120 ] || break; sleep 5; done
curl -s -o /dev/null -w "health: %{http_code}\n" "$R/status/ready"
# the owner exists already and sign-up is switched off: a stranger's sign-up is refused
curl -s -o /dev/null -w "public signup: %{http_code}\n" -H "$H" -d "$(jq -nc --arg p "$NOPE" '{data:{email:{_type:"Email",value:"stranger@example.com"},name:{_type:"Name",value:"X"},password:$p}}')" "$R/api/identity/signup"
curl -s -o /dev/null -w "wrong login: %{http_code}\n" -H "$H" -d "$(jq -nc --arg e "$ADMIN_EMAIL" --arg p "$NOPE" '{data:{email:{_type:"Email",value:$e},password:$p}}')" "$R/api/identity/login"
# the generated login sets the session cookies
curl -s -c "$JAR" -o /dev/null -w "login: %{http_code}\n" -H "$H" -d "$(jq -nc --arg e "$ADMIN_EMAIL" --arg p "$ADMIN_PASSWORD" '{data:{email:{_type:"Email",value:$e},password:$p}}')" "$R/api/identity/login"
BODY="{\"data\":{\"name\":\"Agent $$\"}}"
# write-auth: POST /api/project needs the session cookie from the login; without it, or with a wrong one, the answer is 401
curl -s -b "$JAR" -o /dev/null -w "write with key: %{http_code}\n" -H "$H" -d "$BODY" "$R/api/project"
curl -s -o /dev/null -w "write without key: %{http_code}\n" -H "$H" -d "$BODY" "$R/api/project"
curl -s -H "cookie: user-token=not-a-real-token" -o /dev/null -w "write wrong key: %{http_code}\n" -H "$H" -d "$BODY" "$R/api/project"

Expected output against a fresh deploy:

health: 200
public signup: 403
wrong login: 400
login: 200
write with key: 200
write without key: 401
write wrong key: 401

The refusals are the contract: a request without a session is refused (write without key: 401), a stranger cannot register (public signup: 403) and a wrong password is refused (wrong login: 400). The first start takes a few minutes while OneUptime migrates PostgreSQL and ClickHouse; the loop at the top waits for it.

Why Deploy OneUptime on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying OneUptime on Railway, you are one step closer to supporting a complete full-stack application with minimal burden. Host your servers, databases, AI agents, and more on Railway.

  • Agent-ready - no deployer fields, a contract block, and one script that proves the app is healthy, strangers cannot register, the generated login works and the API refuses writes without a session.
  • Owner included - the first account is created before the site is reachable, so nobody can claim it.
  • Probe included - a probe is registered at first start, so the first monitor you add already runs.
  • Data survives redeploys - accounts in PostgreSQL on a volume, telemetry in ClickHouse on a volume, Valkey on a volume.
  • Pinned - OneUptime, PostgreSQL, Valkey and ClickHouse are pinned by digest, and the wrapper by tag and digest.

Common Use Cases

  • Uptime monitoring and a public status page - website, API and port checks with incident history, instead of a Pingdom or StatusPage subscription.
  • Incident management and on-call - alerts, escalation rules and incident timelines in one place.
  • Logs, traces and metrics - send OpenTelemetry data from your applications to one endpoint and query it in the dashboard.
  • Observability for AI agents - give an agent a generated login to create projects and monitors for the services it deploys.

Dependencies for OneUptime Hosting

  • The oneuptime and probe services, a PostgreSQL service, a Valkey service and a ClickHouse service, each stateful one with its volume, created by the template.

Deployment Dependencies


Template Content

More templates in this category

View Template
Rootprint
Open-source logs and traces with full-text search on object-storage.

Rootprint
1
View Template
Pyroscope profiling
Protected continuous profiling with durable Pyroscope storage.

Anton Orel
1
View Template
SigOnly
Deploy SigNoz with a working demo app & config in one click

zoeyjones
21