mufassall

Шпаргалка · Надёжность

Backpressure

14 мин · Средний · mufassall.dtwin.uz/ru/l/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, который отказывает быстро, а не ставит в очередь
Итоговая сцена
60%70%20%

Диаграмма как код

Итоговая схема урока в виде текста: вставьте её в 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_log

Mermaid: последовательность запросов

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 s

D2

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_log

PlantUML: последовательность запросов

@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
@enduml

PlantUML: компоненты

@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 на входе, чтобы отказ был дешёвым.

Показатели: в начале и в конце

ПоказательВ началеВ конце
Память API40 МБ60 МБ
Задержка события0,5 с1 с
Потеряно событий00
Отклонено событий0%0%

Шаги

  1. Кейс События попадают в память, writer их разбирает

    SDK приложения собирает события и отправляет их пачками до 50 штук.

  2. Проблема База замедляется, буфер растёт

    В 19:00 запускается ночная перестройка индекса, и writer'ы падают до 800 событий в секунду.

  3. Проблема API падает с 1,8 миллиона подтверждённых событий

    В 20:16 контейнер API упирается в лимит 2 GiB и убивается.

  4. Решение У буфера появляется предел: при заполнении ждать

    Теперь в буфере не больше 50 000 событий: около 50 МБ и никогда больше.

  5. Решение Когда полон: ждать, выбросить или сэмплировать

    Ожидание — один ответ, но не единственный.

  6. Решение Сброс нагрузки: быстрое «нет» с Retry-After

    Ждущие запросы всё равно держат соединение и поток.

  7. Решение Надёжный лог и writer'ы, которые сами забирают

    Вместо буфера в памяти теперь лог событий на диске с тремя репликами.

  8. Решение Задержка поднимается по цепочке, с приоритетами

    API каждые 5 секунд читает consumer lag.

  9. Решение Concurrency limit на входе

    Последний страж — в самом API.

  10. Итоги Итог

    Шесть правил backpressure.

Термины

Backpressure (обратное давление)
Торможение продюсера, когда потребители не успевают. Очередь ограничена, и вместо бесконечного роста продюсер ждёт.
Ограниченная очередь (bounded queue)
Очередь с заранее заданной ёмкостью. Что делать при заполнении (ждать, выбросить новое или старое) решает явное правило, и память не растёт бесконечно.
Consumer lag (отставание потребителя)
Насколько потребитель отстаёт от конца лога, в записях или секундах. Самый честный сигнал перегрузки: алерт ставят на него, а не на CPU.
Retry-After
Заголовок в ответе 429 или 503: через сколько секунд клиенту вернуться. Клиент ждёт это время плюс случайный jitter и сохраняет свои данные.
Admission control (контроль допуска)
Решение на входе, какой запрос принять, а какой сразу отклонить: по лимиту одновременных запросов и приоритетам. Быстрый отказ дёшев, ожидание в очереди дорого.
Pull-модель потока
Потребитель сам просит следующую порцию, только закончив предыдущую (poll, request(n), окно TCP). Темп задаёт получатель, а не производитель.