> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Guía de inicio rápido de Managed Postgres
> Descubra el rendimiento de Postgres impulsado por NVMe y añada analítica en tiempo real con la integración nativa de ClickHouse
export const Image = ({img, alt, size}) => {
return
;
};
export const galaxyOnClick = eventName => () => {
try {
if (typeof window !== "undefined" && window.galaxy && eventName) {
window.galaxy.track(eventName, {
interaction: "click"
});
}
} catch (e) {}
};
export const BetaBadge = ({link, galaxyTrack, galaxyEvent}) => {
if (link) {
return
Beta
;
}
return ;
};
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 analítica 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 analítica 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**](/es/products/managed-postgres/connection). 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:
```sql theme={null}
\timing
```
Cree dos tablas de muestra para eventos y usuarios:
```sql theme={null}
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:
```sql theme={null}
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;
```
```text theme={null}
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:
```sql theme={null}
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:**
```sql theme={null}
SELECT event_type, COUNT(*) as count
FROM events
GROUP BY event_type
ORDER BY count DESC;
```
```text theme={null}
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:**
```sql theme={null}
SELECT COUNT(*)
FROM events
WHERE event_timestamp > NOW() - INTERVAL '30 days'
AND event_data->>'additional_info' LIKE 'info_5%';
```
```text theme={null}
count
-------
9042
(1 row)
Time: 109.294 ms
```
**Une eventos con usuarios:**
```sql theme={null}
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;
```
```text theme={null}
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](/es/products/managed-postgres/extensions/pg_clickhouse/introduction) para obtener más información.
Habilita la extensión:
```sql theme={null}
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:
```sql theme={null}
CREATE SERVER ch FOREIGN DATA WRAPPER clickhouse_fdw
OPTIONS(driver 'http', host '', dbname '', port '8443');
```
Reemplace `` por el `hostname` de ClickHouse y `` 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:
```sql theme={null}
CREATE USER MAPPING FOR CURRENT_USER SERVER ch
OPTIONS (user 'default', password '');
```
Ahora importa las tablas de ClickHouse a un esquema de Postgres:
```sql theme={null}
CREATE SCHEMA organization;
IMPORT FOREIGN SCHEMA "" FROM SERVER ch INTO organization;
```
Sustituye `` 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:
```sql theme={null}
\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_`.
**Consulta 1: Usuarios más activos**
Esta consulta identifica a los usuarios más activos mediante múltiples agregaciones:
```sql theme={null}
-- 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;
```
```text theme={null}
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:
```sql theme={null}
-- 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;
```
```text theme={null}
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