ClickHouse vs TimescaleDB em VPS NVMe: Como Construir Analytics e Logs em Tempo Real Sem Pagar Datadog

A Crise dos Custos de Observabilidade: O Choque das Faturas em Dólar

À medida que aplicações modernas escalam, a geração de dados operacionais explode: logs de requisições HTTP, eventos de webhooks de gateways de pagamento, telemetria de consumo de tokens em chamadas de LLMs (OpenAI, Claude) e mensagens processadas por serviços como VPS para Evolution API v3 e automações no VPS para n8n.

Para monitorar esses fluxos, muitas empresas recorrem a plataformas SaaS consagradas como Datadog, New Relic, Loggly ou Dynatrace. Porém, o modelo de precificação dessas ferramentas em moeda estrangeira se tornou um dos maiores ralos de capital de startups e software houses brasileiras:

• Cobrança por Gigabyte Indexado: Plataformas de log cobram em média de US$ 0,10 a US$ 0,30 por gigabyte ingerido, somado a taxas adicionais por retenção de 15 a 30 dias. Uma aplicação que gera 30GB de logs brutos por dia atinge faturas de US$ 300 a US$ 900 mensais apenas para ler os próprios logs.
• Amostragem Compulsória (Sampling): Para evitar o estouro do orçamento em dólar, os times são obrigados a configurar regras de amostragem que descartam 80% a 90% dos logs informativos, tornando impossível debugar problemas intermitentes de clientes reais.
• Tributação Cambial e IOF: Todas as faturas incidem 4,38% de IOF no cartão corporativo internacional, além da oscilação constante do câmbio comercial.

1. ClickHouse: O Gigante Colunar de Velocidade Brutal

O ClickHouse revolucionou o mundo dos bancos analíticos (OLAP). Enquanto bancos de dados relacionais organizam os registros linha a linha na memória e no disco, o ClickHouse agrupa os dados verticalmente por colunas através do seu poderoso motor MergeTree:

• Vetorização de Consultas (SIMD): O motor processa dados em blocos vetoriais aproveitando instruções avançadas da CPU (AVX2/AVX-512), permitindo escanear centenas de milhões de linhas por segundo por núcleo.
• Compressão Extrema em NVMe: Como valores da mesma coluna possuem alta redundância (ex: milhares de repetições do status HTTP 200 ou do método POST), algoritmos como LZ4 e ZSTD compactam o volume original em até 10 vezes.
• Ingestão em Lotes (Batching): O ClickHouse é projetado para receber blocos de dados. Inserções de 5.000 a 50.000 eventos por segundo são processadas com facilidade em instâncias de entrada.

2. TimescaleDB: Particionamento Temporal sem Abandonar o PostgreSQL

O TimescaleDB segue uma filosofia complementar: em vez de construir um novo banco do zero, ele transforma o robusto PostgreSQL 16 em uma máquina de séries temporais de alta eficiência:

• Conceito de Hypertables: O TimescaleDB particiona automaticamente uma tabela comum em múltiplos "chunks" físicos baseados em intervalos de tempo (ex: 1 dia ou 1 semana). A aplicação enxerga apenas uma tabela única, mas o Postgres lê apenas a fatia exata solicitada.
• Integridade Relacional Plena (ACID): Você pode fazer JOIN entre bilhões de eventos de log e sua tabela convencional de clientes ou assinaturas com total consistência.
• Compressão Colunar Híbrida: Em dados históricos mais antigos que 7 dias, o TimescaleDB converte o armazenamento para o formato colunar dentro do próprio PostgreSQL, reduzindo o espaço em disco em até 85%.

Implementação Prática de Hypertables no PostgreSQL 16

Para criar uma hypertable com compressão automática e agregação contínua no TimescaleDB, execute o seguinte script SQL:

-- 1. Habilita a extensão TimescaleDB no PostgreSQL 16
CREATE EXTENSION IF NOT EXISTS timescaledb CASCADE;

-- 2. Cria tabela padrão de eventos
CREATE TABLE eventos_aplicacao (
    tempo TIMESTAMPTZ NOT NULL,
    usuario_id BIGINT,
    evento VARCHAR(50) NOT NULL,
    duracao_ms INT,
    sucesso BOOLEAN,
    metadata JSONB
);

-- 3. Converte a tabela em Hypertable com chunks de 1 dia
SELECT create_hypertable('eventos_aplicacao', 'tempo', chunk_time_interval => INTERVAL '1 day');

-- 4. Habilita compressão colunar nativa
ALTER TABLE eventos_aplicacao SET (
    timescaledb.compress,
    timescaledb.compress_segmentby = 'evento',
    timescaledb.compress_orderby = 'tempo DESC'
);

-- 5. Política para comprimir automaticamente dados com mais de 3 dias
SELECT add_compression_policy('eventos_aplicacao', INTERVAL '3 days');

-- 6. Política de retenção para expirar dados com mais de 180 dias
SELECT add_retention_policy('eventos_aplicacao', INTERVAL '180 days');

Painéis no Grafana: Telemetria de Custos de IA em Tempo Real

Com os dados fluindo continuamente para o ClickHouse ou TimescaleDB, basta conectar o Grafana como visualizador para obter dashboards em tempo real:

• Custo por Modelo e Usuário: Visualize em gráficos de barras o custo diário de chamadas à OpenAI (GPT-4o) e Anthropic (Claude 3.5 Sonnet), identificando instantaneamente contas com comportamento anômalo.
• Latência P95 e P99 de Requisições: Acompanhe a experiência real dos seus usuários no Brasil e detecte lentidões em rotas críticas antes que gerem chamados no suporte.
• Taxa de Erro de Webhooks: Monitore o volume de falhas em integrações com gateways de pagamento ou disparos de mensagens WhatsApp, acionando alertas no Discord ou Telegram.

Configuração de Produção: docker-compose.yml com ClickHouse e Grafana

Abaixo está a infraestrutura pronta para coletar logs e exibir dashboards de telemetria em tempo real em sua VPS You Secure:

version: '3.8'

services:
  clickhouse:
    image: clickhouse/clickhouse-server:latest
    container_name: telemetry_clickhouse
    restart: always
    environment:
      - CLICKHOUSE_DB=telemetry
      - CLICKHOUSE_USER=analytics_user
      - CLICKHOUSE_PASSWORD=${CH_PASSWORD}
    ports:
      - "127.0.0.1:8123:8123" # HTTP Interface
      - "127.0.0.1:9000:9000" # Native Client
    volumes:
      - ch_data:/var/lib/clickhouse
      - ch_logs:/var/log/clickhouse-server
    ulimits:
      nofile:
        soft: 262144
        hard: 262144
    networks:
      - telemetry_net

  grafana:
    image: grafana/grafana:latest
    container_name: telemetry_grafana
    restart: always
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
    ports:
      - "127.0.0.1:3001:3000"
    volumes:
      - grafana_data:/var/lib/grafana
    depends_on:
      - clickhouse
    networks:
      - telemetry_net

networks:
  telemetry_net:
    driver: bridge

volumes:
  ch_data:
  ch_logs:
  grafana_data:

Esquema de Tabela com TTL Automático no ClickHouse

Para registrar logs de requisições e consumo de tokens de inteligência artificial com expiração automática após 90 dias, execute no ClickHouse:

Codecs Avançados de Compressão no ClickHouse

Para alcançar índices de compressão ainda mais extremos em discos NVMe, o ClickHouse permite aplicar codecs especializados por coluna. Por exemplo, em colunas de timestamps e valores float de métricas contínuas, os algoritmos DoubleDelta e Gorilla eliminam quase 95% do peso dos números inteiros e decimais:

-- Exemplo de coluna com compressão especializada combinada
timestamp DateTime64(3, 'America/Sao_Paulo') CODEC(DoubleDelta, ZSTD(1)),
duration_ms Float32 CODEC(Gorilla, ZSTD(1))

CREATE TABLE IF NOT EXISTS telemetry.api_logs (
    timestamp DateTime64(3, 'America/Sao_Paulo'),
    request_id UUID,
    service_name LowCardinality(String),
    endpoint LowCardinality(String),
    method LowCardinality(String),
    status_code UInt16,
    duration_ms Float32,
    prompt_tokens UInt32,
    completion_tokens UInt32,
    total_cost_usd Float64,
    client_ip String,
    error_message String
)
ENGINE = MergeTree()
PARTITION BY toYYYYMM(timestamp)
ORDER BY (service_name, status_code, timestamp)
TTL timestamp + INTERVAL 90 DAY;

Pipeline de Ingestão com Redis 7 para Zero Sobrecarga

Para que o envio de métricas não introduza latência nas respostas da aplicação principal, os eventos são enfileirados no Redis 7 e descarregados em lotes para o ClickHouse a cada 3 segundos:

// Exemplo de ingestor assíncrono em lotes com Node.js
import { Redis } from 'ioredis';
import { createClient } from '@clickhouse/client';

const redis = new Redis(process.env.REDIS_URL!);
const ch = createClient({
  url: 'http://clickhouse:8123',
  username: 'analytics_user',
  password: process.env.CH_PASSWORD,
  database: 'telemetry'
});

async function processBatch() {
  const logs = await redis.rpop('log_buffer', 2000);
  if (!logs || logs.length === 0) return;

  const rows = logs.map(l => JSON.parse(l));
  
  await ch.insert({
    table: 'api_logs',
    values: rows,
    format: 'JSONEachRow'
  });
}

// Executa em intervalo contínuo sem travar a CPU
setInterval(processBatch, 3000);

Comparativo Direto de Engenharia: ClickHouse vs TimescaleDB vs Datadog

Confira o comparativo técnico e financeiro entre as abordagens:

Construir sua própria camada de observabilidade na VPS You Secure é o caminho mais inteligente para obter visibilidade irrestrita sobre sua arquitetura, preservando a saúde financeira do seu negócio. Conheça as configurações técnicas das Melhores VPS do Brasil e tome o controle definitivo da sua infraestrutura.