Что происходит после нажатия кнопки «отправить»
Анатомия клика: что происходит после нажатия кнопки
Пользователь нажимает кнопку «Отправить» и через несколько секунд видит результат.
На экране это выглядит как одно простое действие. С технической точки зрения в этот момент может запускаться целая цепочка процессов:
Дополнительные операции могут выполняться асинхронно через очереди и фоновые сервисы.
В простой системе часть компонентов вообще отсутствует.
В крупной корпоративной платформе между кнопкой и базой данных могут находиться десятки отдельных сервисов.
Поэтому полезно разобраться не в конкретной технологии, а в самом принципе.
Предстоит ответить на ключевые вопросы:
- › Что именно происходит после клика?
- › Где формируется запрос?
- › Как браузер находит сервер?
- › Зачем нужен HTTPS?
- › Как запрос попадает в приложение?
- › Почему сервер иногда обращается к базе данных, а иногда отвечает из кэша?
- › Зачем нужны очереди?
- › И почему пользователь может получить ответ, хотя часть работы системы продолжается ещё несколько секунд или минут?
Начнём с простого сценария
Представим обычную корпоративную веб-систему.
Пользователь заполняет форму:
Компания: ООО «Пример»
Email: ivan@example.ru
и нажимает:
[ ОТПРАВИТЬ ]
Браузер должен превратить это действие в сетевой запрос.
Но даже эта схема сильно упрощена.
Между браузером и сервером ещё нужно установить сетевое соединение, определить адрес сервера, обеспечить шифрование и доставить запрос до нужного компонента инфраструктуры.
Шаг первый: браузер понимает, что произошло
Пользователь нажимает кнопку. Веб-приложение уже находится в браузере и содержит JavaScript-код, который определяет, что нужно сделать.
Например, при отправке формы приложение может сформировать запрос:
Content-Type: application/json
{
"name": "ООО «Пример»",
"email": "ivan@example.ru"
}
После нажатия кнопки браузер формирует структурированный HTTP-запрос к серверу. В нём указываются адрес API, метод запроса, необходимые заголовки и, если требуется, данные для обработки.
Важно понимать, что браузер сам по себе не знает бизнес-правил компании.
Он не решает:
- › можно ли создать такую запись;
- › имеет ли пользователь право это сделать;
- › существует ли уже такая компания;
- › можно ли изменить конкретное поле;
- › как сохранить данные;
- › какие дополнительные действия нужно выполнить.
Шаг второй: браузеру нужно найти сервер
Пользователь работает с адресом вроде:
https://portal.example.ru
Для установления соединения браузеру обычно необходимо получить IP-адрес сервера, соответствующий доменному имени. Эту задачу решает DNS — (Domain Name System). В зависимости от конфигурации имя может разрешаться в IPv4-адрес, IPv6-адрес или несколько адресов.
Это похоже на телефонную книгу: человек запоминает имя, а сеть использует соответствующий IP-адрес.
Но реальный процесс сложнее.
Браузер и операционная система могут уже иметь нужный адрес в кэше. Результат также может находиться на DNS-серверах промежуточных уровней.
> Поэтому DNS-запрос не обязательно каждый раз уходит куда-то далеко в интернет.
DNS не передаёт сам запрос приложения
Это важное различие.
DNS отвечает только на вопрос:
Он не передаёт данные формы.
После получения необходимой сетевой информации браузер может установить соединение с сервером. Для HTTPS требуется защищённое соединение, включающее согласование параметров TLS.
При этом новое соединение не обязательно устанавливается при каждом запросе: браузер может повторно использовать уже открытое соединение или применять другие механизмы, предусмотренные используемым протоколом.
Шаг третий: начинается HTTPS
Современные корпоративные системы практически всегда используют HTTPS. В основе HTTPS лежит HTTP поверх защищённого TLS-соединения.
При установлении HTTPS-соединения клиент и сервер согласуют параметры TLS и выполняют необходимые криптографические операции. После установления защищённого соединения HTTP-запросы и ответы передаются с шифрованием, которое защищает содержимое от чтения и незаметного изменения при передаче.
TLS также позволяет клиенту проверить подлинность сервера по его сертификату. При этом HTTPS не гарантирует безопасность самого приложения: уязвимости в коде, ошибки авторизации и компрометация конечного устройства остаются отдельными рисками.
Шаг четвёртый: запрос попадает не обязательно прямо в приложение
Очень распространённая архитектурная ошибка в представлении системы выглядит так:
Браузер → Сервер → Код приложения
В реальной системе между ними часто находятся дополнительные компоненты.
Зачем всё это?
Современная информационная система должна не только выполнять код, но и управлять нагрузкой, доступом и передачей запросов между компонентами.
- › выдерживать нагрузку;
- › контролировать доступ;
- › распределять запросы;
- › обеспечивать отказоустойчивость;
- › управлять трафиком.
Балансировщик распределяет нагрузку
Представим, что приложение работает на пяти экземплярах:
Пользователь не обязан знать, на каком именно сервере будет обработан его запрос. Балансировщик распределяет трафик между доступными экземплярами.
При корректной настройке балансировщик позволяет:
- › распределять запросы между экземплярами приложения;
- › добавлять новые экземпляры при росте нагрузки;
- › исключать из обслуживания недоступные экземпляры;
- › выполнять регламентное обслуживание отдельных узлов;
- › повышать доступность сервиса при отказе части инфраструктуры.
Сам по себе балансировщик не гарантирует отказоустойчивость: необходимо резервировать и другие критические компоненты, включая сетевую инфраструктуру и хранилища.
Шаг пятый: сервер проверяет, кто отправил запрос
До выполнения бизнес-операции серверу необходимо понять, кто находится по другую сторону соединения.
Если пользователь уже авторизован, браузер может передать соответствующие данные:
- › cookie;
- › session identifier;
- › access token;
- › другие механизмы идентификации.
Сервер извлекает информацию о пользователе и проверяет права.
Это два разных этапа проверки доступа.
Пользователь может быть успешно аутентифицирован, но всё равно не иметь права выполнить конкретную операцию.
Шаг шестой: API принимает запрос
Запрос поступает на серверную точку входа и передаётся обработчику приложения. API — это интерфейс и набор правил взаимодействия между компонентами системы: он определяет доступные операции, форматы данных и ожидаемое поведение при успехе или ошибке.
GET /api/orders/12345
PATCH /api/orders/12345
DELETE /api/orders/12345
Для каждой конечной точки API (endpoint) определён контракт взаимодействия. Он может описывать:
- › формат входных данных;
- › обязательные поля;
- › допустимые значения;
- › способ авторизации;
- › формат ответа;
- › возможные ошибки.
API — это не просто набор URL, а контракт, определяющий правила взаимодействия между компонентами системы.
Сервер сначала проверяет входные данные
Нельзя просто принять JSON от браузера и записать его в базу. Сервер должен проверить данные.
Но проверка формата — только один уровень.
Может оказаться, что:
- › пользователь не имеет права создавать запись;
- › такая запись уже существует;
- › связанный объект не существует;
- › операция запрещена текущим статусом;
- › значение противоречит бизнес-правилам.
Поэтому необходимо различать синтаксическую и структурную проверку данных, проверку прав доступа и бизнес-валидацию. Например, корректный JSON может содержать допустимые по формату значения, но запрос всё равно может нарушать бизнес-правила или быть запрещён текущим состоянием объекта.
После проверки начинается бизнес-логика
Допустим, пользователь создаёт заказ. Сервер может выполнить цепочку:
И вот здесь появляется база данных.
Шаг седьмой: сервер обращается к базе данных
Приложение редко хранит постоянные данные непосредственно в оперативной памяти. Ему нужна система хранения. Например:
- › PostgreSQL;
- › Microsoft SQL Server;
- › Oracle Database;
- › MySQL;
- › специализированные NoSQL-системы.
Допустим, сервер должен создать заказ. Он формирует запрос к базе данных:
VALUES (...);
База выполняет операцию и возвращает результат.
Но даже здесь всё не так просто. Для корпоративных систем критичны:
- › транзакции;
- › ограничения целостности;
- › индексы;
- › блокировки;
- › конкурентный доступ;
- › уровни изоляции;
- › резервное копирование;
- › восстановление;
- › репликация.
База данных — не просто место хранения записей. Она обеспечивает определённые гарантии целостности и согласованности данных, управляет конкурентным доступом и выполняет транзакции в соответствии с выбранными настройками.
Однако транзакция в одной базе данных не гарантирует атомарность всей распределённой бизнес-операции, если она затрагивает другие сервисы. Для таких сценариев требуются отдельные механизмы согласования и восстановления.
Почему приложение не должно просто доверять базе
Часть ограничений действительно может находиться на уровне базы данных. Например, уникальность определённого значения.
Но бизнес-правила обычно требуют более высокого уровня абстракции.
База данных может сохранить значение статуса, но допустимость самой операции должна проверяться бизнес-логикой приложения. Для обеспечения корректности используют несколько уровней защиты:
Каждый уровень отвечает за свою часть корректности.
А если данные уже есть?
Не каждый запрос требует записи в базу.
Например, пользователь открывает список заказов. Приложение может выполнить:
Серверная часть приложения проверяет права пользователя и затем получает данные.
В некоторых системах приложение может получить данные из кэша, не обращаясь к основной базе. Это снижает нагрузку, но требует контроля актуальности данных.
Это снижает нагрузку и ускоряет ответы, но требует заранее определить правила актуализации данных. Для информации, которая часто изменяется или влияет на критичные бизнес-операции, необходимо учитывать допустимую задержку обновления и последствия использования устаревшего значения.
Кэш позволяет не выполнять одну и ту же работу постоянно
Представим страницу, которую открывают тысячи пользователей. Если каждый запрос будет обращаться непосредственно к базе, это создаёт лишнюю нагрузку:
Кэш ускоряет доступ к часто используемой информации.
Но одновременно создаёт новую архитектурную проблему: насколько актуальны данные в кэше?
> Если информация изменилась в базе, кэш должен быть обновлён или инвалидирован.
Поэтому кэш — это не просто «ускоритель».
— Это ещё один источник состояния, которым нужно управлять.
Шаг восьмой: запрос может уйти в другие сервисы
Современная система редко состоит из одного backend-приложения. Например, при создании заказа основная система может обратиться к:
- › сервису клиентов;
- › сервису расчёта стоимости;
- › сервису складских остатков;
- › сервису платежей;
- › сервису уведомлений;
- › системе управления производством.
Здесь возникает вопрос: обязательно ли ждать завершения всех операций?
Не всегда.
Если операция не нужна для немедленного ответа пользователю и допускает задержку, её можно вынести в фоновую обработку. Для этого применяют очереди сообщений и другие механизмы асинхронного взаимодействия.
Однако операции, от которых зависит корректность основного результата, нельзя просто отложить без определения гарантий выполнения и обработки ошибок.
Что можно выполнить сразу, а что — потом
Представим, что пользователь отправил заказ.
Для ответа ему необходимо:
- › проверить данные;
- › создать заказ;
- › вернуть номер заказа.
Но после этого системе ещё нужно:
- › отправить email;
- › сформировать документ;
- › уведомить склад;
- › записать событие в аналитическую систему;
- › обновить поисковый индекс.
Необязательно заставлять пользователя ждать завершения всех этих операций. Можно разделить процесс.
Зачем нужна очередь
Очередь позволяет отделить момент возникновения события от момента его обработки.
Например:
Событие означает: заказ создан. Один сервис может отправить его в очередь. Другой сервис обработает событие позже.
Это даёт несколько преимуществ:
- › отправитель и получатель могут работать независимо друг от друга;
- › очередь помогает сглаживать пики нагрузки;
- › временная недоступность потребителя не обязательно останавливает основной процесс;
- › неудачную обработку можно повторить;
- › несколько потребителей могут обрабатывать одно событие для разных задач.
Конкретные гарантии доставки, порядок обработки и сохранность сообщений зависят от брокера, его конфигурации и логики приложения.
Но очереди тоже не являются бесплатной магией.
Появляются новые вопросы:
- › что делать с неуспешной обработкой;
- › сколько раз повторять;
- › как избежать дублей;
- › где хранить невалидные сообщения;
- › гарантируется ли порядок;
- › что делать при повторной доставке.
Поэтому асинхронная архитектура требует продуманной модели обработки ошибок.
Пользователь может уже получить ответ, хотя система ещё работает
Допустим, пользователь видит:
Но это не обязательно означает, что абсолютно всё, связанное с заказом, уже завершено.
Поэтому в современных системах нужно различать:
Это позволяет строить более производительные и устойчивые системы.
А что происходит, если что-то пошло не так?
Теперь представим другой сценарий. Пользователь нажал «Отправить». Браузер отправил запрос. API его получил. Данные прошли проверку.
Но база данных оказалась временно недоступна.
Система должна корректно обработать сбой и сообщить пользователю, что произошло и удалось ли выполнить операцию:
без дополнительной информации и без понимания, было ли действие выполнено.
В зависимости от этапа сбоя возможны разные ситуации:
- › операция не началась;
- › операция завершилась, но ответ потерялся;
- › часть действий выполнена, а остальные завершились ошибкой;
- › запрос принят в очередь, но ещё не обработан;
- › результат операции пока невозможно достоверно определить.
В последнем случае опасно автоматически выполнять действие повторно: сначала необходимо установить его фактический статус или использовать механизм, исключающий повторное выполнение одной и той же бизнес-операции.
Почему повторный запрос может быть опасен
Представим кнопку:
«Оплатить»
Пользователь нажал её. Запрос ушёл на сервер. Платёжная система обработала операцию. Но ответ от сервера не дошёл до браузера.
Пользователь видит ошибку:
Он нажимает кнопку ещё раз.
Если система не умеет распознавать повтор одной и той же бизнес-операции, возможны дублирование заказа или повторное списание средств.
Для защиты применяют идемпотентность и ключи идемпотентности. Сервер сохраняет результат обработки ключа и при повторном запросе возвращает ранее полученный результат, не выполняя операцию заново. Важно, чтобы проверка ключа и фиксация результата были организованы с учётом конкурентных запросов и требований к хранению данных.
Для платежей, создания заказов и других важных операций защита от повторного выполнения особенно важна.
Что происходит с ответом
Когда сервер завершил синхронную часть обработки, он формирует HTTP-ответ. Например:
Content-Type: application/json
{
"id": 45821,
"status": "created"
}
Ответ проходит обратно через сетевую инфраструктуру к браузеру.
Браузер получает ответ и передаёт данные интерфейсу. JavaScript может изменить состояние страницы. Пользователь видит:
Почему ответ иногда приходит мгновенно, а иногда через несколько секунд
Время ответа складывается из множества компонентов.
Если один из этапов начинает работать медленно, пользователь может почувствовать задержку. Причём причина далеко не всегда находится в коде интерфейса.
Медленный экран может быть следствием:
- › медленного SQL-запроса;
- › отсутствующего индекса;
- › перегруженного API;
- › задержки внешнего сервиса;
- › блокировки в базе;
- › сетевой проблемы;
- › нехватки ресурсов;
- › проблем с кэшем.
Поэтому при диагностике производительности необходимо проверять всю цепочку обработки запроса, а не только работу браузера.
Как инженеры вообще понимают, где произошла проблема
Для этого используются журналы, метрики и распределённая трассировка. Например, одному пользовательскому запросу присваивается идентификатор:
Этот идентификатор может проходить через несколько компонентов:
Если пользователь говорит:
инженер может посмотреть трассировку и увидеть конкретные задержки:
Order Service 110 ms
Database 80 ms
Payment Service 120 ms
Notification 7 400 ms
Эти значения иллюстрируют возможный результат трассировки. Их нельзя автоматически складывать и считать общим временем запроса: часть операций может выполняться параллельно, а длительность родительского участка может включать время вложенных вызовов.
Если уведомление выполняется асинхронно после отправки ответа пользователю, его задержка не обязательно увеличивает время ожидания на странице. Если же приложение ожидает завершения уведомления перед возвратом ответа, задержка может напрямую повлиять на время отклика.
Это особенно важно в распределённых корпоративных системах.
Современная система — это не один сервер
Для небольшого приложения схема действительно может быть очень простой:
Браузер → Backend → Database
И этого может быть достаточно. Но по мере роста требований архитектура усложняется:
Это не означает, что «хорошая архитектура должна быть сложной». Наоборот.
Сложность должна появляться только там, где она решает конкретную проблему.
> Если небольшой системе не нужны очереди, десятки микросервисов и отдельный API Gateway, добавлять их ради архитектурной моды бессмысленно.
Один клик не всегда означает один запрос
Современный интерфейс может инициировать сразу несколько сетевых операций.
Например, пользователь открывает карточку заказа. Браузер может одновременно запросить:
GET /api/order/45821/items
GET /api/order/45821/history
GET /api/order/45821/documents
GET /api/user/permissions
На экране пользователь видит одну страницу. Но технически она собирается из нескольких источников.
Если один запрос должен завершиться до запуска пяти других, задержка первого может увеличить время загрузки всей страницы.
А иногда браузер вообще не ждёт обычный HTTP-ответ
Для некоторых сценариев нужен поток данных от сервера к клиенту.
Например:
- › онлайн-уведомления;
- › статусы выполнения задач;
- › чаты;
- › мониторинг оборудования;
- › оперативные панели.
Здесь могут использоваться механизмы вроде WebSocket или Server-Sent Events.
Тогда сервер может самостоятельно сообщить браузеру:
без необходимости постоянно обновлять страницу и отправлять новые запросы.
Что происходит в корпоративной системе
В enterprise-среде путь запроса обычно ещё сложнее.
Например, сотрудник создаёт заявку. Цепочка может выглядеть так:
Пользователь по-прежнему видит одну кнопку.
Но за ней уже находится распределённая информационная система.
И чем больше компонентов участвует в операции, тем важнее становятся:
- › наблюдаемость;
- › управление ошибками;
- › контроль доступа;
- › трассировка;
- › идемпотентность;
- › управление зависимостями;
- › мониторинг производительности.
Самое важное — не технология, а границы ответственности
Конкретный технологический стек может быть разным. Можно выбрать любой подход к реализации:
- › Можно построить систему на монолите.
- › Можно использовать микросервисы.
- › Можно использовать PostgreSQL, Oracle или другую СУБД.
- › Можно применять Kafka, RabbitMQ или иной механизм очередей.
Но независимо от технологий остаются одни и те же вопросы:
- › кто принимает запрос?
- › кто проверяет права?
- › кто отвечает за бизнес-правила?
- › кто владеет данными?
- › какие операции выполняются синхронно?
- › какие можно вынести в фон?
- › что происходит при ошибке?
- › как система понимает, что запрос уже был обработан?
- › как инженер найдёт проблемный участок?
Именно ответы на эти вопросы формируют архитектуру.
Полный путь одного запроса
Теперь можно собрать всё в одну сквозную схему:
Конкретная система может выглядеть совершенно иначе.
Но эта схема хорошо показывает главное:
нажатие кнопки — это только начало цепочки.
Где чаще всего скрывается реальная сложность
При оценке информационной системы недостаточно учитывать только пользовательские экраны.
Пользователь видит:
форму → кнопку → результат.
Инженер должен видеть:
Именно поэтому изменение одного пользовательского действия иногда требует изменений сразу в нескольких компонентах.
Например, добавление нового поля в форму может означать:
- › изменение frontend;
- › изменение API-контракта;
- › изменение бизнес-логики;
- › изменение схемы базы;
- › изменение интеграции;
- › изменение сообщений очереди;
- › изменение аналитики;
- › изменение аудита;
- › обновление документации.
Почему понимание этого пути важно бизнесу
Знание внутренней механики системы нужно не только разработчикам.
Для руководителя проекта и владельца продукта понимание этой цепочки помогает реалистично оценивать стоимость, сроки и риски изменений.
То же самое касается производительности. Если пользователи жалуются на «медленную систему», вопрос должен звучать не:
а:
— «На каком участке цепочки возникает задержка?»
Такой подход позволяет принимать технические решения с учётом реальных причин задержек и устройства системы.
От кнопки до результата — это цепочка ответственности
После нажатия «Отправить» не происходит одного большого действия под названием «сервер обработал запрос».
Происходит последовательность.
- › Браузер формирует запрос.
- › DNS помогает найти нужный адрес.
- › HTTPS создаёт защищённый канал.
- › Сетевая инфраструктура доставляет запрос до нужного компонента.
- › Система идентифицирует пользователя и проверяет права.
- › API принимает данные.
- › Backend выполняет бизнес-логику.
- › Приложение обращается к базе, кэшу или другим сервисам.
- › Часть операций может быть вынесена в очередь.
- › Фоновые процессы продолжают работу после того, как пользователь уже получил ответ.
- › А вся цепочка должна быть наблюдаемой, чтобы при проблеме можно было определить, где именно она возникла.
Поэтому современная информационная система — это не просто интерфейс и сервер. Это цепочка взаимосвязанных компонентов, каждый из которых выполняет свою часть работы.
Чем сложнее система, тем важнее определить ответственность каждого компонента, правила взаимодействия, обработку ошибок и путь данных от пользователя до результата.
Что происходит с заявкой после формы на сайте
Когда API есть, а интеграция всё равно не работает
Мониторинг — это не просто «сервер работает»
Все инженерные материалы и экспертные статьи
Полный алфавитный справочник ИТ-терминов