golang

QUIC на практике: Connection Migration, qlog и особенности quic-go

  • пятница, 20 ноября 2026 г. в 00:00:13
https://habr.com/ru/companies/first/articles/1109154/

Протокол QUIC активно используется в HTTP/3 и постепенно становится важной частью современной сетевой инфраструктуры. При этом его возможности выходят далеко за рамки HTTP: он позволяет создавать собственные сетевые решения с поддержкой независимых потоков, шифрования и устойчивости к изменениям сети. Мы разберём, как устроен QUIC и какие задачи он решает. Затем покажем ряд практических примеров на Go, написанных при помощи библиотеки quic-go.

Введение

HTTP/3 уже использует более 40% сайтов (по данным W3Techs). Но многие разработчики по-прежнему воспринимают его как «тот же TCP, просто завёрнутый в UDP-пакеты». Однако это полноценный транспортный протокол для современного интернета: он работает поверх UDP, использует TLS, поддерживает независимые потоки и умеет переносить соединение на новый сетевой путь при смене адреса или порта — и его возможности выходят далеко за рамки HTTP. 

В статье мы разберём, как устроен QUIC и какие задачи он решает, а затем на практике, с библиотекой quic-go, напишем на Go три демо, чтобы увидеть, как протокол показывает себя в действии. 

  1. Connection Migration — клиент меняет IP-адрес и порт во время активной сессии, а поток продолжает работать. С помощью qlog посмотрим, что происходит с Connection ID.

  2. Независимость потоков — сравним поведение управляющего канала при параллельной передаче большого объёма данных через QUIC и одно TCP-соединение. Проведём тесты на loopback-интерфейсе и в условиях эмулированных потерь пакетов.

  3. HTTP/3 и HTTP/2 — покажем, как использовать один HTTP-обработчик с двумя транспортами.

Все примеры можно будет запустить самостоятельно и посмотреть, как QUIC ведёт себя в разных сетевых условиях. Они собраны в репозитории quic_server_go_example.

Проблема TCP: почему появился QUIC

На протяжении нескольких десятилетий TCP оставался основным транспортным протоколом интернета. Он гарантирует доставку, восстанавливает порядок сегментов и регулирует перегрузку сети (congestion control). Однако TCP проектировался для стационарных машин в стабильных проводных сетях. Сегодня преобладает мобильный трафик, а приложения загружают сотни мелких ресурсов параллельно. В этих условиях часто старые механизмы TCP становятся узким местом.

Задержки на установление соединения

Чтобы клиент и сервер начали обмениваться полезными данными по HTTPS, нужно пройти два последовательных рукопожатия:

  1. TCP Handshake: 1 RTT (SYN → SYN-ACK → ACK).

  2. TLS 1.3 Handshake: ещё 1 RTT на согласование ключей и сертификатов.

Итого до первого байта HTTP-запроса проходит 2 полных RTT (с TLS 1.2 — до 3 RTT). В мобильных сетях или при связи через континент, где RTT достигает 100 мс, при этом пользователь ждёт около 200–300 мс только на подготовку канала.

Head-of-Line Blocking

TCP представляет данные как единый упорядоченный поток байтов. Когда приложение передаёт через один сокет несколько независимых ресурсов (картинку, CSS и текстовый ответ API), сетевой стек ничего не знает об их границах.

Если сегмент №2 с фрагментом JS теряется, ядро получателя будет удерживать сегменты №3 и №4 в буфере и не отдаст их приложению, пока №2 не будет доставлен повторно. В HTTP/2 убрали HoL-блокировку на уровне приложения (мультиплексируя запросы во фреймы), но на транспортном уровне она осталась: потеря одного TCP-сегмента ставит на паузу все HTTP/2-стримы внутри соединения.

Привязка TCP-соединения к связке IP:Port

TCP идентифицирует соединение с помощью четвёрки адресов: (исходный IP, исходный порт, целевой IP, целевой порт). Например:

(192.168.1.10, 51234, 203.0.113.10, 443)

Пока эта четвёрка сохраняется, TCP считает, что речь идёт об одном и том же соединении. Проблема возникает, когда клиент меняет сеть. Например, смартфон переключается с Wi-Fi на LTE и получает новый IP-адрес:

Wi-Fi:  192.168.1.10:51234 → 203.0.113.10:443

LTE:    198.51.100.25:43120 → 203.0.113.10:443

Для TCP это уже другое соединение: изменились как минимум исходный IP, а часто и исходный порт. Старое TCP-соединение продолжить нельзя, поэтому клиенту приходится устанавливать новое. Для HTTPS это означает повторный TCP Handshake и новый TLS Handshake. Если приложение использует WebSocket или другой stateful-протокол поверх TCP, дополнительно приходится восстанавливать соответствующее соединение и его состояние.

Анатомия QUIC: транспорт в user space

QUIC работает поверх UDP, который сам по себе не гарантирует доставку и порядок пакетов. Надёжность и управление передачей данных протокол реализует самостоятельно. Это даёт QUIC необходимую свободу, так как UDP предоставляет минимальный механизм доставки датаграмм через IP и не навязывает свою модель надёжного соединения. Поверх него QUIC самостоятельно реализует то, что обычно делает TCP: контроль потерь, повторную передачу данных, управление перегрузкой и потоком. При этом QUIC, в отличие от TCP, реализуется в пространстве пользователя (user space) — внутри самой библиотеки или приложения. Это позволяет обновлять и менять транспортную логику без изменений в ядре операционной системы. Упрощённо стек можно представить следующим образом:

На уровне UDP QUIC получает возможность отправлять и получать датаграммы, а всю остальную транспортную механику контролирует самостоятельно. Поэтому такие возможности, как независимые стримы, Connection ID и миграция соединения, не требуют изменений в TCP-стеке операционной системы.

Что даёт перенос в user space:

  1. Скорость внедрения. Изменения в TCP требуют обновления ядра на миллионах серверов и промежуточных устройств — это годы. QUIC обновляется вместе с релизом браузера или бинарника вашего сервиса.

  2. Защита от вмешательства. Полезная нагрузка QUIC-пакета зашифрована, включая фреймы ACK, а номер пакета в заголовке дополнительно закрыт header protection. Промежуточным узлам (middleboxes) остаётся видеть только флаги, версию и Connection ID — «подкручивать» окна и ретрансмиссии, как в TCP, они не могут.

Основные свойства QUIC

Объединённое рукопожатие (1-RTT и 0-RTT)

QUIC совмещает транспортное и криптографическое рукопожатие. При первом подключении требуется 1 RTT. При повторном (resumption) клиент может использовать 0-RTT, отправляя зашифрованные данные (early data) уже в первом пакете.

0-RTT — не просто «быстрое рукопожатие», и у него есть важное ограничение: early data можно воспроизвести повторно (replay). Злоумышленник, перехвативший 0-RTT-пакет, может отправить его серверу ещё раз, и без дополнительных мер сервер выполнит запрос дважды. Поэтому в 0-RTT нельзя без защиты от повторов выполнять неидемпотентные операции — списание денег, создание заказа.

Стримы как сущности первого класса

Внутри одного QUIC-соединения можно открыть большое количество независимых стримов — однонаправленных или двунаправленных. Каждый стрим имеет собственное пространство смещений (offset) и собственное ограничение flow control, при этом для всего соединения также действует общий лимит. Если пакет, содержащий данные стрима №2, потерялся, это не блокирует доставку уже полученных данных других стримов. QUIC может продолжать передавать и отдавать приложению данные стримов №1 и №3, пока для них соблюдаются условия flow control. При потере данных QUIC позже повторно передаст соответствующие данные стрима №2, но ожидание их доставки не останавливает остальные стримы.

Connection Migration и Connection ID

В отличие от TCP, QUIC не привязывает соединение исключительно к паре IP-адресов и портов. Для распознавания соединения он использует Connection ID (CID) — идентификатор длиной до 20 байт. Каждая сторона выдаёт другой стороне идентификаторы, по которым хочет получать пакеты. Благодаря этому смена адреса или порта не обязательно приводит к разрыву соединения. 

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

Сервер узнаёт «своё» соединение по любому из CID, которые он сам выдал клиенту, — именно поэтому смена IP или порта его не смущает.

Когда клиент решает переехать на новый путь, происходит следующее:

  1. Клиент отправляет с нового адреса пакет с фреймом PATH_CHALLENGE (8 случайных байт). Такой пакет обязан идти с новым CID — иначе наблюдатель в сети смог бы связать старый и новый адрес одного пользователя (linkability).

  2. Сервер отвечает PATH_RESPONSE с теми же 8 байтами — и, как правило, тут же посылает клиенту свой PATH_CHALLENGE: он тоже хочет убедиться, что новый адрес клиента реален, а не подделан.

  3. Клиент отвечает на встречный вызов. Путь валидирован с обеих сторон; трафик переезжает, соединение и стримы живут дальше.

Два разных сценария: NAT rebinding и active migration

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

NAT rebinding — пассивный сценарий. У клиента ничего не менялось, но промежуточный NAT переписал порт. Сервер видит пакеты знакомого соединения с нового адреса, валидирует путь и продолжает работу. Приложению делать ничего не нужно.

Active migration — активный сценарий, инициировать его может только клиент. Сервер не может попросить клиента переехать; единственное исключение — механизм Preferred Address, который в quic-go на момент написания не реализован. Поэтому в примере ниже вся логика миграции живёт в клиенте, а серверу не нужно ни строчки: он лишь замечает, что RemoteAddr() изменился.

Сравнительная таблица: TCP vs QUIC

Характеристика

TCP + TLS 1.3

QUIC (HTTP/3)

Базовый транспорт

IP (протокол 6)

UDP (протокол 17)

Где живёт стек

Ядро ОС

Приложение (user space)

Задержка рукопожатия

2 RTT (1 RTT при TLS resumption)

1 RTT (0 RTT при resumption)

HoL Blocking между логическими каналами

Есть (на уровне TCP)

Нет (изоляция на уровне стримов)

Идентификатор соединения

4-tuple (IP:Port <-> IP:Port)

Connection ID (набор CID на каждую сторону)

Смена сети

Разрыв соединения

Connection Migration

Шифрование заголовков

Открыты (Seq, ACK, Window)

Зашифровано почти всё, кроме флагов, версии и CID

Управление перегрузкой

Алгоритм задаёт ядро (по умолчанию Cubic; BBR — если включён администратором)

Выбирает приложение; в quic-go реализован Cubic

Практика: Connection Migration на Go

Теперь проверим Connection Migration на практике. Напишем небольшой пример на Go с библиотекой quic-go: клиент установит соединение с сервером, отправит сообщение, затем сменит IP-адрес и порт и продолжит передачу данных через тот же стрим. После этого посмотрим на логи сервера и с помощью qlog разберём, что происходит внутри соединения при миграции.

Подготовка

Для примера понадобится Go 1.26 и библиотека quic-go, установим её следующей командой:

go get github.com/quic-go/quic-go

QUIC использует TLS 1.3, поэтому даже для локального подключения потребуется сертификат. В нашем проекте он генерируется автоматически. Также необходимо настроить ALPN — идентификатор прикладного протокола, который согласовывают клиент и сервер. Весь вспомогательный код, включая генерацию сертификата, настройку TLS и обработку соединений, вынесен в отдельные пакеты. Здесь рассмотрим только части, непосредственно связанные с миграцией.

Как устроена миграция в quic-go

В обычном случае для подключения к QUIC-серверу достаточно quic.DialAddr(). Однако для миграции нам понадобится управлять UDP-сокетами самостоятельно. Для этого в quic-go предусмотрен quic.Transport. Он позволяет использовать существующий UDP-сокет для отправки и получения QUIC-пакетов. В нашем примере клиент создаёт два транспорта:

  1. Первый использует 127.0.0.1:5001 — условный Wi-Fi.

  2. Второй использует 127.0.0.2:7007 — условный LTE.

Оба адреса относятся к loopback-сети. Это позволяет проверить миграцию на одной машине без реального переключения между сетями. Сам процесс состоит из трёх шагов:

  1. AddPath() — добавляем новый сетевой путь к существующему соединению.

  2. Probe() — проверяем доступность пути с помощью PATH_CHALLENGE и PATH_RESPONSE.

  3. Switch() — переключаем отправку данных на новый путь.

В коде это выглядит следующим образом:

// Регистрируем новый сетевой путь.

path, err := conn.AddPath(nextTransport)

if err != nil {

    return err

}

// Проверяем доступность нового пути.

if err := path.Probe(ctx); err != nil {

    return err

}

// Переключаем отправку пакетов.

if err := path.Switch(); err != nil {

    return err

}

Здесь conn — существующее QUIC-соединение, а nextTransport — транспорт, созданный поверх нового UDP-сокета. Метод Probe() выполняет проверку пути, после которой можно вызвать Switch(). Если попытаться переключиться на непроверенный путь, библиотека вернёт quic.ErrPathNotValidated. Есть ещё одна особенность: Switch() не гарантирует мгновенного переключения. Метод передаёт запрос внутреннему циклу обработки событий соединения. Поэтому пакеты, подготовка которых уже началась, ещё могут отправиться через старый путь. Кроме того, не следует сразу закрывать исходный Transport. Управление временем жизни UDP-сокетов остаётся за кодом приложения.

Запускаем миграцию

Сервер в нашем примере принимает QUIC-соединения и обрабатывает входящие стримы. Специальной логики для миграции в нём нет.

При получении сообщения он выводит его содержимое и текущий адрес клиента — conn.RemoteAddr(). Именно по этому адресу мы сможем увидеть переключение.

На стороне клиента последовательность действий выглядит так:

// Подключаемся через первый транспорт.

conn, err := client.Dial(ctx, tr1, serverAddr, tlsConfig, nil)

if err != nil {

    return err

}

// Отправляем первое сообщение.

conn.Send([]byte("hello from Wi-Fi"))

// Переключаемся на второй транспорт.

if err := conn.Migrate(ctx, tr2); err != nil {

    return err

}

// Продолжаем передачу через тот же стрим.

conn.Send([]byte("hello from LTE"))

Здесь client.Dial(), conn.Migrate() и conn.Send() — методы наших вспомогательных компонентов. Их полная реализация находится в репозитории.

Обратите внимание: после миграции мы не создаём новое QUIC-соединение и не открываем новый стрим. Клиент продолжает использовать уже существующие.

Запустим пример:

go run ./cmd/migration

Для наглядности оставим в выводе только сообщения, полученные сервером:

message received

  data="hello from Wi-Fi"

  remote=127.0.0.1:5001

message received

  data="hello from LTE"

  remote=127.0.0.2:7007

Сервер получил оба сообщения в рамках одного соединения и одного стрима, хотя адрес клиента изменился с 127.0.0.1:5001 на 127.0.0.2:7007.

Таким образом, соединение пережило смену IP-адреса и порта без повторного TLS-рукопожатия.

Для локального запуска на Linux дополнительная настройка loopback обычно не требуется. На macOS адрес 127.0.0.2 может понадобиться добавить вручную:

sudo ifconfig lo0 alias 127.0.0.2 up

Что происходит внутри соединения: анализ qlog

Логи приложения показывают результат миграции, но не объясняют, как QUIC переключается между сетевыми путями.

Для этого воспользуемся qlog — форматом структурированных событий QUIC. Библиотека quic-go поддерживает его через встроенный механизм трассировки.

В нашем проекте запись qlog включается через переменную окружения QLOGDIR:

quic.Config{

    Tracer: qlog.DefaultConnectionTracer,

}

Запустим пример с трассировкой:

QLOGDIR=/tmp/qlogs go run ./cmd/migration

Полученные файлы .sqlog можно открыть в визуализаторе qvis.

Нас интересуют два события:

  • PATH_CHALLENGE — запрос проверки нового пути.

  • PATH_RESPONSE — ответ, подтверждающий получение запроса.

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

Теперь посмотрим на Connection ID.

Как мы разбирали ранее, QUIC использует Connection ID для сопоставления пакетов с соединением. Благодаря этому сервер может распознать существующее соединение, даже когда пакеты начинают приходить с другого IP-адреса.

Для анализа выберем несколько событий из клиентского qlog:

Time    Event             DCID       Frame

------------------------------------------------

1ms     packet_sent       bb20a177   stream

502ms   packet_sent       da611e7b   path_challenge

502ms   packet_received   1f2311ca   path_challenge,path_response

502ms   packet_sent       bb20a177   ack,path_response

502ms   packet_sent       bb20a177   ack,stream

Здесь DCID — Destination Connection ID, идентификатор соединения, указанный в заголовке пакета.

В трассировке видно, что при проверке нового пути клиент использовал другой DCID — da611e7b. Сервер также использовал отдельный идентификатор для своего проверочного пакета.

При этом после переключения данные продолжили передаваться с прежним DCID bb20a177, но уже с нового локального адреса.

Это наблюдение относится к версиям quic-go, использованным в эксперименте. Поведение идентификаторов может меняться между версиями библиотеки.

Главное, что показывает трассировка: проверка нового пути и продолжение передачи данных происходят внутри существующего QUIC-соединения. Для приложения миграция не потребовала создания нового соединения или стрима.

Проверяем миграцию автотестом

Осталось убедиться, что миграция работает не только при ручном запуске.

Здесь есть один нюанс. Поскольку Switch() выполняет переключение асинхронно, нельзя рассчитывать, что первое сообщение после его вызова обязательно отправится с нового адреса.

В первой версии теста мы именно так и делали: отправляли сообщение сразу после Switch() и ожидали, что сервер получит его с нового IP. Иногда тест завершался ошибкой, хотя миграция работала корректно.

Поэтому теперь проверяем фактический результат: отправляем сообщения, пока сервер не увидит новый адрес или не истечёт время ожидания.

Ключевая часть теста:

path2 := tr2.Conn.LocalAddr().String()

waitRemote(t, ctx, remotes, path2, func() error {

    return conn.Send([]byte("on path 2"))

})

Здесь waitRemote() — вспомогательная функция, которая повторяет отправку и проверяет адрес, зарегистрированный сервером.

При разработке обнаружилась ещё одна особенность: попытка постоянно опрашивать conn.LocalAddr() во время переключения приводила к предупреждению детектора гонок go test -race.

Поэтому адрес нового пути мы берём непосредственно у созданного UDP-сокета, а завершение миграции проверяем по сообщениям сервера.

Запустить все тесты можно командой:

go test -race ./...

Результат

Мы перенесли действующее QUIC-соединение на другой UDP-сокет, изменив IP-адрес и порт клиента. При этом сервер продолжил получать сообщения через тот же стрим без повторного установления соединения.

Анализ qlog позволил увидеть обмен PATH_CHALLENGE/PATH_RESPONSE и использование Connection ID во время миграции. Это одна из особенностей QUIC, полезных для долгоживущих соединений: смена сетевого пути не обязательно приводит к разрыву прикладной сессии.

Практика: независимые стримы QUIC и Head-of-Line Blocking

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

В TCP ситуация другая: данные передаются как единый упорядоченный поток байтов. Если сегмент потерялся, получатель не сможет прочитать следующие за ним данные, пока потеря не будет восстановлена. Это явление называется Head-of-Line Blocking (HoL).

Посмотрим, как эта разница проявляется на практике.

Сценарий эксперимента

Создадим два канала передачи данных внутри одного соединения:

  • Bulk — непрерывно отправляет большой объём данных, стараясь занять доступную пропускную способность.

  • Control — каждые 25 мс отправляет короткое управляющее сообщение.

На сервере будем измерять интервалы между получением управляющих сообщений. Всего отправим 40 сообщений и рассчитаем медиану (p50), 95-й перцентиль (p95) и максимальный интервал.

Чем ближе результаты к заданным 25 мс, тем стабильнее доставка управляющих сообщений.

Реализуем сценарий двумя способами:

  • QUIC: используем два независимых стрима одного соединения.

  • TCP+TLS: передаём оба типа сообщений через одно соединение, разделяя их собственными кадрами [тип][длина][данные]. Этот вариант имитирует мультиплексирование поверх TCP, но не является реализацией HTTP/2. Это важно учитывать при интерпретации результатов.

Проверим оба варианта сначала на обычном loopback, а затем добавим задержку и потери пакетов.

Реализация

Основная логика одинакова для обоих транспортов. В двух горутинах запускаются передача большого объёма данных и отправка коротких сообщений с интервалом 25 мс.

Для QUIC каждому типу данных выделяется отдельный стрим:

control, err := conn.OpenStreamSync(ctx)

if err != nil {

    return err

}

bulk, err := conn.OpenStreamSync(ctx)

if err != nil {

    return err

}

Затем запускаем обе нагрузки:

go sendBulk(bulk)

go sendControl(control, 25*time.Millisecond)

Здесь sendBulk() и sendControl() — вспомогательные функции нашего проекта. Первая непрерывно записывает данные блоками по 64 КиБ, вторая отправляет 40 коротких сообщений.

В TCP-варианте используется аналогичная схема, но обе горутины записывают кадры в один TLS-сокет. Доступ к записи защищён общим мьютексом, чтобы кадры не перемешивались.

Таким образом, в обоих случаях управляющие сообщения конкурируют с большой передачей данных. Разница в том, как транспорт обрабатывает эти потоки.

Эксперимент №1. Чистый loopback

Начнём с локальной сети без искусственных задержек и потерь:

go run ./cmd/multistream

go run ./cmd/multistream -tcp

Транспорт

p50

p95

Максимум

QUIC

25,1 мс

25,3 мс

25,3 мс

TCP+TLS

26,1 мс

26,1 мс

26,2 мс

Оба варианта доставили все 40 управляющих сообщений. Интервалы практически совпадают с заданными 25 мс.

Это ожидаемый результат. Пока пакеты не теряются, TCP не приходится восстанавливать пропущенные сегменты, поэтому HoL-блокировка на транспортном уровне не проявляется.

Небольшая разница между результатами может быть связана с планированием горутин, буферизацией и способом записи данных в сокет.

На чистом канале оба варианта справились с задачей. Теперь посмотрим, что изменится при потерях.

Эксперимент №2. Задержка и потери пакетов

Для имитации нестабильной сети воспользуемся tc netem.

Настроим следующие параметры:

  • Задержка — 20 мс в каждом направлении, около 40 мс RTT.

  • Потери — 2 % пакетов.

Чтобы не влиять на сетевые соединения хост-системы, запустим эксперимент в отдельном Linux network namespace.

Сначала соберём приложение:

go build -o /tmp/multistream ./cmd/multistream

Затем запустим QUIC-вариант:

unshare -Urn sh -c '

  ip link set lo up

  tc qdisc add dev lo root netem delay 20ms loss 2%

  /tmp/multistream

'

Для TCP достаточно добавить флаг -tcp:

unshare -Urn sh -c '

  ip link set lo up

  tc qdisc add dev lo root netem delay 20ms loss 2%

  /tmp/multistream -tcp

'

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

Теперь сравним результаты.

Результаты

Транспорт

p50

p95

Максимум

QUIC, без потерь

25,1 мс

25,3 мс

25,3 мс

TCP+TLS, без потерь

26,1 мс

26,1 мс

26,2 мс

QUIC, 2 % потерь

26,7 мс

40,2 мс

40,2 мс

TCP+TLS, 2 % потерь

120,6 мс

333,8 мс

363,6 мс

Разница стала заметной.

В QUIC медианный интервал увеличился незначительно — с 25,1 до 26,7 мс. Даже максимальный интервал составил около 40 мс.

В TCP-варианте медиана выросла до 120,6 мс, а максимальная пауза между управляющими сообщениями достигла 363,6 мс.

Почему так произошло?

В QUIC потеря пакета с данными bulk-стрима не блокирует чтение уже полученных данных control-стрима. Каждый стрим имеет собственную последовательность байтов, поэтому восстановление потерь происходит без межстримовой HoL-блокировки.

В TCP оба логических канала используют один упорядоченный поток байтов. Если сегмент с данными bulk-канала потерян, следующие за ним управляющие сообщения не могут быть переданы приложению, даже если содержащие их TCP-сегменты уже пришли.

В нашем эксперименте ситуацию дополнительно усугубляла конкуренция за запись в сокет: большой поток данных мог занимать буфер отправки, задерживая управляющие кадры ещё до их передачи по сети.

В результате TCP-вариант под потерями завершил отправку управляющих сообщений значительно позже запланированного времени.

Что важно учитывать

У эксперимента есть два ограничения.

Во-первых, мы не сравниваем пропускную способность транспортов.

Под потерями QUIC передал около 1 МиБ данных, а TCP — около 64 МиБ. Это существенная разница в нагрузке, поэтому считать условия полностью эквивалентными нельзя.

На результаты влияют размер пакетов, сегментация, управление перегрузкой и особенности работы netem. В частности, потери моделируются на уровне пакетов, а не одинакового объёма переданных данных.

Поэтому полученные цифры нельзя использовать для вывода о том, что QUIC быстрее или медленнее TCP.

Во-вторых, наш TCP-вариант — упрощённая модель мультиплексирования.

Мы используем собственный формат кадров и общий мьютекс для записи в сокет. Реальная реализация HTTP/2 имеет более сложные механизмы управления потоками и планирования отправки.

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

Вывод

Эксперимент показывает, как отсутствие межстримовой HoL-блокировки в QUIC помогает изолировать управляющий трафик от потерь в соседнем стриме.

На чистом канале оба варианта обеспечивали интервалы около 25 мс. При 2 % потерь в нашей реализации QUIC интервалы остались близки к заданным, тогда как в TCP-варианте появились задержки до нескольких сотен миллисекунд.

При этом независимость стримов не означает полной изоляции. Они по-прежнему используют общее соединение, разделяют доступную пропускную способность и зависят от управления перегрузкой.

Полученные результаты относятся к конкретному эксперименту, но хорошо иллюстрируют различие между независимыми QUIC-стримами и мультиплексированием поверх одного упорядоченного TCP-потока.

Практика: HTTP/3 и HTTP/2 на одном сервере

На практике QUIC чаще всего встречается как транспорт для HTTP/3. Однако UDP доступен не во всех сетях, поэтому веб-сервисы обычно сохраняют поддержку HTTP/2 и HTTP/1.1 поверх TCP.

Посмотрим, как организовать такую схему на Go с помощью quic-go.

Библиотека предоставляет http3.Server, который работает со стандартным интерфейсом http.Handler. Это позволяет использовать один обработчик для HTTP/3, HTTP/2 и HTTP/1.1, не дублируя прикладную логику.

Запускаем два транспорта

Создадим простой обработчик, который возвращает версию протокола, использованную клиентом:

handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

    fmt.Fprintf(w, "Hello from %s!\n", r.Proto)

})

Теперь настроим два сервера с общим обработчиком и TLS-сертификатом:

// HTTP/3 поверх QUIC (UDP).

h3 := &http3.Server{

    Addr:      ":4433",

    TLSConfig: tlsConfig,

    Handler:   handler,

}

// HTTP/2 и HTTP/1.1 поверх TCP.

tcp := &http.Server{

    Addr:      ":4433",

    TLSConfig: tlsConfig,

    Handler:   handler,

}

Оба сервера используют порт 4433, но работают с разными транспортными протоколами: HTTP/3 — с UDP, HTTP/2 и HTTP/1.1 — с TCP. Поэтому конфликта портов не возникает.

Для TCP-сервера необходимо настроить TLS с поддержкой HTTP/2 и HTTP/1.1. В нашем проекте это сделано в общей TLS-конфигурации:

tlsConfig.NextProtos = []string{"h2", "http/1.1"}

HTTP/3-сервер самостоятельно настраивает необходимые параметры ALPN для QUIC.

В примере используется один сертификат для обоих серверов. Полная конфигурация TLS и запуск слушателей приведены в репозитории.

Сообщаем клиенту о поддержке HTTP/3

Обычно клиент сначала устанавливает HTTPS-соединение по TCP. Чтобы сообщить ему о доступности HTTP/3, сервер может вернуть заголовок Alt-Svc.

В quic-go для этого предусмотрен метод SetQUICHeaders():

handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

    h3.SetQUICHeaders(w.Header())

    fmt.Fprintf(w, "Hello from %s!\n", r.Proto)

})

В ответе появится заголовок:

Alt-Svc: h3=":4433"; ma=2592000

Он сообщает клиенту, что ресурс также доступен по HTTP/3 на порту 4433. Параметр ma задаёт время, в течение которого клиент может считать эту информацию актуальной.

Браузер, поддерживающий HTTP/3, может использовать этот заголовок и попробовать установить QUIC-соединение для следующих запросов.

При этом Alt-Svc не переключает транспорт автоматически. Решение принимает клиент, учитывая собственные настройки, доступность UDP и результат проверки TLS-сертификата.

Проверяем работу

Запустим сервер:

go run ./cmd/http3

Сначала проверим HTTP/2:

curl -s --http2 -k https://127.0.0.1:4433/

Ответ:

Hello from HTTP/2.0!

Аналогично проверим HTTP/1.1:

curl -s --http1.1 -k https://127.0.0.1:4433/

Hello from HTTP/1.1!

Теперь убедимся, что сервер сообщает о поддержке HTTP/3:

curl -sI --http2 -k https://127.0.0.1:4433/ | grep -i alt-svc

alt-svc: h3=":4433"; ma=2592000

Для проверки самого HTTP/3 понадобится клиент с поддержкой QUIC. Однако не каждая сборка curl включает HTTP/3.

Проверить это можно командой:

curl --version

Если в списке возможностей присутствует HTTP3, можно выполнить запрос:

curl --http3-only -k https://127.0.0.1:4433/

Для проверки через Go воспользуемся http3.Transport из quic-go:

tr := &http3.Transport{

    TLSClientConfig: &tls.Config{

        InsecureSkipVerify: true,

    },

}

defer tr.Close()

client := &http.Client{Transport: tr}

resp, err := client.Get("https://127.0.0.1:4433/")

if err != nil {

    log.Fatal(err)

}

fmt.Println(resp.Proto) // HTTP/3.0

Здесь InsecureSkipVerify используется исключительно для локального тестирования с самоподписанным сертификатом. В рабочем приложении проверку сертификата отключать нельзя.

Если в ответе указано HTTP/3.0, значит запрос действительно был выполнен через QUIC.

А что с fallback?

Наш сервер поддерживает сразу три версии HTTP, но выбор между ними остаётся за клиентом.

Если HTTP/3 недоступен, клиент с соответствующей логикой может использовать HTTP/2 или HTTP/1.1. Однако такая возможность не означает, что любой HTTP-клиент автоматически повторит неудачный запрос через TCP.

Например, использованный выше http3.Transport работает только с HTTP/3 и самостоятельно не переключается на HTTP/2.

Таким образом, в этом примере мы реализовали серверную поддержку нескольких транспортов, а не механизм клиентского fallback.

Результат

Мы запустили HTTP/3 и HTTP/2 на одном номере порта, используя общий TLS-сертификат и один http.Handler.

Для приложения различия между транспортами практически незаметны: обработчик получает обычный http.Request и возвращает http.ResponseWriter.

При этом HTTP/3 использует QUIC поверх UDP, а HTTP/2 продолжает работать поверх TCP. Такая архитектура позволяет внедрять HTTP/3, сохраняя совместимость с клиентами и сетями, в которых QUIC недоступен.

Обратная сторона медали: QUIC в production

QUIC даёт независимые стримы и возможность миграции между сетями, но требует учитывать особенности user-space-реализации, настройки UDP и доступности протокола в сети.

Нагрузка на CPU

В отличие от TCP, QUIC реализует транспортную логику в user space. Приложение обрабатывает QUIC-пакеты, включая шифрование и управление соединением, поэтому при высокой нагрузке стоимость обработки может быть заметной. При этом результат зависит от размера пакетов, характера трафика, операционной системы и аппаратных возможностей.

Снизить накладные расходы помогают UDP GSO/GRO в Linux. quic-go использует GSO там, где оно поддерживается. Для фильтрации нежелательного трафика до передачи в приложение можно применять eBPF/XDP.

Набор доступных оптимизаций различается между операционными системами. Поэтому производительность стоит измерять на той платформе, где будет работать сервис, а не только на машине разработчика.

Настройка UDP-буферов

При интенсивном трафике UDP-буферы ядра могут переполняться, из-за чего пакеты теряются ещё до обработки QUIC-стеком. quic-go предупреждает, если не удаётся увеличить буфер приёма до рекомендуемого размера.

В Linux можно поднять системные лимиты:

sudo sysctl -w net.core.rmem_max=25000000

sudo sysctl -w net.core.wmem_max=25000000

Эти значения — пример настройки, а не универсальный оптимум: подходящие лимиты зависят от нагрузки и доступной памяти. Дополнительные рекомендации приведены в документации quic-go по UDP-буферам.

Если сеть блокирует UDP

Некоторые корпоративные сети, публичные Wi-Fi и провайдеры ограничивают UDP-трафик. В таких условиях QUIC-соединение может не установиться, даже если HTTPS по TCP доступен.

Поэтому поддержка HTTP/3 обычно сочетается с HTTP/2 поверх TCP. Сервер может обслуживать оба протокола, а клиент — выбирать доступный транспорт. Конкретный алгоритм переключения зависит от реализации: наличие двух серверных слушателей само по себе не обеспечивает клиентский fallback.

Цена миграции

Connection Migration позволяет сохранить QUIC-соединение при смене сетевого пути, но переключение не происходит мгновенно и бесплатно.

  • Проверка пути. Перед использованием нового пути QUIC проверяет его доступность. На это требуется время, зависящее от сетевой задержки.

  • Ограничения сервера. Сервер может запретить клиенту активную миграцию с помощью транспортного параметра disable_active_migration.

  • Изменение характеристик соединения. После миграции могут измениться RTT, доступная пропускная способность и условия потерь. Реализация должна адаптировать передачу к новому пути, поэтому скорость после переключения может временно снизиться.

Таким образом, миграция помогает сохранить сессию, но не гарантирует отсутствия пауз или падения пропускной способности. Это особенно важно для соединений, передающих большие объёмы данных.

Заключение

В статье мы рассмотрели три практических аспекта QUIC: миграцию соединения, независимую передачу данных в стримах и использование QUIC в качестве транспорта для HTTP/3.

Эксперименты показали следующее:

  • Connection Migration позволяет сохранить соединение при смене адреса и порта. Клиент продолжает использовать существующий стрим, а qlog помогает проследить проверку нового пути и поведение Connection ID.

  • Независимые стримы уменьшают влияние потерь между потоками данных. В нашем эксперименте при 2 % потерь интервалы между управляющими сообщениями в QUIC оставались близки к заданным 25 мс. В TCP-модели они увеличивались значительно сильнее. Это результат конкретной конфигурации, а не универсальный бенчмарк двух протоколов.

  • HTTP/3 можно добавить к существующему HTTP-сервису без дублирования прикладной логики. Один обработчик может обслуживать запросы через HTTP/3 и HTTP/2. При этом переключение между транспортами необходимо реализовать или обеспечить на стороне клиента.

Где QUIC может быть полезен

  • Мобильные приложения. Миграция помогает сохранять соединение при переключении между Wi-Fi и мобильной сетью.

  • Стриминг и интерактивные приложения. Разделение управляющего и основного трафика по стримам позволяет избежать межстримовой HoL-блокировки, хотя потери и перегрузка всё ещё влияют на соединение.

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

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

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

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

Автор: Александр Донцов


НЛО прилетело и оставило здесь промокод для читателей нашего блога:
-15% на заказ нового VDS — HABRFIRSTVDS.

Положение об акции