Лучший способ добавить задержку между HTTP-запросами с одного IP-адреса?

Содержание

Вопрос или проблема
Ответ или решение
Как добавить задержку между HTTP-запросами от конкретного IP-адреса
1. Использование tc и iptables
Ответ на ваш вопрос:
Пример настройки:
2. Использование mod_security
3. Альтернативные методы
3.1. Использование NFQUEUE и пользовательского приложения
Пример:
4. Настройка на уровне приложения
Заключение

Вопрос или проблема

Мне нужно задерживать HTTP-запросы, отправляемые с определённого IP, на 1 секунду каждый. Под задержкой я имею в виду, что она должна быть вставлена между запросами, а не просто отложена. Чтобы было понятно, если я получаю 2 запроса в одну секунду в 01:00:00, их следует обрабатывать в очереди FIFO, первый в 01:00:00 (или 01:00:01), а второй в 01:00:01 (или 01:00:02). Я не хочу, чтобы оба запроса обрабатывались вместе в 01:00:01. Мне нужна задержка между запросами, потому что сам запрос потребляет ЦП, и я не хочу, чтобы несколько запросов накладывались друг на друга. Изменение времени отправки запросов с источника – не вариант, так как им это не интересно. Я использую Litespeed Enterprise в качестве веб-сервера. Кроме того, я не могу использовать простой лимитировщик скорости, потому что это не связано с использованием пропускной способности, мне нужен лимит на запрос/сек.

После небольшого гугления я нашёл следующие решения:

Использование iptables + tc с netem

iptables -A PREROUTING -t mangle -s <source_ip> -j MARK --set-mark 1
tc qdisc add dev eth0 root handle 1: prio
tc qdisc add dev eth0 parent 1:1 handle 10: netem delay 100ms

Использование mod_security, но, похоже, он не поддерживает удержание очереди?
Другие (например, использование NFQUEUE с пользовательским ПО и т.д.)

Мои вопросы:

Добавляет ли решение tc задержку между пакетами или просто откладывает их?
Я предпочёл бы что-то на уровне 7, чтобы сопоставить один HTTP-запрос, а не пакеты. Возможно ли управлять очередью с помощью mod_sec (или другого модуля, знающего о LS), и как? Даже модуль PHP мог бы стать решением.
Есть ли какие-либо предложения в общем? Другие альтернативы?

Ответ или решение

Как добавить задержку между HTTP-запросами от конкретного IP-адреса

Ваша задача заключается в том, чтобы ввести задержку в 1 секунду между HTTP-запросами, поступающими от определенного IP-адреса. Важно, чтобы эта задержка обеспечивала обработку запросов по очереди (FIFO), а не просто откладывала их выполнение. Рассмотрим возможные подходы для решения этой проблемы, включая детали и нюансы для каждого из предложенных методов.

1. Использование `tc` и `iptables`

Ответ на ваш вопрос:

Технически, tc (Traffic Control) применяет задержку на уровне пакетов и не имеет механизма для управления очередями на уровне HTTP- или TCP-протоколов. Однако, он может быть использован для введения задержки в обработку сетевого трафика.

Пример настройки:

iptables -A PREROUTING -t mangle -s <source_ip> -j MARK --set-mark 1
tc qdisc add dev eth0 root handle 1: prio
tc qdisc add dev eth0 parent 1:1 handle 10: netem delay 1000ms

Этот пример добавляет 1-секундную задержку ко всем пакетам, идущим от указанного IP. Однако, это не гарантирует строгую обработку запросов в порядке их поступления, поскольку задержка будет рассчитана на уровне сетевых пакетов.

2. Использование `mod_security`

К сожалению, mod_security не поддерживает механизм работы с очередями HTTP-запросов. Он больше предназначен для фильтрации и защиты веб-приложений, нежели для управления задержкой между запросами.

3. Альтернативные методы

3.1. Использование NFQUEUE и пользовательского приложения

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

Пример:

Настройте iptables для передачи пакетов в NFQUEUE:
```
iptables -A INPUT -s <source_ip> -j NFQUEUE --queue-num 0
```
Создайте пользовательское приложение на Python или другом языке, которое будет извлекать пакеты, обрабатывать их с задержкой, после чего отправлять назад в сеть.

import time
from netfilterqueue import NetfilterQueue

def process_packet(packet):
    # тут можно добавить задержку
    time.sleep(1)
    packet.accept()  # отправка пакета обратно

nfqueue = NetfilterQueue()
nfqueue.bind(0, process_packet)
try:
    nfqueue.run()
except KeyboardInterrupt:
    print('Режим выхода...')

4. Настройка на уровне приложения

Если у вас есть доступ к коду приложения, вы можете добавить обработчик PHP или другого серверного языка, который будет контролировать очередь запросов. Подход будет аналогичен следующему:

session_start();
if (!isset($_SESSION['last_request_time'])) {
    $_SESSION['last_request_time'] = time();
}

$current_time = time();
$delay_time = 1;

if ($current_time - $_SESSION['last_request_time'] < $delay_time) {
    sleep($delay_time - ($current_time - $_SESSION['last_request_time']));
}

$_SESSION['last_request_time'] = time();
// Обработка HTTP-запроса

Заключение

Итак, среди рассмотренных методов, использование NFQUEUE в сочетании с пользовательским приложением предоставляет наиболее подходящее решение для управления HTTP-запросами с задержкой 1 секунду между запросами от конкретного IP. Этот способ позволит вам достичь требуемого эффекта, при этом обеспечивая FIFO-обработку. Выбор уровня приложения для внедрения задержки позволяет избежать необходимости работы с сетевыми пакетами напрямую и предоставляет более гибкое управление.

Рекомендации: всегда тестируйте выбранное решение в контролируемой среде перед развертыванием на реальном сервере, чтобы избежать негативного влияния на производительность вашего веб-приложения.