💬 События публикуются дважды

Сервис сохраняет заказ в БД и сразу публикует событие OrderCreated. Выглядит логично, но БД и очередь это две отдельные системы.

Что может произойти: БД коммитилась, но публикация упала. Заказ есть, события нет. Клиент повторяет запрос из за таймаута. Событие публикуется еще раз. Нижестоящий сервис видит два события и создает два заказа вместо одного.

➡️ Решение: Outbox паттерн

Сохраняем заказ и событие в одной БД транзакции. Отдельный диспетчер читает неотправленные события и публикует их позже. Если диспетчер упадет или повторится, событие уже в БД и не потеряется.

// В одной транзакции
BEGIN
  INSERT INTO orders ...
  INSERT INTO outbox ...
COMMIT

// Отдельно
func dispatchOutbox() {
  events := store.GetUnsent()
  for _, e := range events {
    publisher.Send(e)
    store.MarkSent(e.ID)
  }
}

➡️ Ключевые моменты

Каждое событие должно иметь уникальный ID. Потребители должны быть идемпотентные (игнорировать дубликаты). Outbox паттерн гарантирует, что событие не потеряется, но не гарантирует ровно одну доставку. Это нормально, если потребители правильно обрабатывают дубликаты.

➡️ Что делать

Добавьте таблицу outbox. Вставляйте заказ и событие одной транзакцией. Запустите диспетчер, который периодически отправляет события из outbox. Добавьте уникальный event_id потребителям для фильтрации дубликатов.

Граница между микросервисами это самое опасное место. Outbox паттерн это простой способ сделать ее безопаснее.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoToProduction

🎸 Конференция, которая заканчивается концертом

ИТ-Пикник 2026 — это не только доклады. Музыкальный хедлайнер — LAB, шоу Антона Беляева и команды Therr Maitz: популярные треки в новых аранжировках с оркестром и хором. А ещё ИТ-Квартирник — отдельная сцена для музыкантов из мира технологий, где семь команд из опен-колла борются за право выйти на главную сцену с Pompeya.

➡️ Собрали всё, что известно о фестивале

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoGiggle

⭐️ Пишем долгоживущую программу на Go с GOGC=off. Часть 1, GOMEMLIMIT

Короткий ответ: да, но не так, как обычно себе это представляют. Полностью выключенный сборщик мусора почти всегда означает, что программа рано или поздно съест всю память. Работающие варианты сводятся к тому, что GC не выключается совсем, а перестаёт запускаться по росту кучи и начинает запускаться по вашим правилам.

В этой части разберём, что делает GOGC=off, почему наивный вариант падает, и самый практичный способ жить без сборок, связку с GOMEMLIMIT.

➡️ Что делает GOGC

GOGC задаёт, насколько куча должна вырасти относительно живых данных, прежде чем начнётся следующий цикл сборки. При значении по умолчанию 100 сборка стартует, когда куча удвоилась относительно объёма живых объектов после прошлого цикла. При GOGC=200 цикл будет реже и памяти уйдёт больше. При GOGC=off триггер по росту кучи пропадает совсем.

То же самое можно сделать из кода:

import "runtime/debug"

func main() {
    debug.SetGCPercent(-1) // эквивалент GOGC=off
    // ...
}

Важно понимать, что аллокатор при этом никуда не девается. Программа продолжает выделять память, просто освобождать её никто не будет. Каждый временный слайс, каждая строка от fmt.Sprintf, каждый заголовок HTTP запроса остаются в куче навсегда. Для батча, который живёт три секунды и завершается, это идеально. Для сервиса, который работает неделями, это утечка по определению.

➡️ Почему наивный вариант падает

Возьмём типичный HTTP сервис. Даже если ваш собственный код не аллоцирует, стандартная библиотека аллоцирует за вас. net/http создаёт объекты на каждый запрос, encoding/json создаёт их на каждый декод, драйвер базы создаёт их на каждый ряд. При тысяче запросов в секунду и паре килобайт мусора на запрос вы получаете около двух мегабайт в секунду, то есть примерно семь гигабайт в час. Дальше приходит OOM killer.

Поэтому вопрос не в том, можно ли выключить GC, а в том, чем заменить триггер, который вы выключили.

➡️ GOMEMLIMIT как замена триггера

GOMEMLIMIT — самый практичный подход и он появился в Go 1.19. Комбинация GOGC=off и GOMEMLIMIT даёт сборщик, который не реагирует на рост кучи вообще, но запускается, когда потребление памяти приближается к заданному лимиту.

GOGC=off GOMEMLIMIT=4GiB ./myservice

Или из кода:

debug.SetGCPercent(-1)
debug.SetMemoryLimit(4 << 30) // 4 GiB

Что вы получаете. Пока памяти хватает, циклов сборки нет совсем, а значит нет накладных расходов на маркировку и барьеры записи. Как только программа подходит к лимиту, GC включается и удерживает потребление около него. Куча живёт в стабильном состоянии, а не пилой от нуля до удвоения.

Что вы теряете. Если объём живых данных сам по себе дорастает до лимита, GC начнёт запускаться непрерывно и программа уйдёт в смерть от сборки, когда почти всё время уходит на бесполезные циклы. Лимит поэтому ставят с запасом относительно ожидаемого объёма живых данных, а не впритык к памяти контейнера. Разумная практика ставить GOMEMLIMIT процентов на десять ниже лимита пода, чтобы GC успел среагировать раньше, чем это сделает cgroup.

Ещё одна тонкость. GOMEMLIMIT учитывает всю память рантайма, включая стеки горутин и служебные структуры, но не учитывает то, что выделено вне рантайма, например через cgo или mmap. Если такого много, лимит надо занижать дополнительно.

➡️ Про ballast

Раньше был популярен трюк с большим фиктивным слайсом, который выделяли на старте, чтобы поднять порог срабатывания GC. Сейчас он не нужен. GOMEMLIMIT решает ту же задачу.

Итог первой части

GOGC=off сам по себе это не оптимизация, а отложенный OOM. Но GOGC=off вместе с GOMEMLIMIT вполне живёт в проде годами. Сборщик молчит на нормальной нагрузке и вступает в дело только у границы, которую вы задали сами.

Во второй части посмотрим на два более жёстких варианта. Ручные вызовы runtime.GC() в окнах простоя и код, который вообще не аллоцирует после старта.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoDeep

🔒 age, шифрование файлов без конфигов и без GPG

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

age делает ровно эту задачу и ничего больше. Инструмент шифрования файлов, формат и Go библиотека от Филиппо Вальсорды. Маленькие явные ключи, никаких опций конфигурации, поведение в духе UNIX. Формат описан спецификацией age-encryption.org/v1.

Базовый сценарий

Три команды:

$ age-keygen -o key.txt
Public key: age1ql3z7hjy54pw3hyww5ayyfg7zqgvc7w3j2elw8zmrj2kg5sfn9aqmcac8p

$ tar cvz ~/data | age -r age1ql3z7... > data.tar.gz.age

$ age -d -i key.txt data.tar.gz.age > data.tar.gz

Публичный ключ это одна строка с префиксом age1, приватный одна строка с префиксом AGE-SECRET-KEY-1. Никакого keyring и никакого состояния на диске кроме файла с ключом.

Что ещё умеет

Флаг -r можно повторять, тогда файл расшифрует любой из получателей. Список получателей удобнее держать файлом и передавать через -R. Флаг -p шифрует паролем, причём при пустом вводе age сгенерирует стойкую фразу сам. Флаг -a даёт текстовый PEM вывод, если файл надо вставить в письмо или в YAML. При расшифровке тип файла определяется автоматически.

Приятно, что можно шифровать на обычные SSH ключи:

$ age -R ~/.ssh/id_ed25519.pub example.jpg > example.jpg.age
$ age -d -i ~/.ssh/id_ed25519 example.jpg.age > example.jpg

Отсюда трюк с GitHub, где публичные ключи лежат по адресу вида github.com/username.keys:

$ curl https://github.com/benjojo.keys | age -R - example.jpg > example.jpg.age

С версии 1.3.0 есть гибридные постквантовые ключи через age-keygen -pq. Цена в том, что публичный ключ получателя разрастается примерно до двух тысяч символов.

Как библиотека

CLI это обёртка над пакетом filippo.io/age:

recipient, _ := age.ParseX25519Recipient(pubKey)

out := &bytes.Buffer{}
w, err := age.Encrypt(out, recipient)
if err != nil {
    log.Fatal(err)
}
io.WriteString(w, "секретные данные")
w.Close() // обязателен, иначе не запишется финальный блок

Всё построено на io.Reader и io.Writer, поэтому поток по сети шифруется так же, как строка в памяти. Расшифровка через age.Decrypt с age.ParseX25519Identity.

Ставится из репозиториев почти везде, либо командой go install filippo.io/age/cmd/...@latest.

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

➡️ Репозиторий

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoToProduction

😋 Топ-вакансий для Go-разработчиков за неделю

Go-разработчик — от 365 000 ₽, Удаленно (Москва)

Golang разработчик — офис в Москве

Senior Backend Engineer — от 450 000 ₽, удаленно (Москва)

➡️ Еще больше топовых вакансий — в нашем канале Go jobs

🐸 Библиотека Go-разработчика

#GoWork

⭐️ Пишем долгоживущую программу на Go с GOGC=off. Часть 2, ручной GC и код без аллокаций

В первой части мы разобрали связку GOGC=off и GOMEMLIMIT. Она подходит большинству сервисов и не требует переписывать код. Но есть задачи, где даже редкие циклы сборки в неудачный момент неприемлемы. Торговый бот в момент котировки, игровой сервер внутри тика, обработчик, у которого хвостовые задержки важнее среднего времени ответа.

Для таких случаев есть два более жёстких варианта.

➡️ Вариант первый, ручные циклы в окнах простоя

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

debug.SetGCPercent(-1)

for {
    batch := queue.Fetch()
    process(batch) // на этом участке GC не вмешивается

    if idle() {
        runtime.GC()
        debug.FreeOSMemory() // ещё и вернуть память операционной системе
    }
}


runtime.GC() выполняет полный цикл синхронно и возвращает управление, когда он закончен. debug.FreeOSMemory() делает то же самое и дополнительно отдаёт освободившиеся страницы ОС, что полезно, если вы платите за резидентную память, а не за виртуальную.

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

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

var m runtime.MemStats

func maybeCollect(limit uint64) {
    runtime.ReadMemStats(&m) // это stop the world, не вызывайте в горячем цикле
    if m.HeapAlloc > limit {
        runtime.GC()
    }
}


runtime.ReadMemStats сам по себе останавливает мир, так что вызывать его надо по таймеру раз в секунду, а не на каждой итерации.

➡️ Вариант второй, программа без аллокаций

Теоретически самый чистый путь. Если после инициализации программа не аллоцирует в куче вообще, сборщику нечего собирать и GOGC=off безопасен буквально навсегда.

Это означает выделение всех буферов на старте, переиспользование через sync.Pool или собственные пулы, отказ от fmt в горячем пути, отказ от интерфейсов там, где значение убегает в кучу, работу со срезами фиксированной ёмкости вместо растущего append.

Проверять это надо не на глаз, а инструментами:

go build -gcflags='-m' ./...   // что именно убегает в кучу
go test -bench=. -benchmem     // столбец allocs/op должен быть нулевым

И регрессионный тест, который падает, как только счётчик аллокаций перестал быть нулём:

func TestNoAllocs(t *testing.T) {
    allocs := testing.AllocsPerRun(1000, func() {
        process(input) // горячий путь
    })
    if allocs != 0 {
        t.Fatalf("ожидали 0 аллокаций, получили %v", allocs)
    }
}

Честное предупреждение. Держать такое состояние в живом проекте тяжело. Одна безобидная строка логирования, один err.Error() в неудачном месте, и аллокации возвращаются. Обычно так пишут узкое ядро системы, а весь остальной сервис живёт с обычным GC.

Когда всё это оправдано

Выключать сборщик стоит только после измерений. Профиль показывает заметное время в runtime.gcBgMarkWorker, трассировка показывает всплески задержек ровно на циклах сборки, или программа настолько короткоживущая, что сборка просто не успевает окупиться.
Во всех остальных случаях достаточно поднять GOGC до 200 или 400. Это даёт большую часть выигрыша и не создаёт риска OOM.

Долгоживущая программа с GOGC=off возможна, если вы не оставляете систему без тормозов совсем. GOMEMLIMIT подходит почти всем и не требует менять код. Ручные вызовы runtime.GC() в окнах простоя дают самые ровные задержки, но нуждаются в страховке по памяти. Код без аллокаций работает вечно, но живёт только под постоянным присмотром бенчмарков.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoDeep

🧑‍💻 В Go захотели поддержку GOARM64=v9.6

В трекере Go появилось предложение №80402. Разработчик просит добавить новое значение переменной GOARM64 со значением v9.6 и тег сборки arm64.v9.6, чтобы тулчейн умел собирать под архитектуру Armv9.6-A.

Вместе с версией предлагают включать набор инструкций FEAT_CMPBR автоматически. Он объединяет сравнение и условный переход в одну операцию, в Armv9.6-A обязателен, поэтому отдельная опция не нужна. По умолчанию поведение не меняется, значение пригодится тем, кто собирает под свежие чипы на Armv9.6-A.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoLive

🛡 Защита от SQL инъекций и XSS в Go

Оба типа атак растут из одной ошибки. Мы склеиваем строку из данных пользователя и отдаём её движку, который умеет исполнять код. База данных видит SQL, браузер видит HTML или JavaScript. Данные внезапно становятся командами.

Разберём, как этого не допускать на практике, и что спросят на собеседовании.

💉 SQL инъекции

Опасный код выглядит так:

query := fmt.Sprintf("SELECT id, email FROM users WHERE email = '%s'", email)
row := db.QueryRow(query)

Если в email придёт ' OR 1=1 --, условие развалится и вернётся вся таблица. Строка форматируется до того, как попадёт в базу, поэтому никакой защиты тут нет.

Правильный вариант передаёт значения отдельно от текста запроса:

row := db.QueryRowContext(ctx,
    "SELECT id, email FROM users WHERE email = $1", email)

Драйвер отправляет запрос и параметры разными полями протокола. Значение уже не может изменить структуру запроса, потому что база разбирает синтаксис до подстановки данных. Синтаксис плейсхолдера зависит от драйвера, в pgx и lib/pq это $1, в go-sql-driver/mysql это ?.

Что нельзя параметризовать

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

var allowedSort = map[string]string{
    "created": "created_at",
    "email":   "email",
}

column, ok := allowedSort[r.URL.Query().Get("sort")]
if !ok {
    column = "created_at"
}

query := fmt.Sprintf("SELECT id FROM users ORDER BY %s DESC LIMIT 50", column)

Форматирование строки тут безопасно, потому что в column попадает только заранее известное значение из карты, а не пользовательский ввод.

Отдельно стоит помнить про IN. Список плейсхолдеров придётся собрать самому:

placeholders := make([]string, len(ids))
args := make([]any, len(ids))
for i, id := range ids {
    placeholders[i] = fmt.Sprintf("$%d", i+1)
    args[i] = id
}

query := "SELECT id FROM users WHERE id IN (" + strings.Join(placeholders, ",") + ")"
rows, err := db.QueryContext(ctx, query, args...)

В pgx проще передать массив через = ANY($1).
Билдеры вроде squirrel и ORM вроде gorm подставляют аргументы сами. Но у обоих есть методы для сырых кусков SQL, и туда пользовательский ввод класть нельзя. gorm спасает не сам по себе, а только пока мы не пишем Where(fmt.Sprintf(...)).

Дополнительные меры, которые уменьшают ущерб при ошибке. Отдельный пользователь базы с минимальными правами, без DROP и без доступа к чужим схемам. Логи запросов без подстановленных значений. Ограничение на размер входных полей.

🔪 XSS

Та же логика, только теперь опасный движок это браузер. Если мы вставим пользовательский текст прямо в HTML, тег <script> из комментария выполнится у всех, кто открыл страницу.

Плохо:

fmt.Fprintf(w, "<div>Привет, %s</div>", name)

Хорошо:

tmpl := template.Must(template.New("page").Parse(
    `<div>Привет, {{ .Name }}</div>`))
tmpl.Execute(w, data)

Ключевое отличие в пакете. html/template экранирует данные с учётом контекста, text/template не экранирует ничего. Импорт text/template в веб хендлере это готовая дыра, и на собеседовании про это спрашивают почти всегда.

Контекстность означает, что шаблонизатор смотрит, куда именно попадает значение. Внутри тега это HTML экранирование, внутри атрибута другое, внутри href проверка схемы, внутри блока <script> экранирование по правилам JavaScript.

Один и тот же {{ .Value }} даст разный вывод:

tmpl := template.Must(template.New("x").Parse(`
<a href="{{ .URL }}" title="{{ .Title }}">{{ .Title }}</a>
<script>var user = {{ .Name }};</script>
`))

Строка javascript:alert(1) в href превратится в #ZgotmplZ, то есть ссылка просто не сработает.

➡️ Где защита отключается

Типы template.HTML, template.JS, template.URL говорят шаблонизатору доверять содержимому и не трогать его. Это законная возможность, но применять её к данным пользователя нельзя:

// так делать нельзя
data.Bio = template.HTML(userInput)

Если пользователю действительно нужен HTML, например разметка в комментариях, содержимое надо чистить санитайзером:

import "github.com/microcosm-cc/bluemonday"

p := bluemonday.UGCPolicy()
safe := template.HTML(p.Sanitize(userInput))


bluemonday работает по белому списку тегов и атрибутов, всё остальное вырезает.

➡️ API и заголовки

Для JSON ответов достаточно encoding/json, он экранирует <, > и & в escape последовательности. Но заголовок ставить обязательно, иначе браузер может угадать тип и отрендерить ответ как HTML.

w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Header().Set("X-Content-Type-Options", "nosniff")
json.NewEncoder(w).Encode(resp)

Хорошая практика добавить Content-Security-Policy, который запрещает инлайновые скрипты. Он не заменяет экранирование, но снижает шанс, что случайная дыра превратится в кражу сессий. Куки сессии стоит помечать HttpOnly, тогда украденный скрипт до них не доберётся.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoDeep

🤩 Go открыт для разработки 1.28

Команда Go сообщила о статусе релиза Go 1.27, он скоро уйдёт в релиз, а основная ветка уже открыта для общей разработки Go 1.28.

Пока идёт стабилизация 1.27. В треде разработчики уже расписали планы на следующую версию.

Будут чинить баги корректности компилятора, добавлять инкрементальные оптимизации в regalloc и планировщик, а также убирать рукописный ассемблер в пользу чистого Go.

Будут переработаны узкие места масштабируемости сборщика мусора при работе на более чем 256 ядрах и проведут эксперименты с NUMA осведомлённостью Green Tea.

➡️ Источник

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoLive

🫡 Один и тот же запрос к AI можно выполнить двумя способами — и получить совершенно разный результат.

1️⃣ способ — просто попросить написать код. Модель может сгенерировать рабочее решение, но именно на этапе проверки часто всплывают пропущенные edge case’ы, ошибки обработки или проблемы с тестами.

2️⃣ способ — дать агенту цикл Think → Act → Observe. Он не останавливается после первой попытки: планирует действия, проверяет результат и, если находит ошибку, исправляет её и пробует снова.

Самое интересное, что разница здесь не столько в модели ❕ Claude, GPT или другая LLM могут быть одинаковыми. Разницу создаёт инженерная система вокруг них.

📅 Именно это разберём 23 июля в 19:00 (МСК) на бесплатном вебинаре с Алексеем Жиряковым (Executive Director в Сбере, GenAI Data Platform, ex-CTO Stream и KION).

На живом демо покажем, как один и тот же запрос работает без агентной системы и с ней 🔥

🔗 Регистрация

🏃‍♀️ Proglib Academy