Monitoramento até o médico chegar!
Outono, chuva, quase nada de energia solar – hora de um check-up completo: qual camada de monitoramento do homelab verifica o quê, por que um servidor caído não consegue avisar de si mesmo, um pequeno uptime check feito de casa e o que o valor de pressão realmente mede.

🌐 Também em: English · Deutsch · Français · Español · Italiano · Nederlands · Polski
A partir das 17h, a natureza muda para o dark mode – no sistema inteiro, sem botão, sem opt-out. Ao contrário daqui do blog, não dá para desligar com um clique. 🌑 De manhã a temperatura está em um dígito, e nos dias cinzentos aqui no sul da Alemanha os painéis solares produzem o suficiente para um café – espresso, não cappuccino. ☕ Meus pensamentos voltam às últimas férias em Maiorca: sol, mar e Playa de Palma. Em casa a festa é mais tranquila: servidores em vez de sangria, dashboards em vez de pista de dança. 🍹
Agora falando sério.
Servidores, e aplicações web em especial, ficam doentes como pacientes de verdade. Têm febre (CPU no limite), falta de ar (disco cheio), perda de memória (RAM acabando) ou simplesmente um dia ruim e respondem mais devagar que o normal. Alguns sintomas passam sozinhos, outros são os primeiros sinais de algo sério e precisam ser investigados. Monitoramento é exatamente isso: medir regularmente pulso, temperatura e pressão, perceber anomalias antes que virem emergência e saber onde olhar quando a coisa fica séria.
E como com um médico: se você só mede o próprio pulso, não vai perceber a própria parada cardíaca. Era exatamente essa a lacuna que restava no monitoramento aqui.
Índice
🩺 O check-up: quem verifica o quê?
Para se orientar: aqui existem dois mundos. Na internet há três servidores alugados – o blog e duas instâncias Nextcloud. Em casa há um pequeno rack com hardware próprio, incluindo o servidor de NAS e backup, que roda 24 horas por dia de qualquer jeito e passa a maior parte do tempo ocioso. Ao longo dos meses, camadas de monitoramento cresceram nos dois mundos. Cada uma responde a uma pergunta diferente.
Nos três servidores na internet – cada um vigia a si mesmo:
| Camada | Com que frequência | O que ela percebe |
|---|---|---|
| Monit | a cada 2 min | serviço parado, jail do fail2ban sumida, bans e firewall fora de sincronia, pod travado, certificado < 21 dias, backup velho demais, erros de entrega de e-mail |
| Prometheus + Grafana | continuamente | disco, RAM, CPU, containers no limite, loops de restart, OOM kills, PHP-FPM saturado |
| Heartbeats | continuamente | um job noturno (AIDE, rkhunter, ClamAV, updates …) não deu sinal |
| Loki | continuamente | negações do SELinux, erros do fail2ban, OOM do kernel, um serviço escrevendo erros demais |
| Testes de efeito | a cada execução do playbook | cadeia de ban, filtros, domínios SELinux, métricas presentes |
A partir do servidor NAS em casa – a visão de fora e sobre o meu próprio hardware:
| Camada | Com que frequência | Olha para | O que ela percebe |
|---|---|---|---|
| Revisão de ataques | diariamente | os servidores na internet | rajadas de POST em pontos de entrada PHP, crashes do PHP-FPM |
| Visão de fora | semanalmente | os servidores na internet | portas abertas, certificados, versões, servidores antigos esquecidos |
| Temperaturas | a cada 10 min | só o rack em casa | histórico de calor do meu próprio hardware; superaquecimento de verdade o próprio iLO manda por e-mail. Os servidores na internet ficam num data center – a temperatura deles é problema do provedor. |
A lição: cada camada existe para um tipo de falha. O Monit vê se algo está rodando, o Prometheus se é suficiente, o Loki por que travou, os heartbeats se algo aconteceu de fato.
🚑 A lacuna: quem chama o médico quando o paciente desmaia?
A primeira tabela já entrega: tudo nela roda no servidor que ela vigia. Se um servidor cai por completo, o provedor tem uma pane ou a rede some, Monit, Grafana e Loki caem junto. Ninguém manda e-mail – e na caixa de entrada o silêncio parece exatamente “tudo certo”. Um servidor sem monitoramento é o servidor de Schrödinger: no ar e fora do ar ao mesmo tempo – até alguém abrir a caixa, geralmente um usuário com o celular na mão. 🐈📦
Até agora você perceberia pelo e-mail de teste semanal que não chega, ou pela verificação de segunda-feira vista de fora. No pior caso, depois de dias. Existe também um segundo caso: todos os serviços rodam, mas o site só mostra “Error establishing a database connection”, ou o Nextcloud está preso no modo de manutenção. Para o Monit, tudo verde. A pergunta, aliás, tem quase dois mil anos – Juvenal a fez em suas Sátiras: Quis custodiet ipsos custodes? Quem vigia os vigilantes?
Isso vai além da tecnologia: eu quero perceber uma queda eu mesmo antes que alguém me procure por causa dela. Essa é a diferença entre reativo e proativo. Reativo significa agir depois que um problema apareceu – geralmente porque alguém liga ou escreve “a nuvem não está funcionando”. Aí o estrago já está feito, e o usuário viu antes de mim. Proativo significa garantir de antemão que você mesmo detecta problemas cedo – de preferência antes que alguém perceba, no mínimo para poder responder à primeira mensagem com “Já sei, estou cuidando disso.” Cada camada das tabelas acima é um pedaço de proatividade; sem uma visão de fora, a maior queda de todas continuava reativa. Existem dois tipos de admins: os que ficam sabendo de uma queda pelo monitoramento – e os que ficam sabendo pelos usuários.
A lição: um monitoramento que roda na mesma máquina que o paciente não consegue relatar a falha total dela. Para isso é preciso alguém de fora.
🏠 A visita domiciliar: um uptime check feito de casa
A solução é propositalmente pequena e não precisa de hardware novo – o servidor NAS em casa já está acordado mesmo. Um script Python ali acessa cada um dos três sites na internet a cada 5 minutos do jeito que um visitante faria, só que sem navegador:
- WordPress: a página inicial responde 200 e é uma página de verdade, não uma página de erro de banco de dados nem um aviso de manutenção.
- Nextcloud:
status.phpinforma “installed”, “not in maintenance” e “no pending database upgrade”. - Collabora:
/hosting/discoverydevolve o XML WOPI de que o Nextcloud precisa para abrir documentos. - Certificado: uma vez por dia – inválido ou válido por menos de 14 dias é um achado.
O e-mail só sai quando há mudança: “down” depois de duas execuções seguidas com falha (um soluço isolado não é alarme), “back” com a duração da queda e um lembrete a cada 12 horas enquanto algo continuar fora do ar. Se todos os alvos falham ao mesmo tempo, o script primeiro verifica dois sites neutros na internet – se eles também sumiram, é a própria linha, e não há alarme falso. Em miniatura, é o problema dos dois generais da ciência da computação: quando nenhuma resposta volta, você não sabe se caiu o destinatário ou o mensageiro – então pergunta a um terceiro.
O user agent contém “uptime” para que as estatísticas de visitantes não contem as 288 visitas diárias vindas da minha própria sala. E um aceno a Heisenberg: uma medição deve alterar o mínimo possível aquilo que mede – doze requisições por hora somem no ruído de fundo.
O limite dele: se o servidor NAS estiver desligado ou a linha de casa cair, ninguém verifica. Ainda assim é um grande passo – antes, a única verificação de fora rodava uma vez por semana.
A lição: verifique de fora o que o usuário vê, não se um processo está rodando. E relate mudanças de estado, não estados – senão os e-mails logo acabam não lidos no arquivo. Um alarme que toca o tempo todo é um detector de fumaça numa sauna. 🔥
💓 Medindo a pressão: o que significa “pressure”
Também é novo no dashboard um valor que ficou vazio por muito tempo: pressure (Pressure Stall Information, PSI). Ele não mede o quanto algo está cheio, mas por quanto tempo os programas tiveram que esperar porque um recurso estava em falta. Uma CPU pode estar 100 % ocupada sem ninguém esperar – só a espera faz um servidor parecer lento. Afinal, no caixa do supermercado ninguém liga para o quanto o caixa está ocupado – só para o tamanho da fila.
$ cat /proc/pressure/memory
some avg10=0.00 avg60=0.00 avg300=0.00 total=31
full avg10=0.00 avg60=0.00 avg300=0.00 total=31
- cpu / memory / io: esperou por tempo de CPU, por memória livre (o kernel teve que recuperar memória primeiro – o sinal mais precoce antes de OOM kills) ou pelo disco.
- some: fração do tempo em que pelo menos um processo estava esperando.
- full: fração do tempo em que todos estavam esperando e nada avançava – o valor mais sério.
- avg10 / avg60 / avg300: porcentagem do tempo, em média sobre 10 segundos, 1 e 5 minutos.
Regra prática: alguns por cento são normais. some acima de 10–20 % por muito tempo chama atenção; full em memória ou disco claramente acima de 0 por um tempo é um achado.
Um erro meu de quebra: nesses servidores o PSI vem desligado no kernel por padrão e é ativado com o parâmetro de boot psi=1. Configurar foi rápido – mas ele só vale no próximo boot. O blog reiniciou na noite seguinte; os dois servidores Nextcloud rodaram mais um dia e meio com o painel vazio até serem reiniciados manualmente.
A lição: um parâmetro de boot só conta depois do boot. Uma mudança só está pronta quando o valor chega onde você quer vê-lo.
🔍 Um achado durante o check-up
Revisar tudo revelou mais uma coisa: o script de temperatura do rack em casa – ele só mede o meu próprio hardware, não os servidores na internet – não tem e-mail configurado. A primeira preocupação foi que ninguém avisaria sobre superaquecimento. Uma olhada no iLO mostrou que o AlertMail dele já tinha sido configurado há muito tempo e avisa sozinho sobre temperaturas críticas. O script só acrescenta no relatório os indícios precoces e discretos.
A lição: antes de construir um novo alerta, veja o que já alerta. Alarmes duplicados não trazem ganho.
🔭 O que vem a seguir: mais preciso, não mais
Um monitoramento assim nunca está pronto. Mas evoluí-lo aqui não significa adicionar novas ferramentas – significa deixar os testes existentes mais precisos e específicos. Algumas considerações realistas que não precisam de nova infraestrutura – ideias, não promessas:
- Função em vez de alcançabilidade: uma conta de teste faz login no Nextcloud, envia um arquivo pequeno via WebDAV, baixa de novo e compara o checksum. Isso verifica login, armazenamento, banco de dados e Redis de uma só vez.
- Conteúdo em vez de código de status: no blog, um teste abre um post específico e espera o título dele – uma página pode responder 200 e mesmo assim estar vazia ou vir de um cache desatualizado.
- Lento antes de quebrado: registrar o tempo de resposta e avisar quando ele estiver claramente acima da própria mediana dos últimos dias. A maioria das quedas se anuncia primeiro como “lerdeza”.
- Verificações mútuas: os três servidores na internet verificam uns aos outros – assim alguém continua acordado mesmo quando a linha de casa cai.
- Quem verifica a visita domiciliar? A própria verificação precisa de um heartbeat, por exemplo um timestamp que um monitor na internet sente falta quando ele para de chegar. Juvenal manda lembranças.
Além disso vem o ajuste fino: limites que disparam com frequência demais ou de menos são ajustados, e todo incidente real que nenhum teste percebeu vira uma pergunta: qual teste o teria encontrado?
A lição: o monitoramento amadurece a cada incidente. Quanto mais específico um teste, mais perto ele está do que um usuário realmente faz.
📜 O script
Só a biblioteca padrão do Python, e-mail pelo comando local mail (aqui msmtp). A configuração com os endereços e o destinatário do e-mail fica ao lado, mostrada abaixo com valores de exemplo.
#!/usr/bin/env python3
"""
uptime_check.py - is every site still reachable and working, seen from outside?
Monit, Prometheus, Grafana and Loki run on the servers they watch. If a whole
server goes down (crash, hoster outage, network), they go down with it and
nobody sends a mail. This script runs on a machine at home every 5 minutes,
checks each site the way a visitor would and mails only when the state
changes: DOWN after <fail_after> failed runs in a row, UP again with the
downtime, a reminder every <remind_hours> while it stays down.
uptime_check.py run all checks (cron)
uptime_check.py --dry-run run all checks, print mails instead of sending
uptime_check.py --status show the stored state
Kinds of checks (uptime_check.conf, [targets]):
wordpress page answers 200 and is a real page, not a database error
nextcloud status.php: installed, not in maintenance, no pending DB upgrade
collabora /hosting/discovery answers with the WOPI discovery XML
Every target also gets a TLS certificate check (warning below cert_warn_days).
Standard library only. Mail goes through the local "mail" command (msmtp).
"""
import configparser, datetime as dt, json, os, socket, ssl, subprocess, sys, time
import urllib.error, urllib.request
from urllib.parse import urlsplit
HERE = os.path.dirname(os.path.abspath(__file__))
CONF = os.path.join(HERE, "uptime_check.conf")
STATE = os.path.join(HERE, "state.json")
LOG = os.path.join(HERE, "uptime_check.log")
UA = "uptime-check/1.0 (+homelab)" # "uptime" keeps it out of the visitor statistics
def log(msg):
with open(LOG, "a") as f:
f.write(f"{dt.datetime.now():%Y-%m-%d %H:%M:%S} {msg}\n")
def fetch(url, timeout):
"""GET url -> (status, body text, seconds). Raises on network errors."""
req = urllib.request.Request(url, headers={"User-Agent": UA})
t0 = time.monotonic()
try:
with urllib.request.urlopen(req, timeout=timeout) as r:
body = r.read(2_000_000).decode("utf-8", "replace")
return r.status, body, time.monotonic() - t0
except urllib.error.HTTPError as e:
return e.code, "", time.monotonic() - t0
# Each check returns None when everything is fine, otherwise a short reason.
def check_wordpress(base, timeout):
status, body, secs = fetch(base, timeout)
if status != 200:
return f"HTTP {status}"
if "Error establishing a database connection" in body:
return "WordPress meldet: keine Datenbankverbindung"
if "Briefly unavailable for scheduled maintenance" in body:
return "WordPress steckt im Wartungsmodus"
if "wp-content" not in body or "</html>" not in body:
return "Antwort ist keine vollständige WordPress-Seite"
return None
def check_nextcloud(base, timeout):
status, body, secs = fetch(base.rstrip("/") + "/status.php", timeout)
if status != 200:
return f"status.php: HTTP {status}"
try:
s = json.loads(body)
except ValueError:
return "status.php liefert kein JSON"
if not s.get("installed"):
return "status.php: installed = false"
if s.get("maintenance"):
return "Nextcloud ist im Wartungsmodus"
if s.get("needsDbUpgrade"):
return "Nextcloud wartet auf ein Datenbank-Upgrade (occ upgrade)"
return None
def check_collabora(base, timeout):
status, body, secs = fetch(base.rstrip("/") + "/hosting/discovery", timeout)
if status != 200:
return f"discovery: HTTP {status}"
if "<wopi-discovery" not in body:
return "discovery liefert kein WOPI-XML"
return None
CHECKS = {"wordpress": check_wordpress, "nextcloud": check_nextcloud, "collabora": check_collabora}
def cert_days_left(base, timeout):
host = urlsplit(base).hostname
ctx = ssl.create_default_context() # also fails on an invalid or wrong-name certificate
with socket.create_connection((host, 443), timeout=timeout) as sock:
with ctx.wrap_socket(sock, server_hostname=host) as tls:
not_after = ssl.cert_time_to_seconds(tls.getpeercert()["notAfter"])
return int((not_after - time.time()) // 86400)
def run_check(kind, base, timeout):
try:
return CHECKS[kind](base, timeout)
except (urllib.error.URLError, socket.timeout, TimeoutError, ConnectionError, ssl.SSLError, OSError) as e:
reason = getattr(e, "reason", e)
return f"nicht erreichbar ({reason})"
def online(refs, timeout):
"""Is this machine itself online? True if any reference URL answers at all."""
for url in refs:
try:
fetch(url, timeout)
return True
except Exception:
continue
return False
def fmt_duration(seconds):
m = int(seconds // 60)
return f"{m // 60} h {m % 60} min" if m >= 60 else f"{m} min"
def send_mail(to, subject, text, dry_run):
if dry_run:
print(f"--- MAIL an {to}: {subject}\n{text}\n---")
return
r = subprocess.run(["mail", "-s", subject, to], input=text, text=True, capture_output=True)
if r.returncode != 0:
log(f"MAIL FEHLER rc={r.returncode}: {r.stderr.strip()}")
def main():
dry_run = "--dry-run" in sys.argv
cfg = configparser.ConfigParser()
if not cfg.read(CONF):
sys.exit(f"config missing: {CONF}")
g = cfg["general"]
timeout = g.getint("timeout", 20)
fail_after = g.getint("fail_after", 2)
remind = g.getint("remind_hours", 12) * 3600
cert_warn = g.getint("cert_warn_days", 14)
refs = g.get("reference_urls", "").split()
mail_to = g["mail_to"]
try:
state = json.load(open(STATE))
except (OSError, ValueError):
state = {}
if "--status" in sys.argv:
print(json.dumps(state, indent=2, ensure_ascii=False))
return
now = int(time.time())
targets = {name: val.split(None, 1) for name, val in cfg["targets"].items()}
results = {name: run_check(kind, url, timeout) for name, (kind, url) in targets.items()}
# Everything failed at once? Then it is more likely this machine's own
# line than all servers - check a neutral reference before alarming.
if all(results.values()) and not online(refs, timeout):
log("alle Ziele fehlgeschlagen und Referenz nicht erreichbar - eigene Leitung offline, nichts gezählt")
return
mails = []
for name, (kind, url) in targets.items():
st = state.setdefault(name, {"status": "up", "fails": 0, "since": now, "last_mail": 0})
reason = results[name]
if reason is None:
if st["status"] == "down":
mails.append(f"WIEDER DA {name} ({url}) nach {fmt_duration(now - st['since'])}")
log(f"UP {name} nach {fmt_duration(now - st['since'])}")
st.update(status="up", since=now)
st["fails"] = 0
else:
st["fails"] += 1
log(f"FAIL {name} ({st['fails']}x): {reason}")
if st["status"] == "up" and st["fails"] >= fail_after:
st.update(status="down", since=now, last_mail=now, reason=reason)
mails.append(f"AUSFALL {name} ({url}): {reason}")
elif st["status"] == "down" and now - st["last_mail"] >= remind:
st["last_mail"] = now
mails.append(f"NOCH DOWN {name} ({url}) seit {fmt_duration(now - st['since'])}: {reason}")
# Certificate: checked once per target and day, so at most one warning a day.
if reason is None and now - st.get("cert_checked", 0) >= 86400:
st["cert_checked"] = now
try:
days = cert_days_left(url, timeout)
if days < cert_warn:
mails.append(f"ZERTIFIKAT {name}: läuft in {days} Tagen ab (Erneuerung hängt?)")
except Exception as e:
mails.append(f"ZERTIFIKAT {name}: Prüfung fehlgeschlagen ({e})")
if mails:
down = sum(1 for s in state.values() if s["status"] == "down")
subject = f"Erreichbarkeit: {down} Ziel(e) down" if down else "Erreichbarkeit: alles wieder erreichbar"
text = "\n".join(mails) + f"\n\nGeprüft {dt.datetime.now():%Y-%m-%d %H:%M} von {socket.gethostname()}.\n"
send_mail(mail_to, subject, text, dry_run)
if not dry_run:
tmp = STATE + ".tmp"
with open(tmp, "w") as f:
json.dump(state, f, indent=1)
os.replace(tmp, STATE)
if __name__ == "__main__":
main()
A configuração uptime_check.conf (valores de exemplo):
# uptime_check.conf - chmod 600 (contains the mail address)
[general]
mail_to = you@example.org
# seconds per request
timeout = 20
# failed runs in a row before a DOWN mail (cron every 5 min -> 10 min)
fail_after = 2
remind_hours = 12
cert_warn_days = 14
# neutral sites: if ALL targets fail, these tell "server down" from "own line down"
reference_urls = https://www.google.com/generate_204 https://one.one.one.one/
[targets]
# name = kind base-url
blog = wordpress https://blog.example.org/
cloud = nextcloud https://cloud.example.org/
office = collabora https://office.example.org/
E a entrada no crontab:
*/5 * * * * cd $HOME/uptime-check && python3 -I uptime_check.py >> cron.log 2>&1
Para testar: --dry-run só imprime os e-mails, --status mostra o estado salvo. O jeito mais fácil de testar uma queda é um alvo extra apontando para um endereço que não existe (.invalid) – e não caminhos errados no seu próprio servidor, senão o fail2ban bane a sua própria linha.
🎯 As lições
- Um monitoramento no próprio servidor não consegue relatar a falha total dele – alguém precisa olhar de fora.
- Verifique o que o usuário vê: uma página de verdade, um “installed: true” – não apenas um processo rodando.
- Relate mudanças de estado, não estados; duas falhas antes do alarme filtram os soluços.
- Pressure mostra espera, não utilização – aquilo que os usuários sentem como “lento”.
- Um parâmetro de boot só funciona depois do boot; só está pronto quando o valor chega.
E agora: aquecimento ligado, chaleira ligada, mais uma olhada nas fotos de Maiorca. Os servidores vão chamar quando o médico for necessário. There’s no place like 127.0.0.1 – mas 127.0.0.1 é justamente aquele que não consegue avisar ninguém de que ele mesmo caiu. É para isso que agora existe a visita domiciliar. 😉
