QUIC на практике: Connection Migration, qlog и особенности quic-go
- пятница, 20 ноября 2026 г. в 00:00:13

Протокол QUIC активно используется в HTTP/3 и постепенно становится важной частью современной сетевой инфраструктуры. При этом его возможности выходят далеко за рамки HTTP: он позволяет создавать собственные сетевые решения с поддержкой независимых потоков, шифрования и устойчивости к изменениям сети. Мы разберём, как устроен QUIC и какие задачи он решает. Затем покажем ряд практических примеров на Go, написанных при помощи библиотеки quic-go.
HTTP/3 уже использует более 40% сайтов (по данным W3Techs). Но многие разработчики по-прежнему воспринимают его как «тот же TCP, просто завёрнутый в UDP-пакеты». Однако это полноценный транспортный протокол для современного интернета: он работает поверх UDP, использует TLS, поддерживает независимые потоки и умеет переносить соединение на новый сетевой путь при смене адреса или порта — и его возможности выходят далеко за рамки HTTP.
В статье мы разберём, как устроен QUIC и какие задачи он решает, а затем на практике, с библиотекой quic-go, напишем на Go три демо, чтобы увидеть, как протокол показывает себя в действии.
Connection Migration — клиент меняет IP-адрес и порт во время активной сессии, а поток продолжает работать. С помощью qlog посмотрим, что происходит с Connection ID.
Независимость потоков — сравним поведение управляющего канала при параллельной передаче большого объёма данных через QUIC и одно TCP-соединение. Проведём тесты на loopback-интерфейсе и в условиях эмулированных потерь пакетов.
HTTP/3 и HTTP/2 — покажем, как использовать один HTTP-обработчик с двумя транспортами.
Все примеры можно будет запустить самостоятельно и посмотреть, как QUIC ведёт себя в разных сетевых условиях. Они собраны в репозитории quic_server_go_example.
На протяжении нескольких десятилетий TCP оставался основным транспортным протоколом интернета. Он гарантирует доставку, восстанавливает порядок сегментов и регулирует перегрузку сети (congestion control). Однако TCP проектировался для стационарных машин в стабильных проводных сетях. Сегодня преобладает мобильный трафик, а приложения загружают сотни мелких ресурсов параллельно. В этих условиях часто старые механизмы TCP становятся узким местом.
Чтобы клиент и сервер начали обмениваться полезными данными по HTTPS, нужно пройти два последовательных рукопожатия:
TCP Handshake: 1 RTT (SYN → SYN-ACK → ACK).
TLS 1.3 Handshake: ещё 1 RTT на согласование ключей и сертификатов.

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

Если сегмент №2 с фрагментом JS теряется, ядро получателя будет удерживать сегменты №3 и №4 в буфере и не отдаст их приложению, пока №2 не будет доставлен повторно. В HTTP/2 убрали HoL-блокировку на уровне приложения (мультиплексируя запросы во фреймы), но на транспортном уровне она осталась: потеря одного TCP-сегмента ставит на паузу все HTTP/2-стримы внутри соединения.
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 работает поверх UDP, который сам по себе не гарантирует доставку и порядок пакетов. Надёжность и управление передачей данных протокол реализует самостоятельно. Это даёт QUIC необходимую свободу, так как UDP предоставляет минимальный механизм доставки датаграмм через IP и не навязывает свою модель надёжного соединения. Поверх него QUIC самостоятельно реализует то, что обычно делает TCP: контроль потерь, повторную передачу данных, управление перегрузкой и потоком. При этом QUIC, в отличие от TCP, реализуется в пространстве пользователя (user space) — внутри самой библиотеки или приложения. Это позволяет обновлять и менять транспортную логику без изменений в ядре операционной системы. Упрощённо стек можно представить следующим образом:

На уровне UDP QUIC получает возможность отправлять и получать датаграммы, а всю остальную транспортную механику контролирует самостоятельно. Поэтому такие возможности, как независимые стримы, Connection ID и миграция соединения, не требуют изменений в TCP-стеке операционной системы.
Что даёт перенос в user space:
Скорость внедрения. Изменения в TCP требуют обновления ядра на миллионах серверов и промежуточных устройств — это годы. QUIC обновляется вместе с релизом браузера или бинарника вашего сервиса.
Защита от вмешательства. Полезная нагрузка QUIC-пакета зашифрована, включая фреймы ACK, а номер пакета в заголовке дополнительно закрыт header protection. Промежуточным узлам (middleboxes) остаётся видеть только флаги, версию и Connection ID — «подкручивать» окна и ретрансмиссии, как в TCP, они не могут.
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, но ожидание их доставки не останавливает остальные стримы.

В отличие от TCP, QUIC не привязывает соединение исключительно к паре IP-адресов и портов. Для распознавания соединения он использует Connection ID (CID) — идентификатор длиной до 20 байт. Каждая сторона выдаёт другой стороне идентификаторы, по которым хочет получать пакеты. Благодаря этому смена адреса или порта не обязательно приводит к разрыву соединения.
Важно: CID у соединения не один. В ходе рукопожатия стороны обмениваются фреймами NEW_CONNECTION_ID, выдавая друг другу по несколько запасных идентификаторов.
Сервер узнаёт «своё» соединение по любому из CID, которые он сам выдал клиенту, — именно поэтому смена IP или порта его не смущает.
Когда клиент решает переехать на новый путь, происходит следующее:
Клиент отправляет с нового адреса пакет с фреймом PATH_CHALLENGE (8 случайных байт). Такой пакет обязан идти с новым CID — иначе наблюдатель в сети смог бы связать старый и новый адрес одного пользователя (linkability).
Сервер отвечает PATH_RESPONSE с теми же 8 байтами — и, как правило, тут же посылает клиенту свой PATH_CHALLENGE: он тоже хочет убедиться, что новый адрес клиента реален, а не подделан.
Клиент отвечает на встречный вызов. Путь валидирован с обеих сторон; трафик переезжает, соединение и стримы живут дальше.
Два этих механизма внешне могут выглядеть одинаково, но имеют существенные отличия.
NAT rebinding — пассивный сценарий. У клиента ничего не менялось, но промежуточный NAT переписал порт. Сервер видит пакеты знакомого соединения с нового адреса, валидирует путь и продолжает работу. Приложению делать ничего не нужно.
Active migration — активный сценарий, инициировать его может только клиент. Сервер не может попросить клиента переехать; единственное исключение — механизм Preferred Address, который в quic-go на момент написания не реализован. Поэтому в примере ниже вся логика миграции живёт в клиенте, а серверу не нужно ни строчки: он лишь замечает, что RemoteAddr() изменился.
Характеристика | 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 | Connection ID (набор CID на каждую сторону) |
Смена сети | Разрыв соединения | Connection Migration |
Шифрование заголовков | Открыты (Seq, ACK, Window) | Зашифровано почти всё, кроме флагов, версии и CID |
Управление перегрузкой | Алгоритм задаёт ядро (по умолчанию Cubic; BBR — если включён администратором) | Выбирает приложение; в quic-go реализован Cubic |
Теперь проверим 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-серверу достаточно quic.DialAddr(). Однако для миграции нам понадобится управлять UDP-сокетами самостоятельно. Для этого в quic-go предусмотрен quic.Transport. Он позволяет использовать существующий UDP-сокет для отправки и получения QUIC-пакетов. В нашем примере клиент создаёт два транспорта:
Первый использует 127.0.0.1:5001 — условный Wi-Fi.
Второй использует 127.0.0.2:7007 — условный LTE.
Оба адреса относятся к loopback-сети. Это позволяет проверить миграцию на одной машине без реального переключения между сетями. Сам процесс состоит из трёх шагов:
AddPath() — добавляем новый сетевой путь к существующему соединению.
Probe() — проверяем доступность пути с помощью PATH_CHALLENGE и PATH_RESPONSE.
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
Логи приложения показывают результат миграции, но не объясняют, как 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 — независимая доставка данных в разных стримах. Если пакет одного стрима потерялся, это не мешает приложению читать уже полученные данные другого.
В 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-сокет. Доступ к записи защищён общим мьютексом, чтобы кадры не перемешивались.
Таким образом, в обоих случаях управляющие сообщения конкурируют с большой передачей данных. Разница в том, как транспорт обрабатывает эти потоки.
Начнём с локальной сети без искусственных задержек и потерь:
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-блокировка на транспортном уровне не проявляется.
Небольшая разница между результатами может быть связана с планированием горутин, буферизацией и способом записи данных в сокет.
На чистом канале оба варианта справились с задачей. Теперь посмотрим, что изменится при потерях.
Для имитации нестабильной сети воспользуемся 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-потока.
На практике 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 и запуск слушателей приведены в репозитории.
Обычно клиент сначала устанавливает 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.
Наш сервер поддерживает сразу три версии 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 даёт независимые стримы и возможность миграции между сетями, но требует учитывать особенности user-space-реализации, настройки UDP и доступности протокола в сети.
В отличие от TCP, QUIC реализует транспортную логику в user space. Приложение обрабатывает QUIC-пакеты, включая шифрование и управление соединением, поэтому при высокой нагрузке стоимость обработки может быть заметной. При этом результат зависит от размера пакетов, характера трафика, операционной системы и аппаратных возможностей.
Снизить накладные расходы помогают UDP GSO/GRO в Linux. quic-go использует GSO там, где оно поддерживается. Для фильтрации нежелательного трафика до передачи в приложение можно применять eBPF/XDP.
Набор доступных оптимизаций различается между операционными системами. Поэтому производительность стоит измерять на той платформе, где будет работать сервис, а не только на машине разработчика.
При интенсивном трафике UDP-буферы ядра могут переполняться, из-за чего пакеты теряются ещё до обработки QUIC-стеком. quic-go предупреждает, если не удаётся увеличить буфер приёма до рекомендуемого размера.
В Linux можно поднять системные лимиты:
sudo sysctl -w net.core.rmem_max=25000000 sudo sysctl -w net.core.wmem_max=25000000
Эти значения — пример настройки, а не универсальный оптимум: подходящие лимиты зависят от нагрузки и доступной памяти. Дополнительные рекомендации приведены в документации quic-go по 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. При этом переключение между транспортами необходимо реализовать или обеспечить на стороне клиента.
Мобильные приложения. Миграция помогает сохранять соединение при переключении между Wi-Fi и мобильной сетью.
Стриминг и интерактивные приложения. Разделение управляющего и основного трафика по стримам позволяет избежать межстримовой HoL-блокировки, хотя потери и перегрузка всё ещё влияют на соединение.
Межсервисное взаимодействие через сети с потерями. Независимые стримы могут уменьшить влияние потери отдельных пакетов на задержки соседних потоков.
Долгоживущие соединения с несколькими логическими каналами. Например, телеметрия, агенты и управление устройствами, где важно передавать команды параллельно с основным потоком данных.
Однако QUIC не всегда будет лучшим выбором. Внутри дата-центра, где сеть стабильна, а существующая TCP-инфраструктура хорошо оптимизирована, выигрыш может оказаться небольшим. На устройствах с ограниченными ресурсами дополнительные расходы на обработку пакетов также могут иметь значение.
Практический вывод прост: QUIC стоит выбирать не только из-за возможностей протокола, но и с учётом условий сети, требований приложения и результатов измерений на целевой инфраструктуре.
Автор: Александр Донцов
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
-15% на заказ нового VDS — HABRFIRSTVDS.