Docker Compose

Execute uma instância completa e gratuita do Status200 em um único servidor Linux com o Docker Compose. Esta página leva você de um servidor recém-criado a uma instância em funcionamento e depois trata de HTTPS, do reforço para produção, de backups, de atualizações e da remoção. Para trabalhar no próprio código do Status200, veja Desenvolvimento local.

Como funciona#

O Docker Compose executa cada parte do Status200 como um contêiner no seu servidor. Todo o tráfego entra pelo contêiner ingress, que o encaminha para o app. O app guarda os dados no PostgreSQL, no ClickHouse e no Valkey. Uma sonda incluída executa as verificações dos seus monitores e envia os resultados pelo ingress.

Para produção em grande escala, ou quando você precisar de alta disponibilidade, use o chart do Helm no Kubernetes: o Docker Compose executa uma única cópia de cada serviço em um único servidor.

Requisitos#

Escolha o tamanho do servidor pelo que você vai executar nele. A telemetria (logs, métricas, traces) é o que determina memória e disco; veja Dimensionamento e planejamento de capacidade quando conhecer seus volumes.

O mínimo para homelab serve para uso pessoal e experimental — há quem rode o Status200 em um Raspberry Pi.

Você também precisa de:

• Docker com o plugin Docker Compose v2 (o comando docker compose).
• Git, para baixar o Status200.
• Node.js e npm, que executam os scripts npm start e npm run update que envolvem o Docker Compose.
• Portas 80 e 443 livres no servidor. A tabela abaixo lista cada porta que o Status200 usa no host.

Há também um vídeo passo a passo da instalação.

Instalar o Status200#

1. Clone o branch release#

   O branch release contém os arquivos da versão mais recente.

   Bash

   git clone --depth 1 --single-branch --branch release https://git.wilix.dev/status200/status200.git
   cd oneuptime

2. Crie o config.env#

   Todas as configurações do Status200 ficam no config.env. Comece pelo exemplo:

   Bash

   cp config.example.env config.env

3. Defina o nome de host#

   Abra o config.env e defina HOST com o nome de domínio ou o endereço IP que as pessoas vão usar para acessar o Status200, sem http://. Mantenha localhost só para experimentar o Status200 no seu próprio computador.

   config.envINI

   HOST=status200.example.com

4. Gere segredos aleatórios#

   O arquivo de exemplo vem com segredos de exemplo que são públicos no GitHub. Substitua cada um por um valor aleatório próprio:

   Bash

   while grep -q "please-change-this-to-random-value" config.env; do
     sed -i "0,/please-change-this-to-random-value/{s/please-change-this-to-random-value/$(openssl rand -hex 32)/}" config.env
   done
   grep -c "please-change-this" config.env

   O último comando imprime 0: não sobrou nenhum segredo de exemplo. O laço usa o GNU sed, que todo servidor Linux tem. Estas são as configurações que ele preenche:

   Configuração	O que ela protege
   ONEUPTIME_SECRET	As chamadas entre os próprios serviços do Status200.
   ENCRYPTION_SECRET	Os segredos que o Status200 guarda, como tokens de integrações e senhas SMTP, e os tokens de login que ele emite.
   DATABASE_PASSWORD, CLICKHOUSE_PASSWORD, VALKEY_PASSWORD	Os três armazenamentos de dados.
   REGISTER_PROBE_KEY	O registro de sondas na sua instância.
   GLOBAL_PROBE_1_KEY, GLOBAL_PROBE_2_KEY	As sondas globais que o Docker Compose pode executar (probe-1 é executada por padrão).
   STATUS200_RUNNER_KEY	O Runner incluído.
   GLOBAL_RUNNER_KEY	O Runner global incluído, que executa as etapas JavaScript de todos os projetos.

   Importante

   Defina os segredos antes da primeira inicialização e mantenha-os depois. O PostgreSQL só aceita a senha quando cria o banco de dados, e mudar ENCRYPTION_SECRET depois torna ilegível todo valor criptografado com o anterior. Se o DATABASE_PASSWORD ainda for o segredo de exemplo na primeira inicialização, o npm start dá a ele um valor aleatório antes que o PostgreSQL crie o banco de dados.

5. Inicie o Status200#

   npmDocker CLI

   npm

   Bash

   npm start

   Docker CLI

   Bash

   (export $(grep -v '^#' config.env | xargs) && docker compose up --remove-orphans -d)

   A primeira inicialização leva alguns minutos: o Docker baixa as imagens e o Status200 cria os bancos de dados. O npm start espera cada parte responder e termina com Status200 is up!

6. Crie a primeira conta#

   Abra http:// seguido do seu HOST (por exemplo http://localhost) e cadastre-se. A primeira conta de uma instância nova passa a ser o administrador principal dela, que pode abrir o Admin Dashboard em /admin.

   Qualquer pessoa que consiga acessar a página pode se cadastrar depois de você. Para impedir isso, abra o Admin Dashboard, vá em Configurações > Autenticação e desative Permitir cadastro. As pessoas que você convidar para um projeto ainda podem criar a conta.

Configurar HTTPS#

O Status200 serve HTTP simples até você escolher uma de duas formas de adicionar HTTPS:

Se você colocar páginas de status ou painéis em domínios personalizados, deixar o Status200 cuidar do TLS é a configuração mais simples: o ingress pede e serve sozinho os certificados desses domínios.

Com HTTP_PROTOCOL=https, o Status200 monta links HTTPS, mantém os cookies de login no HTTPS e pede aos navegadores que acessem o seu HOST só por HTTPS. Um navegador segue isso por um ano, em todas as portas desse nome; então, se um dia o HOST tiver que responder de novo por HTTP simples, defina HSTS_MAX_AGE_SECONDS=0 no config.env algum tempo antes: os navegadores esquecem a regra na próxima visita.

Deixar o Status200 obter um certificado#

1. Aponte seu domínio para o servidor#

   Crie um registro DNS A (ou AAAA para IPv6) para o seu domínio, com o endereço IP público do servidor como valor. Com um registro AAAA, ative também o IPv6 para o Status200: veja Endereços dos visitantes.

2. Ative a emissão de certificados#

   Defina estes valores no config.env:

   config.envINI

   HOST=status200.example.com
   PROVISION_SSL=true
   HTTP_PROTOCOL=https

   HOST precisa ser um nome de domínio: o Status200 não consegue obter um certificado para um endereço IP nem para localhost.

3. Reinicie com as novas configurações#

   Bash

   npm start

4. Abra sua instância por HTTPS#

   Abra https://status200.example.com. O Status200 pede o certificado ao iniciar e depois o verifica a cada hora, renovando-o quando faltam menos de 30 dias. Até o primeiro certificado chegar, normalmente em poucos minutos, o ingress serve um certificado autoassinado temporário e o navegador avisa você.

Usar seu próprio proxy reverso#

Estes passos executam o proxy no mesmo servidor que o Status200. Se o seu proxy roda em outra máquina, pule o primeiro passo, aponte o proxy para a porta 80 deste servidor e, com o firewall do seu provedor de nuvem, deixe só o proxy alcançar as portas 80 e 443: um visitante que alcança o Status200 sem passar pelo proxy pode escolher o endereço pelo qual o Status200 o conta.

1. Tire o ingress das portas 80 e 443#

   O proxy precisa das portas 80 e 443, então mova o ingress para outras portas, publicadas apenas no endereço de loopback 127.0.0.1 deste servidor, para que os visitantes alcancem o Status200 somente pelo seu proxy. A sonda e o Runner usam a rede do host e alcançam o Status200 por http://localhost, então mudam junto:

   config.envINI

   ONEUPTIME_HTTP_PORT=127.0.0.1:8080
   STATUS_PAGE_HTTPS_PORT=127.0.0.1:8443
   GLOBAL_PROBE_1_STATUS200_URL=http://localhost:8080
   ONEUPTIME_RUNNER_STATUS200_URL=http://localhost:8080

2. Informe ao Status200 que ele está atrás de um proxy#

   config.envINI

   HOST=status200.example.com
   HTTP_PROTOCOL=https
   PROVISION_SSL=false
   TRUSTED_PROXY_HOPS=2

   HTTP_PROTOCOL=https faz os links que o Status200 monta usarem HTTPS. TRUSTED_PROXY_HOPS=2 conta o seu proxy e o ingress do Status200, para que o Status200 leia o endereço real do visitante nas allowlists de IP e nos limites de taxa. Some um para cada proxy adicional que acrescente dados ao X-Forwarded-For, como uma CDN ou um balanceador de carga.

3. Reinicie o Status200 nas novas portas#

   Bash

   (export $(grep -v '^#' config.env | xargs) && docker compose up --remove-orphans -d)
   bash Tests/Scripts/status-check.sh localhost:8080

   O npm start verifica http://localhost na porta 80, onde ficará o seu proxy, então verifique você mesmo a nova porta. O script termina com Status200 is up!

4. Configure o proxy#

   CaddyNginx

   Caddy

   Caddyfile

   status200.example.com {
       reverse_proxy localhost:8080
   }

   O Caddy obtém e renova o certificado sozinho, redireciona HTTP para HTTPS e repassa conexões WebSocket. Recarregue o Caddy depois de alterar o arquivo, por exemplo com sudo systemctl reload caddy.

   Nginx

   /etc/nginx/conf.d/status200.confNginx

   map $http_upgrade $status200_connection_upgrade {
       default upgrade;
       ""      close;
   }
   
   server {
       listen 80;
       server_name status200.example.com;
       return 301 https://$host$request_uri;
   }
   
   server {
       listen 443 ssl;
       server_name status200.example.com;
   
       ssl_certificate     /etc/letsencrypt/live/status200.example.com/fullchain.pem;
       ssl_certificate_key /etc/letsencrypt/live/status200.example.com/privkey.pem;
   
       # The limits Status200's own ingress uses.
       client_max_body_size 50M;
       proxy_read_timeout 300s;
       proxy_send_timeout 300s;
   
       proxy_http_version 1.1;
       proxy_set_header Host $host;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header X-Forwarded-Proto $scheme;
       proxy_set_header Upgrade $http_upgrade;
       proxy_set_header Connection $status200_connection_upgrade;
   
       location / {
           proxy_pass http://127.0.0.1:8080;
       }
   
       # MCP clients keep a stream open.
       location /mcp {
           proxy_pass http://127.0.0.1:8080;
           proxy_buffering off;
           proxy_read_timeout 86400s;
           proxy_send_timeout 86400s;
       }
   }

   Os caminhos dos certificados são onde o Certbot coloca um certificado do Let's Encrypt; use os caminhos do seu próprio certificado se ele vier de outro lugar. Verifique o arquivo e recarregue o Nginx com sudo nginx -t && sudo systemctl reload nginx.

   Os dois enviam X-Forwarded-Proto, que avisa o Status200 de que um visitante veio por HTTPS. Qualquer outro proxy também precisa enviá-lo, senão os cookies de login das páginas de status e dos painéis nos seus domínios personalizados não ficam no HTTPS.

5. Abra sua instância pelo proxy#

   Abra https://status200.example.com. Você deve ver a página de login do Status200, servida com o certificado do seu proxy.

Endereços dos visitantes#

O Status200 conta cada visitante pelo endereço de onde ele se conecta: os limites de login, os outros limites por endereço e as allowlists de IP das páginas de status e dos dashboards leem esse endereço. Duas configurações precisam de um ajuste para que esse endereço seja o do próprio visitante:

Sem IPv6 na rede do Status200, o Docker repassa ao Status200 cada visitante que chega por IPv6 a partir de um endereço próprio, e o Status200 conta todos eles como um único visitante: as tentativas de login malsucedidas de uma pessoa podem bloquear as outras. Ativar o IPv6 exige o Docker Engine 27 ou mais recente (o docker version mostra a sua).

1. Ative o IPv6#

   Crie o docker-compose.override.yml ao lado do docker-compose.yml, ou acrescente isto ao que você já tem; o npm start e o npm run update o leem:

   docker-compose.override.ymlYAML

   networks:
     oneuptime:
       enable_ipv6: true

2. Reinicie o Status200#

   Bash

   npm stop
   npm start

   O Status200 para e inicia de novo com IPv6 na rede dele. Seus dados são mantidos. O Docker não consegue remover uma rede à qual um contêiner seu ainda está conectado, como um proxy reverso: desconecte-o antes da rede do Status200 e conecte-o de novo depois. Se o npm start parar com has active endpoints, desconecte-o e execute de novo o npm stop e o npm start.

3. Verifique a rede#

   Bash

   docker network ls --quiet --filter name=_oneuptime | xargs docker network inspect | grep EnableIPv6

   O comando mostra "EnableIPv6": true,.

Quando várias pessoas entram a partir de um mesmo endereço de rede privada, a página Integridade do Status200 do Admin Dashboard avisa, com o ajuste que muda isso.

Checklist de produção#

O Docker Compose executa uma única cópia de cada serviço em um único servidor, o que serve para equipes pequenas e homelabs. Antes de depender dele, passe por esta lista.

Troque a senha do banco de dados#

O PostgreSQL mantém a senha com que foi criado, então mudar só o DATABASE_PASSWORD no config.env deixa o Status200 sem acesso ao banco de dados. Para dar uma senha própria a uma instalação que começou com o segredo de exemplo, troque-a no PostgreSQL e no config.env ao mesmo tempo e depois inicie o Status200 de novo:

NEW_PASSWORD=$(openssl rand -hex 32) &&
  (export $(grep -v '^#' config.env | xargs) && docker compose exec -T postgres psql -U "$DATABASE_USERNAME" -d "$DATABASE_NAME" -c "ALTER USER \"$DATABASE_USERNAME\" PASSWORD '$NEW_PASSWORD'") &&
  sed -i "s/^DATABASE_PASSWORD=.*/DATABASE_PASSWORD=$NEW_PASSWORD/" config.env
npm start

Se você definiu DATABASE_BACKUP_PASSWORD e DATABASE_RESTORE_PASSWORD, dê a eles também o novo valor.

Backup e restauração#

O PostgreSQL guarda tudo o que você configura: monitores, incidentes, páginas de status, usuários. O npm run backup gera um dump dele em um arquivo na pasta Backups.

1. Dê ao script de backup a senha do banco de dados#

   No config.env, defina DATABASE_BACKUP_PASSWORD com o valor de DATABASE_PASSWORD. O script lê o config.env como texto simples, então o ${DATABASE_PASSWORD} que vem com ele nunca é preenchido.

2. Execute o backup#

   Bash

   npm run backup

   Ele pede sua senha de sudo e grava Backups/db-<day of the month>.backup, de modo que os backups diários substituem os de um mês antes. Execute-o pelo menos uma vez por dia.

3. Copie os backups para fora do servidor#

   Um backup no mesmo disco que o banco de dados não sobrevive à perda desse disco.

Só o próprio servidor alcança o PostgreSQL: ele responde na porta 5400 de 127.0.0.1. Para fazer o backup a partir de outra máquina, abra um túnel SSH nessa máquina e depois conecte-se à porta 5400 dela mesma:

ssh -N -L 5400:127.0.0.1:5400 you@status200.example.com

services:
  postgres:
    ports:
      - "10.0.0.5:5401:5432"

O ClickHouse guarda sua telemetria no volume do Docker status200_clickhouse, e nenhum script faz backup dele. Se você precisa manter essa telemetria, faça backup do volume com uma ferramenta do ClickHouse como o clickhouse-backup, ou copie-o com o Status200 parado.

Para restaurar o PostgreSQL, defina os valores DATABASE_RESTORE_* no config.env: DATABASE_RESTORE_PASSWORD com o valor de DATABASE_PASSWORD, como nos backups, e DATABASE_RESTORE_FILENAME com o backup a restaurar, por exemplo db-31.backup. Depois execute bash restore.sh. O banco de dados em que ele restaura já precisa existir; em uma instalação em funcionamento, ele existe.

Atualizar o Status200#

Faça backup primeiro e depois execute:

git checkout release
git pull
npm run update

O npm run update pede sua senha de sudo, adiciona ao seu config.env as configurações novas do config.example.env (seus próprios valores ficam), baixa as imagens novas e reinicia o Status200. Como o npm start, ele termina com Status200 is up!

Passar para uma nova versão principal (da 13 para a 14, por exemplo) pode exigir mais: leia Atualizar o Status200 para uma nova versão antes de começar.

APP_TAG=release no config.env sempre baixa a versão mais recente da Community Edition. Para ficar em uma versão, defina APP_TAG com o número dela, por exemplo 14.0.22. Para a Enterprise Edition, as tags são enterprise-release e enterprise-14.0.22.

Desinstalar o Status200#

Pare o Status200 e remova os contêineres e a rede dele:

npm run down

Seus dados ficam nos volumes status200_postgres e status200_clickhouse, e a pasta oneuptime mantém o config.env e seus backups. Para apagar também os dados:

(export $(grep -v '^#' config.env | xargs) && docker compose down --volumes --remove-orphans)

Depois apague a pasta oneuptime.

Solução de problemas#

sudo usermod -aG docker $USER

npm run ps
npm run logs

(export $(grep -v '^#' config.env | xargs) && docker compose logs app) | grep -A 5 CoreSSL

Próximos passos#