Какие техники и паттерны используются для снижения сетевой нагрузки и количества запросов в бэкенд-системах?

Question

Какие техники и паттерны используются для снижения сетевой нагрузки и количества запросов в бэкенд-системах?

Тип вопроса: Архитектура Вероятность: 10% Категория: Golang Разработчик

Ответ

Для снижения сетевой нагрузки и уменьшения числа запросов применяются различные подходы на уровне кода, архитектуры и протоколов.

На уровне приложения и кода:

Кеширование (Caching): Хранение часто запрашиваемых данных в быстрой памяти (In-memory кеш, Redis, Memcached) для избежания повторных обращений к медленным источникам (БД, внешние API).
Пул соединений (Connection Pooling): Переиспользование установленных сетевых соединений (например, к базе данных) вместо создания новых на каждый запрос. Это значительно снижает задержки, связанные с TCP и TLS хендшейками. В Go database/sql делает это автоматически.
Пакетная обработка (Batching): Объединение множества мелких операций в один крупный запрос. Например, вместо 100 отдельных INSERT выполнить один INSERT со 100 строками.
Ограничение частоты запросов (Rate Limiting): Защита сервиса от перегрузки путем ограничения количества запросов от одного клиента за определенный промежуток времени. В Go для этого есть отличная библиотека golang.org/x/time/rate.
```
import "golang.org/x/time/rate"
import "time"

limiter := rate.NewLimiter(rate.Every(time.Second), 10) // 10 запросов в секунду
if !limiter.Allow() {
    // Ответить ошибкой 429 Too Many Requests
}
```

На уровне архитектуры и протоколов:

GraphQL: Позволяет клиенту запрашивать только те данные, которые ему нужны, одним запросом. Это решает проблему избыточной (over-fetching) и недостаточной (under-fetching) выборки данных, характерную для REST API.
gRPC: Фреймворк для удаленного вызова процедур, использующий HTTP/2 и Protocol Buffers. Бинарный формат Protobuf гораздо компактнее JSON, а HTTP/2 поддерживает мультиплексирование запросов через одно TCP-соединение, что снижает накладные расходы.
WebSockets или Server-Sent Events (SSE): Для real-time коммуникаций используются постоянные соединения. Это избавляет от необходимости постоянно опрашивать сервер на наличие обновлений (polling), что резко снижает количество HTTP-запросов.

Ответ 18+ 🔞

Ах ты ж ёпта, ну и тема! Снизить нагрузку на сеть, чтобы серваки не легли как мудаки после корпоратива. Слушай, тут целая наука, но если по-простому, то вот как умные дядьки выкручиваются.

В самом коде, прямо в лоб:

Кеширование, блядь. Это святое! Зачем каждый раз тащить одно и то же из базы, если можно припрятать рядом, в оперативке? Redis, Memcached — это твои новые лучшие друзья. Получил данные раз — положил в кеш. Следующий чувак пришёл — хвать из кеша, и база даже не вспотела. Красота.
Пул соединений. Представь, ты каждый раз, чтобы сказать «привет» базе данных, заново знакомишься, пожимаешь руку (TCP), предъявляешь паспорт (TLS). Заебёшься. Умные библиотеки (в Go database/sql сам так делает) держат кучу готовых, разогретых соединений в пуле. Пришёл — взял из пула, поболтал — вернул обратно. Никакой волокиты, ебать.
Пакетная обработка. Это когда вместо того, чтобы сто раз сходить на кухню за одной пельмешкой, ты берёшь тарелку и накладываёшь сразу сто. С базой так же: вместо 100 мелких INSERT — один здоровенный, да похуй, со всеми строками сразу. Эффективность зашкаливает, ядрёна вошь!
Rate Limiting, или «Успокойся, мудила». Чтобы какой-нибудь бот или слишком активный пользователь не положил твой сервис, ему вежливо говорят: «Не больше N запросов в секунду, окей?». В Go есть отличная штука golang.org/x/time/rate. Настроил лимитер — и спи спокойно.
```
import "golang.org/x/time/rate"
import "time"

limiter := rate.NewLimiter(rate.Every(time.Second), 10) // 10 запросов в секунду
if !limiter.Allow() {
    // Отправляешь ему в ответ 429 и идешь пить чай
}
```

А есть ещё по-крупному, на уровне всей архитектуры:

GraphQL. Это когда клиент, задолбавшись получать от REST API то слишком много, то слишком мало данных, говорит: «Знаешь что? Я сам скажу, что мне нужно». И одним запросом выгребает ровно те поля, которые ему нужны. Ничего лишнего. Элегантно, сука.
gRPC. Вот это уже серьёзная движуха. Вместо тяжёлого JSON'а — лёгкие бинарные Protobuf. Вместо кучи отдельных HTTP/1.1 соединений — одно HTTP/2, по которому одновременно летает куча запросов и ответов (мультиплексирование, ёпта!). Скорость и экономия — просто овердохуища.
WebSockets или SSE. Это для тех, кому надо «онлайн». Вместо того чтобы клиент каждую секунду дёргал сервер вопросом «Ну чё там новенького?» (это polling, долбоёбство редкостное), он устанавливает одно долгосрочное соединение. Сервер сам, когда есть что сказать, подходит и шепчет на ушко. Запросов — ноль, счастья — море.

Вот так вот, нехитрыми, блядь, методами и сохраняют нервы, трафик и железо. Главное — думать головой, а не жопу чесать.