Guía de inicio rápido de ClickHouse Managed Postgres

Beta

ClickHouse Managed Postgres es un servicio Postgres de nivel empresarial respaldado por almacenamiento NVMe, que ofrece un rendimiento hasta 10 veces más rápido para cargas de trabajo limitadas por disco en comparación con el almacenamiento en red como EBS. Esta guía de inicio rápido se divide en dos partes:

Parte 1: Comienza a usar NVMe Postgres y comprueba su rendimiento
Parte 2: Desbloquea la analítica en tiempo real integrándolo con ClickHouse

ClickHouse Managed Postgres está disponible actualmente en AWS en varias regiones y se encuentra en public beta.

En esta guía de inicio rápido, harás lo siguiente:

Crea una instancia de ClickHouse Managed Postgres con el rendimiento de NVMe
Carga 1 millón de eventos de muestra y comprueba la velocidad de NVMe
Ejecuta consultas y experimenta un rendimiento de baja latencia
Replica los datos en ClickHouse para analítica en tiempo real
Consulta ClickHouse directamente desde Postgres usando pg_clickhouse

Parte 1: Primeros pasos con NVMe Postgres

Crear una base de datos

Para crear un nuevo servicio ClickHouse Managed Postgres, haz clic en el botón New service en la lista de servicios de la Cloud Console. A continuación, podrás seleccionar Postgres como tipo de base de datos.

Crear un servicio de ClickHouse Managed Postgres

Introduce un nombre para tu instancia de base de datos y haz clic en Create service. Serás redirigido a la página de descripción general.

Tu instancia de ClickHouse Managed Postgres estará aprovisionada y lista para usar en 3-5 minutos.

Conectar a tu base de datos

En la barra lateral izquierda, verás un botón Conectar. Haz clic en él para ver los detalles de conexión y las cadenas de conexión en varios formatos.

Modal Conectar de ClickHouse Managed Postgres

Copia la cadena de conexión de psql y conéctate a tu base de datos. También puedes usar cualquier client compatible con Postgres, como DBeaver, o cualquier biblioteca de aplicación.

Comprueba el rendimiento de NVMe

Veamos el rendimiento de NVMe en acción. Primero, habilita la medición de tiempo en psql para medir la ejecución de consultas:

Cree dos tablas de muestra para eventos y usuarios:

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

Ahora, inserta 1 millón de eventos y comprueba la velocidad de 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)

Inserta 1.000 usuarios:

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;

Ejecuta consultas sobre tus datos

Ahora ejecutemos algunas consultas para ver con qué rapidez responde Postgres con almacenamiento NVMe.

Agregación de 1 millón 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 con filtrado JSONB y rango de fechas:

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

Unir eventos con usuarios:

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: Añade analítica en tiempo real con ClickHouse

Mientras que Postgres destaca en cargas de trabajo transaccionales (OLTP), ClickHouse está diseñado específicamente para consultas analíticas (OLAP) sobre grandes conjuntos de datos. Al integrar ambos, se obtiene lo mejor de los dos mundos:

Postgres para los datos transaccionales de tu aplicación (inserciones, actualizaciones, consultas puntuales por clave)
ClickHouse para analítica en menos de un segundo sobre miles de millones de filas

Esta sección muestra cómo replicar los datos de Postgres en ClickHouse y consultarlos sin interrupciones.

Configurar la integración con ClickHouse

Ahora que tenemos tablas y datos en Postgres, vamos a replicar las tablas en ClickHouse para analítica. Comenzamos haciendo clic en Sync to ClickHouse en la barra lateral. Luego puedes hacer clic en Replicate data in ClickHouse.

Integración vacía de ClickHouse Managed Postgres

En el formulario que aparece a continuación, puedes introducir un nombre para tu integración y seleccionar una instancia de ClickHouse existente a la que replicar los datos. Si aún no tienes una instancia de ClickHouse, puedes crear una directamente desde este formulario.

Formulario de integración de ClickHouse Managed Postgres

Haz clic en Siguiente para acceder al selector de tablas. Aquí solo tienes que:

Selecciona una base de datos de ClickHouse en la que replicar.
Expande el esquema public y selecciona las tablas users y events que creamos anteriormente.
Haz clic en Replicate data to ClickHouse.

selector de tablas de ClickHouse Managed Postgres

El proceso de replicación comenzará y serás redirigido a la página de resumen de la integración. Al ser la primera integración, puede tardar entre 2 y 3 minutos en configurar la infraestructura inicial. Mientras tanto, exploremos la nueva extensión pg_clickhouse.

Consulta ClickHouse desde Postgres

La extensión pg_clickhouse te permite consultar datos de ClickHouse directamente desde Postgres usando SQL estándar. Esto significa que tu aplicación puede usar Postgres como una capa de consulta unificada tanto para datos transaccionales como analíticos. Consulta la documentación completa para más detalles.

Habilita la extensión:

CREATE EXTENSION pg_clickhouse;

A continuación, crea una conexión de servidor externo a ClickHouse. Usa el driver http con el puerto 8443 para conexiones seguras:

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

Reemplaza <clickhouse_cloud_host> con el hostname de tu ClickHouse y <database_name> con la base de datos que seleccionaste durante la configuración de la replicación. Puedes encontrar el hostname en tu servicio de ClickHouse haciendo clic en Connect en la barra lateral.

Ahora, asignamos el usuario de Postgres a las credenciales del servicio de ClickHouse:

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

Ahora importa las tablas de ClickHouse en un esquema de Postgres:

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

Reemplaza <database_name> con el mismo nombre de base de datos que usaste al crear el servidor.

Ahora puedes ver todas las tablas de ClickHouse en tu cliente de Postgres:

Ve tu analítica en acción

Vuelve a la página de integración. Deberías ver que la replicación inicial ha finalizado. Haz clic en el nombre de la integración para ver los detalles.

Lista de analítica de ClickHouse Managed Postgres

Haz clic en el nombre del servicio para abrir la consola de ClickHouse y ver tus tablas replicadas.

Tablas replicadas de ClickHouse Managed Postgres en ClickHouse

Comparación del rendimiento de Postgres vs ClickHouse

Ahora ejecutemos algunas consultas analíticas y comparemos el rendimiento entre Postgres y ClickHouse. Ten en cuenta que las tablas replicadas utilizan la convención de nomenclatura public_<table_name>.

Consulta 1: Usuarios más activos

Esta consulta encuentra los usuarios más activos con múltiples agregaciones:

-- 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: Participación de usuarios por país y plataforma

Esta consulta combina eventos con usuarios y calcula métricas de participación:

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

Comparación de rendimiento:

Consulta	Postgres (NVMe)	ClickHouse (via pg_clickhouse)	Aumento de velocidad
Usuarios principales (5 agregaciones)	555 ms	164 ms	3.4x
Interacción de los usuarios (JOIN + agregaciones)	1,246 ms	170 ms	7.3x

Limpieza

Para eliminar los recursos creados en esta guía de inicio rápido:

Primero, elimina la integración de ClickPipe del servicio de ClickHouse
Luego, elimina la instancia de ClickHouse Managed Postgres en la Cloud Console

Beta

Puedes seguir este camino tú mismo, automatizarlo con un script o entregárselo a un agente de IA. Cambia a la vista de Cloud UI para ver la versión de la consola.

En esta página se explica el aprovisionamiento de ClickHouse Managed Postgres, la carga de datos, su replicación a ClickHouse y la ejecución de consultas, todo desde la línea de comandos con la ClickHouse CLI (clickhousectl) y psql. Los comandos no son interactivos; clickhousectl genera JSON con --json.

Requisitos previos

Instala ClickHouse CLI:

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

También necesitas psql (herramientas del client de PostgreSQL; en MacOS, brew install libpq) y jq.

Las operaciones de escritura (crear, eliminar) requieren autenticación mediante API key; el inicio de sesión con OAuth es de solo lectura:

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

Como alternativa, configura las variables de entorno CLICKHOUSE_CLOUD_API_KEY y CLICKHOUSE_CLOUD_API_SECRET. Verifica con clickhousectl cloud auth status; debería aparecer una entrada con el alcance read/write.

Parte 1: Crear Postgres y cargar datos

Crear un servicio de Postgres

Cree el servicio y guarde la respuesta; la contraseña se muestra solo una vez:

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

La respuesta incluye el ID del servicio, el nombre de host y una cadena de conexión lista para usar:

{
  "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": []
}

Extrae lo necesario para el resto de esta guía:

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

Si pierdes la contraseña, genera una nueva con clickhousectl cloud postgres reset-password $PG_ID --generate.

Espera a que finalice el aprovisionamiento del servicio

El aprovisionamiento tarda unos minutos. Consulta periódicamente hasta que el estado sea running:

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

Cargar datos de muestra

Cree dos tablas e inserte 1 millón de eventos con 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

La inserción de 1 millón de filas se completa en unos 7 segundos en m6gd.large (el tamaño más pequeño) gracias al almacenamiento NVMe. Compruébelo con una consulta; el número de filas varía entre ejecuciones porque los datos se generan con random():

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

Parte 2: Replicar en ClickHouse

Crear un servicio de ClickHouse

Cree un servicio en la misma región y guarde la respuesta; la contraseña solo aparece en la respuesta de creación:

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)

Espere hasta que esté en ejecución; ClickPipe requiere que el destino esté en ejecución:

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

Para usar un servicio existente, configure CH_ID con el valor de clickhousectl cloud service list y CH_PASSWORD con la contraseña del usuario default, que necesita el paso pg_clickhouse.

Replicar las tablas en ClickHouse

Cree un Postgres CDC ClickPipe en el servicio de ClickHouse que apunte al nombre de host de ClickHouse Managed Postgres. El pipe copia las filas existentes y luego mantiene ClickHouse sincronizado con los cambios posteriores:

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:

Las tablas replicadas quedan en la base de datos default del servicio de ClickHouse, con los nombres definidos por los destinos de --table-mapping
La publication y el replication slot se crean automáticamente, y la publication se limita a las tablas mapeadas; pasa --publication-name para usar una que administres tú mismo
Usa el nombre de host directo de Postgres; la replicación no es compatible a través de PgBouncer

Espera a que el pipe llegue a Running

El pipe pasa por Provisioning, Setup y, en el caso de tablas más grandes, Snapshot antes de llegar a Running, lo que suele tardar unos 4 minutos en el caso del primer pipe de un servicio. Failed e InternalError son estados terminales:

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

Consultar los datos replicados en ClickHouse

Ejecuta consultas SQL directamente desde la CLI en el servicio de ClickHouse. La primera llamada aprovisiona automáticamente un endpoint de Query API y una API key con alcance específico para el servicio:

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

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

Las nuevas operaciones de escritura en Postgres se replican de forma continua. Inserte una fila y consulte repetidamente hasta que el recuento alcance 1.000.001 (normalmente, en menos de un 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 ClickHouse desde Postgres

La extensión pg_clickhouse permite que Postgres actúe como una capa de consulta unificada para datos transaccionales y analíticos. Obtén el nombre de host HTTPS de ClickHouse y, a continuación, configura la extensión con 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

El heredoc se deja sin comillas a propósito, para que el shell sustituya $CH_HOST y $CH_PASSWORD antes de que el SQL llegue a Postgres. Las tablas replicadas ahora aparecen como tablas externas en el esquema organization; las consultas contra ellas se ejecutan en ClickHouse.

Medido en m6gd.large con este conjunto de datos, las consultas analíticas se ejecutan entre 6 y 9 veces más rápido mediante las tablas externas (por ejemplo, un GROUP BY de 5 agregaciones: 176 ms vía ClickHouse frente a 1.133 ms localmente; un JOIN con agregaciones: 298 ms frente a 2.764 ms).

Limpieza

Elimina primero el ClickPipe y luego el servicio de Postgres. Al eliminar un servicio, todos sus datos se borran de forma permanente:

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

No se puede eliminar directamente un servicio de ClickHouse en ejecución. Deténgalo, espere a que aparezca como stopped y luego elimínelo:

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"