> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-fbfa8bee.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Connexion de ClickHouse à PostgreSQL
> Page décrivant les différentes méthodes pour connecter PostgreSQL à ClickHouse
export const ExperimentalBadge = () => {
return ;
};
export const CloudNotSupportedBadge = () => {
return
Non pris en charge par ClickHouse Cloud
;
};
Cette page présente les options suivantes pour intégrer PostgreSQL à ClickHouse :
* utiliser le moteur de table `PostgreSQL` pour lire depuis une table PostgreSQL
* utiliser le moteur de base de données expérimental `MaterializedPostgreSQL` pour synchroniser une base de données PostgreSQL avec une base de données ClickHouse
Découvrez notre service [Managed Postgres](/fr/products/managed-postgres/overview). Reposant sur un stockage NVMe physiquement colocalisé avec la capacité de calcul, il offre des performances jusqu’à 10 fois supérieures pour les workloads limités par les E/S disque par rapport aux alternatives utilisant du stockage réseau comme EBS, et vous permet de répliquer vos données Postgres vers ClickHouse à l’aide du connecteur Postgres CDC dans ClickPipes.
## Utilisation du moteur de table PostgreSQL
Le moteur de table `PostgreSQL` permet d'effectuer des opérations **SELECT** et **INSERT** sur des données stockées sur un serveur PostgreSQL distant depuis ClickHouse.
Cet article illustre les méthodes de base pour l'intégration à l'aide d'une seule table.
### 1. Configuration de PostgreSQL
1. Dans `postgresql.conf`, ajoutez l’entrée suivante pour que PostgreSQL écoute sur les interfaces réseau :
```text theme={null}
listen_addresses = '*'
```
2. Créez un utilisateur pour permettre la connexion depuis ClickHouse. À des fins de démonstration, cet exemple octroie tous les privilèges de superutilisateur.
```sql theme={null}
CREATE ROLE clickhouse_user SUPERUSER LOGIN PASSWORD 'ClickHouse_123';
```
3. Créez une nouvelle base de données dans PostgreSQL :
```sql theme={null}
CREATE DATABASE db_in_psg;
```
4. Créez une nouvelle table :
```sql theme={null}
CREATE TABLE table1 (
id integer primary key,
column1 varchar(10)
);
```
5. Ajoutons quelques lignes pour les tests :
```sql theme={null}
INSERT INTO table1
(id, column1)
VALUES
(1, 'abc'),
(2, 'def');
```
6. Pour configurer PostgreSQL afin d’autoriser les connexions à la nouvelle base de données avec le nouvel utilisateur pour la réplication, ajoutez l’entrée suivante au fichier `pg_hba.conf`. Mettez à jour la ligne d’adresse avec le sous-réseau ou l’adresse IP de votre serveur PostgreSQL :
```text theme={null}
# TYPE DATABASE USER ADDRESS METHOD
host db_in_psg clickhouse_user 192.168.1.0/24 password
```
7. Rechargez le fichier de configuration `pg_hba.conf` (adaptez cette commande selon votre version) :
```text theme={null}
/usr/pgsql-12/bin/pg_ctl reload
```
8. Vérifiez que le nouvel utilisateur `clickhouse_user` peut se connecter :
```text theme={null}
psql -U clickhouse_user -W -d db_in_psg -h
```
Si vous utilisez cette fonctionnalité dans ClickHouse Cloud, vous devrez შესაძლოა autoriser les adresses IP de ClickHouse Cloud à accéder à votre instance PostgreSQL.
Consultez la [Cloud Endpoints API](/fr/products/cloud/guides/sql-console/query-endpoints) de ClickHouse pour obtenir des détails sur le trafic sortant.
### 2. Définir une Table dans ClickHouse
1. Connectez-vous à `clickhouse-client` :
```bash theme={null}
clickhouse-client --user default --password ClickHouse123!
```
2. Créons une nouvelle base de données :
```sql theme={null}
CREATE DATABASE db_in_ch;
```
3. Créez une table utilisant le moteur de table `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');
```
Les paramètres minimaux requis sont :
| paramètre | Description | exemple |
| --------- | ---------------------------------------------- | ----------------------------- |
| host:port | nom d’hôte ou IP et port | postgres-host.domain.com:5432 |
| database | nom de la base de données PostgreSQL | db\_in\_psg |
| user | nom d’utilisateur pour se connecter à Postgres | clickhouse\_user |
| password | mot de passe pour se connecter à Postgres | ClickHouse\_123 |
Consultez la page de documentation sur le [moteur de table PostgreSQL](/fr/reference/engines/table-engines/integrations/postgresql) pour obtenir la liste complète des paramètres.
### 3 Tester l’intégration
1. Dans ClickHouse, affichez les lignes initiales :
```sql theme={null}
SELECT * FROM db_in_ch.table1
```
La table ClickHouse devrait automatiquement être alimentée avec les deux lignes déjà présentes dans la table PostgreSQL :
```response theme={null}
Query id: 34193d31-fe21-44ac-a182-36aaefbd78bf
┌─id─┬─column1─┐
│ 1 │ abc │
│ 2 │ def │
└────┴─────────┘
```
2. De retour dans PostgreSQL, ajoutez deux lignes dans la table :
```sql theme={null}
INSERT INTO table1
(id, column1)
VALUES
(3, 'ghi'),
(4, 'jkl');
```
4. Ces deux nouvelles lignes devraient apparaître dans votre table ClickHouse :
```sql theme={null}
SELECT * FROM db_in_ch.table1
```
La réponse doit être :
```response theme={null}
Query id: 86fa2c62-d320-4e47-b564-47ebf3d5d27b
┌─id─┬─column1─┐
│ 1 │ abc │
│ 2 │ def │
│ 3 │ ghi │
│ 4 │ jkl │
└────┴─────────┘
```
5. Voyons ce qui se passe lorsque vous ajoutez des lignes à la table ClickHouse :
```sql theme={null}
INSERT INTO db_in_ch.table1
(id, column1)
VALUES
(5, 'mno'),
(6, 'pqr');
```
6. Les lignes ajoutées dans ClickHouse devraient apparaître dans la table 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)
```
Cet exemple a présenté l’intégration de base entre PostgreSQL et ClickHouse à l’aide du moteur de table `PostrgeSQL`.
Consultez la [page de documentation du moteur de table PostgreSQL](/fr/reference/engines/table-engines/integrations/postgresql) pour découvrir d’autres fonctionnalités, comme la spécification de schémas, le renvoi d’un sous-ensemble de colonnes et la connexion à plusieurs répliques. Consultez également le billet de blog [ClickHouse and PostgreSQL - a match made in data heaven - part 1](https://clickhouse.com/blog/migrating-data-between-clickhouse-postgres).
## Utilisation du moteur de base de données MaterializedPostgreSQL
Le moteur de base de données PostgreSQL s’appuie sur les fonctionnalités de réplication de PostgreSQL pour créer une replica de la base de données avec tout ou partie des schémas et des tables.
Cet article illustre les méthodes d’intégration de base à l’aide d’une base de données, d’un schéma et d’une table.
***Dans les procédures suivantes, la CLI PostgreSQL (`psql`) et la ClickHouse CLI (`clickhouse-client`) sont utilisées. Le serveur PostgreSQL est installé sur Linux. La configuration minimale ci-dessous s’applique si la base de données PostgreSQL est une nouvelle installation de test.***
### 1. Dans PostgreSQL
1. Dans `postgresql.conf`, définissez les niveaux d’écoute minimaux, le `wal level` de réplication et les slots de réplication :
ajoutez les entrées suivantes :
```text theme={null}
listen_addresses = '*'
max_replication_slots = 10
wal_level = logical
```
\**ClickHouse nécessite un wal level au minimum défini sur `logical` et au moins `2` slots de réplication*
2. À l’aide d’un compte administrateur, créez un utilisateur pour la connexion depuis ClickHouse :
```sql theme={null}
CREATE ROLE clickhouse_user SUPERUSER LOGIN PASSWORD 'ClickHouse_123';
```
\**à des fins de démonstration, des privilèges complets de superutilisateur ont été accordés.*
3. créer une nouvelle base de données :
```sql theme={null}
CREATE DATABASE db1;
```
4. connectez-vous à la nouvelle base de données avec `psql` :
```text theme={null}
\connect db1
```
5. créez une nouvelle table :
```sql theme={null}
CREATE TABLE table1 (
id integer primary key,
column1 varchar(10)
);
```
6. insérez les lignes initiales :
```sql theme={null}
INSERT INTO table1
(id, column1)
VALUES
(1, 'abc'),
(2, 'def');
```
7. Configurez PostgreSQL pour autoriser le nouvel utilisateur de réplication à se connecter à la nouvelle base de données. Vous trouverez ci-dessous l’entrée minimale à ajouter au fichier `pg_hba.conf` :
```text theme={null}
# TYPE DATABASE USER ADDRESS METHOD
host db1 clickhouse_user 192.168.1.0/24 password
```
\**à des fins de démonstration, cette méthode d’authentification par mot de passe en clair est utilisée. mettez à jour la ligne d’adresse avec le sous-réseau ou l’adresse du serveur, conformément à la documentation PostgreSQL*
8. rechargez la configuration `pg_hba.conf` avec une commande comme celle-ci (à adapter selon votre version) :
```text theme={null}
/usr/pgsql-12/bin/pg_ctl reload
```
9. Testez la connexion avec le nouvel utilisateur `clickhouse_user` :
```text theme={null}
psql -U clickhouse_user -W -d db1 -h
```
### 2. Dans ClickHouse
1. connectez-vous à ClickHouse CLI
```bash theme={null}
clickhouse-client --user default --password ClickHouse123!
```
2. Activez la fonctionnalité expérimentale PostgreSQL pour le moteur de base de données :
```sql theme={null}
SET allow_experimental_database_materialized_postgresql=1
```
3. Créez la nouvelle base de données qui sera répliquée et définissez la table initiale :
```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';
```
options minimales :
| parameter | Description | example |
| --------- | ---------------------------------------------- | ------------------------------------------------- |
| host:port | nom d’hôte ou adresse IP et port | postgres-host.domain.com:5432 |
| database | nom de la base de données PostgreSQL | db1 |
| user | nom d’utilisateur pour se connecter à Postgres | clickhouse\_user |
| password | mot de passe pour se connecter à Postgres | ClickHouse\_123 |
| settings | paramètres supplémentaires du moteur | materialized\_postgresql\_tables\_list = 'table1' |
Pour le guide complet sur le moteur de base de données PostgreSQL, consultez [https://clickhouse.com/docs/engines/database-engines/materialized-postgresql/#settings](https://clickhouse.com/docs/engines/database-engines/materialized-postgresql/#settings)
4. Vérifiez que la table initiale contient des données :
```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. Tester la réplication de base
1. Dans PostgreSQL, ajoutez de nouvelles lignes :
```sql theme={null}
INSERT INTO table1
(id, column1)
VALUES
(3, 'ghi'),
(4, 'jkl');
```
2. Dans ClickHouse, vérifiez que les nouvelles lignes sont bien 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. Résumé
Ce guide d’intégration s’est concentré sur un exemple simple montrant comment répliquer une base de données contenant une table. Il existe toutefois des options plus avancées, notamment la réplication de l’ensemble de la base de données ou l’ajout de nouvelles tables et de nouveaux schémas aux réplications existantes. Bien que les commandes DDL ne soient pas prises en charge pour cette réplication, le moteur peut être configuré pour détecter les changements et recharger les tables lorsque des modifications structurelles sont apportées.
Pour en savoir plus sur les fonctionnalités disponibles dans les options avancées, consultez la [documentation de référence](/fr/reference/engines/database-engines/materialized-postgresql).