Burrice Artificial e SRE: Como a simplicidade resolve problemas complexos
Na cultura DevOps e SRE, somos bombardeados por ferramentas de monitoramento complexas, dashboards cheios de métricas de vaidade e sistemas de observabilidade caríssimos. Mas, na prática, quando o servidor está pegando fogo às 3 da manhã, o que você realmente precisa? Contexto.
Hoje, eu chamo a minha abordagem de "Burrice Artificial". A ideia é simples: em vez de tentar criar uma IA que "adivinha" o problema, eu crio um coletor de dados que "entrega o contexto" para a IA.
O conceito de Burrice Artificial
A "Burrice Artificial" é o reconhecimento de que, muitas vezes, não precisamos de machine learning preditivo avançado. Precisamos de um script que saiba onde estão os arquivos de log, como checar a saúde dos containers e o estado dos serviços.
O SRE moderno não é aquele que sabe de cor todos os comandos do Linux, mas aquele que sabe quais comandos geram a informação necessária para diagnosticar um problema. Se você tem essa lista, você tem o poder.
A solução: O coletor de contexto
Criei um script simples em Python que atua como meus "olhos" no servidor. Ele não resolve o problema por mim; ele coleta o "estado da arte" da minha infraestrutura, transforma tudo em um JSON estruturado e entrega para uma LLM (como o ChatGPT ou Gemini) analisar.
Ao invés de caçar erros manualmente, eu mando: "Analise este JSON, me diga onde está o gargalo e sugira a correção". A IA é ótima em correlacionar dados, mas ela precisa que os dados cheguem organizados.
O Script Genérico
Abaixo, compartilho uma versão genérica desse script. Você pode adaptar as seções de infra, docker e logs conforme a sua realidade (seja um ambiente legado ou cloud-native):
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import subprocess
import os
import json
from datetime import datetime
# Configuração de saída
REPORT_FILE = "system_diagnostic_report.json"
def run_cmd(cmd):
"""Executa comando de forma segura"""
try:
return subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT, timeout=10).decode(errors="ignore").strip()
except Exception as e:
return f"Falha na coleta: {str(e)}"
def collect_diagnostic():
report = {
"timestamp_utc": datetime.utcnow().isoformat() + "Z",
"system_health": {
"uptime": run_cmd("uptime"),
"memory": run_cmd("free -h"),
"disk_usage": run_cmd("df -h"),
},
"service_layer": {
"containers": run_cmd("docker ps --format 'table {{.Names}}\t{{.Status}}'"),
"service_status": run_cmd("systemctl status nginx --no-pager | tail -n 10")
},
"recent_errors": {
"logs": run_cmd("tail -n 50 /var/log/syslog | grep -i 'error'")
}
}
# O "Prompt de Contexto" que você envia junto ao JSON para a IA
report["ai_prompt"] = "Você é um SRE Senior. Analise este JSON de diagnóstico, identifique gargalos de performance, erros de serviço e sugira correções."
return report
if __name__ == "__main__":
data = collect_diagnostic()
with open(REPORT_FILE, "w") as f:
json.dump(data, f, indent=2)
print(f"✅ Relatório gerado: {REPORT_FILE}")
Por que isso funciona?
- Redução de Carga Cognitiva: Eu não preciso lembrar flags complexas do Docker ou greps gigantescos.
- Documentação: Cada diagnóstico vira um arquivo que posso guardar para analisar tendências futuras.
- Velocidade: O tempo entre "o site caiu" e "eu sei o motivo" caiu drasticamente. A IA faz o trabalho braçal de ler o log, eu faço o trabalho intelectual de implementar a correção.
Conclusão Não tenha medo de ser "burro" na sua automação. SRE é sobre resolver problemas, não sobre quem tem o script mais rebuscado. A IA é uma ferramenta poderosa, mas ela só é tão boa quanto os dados que você fornece a ela. Dê o contexto certo, e você terá o diagnóstico certo.
