Спринт 1/3 → Тема 3/4: Пакет compress. Сжатие данных → Урок 1/3

Пакет compress. Сжатие данных

Не успели вы расслабиться, как на пороге появляется Лиза — и сообщает вам потрясающую новость.

Лиза

Привет! Так, вот ваши билеты, вот ваучер на гостиницу, завтра вы с Сашей летите в командировку.

В смысле в командировку? Куда?

Лиза

А Саша тебе не сказал? Наши коллеги в Берлине устраивают крутую конференцию по SQL и базам данных. Съездите, проветритесь. Заодно, может, новых покупателей найдёте для нашей голосовой почты с Алисой 😊

Ну дела…

Лиза

Не беспокойся. Будет круто, обещаю. Goловокружительно!

Да уж, и так голова кругом.

Лиза

Ах да, забыла вас предупредить, что, поскольку билеты покупали в последний момент, вы летите с пересадкой… в Стамбуле 😬

Саша

Так, а вот это уже для меня сюрприз! Ладно, разберёмся. Спасибо за помощь, Лиз.

Если пересадка, значит, нам нужна ручная кладь побольше…

Саша

А что ты хочешь туда упаковать? У нас один вечер на сборы. И я уже иду собираться. Встречаемся завтра в аэропорту.

Ох, договорились.

Саша

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

Вроде помещается.

Саша

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

Иногда бывают такие ситуации, когда нужно сократить объём передаваемых по сети данных. А уж с тем, чтобы сэкономить место на диске, в файловом хранилище или памяти компьютера, сталкиваются практически все. Не только разработчики. Решить подобные ситуации поможет сжатие данных (data compression). О нём и расскажем в этой теме.

Рассмотрим, как применять алгоритмы сжатия к произвольным блокам данных и в обработчиках HTTP-сервера.

В этой теме вы:

изучите пакет compress стандартной библотеки;
познакомитесь со сторонними пакетами для сжатия данных;
научитесь упаковывать и распаковывать данные алгоритмом Deflate;
узнаете, как реализовать gzip-сжатие на стороне веб-сервера;
попробуете распаковать сжатое тело запроса.

Эти знания помогут вам реализовать поддержку gzip-сжатия в вашем проекте.

Саша

Контроль прошли. Пойдём вон там за столик сядем, возьмём кофе и начнём урок.

Да, хорошая идея.

Оптимизация передачи данных

Сжатие данных — это преобразование данных, которое помогает уменьшить занимаемый ими объём. Оно позволяет не только экономить место на устройстве, но и увеличивать скорость передачи данных. Сжатие особенно эффективно при передаче HTML-страниц и данных в формате JSON, так как текстовая информация сжимается очень хорошо.

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

Для примера можно рассмотреть простейший формат сжатия – gzip, который широко используется в Linux. У него следующая структура:

10-байтовый заголовок, содержащий флаги, временную метку, идентификаторы;
дополнительные заголовки с именем исходного файла и комментариями;
данные, сжатые с помощью алгоритма сжатия Deflate;
8-байтовый блок с контрольной суммой и размером несжатых данных.

Формат gzip по умолчанию предназначен для сжатия одного файла, поэтому коллекцию файлов предварительно объединяют в один архив tar и сжимают в формате gzip. У сжатого файла будет расширение .tar.gz.

В одном формате сжатия могут использоваться разные алгоритмы, а один и тот же алгоритм сжатия может применяться в разных форматах.

Пакеты для сжатия данных

В Go алгоритмы сжатия реализованы в следующих пакетах стандартной библиотеки:

compress/bzip2 — распаковка сжатых данных в формате bzip2;
compress/lzw — реализация алгоритма сжатия данных LZW;
compress/flate — реализация алгоритма сжатия данных Deflate;
compress/gzip — поддержка сжатия данных в формате gzip (использует алгоритм Deflate);
compress/zlib — поддержка сжатия данных в формате zlib (использует алгоритм Deflate).

В zip-архивах используются алгоритмы bzip2, LZW и Deflate, а формат gzip применяется в gz архивах.

Рассмотрим подробнее пакеты compress/flate и compress/gzip. Первый пакет реализует часто используемый алгоритм сжатия Deflate, а второй обеспечивает поддержку формата gzip, используемого при сжатии HTML-страниц. Работа с остальными пакетами аналогична.

Функции пакетов compress принимают в качестве параметров переменные, которые реализуют интерфейсы io.Reader и io.Writer. В каждом пакете обычно есть два типа: Writer для сжатия и Reader для распаковки данных.

Так при создании *gzip.Reader в функцию gzip.NewReader(r io.Reader) передаётся io.Reader со сжатыми данными. При этом тип *gzip.Reader тоже реализует интерфейс io.Reader, из него можно читать уже распакованные данные.

Аналогично со сжатием. gzip.NewWriter(w io.Writer) принимает io.Writer, в который будут сохраняться сжатые данные. Сам *gzip.Writer реализует интерфейс io.Writer, в который пишутся исходные данные.

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

Разберём на примере. Напишем функции сжатия и распаковки с методом Deflate:

GO
// Compress сжимает слайс байт.
func Compress(data []byte) ([]byte, error) {
    var b bytes.Buffer
    // создаём переменную w — в неё будут записываться входящие данные,
    // которые будут сжиматься и сохраняться в bytes.Buffer
    w, err := flate.NewWriter(&b, flate.BestCompression)
    if err != nil {
        return nil, fmt.Errorf("failed init compress writer: %v", err)
    }
    // запись данных
    _, err = w.Write(data)
    if err != nil {
        return nil, fmt.Errorf("failed write data to compress temporary buffer: %v", err)
    }
    // обязательно нужно вызвать метод Close() — в противном случае часть данных
    // может не записаться в буфер b; если нужно выгрузить все упакованные данные
    // в какой-то момент сжатия, используйте метод Flush()
    err = w.Close()
    if err != nil {
        return nil, fmt.Errorf("failed compress data: %v", err)
    }
    // переменная b содержит сжатые данные
    return b.Bytes(), nil
}

// Decompress распаковывает слайс байт.
func Decompress(data []byte) ([]byte, error) {
    // переменная r будет читать входящие данные и распаковывать их
    r := flate.NewReader(bytes.NewReader(data))
    defer r.Close()

    var b bytes.Buffer
    // в переменную b записываются распакованные данные
    _, err := b.ReadFrom(r)
    if err != nil {
        return nil, fmt.Errorf("failed decompress data: %v", err)
    }

    return b.Bytes(), nil
} 

Функция flate.NewWriter() принимает переменную интерфейсного типа io.Writer. В нашем примере это bytes.Buffer. Если указать переменную типа os.File, сжатые данные будут сразу записываться в файл.

То же самое делает функция flate.NewReader(). Для неё источником сжатых данных может быть переменная типа os.File или другого типа с поддержкой интерфейса io.Reader.

Теперь создадим текст, в котором функция strings.Repeat()создаст большое количество повторяющихся подстрок. Вызовем созданную функцию Compress().

GO
func main() {
    data := []byte(strings.Repeat(`This is a test message`, 20))
    // сжимаем содержимое data
    b, err := Compress(data)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%d bytes has been compressed to %d bytes\r\n", len(data), len(b))

    // распаковываем сжатые данные
    out, err := Decompress(b)
    if err != nil {
        log.Fatal(err)
    }
    // сравниваем начальные и полученные данные
    if !bytes.Equal(data, out) {
        log.Fatal(`original data != decompressed data`)
    }
} 

На экран выведется: 440 bytes has been compressed to 33 bytes. Получилось сжать строчку в 12 раз!

Саша

В такие моменты я вспоминаю легенду про царя Филиппа II, отца Александра Македонского. Он грозился завоевать всю Лаконию и написал спартанцам длинное письмо: «Если в Лаконию войду, я изгоню вас за пределы…»

Спартанцы были очень лаконичны — и ответили одним словом.

Но всё же данные нужно не только хранить. Ими нужно обмениваться. Для этой цели существуют алгоритмы с быстрым сжатием и распаковкой:

Brotli от Google и Zstandard сжимают данные значительно быстрее, чем Deflate, и превосходят его по степени сжатия и скорости распаковки. Но это не означает, что они лучше. Идеального по всем параметрам алгоритма сжатия просто не существует. У каждого алгоритма есть дополнительные настройки, которые влияют на степень и скорость компрессии.

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

Алгоритм	Степень сжатия,%	Скорость упаковки, MiB/sec	Скорость распаковки, MiB/sec
Zstandard	18.54	0.64	322.88
Brotli	19.49	0.34	201.15
gzip	26.31	7.72	122.91
LZ4	30.24	12.06	1258.51
Snappy	41.29	132.59	882.18

Методы сжатия и распаковки в этих пакетах тоже принимают переменные интерфейсов io.Writer и io.Reader. Благодаря этому при разработке можно переключаться с одного алгоритма на другой без больших изменений в коде и выбирать оптимальный вариант для конкретной задачи.

Вот как может выглядеть функция сжатия алгоритмом Brotli:

GO
func BrotliCompress(data []byte) ([]byte, error) {
    var buf bytes.Buffer

    w := brotli.NewWriterLevel(&buf, brotli.BestCompression)
    _, err := w.Write(data)
    if err != nil {
        return nil, err
    }
    err = w.Close()
    if err != nil {
        return nil, err
    }
    return buf.Bytes(), err
} 

Она почти идентична функции Compress, которая была рассмотрена выше. Фактически, замена функции flate.NewWriter() на brotli.NewWriterLevel() позволяет переключится с одного алгоритма сжатия на другой.

В пакетах сжатия данных часто встречается метод Flush(). Зачем он нужен?

Саша

Он позволяет принудительно сбросить остаток данных в буфере. Записывает все находящиеся во внутреннем буфере данные в выходной io.Writer. Отмечу, что при вызове Close() нет нужды вызыватьFlush().

Задание 1/5

Отметьте верные утверждения.

Можно создать и распаковать gz-файл, используя пакет compress/gzip.

Пакет compress/gzip позволяет создавать и распаковывать gz-файлы.

Только LZW и Deflate поддерживаются форматом zip.

bzip2 тоже поддерживается форматом zip.

Для сжатия создаётся переменная с реализацией интерфейса io.Reader, а для распаковки — io.Writer.

Для сжатия создаётся переменная с реализацией интерфейса io.Writer, а для распаковки — io.Reader.

В zip-архивах может использоваться любой из этих алгоритмов сжатия — LZW, bzip2 и Deflate.

Формат zip может использовать любой из этих трёх методов.

Сжатие данных сервером

Рассмотрим, как применяется сжатие данных в работе сервера. Пусть по умолчанию должны сжиматься все ответы сервера, поэтому используем middleware-обработчик. Вы уже встречались с понятием middleware в теме net/http. Напомним основные принципы.

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

Middleware применяется для аутентификации, логирования, проксирования, балансировки нагрузки и восстановления сервера после panic. Чтобы добавить в HTTP-сервер сжатие данных не нужно вносить никаких изменений в существующие обработчики. Middleware-обработчик сжатия подменит http.ResponseWriter и на лету сможет упаковывать данные в нужный формат.

Размер HTML-страницы может превышать один мегабайт, поэтому есть смысл её уменьшить. Так как передаётся текст, сервер может отправлять браузеру страницу в сжатом виде, предварительно убедившись, что клиент способен распаковать такой ответ. Для этого нужно проверить наличие и значение заголовка Accept-Encoding в запросе.

Accept-Encoding указывает на то, какой формат сжатых данных поддерживается клиентом:

gzip — сжатие gzip;
compress — сжатие LZW;
deflate — сжатие zlib;
br — сжатие brotli.

В заголовке может быть указан один или несколько поддерживаемых форматов сжатия, а также коэффициент предпочтения ;q= для конкретных форматов.

TXT

Accept-Encoding: gzip
Accept-Encoding: gzip, deflate, br
Accept-Encoding: deflate, gzip;q=1.0

После того как сервер проверил заголовок Accept-Encoding и обнаружил поддержку нужного формата сжатия, он может сжать тело ответа и отправить клиенту. Так как сжатие данных — необязательная операция, сервер должен в ответе указать признак, по которому клиент поймёт, что ответ сервера нужно распаковать.

Для этого к ответу нужно добавить заголовок Content-Encoding. Значение Content-Encoding должно равняться одному из значений Accept-Encoding и указывать на используемый формат сжатия.

TXT

Content-Encoding: gzip

Теперь рассмотрим реализацию простого сервера с поддержкой gzip-сжатия. Пусть сервер возвращает страницу с 20 строками Hello, world.

GO
func defaultHandle(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/html")
    io.WriteString(w, "<html><body>"+strings.Repeat("Hello, world<br>", 20)+"</body></html>")
} 

Поскольку требуется перехватывать и сжимать все страницы, упаковщик gzip должен подменить http.ResponseWriter и сразу же упаковать данные в нужный формат.

Опишем тип gzipWriter, поддерживающий интерфейс http.ResponseWriter.

GO
type gzipWriter struct {
    http.ResponseWriter
    Writer io.Writer
}

func (w gzipWriter) Write(b []byte) (int, error) {
    // w.Writer будет отвечать за gzip-сжатие, поэтому пишем в него
    return w.Writer.Write(b)
} 

Так как http.ResponseWriter указан без имени поля, он встраивается в тип gzipWriter, который содержит все методы этого интерфейса. В противном случае нужно было бы описать методы Header и WriteHeader. В примере для gzipWriter достаточно переопределить метод Write.

Напишем обработчик, который будет сжимать данные, и подключим его к серверу как middleware. Для этого определим функцию, которая принимает в параметре обработчик http.Handler и возвращает себя как новый обработчик. Таким образом, запрос к серверу попадёт в эту функцию, где при необходимости можно заменить обычный Writer на gzip.Writer, и он обеспечит сжатие данных. Если вы используете для управления HTTP-сервером внешний пакет, то подключение middleware может отличаться от приведённого примера.

GO
func gzipHandle(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // проверяем, что клиент поддерживает gzip-сжатие
        // это упрощённый пример. В реальном приложении следует проверять все
        // значения r.Header.Values("Accept-Encoding") и разбирать строку
        // на составные части, чтобы избежать неожиданных результатов
        if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
            // если gzip не поддерживается, передаём управление
            // дальше без изменений
            next.ServeHTTP(w, r)
            return
        }

        // создаём gzip.Writer поверх текущего w
        gz, err := gzip.NewWriterLevel(w, gzip.BestSpeed)
        if err != nil {
            io.WriteString(w, err.Error())
            return
        }
        defer gz.Close()

        w.Header().Set("Content-Encoding", "gzip")
        // передаём обработчику страницы переменную типа gzipWriter для вывода данных
        next.ServeHTTP(gzipWriter{ResponseWriter: w, Writer: gz}, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", defaultHandle)
    http.ListenAndServe(":3000", gzipHandle(mux))
} 

Минимальным кодом получилось создать сервер с поддержкой gzip. Если добавить в сервер другие страницы, они тоже будут автоматически сжиматься. Запустите программу и посмотрите в браузере, как работает сжатие.

Созданный сервер далёк от идеала и не учитывает некоторые моменты.

Во-первых, перед тем как приступить к сжатию, нужно убедиться, что передаваемые данные имеет смысл сжимать, что это не изображение, документ или архивный файл. Лучше определить и использовать массив значений Content-Type, при которых будет происходить сжатие. Например:

TXT

application/javascript
application/json
text/css
text/html
text/plain
text/xml

И нужно дополнительно проверять заголовок Content-Type на соответствие данному списку.

Во-вторых, стоит решить вопрос о сжатии маленьких файлов (до 1400 байт), так как особой выгоды здесь нет: данные всё равно передаются пакетами определённого размера. Если этот момент не описан в ТЗ, он остаётся на усмотрение разработчика.

В-третьих, нужно подумать над тем, как отказаться от постоянного вызова gzip.NewWriterLevel и использовать метод gzip.Reset, чтобы избежать выделения памяти при каждом запросе.

Можно найти готовые фреймворки и пакеты, которые учитывают эти проблемы при работе с gzip, и изучить их реализацию.

Задание 2/5

Реализуйте аналог обработчика gzipHandle в разобранном выше примере, который использует zlib формат вместо gzip. Помните, что в этом случае нужно проверять Accept-Encoding на наличие deflate.

Готово

GO
package main

import (
    "compress/flate"
    "compress/zlib"
    "io"
    "net/http"
    "strings"
)

type zlibWriter struct {
    http.ResponseWriter
    Writer io.Writer
}

func (w zlibWriter) Write(b []byte) (int, error) {
    // w.Writer будет отвечать за zlib-сжатие, поэтому пишем в него
    return w.Writer.Write(b)
}

func defaultHandle(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/html")
    io.WriteString(w, "<html><body>"+strings.Repeat("Hello, world<br>", 20)+"</body></html>")
}

func deflateHandle(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // проверяем, что клиент поддерживает deflate-сжатие
        if !strings.Contains(r.Header.Get("Accept-Encoding"), "deflate") {
            next.ServeHTTP(w, r)
            return
        }
        flatew, err := zlib.NewWriterLevel(w, flate.BestCompression)
        if err != nil {
            io.WriteString(w, err.Error())
            return
        }
        defer flatew.Close()

        w.Header().Set("Content-Encoding", "deflate")
        next.ServeHTTP(zlibWriter{ResponseWriter: w, Writer: flatew}, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", defaultHandle)
    http.ListenAndServe(":3000", deflateHandle(mux))
} 

Задание 3/5

Выберите верные утверждения.

middleware может прекратить обработку запроса и вернуть ответ.

Для этого не нужно вызывать следующий обработчик. Чаще всего это происходит в случае ошибочной ситуации.

gzip-сжатие на сервере нельзя реализовать без middleware.

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

Отдавать сжатый ответ можно только при наличии соответствующего формата в Accept-Encoding.

Сжатие данных можно делать только тогда, когда принимающая сторона может их распаковать.

Использование заголовка Content-Encoding для сжатых данных опционально.

Без этого заголовка клиент не узнает сжаты ли данные и в каком формате.

Распаковка данных

Если вы отправляете запрос HTTP-серверу стандартным Go-клиентом, он автоматически добавляет заголовок Accept-Encoding: gzip и распаковывает полученный ответ. В этом случае не нужно добавлять распаковку в код клиента.

Рассмотрим ситуацию, когда серверу может прийти запрос со сжатыми данными. Приведённый ниже обработчик получает в теле запроса сжатые данные в формате gzip, распаковывает и возвращает их оригинальный размер.

GO
// LengthHandle возвращает размер распакованных данных.
func LengthHandle(w http.ResponseWriter, r *http.Request) {
    // создаём *gzip.Reader, который будет читать тело запроса
    // и распаковывать его
    gz, err := gzip.NewReader(r.Body)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    // закрытие gzip-читателя опционально, т.к. все данные уже прочитаны и 
    // текущая реализация не требует закрытия, тем не менее лучше это делать -
    // некоторые реализации могут рассчитывать на закрытие читателя
    // gz.Close() не вызывает закрытия r.Body - это будет сделано позже, http-сервером
    defer gz.Close()

    // при чтении вернётся распакованный слайс байт
    body, err := io.ReadAll(gz)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    fmt.Fprintf(w, "Length: %d", len(body))
} 

Распаковка сжатых gzip-данных не сильно отличается от распаковки Deflate. Этот обработчик считает, что к нему приходят только упакованные данные. Если в запросе отправить обычный текст, вернётся ошибка.

Задание 4/5

Измените обработчик LengthHandle так, чтобы он распаковывал тело запроса только при наличии заголовка Content-Encoding: gzip. Если заголовка нет, должен возвращаться размер тела запроса без декомпрессии.

Готово

GO
func LengthHandle(w http.ResponseWriter, r *http.Request) {
    // переменная reader будет равна r.Body или *gzip.Reader
    var reader io.Reader

    if r.Header.Get(`Content-Encoding`) == `gzip` {
        gz, err := gzip.NewReader(r.Body)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        reader = gz
        defer gz.Close()
    } else {
        reader = r.Body
    }

    body, err := io.ReadAll(reader)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    fmt.Fprintf(w, "Length: %d", len(body))
} 

Задание 5/5

Отметьте верные утверждения.

Вызов метода Close() обязателен после сжатия.

Важно вызвать метод Close(), потому что он отправляет оставшиеся данные.

Метод Header.Get(key string) возвращает все значения указанного ключа.

Этот метод возвращает только первое значение.

На сервере можно сжать только нужные типы данных, чтобы не сжимать всё подряд.

Используя значение заголовка Content-Type, можно реализовать выборочное сжатие данных.

Наличие Accept-Encoding в заголовке разрешает отправлять контент в gzip-формате.

Можно отправлять, только если значение Accept-Encoding содержит gzip.

Саша

Здесь вроде бы есть Wi-Fi — давай попробуем подключиться. Созвонимся с Лизой и Гошей, узнаем, как там у них дела.

Давай. Воу, уже посыпались уведомления. Каждый день удивляюсь: откуда у людей столько времени, чтобы все их читать?

Саша

Как раз для этого наша голосовая почта может пригодиться — будет зачитывать только самые важные сообщения. О, ребята, привет!

Гоша

День добрый!

Забавно. Гоша и Лиза теперь на экране ноутбука, а Алиса здесь, рядом со мной.

Алиса

Неправда. Вашу Алису и там, и тут передают!

Лиза

И не поспоришь ведь. Гош, давай сегодня про сжатие данных поговорим.

Обучаем Алису

Гоша

Запросы от клиента, как и ответы от сервера, могут весить очень много — вплоть до десятков мегабайт.

Лиза

Чтобы сократить время передачи данных, можно применить эффективный алгоритм сжатия. Например, распространённый формат gzip.

Гоша

Поскольку HTTP/1.1 — этой текстовый протокол, передаваемые по нему данные отлично поддаются компрессии. Причём с невысоким расходом процессора на обработку алгоритма сжатия.

Добавим в навык Алисы поддержку сжатия и декомпрессии данных. Сделаем это через механизм middleware, чтобы отделить реализацию хендлера запросов от реализации сжатия и декомпрессии. Тогда хендлер не будет заботиться о том, сжимались ли данные на стороне клиента. Он просто продолжит пользоваться стандартными объектами http.ResponseWriter и *http.Request, как и раньше.

Создадим файл cmd/skill/gzip.go:

> ~/dev/alice-skill
       |
       |--- cmd
       |     |--- skill
       |            |--- flags.go
       |            |--- gzip.go
       |            |--- main.go
       |            |--- main_test.go
       |--- internal
       |       |--- logger
       |       |      |--- logger.go
       |       |--- models
       |              |--- models.go
       |--- go.mod
       |--- go.sum

В новый файл поместим код, который будет реализовывать http.ResponseWriter, и поле Body объекта *http.Request:

GO
package main

import (
    "compress/gzip"
    "io"
    "net/http"
)

// compressWriter реализует интерфейс http.ResponseWriter и позволяет прозрачно для сервера
// сжимать передаваемые данные и выставлять правильные HTTP-заголовки
type compressWriter struct {
    w  http.ResponseWriter
    zw *gzip.Writer
}

func newCompressWriter(w http.ResponseWriter) *compressWriter {
    return &compressWriter{
        w:  w,
        zw: gzip.NewWriter(w),
    }
}

func (c *compressWriter) Header() http.Header {
    return c.w.Header()
}

func (c *compressWriter) Write(p []byte) (int, error) {
    return c.zw.Write(p)
}

func (c *compressWriter) WriteHeader(statusCode int) {
    if statusCode < 300 {
        c.w.Header().Set("Content-Encoding", "gzip")
    }
    c.w.WriteHeader(statusCode)
}

// Close закрывает gzip.Writer и досылает все данные из буфера.
func (c *compressWriter) Close() error {
    return c.zw.Close()
}

// compressReader реализует интерфейс io.ReadCloser и позволяет прозрачно для сервера
// декомпрессировать получаемые от клиента данные
type compressReader struct {
    r  io.ReadCloser
    zr *gzip.Reader
}

func newCompressReader(r io.ReadCloser) (*compressReader, error) {
    zr, err := gzip.NewReader(r)
    if err != nil {
        return nil, err
    }

    return &compressReader{
        r:  r,
        zr: zr,
    }, nil
}

func (c compressReader) Read(p []byte) (n int, err error) {
    return c.zr.Read(p)
}

func (c *compressReader) Close() error {
    if err := c.r.Close(); err != nil {
        return err
    }
    return c.zr.Close()
} 

Теперь нужно дополнить код в файле main.go. Добавим в него middleware-функцию и обернём ею хендлер:

GO
func gzipMiddleware(h http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // по умолчанию устанавливаем оригинальный http.ResponseWriter как тот,
        // который будем передавать следующей функции
        ow := w

        // проверяем, что клиент умеет получать от сервера сжатые данные в формате gzip
        acceptEncoding := r.Header.Get("Accept-Encoding")
        supportsGzip := strings.Contains(acceptEncoding, "gzip")
        if supportsGzip {
            // оборачиваем оригинальный http.ResponseWriter новым с поддержкой сжатия
            cw := newCompressWriter(w)
            // меняем оригинальный http.ResponseWriter на новый
            ow = cw
            // не забываем отправить клиенту все сжатые данные после завершения middleware
            defer cw.Close()
        }

        // проверяем, что клиент отправил серверу сжатые данные в формате gzip
        contentEncoding := r.Header.Get("Content-Encoding")
        sendsGzip := strings.Contains(contentEncoding, "gzip")
        if sendsGzip {
            // оборачиваем тело запроса в io.Reader с поддержкой декомпрессии
            cr, err := newCompressReader(r.Body)
            if err != nil {
                w.WriteHeader(http.StatusInternalServerError)
                return
            }
            // меняем тело запроса на новое
            r.Body = cr
            defer cr.Close()
        }

        // передаём управление хендлеру
        h.ServeHTTP(ow, r)
    }
}

// ...

func run() error {
    if err := logger.Initialize(flagLogLevel); err != nil {
    return err
    }

    logger.Log.Info("Running server", zap.String("address", flagRunAddr))
    // оборачиваем хендлер webhook в middleware с логированием и поддержкой gzip
    return http.ListenAndServe(flagRunAddr, logger.RequestLogger(gzipMiddleware(webhook)))
} 

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

GO
// ...

func TestGzipCompression(t *testing.T) {
    handler := http.HandlerFunc(gzipMiddleware(webhook))
    
    srv := httptest.NewServer(handler)
    defer srv.Close()
    
    requestBody := `{
        "request": {
            "type": "SimpleUtterance",
            "command": "sudo do something"
        },
        "version": "1.0"
    }`

    // ожидаемое содержимое тела ответа при успешном запросе
    successBody := `{
        "response": {
            "text": "Извините, я пока ничего не умею"
        },
        "version": "1.0"
    }`
    
    t.Run("sends_gzip", func(t *testing.T) {
        buf := bytes.NewBuffer(nil)
        zb := gzip.NewWriter(buf)
        _, err := zb.Write([]byte(requestBody))
        require.NoError(t, err)
        err = zb.Close()
        require.NoError(t, err)
        
        r := httptest.NewRequest("POST", srv.URL, buf)
        r.RequestURI = ""
        r.Header.Set("Content-Encoding", "gzip")
        
        resp, err := http.DefaultClient.Do(r)
        require.NoError(t, err)
        require.Equal(t, http.StatusOK, resp.StatusCode)
        
        defer resp.Body.Close()
        
        b, err := io.ReadAll(resp.Body)
        require.NoError(t, err)
        require.JSONEq(t, successBody, string(b))
    })

    t.Run("accepts_gzip", func(t *testing.T) {
        buf := bytes.NewBufferString(requestBody)
        r := httptest.NewRequest("POST", srv.URL, buf)
        r.RequestURI = ""
        r.Header.Set("Accept-Encoding", "gzip")
        
        resp, err := http.DefaultClient.Do(r)
        require.NoError(t, err)
        require.Equal(t, http.StatusOK, resp.StatusCode)
        
        defer resp.Body.Close()
        
        zr, err := gzip.NewReader(resp.Body)
        require.NoError(t, err)
        
        b, err := io.ReadAll(zr)
        require.NoError(t, err)
        
        require.JSONEq(t, successBody, string(b))
    })
} 

Запустим тесты и убедимся, что все проверки завершаются успешно:

SHELL

=== RUN   Test_webhook
--- PASS: Test_webhook (0.00s)
...
=== RUN   TestGzipCompression
--- PASS: TestGzipCompression (0.00s)
=== RUN   TestGzipCompression/sends_gzip
    --- PASS: TestGzipCompression/sends_gzip (0.00s)
=== RUN   TestGzipCompression/accepts_gzip
    --- PASS: TestGzipCompression/accepts_gzip (0.00s)
PASS
Process finished with the exit code 0

Лиза

Gотово-лайтово!

Гоша

Теперь сервер может эффективно обрабатывать и передавать данные даже по не очень быстрым каналам.

Ребята, спасибо большое! Объявили нашу посадку, так что нам пора отключаться. Созвонимся завтра!

Саша

До связи!

Вы заходите в самолёт и рассаживаетесь по местам.

Саша

Пока летим, можешь ещё что-нибудь почитать по теме или инкремент по проекту сделать.

Да, пожалуй, этим и займусь.

Дополнительные материалы

В стандартной библиотеке Go есть ещё два пакета, которые имеют отношение к сжатию данных. Пакеты archive/tar и archive/zip предназначены для создания и распаковки архивных файлов соответствующих форматов. Если нужна поддержка других архивов, можно воспользоваться пакетом mholt/archiver.

В этом уроке не рассматривалась работа с архивами, но вы можете попрактиковаться самостоятельно. Например, заставить сервер на лету генерировать документ, упаковывать его в zip и отдавать для скачивания. Или, не прибегая к внешним зависимостям, найти и заменить текст в docx- или xlsx-файле.

Хабр | Интерфейсные типы io.Reader и io.Writer — статья об интерфейсных типах.
Echo | Gzip Middleware — пример реализации gzip в HTTP-сервере.
GitHub | Zstandard — алгоритм сжатия Zstandard.
GitHub | NYTimes/gziphandler — пакет gziphandler.
GitHub | mholt/archiver — пакет mholt/archiver для работы с архивами.
GitHub | Squash Compression Benchmark — Squash Compression Benchmark.
MDN Web Docs | Accept-Encoding — спецификация заголовка Accept-Encoding.
MDN Web Docs | Content-Encoding — спецификация заголовка Content-Encoding.

Спринт 2

Пакет compress. Сжатие данных

Оптимизация передачи данных

Пакеты для сжатия данных

Задание 1/5

Сжатие данных сервером

Задание 2/5

Задание 3/5

Распаковка данных

Задание 4/5

Задание 5/5

Обучаем Алису

Дополнительные материалы