Шпаргалка · Надёжность
Backpressure
Проблема
Мобильное приложение шлёт события аналитики в ingest API, а тот держит их в памяти, пока writer не запишет их в базу. Когда база замедляется, события приходят быстрее, чем уходят, у буфера нет предела, и API падает по памяти с 1,8 миллиона уже подтверждённых событий. Backpressure — это способ системы сказать «помедленнее» вверх по цепочке: ограниченный буфер, выбранная стратегия переполнения, 429 с Retry-After, потребители, которые сами забирают работу, отказ по приоритету и лимит на входе.
Чему вы научитесь
- Почему неограниченная очередь превращает перегрузку сначала в задержку, потом в потерю данных, и как это посчитать
- Ограниченный буфер и четыре стратегии переполнения: block, drop newest, drop oldest, sampling
- Сброс нагрузки через 429 и Retry-After и pull-модель: consumer poll, окно TCP, request(n)
- Передача сигнала вверх по приоритету и concurrency limit, который отказывает быстро, а не ставит в очередь
Диаграмма как код
Итоговая схема урока в виде текста: вставьте её в Jira, GitLab, GitHub, Notion или документацию, там Mermaid рисуется сам. Есть варианты для D2 и PlantUML (Confluence, IntelliJ).
Mermaid: схема
flowchart LR
n_apps(["Мобильные приложения"])
n_api["Ingest API"]
n_writer("Writer'ы")
n_db[("БД аналитики")]
n_log[["Лог событий"]]
n_apps --> n_api
n_writer --> n_db
n_api --> n_log
n_writer --> n_logMermaid: последовательность запросов
sequenceDiagram
participant n_apps as Мобильные приложения
participant n_api as Ingest API
participant n_buffer as Буфер в памяти
participant n_writer as Writer'ы
participant n_log as Лог событий
Note over n_apps,n_api: События попадают в память, writer их разбирает
n_apps->>n_api: POST /v1/events HTTP/1.1
n_api-->>n_apps: HTTP/1.1 202 Accepted
Note over n_api,n_buffer: База замедляется, буфер растёт
n_api->>n_buffer: 19:10 buffer in 1 200/s out 800/s
Note over n_api,n_buffer: API падает с 1,8 миллиона подтверждённых событий
n_api->>n_buffer: 20:16:41 api-3 OOMKilled (limit 2 GiB)
Note over n_api,n_buffer: У буфера появляется предел: при заполнении ждать
n_api->>n_buffer: buffer = BoundedQueue(capacity=50_000)
Note over n_api,n_buffer: Когда полон: ждать, выбросить или сэмплировать
n_api->>n_buffer: buffer full (50 000): what happens to event 50 001
Note over n_apps,n_api: Сброс нагрузки: быстрое «нет» с Retry-After
n_apps->>n_api: POST /v1/events HTTP/1.1
n_api-->>n_apps: HTTP/1.1 429 Too Many Requests
Note over n_writer,n_log: Надёжный лог и writer'ы, которые сами забирают
n_writer->>n_log: writer-2 poll(max_records=500)
Note over n_api,n_log: Задержка поднимается по цепочке, с приоритетами
n_api->>n_log: api admission consumer_lag=74 s (limit 60 s)
Note over n_apps,n_api: Concurrency limit на входе
n_apps->>n_api: api concurrency limiter window 1 sD2
direction: right
n_apps: "Мобильные приложения" {
shape: rectangle
}
n_api: "Ingest API" {
shape: rectangle
}
n_writer: "Writer'ы" {
shape: rectangle
style.multiple: true
}
n_db: "БД аналитики" {
shape: cylinder
}
n_log: "Лог событий" {
shape: queue
}
n_apps -> n_api
n_writer -> n_db
n_api -> n_log
n_writer -> n_logPlantUML: последовательность запросов
@startuml
participant "Мобильные приложения" as n_apps
participant "Ingest API" as n_api
queue "Буфер в памяти" as n_buffer
participant "Writer'ы" as n_writer
queue "Лог событий" as n_log
note over n_apps, n_api : События попадают в память, writer их разбирает
n_apps -> n_api : POST /v1/events HTTP/1.1
n_api --> n_apps : HTTP/1.1 202 Accepted
note over n_api, n_buffer : База замедляется, буфер растёт
n_api -> n_buffer : 19:10 buffer in 1 200/s out 800/s
note over n_api, n_buffer : API падает с 1,8 миллиона подтверждённых событий
n_api -> n_buffer : 20:16:41 api-3 OOMKilled (limit 2 GiB)
note over n_api, n_buffer : У буфера появляется предел: при заполнении ждать
n_api -> n_buffer : buffer = BoundedQueue(capacity=50_000)
note over n_api, n_buffer : Когда полон: ждать, выбросить или сэмплировать
n_api -> n_buffer : buffer full (50 000): what happens to event 50 001
note over n_apps, n_api : Сброс нагрузки: быстрое «нет» с Retry-After
n_apps -> n_api : [повтор] POST /v1/events HTTP/1.1
n_api --> n_apps : HTTP/1.1 429 Too Many Requests
note over n_writer, n_log : Надёжный лог и writer'ы, которые сами забирают
n_writer -> n_log : writer-2 poll(max_records=500)
note over n_api, n_log : Задержка поднимается по цепочке, с приоритетами
n_api -> n_log : api admission consumer_lag=74 s (limit 60 s)
note over n_apps, n_api : Concurrency limit на входе
n_apps -> n_api : api concurrency limiter window 1 s
@endumlPlantUML: компоненты
@startuml
left to right direction
agent "Мобильные приложения" as n_apps
component "Ingest API" as n_api
collections "Writer'ы" as n_writer
database "БД аналитики" as n_db
queue "Лог событий" as n_log
n_apps --> n_api
n_writer --> n_db
n_api --> n_log
n_writer --> n_log
@endumlИтог
Шесть правил backpressure.
1) Если нагрузка выше 1, очередь растёт на (вход − выход) каждую секунду: считайте, а не надейтесь. 2) У каждого буфера есть предел, выбранный по допустимой задержке. 3) Решите, что делать при заполнении: block, drop newest, drop oldest или sample, и считайте выброшенное. 4) Отказывайте быстрым 429 с Retry-After; клиенты хранят данные и повторяют с jitter. 5) Пусть потребители забирают сами, бэклог лежит в надёжном логе, а алерт стоит на consumer lag. 6) Передавайте сигнал вверх по приоритету и ограничивайте concurrency на входе, чтобы отказ был дешёвым.
Показатели: в начале и в конце
| Показатель | В начале | В конце |
|---|---|---|
| Память API | 40 МБ | 60 МБ |
| Задержка события | 0,5 с | 1 с |
| Потеряно событий | 0 | 0 |
| Отклонено событий | 0% | 0% |
Шаги
- Кейс События попадают в память, writer их разбирает
SDK приложения собирает события и отправляет их пачками до 50 штук.
- Проблема База замедляется, буфер растёт
В 19:00 запускается ночная перестройка индекса, и writer'ы падают до 800 событий в секунду.
- Проблема API падает с 1,8 миллиона подтверждённых событий
В 20:16 контейнер API упирается в лимит 2 GiB и убивается.
- Решение У буфера появляется предел: при заполнении ждать
Теперь в буфере не больше 50 000 событий: около 50 МБ и никогда больше.
- Решение Когда полон: ждать, выбросить или сэмплировать
Ожидание — один ответ, но не единственный.
- Решение Сброс нагрузки: быстрое «нет» с Retry-After
Ждущие запросы всё равно держат соединение и поток.
- Решение Надёжный лог и writer'ы, которые сами забирают
Вместо буфера в памяти теперь лог событий на диске с тремя репликами.
- Решение Задержка поднимается по цепочке, с приоритетами
API каждые 5 секунд читает consumer lag.
- Решение Concurrency limit на входе
Последний страж — в самом API.
- Итоги Итог
Шесть правил backpressure.
Термины
- Backpressure (обратное давление)
- Торможение продюсера, когда потребители не успевают. Очередь ограничена, и вместо бесконечного роста продюсер ждёт.
- Ограниченная очередь (bounded queue)
- Очередь с заранее заданной ёмкостью. Что делать при заполнении (ждать, выбросить новое или старое) решает явное правило, и память не растёт бесконечно.
- Consumer lag (отставание потребителя)
- Насколько потребитель отстаёт от конца лога, в записях или секундах. Самый честный сигнал перегрузки: алерт ставят на него, а не на CPU.
- Retry-After
- Заголовок в ответе 429 или 503: через сколько секунд клиенту вернуться. Клиент ждёт это время плюс случайный jitter и сохраняет свои данные.
- Admission control (контроль допуска)
- Решение на входе, какой запрос принять, а какой сразу отклонить: по лимиту одновременных запросов и приоритетам. Быстрый отказ дёшев, ожидание в очереди дорого.
- Pull-модель потока
- Потребитель сам просит следующую порцию, только закончив предыдущую (poll, request(n), окно TCP). Темп задаёт получатель, а не производитель.