Api, webhook или очередь сообщений?
Что выбрать для обмена данными между системами
Когда в компании появляется несколько информационных систем, возникает необходимость наладить обмен данными между ними.
CRM должна передавать заявку в ERP. Сайт — отправлять заказ в учётную систему. Складская система — сообщать о движении товара. Внешний сервис — уведомлять внутреннюю систему об изменении статуса.
На этом этапе возникает вопрос: использовать API, webhook или очередь сообщений?
Эти три механизма нередко сравнивают так, будто они конкурируют друг с другом. На практике они решают разные задачи.
«Как одна система может запросить данные или выполнить операцию в другой системе?»
«Как система может сама сообщить другой системе, что что-то произошло?»
«Как передать событие или задачу, чтобы её можно было обработать независимо от отправителя?»
По мере усложнения архитектуры важно определить, как именно системы должны обмениваться данными, и только после этого выбирать технологии.
API, webhook и очередь сообщений можно использовать вместе
В проектах эти механизмы часто используют одновременно.
Например, интернет-магазин может работать примерно так:
API, webhook и очередь сообщений здесь выполняют разные задачи в рамках одной интеграции.
Поэтому вопрос «API или webhook?» не всегда корректен: эти механизмы могут дополнять друг друга.
API: когда системе нужно обратиться к другой системе
API позволяет одной системе обращаться к другой за данными или для выполнения операции.
Одна система делает запрос другой:
Например, внутренняя система хочет узнать текущий статус заказа.
Она отправляет запрос: «Дай мне заказ № 123».
Вторая система отвечает: «Заказ № 123 имеет статус „Отгружен“».
Такой подход подходит, когда вызывающей системе нужен ответ на запрос.
[ API_USE_CASES ]
- › получения данных;
- › создания объектов;
- › изменения объектов;
- › проверки состояния;
- › выполнения конкретных операций;
- › синхронного взаимодействия между системами.
Например, при открытии карточки клиента интерфейс может запросить актуальные данные через API. Отправлять такой запрос в очередь нет смысла, если пользователь должен сразу увидеть ответ.
Что происходит, если другая система недоступна
При синхронном вызове системе A нужен ответ от системы B, поэтому недоступность B может помешать выполнению операции.
Если A делает запрос к B, а B недоступна, A получает ошибку или вынуждена ждать. Для простой интеграции это обычно не проблема. Сложности возникают, когда для выполнения одной операции требуется последовательный ответ от нескольких систем.
Если каждая операция ждёт следующую, временная проблема одного сервиса начинает распространяться дальше по цепочке. В таких случаях стоит рассмотреть асинхронную обработку отдельных этапов.
Webhook: уведомление о событии без постоянных запросов
Webhook работает наоборот.
A → B: А сейчас?
A → B: А теперь?
A → B: А сейчас?
A → B: А теперь?
Допустим, платёжный сервис изменил статус платежа. Вместо периодических запросов о статусе заказа платёжный сервис может отправить webhook, когда статус изменится.
[ ПРИМЕНЕНИЕ WEBHOOK ДЛЯ СОБЫТИЙ ]
- › заказ создан;
- › платёж подтверждён;
- › документ изменён;
- › клиент зарегистрирован;
- › задача завершена;
- › статус доставки изменился;
- › файл готов;
- › операция завершилась.
Webhook — это уведомление о событии, которое обычно передаётся HTTP-запросом. Для надёжной доставки нужно предусмотреть повторные попытки, обработку тайм-аутов, проверку подлинности запроса, защиту от дубликатов и контроль ошибок доставки.
И здесь важно не путать webhook с полноценной очередью сообщений.
Почему webhook сам по себе не гарантирует надёжность
Это одна из распространённых ошибок проектирования.
Разработчик принимает webhook через метод POST /webhook и сразу внутри этого HTTP-запроса начинает выполнять тяжёлые операции:
- ✕ проверять данные;
- ✕ обращаться к CRM;
- ✕ обращаться к ERP;
- ✕ создавать документы;
- ✕ отправлять письма;
- ✕ обновлять склад;
- ✕ рассчитывать показатели.
На тестовом стенде всё прекрасно.
А потом внешний сервис присылает несколько сотен событий подряд. И внезапно webhook становится не просто уведомлением, а точкой входа для огромного количества работы. Если обработчик отвечает слишком долго или завершается с ошибкой, отправитель может повторить доставку. Это создаёт риск дублирования операций и увеличивает нагрузку.
Поэтому хороший webhook-контур часто выглядит иначе:
Обработчик webhook может проверять запрос и сохранять событие в очереди. Подтверждать приём следует после сохранения сообщения, если этого требует протокол взаимодействия с отправителем.
После сохранения сообщения его обрабатывает отдельный потребитель. Это позволяет быстрее отвечать на webhook-запросы и сохранять принятые события при временной недоступности внутренних систем.
Очередь сообщений: как отделить отправку от обработки
Очередь позволяет отделить отправку задачи от её обработки.
Представим склад. ERP сообщает: «Создано задание на отгрузку». ERP не обязательно ждать завершения обработки складской системой. Можно передать сообщение в очередь:
Теперь системы становятся менее связаны между собой.
ERP сообщает о событии и продолжает свою работу. Потребители получают сообщение и обрабатывают его тогда, когда готовы.
[ QUEUE_BENEFITS ]
- › сообщений много;
- › обработка занимает время;
- › системы работают с разной скоростью;
- › временная недоступность потребителя допустима;
- › нужны повторные попытки;
- › одно событие должны обработать несколько систем;
- › необходимо сохранять сообщения при временной недоступности потребителя;
- › нужно сгладить резкие пики нагрузки.
Чем отличаются API, webhook и очередь сообщений
Кратко:
«Дай данные / выполни операцию»
«У меня произошло событие»
«Вот сообщение, обработай его»
Но одной этой таблицы недостаточно для проектирования. Потому что вопрос обычно не звучит так: «Какую технологию выбрать?»
Он звучит так: «Что должно произойти, если одна система сейчас недоступна?» Это один из основных вопросов при проектировании интеграции.
Что произойдёт, если система-получатель станет недоступна?
Допустим, CRM должна передать заказ в ERP.
└───► ERP недоступна
└───► ERROR
Дальше нужно самостоятельно решать:
- • повторять запрос;
- • сколько раз и через какой интервал;
- • как определить, что операция всё-таки прошла;
- • что делать при таймауте и как избежать двойного создания заказа.
Сам по себе API не гарантирует доставку и выполнение операции при сбоях.
└───► ERP недоступна
└───► сообщение сохраняется в очереди
└───► ERP восстанавливается
└───► потребитель повторяет обработку
В этом случае сообщение может оставаться в очереди до восстановления потребителя.
Такой подход работает, если брокер сохраняет сообщения до подтверждения обработки, а потребитель отправляет подтверждение только после фиксации результата. Если подтверждать сообщение раньше времени, сбой может привести к потере операции. Если подтверждение не дойдёт до брокера, сообщение может быть доставлено повторно. Поэтому потребитель должен уметь распознавать дубликаты.
Когда очередь не нужна
Использовать очередь для всех операций подряд не стоит: некоторым запросам нужен немедленный ответ.
Если пользователю нужно открыть карточку клиента и получить актуальные данные, очередь может быть совершенно неуместна. Пользователь открывает карточку и ожидает увидеть данные сразу.
Очередь нужна, когда операцию можно выполнить асинхронно и не требуется немедленно возвращать её результат пользователю.
Как меняется интеграция при росте числа систем
На маленьком проекте интеграция часто выглядит очень просто: CRM ↔ API ↔ ERP. И это нормально. Не нужно строить распределённую систему из десятка компонентов только потому, что это технически возможно.
По мере развития проекта к интеграции могут подключаться новые системы:
- › ещё одна CRM;
- › мобильное приложение;
- › склад и сайт;
- › платёжная система;
- › служба доставки;
- › аналитика;
- › документооборот;
- › несколько внешних API.
По мере увеличения числа прямых интеграций схема взаимодействия усложняется. Если каждая система связывается со многими другими, возникает так называемая архитектура «спагетти»:
Как событийная архитектура упрощает обмен данными
Вместо прямых связей между всеми системами можно использовать общий механизм передачи событий.
Источник публикует событие, например OrderCreated, а потребители независимо решают, какие действия выполнить. Сообщение должно содержать достаточно данных для предусмотренного сценария либо идентификатор объекта, по которому потребитель может получить необходимые сведения через API.
Такая модель уменьшает прямую связанность систем, но требует согласованного формата событий, правил версионирования и понятной семантики повторной обработки.
Но у неё неизбежно появляется собственная инженерная сложность:
- › структура событий;
- › версии сообщений;
- › идемпотентность;
- › порядок событий;
- › повторная доставка;
- › дедупликация;
- › обработка ошибок;
- › мониторинг;
- › dead-letter queue;
- › трассировка операций.
Именно поэтому переход от простого API к очередям — это не просто подключение ещё одного сервиса.
Меняется сама архитектурная модель.
Идемпотентность: как избежать повторного выполнения операции
Представим, что система получила сообщение: «Создать документ № 123». Обработала его. Но ответ потерялся. Отправитель решил повторить сообщение.
Если обработчик просто выполнит операцию ещё раз, мы получим второй документ.
Поэтому в распределённых системах нужно заранее понимать:
Что произойдёт, если одно и то же сообщение придёт дважды?
Обработчик должен корректно обрабатывать повторно доставленные сообщения, не выполняя одну бизнес-операцию дважды.
Каждому событию можно присвоить уникальный идентификатор:
Обработчик проверяет идентификатор события по журналу уже обработанных сообщений. Проверка и фиксация результата должны быть организованы так, чтобы параллельные экземпляры обработчика не выполнили одну операцию дважды. Для этого используют, например, уникальное ограничение на идентификатор события и транзакционную фиксацию вместе с бизнес-изменением, если они выполняются в одной базе данных.
На практике именно такие детали требуют дополнительной разработки и тестирования, хотя на архитектурной схеме их обычно не видно.
Что делать, если события приходят не по порядку
Например, события могут прийти в таком порядке:
Сначала пришло:
а затем — более старое событие:
Что должна сделать система?
Решение зависит от того, что означает каждое сообщение: изменение состояния объекта или отдельное бизнес-событие. Если каждое событие описывает новое состояние объекта, обработчик должен уметь распознавать устаревшие версии и не перезаписывать ими более актуальное состояние. Если события описывают отдельные бизнес-факты, их нельзя просто отбрасывать по времени: необходимо учитывать допустимые переходы состояния и порядок, требуемый конкретным процессом.
[ ARCHITECTURAL_CHECKLIST ]
- › гарантируется ли порядок сообщений;
- › кем гарантируется;
- › для какого конкретно ключа;
- › что происходит при повторной доставке;
- › может ли сообщение задержаться;
- › что делать с устаревшим состоянием.
Поэтому при выборе очереди нужно отдельно определить правила порядка обработки и работы с устаревшими событиями.
Как выбрать способ обмена данными
Начинать лучше не с технологии.
Сначала нужно описать сам сценарий обмена.
Если системе нужен ответ прямо сейчас
Используйте API.
- • Получить карточку клиента.
- • Проверить наличие товара.
- • Создать заявку.
- • Получить текущий статус.
Если нужно сообщить другой системе о событии
Используйте webhook.
- • Платёж подтверждён.
- • Заказ изменил статус.
- • Документ подписан.
- • Новый клиент зарегистрирован.
Если обработку можно отделить от события
Используйте очередь сообщений.
- • Обработать 50 000 записей.
- • Передать задания нескольким потребителям.
- • Обработать событие с повторной доставкой.
- • Продолжать приём сообщений, пока недоступен потребитель, если очередь и инфраструктура настроены соответствующим образом.
Как API, webhook и очередь работают вместе
В одной интеграции разные механизмы часто используют для разных задач.
Она редко строится на утверждениях вроде: «У нас всё на API» или «Мы всё сделали через Kafka». Например, API используют для запросов, webhook — для уведомлений, а очередь — для отложенной обработки сообщений.
Применяется строго для **синхронных операций**, когда ответ нужен инициатору здесь и сейчас.
Используется для **получения уведомлений о событиях** от внешних сервисов без постоянного опроса. Фактическая задержка зависит от отправителя, сети и обработки на стороне получателя.
Используется для **тяжёлой, фоновой** или асинхронной обработки, когда требуется отделить отправку от выполнения, сгладить пики нагрузки и предусмотреть восстановление после сбоев.
При этом внутри одного и того же сквозного бизнес-сценария они могут последовательно работать вместе:
Такой подход позволяет использовать каждый механизм для подходящих ему задач.
Когда достаточно простого API
Не стоит внедрять дополнительную инфраструктуру, пока для неё нет конкретной задачи.
Если компания обменивается данными между двумя системами с небольшой нагрузкой и понятными правилами обработки, API может быть достаточно. Необязательно сразу внедрять брокер сообщений, десяток микросервисов, event bus и сложную систему мониторинга. Архитектура должна соответствовать нагрузке и требованиям бизнеса.
Дополнительную инфраструктуру нужно не только внедрить, но и сопровождать:
- › её нужно разрабатывать;
- › тестировать;
- › мониторить;
- › документировать;
- › обновлять;
- › поддерживать;
- › объяснять новым разработчикам.
Поэтому очередь не является «более взрослым» вариантом API.
Это другой инструмент для другой задачи.
Что нужно определить перед интеграцией систем
Когда проектируем обмен между несколькими системами, недостаточно спросить: «Есть ли у этой системы API?» Мы смотрим глубже:
Какая система хранит актуальные данные?
Где действительно хранится актуальное состояние объекта?
Кто инициирует действие?
Пользователь, внутренняя система или внешний сервис?
Нужен ли ответ немедленно?
Если да, обычно подходит синхронный запрос к API.
Что произойдёт при недоступности системы?
Можно ли повторить операцию позже?
Можно ли потерять событие?
Нужно определить, какие события допустимо потерять, а какие требуют гарантированного сохранения и повторной обработки.
Допустима ли повторная доставка?
Если сообщение придёт дважды, система должна корректно это пережить.
Какой объём и интенсивность обмена?
Десять сообщений в минуту и сто тысяч сообщений в минуту — разные архитектурные задачи.
Сколько систем будет потреблять событие?
Если один источник должен уведомлять пять систем, событийная модель может оказаться естественнее множества вызовов.
Как будет происходить мониторинг?
Нужно отслеживать, было ли сообщение доставлено, обработано или завершилось ошибкой.
Что произойдёт при ошибке?
Заранее определите, когда повторять обработку, когда откладывать сообщение, когда передавать его в dead-letter queue и в каких случаях требуется вмешательство оператора.
Сначала сценарий обмена, затем технология
Выбор брокера, настройка webhook и проектирование API не решат проблему, если заранее не определены правила обмена данными между системами.
Две системы постоянно спорят о том, какая из них владеет определёнными данными.
Сам по себе брокер сообщений эту проблему не решит.
Система получает один и тот же заказ из трёх источников и не умеет определить, что это один заказ.
В этом случае нужно решить задачу идентификации заказов и устранения дубликатов, а не менять способ передачи данных.
Бизнес ожидает, что изменение в одной системе появится в другой мгновенно, хотя вся архитектура построена асинхронно.
Тогда проблема уже в согласовании требований и модели данных.
Поэтому интеграцию лучше начинать не с вопроса: «Какой протокол использовать?»
а с вопроса: «Что именно должно произойти между этими системами и что должно произойти, если что-то пойдёт не по плану?»
Итог
API, webhook и очередь сообщений — не три версии одного и того же инструмента.
- › API предоставляет программный интерфейс для получения данных и выполнения операций. Он часто используется для синхронных запросов, когда вызывающей системе нужен немедленный ответ, но сам по себе API не исключает асинхронные операции: например, запрос может запускать фоновую задачу и возвращать её идентификатор для последующей проверки статуса.
- › Webhook удобен, когда система должна сообщить другой системе о произошедшем событии в формате push-уведомления.
- › Очередь сообщений нужна, когда отправку события важно отделить от его обработки, сглаживать пики нагрузки и допускать временную недоступность потребителей. Возможность надёжно переживать такие сбои зависит от настроек хранения сообщений, подтверждений обработки, повторных попыток и механизма восстановления после ошибок.
В простом проекте вполне может хватить API.
В более сложной системе webhook может стать входом в очередь.
Очередь позволяет передавать сообщения нескольким независимым потребителям.
Поэтому правильная архитектура часто выглядит не как выбор одного конкретного протокола, а как осознанное использование каждого механизма там, где он действительно нужен.
По мере роста числа систем важно учитывать, насколько сильно они зависят друг от друга и как сбой одного компонента повлияет на остальные.
Хорошая интеграция — это не просто когда системы технически умеют обмениваться данными.
Хорошая интеграция — когда они могут обмениваться данными предсказуемо, контролируемо и без превращения одной временной ошибки в полную остановку всего процесса.
Почему интеграции между системами ломаются
Когда API есть, а интеграция всё равно не работает
Как синхронизировать данные между системами
Все инженерные материалы и экспертные статьи
Полный алфавитный справочник ИТ-терминов