Guia de início rápido para Managed Postgres

Experimente o desempenho do Postgres com tecnologia NVMe e adicione analytics em tempo real com integração nativa com o ClickHouse

O ClickHouse Managed Postgres é um Postgres de nível empresarial com armazenamento NVMe, oferecendo desempenho até 10x mais rápido para workloads disk-bound em comparação com armazenamento conectado à rede, como o EBS. Este quickstart está dividido em duas partes:

• Parte 1: Comece a usar o NVMe Postgres e experimente seu desempenho
• Parte 2: Tenha analytics em tempo real integrando com o ClickHouse

O Managed Postgres está disponível atualmente na AWS em diversas regiões e está em public beta.

Neste guia de início rápido, você irá:

• Crie uma instância do Managed Postgres com desempenho proporcionado pelo NVMe
• Carregue 1 milhão de eventos de exemplo e veja a velocidade do NVMe em ação
• Execute consultas e experimente um desempenho com baixa latência
• Replique dados para o ClickHouse para analytics em tempo real
• Consulte o ClickHouse diretamente do Postgres usando pg_clickhouse

​

Parte 1: Primeiros passos com NVMe Postgres

​

Criar um banco de dados

Para criar um novo serviço Managed Postgres, clique no botão New service na lista de serviços do Cloud Console. Em seguida, você poderá selecionar Postgres como o tipo de banco de dados.

Insira um nome para sua instância de banco de dados e clique em Create service. Você será direcionado para a página de visão geral.

Sua instância do Managed Postgres será provisionada e estará pronta para uso em 3 a 5 minutos.

​

Conecte-se ao seu banco de dados

Na barra lateral à esquerda, você verá um botão Connect. Clique nele para visualizar os detalhes de conexão e as connection strings em múltiplos formatos.

Copie a connection string do psql e conecte-se ao seu banco de dados. Você também pode usar qualquer client compatível com Postgres, como o DBeaver, ou qualquer biblioteca de aplicação.

​

Experimente o desempenho com NVMe

Vamos ver na prática o desempenho proporcionado pelo NVMe. Primeiro, ative a temporização no psql para medir a execução da consulta:

\timing

Crie duas tabelas de exemplo para eventos e usuários:

CREATE TABLE events (
   event_id SERIAL PRIMARY KEY,
   event_name VARCHAR(255) NOT NULL,
   event_type VARCHAR(100),
   event_timestamp TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
   event_data JSONB,
   user_id INT,
   user_ip INET,
   is_active BOOLEAN DEFAULT TRUE,
   created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
   updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE users (
   user_id SERIAL PRIMARY KEY,
   name VARCHAR(100),
   country VARCHAR(50),
   platform VARCHAR(50)
);

Agora, insira 1 milhão de eventos e veja a velocidade do NVMe:

INSERT INTO events (event_name, event_type, event_timestamp, event_data, user_id, user_ip)
SELECT
   'Event ' || gs::text AS event_name,
   CASE
       WHEN random() < 0.5 THEN 'click'
       WHEN random() < 0.75 THEN 'view'
       WHEN random() < 0.9 THEN 'purchase'
       WHEN random() < 0.98 THEN 'signup'
       ELSE 'logout'
   END AS event_type,
   NOW() - INTERVAL '1 day' * (gs % 365) AS event_timestamp,
   jsonb_build_object('key', 'value' || gs::text, 'additional_info', 'info_' || (gs % 100)::text) AS event_data,
   GREATEST(1, LEAST(1000, FLOOR(POWER(random(), 2) * 1000) + 1)) AS user_id,
   ('192.168.1.' || ((gs % 254) + 1))::inet AS user_ip
FROM
   generate_series(1, 1000000) gs;

INSERT 0 1000000
Time: 3596.542 ms (00:03.597)

Desempenho do NVMe

1 milhão de linhas com dados JSONB inseridas em menos de 4 segundos. Em bancos de dados em nuvem tradicionais que usam armazenamento conectado à rede, como EBS, essa mesma operação normalmente leva de 2 a 3 vezes mais tempo devido à latência de ida e volta da rede e à limitação de IOPS. O armazenamento NVMe elimina esses gargalos ao manter o armazenamento fisicamente conectado ao compute.

O desempenho varia de acordo com o tamanho da instância, a carga atual e as características dos dados.

Insira 1.000 usuários:

INSERT INTO users (name, country, platform)
SELECT
    first_names[first_idx] || ' ' || last_names[last_idx] AS name,
    CASE
        WHEN random() < 0.25 THEN 'India'
        WHEN random() < 0.5 THEN 'USA'
        WHEN random() < 0.7 THEN 'Germany'
        WHEN random() < 0.85 THEN 'China'
        ELSE 'Other'
    END AS country,
    CASE
        WHEN random() < 0.2 THEN 'iOS'
        WHEN random() < 0.4 THEN 'Android'
        WHEN random() < 0.6 THEN 'Web'
        WHEN random() < 0.75 THEN 'Windows'
        WHEN random() < 0.9 THEN 'MacOS'
        ELSE 'Linux'
    END AS platform
FROM
    generate_series(1, 1000) AS seq
    CROSS JOIN LATERAL (
        SELECT
            array['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank', 'Grace', 'Hank', 'Ivy', 'Jack', 'Liam', 'Olivia', 'Noah', 'Emma', 'Sophia', 'Benjamin', 'Isabella', 'Lucas', 'Mia', 'Amelia', 'Aarav', 'Riya', 'Arjun', 'Ananya', 'Wei', 'Li', 'Huan', 'Mei', 'Hans', 'Klaus', 'Greta', 'Sofia'] AS first_names,
            array['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis', 'Martinez', 'Taylor', 'Anderson', 'Thomas', 'Jackson', 'White', 'Harris', 'Martin', 'Thompson', 'Moore', 'Lee', 'Perez', 'Sharma', 'Patel', 'Gupta', 'Reddy', 'Zhang', 'Wang', 'Chen', 'Liu', 'Schmidt', 'Müller', 'Weber', 'Fischer'] AS last_names,
            1 + (seq % 32) AS first_idx,
            1 + ((seq / 32)::int % 32) AS last_idx
    ) AS names;

​

Execute consultas nos seus dados

Agora vamos executar algumas consultas para ver com que rapidez o Postgres responde com armazenamento NVMe.

Agregue 1 milhão de eventos por tipo:

SELECT event_type, COUNT(*) as count 
FROM events 
GROUP BY event_type 
ORDER BY count DESC;

 event_type | count  
------------+--------
 click      | 499523
 view       | 375644
 purchase   | 112473
 signup     |  12117
 logout     |    243
(5 rows)

Time: 114.883 ms

Consulta com filtragem JSONB e intervalo de datas:

SELECT COUNT(*) 
FROM events 
WHERE event_timestamp > NOW() - INTERVAL '30 days'
  AND event_data->>'additional_info' LIKE 'info_5%';

 count 
-------
  9042
(1 row)

Time: 109.294 ms

Faça join de eventos com usuários:

SELECT u.country, COUNT(*) as events, AVG(LENGTH(e.event_data::text))::int as avg_json_size
FROM events e
JOIN users u ON e.user_id = u.user_id
GROUP BY u.country
ORDER BY events DESC;

 country | events | avg_json_size 
---------+--------+---------------
 USA     | 383748 |            52
 India   | 255990 |            52
 Germany | 223781 |            52
 China   | 127754 |            52
 Other   |   8727 |            52
(5 rows)

Time: 224.670 ms

Seu Postgres está pronto

Neste ponto, você já tem um banco de dados Postgres totalmente funcional e de alto desempenho, pronto para executar suas cargas de trabalho transacionais.

Continue para a Parte 2 para ver como a integração nativa do ClickHouse pode turbinar seu analytics.

---

​

Parte 2: Adicione analytics em tempo real com ClickHouse

Enquanto o Postgres se destaca em cargas de trabalho transacionais (OLTP), o ClickHouse foi desenvolvido especificamente para consultas analíticas (OLAP) em grandes conjuntos de dados. Ao integrar os dois, você obtém o melhor dos dois mundos:

• Postgres para os dados transacionais da sua aplicação (inserções, atualizações, buscas pontuais)
• ClickHouse para analytics em menos de um segundo em bilhões de linhas

Esta seção mostra como replicar seus dados do Postgres para o ClickHouse e consultá-los de forma integrada.

​

Setup da integração com o ClickHouse

Agora que temos tabelas e dados no Postgres, vamos replicar as tabelas para o ClickHouse para analytics. Começamos clicando em ClickHouse integration na barra lateral. Em seguida, clique em Replicate data in ClickHouse.

No formulário a seguir, você pode inserir um nome para sua integração e selecionar uma instância do ClickHouse existente para replicar os dados. Se você ainda não tiver uma instância do ClickHouse, poderá criar uma diretamente neste formulário.

Importante

Certifique-se de que o serviço do ClickHouse selecionado esteja com o status Running antes de prosseguir.

Clique em Next para ser direcionado ao seletor de tabelas. Aqui, tudo o que você precisa fazer é:

• Selecione um banco de dados do ClickHouse para o qual replicar.
• Expanda o schema public e selecione as tabelas users e events que criamos anteriormente.
• Clique em Replicar dados no ClickHouse.

O processo de replicação será iniciado e você será redirecionado para a página de visão geral da integração. Por ser a primeira integração, pode levar de 2 a 3 minutos para configurar a infraestrutura inicial. Enquanto isso, vamos conhecer a nova extensão pg_clickhouse.

​

Consulte o ClickHouse a partir do Postgres

A extensão pg_clickhouse permite consultar dados do ClickHouse diretamente do Postgres usando SQL padrão. Isso significa que sua aplicação pode usar o Postgres como uma camada de consulta unificada para dados transacionais e analíticos. Consulte a documentação completa para mais detalhes.

Ative a extensão:

CREATE EXTENSION pg_clickhouse;

Em seguida, crie uma conexão de foreign server para o ClickHouse. Use o driver http com a porta 8443 para conexões seguras:

CREATE SERVER ch FOREIGN DATA WRAPPER clickhouse_fdw
       OPTIONS(driver 'http', host '<clickhouse_cloud_host>', dbname '<database_name>', port '8443');

Substitua <clickhouse_cloud_host> pelo hostname do seu ClickHouse e <database_name> pelo banco de dados selecionado durante a configuração da replicação. Você pode encontrar o hostname no seu serviço do ClickHouse clicando em Connect na barra lateral.

Agora, mapeamos o usuário do Postgres para as credenciais do serviço ClickHouse:

CREATE USER MAPPING FOR CURRENT_USER SERVER ch 
OPTIONS (user 'default', password '<clickhouse_password>');

Agora importe as tabelas do ClickHouse para um schema do Postgres:

CREATE SCHEMA organization;
IMPORT FOREIGN SCHEMA "<database_name>" FROM SERVER ch INTO organization;

Substitua <database_name> pelo mesmo nome do banco de dados que você usou ao criar o servidor.

Agora você pode ver todas as tabelas do ClickHouse no seu cliente Postgres:

\det+ organization.*

​

Veja seu analytics em ação

Volte à página de integração. Você verá que a replicação inicial foi concluída. Clique no nome da integração para ver os detalhes.

Clique no nome do serviço para abrir o console do ClickHouse e visualizar suas tabelas replicadas.

​

Compare o desempenho do Postgres vs ClickHouse

Agora vamos executar algumas consultas analíticas e comparar o desempenho entre o Postgres e o ClickHouse. Observe que as tabelas replicadas utilizam a convenção de nomenclatura public_<table_name>.

Consulta 1: Usuários mais ativos

Esta consulta encontra os usuários mais ativos com múltiplas agregações:

-- Via ClickHouse
SELECT 
    user_id,
    COUNT(*) as total_events,
    COUNT(DISTINCT event_type) as unique_event_types,
    SUM(CASE WHEN event_type = 'purchase' THEN 1 ELSE 0 END) as purchases,
    MIN(event_timestamp) as first_event,
    MAX(event_timestamp) as last_event
FROM organization.public_events
GROUP BY user_id
ORDER BY total_events DESC
LIMIT 10;

 user_id | total_events | unique_event_types | purchases |        first_event         |         last_event         
---------+--------------+--------------------+-----------+----------------------------+----------------------------
       1 |        31439 |                  5 |      3551 | 2025-01-22 22:40:45.612281 | 2026-01-21 22:40:45.612281
       2 |        13235 |                  4 |      1492 | 2025-01-22 22:40:45.612281 | 2026-01-21 22:40:45.612281
...
(10 rows)

Time: 163.898 ms   -- ClickHouse
Time: 554.621 ms   -- Same query on Postgres

Consulta 2: Engajamento de usuários por país e plataforma

Esta consulta realiza junções entre eventos e usuários e calcula métricas de engajamento:

-- Via ClickHouse
SELECT 
    u.country,
    u.platform,
    COUNT(DISTINCT e.user_id) as users,
    COUNT(*) as total_events,
    ROUND(COUNT(*)::numeric / COUNT(DISTINCT e.user_id), 2) as events_per_user,
    SUM(CASE WHEN e.event_type = 'purchase' THEN 1 ELSE 0 END) as purchases
FROM organization.public_events e
JOIN organization.public_users u ON e.user_id = u.user_id
GROUP BY u.country, u.platform
ORDER BY total_events DESC
LIMIT 10;

 country | platform | users | total_events | events_per_user | purchases 
---------+----------+-------+--------------+-----------------+-----------
 USA     | Android  |   115 |       109977 |             956 |     12388
 USA     | Web      |   108 |       105057 |             972 |     11847
 USA     | iOS      |    83 |        84594 |            1019 |      9565
 Germany | Android  |    85 |        77966 |             917 |      8852
 India   | Android  |    80 |        68095 |             851 |      7724
...
(10 rows)

Time: 170.353 ms   -- ClickHouse
Time: 1245.560 ms  -- Same query on Postgres

Comparação de desempenho:

Consulta	Postgres (NVMe)	ClickHouse (via pg_clickhouse)	Ganho
Principais usuários (5 agregações)	555 ms	164 ms	3,4x
Engajamento do usuário (JOIN + agregações)	1.246 ms	170 ms	7,3x

Quando usar o ClickHouse

Mesmo neste conjunto de dados com 1 milhão de linhas, o ClickHouse oferece desempenho 3 a 7 vezes superior em consultas analíticas complexas com junções e múltiplas agregações. A diferença se torna ainda mais expressiva em escalas maiores (100M+ linhas), nas quais o armazenamento colunar e a execução vetorizada do ClickHouse podem proporcionar acelerações de 10 a 100 vezes.

Os tempos de consulta variam de acordo com o tamanho da instância, a latência de rede entre os serviços, as características dos dados e a carga atual.

​

Limpeza

Para excluir os recursos criados neste quickstart:

1. Primeiro, exclua a integração ClickPipe do serviço ClickHouse
2. Em seguida, exclua a instância do Managed Postgres no Cloud Console