AIOps DevOps ,

Criando um Agente DevOps com Python e LangChain: Automação de Tarefas na Prática

Construir um agente DevOps com LangChain deixou de ser experimento de laboratório e já é uma forma real de reduzir tarefas repetitivas de administração de sistemas. Neste tutorial mão na massa, vamos criar do zero um pequeno agente de IA em Python capaz de verificar o status de serviços via systemctl, checar a saúde de APIs via HTTP e limpar logs antigos automaticamente — tudo isso decidindo sozinho qual ferramenta usar a partir de um comando em linguagem natural. Ao final, você terá um agente funcional, com código completo, diagramas de arquitetura e boas práticas de segurança para não colocar em risco seus servidores de produção.

O que é um agente de IA aplicado a DevOps

Um agente de IA, na prática, é um modelo de linguagem (LLM) acoplado a um conjunto de ferramentas (tools) que ele pode chamar de forma autônoma para cumprir um objetivo. Diferente de um chatbot comum, que apenas responde texto, um agente DevOps com LangChain consegue executar ações reais no sistema operacional: rodar comandos, consultar APIs, ler arquivos de log e tomar decisões sobre qual ferramenta usar em cada etapa.

O LangChain fornece a camada de orquestração entre o LLM e essas ferramentas, implementando o padrão ReAct (Reasoning + Acting): o agente raciocina sobre o problema, escolhe uma ação, observa o resultado e repete o ciclo até ter uma resposta final. É exatamente esse ciclo que vamos implementar ao longo do tutorial.

Pré-requisitos e instalação do ambiente

Antes de escrever código, prepare o ambiente Python. Recomendamos um ambiente virtual isolado para não conflitar com outras dependências do sistema.

python3 -m venv venv
source venv/bin/activate

pip install langchain langchain-openai python-dotenv requests psutil

Configurando a chave de API do modelo

O agente precisa de um modelo com suporte a tool calling. Neste tutorial usamos a família GPT via langchain-openai, mas qualquer modelo compatível com chamada de ferramentas (Anthropic, Google Gemini, modelos locais via Ollama) pode substituir o exemplo sem alterar a lógica do agente.

# .env
OPENAI_API_KEY=sua-chave-aqui
# config.py
from dotenv import load_dotenv

load_dotenv()

Arquitetura do agente DevOps

Antes de implementar, vale entender como as peças se conectam. O usuário envia um comando em linguagem natural, o agente (LLM + LangChain) interpreta a intenção e decide qual ferramenta chamar, a ferramenta interage diretamente com a infraestrutura (systemd, API HTTP ou sistema de arquivos) e o resultado retorna ao agente, que formula a resposta final.

Usuário “verifique o nginx” Agente DevOps LangChain + create_agent Loop ReAct (raciocínio + ação + observação) LLM com tool calling verificar_status_servico systemctl status verificar_status_api requisição HTTP GET limpar_logs remove arquivos antigos Infraestrutura systemd · API · filesystem comando resposta observação (resultado)

Figura 1 — Arquitetura do agente DevOps: o LLM decide qual ferramenta chamar, a ferramenta interage com a infraestrutura real e o resultado volta como observação para o agente formular a resposta.

Passo 1: criando as ferramentas (tools) do agente

Ferramentas são funções Python comuns decoradas com @tool. O LangChain infere o schema de entrada a partir das anotações de tipo e usa a docstring para decidir quando invocar cada uma — por isso a qualidade da docstring é tão importante quanto o código em si.

Ferramenta para verificar status de serviços via systemctl

# tools.py
import subprocess
from langchain.tools import tool

@tool
def verificar_status_servico(nome_servico: str) -> str:
    """Verifica o status atual de um serviço systemd no Linux.

    Use esta ferramenta quando o usuário pedir para checar se um
    serviço (como nginx, postgresql, docker) está rodando, parado
    ou com falha.

    Args:
        nome_servico: nome exato do serviço systemd, ex: "nginx".
    """
    resultado = subprocess.run(
        ["systemctl", "is-active", nome_servico],
        capture_output=True,
        text=True,
    )
    status = resultado.stdout.strip() or resultado.stderr.strip()
    return f"Serviço '{nome_servico}' está: {status}"

Ferramenta para verificar status de uma API via HTTP

import requests
from langchain.tools import tool

@tool
def verificar_status_api(url: str, timeout: int = 5) -> str:
    """Verifica se uma API HTTP está respondendo corretamente.

    Use esta ferramenta quando o usuário pedir para checar a saúde
    (health check) de um endpoint ou serviço web.

    Args:
        url: endereço completo do endpoint, ex: "https://api.exemplo.com/health".
        timeout: tempo máximo de espera em segundos.
    """
    try:
        resposta = requests.get(url, timeout=timeout)
        return (
            f"API {url} respondeu com status HTTP {resposta.status_code} "
            f"em {resposta.elapsed.total_seconds():.2f}s"
        )
    except requests.exceptions.RequestException as erro:
        return f"Falha ao acessar {url}: {erro}"

Ferramenta para limpar logs antigos

Esta é a ferramenta mais sensível, já que apaga arquivos. Vamos incluir um parâmetro dry_run para permitir simulação antes da execução real — um detalhe fundamental de segurança que retomamos mais adiante.

import os
import time
from langchain.tools import tool

@tool
def limpar_logs(diretorio: str, dias: int = 30, dry_run: bool = True) -> str:
    """Remove arquivos .log mais antigos que um número de dias.

    Use esta ferramenta quando o usuário pedir para limpar, liberar
    espaço ou remover logs antigos de um diretório.

    Args:
        diretorio: caminho absoluto do diretório de logs, ex: "/var/log/app".
        dias: idade mínima em dias para o arquivo ser removido.
        dry_run: se True, apenas lista os arquivos que seriam removidos,
            sem apagar nada de fato. Use sempre dry_run=True primeiro.
    """
    if not os.path.isdir(diretorio):
        return f"Diretório '{diretorio}' não encontrado."

    limite = time.time() - (dias * 86400)
    candidatos = []

    for arquivo in os.listdir(diretorio):
        if arquivo.endswith(".log"):
            caminho = os.path.join(diretorio, arquivo)
            if os.path.getmtime(caminho) < limite:
                candidatos.append(caminho)

    if dry_run:
        return (
            f"[dry-run] {len(candidatos)} arquivo(s) seriam removidos: "
            f"{candidatos[:10]}"
        )

    for caminho in candidatos:
        os.remove(caminho)

    return f"{len(candidatos)} arquivo(s) de log removido(s) de '{diretorio}'."

Passo 2: montando o agente com create_agent

Com as ferramentas prontas, criamos o agente usando create_agent, a API atual do LangChain para construção de agentes (o antigo initialize_agent e o create_react_agent isolado foram descontinuados em favor dessa abordagem unificada, que roda sobre um runtime baseado em grafo do LangGraph).

# agent.py
from config import load_dotenv  # garante que o .env seja carregado
from langchain.agents import create_agent
from tools import verificar_status_servico, verificar_status_api, limpar_logs

SYSTEM_PROMPT = """Você é um agente DevOps responsável por operações
simples de administração de sistemas Linux. Sempre que uma ação puder
apagar dados (como limpar_logs), execute primeiro com dry_run=True,
mostre o resultado ao usuário e só prossiga com dry_run=False se o
usuário confirmar explicitamente. Seja direto e técnico nas respostas."""

agente = create_agent(
    "openai:gpt-4.1-mini",
    tools=[verificar_status_servico, verificar_status_api, limpar_logs],
    system_prompt=SYSTEM_PROMPT,
)

if __name__ == "__main__":
    while True:
        comando = input("\nComando> ")
        if comando.lower() in {"sair", "exit"}:
            break

        resultado = agente.invoke(
            {"messages": [{"role": "user", "content": comando}]}
        )
        ultima_mensagem = resultado["messages"][-1]
        print(f"\nAgente: {ultima_mensagem.content}")

Substitua "openai:gpt-4.1-mini" pelo identificador do modelo disponível na sua conta — o LangChain resolve automaticamente o provedor a partir do prefixo (openai:, anthropic:, google_genai:, entre outros).

Passo 3: testando o agente na prática

Exemplo de execução: verificação de serviço

$ python agent.py
Comando> o nginx está rodando?

Agente: O serviço nginx está ativo (status: active).

Por trás da resposta, o agente executou o ciclo ReAct completo: interpretou a pergunta, decidiu chamar verificar_status_servico("nginx"), recebeu a observação "Serviço 'nginx' está: active" e converteu isso em uma resposta natural.

Exemplo de execução: limpeza de logs

Comando> limpe os logs com mais de 15 dias em /var/log/app

Agente: Encontrei 42 arquivos .log com mais de 15 dias em /var/log/app.
Quer que eu remova esses arquivos definitivamente? (sim/não)

Comando> sim

Agente: 42 arquivo(s) de log removido(s) de '/var/log/app'.

Note que o agente respeitou a instrução do system_prompt e rodou primeiro em modo dry_run, só executando a remoção real após confirmação — esse é o comportamento esperado de um agente DevOps com LangChain operando com segurança sobre infraestrutura real.

Como o agente decide qual ferramenta usar (loop ReAct)

O LangChain implementa internamente o padrão ReAct: a cada passo, o modelo recebe o histórico de mensagens, decide entre gerar uma resposta final ou chamar uma ferramenta, observa o resultado da ferramenta e repete o processo até considerar a tarefa concluída.

Prompt do usuário “limpe os logs antigos” Reasoning o LLM decide o próximo passo Acting chama limpar_logs(…) Observation resultado da ferramenta Resposta final quando não há mais ações novo ciclo de reasoning tarefa concluída

Figura 2 — Loop ReAct: o agente alterna entre raciocínio, ação (chamada de ferramenta) e observação até decidir que a tarefa está concluída e gerar a resposta final.

Adicionando segurança: confirmação antes de ações destrutivas

Além do padrão dry_run já embutido na ferramenta limpar_logs, o LangChain permite interceptar qualquer chamada de ferramenta com middleware, criando uma camada extra de segurança independente do que o modelo “decidir” fazer.

from langchain.agents.middleware import wrap_tool_call
from langchain.messages import ToolMessage

FERRAMENTAS_SENSIVEIS = {"limpar_logs"}

@wrap_tool_call
def exigir_confirmacao(request, handler):
    """Bloqueia execução real de ferramentas sensíveis sem confirmação explícita."""
    nome = request.tool_call["name"]
    args = request.tool_call["args"]

    if nome in FERRAMENTAS_SENSIVEIS and not args.get("dry_run", True):
        confirmacao = input(
            f"\n[confirmação necessária] Executar '{nome}' com args {args}? (sim/não) "
        )
        if confirmacao.strip().lower() != "sim":
            return ToolMessage(
                content="Ação cancelada pelo operador.",
                tool_call_id=request.tool_call["id"],
            )

    return handler(request)

Basta registrar esse middleware na criação do agente:

agente = create_agent(
    "openai:gpt-4.1-mini",
    tools=[verificar_status_servico, verificar_status_api, limpar_logs],
    system_prompt=SYSTEM_PROMPT,
    middleware=[exigir_confirmacao],
)

Essa camada garante que, mesmo que o modelo “alucine” uma decisão ou o prompt seja manipulado por um usuário mal-intencionado, nenhuma ação destrutiva é executada sem confirmação humana — um princípio essencial ao colocar qualquer agente DevOps com LangChain próximo de sistemas de produção.

Expandindo o agente: próximos passos

O agente construído neste tutorial cobre três operações básicas, mas a mesma estrutura escala para cenários mais complexos. Você pode adicionar uma ferramenta de restart de serviço (systemctl restart) protegida pelo mesmo middleware de confirmação, uma ferramenta de consulta a métricas via API do Prometheus para embasar decisões do agente com dados reais, integração com Slack ou Telegram para receber comandos e enviar alertas diretamente do agente, e memória de longo prazo, registrando o histórico de ações executadas em um banco de dados para auditoria. Também é possível conectar o agente a servidores MCP (Model Context Protocol) para reutilizar ferramentas já expostas por outras plataformas de observabilidade, sem precisar reescrever integrações do zero.

Boas práticas para agentes DevOps em produção

Rodar um agente de IA com acesso a comandos de sistema exige mais cautela do que um chatbot comum. Restrinja o escopo de cada ferramenta ao mínimo necessário, evitando funções genéricas que executem comandos arbitrários passados pelo modelo. Sempre implemente confirmação humana para qualquer ação irreversível, como remoção de arquivos, restart de serviços críticos ou alterações de configuração. Registre logs de auditoria de cada chamada de ferramenta, incluindo os argumentos usados e o resultado retornado, para rastrear decisões tomadas pelo agente. Limite o acesso do agente a credenciais com escopo reduzido, seguindo o princípio de menor privilégio, e nunca exponha chaves de API de produção diretamente no código-fonte. Por fim, teste o agente extensivamente em ambiente de staging antes de liberar qualquer ferramenta sensível em produção.

Conclusão

Construir um agente DevOps com LangChain é um exercício direto de conectar um LLM a ferramentas Python bem definidas, aproveitando o loop ReAct para automatizar decisões que hoje ainda dependem de intervenção manual. Com create_agent, três ferramentas simples e uma camada de confirmação para ações destrutivas, já é possível ter um assistente capaz de verificar serviços, checar APIs e limpar logs com segurança. A partir dessa base, o caminho natural é expandir o conjunto de ferramentas, integrar com sistemas de observabilidade existentes e aplicar o mesmo padrão de agente DevOps com LangChain a fluxos cada vez mais complexos de automação de infraestrutura.

Tag

Posts Relacionados