Browser Use e Playwright com Agentes de IA: Como Rodar Automação Web Autônoma 24/7 em VPS Linux

1. A Nova Era da Automação Web: Por Que Agentes Visuais Mudaram o Jogo

Durante mais de uma década, a automação web corporativa dependeu de scripts frágeis construídos sobre Selenium, Puppeteer ou BeautifulSoup. Esses scripts baseavam-se em seletores CSS estáticos e caminhos XPath rígidos (como div.card > button.btn-primary). Bastava uma atualização na interface do usuário (UI), a alteração de uma classe pelo framework de frontend ou um teste A/B no portal de destino para que toda a esteira de automação quebrasse, demandando horas de manutenção de engenharia.

Em 2027, bibliotecas de última geração como o browser-use integradas ao Playwright e impulsionadas por modelos multimodais de alta eficiência (como Google Gemini 2.5 Flash e Claude 3.5/3.7 Sonnet) revolucionaram esse paradigma. Em vez de depender de seletores CSS fixos, o agente de IA 'enxerga' a página da mesma forma que um operador humano:

• Ele extrai a árvore de acessibilidade do navegador (Accessibility Tree), identificando elementos semânticos navegáveis.
• Calcula as caixas delimitadoras (Bounding Boxes - BBox) com coordenadas cartesianas na tela para cada botão, campo de entrada e link.
• Captura um screenshot da viewport renderizada e sobrepõe marcadores visuais numerados em cada elemento interativo.
• Envia a imagem compactada e o estado semântico para o modelo de linguagem multimodal, que decide qual ação tomar: click_element(id=14), input_text(id=8, text='01.234.567/0001-89') ou scroll_down(pages=1).

Essa flexibilidade permite construir robôs capazes de emitir certidões negativas em portais de prefeituras, preencher cadastros em ERPs legados, monitorar preços em marketplaces complexos e alimentar pipelines em uma VPS para n8n sem quebrar com mudanças cosméticas de layout.

2. O Grande Gargalo do Linux em Produção: A Armadilha do /dev/shm

Quando os desenvolvedores movem um agente baseado em browser-use do ambiente local (onde o navegador roda com aceleração de hardware e memória de sobra) para uma VPS Linux headless, um problema clássico e devastador surge logo nas primeiras execuções: o navegador fecha abruptamente sem deixar traceback em Python.

A causa raiz reside no mecanismo de renderização do Chromium. Para renderizar elementos pesados de Single Page Applications (SPAs) modernas desenvolvidas em React, Next.js ou Angular, o Chromium compartilha buffers gráficos de memória entre o processo mestre do navegador e os processos filhos de renderização de abas utilizando o sistema de arquivos virtual /dev/shm (Shared Memory / tmpfs).

Por padrão de segurança, o daemon do Docker aloca apenas 64 megabytes de espaço para /dev/shm em qualquer container recém-criado. Uma única página rica com banners em alta definição, scripts de tracking e elementos Canvas pode ultrapassar esse limite em segundos. Quando isso acontece, o Linux envia um sinal de terminação forçada por violação de memória:

Para eliminar definitivamente esse comportamento em produção contínua, duas configurações simultâneas são indispensáveis:

1. Configurar explicitamente o tamanho da memória compartilhada no Docker Compose através da diretiva shm_size: '2gb'.
2. Iniciar o Chromium via Playwright com as flags de compatibilidade headless Linux: --disable-dev-shm-usage, --no-sandbox e --disable-gpu.

3. Por Que o Endereço IP Brasileiro de São Paulo é Decisivo

Muitos desenvolvedores cometem o erro grave de contratar servidores extremamente baratos sediados na Alemanha, Finlândia ou Estados Unidos (como Hetzner ou OVH) para rodar agentes web voltados a processos de negócios no Brasil. O resultado prático é o bloqueio imediato do robô nas primeiras 24 horas de operação.

Sistemas modernos de mitigação de tráfego automatizado e Web Application Firewalls (Cloudflare Turnstile, Akamai Bot Manager, Datadome, Kasada e reCAPTCHA Enterprise) utilizam análise comportamental de rede. Quando um endereço IP associado a um datacenter na Europa tenta autenticar-se em um portal de banco brasileiro, no sistema da Nota Fiscal Paulista ou em marketplaces nacionais como Mercado Livre e Magalu, as seguintes regras são disparadas:

• Geo-blocking e Desafios Interativos: O portal exige desafios biométricos ou captchas visuais impossíveis de contornar sem custos astronômicos de tokens.
• Reputação de ASN Internacional: Faixas de IP estrangeiras possuem baixa pontuação de confiança para transações em Real (BRL).
• Latência Adicional de Conexão: O tráfego precisa cruzar cabos submarinos atlânticos, adicionando de 180ms a 240ms de overhead a cada requisição de imagem, script e stylesheet da página.

Ao hospedar seu agente em uma VPS sem fidelidade no Brasil em São Paulo, o container herda um endereço IPv4 nacional limpo, com latência de apenas 6,6ms em relação ao Ponto de Troca de Tráfego central (IX.br). O tráfego do agente é interpretado pelos firewalls corporativos como uma navegação comum de usuário local, reduzindo os bloqueios por captcha em mais de 90%.

4. Arquitetura 24/7 com Docker Compose e noVNC para Depuração Visual

Em ambientes headless puros, quando o agente de IA encontra um fluxo inesperado (como um modal promocional desconhecido ou um formulário dinâmico em etapas), a equipe técnica fica completamente às cegas sem saber o que o navegador estava exibindo.

A solução profissional consiste em empacotar o container com um servidor virtual de janelas Xvfb e uma interface web noVNC. Isso permite que você acerte regras de firewall e abra o navegador pelo browser do seu computador (na porta 6080) para assistir a IA navegando em tempo real, ou intervir manualmente assumindo o controle do mouse e teclado quando necessário:

[Operador Humano] ──(HTTPS porta 6080)──► [noVNC Web Interface]
                                                 │
                                                 ▼
[Container Docker] ──(X11 Socket)──► [Xvfb Display :99] ◄── [x11vnc]
      │                                       ▲
      ▼                                       │ (Renderização Gráfica)
[Python 3.11 Runtime: browser-use + Playwright] ──► [Chromium Engine]
      │                                                   │ (shm_size: 2GB)
      ├──(Tokens Multimodais)──► [Gemini 2.5 Flash / Claude]
      └──(Notificações de Alerta)──► [Evolution API WhatsApp / n8n]
  

Abaixo apresentamos o docker-compose.yml pronto para produção, configurado com alocação correta de memória compartilhada e volumes persistentes para cookies e sessões:

# docker-compose.yml - Infraestrutura 24/7 para Agentes Web Autônomos
version: '3.8'

services:
  browser_agent:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: browser_use_worker
    restart: unless-stopped
    # CRÍTICO: 2GB de memória compartilhada para impedir SIGSEGV do Chromium
    shm_size: '2gb'
    environment:
      - DISPLAY=:99
      - RESOLUTION=1920x1080x24
      - GEMINI_API_KEY=AIzaSyD-YourRealKeyHere
      - REDIS_URL=redis://redis_queue:6379/0
      - EVOLUTION_API_URL=https://wa.seudominio.com.br
      - EVOLUTION_API_KEY=sua_chave_global_evolution
    ports:
      # Porta noVNC para monitoramento visual em tempo real
      - "127.0.0.1:6080:6080"
    volumes:
      # Persistência de cookies e dados de sessão entre reinicializações
      - ./browser_sessions:/app/sessions
      - ./agent_recordings:/app/recordings
      - ./logs:/app/logs
    networks:
      - internal_agent_net
    depends_on:
      - redis_queue

  redis_queue:
    image: redis:7-alpine
    container_name: agent_task_redis
    restart: always
    command: redis-server --appendonly yes --maxmemory 512mb --maxmemory-policy allkeys-lru
    volumes:
      - redis_data:/data
    networks:
      - internal_agent_net

networks:
  internal_agent_net:
    driver: bridge

volumes:
  redis_data:

5. Implementação em Python: Agente Resiliente com Persistência de Sessão

Abaixo está o script completo em Python utilizando a biblioteca browser-use, demonstrando como inicializar o Playwright com persistência de cookies (storage_state), gerenciar janelas virtuais no Linux e disparar relatórios executivos para a equipe:

# agent_runner.py - Execução Autônoma de Browser Use 24/7
import os
import asyncio
from pathlib import Path
from browser_use import Agent, Browser, BrowserConfig
from browser_use.browser.context import BrowserContextConfig
from langchain_google_genai import ChatGoogleGenerativeAI
import requests

SESSION_DIR = Path("/app/sessions")
SESSION_DIR.mkdir(parents=True, exist_ok=True)
STORAGE_FILE = SESSION_DIR / "auth_state.json"

async def run_autonomous_browser_agent(task_instruction: str):
    # 1. Configuração do Chromium para ambiente headless Linux KVM
    browser_config = BrowserConfig(
        headless=True,
        disable_security=False,
        extra_chromium_args=[
            "--no-sandbox",
            "--disable-setuid-sandbox",
            "--disable-dev-shm-usage",
            "--disable-gpu",
            "--window-size=1920,1080",
            "--lang=pt-BR,pt",
        ]
    )
    
    # 2. Configuração de contexto com persistência de cookies
    context_config = BrowserContextConfig(
        cookies_file=str(STORAGE_FILE) if STORAGE_FILE.exists() else None,
        locale="pt-BR",
        timezone_id="America/Sao_Paulo",
    )
    
    browser = Browser(config=browser_config)
    context = await browser.new_context(config=context_config)
    
    # 3. LLM Multimodal de alta velocidade e baixo custo de tokens
    llm = ChatGoogleGenerativeAI(
        model="gemini-2.5-flash",
        google_api_key=os.getenv("GEMINI_API_KEY"),
        temperature=0.1
    )
    
    agent = Agent(
        task=task_instruction,
        llm=llm,
        browser_context=context,
        use_vision=True,
        save_conversation_path="/app/logs/conversation.json"
    )
    
    print(f"[AGENT] Iniciando tarefa autônoma: {task_instruction}")
    history = await agent.run(max_steps=25)
    
    # 4. Salva o estado da sessão (cookies/tokens) para evitar novos logins
    await context.save_storage_state(path=str(STORAGE_FILE))
    await browser.close()
    
    final_result = history.final_result()
    print(f"[AGENT] Concluído com sucesso: {final_result}")
    
    # 5. Notificação via WhatsApp pela Evolution API
    notify_whatsapp_operator(task_instruction, final_result)
    return final_result

def notify_whatsapp_operator(task: str, result: str):
    evo_url = os.getenv("EVOLUTION_API_URL")
    evo_key = os.getenv("EVOLUTION_API_KEY")
    if not evo_url or not evo_key:
        return
    
    payload = {
        "number": "5511999999999",
        "text": f"🤖 *Relatório de Execução do Agente Web*\n\n*Tarefa:* {task}\n\n*Resultado:*\n{result}"
    }
    try:
        requests.post(
            f"{evo_url}/message/sendText/operacoes",
            json=payload,
            headers={"apikey": evo_key},
            timeout=10
        )
    except Exception as e:
        print(f"[WARN] Falha ao enviar WhatsApp: {e}")

if __name__ == "__main__":
    test_task = (
        "Acesse o site da Receita Federal ou portal de certidões, "
        "consulte o status cadastral da empresa e extraia a data de validade da certidão."
    )
    asyncio.run(run_autonomous_browser_agent(test_task))

6. Integração com Evolution API v3 e n8n para Operações Completas

Um agente web isolado resolve apenas metade do desafio corporativo. O verdadeiro ganho de produtividade ocorre quando você orquestra o agente dentro de uma esteira integrada:

1. O cliente ou gestor da empresa envia um comando via WhatsApp (por exemplo: 'Consulte o estoque do fornecedor X e emita o boleto').
2. A VPS para Evolution API v3 recebe o webhook do WhatsApp e repassa o payload para a VPS para n8n.
3. O n8n valida os parâmetros, grava a solicitação na fila Redis e aciona o worker do browser-use via requisição interna.
4. O agente executa o Playwright no Chromium Headless, resolve o fluxo web, faz o download do arquivo PDF do comprovante e devolve o documento via mensagem direta de WhatsApp.

Essa arquitetura integrada transforma processos burocráticos manuais que consumiam horas de colaboradores em fluxos automáticos executados em segundos, sem risco de esquecimento e com auditoria completa de logs.

7. Dimensionamento de VPS e Requisitos de Hardware

Diferente de microsserviços convencionais de API que consomem poucos megabytes de memória, o Chromium é uma das aplicações mais ávidas por recursos computacionais do ecossistema Linux. Cada aba ativa de navegação aloca threads isoladas para compilação JavaScript (V8), renderização visual (Blink) e decodificação de mídia.

Tentar executar o browser-use em servidores virtuais com apenas 2GB de RAM (frequentes em hospedagens populares genéricas) leva a travamentos constantes e corrupção de sessões. O dimensionamento técnico mínimo recomendado para operação 24/7 consiste em:

• Virtualização: KVM estrita, garantindo que o Chromium tenha acesso a instruções de CPU modernas (AVX2, SSE4) essenciais para compilação rápida de scripts JS.
• Processamento: 4 vCPUs dedicadas para suportar picos de carga durante a abertura simultânea de abas e cálculo de árvores de acessibilidade.
• Memória RAM: 4GB de RAM reais, permitindo alocar 2GB para /dev/shm, 1GB para o sistema operacional Linux e 1GB para os processos Python e Redis.
• Armazenamento: 100GB em discos NVMe de alta performance, assegurando escrita ultra-rápida de gravações de vídeo de sessões e screenshots em alta resolução.

Na You Secure, você conta com um dos Melhores VPS do Brasil, desenhado especificamente para suportar cargas de trabalho intensivas de inteligência artificial, automação e orquestração de microsserviços.