Guia de início rápido para ClickHouse Managed Postgres

Beta

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 ClickHouse Managed Postgres está disponível atualmente na AWS em diversas regiões e está em public beta.

Neste guia 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 ClickHouse 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.

Criar um serviço Managed Postgres do ClickHouse

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.

Visão geral do ClickHouse Managed Postgres

Sua instância do ClickHouse 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 Conectar. Clique nele para visualizar os detalhes de conexão e as cadeias de conexão em vários 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:

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)

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

Parte 2: Adicione análises 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.

Configurar a 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 Sync to ClickHouse na barra lateral. Em seguida, clique em Replicate data in ClickHouse.

Integração vazia do ClickHouse Managed Postgres

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.

Formulário de integração do ClickHouse Managed Postgres

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.

Seletor de tabelas do ClickHouse Managed Postgres

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 unificada de consulta 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.

Note

Se você estiver usando o console do ClickHouse Cloud para executar SQL, conceda ao usuário administrador do console acesso ao foreign server:

GRANT USAGE ON FOREIGN SERVER ch TO chpg_console_admin;

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:

Veja suas análises 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.

Lista de analytics do ClickHouse Managed Postgres

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

Tabelas replicadas do ClickHouse Managed Postgres no ClickHouse

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

Limpeza

Para excluir os recursos criados neste quickstart:

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

Beta

Você pode seguir este caminho por conta própria, automatizá-lo com um script ou entregá-lo a um agente de IA. Alterne para a visualização Cloud UI para ver a versão no console.

Esta página aborda o provisionamento do ClickHouse Managed Postgres, o carregamento de dados, a replicação para o ClickHouse e a execução de consultas, tudo pela linha de comando com a ClickHouse CLI (clickhousectl) e psql. Os comandos são não interativos; o clickhousectl gera JSON com --json.

Pré-requisitos

Instale a ClickHouse CLI:

curl https://clickhouse.com/cli | sh

Você também precisa do psql (ferramentas do cliente PostgreSQL; no macOS, brew install libpq) e do jq.

Operações de escrita (criação, exclusão) exigem autenticação por chave de API; o login via OAuth é somente leitura:

clickhousectl cloud auth login --api-key <YOUR_KEY> --api-secret <YOUR_SECRET>

Como alternativa, defina as variáveis de ambiente CLICKHOUSE_CLOUD_API_KEY e CLICKHOUSE_CLOUD_API_SECRET. Verifique com clickhousectl cloud auth status; deve haver uma entrada com escopo read/write.

Parte 1: Criar o Postgres e carregar os dados

Criar um serviço Postgres

Crie o serviço e salve a resposta; a senha é exibida apenas uma vez:

clickhousectl cloud postgres create \
  --name quickstart-pg \
  --region us-east-1 \
  --size m6gd.large \
  --pg-version 18 \
  --json > pg.json

A resposta inclui o ID do serviço, o hostname e uma string de conexão pronta para uso:

{
  "id": "3b5a3112-bf02-82d0-bd02-fbe67d5caa7a",
  "name": "quickstart-pg",
  "provider": "aws",
  "region": "us-east-1",
  "postgresVersion": "18",
  "size": "m6gd.large",
  "storageSize": 118,
  "haType": "none",
  "state": "creating",
  "createdAt": "2026-07-22T13:21:22Z",
  "hostname": "quickstart-pg-c1406b50.pg7dd324nz0a1qm1fqskxbjn7m.c0.us-east-1.aws.pg.clickhouse.cloud",
  "username": "postgres",
  "password": "vV6cfEr2p_-TzkCDrZOx",
  "connectionString": "postgres://postgres:vV6cfEr2p_-TzkCDrZOx@quickstart-pg-c1406b50.pg7dd324nz0a1qm1fqskxbjn7m.c0.us-east-1.aws.pg.clickhouse.cloud:5432/postgres?channel_binding=require",
  "isPrimary": true,
  "tags": []
}

Extraia o que será necessário para o restante deste guia:

PG_ID=$(jq -r .id pg.json)
PG_URL=$(jq -r .connectionString pg.json)

Se a senha for perdida, gere uma nova com clickhousectl cloud postgres reset-password $PG_ID --generate.

Aguarde o provisionamento do serviço

O Provisioning leva alguns minutos. Verifique periodicamente até que o estado seja running:

while [ "$(clickhousectl cloud postgres get "$PG_ID" --json | jq -r .state)" != "running" ]; do
  sleep 15
done

Carregar dados de exemplo

Crie duas tabelas e insira 1 milhão de eventos usando o psql:

psql "$PG_URL" <<'SQL'
\timing
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)
);

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 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;
SQL

Timing is on.
CREATE TABLE
Time: 86.029 ms
CREATE TABLE
Time: 80.962 ms
INSERT 0 1000000
Time: 7120.357 ms (00:07.120)
INSERT 0 1000
Time: 84.807 ms

A inserção de 1 milhão de linhas leva cerca de 7 segundos no m6gd.large (a menor configuração), graças ao armazenamento NVMe. Verifique com uma consulta; a contagem de linhas varia entre as execuções porque os dados são gerados com random():

psql "$PG_URL" -c "SELECT event_type, COUNT(*) FROM events GROUP BY event_type ORDER BY 2 DESC;"

Parte 2: Replicar para o ClickHouse

Criar um serviço do ClickHouse

Crie um serviço na mesma região e salve a resposta; a senha aparece apenas na resposta de criação:

clickhousectl cloud service create \
  --name quickstart-ch \
  --region us-east-1 \
  --json > ch.json

CH_ID=$(jq -r .service.id ch.json)
CH_PASSWORD=$(jq -r .password ch.json)

Aguarde até que ele esteja em execução; o ClickPipe requer um destino em execução:

while [ "$(clickhousectl cloud service get "$CH_ID" --json | jq -r .state)" != "running" ]; do
  sleep 15
done

Para usar um serviço existente, defina CH_ID a partir de clickhousectl cloud service list e CH_PASSWORD como a senha do usuário default, que é necessária para a etapa pg_clickhouse.

Replique as tabelas para o ClickHouse

Crie um Postgres CDC ClickPipe no serviço do ClickHouse, apontando para o hostname do ClickHouse Managed Postgres. O pipe copia as linhas existentes e, em seguida, mantém o ClickHouse sincronizado com as alterações contínuas:

PG_HOST=$(jq -r .hostname pg.json)
PG_PASSWORD=$(jq -r .password pg.json)

clickhousectl cloud clickpipe create postgres "$CH_ID" \
  --name quickstart-sync \
  --host "$PG_HOST" \
  --pg-database postgres \
  --username postgres \
  --password "$PG_PASSWORD" \
  --table-mapping public.events:public_events \
  --table-mapping public.users:public_users \
  --json > pipe.json

PIPE_ID=$(jq -r .id pipe.json)

Notas:

As tabelas replicadas são gravadas no banco de dados default do serviço do ClickHouse, com os nomes definidos pelos destinos de --table-mapping
A publication e o replication slot são criados automaticamente, com a publication restrita às tabelas mapeadas; passe --publication-name para usar uma gerenciada por você
Use o hostname direto do Postgres; a replicação não é compatível com o PgBouncer

Aguarde o pipe atingir o status `Running`

O pipe passa por Provisioning, Setup e, no caso de tabelas maiores, Snapshot antes de atingir Running, o que leva cerca de 4 minutos para o primeiro pipe em um service. Failed e InternalError são estados terminais:

while :; do
  STATE=$(clickhousectl cloud clickpipe get "$CH_ID" "$PIPE_ID" --json | jq -r .state)
  case "$STATE" in
    Running) break ;;
    Failed|InternalError) echo "ClickPipe entered terminal state: $STATE" >&2; exit 1 ;;
  esac
  sleep 15
done

Consulte os dados replicados no ClickHouse

Execute SQL diretamente no serviço do ClickHouse pela CLI. A primeira chamada cria automaticamente um endpoint da Query API e uma chave de API com escopo no serviço:

clickhousectl cloud service query --id "$CH_ID" \
  --query "SELECT count() FROM public_events"

Provisioning Query API endpoint + key for service 'quickstart-ch'...
1000000

Novas gravações no Postgres são replicadas continuamente. Insira uma linha e faça consultas até que a contagem atinja 1,000,001 (normalmente em menos de um minuto):

psql "$PG_URL" -c "INSERT INTO events (event_name, event_type, user_id, user_ip) VALUES ('cdc-test', 'click', 42, '10.0.0.1');"

while [ "$(clickhousectl cloud service query --id "$CH_ID" \
  --query "SELECT count() FROM public_events")" != "1000001" ]; do
  sleep 10
done

Consultar o ClickHouse no Postgres

A extensão pg_clickhouse permite que o Postgres atue como uma camada unificada de consulta para dados transacionais e analíticos. Obtenha o hostname HTTPS do ClickHouse e, em seguida, configure a extensão usando o psql:

CH_HOST=$(clickhousectl cloud service get "$CH_ID" --json \
  | jq -r '.endpoints[] | select(.protocol=="https") | .host')

psql "$PG_URL" <<SQL
CREATE EXTENSION pg_clickhouse;
CREATE SERVER ch FOREIGN DATA WRAPPER clickhouse_fdw
       OPTIONS(driver 'http', host '$CH_HOST', dbname 'default', port '8443');
CREATE USER MAPPING FOR CURRENT_USER SERVER ch
       OPTIONS (user 'default', password '$CH_PASSWORD');
CREATE SCHEMA organization;
IMPORT FOREIGN SCHEMA "default" FROM SERVER ch INTO organization;
SQL

O heredoc está sem aspas de propósito, para que o shell substitua $CH_HOST e $CH_PASSWORD antes que o SQL chegue ao Postgres. As tabelas replicadas agora estão visíveis como tabelas estrangeiras no schema organization; as consultas sobre elas são executadas no ClickHouse.

Em testes no m6gd.large com este conjunto de dados, as consultas analíticas são executadas de 6 a 9 vezes mais rápido por meio das tabelas estrangeiras (por exemplo, um GROUP BY com 5 agregações: 176 ms via ClickHouse vs 1.133 ms localmente; um JOIN com agregações: 298 ms vs 2.764 ms).

Limpeza

Exclua primeiro o ClickPipe e depois o serviço Postgres. Ao excluir um serviço, todos os dados dele são removidos permanentemente:

clickhousectl cloud clickpipe delete "$CH_ID" "$PIPE_ID"
clickhousectl cloud postgres delete "$PG_ID"

Um serviço do ClickHouse em execução não pode ser excluído diretamente. Pare-o, aguarde até stopped e depois exclua:

clickhousectl cloud service stop "$CH_ID"

while [ "$(clickhousectl cloud service get "$CH_ID" --json | jq -r .state)" != "stopped" ]; do
  sleep 10
done

clickhousectl cloud service delete "$CH_ID"

Guia de início rápido para ClickHouse Managed Postgres

Parte 1: Primeiros passos com NVMe Postgres

Criar um banco de dados

Conecte-se ao seu banco de dados

Experimente o desempenho com NVMe

Execute consultas nos seus dados

Parte 2: Adicione análises em tempo real com ClickHouse

Configurar a integração com o ClickHouse

Consulte o ClickHouse a partir do Postgres

Veja suas análises em ação

Compare o desempenho do Postgres vs ClickHouse

Limpeza

Pré-requisitos

Parte 1: Criar o Postgres e carregar os dados

Criar um serviço Postgres

Aguarde o provisionamento do serviço

Carregar dados de exemplo

Parte 2: Replicar para o ClickHouse

Criar um serviço do ClickHouse

Replique as tabelas para o ClickHouse

Aguarde o pipe atingir o status Running

Consulte os dados replicados no ClickHouse

Consultar o ClickHouse no Postgres

Limpeza

Aguarde o pipe atingir o status `Running`