Guía de inicio rápido de Managed Postgres

Descubra el rendimiento de Postgres impulsado por NVMe y añada análisis en tiempo real con la integración nativa de ClickHouse

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

• Parte 1: Dé los primeros pasos con NVMe Postgres y compruebe su rendimiento
• Parte 2: Obtenga análisis en tiempo real integrándolo con ClickHouse

Managed Postgres está disponible actualmente en AWS en varias regiones y es gratuito durante la vista previa privada.

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

• Crear una instancia de Managed Postgres con el rendimiento de NVMe
• Cargar 1 millón de eventos de muestra y ver la velocidad de NVMe en acción
• Ejecutar consultas y experimentar un rendimiento de baja latencia
• Replicar datos en ClickHouse para obtener análisis en tiempo real
• Consultar ClickHouse directamente desde Postgres usando pg_clickhouse

​

Parte 1: Primeros pasos con NVMe Postgres

​

Crear una base de datos

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

Introduzca un nombre para su instancia de base de datos y haga clic en Create service. Se le llevará a la página Overview.

Su instancia de Managed Postgres se aprovisionará y estará lista para usarse en un plazo de 3 a 5 minutos.

​

Conéctate a tu base de datos

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

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

​

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:

\timing

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)

Rendimiento de NVMe

1 millón de filas con datos JSONB insertadas en menos de 4 segundos. En las bases de datos tradicionales en la nube que usan almacenamiento en red como EBS, esta misma operación suele tardar entre 2 y 3 veces más debido a la latencia de ida y vuelta de la red y a la limitación de IOPS. El almacenamiento NVMe elimina estos cuellos de botella al mantener el almacenamiento físicamente conectado al nodo de cómputo.

El rendimiento varía según el tamaño de la instancia, la carga actual y las características de los datos.

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;

​

Ejecutar consultas sobre tus datos

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

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

Une 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

Tu Postgres está listo

En este punto, ya tienes una base de datos Postgres totalmente funcional y de alto rendimiento, lista para tus cargas de trabajo transaccionales.

Continúa con la Parte 2 para ver cómo la integración nativa de ClickHouse puede potenciar tus análisis.

---

​

Parte 2: Añade análisis en tiempo real con ClickHouse

Aunque Postgres destaca en cargas de trabajo transaccionales (OLTP), ClickHouse está diseñado específicamente para consultas analíticas (OLAP) sobre grandes volúmenes de datos. Al integrar ambos, obtienes lo mejor de ambos mundos:

• Postgres para los datos transaccionales de tu aplicación (inserciones, actualizaciones, consultas puntuales)
• ClickHouse para análisis en menos de un segundo sobre miles de millones de filas

Esta sección te muestra cómo replicar tus datos de Postgres en ClickHouse y consultarlos sin inconvenientes.

​

Configurar ClickHouse integration

Ahora que ya tenemos tablas y datos en Postgres, vamos a replicar las tablas en ClickHouse para análisis. Para empezar, haz clic en ClickHouse integration en la barra lateral. Luego, puedes hacer clic en Replicate data in ClickHouse.

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

Importante

Asegúrate de que el servicio de ClickHouse que selecciones esté en estado Running antes de continuar.

Haz clic en Next para ir al selector de tablas. Aquí, solo tienes que hacer lo siguiente:

• Seleccionar una base de datos de ClickHouse en la que replicar los datos.
• Expandir el esquema public y seleccionar las tablas users y events que creamos antes.
• Hacer clic en Replicate data to ClickHouse.

Se iniciará el proceso de replicación y se te llevará a la página de resumen de la integración. Como se trata de la primera integración, la configuración de la infraestructura inicial puede tardar entre 2 y 3 minutos. Mientras tanto, veamos la nueva extensión pg_clickhouse.

​

Consultar ClickHouse desde Postgres

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

Habilita la extensión:

CREATE EXTENSION pg_clickhouse;

Luego, cree una conexión de servidor externo con ClickHouse. Use el controlador 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');

Reemplace <clickhouse_cloud_host> por el hostname de ClickHouse y <database_name> por la base de datos que seleccionó durante la configuración de la replicación. Puede encontrar el hostname en su 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 a un esquema de Postgres:

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

Sustituye <database_name> por el mismo nombre de la base de datos que usaste al crear el servidor.

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

\det+ organization.*

​

Vea sus analíticas en acción

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

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

​

Comparar el rendimiento de Postgres frente a ClickHouse

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

Consulta 1: Usuarios más activos

Esta consulta identifica a los usuarios más activos mediante múltiples agregaciones:

-- Mediante 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   -- La misma consulta en Postgres

Consulta 2: Interacción de los usuarios por país y plataforma

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

-- Vía 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  -- Misma consulta en Postgres

Comparación del rendimiento:

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

Cuándo usar ClickHouse

Incluso con este conjunto de datos de 1 millón de filas, ClickHouse ofrece un rendimiento entre 3 y 7 veces superior en consultas analíticas complejas con JOINs y múltiples agregaciones. La diferencia se acentúa aún más a mayor escala (100M+ filas), donde el almacenamiento columnar y la ejecución vectorizada de ClickHouse pueden ofrecer aceleraciones de entre 10 y 100 veces.

Los tiempos de consulta varían en función del tamaño de la instancia, la latencia de red entre servicios, las características de los datos y la carga actual.

​

Limpieza

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

1. Primero, elimine la integración de ClickPipe del servicio de ClickHouse
2. Luego, elimine la instancia de Managed Postgres en Cloud Console