Redação YTI&W-News
Introdução ao Self-Hosted AI
O Self-Hosted AI é uma abordagem de integração de inteligência artificial (IA) que permite que as organizações alojem e gerenciem seus próprios modelos de IA em suas infraestruturas locais, em vez de confiar em APIs na nuvem. Isso oferece uma maior flexibilidade, controle e segurança sobre os dados e os modelos de IA utilizados.
O OpenClaw é um framework de código aberto que facilita a implementação de Self-Hosted AI, permitindo que as organizações definam e gerenciem seus próprios modelos de IA, conectem-os a ferramentas e APIs e gerenciem seu ciclo de vida. O OpenClaw é projetado para ser escalável e flexível, permitindo que as organizações ajustem sua infraestrutura de acordo com as necessidades específicas de seus negócios.
A escolha de um sistema Self-Hosted AI em vez de uma API na nuvem é motivada pela necessidade de controle e segurança sobre os dados e os modelos de IA utilizados. Ao alojar os próprios modelos de IA, as organizações podem evitar a dependência de terceiros e garantir que seus dados estejam protegidos. Além disso, a Self-Hosted AI pode oferecer melhorias na escalabilidade e na eficiência, pois as organizações podem ajustar sua infraestrutura de acordo com as necessidades específicas de seus negócios.
O OpenClaw é uma opção atraente para as organizações que buscam implementar Self-Hosted AI de forma segura e escalável. Com o OpenClaw, as organizações podem definir e gerenciar seus próprios modelos de IA, conectá-los a ferramentas e APIs e gerenciar seu ciclo de vida, garantindo que seus dados estejam protegidos e que sua infraestrutura seja escalável e eficiente.
📊 Arquitetura Inicial e Decisões de Hardware
O sistema foi inicialmente projetado com uma arquitetura baseada em um servidor bare-metal, com um servidor de nuvem como fallback. O servidor bare-metal foi escolhido por sua capacidade de oferecer maior controle e flexibilidade em relação aos recursos de hardware.
Especificações de Hardware
O servidor bare-metal foi equipado com:
- Dual AMD EPYC 7443 CPUs (48 núcleos totais)
- 256 GB DDR4 ECC RAM
- Duas NVIDIA A10 GPUs (24 GB VRAM cada)
- 2 TB NVMe de armazenamento em RAID 1
Os custos mensais de colocation, incluindo energia e banda, foram de aproximadamente $1.200.
Configuração do OpenClaw
O OpenClaw foi configurado usando Docker Compose com cinco agentes, cada um com um papel diferente:
- Agente de resumo de documentos
- Agente de extração de dados
- Agente de roteamento de perguntas de clientes
- Agente de triagem de revisão de código
- Agente de geração de relatórios
Cada agente foi definido em um arquivo YAML separado, especificando seu papel, modelo, acesso a ferramentas e comportamento de timeout.
Integração com Ferramentas Internas
O OpenClaw foi integrado com uma API REST para submissão de tarefas, um banco de dados PostgreSQL para armazenamento de estado e auditoria, e um servidor de Redis para armazenamento de dados de sessão.
Cada agente conectou-se a um servidor de ferramentas internas que expunha serviços de parsing de PDF, consultas de banco de dados e validação de schema por meio de HTTP.
# docker-compose.yml — OpenClaw production stack, Day 0
# Requires: Docker Compose v2+, NVIDIA Container Toolkit installed on host
# Set PG_PASSWORD in a .env file before running: docker compose up -d
services:
openclaw-core:
image: openclaw/core:latest
restart: always
ports:
- "8400:8400"
environment:
- OPENCLAW_MODEL_BACKEND=vllm
- OPENCLAW_STATE_STORE=redis
- OPENCLAW_LOG_LEVEL=info
- OPENCLAW_MAX_AGENTS=10
- VLLM_MODEL=mistralai/Mistral-7B-Instruct-v0.3
- VLLM_GPU_MEMORY_UTILIZATION=0.85
- VLLM_MAX_MODEL_LEN=8192
volumes:
- ./config:/etc/openclaw
- model-cache:/models
deploy:
resources:
limits:
memory: 32G
reservations:
devices:
- driver: nvidia
count: 2
capabilities: [gpu]
depends_on:
- redis
- postgres
redis:
image: redis:7-alpine
restart: always
ports:
- "6379:6379"
postgres:
image: postgres:16-alpine
restart: always
environment:
- POSTGRES_DB=openclaw
- POSTGRES_USER=openclaw
- POSTGRES_PASSWORD=${PG_PASSWORD}
volumes:
- pgdata:/var/lib/postgresql/data
model-cache:
pgdata:
📈 Desempenho e Surpresas Iniciais
Após estabelecer os baselines de desempenho para todos os cinco tipos de agentes utilizando um conjunto de teste de carga com k6, observamos os seguintes resultados:
Desempenho dos Agentes
- O agente de resumo de documentos processava aproximadamente 14 requisições por minuto com uma latência média de 3,2 segundos.
- O agente de extração de dados era mais lento, processando cerca de 8 requisições por minuto, devido às chamadas de ferramentas em várias etapas.
- A utilização de GPU estava em 72% médio para ambos os A10s, enquanto a utilização de CPU raramente ultrapassava 35%.
- O consumo de memória foi a surpresa: mesmo com um limite de container de 32 GB, o processo de OpenClaw Core subiu para 28 GB até o dia três.
Primeiras Surpresas e Problemas
- Em dia cinco, o primeiro problema real apareceu: as sessões de agente de longo prazo acumulavam estado de contexto que nunca foi completamente coletado entre tarefas.
- Isso levou a um aumento gradual no consumo de VRAM até que o backend vLLM seja OOM-killed e reiniciado.
- O agente de triagem de revisão de código, após processar cerca de 200 pull requests consecutivos, começou a classificar níveis de severidade incorretamente.
- Seu histórico de conversa acumulado estava poluindo o contexto de prompt do sistema.
Para resolver esses problemas, implementamos uma configuração de observabilidade para rastrear o número de tokens de contexto do agente de sessão e forçar um reset de sessão após 50 tarefas.
# prometheus/openclaw-targets.yml
scrape_configs:
- job_name: "openclaw-agents"
scrape_interval: 15s
static_configs:
- targets: ["openclaw-core:8400"]
metrics_path: /metrics
metric_relabel_configs:
- source_labels: [__name__]
regex: "openclaw_agent_tasks_total|openclaw_agent_latency_seconds|openclaw_gpu_memory_bytes|openclaw_agent_errors_total|openclaw_session_context_tokens"
action: keep
Essa métrica se tornou nosso sistema de alerta precoce para deriva de agente.
🔄 Escalabilidade e Pivô da Arquitetura
Desafios de Escalabilidade
Quando tentamos escalar de 5 para 12 agentes concorrentes, o sistema entrou em colapso. O vLLM backend não conseguiu servir 12 agentes simultaneamente em duas GPUs A10 sem contenda grave. As requisições ficaram acumuladas, os tempos de resposta aumentaram e o armazenamento de estado do PostgreSQL ficou cheio de registros incompletos. O gargalo era a memória de GPU: 24 GB por cartão é generoso para uma ou duas instâncias de modelo, mas com 12 agentes todos esperando inferência baixa-latência, a pressão na cache KV foi insustentável.
Pivô da Arquitetura: Introdução de Fila de Tarefas e Gerenciador de Pool de Agentes
Para resolver esses problemas, rearquitetamos o sistema. Em vez de agentes puxando tarefas diretamente da API, introduzimos Redis Streams como uma fila de tarefas com níveis de prioridade, lógica de retry e tratamento de mensagens mortas. Os agentes se tornaram trabalhadores em pool: cinco agentes quentes rodaram continuamente e agentes adicionais foram iniciados apenas quando a profundidade da fila excedeu um limiar.
# task_queue/worker.py — Trabalhador em pool com Redis Streams
# Requer: pip install redis requests
import os
import json
import time
import logging
import redis
import requests
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
r = redis.Redis(host="redis", port=6379, decode_responses=True)
STREAM = "openclaw:tasks"
GROUP = "agent-pool"
CONSUMER = f"worker-{os.getpid()}"
DLQ_STREAM = "openclaw:tasks:dlq"
MAX_RETRIES = 3
# Crie o grupo de consumidores se não existir
try:
r.xgroup_create(STREAM, GROUP, id="0", mkstream=True)
except redis.exceptions.ResponseError:
# O grupo já existe
pass
def process_task(task_data):
resposta = requests.post(
"http://openclaw-core:8400/v1/tasks",
json=task_data,
timeout=task_data.get("timeout_seconds", 120),
)
resposta.raise_for_status()
return resposta.json()
while True:
try:
entradas = r.xreadgroup(
GROUP, CONSUMER, {STREAM: ">"}, count=1, block=5000
)
except redis.exceptions.ConnectionError:
logger.warning("Conexão Redis perdida, tentando novamente em 5s...")
time.sleep(5)
continue
if not entradas:
continue
for stream_name, mensagens in entradas:
for msg_id, campos in mensagens:
task_data = json.loads(campos["payload"])
reprises = int(campos.get("retries", 0))
prioridade = campos.get("prioridade", "normal")
try:
resultado = process_task(task_data)
r.xack(STREAM, GROUP, msg_id)
logger.info("Tarefa %s concluída com sucesso", msg_id)
except Exception as e:
logger.error("Tarefa %s falhou: %s", msg_id, e)
# Acredite a mensagem falha para que não seja reenviada
r.xack(STREAM, GROUP, msg_id)
if reprises >= MAX_RETRIES:
r.xadd(
DLQ_STREAM,
{
"payload": campos["payload"],
"erro": str(e),
"id_original": msg_id,
},
)
else:
r.xadd(
STREAM,
{
"payload": campos["payload"],
"reprises": str(reprises + 1),
"prioridade": prioridade,
},
)
Com essa mudança, a estabilidade e o desempenho do sistema melhoraram significativamente. A taxa de processamento de tarefas estabilizou em 45 tarefas por minuto com sete agentes quentes, e a fila absorveu picos de tráfego sem causar falhas em cascata. Essa foi a mudança mais impactante que fizemos ao longo dos 30 dias.
📊 Análise de Custo e Conclusões
Comparação de Custo entre Self-Hosted e API na Nuvem
| Categoria de Custo | Self-Hosted | API na Nuvem |
| — | — | — |
| Colocation (servidor + energia + banda) | $1,200 | – |
| Amortização de Hardware | $680 | – |
| Licenças de Software | $0 | – |
| Mão de Obra de Operação (8 horas/semana a $95/hora) | $3,040 | $760 (manutenção de integração) |
| Ferramentas de Monitoramento (Grafana Cloud free tier + Prometheus) | $0 | – |
| Total Mensal | $4,920 | $4,741 |
Resultados da Análise de Custo
A análise de custo revelou que os custos de self-hosting são semelhantes aos custos de usar uma API na nuvem, especialmente considerando a opção de manutenção de integração. No entanto, é importante notar que o self-hosting exige uma maior investimento em infraestrutura e mão de obra de operação, enquanto a API na nuvem oferece uma solução mais flexível e escalável.
Implicações para a Adoção de Sistemas Self-Hosted
A análise de custo sugere que os sistemas self-hosted são mais adequados para equipes com trabalholoads estáveis e altos, além de existir infraestrutura de GPU ou relacionamentos de colocation. Além disso, a adoção de sistemas self-hosted pode ser mais apropriada para equipes que valorizam a soberania dos dados e a capacidade de controlar a infraestrutura.
Conclusões
A análise de custo e as implicações para a adoção de sistemas self-hosted sugerem que a escolha entre self-hosting e API na nuvem depende das necessidades e prioridades específicas da equipe. Em resumo, os sistemas self-hosted oferecem mais controle e soberania dos dados, mas exige uma maior investimento em infraestrutura e mão de obra de operação.
Fonte de Referência: sitepoint.com.
Curadoria e Adaptação: Redação Yassutaro Developers.
Redação YTI&W-News
Notícias do universo do Desenvolvimento Web, dicas e tutoriais para Webmasters.
- Ollama vs vLLM: Simplicidade como Obstáculo Técnico 16 de fevereiro de 2026
- Revolução Zero Inference com WebGPU 16 de fevereiro de 2026
- Crie código offline em 30 minutos com LLM stack 16 de fevereiro de 2026
- Desbloqueie o Poder do StringTune 16 de fevereiro de 2026
- Guia Completo sobre Filestack: Passo a Passo 15 de fevereiro de 2026
