Extensões PostgreSQL: Substitua Redis, MongoDB e Kafka com SQL

Dominar as extensões PostgreSQL deixou de ser apenas uma opção para se tornar a principal estratégia de arquitetura em 2026. Com um ecossistema extremamente maduro, o Postgres agora absorve nativamente cargas de trabalho pesadas que antes exigiam infraestruturas separadas — como Elasticsearch, Redis, MongoDB e Kafka. E o melhor? Ele faz tudo isso dentro do SQL padrão, garantindo transações ACID e cortando os custos operacionais pela metade.

Neste guia definitivo, você vai descobrir na prática como configurar o PostgreSQL para lidar com busca textual avançada (BM25), busca vetorial com IA, séries temporais, filas de mensagens, cache em memória e muito mais. Se você quer simplificar seu backend e escalar sem dor de cabeça, este artigo é o seu mapa.

Em 2026, o PostgreSQL deixou de ser apenas um banco relacional. Com um ecossistema de extensões maduro, ele absorve cargas de trabalho que antes exigiam múltiplos bancos especializados — e faz isso dentro do SQL, com transações ACID, sem sincronização de dados e com uma única infraestrutura para operar.

Neste guia, você verá exemplos SQL funcionais para busca textual, busca vetorial, séries temporais, cache, filas de mensagens, documentos, consultas geoespaciais, tarefas agendadas e busca fuzzy. Cada seção é autônoma; vá direto ao que interessa. Incluí dicas avançadas para quem quer ir além do básico e uma conclusão com recomendações de adoção progressiva.

Extensões PostgreSQL: Habilitando Tudo (ou Quase)

Abaixo está o conjunto completo de extensões que abordaremos. Você não precisa de todas — escolha as que correspondem à sua carga de trabalho. Se estiver usando o Tiger Cloud, elas já estão disponíveis sem configuração adicional. Para self-hosting, cada seção indica o repositório.

CREATE EXTENSION pg_textsearch;   -- Busca textual BM25
CREATE EXTENSION vector;          -- Busca vetorial (pgvector)
CREATE EXTENSION vectorscale;     -- Índice DiskANN para vetores
CREATE EXTENSION ai;              -- Embeddings de IA e fluxos RAG
CREATE EXTENSION timescaledb;     -- Séries temporais
CREATE EXTENSION pgmq;            -- Filas de mensagens
CREATE EXTENSION pg_cron;         -- Tarefas agendadas
CREATE EXTENSION postgis;         -- Geoespacial
CREATE EXTENSION pg_trgm;         -- Busca fuzzy (trigramas)

1. Busca de Texto Completo (Substitui Elasticsearch)

Extensão: pg_textsearch – ranqueamento BM25 verdadeiro, o mesmo algoritmo que alimenta o Elasticsearch.

Substitui: Elasticsearch (cluster JVM separado), Solr, Algolia (US$1/1.000 buscas).

Ganhos: Sem cluster separado, sem pipelines de sincronização, sem divergência de dados.

CREATE TABLE articles (
  id SERIAL PRIMARY KEY,
  title TEXT,
  content TEXT
);

CREATE INDEX idx_articles_bm25 ON articles USING bm25(content)
  WITH (text_config = 'english');

SELECT title, -(content <@> 'database optimization') AS score
FROM articles
ORDER BY content <@> 'database optimization'
LIMIT 10;

2. Busca Vetorial (Substitui Pinecone)

Extensões: pgvector + pgvectorscale

Substitui: Pinecone (US$70/mês mínimo), Qdrant, Milvus, Weaviate.

Ganhos: Índice DiskANN (da Microsoft Research). Em benchmark com 50M de vetores, latência p95 28x menor e throughput 16x maior que Pinecone com 99% de revocação.

CREATE EXTENSION vector;
CREATE EXTENSION vectorscale CASCADE;

CREATE TABLE documents (
  id SERIAL PRIMARY KEY,
  content TEXT,
  embedding vector(1536)
);

CREATE INDEX idx_docs_embedding ON documents USING diskann(embedding);

SELECT content, embedding <=> '[0.1, 0.2, ...]'::vector AS distance
FROM documents
ORDER BY embedding <=> '[0.1, 0.2, ...]'::vector
LIMIT 10;

Sincronia automática de embeddings com pgai

Chega de pipelines manuais. O pgai regenera embeddings automaticamente em cada INSERT e UPDATE.

SELECT ai.create_vectorizer(
  'documents'::regclass,
  loading => ai.loading_column(column_name => 'content'),
  embedding => ai.embedding_openai(
    model => 'text-embedding-3-small',
    dimensions => '1536'
  )
);

3. Busca Híbrida: BM25 + Vetores em uma Única Consulta

Aqui a consolidação brilha. Fora do Postgres, combinar palavra-chave e semântica exige duas APIs, fusão de resultados e latência dobrada. No Postgres, é uma única transação.

Híbrida ponderada simples

SELECT
  title,
  -(content <@> 'database optimization') AS bm25_score,
  embedding <=> query_embedding AS vector_distance,
  0.7 * (-(content <@> 'database optimization')) +
  0.3 * (1 - (embedding <=> query_embedding)) AS hybrid_score
FROM articles
ORDER BY hybrid_score DESC
LIMIT 10;

Reciprocal Rank Fusion (para aplicações RAG)

WITH bm25 AS (
  SELECT id, ROW_NUMBER() OVER (ORDER BY content <@> $1) AS rank
  FROM documents LIMIT 20
),
vectors AS (
  SELECT id, ROW_NUMBER() OVER (ORDER BY embedding <=> $2) AS rank
  FROM documents LIMIT 20
)
SELECT d.*,
  1.0 / (60 + COALESCE(b.rank, 1000)) +
  1.0 / (60 + COALESCE(v.rank, 1000)) AS score
FROM documents d
LEFT JOIN bm25 b ON d.id = b.id
LEFT JOIN vectors v ON d.id = v.id
WHERE b.id IS NOT NULL OR v.id IS NOT NULL
ORDER BY score DESC LIMIT 10;

4. Séries Temporais (Substitui InfluxDB)

Extensão: timescaledb (21K+ estrelas no GitHub)

Substitui: InfluxDB, Prometheus (apenas métricas).

Ganhos: Particionamento automático por tempo, compressão de até 95%, agregações contínuas e SQL completo. Séries temporais convivem com dados relacionais com JOINs e ACID.

CREATE EXTENSION timescaledb;

CREATE TABLE metrics (
  time TIMESTAMPTZ NOT NULL,
  device_id TEXT,
  temperature DOUBLE PRECISION
);

SELECT create_hypertable('metrics', 'time');

SELECT time_bucket('1 hour', time) AS hour,
       AVG(temperature)
FROM metrics
WHERE time > NOW() - INTERVAL '24 hours'
GROUP BY hour;

Automação de ciclo de vida

SELECT add_retention_policy('metrics', INTERVAL '30 days');

ALTER TABLE metrics SET (timescaledb.compress);
SELECT add_compression_policy('metrics', INTERVAL '7 days');

Estudo de caso: Plexigrid reduziu de 4 bancos para 1 e obteve consultas 350x mais rápidas.

5. Cache (Substitui Redis para cenários simples)

Recurso nativo: Tabelas UNLOGGED + JSONB

Substitui: Redis em cenários de cache chave‑valor simples.

Ganhos: Armazenamento em memória sem overhead de WAL, transacional, sem serviço separado.

Quando manter Redis: Pub/sub, sorted sets, scripts Lua ou estruturas complexas ainda pedem Redis.

CREATE UNLOGGED TABLE cache (
  key TEXT PRIMARY KEY,
  value JSONB,
  expires_at TIMESTAMPTZ
);

INSERT INTO cache (key, value, expires_at)
VALUES ('user:123', '{"name": "Alice"}', NOW() + INTERVAL '1 hour')
ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value;

SELECT value FROM cache
WHERE key = 'user:123' AND expires_at > NOW();

SELECT cron.schedule('cache_cleanup', '0 * * * *',
  $$DELETE FROM cache WHERE expires_at < NOW()$$);

6. Filas de Mensagens (Substitui Kafka/RabbitMQ para tarefas)

Extensão: pgmq

Substitui: Kafka ou RabbitMQ em filas de tarefas e eventos simples.

Ganhos: Fila leve dentro do Postgres, com timeout de visibilidade e remoção pós‑processamento, tudo transacional.

Quando manter Kafka: Streaming de alta vazão, grupos de consumidores, semântica exactly‑once, replicação multi‑datacenter.

CREATE EXTENSION pgmq;
SELECT pgmq.create('my_queue');

SELECT pgmq.send('my_queue', '{"event": "signup", "user_id": 123}');

SELECT * FROM pgmq.read('my_queue', 30, 5);

SELECT pgmq.delete('my_queue', msg_id);

Alternativa nativa: SKIP LOCKED

CREATE TABLE jobs (
  id SERIAL PRIMARY KEY,
  payload JSONB,
  status TEXT DEFAULT 'pending'
);

UPDATE jobs SET status = 'processing'
WHERE id = (
  SELECT id FROM jobs WHERE status = 'pending'
  FOR UPDATE SKIP LOCKED LIMIT 1
) RETURNING *;

7. Documentos (Substitui MongoDB)

Recurso nativo: JSONB (desde 2014)

Substitui: MongoDB para armazenamento de documentos.

Ganhos: Sem esquema, indexação GIN, ACID, JOINs relacionais e SQL. Sem banco separado para dados “document-shaped”.

CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  data JSONB
);

INSERT INTO users (data) VALUES ('{
  "name": "Alice",
  "profile": {"bio": "Developer", "links": ["github.com/alice"]}
}');

SELECT data->>'name', data->'profile'->>'bio'
FROM users
WHERE data->'profile'->>'bio' LIKE '%Developer%';

CREATE INDEX idx_users_email ON users ((data->>'email'));

8. Geoespacial (Substitui GIS Especializado)

Extensão: PostGIS (padrão da indústria desde 2001)

Substitui: Praticamente nada – o PostGIS é a fundação de muitas ferramentas GIS, incluindo OpenStreetMap. 24 anos em produção.

CREATE EXTENSION postgis;

CREATE TABLE stores (
  id SERIAL PRIMARY KEY,
  name TEXT,
  location GEOGRAPHY(POINT, 4326)
);

SELECT name,
  ST_Distance(location, ST_MakePoint(-122.4, 37.78)::geography) AS meters
FROM stores
WHERE ST_DWithin(location, ST_MakePoint(-122.4, 37.78)::geography, 5000);

9. Tarefas Agendadas (Substitui Cron Externo)

Extensão: pg_cron

Substitui: Cron jobs do SO, Kubernetes CronJobs, Lambda agendado.

Ganhos: Agendamento dentro do banco, ideal para manutenção: limpeza de cache, refresh de views materializadas, retenção.

CREATE EXTENSION pg_cron;

SELECT cron.schedule('cleanup', '0 * * * *',
  $$DELETE FROM cache WHERE expires_at < NOW()$$);

SELECT cron.schedule('rollup', '0 2 * * *',
  $$REFRESH MATERIALIZED VIEW CONCURRENTLY daily_stats$$);

10. Busca Fuzzy (Tolerância a Erros de Digitação)

Extensão: pg_trgm (nativa do Postgres)

CREATE EXTENSION pg_trgm;

CREATE INDEX idx_name_trgm ON products USING GIN (name gin_trgm_ops);

SELECT name FROM products
WHERE name % 'posgresql'
ORDER BY similarity(name, 'posgresql') DESC;

Conclusão: Um Banco, Múltiplas Personalidades

Como vimos, a promessa do PostgreSQL em 2026 é entregar consolidação sem concessões. Adicionando extensões robustas como pgvector, timescaledb e pg_textsearch, você elimina a complexidade absurda de manter sete sistemas diferentes rodando ao mesmo tempo.

Obviamente, ferramentas hiper-especializadas como Kafka ou Elasticsearch ainda têm o seu lugar em cenários de nicho e escala extrema. Mas para 95% das aplicações modernas, centralizar tudo no Postgres entrega uma performance brutal, reduz pontos de falha na sua rede e libera o seu time de engenharia para focar no que realmente importa: criar novas features.

Próximos passos recomendados: Não tente migrar toda a sua infraestrutura de uma vez. Comece movendo a carga de trabalho mais isolada da sua aplicação (como a busca textual ou o agendamento de tarefas com pg_cron). Monitore os recursos e sinta a estabilidade do sistema.