Когда процесс внутри контейнера отправляет сетевой пакет наружу, в ядре Linux запускается длинная бюрократическая цепочка. Для твоего кода вызов выглядит мгновенным, но за кулисами массив байтов проходит через выделение памяти, копирование буферов, таблицы маршрутизации, правила межсетевого экрана и систему отслеживания соединений. На обычном сервере эта внутренняя кухня незаметна. Но когда скорость сетевой карты вырастает до 100 или 200 Гбит/с, а счет идет на десятки миллионов пакетов в секунду, штатный конвейер ядра становится главным тормозом инфраструктуры.
С этой стеной столкнулся ведущий инженер Loophole Labs Алекс Сёрли (Alex Sørlie) при создании платформы живой миграции Architect. Во время переноса работающего контейнера между облаками каждый пакет нужно перехватить, модифицировать, упаковать в туннель и перенаправить на новый узел без разрыва соединения. В Linux для обработки трафика на скорости физического канала существует технология XDP (eXpress Data Path — экспресс-путь данных на базе eBPF). Вот только по архитектуре ядра XDP работает исключительно на входящем трафике, а для исходящих пакетов контейнера он недоступен. Но так ли неприступно это ограничение, если заглянуть в устройство виртуальных интерфейсов?
Почему подсистема Traffic Control захлебывается на 21,1 Гбит/с и сколько стоит буфер ядра
Ты наверняка спросишь: зачем протаскивать XDP на выход, если в Linux уже есть штатный механизм перехвата исходящих пакетов через eBPF — подсистема Traffic Control (TC)? Именно на хуках TC строят фильтрацию исходящего трафика сетевые плагины Kubernetes. О базовом пути пакета в кластере мы говорили в разборе архитектуры сетей Kubernetes от сетевого стека Linux до eBPF. На фоне таблиц iptables, которые в тестах команды на канале 200 Гбит/с при MTU 1500 выдали всего 15,6 Гбит/с с разбросом задержек из-за борьбы за процессор, перехват через TC выглядит шагом вперед.
Однако на практике пропускная способность Traffic Control упирается в потолок: на двухсотгигабитном стенде между двумя машинами AWS EC2 программа на TC прокачала лишь 21,1 Гбит/с на исходящем трафике и 23 Гбит/с на входящем. Для живой миграции нагруженных узлов это потеря почти 90% скорости канала.
Причина в том, когда и с какими данными работает TC. Хук запускается поздно — после маршрутизации, фаервола и таблицы отслеживания состояний conntrack. Но главный удар наносит структура struct sk_buff (сокет-буфер ядра). На каждый кадр ядро выделяет этот тяжеловесный объект в памяти и копирует туда метаданные. Представь курьерскую службу, где каждое письмо перед отправкой перекладывают в деревянный ящик, оклеивают бланками для всех отделов сортировки и только у дверей склада спрашивают твоего разрешения на выезд. При миллионах пакетов в секунду аллокации sk_buff сжигают ресурсы процессора еще до старта eBPF-программы.
Как устроен спринт XDP в драйвере сетевой карты и почему ему закрыт выход
В отличие от сокет-буфера, XDP работает как мгновенный фейсконтроль на пороге сетевой карты. Когда пакет прилетает из кабеля, адаптер через прямой доступ к памяти (DMA) записывает байты в кольцевой буфер приема (RX ring buffer) и посылает прерывание драйверу. Драйвер переносит указатель на пакет во входную очередь приема (RX queue) — и ровно здесь запускается программа XDP. Структуры sk_buff еще не существует, ядро Linux даже не знает о прибытии кадра, а обработка идет по сырым байтам в режиме нулевого копирования (zero-copy).
Почему же этот скоростной механизм работает только на вход? Изучив исходники ядра Linux, инженеры заметили важную деталь: ядро вообще не ставит на пакеты метку «входящий». Единственным триггером для вызова XDP служит сам факт попадания кадра в очередь приема RX. Когда приложение внутри контейнера отправляет данные наружу, пакет сразу падает в очередь передачи (TX queue). Входная очередь RX не используется, а значит, у драйвера просто нет точки запуска XDP.
Разворот через зеркальный туннель veth и цена полного обхода ядра
Раз ядро определяет входящий трафик только по попаданию в очередь RX, нужно заставить исходящий пакет контейнера притвориться входящим для хоста. И подходящий инструмент уже встроен в каждый сервер с Docker, containerd или Kubernetes.
Сетевое пространство имен (network namespace) каждого контейнера соединяется с хостом через пару виртуальных интерфейсов veth (Virtual Ethernet), работающую как сквозная труба. Один конец (veth0-A) находится внутри контейнера, а второй (veth1-A) — на хосте. Когда контейнер отправляет пакет в очередь TX своего интерфейса veth0-A, драйвер просто перекладывает указатель на память пакета во входную очередь приема RX парного интерфейса veth1-A.
С точки зрения хоста пакет только что поступил в очередь RX! Поскольку с ядра Linux 4.19 драйвер veth поддерживает нативный XDP, мы вешаем XDP-программу на veth1-A, меняем заголовки и через вердикт XDP_REDIRECT сбрасываем кадр напрямую в очередь TX физической карты eth0 в обход сетевого стека Linux.
Правда, при первом же запуске на стенде пакеты исчезли по дороге: дамп tcpdump на коммутаторе показал, что свитч молча отбрасывает кадры. Обходя сетевой стек ядра, ты обязан вручную выполнять его работу — пересчитывать контрольные суммы после подмены IP-адресов (NAT) и искать MAC-адрес получателя по протоколу ARP. Чтобы не пересчитывать сумму по всему буферу и самостоятельно проставить MAC-адрес следующего узла, в XDP-программу внедряют инкрементальное сложение и собственную ARP-таблицу в карте eBPF:
static __always_inline __u16 csum16_add(__u16 csum, __u16 addend) {
csum += addend;
return csum + (csum < addend);
}
struct arp_entry { __u8 mac[ETH_ALEN]; };
struct {
__uint(type, BPF_MAP_TYPE_HASH);
__type(key, __be32);
__type(value, struct arp_entry);
__uint(max_entries, 65535);
} arp_table SEC(".maps");
csum = csum16_add(~tcp->check, ~old_ip_high);
csum = csum16_add(csum, ~old_ip_low);
csum = csum16_add(csum, new_ip_high);
csum = csum16_add(csum, new_ip_low);
tcp->check = ~csum;
struct arp_entry *entry = bpf_map_lookup_elem(&arp_table, &dest_ip);
if (entry) memcpy(eth->h_dest, entry->mac, ETH_ALEN);
Посмотрим, как этот код спасает пакеты в рантайме. Функция csum16_add складывает 16-битные слова с учетом переноса разряда csum < addend. Вместо чтения всего пакета мы берем инвертированную старую сумму ~tcp->check, вычитаем половинки старого IP (~old_ip_high, ~old_ip_low), прибавляем новый адрес и записываем инвертированный итог в tcp->check за пару тактов процессора. А хеш-таблица arp_table (BPF_MAP_TYPE_HASH на 65 535 записей) сопоставляет IP-адрес __be32 со структурой arp_entry: вызов bpf_map_lookup_elem находит запись для dest_ip, и memcpy копирует физический адрес entry->mac в заголовок кадра eth->h_dest. Коммутатор получает валидный Ethernet-кадр без обращения к ядру Linux.
Контраст четырех режимов на стенде 200 Гбит/с и границы метода в Kubernetes
Чтобы проверить решение в бою, авторы запустили iPerf3 в стандартных контейнерах с парами veth между двумя инстансами AWS EC2 с сетью 200 Гбит/с и MTU 1500. Менялся только механизм переброски пакета из veth в физический адаптер:
| Режим на выходе контейнера | Скорость (MTU 1500) | Что происходит под капотом |
|---|---|---|
iptables (PREROUTING) | 15,6 Гбит/с | Проход через ядро, NAT и conntrack; борьба за CPU и скачки задержек |
| Traffic Control (TC egress) | 21,1 Гбит/с | Запуск после выделения struct sk_buff и базовых подсистем стека |
Generic XDP на veth | Ниже 21,1 Гбит/с | Программный запуск после аллокации sk_buff без оптимизаций TC |
Native XDP на veth | 194 Гбит/с | Перехват в очереди RX до ядра; рост в 12,4× к iptables и в 9,2× к TC |
Показательна ловушка режима Generic XDP: он оказался медленнее Traffic Control, так как запускается в тестовом режиме уже после создания sk_buff, теряя плюсы раннего перехвата. Лишь включение нативного драйвера (xdpdrv через ip link set dev veth1 xdpgeneric off && ip link set dev veth1 xdpdrv object xdp_egress.o section xdp) позволило выжать 194 Гбит/с при минимальном разбросе задержек.
Для сетевых микросервисов, систем живой миграции и Docker-окружений (команда готовит открытый сетевой плагин на замену стандартному мосту Docker) это способ кратно ускорить сеть без патчей ядра. Однако в кластерах Kubernetes полный обход стека через XDP_REDIRECT означает, что пакеты исчезают с радаров модуля conntrack. Если в классических CNI инженеры борются с тормозами распухших таблиц сессий (мы разбирали это в статье про устранение 80-секундных задержек в Kubernetes из-за таблицы conntrack в Cilium CNI), то при переходе на чистый XDP отслеживание состояний соединений и фоновое обновление таблицы ARP через демон в пространстве пользователя придется брать на себя.
Сухой остаток этой истории прост: ограничение XDP только входящим трафиком оказалось лишь следствием работы драйвера с очередью приема, а стандартная пара интерфейсов veth позволяет превратить выход контейнера во вход хоста и разогнать отправку пакетов с 21,1 до 194 Гбит/с на обычном ядре Linux.



