> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Быстрый старт для Managed Postgres
> Оцените производительность Postgres на базе NVMe и добавьте Real-time аналитику с помощью нативной интеграции 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 — это Postgres корпоративного уровня на базе NVMe-хранилища, который обеспечивает до 10 раз более высокую производительность для рабочих нагрузок, упирающихся в скорость дисковой подсистемы, по сравнению с сетевыми хранилищами вроде EBS. Этот быстрый старт состоит из двух частей:
* **Часть 1:** Начните работу с NVMe Postgres и оцените его производительность
* **Часть 2:** Откройте возможности Real-time аналитики, интегрировав ее с ClickHouse
Сейчас Managed Postgres доступен в AWS в нескольких регионах и предоставляется бесплатно в рамках закрытой предварительной версии.
**В этом быстром старте вы:**
* Создадите экземпляр Managed Postgres с производительностью NVMe
* Загрузите 1 миллион тестовых событий и увидите скорость NVMe в действии
* Выполните запросы и оцените низкую задержку
* Реплицируете данные в ClickHouse для Real-time аналитики
* Будете выполнять запросы к ClickHouse напрямую из Postgres с помощью `pg_clickhouse`
## Часть 1: Начало работы с NVMe Postgres
### Создание базы данных
Чтобы создать новый сервис Managed Postgres, нажмите кнопку **New service** в списке сервисов в Cloud Console. Затем вы сможете выбрать Postgres в качестве типа базы данных.
Введите имя для экземпляра базы данных и нажмите **Create service**. После этого вы перейдёте на страницу обзора.
Экземпляр Managed Postgres будет подготовлен и готов к использованию через 3–5 минут.
### Подключитесь к своей базе данных
На боковой панели слева вы увидите [**кнопку Connect**](/ru/products/managed-postgres/connection). Нажмите на нее, чтобы просмотреть сведения о подключении и строки подключения в разных форматах.
Скопируйте строку подключения `psql` и подключитесь к своей базе данных. Вы также можете использовать любой клиент, совместимый с Postgres, например DBeaver, или любую библиотеку для приложений.
### Оцените производительность NVMe
Давайте посмотрим, как проявляется производительность NVMe на практике. Сначала включите замер времени в psql, чтобы оценить время выполнения запроса:
```sql theme={null}
\timing
```
Создайте две тестовые таблицы для событий и пользователей:
```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)
);
```
Теперь вставьте 1 миллион событий и посмотрите на скорость 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)
```
**Производительность NVMe**
1 миллион строк с данными JSONB вставляется менее чем за 4 секунды. В традиционных облачных базах данных, использующих сетевые хранилища вроде EBS, та же операция обычно занимает в 2–3 раза больше времени из-за задержек при сетевом обмене и ограничений по IOPS. NVMe-хранилище устраняет эти узкие места, поскольку хранилище физически подключено к вычислительным ресурсам.
Производительность зависит от размера инстанса, текущей нагрузки и характеристик данных.
Вставьте 1 000 пользователей:
```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;
```
### Выполните запросы к своим данным
Теперь давайте выполним несколько запросов, чтобы увидеть, насколько быстро Postgres отвечает при использовании NVMe-хранилища.
**Агрегируйте 1 миллион событий по типу:**
```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 строк)
Время: 114.883 ms
```
**Запрос с фильтрацией по JSONB и диапазоном дат:**
```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
```
**Объедините события с пользователями:**
```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
```
**Ваш Postgres готов**
На этом этапе у вас есть полностью работоспособная высокопроизводительная база данных Postgres, готовая к транзакционным нагрузкам.
Перейдите к части 2, чтобы узнать, как нативная интеграция ClickHouse может вывести вашу аналитику на новый уровень.
***
## Часть 2: Добавьте Real-time аналитику с ClickHouse
Хотя Postgres отлично подходит для транзакционных рабочих нагрузок (OLTP), ClickHouse специально создан для аналитических запросов (OLAP) по большим наборам данных. Объединив их, вы получите лучшее из двух миров:
* **Postgres** для транзакционных данных вашего приложения (вставки, обновления, точечные выборки)
* **ClickHouse** для аналитики с задержкой менее секунды на миллиардах строк
В этом разделе показано, как настроить репликацию данных из Postgres в ClickHouse и выполнять запросы к ним без лишних сложностей.
### Настройка интеграции ClickHouse
Теперь, когда в Postgres есть таблицы и данные, давайте настроим репликацию таблиц в ClickHouse для аналитики. Сначала нажмите **ClickHouse integration** на боковой панели. Затем нажмите **Replicate data in ClickHouse**.
В открывшейся форме можно указать имя интеграции и выбрать существующий экземпляр ClickHouse, в который будут реплицироваться данные. Если у вас еще нет экземпляра ClickHouse, его можно создать прямо из этой формы.
**Важно**
Перед продолжением убедитесь, что выбранный сервис ClickHouse находится в состоянии Running.
Нажмите **Next**, чтобы перейти к выбору таблиц. Здесь нужно сделать следующее:
* Выберите базу данных ClickHouse, в которую будут реплицироваться данные.
* Разверните схему **public** и выберите таблицы users и events, которые мы создали ранее.
* Нажмите **Replicate data to ClickHouse**.
Запустится процесс репликации, и вы перейдете на страницу обзора интеграции. Поскольку это первая интеграция, развертывание базовой инфраструктуры может занять 2–3 минуты. А пока давайте рассмотрим новое расширение **pg\_clickhouse**.
### Выполнение запросов к ClickHouse из Postgres
Расширение `pg_clickhouse` позволяет напрямую выполнять запросы к данным ClickHouse из Postgres с помощью стандартного SQL. Это означает, что ваше приложение может использовать Postgres как единый слой запросов как для транзакционных, так и для аналитических данных. Подробности см. в [полной документации](/ru/integrations/connectors/tools/pg_clickhouse/introduction).
Включите расширение:
```sql theme={null}
CREATE EXTENSION pg_clickhouse;
```
Затем создайте foreign server для подключения к ClickHouse. Используйте драйвер `http` и порт `8443` для защищённых соединений:
```sql theme={null}
CREATE SERVER ch FOREIGN DATA WRAPPER clickhouse_fdw
OPTIONS(driver 'http', host '', dbname '', port '8443');
```
Замените `` на имя хоста ClickHouse, а `` — на базу данных, выбранную при настройке репликации. Имя хоста можно найти в сервисе ClickHouse, нажав **Connect** на боковой панели.
Теперь сопоставим пользователя Postgres с учетными данными сервиса ClickHouse:
```sql theme={null}
CREATE USER MAPPING FOR CURRENT_USER SERVER ch
OPTIONS (user 'default', password '');
```
Теперь импортируйте таблицы ClickHouse в схему Postgres:
```sql theme={null}
CREATE SCHEMA organization;
IMPORT FOREIGN SCHEMA "" FROM SERVER ch INTO organization;
```
Замените `` на то же имя базы данных, которое вы использовали при создании сервера.
Теперь в клиенте Postgres вы можете увидеть все таблицы ClickHouse:
```sql theme={null}
\det+ organization.*
```
### Посмотрите аналитику в работе
Снова перейдите на страницу интеграции. Вы увидите, что начальная репликация завершена. Нажмите на название интеграции, чтобы посмотреть подробности.
Нажмите на название сервиса, чтобы открыть консоль ClickHouse и увидеть реплицированные таблицы.
### Сравнение производительности Postgres и ClickHouse
Теперь выполним несколько аналитических запросов и сравним производительность Postgres и ClickHouse. Обратите внимание: для реплицированных таблиц используется соглашение об именовании `public_`.
**Запрос 1: Самые активные пользователи**
Этот запрос определяет самых активных пользователей с помощью нескольких агрегаций:
```sql theme={null}
-- Через 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 -- Тот же запрос в Postgres
```
**Запрос 2: Вовлечённость пользователей по странам и платформам**
Этот запрос связывает события с пользователями и вычисляет метрики вовлечённости:
```sql theme={null}
-- Через 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 -- Тот же запрос в Postgres
```
**Сравнение производительности:**
| Query | Postgres (NVMe) | ClickHouse (via pg\_clickhouse) | Speedup |
| ---------------------------------------------- | --------------- | ------------------------------- | ------- |
| Топ пользователей (5 агрегаций) | 555 ms | 164 ms | 3.4x |
| Вовлечённость пользователей (JOIN + агрегации) | 1,246 ms | 170 ms | 7.3x |
**Когда использовать ClickHouse**
Даже на этом наборе данных из 1 млн строк ClickHouse обеспечивает в 3–7 раз более высокую производительность для сложных аналитических запросов с JOIN и несколькими агрегациями. На больших масштабах (100 млн+ строк) разница становится ещё заметнее: благодаря столбцовому хранению и векторизованному выполнению ClickHouse может давать ускорение в 10–100 раз.
Время выполнения запросов зависит от размера инстанса, сетевой задержки между сервисами, характеристик данных и текущей нагрузки.
## Очистка
Чтобы удалить ресурсы, созданные в этом быстром старте:
1. Сначала удалите интеграцию ClickPipe в сервисе ClickHouse
2. Затем удалите экземпляр Managed Postgres в Cloud Console