> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-home-button.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Conectar ClickHouse con PostgreSQL
> Página que describe las distintas formas de conectar PostgreSQL con ClickHouse
export const ExperimentalBadge = () => {
return ;
};
export const CloudNotSupportedBadge = () => {
return
Not supported in ClickHouse Cloud
;
};
Esta página cubre las siguientes opciones para integrar PostgreSQL con ClickHouse:
* usar el motor de tabla `PostgreSQL` para leer desde una tabla de PostgreSQL
* usar el motor de base de datos experimental `MaterializedPostgreSQL` para sincronizar una base de datos de PostgreSQL con una base de datos de ClickHouse
Consulta nuestro servicio [Managed Postgres](/es/products/managed-postgres/overview). Gracias a su almacenamiento NVMe, ubicado físicamente junto al cómputo, ofrece un rendimiento hasta 10 veces superior para cargas de trabajo limitadas por disco en comparación con alternativas que usan almacenamiento conectado por red como EBS, y te permite replicar tus datos de Postgres en ClickHouse mediante el conector Postgres CDC de ClickPipes.
## Uso del motor de tabla PostgreSQL
El motor de tabla `PostgreSQL` permite realizar operaciones **SELECT** e **INSERT** sobre datos almacenados en un servidor PostgreSQL remoto desde ClickHouse.
Este artículo ilustra métodos básicos de integración usando una sola tabla.
### 1. Configuración de PostgreSQL
1. En `postgresql.conf`, agregue la siguiente entrada para que PostgreSQL escuche en las interfaces de red:
```text theme={null}
listen_addresses = '*'
```
2. Cree un usuario para que ClickHouse se conecte. Con fines de demostración, este ejemplo le concede privilegios completos de superusuario.
```sql theme={null}
CREATE ROLE clickhouse_user SUPERUSER LOGIN PASSWORD 'ClickHouse_123';
```
3. Cree una nueva base de datos en PostgreSQL:
```sql theme={null}
CREATE DATABASE db_in_psg;
```
4. Cree una tabla nueva:
```sql theme={null}
CREATE TABLE table1 (
id integer primary key,
column1 varchar(10)
);
```
5. Agreguemos unas cuantas filas para probar:
```sql theme={null}
INSERT INTO table1
(id, column1)
VALUES
(1, 'abc'),
(2, 'def');
```
6. Para configurar PostgreSQL de modo que permita conexiones a la nueva base de datos con el nuevo usuario para la replicación, agrega la siguiente entrada al archivo `pg_hba.conf`. Actualiza la línea de dirección con la subred o la dirección IP de tu servidor de PostgreSQL:
```text theme={null}
# TYPE DATABASE USER ADDRESS METHOD
host db_in_psg clickhouse_user 192.168.1.0/24 password
```
7. Recarga la configuración `pg_hba.conf` (ajusta este comando según tu versión):
```text theme={null}
/usr/pgsql-12/bin/pg_ctl reload
```
8. Verifique que el nuevo `clickhouse_user` pueda iniciar sesión:
```text theme={null}
psql -U clickhouse_user -W -d db_in_psg -h
```
Si estás usando esta función en ClickHouse Cloud, puede que necesites permitir el acceso a tu instancia de PostgreSQL desde las direcciones IP de ClickHouse Cloud.
Consulta la [Cloud Endpoints API](/es/products/cloud/guides/sql-console/query-endpoints) de ClickHouse para obtener información sobre el tráfico de salida.
### 2. Defina una tabla en ClickHouse
1. Inicie sesión en el cliente `clickhouse-client`:
```bash theme={null}
clickhouse-client --user default --password ClickHouse123!
```
2. Vamos a crear una nueva base de datos:
```sql theme={null}
CREATE DATABASE db_in_ch;
```
3. Cree una tabla que use `PostgreSQL`:
```sql theme={null}
CREATE TABLE db_in_ch.table1
(
id UInt64,
column1 String
)
ENGINE = PostgreSQL('postgres-host.domain.com:5432', 'db_in_psg', 'table1', 'clickhouse_user', 'ClickHouse_123');
```
Los parámetros mínimos necesarios son:
| parámetro | Descripción | ejemplo |
| --------- | -------------------------------------------- | ----------------------------- |
| host:port | nombre de host o dirección IP y puerto | postgres-host.domain.com:5432 |
| database | nombre de la base de datos de PostgreSQL | db\_in\_psg |
| user | nombre de usuario para conectarse a Postgres | clickhouse\_user |
| password | contraseña para conectarse a Postgres | ClickHouse\_123 |
Consulte la página de documentación de [PostgreSQL table engine](/es/reference/engines/table-engines/integrations/postgresql) para ver la lista completa de parámetros.
### 3 Probar la integración
1. En ClickHouse, consulte las filas iniciales:
```sql theme={null}
SELECT * FROM db_in_ch.table1
```
La tabla de ClickHouse debería llenarse automáticamente con las dos filas que ya existían en la tabla de PostgreSQL:
```response theme={null}
Query id: 34193d31-fe21-44ac-a182-36aaefbd78bf
┌─id─┬─column1─┐
│ 1 │ abc │
│ 2 │ def │
└────┴─────────┘
```
2. De nuevo en PostgreSQL, añada un par de filas a la tabla:
```sql theme={null}
INSERT INTO table1
(id, column1)
VALUES
(3, 'ghi'),
(4, 'jkl');
```
4. Esas dos filas nuevas deberían aparecer en tu tabla de ClickHouse:
```sql theme={null}
SELECT * FROM db_in_ch.table1
```
La respuesta debería ser:
```response theme={null}
Query id: 86fa2c62-d320-4e47-b564-47ebf3d5d27b
┌─id─┬─column1─┐
│ 1 │ abc │
│ 2 │ def │
│ 3 │ ghi │
│ 4 │ jkl │
└────┴─────────┘
```
5. Veamos qué ocurre cuando añades filas a la tabla de ClickHouse:
```sql theme={null}
INSERT INTO db_in_ch.table1
(id, column1)
VALUES
(5, 'mno'),
(6, 'pqr');
```
6. Las filas agregadas en ClickHouse deberían aparecer en la tabla de PostgreSQL:
```sql theme={null}
db_in_psg=# SELECT * FROM table1;
id | column1
----+---------
1 | abc
2 | def
3 | ghi
4 | jkl
5 | mno
6 | pqr
(6 rows)
```
Este ejemplo mostró la integración básica entre PostgreSQL y ClickHouse mediante el motor de tabla `PostrgeSQL`.
Consulta la [página de documentación del motor de tabla PostgreSQL](/es/reference/engines/table-engines/integrations/postgresql) para ver más funcionalidades, como especificar esquemas, devolver solo un subconjunto de columnas y conectarse a varias réplicas. Consulta también el blog [ClickHouse and PostgreSQL - a match made in data heaven - part 1](https://clickhouse.com/blog/migrating-data-between-clickhouse-postgres).
## Uso del motor de base de datos MaterializedPostgreSQL
El motor de base de datos PostgreSQL utiliza las funciones de replicación de PostgreSQL para crear una réplica de la base de datos con todos los esquemas y tablas, o con un subconjunto de ellos.
Este artículo ilustra métodos básicos de integración con una base de datos, un esquema y una tabla.
***En los procedimientos siguientes se utilizan PostgreSQL CLI (psql) y ClickHouse CLI (clickhouse-client). El servidor PostgreSQL está instalado en Linux. A continuación se muestra la configuración mínima si la base de datos PostgreSQL es una instalación de prueba nueva***
### 1. En PostgreSQL
1. En `postgresql.conf`, configure los niveles mínimos de escucha, el nivel WAL de replicación y los slots de replicación:
agregue las siguientes entradas:
```text theme={null}
listen_addresses = '*'
max_replication_slots = 10
wal_level = logical
```
\**ClickHouse necesita como mínimo el nivel de wal `logical` y al menos `2` slots de replicación*
2. Con una cuenta de administrador, cree un usuario para conectarse desde ClickHouse:
```sql theme={null}
CREATE ROLE clickhouse_user SUPERUSER LOGIN PASSWORD 'ClickHouse_123';
```
\**con fines de demostración, se han concedido privilegios completos de superusuario.*
3. cree una nueva base de datos:
```sql theme={null}
CREATE DATABASE db1;
```
4. conéctese a la nueva base de datos desde `psql`:
```text theme={null}
\connect db1
```
5. cree una nueva tabla:
```sql theme={null}
CREATE TABLE table1 (
id integer primary key,
column1 varchar(10)
);
```
6. añade las filas iniciales:
```sql theme={null}
INSERT INTO table1
(id, column1)
VALUES
(1, 'abc'),
(2, 'def');
```
7. Configure PostgreSQL para permitir conexiones a la nueva base de datos con el nuevo usuario de replicación. A continuación se muestra la entrada mínima que se debe añadir al archivo `pg_hba.conf`:
```text theme={null}
# TYPE DATABASE USER ADDRESS METHOD
host db1 clickhouse_user 192.168.1.0/24 password
```
\**para fines de demostración, aquí se utiliza el método de autenticación con contraseña en texto claro. actualice la línea `address` con la subred o la dirección del servidor, según la documentación de PostgreSQL*
8. vuelva a cargar la configuración de `pg_hba.conf` con algo como esto (ajústelo según su versión):
```text theme={null}
/usr/pgsql-12/bin/pg_ctl reload
```
9. Pruebe a iniciar sesión con el nuevo `clickhouse_user`:
```text theme={null}
psql -U clickhouse_user -W -d db1 -h
```
### 2. En ClickHouse
1. acceda a la ClickHouse CLI
```bash theme={null}
clickhouse-client --user default --password ClickHouse123!
```
2. Habilite la función experimental de PostgreSQL para el motor de base de datos:
```sql theme={null}
SET allow_experimental_database_materialized_postgresql=1
```
3. Cree la nueva base de datos que se va a replicar y defina la tabla inicial:
```sql theme={null}
CREATE DATABASE db1_postgres
ENGINE = MaterializedPostgreSQL('postgres-host.domain.com:5432', 'db1', 'clickhouse_user', 'ClickHouse_123')
SETTINGS materialized_postgresql_tables_list = 'table1';
```
opciones mínimas:
| parameter | Descripción | ejemplo |
| --------- | -------------------------------------------- | ------------------------------------------------- |
| host:port | nombre de host o dirección IP y puerto | postgres-host.domain.com:5432 |
| database | nombre de la base de datos PostgreSQL | db1 |
| user | nombre de usuario para conectarse a Postgres | clickhouse\_user |
| password | contraseña para conectarse a Postgres | ClickHouse\_123 |
| settings | configuración adicional para el motor | materialized\_postgresql\_tables\_list = 'table1' |
Para consultar la guía completa del motor de base de datos PostgreSQL, consulte [https://clickhouse.com/docs/engines/database-engines/materialized-postgresql/#settings](https://clickhouse.com/docs/engines/database-engines/materialized-postgresql/#settings)
4. Compruebe que la tabla inicial tenga datos:
```sql theme={null}
ch_env_2 :) select * from db1_postgres.table1;
SELECT *
FROM db1_postgres.table1
```
```response theme={null}
Query id: df2381ac-4e30-4535-b22e-8be3894aaafc
┌─id─┬─column1─┐
│ 1 │ abc │
└────┴─────────┘
┌─id─┬─column1─┐
│ 2 │ def │
└────┴─────────┘
```
### 3. Probar la replicación básica
1. En PostgreSQL, agregue nuevas filas:
```sql theme={null}
INSERT INTO table1
(id, column1)
VALUES
(3, 'ghi'),
(4, 'jkl');
```
2. En ClickHouse, verifica que las nuevas filas estén visibles:
```sql theme={null}
ch_env_2 :) select * from db1_postgres.table1;
SELECT *
FROM db1_postgres.table1
```
```response theme={null}
Query id: b0729816-3917-44d3-8d1a-fed912fb59ce
┌─id─┬─column1─┐
│ 1 │ abc │
└────┴─────────┘
┌─id─┬─column1─┐
│ 4 │ jkl │
└────┴─────────┘
┌─id─┬─column1─┐
│ 3 │ ghi │
└────┴─────────┘
┌─id─┬─column1─┐
│ 2 │ def │
└────┴─────────┘
```
### 4. Resumen
Esta guía de integración se ha centrado en un ejemplo sencillo de cómo replicar una base de datos con una tabla; sin embargo, existen opciones más avanzadas, como replicar toda la base de datos o añadir nuevas tablas y esquemas a las replicaciones ya existentes. Aunque esta replicación no admite comandos DDL, el motor puede configurarse para detectar cambios y volver a cargar las tablas cuando se realicen cambios estructurales.
Para conocer más funcionalidades disponibles en las opciones avanzadas, consulte la [documentación de referencia](/es/reference/engines/database-engines/materialized-postgresql).