OpenUptime

npx add-mcp 'https://openuptime.app/api/mcp'

OpenUptime

Monitoramento de uptime e páginas de status de código aberto. Roda em Cloudflare Workers com Postgres, ou em um único contêiner Docker.

Versão hospedada · Documentação · Referência · Licença MIT

• Verificações HTTP, TCP, DNS, heartbeat, PostgreSQL, MySQL e Redis, com correspondência de palavras-chave e alertas de resposta lenta
• Incidentes, janelas de manutenção e páginas de status públicas com assinaturas por e-mail / RSS
• Alertas para Slack, Lark / Feishu, Telegram, PagerDuty, webhooks e e-mail
• Workspaces, projetos, funções, chaves de API, um servidor MCP para agentes, importação / exportação JSON

Parte	Stack
apps/api	Hono, better-auth, Cloudflare Worker (cron + consumidor de fila)
apps/web	Astro (páginas estáticas, SSR para páginas de status) + ilhas React
packages/repo	Interface de armazenamento (Repo) e tipos de entidade
packages/db-pg	Implementação Postgres de Repo: esquema Drizzle, migrações

Implantar no Cloudflare

O site é composto por dois Workers em um único domínio:

Worker	Serve	Também faz
openuptime-api	your-domain/api/* (uma rota de Worker no seu zone)	cron por minuto, consumidor de fila que executa as verificações
openuptime-web	todo o resto em your-domain (um domínio personalizado de Worker)	páginas de status (SSR); acessa a API por meio de um service binding

Manter a API sob /api/* do mesmo domínio significa que os cookies de sessão permanecem na mesma origem. Você não precisa de um hostname separado para a API.

Antes de começar

• Uma conta Cloudflare e um domínio cujo DNS esteja no Cloudflare (o zone).
• Um banco de dados Postgres acessível pela internet (Neon, Supabase, RDS, ou o seu próprio). Os Workers se conectam por meio do Hyperdrive.
• Node.js 22+ e pnpm (corepack enable fornece a versão fixada).
• Plano Pago dos Workers para a Queue (padrão). No plano gratuito, execute em modo inline: veja Referência.

1. Obtenha o código e faça login

git clone https://github.com/becoolme/openuptime.git && cd openuptime
pnpm install
cd apps/api && npx wrangler login

Todos os comandos npx wrangler … abaixo são executados em apps/api, salvo indicação em contrário.

2. Crie a Queue e o Hyperdrive

npx wrangler queues create openuptime-checks
npx wrangler hyperdrive create openuptime-prod --connection-string="postgres://user:pass@host:5432/db"

O segundo comando imprime um id. Em apps/api/wrangler.jsonc, descomente a linha hyperdrive e cole-o:

"hyperdrive": [{ "binding": "HYPERDRIVE", "id": "<id printed above>" }],

A linha comentada placement é opcional (ela executa o Worker ao lado do seu host de banco de dados); deixe-a comentada, a menos que você queira isso.

3. Crie o esquema

A partir da raiz do repositório:

DATABASE_URL="postgres://user:pass@host:5432/db" pnpm db:migrate

Ele aplica apenas o que é novo, então execute novamente após cada atualização. Ele nunca emite CREATE SCHEMA, então uma função sem CREATE no nível do banco de dados também funciona.

4. Aponte a configuração para o seu domínio

Edite dois arquivos. Em ambos, substitua status.example.com pelo seu próprio domínio.

apps/api/wrangler.jsonc, onde zone_name é o zone (o domínio de nível superior), mesmo quando você atende a partir de um subdomínio. Descomente routes e defina:

"routes": [{ "pattern": "status.example.com/api/*", "zone_name": "example.com" }],
"vars": {
  "BETTER_AUTH_URL": "https://status.example.com",   // public origin: cookies, OAuth, email links
  "WEB_ORIGIN": "https://status.example.com",        // same value
  "EMAIL_FROM": "alerts@example.com"                 // sender address; optional, see below
}

O e-mail é opcional: sem ele, convites e alertas são gravados no log do Worker. Para enviá-lo, primeiro integre seu domínio em Envio de E-mail no painel do Cloudflare (veja Referência).

apps/web/wrangler.jsonc:

"routes": [{ "pattern": "status.example.com", "custom_domain": true }],
"vars": { "PRODUCT_URL": "https://status.example.com" }   // target of the "Powered by" link on status pages

O domínio personalizado cria o registro DNS e o certificado para você; o hostname não deve ter um registro DNS apontando para outro lugar.

Sem domínio no Cloudflare? Deixe routes fora de ambos os arquivos e defina BETTER_AUTH_URL e WEB_ORIGIN para o endereço https://openuptime-web.<your-subdomain>.workers.dev do Worker web. O Worker web então encaminha /api/* para o Worker da API por meio do service binding, então os cookies permanecem na mesma origem.

5. Defina os segredos

npx wrangler secret put BETTER_AUTH_SECRET     # openssl rand -hex 32
npx wrangler secret put CRON_SECRET            # any long random string; guards /internal/*

Se o wrangler perguntar se deseja criar o Worker primeiro, responda sim. Opcional: GITHUB_CLIENT_ID e GITHUB_CLIENT_SECRET adicionam "Entrar com GitHub".

6. Implante

pnpm exec wrangler deploy                     # in apps/api
cd ../web && pnpm build && pnpm exec wrangler deploy

Implante a API primeiro: o Worker web se vincula a ela pelo nome.

7. Verifique

curl https://status.example.com/api/health    # {"ok":true}

Abra o domínio e cadastre-se. Depois que sua própria conta existir, você pode definir "DISABLE_SIGNUP": "true" no vars da API e implantar novamente para fechar o registro (pessoas convidadas ainda podem entrar).

Atualizar depois: puxe, pnpm install, pnpm db:migrate, e então implante a API e o Worker web, nessa ordem.

Self-host com Docker

Um único contêiner executa a API, o aplicativo web e o agendador de verificações; o Postgres vem com o arquivo compose. Execute a imagem publicada ou construa a partir do código-fonte; as configurações são as mesmas.

Opção A: execute a imagem publicada

As versões com tag são publicadas em ghcr.io/becoolme/openuptime para linux/amd64 e linux/arm64. Você não precisa clonar nem compilar:

mkdir openuptime && cd openuptime
curl -fsSLO https://raw.githubusercontent.com/becoolme/openuptime/main/docker-compose.yml
curl -fsSL https://raw.githubusercontent.com/becoolme/openuptime/main/.env.docker.example -o .env

Edite .env: defina POSTGRES_PASSWORD e BETTER_AUTH_SECRET (openssl rand -hex 32) e descomente OPENUPTIME_IMAGE. Fixe uma versão (ghcr.io/becoolme/openuptime:0.1.0) ou siga o lançamento mais recente (:latest). Então:

docker compose pull && docker compose up -d     # http://localhost:8080

Atualização: altere a tag se você fixou uma e execute os mesmos dois comandos novamente. As migrações são executadas na inicialização.

Opção B: construir a partir do código-fonte

git clone https://github.com/becoolme/openuptime.git && cd openuptime
cp .env.docker.example .env      # set POSTGRES_PASSWORD and BETTER_AUTH_SECRET (openssl rand -hex 32)
docker compose up -d --build     # http://localhost:8080

Atualização: git pull, depois docker compose up -d --build.

De qualquer forma

O esquema é migrado na inicialização e os dados ficam no volume pgdata. Defina PUBLIC_URL quando o aplicativo não for servido a partir de http://localhost:8080. O e-mail é opcional; veja Referência.

Depois que sua própria conta existir, defina DISABLE_SIGNUP=true em .env e execute docker compose up -d para fechar o registro (pessoas convidadas ainda podem entrar).

Desenvolver

pnpm install
cp .env.example apps/api/.dev.vars   # edit DATABASE_URL and secrets
DATABASE_URL=postgres://user:pass@localhost:5432/openuptime_dev pnpm db:migrate   # same URL as in .dev.vars
pnpm dev:api    # http://localhost:8787  (checks run inline every 15s)
pnpm dev:web    # http://localhost:4321  (proxies /api to the API)
pnpm typecheck

Servidor MCP

Agentes (Claude, Cursor, Codex e qualquer cliente MCP) podem gerenciar monitores, incidentes e páginas de status por HTTP Streamable em /api/mcp, autorizando com OAuth ou uma chave de API:

claude mcp add --transport http openuptime https://openuptime.app/api/mcp   # or https://<your-host>/api/mcp

A configuração do cliente, os escopos e a lista de ferramentas estão na documentação do MCP. Uma habilidade de agente que ensina os fluxos de trabalho comuns está incluída em skills/openuptime: npx skills add becoolme/openuptime. O servidor hospedado está listado no MCP Registry como app.openuptime/mcp; server.json é sua entrada.

Testes, como as verificações funcionam, o servidor MCP, canais de alerta e os outros detalhes estão em docs/reference.md.

Código aberto vs. hospedado

O monitoramento em si é o mesmo código em ambos. O serviço hospedado em openuptime.app adiciona planos, cobrança e alguns recursos que existem apenas nessa versão; ele se conecta a este repositório por meio de uma interface (Edition, veja docs/editions.md), então nada no núcleo é bloqueado ou limitado.

	Self-hosted (este repositório, MIT)	Hospedado (openuptime.app)
Monitores, incidentes, páginas de status, canais de alerta, API, MCP	Tudo	Tudo
Limites	Nenhum: sem planos, cotas ou medição	Plano gratuito, planos pagos a partir de $5/mês (preços); monitores, verificações, e-mails e duração do histórico dependem do plano
Execução	Você: Postgres, o Worker ou contêiner, um provedor de e-mail, backups, atualizações	Nós fazemos; nada para instalar
Monitoramento de certificado SSL (alertas de expiração, tipo de monitor ssl)	Não incluído	Lite e acima
Domínio personalizado para uma página de status	Não incluído	Team
Onde seus dados ficam	Seu banco de dados	O nosso (Postgres em hospedagem gerenciada)

Escolha self-hosting se você quiser ser dono dos dados e da infraestrutura, ou não quiser se preocupar com limites. Escolha hospedado se preferir não executar nada. Ambos recebem as mesmas atualizações principais.

Contribuindo e segurança

Veja CONTRIBUTING.md. Relate vulnerabilidades de forma privada, conforme descrito em SECURITY.md, não em issues públicas.

Licença

MIT