📦 Для Go появился лёгкий и удобный инструмент для событийной архитектуры

signals — это минималистичная библиотека без зависимостей, которая реализует простой pub-sub механизм для ваших Go-приложений.

Особенности:
- никаких внешних зависимостей
- тонкий и понятный API
- удобный in-process event system

Репозиторий: https://github.com/maniartech/signals

#golang

🆕 На Stepik вышел курс — «Golang + SQLx: построение высоконагруженных сервисов с нуля до продакшена» 

Уже пишете на Go и хотите разобраться, как строить быстрые и отказоустойчивые сервисы? Этот курс — именно то, что нужно, чтобы прокачать навыки работы с SQLx и backend-архитектурой.

• Полный путь от CRUD-операций до масштабируемых систем: транзакции, уровни изоляции, конкурентное программирование, балансировка нагрузки
• Оптимизация SQL: индексы, кэширование, профилирование запросов
• Масштабирование и администрирование сервисов: кластеры, отказоустойчивость, мониторинг и логирование
• Практика на реальных кейсах: проектируем API, отрабатываем ошибки, настраиваем CI/CD
• 150+ интерактивных заданий с автопроверкой — пишите код прямо в браузере, когда удобно
• Итоговый pet-project: к концу курса у вас будет готовый сервис уровня продакшн

🎓 Сертификат по завершении — добавьте его в резюме или профиль LinkedIn

🚀 Прокачайте Golang и SQLx с пользой и практикой. Начните уже сегодня и получите скидку 30%, которая действует в течение 48 часов.

👉 Пройти курс на Stepik

Graceful Shutdowns в Go HTTP-серверах: как обеспечить 0 простоев при живом трафике

Graceful shutdown - это “прощание с клиентами”, когда сервер:
- перестаёт принимать новые запросы
- даёт завершиться текущим запросам
- чистит ресурсы (базы, файлы и т.д.)
- и только потом закрывается

Зачем это нужно:
Если просто “убить” сервер:
- запросы могут оборваться на полпути (например, оплата)
- пользователи получат ошибки или потеряют данные
- могут остаться “висячие” соединения и утечки ресурсов

Graceful shutdown решает это, особенно важно при деплое, перезагрузках, работе в Kubernetes/Docker.

# Как это сделать в Go
1. Использовать http.Server.Shutdown(ctx) - сервер перестаёт принимать новые запросы, но завершает текущие в рамках таймаута.
2. Перехватывать сигналы ОС (`SIGINT`, SIGTERM`) через `os/signal, чтобы начать shutdown.
3. Использовать context.WithTimeout, чтобы ограничить время завершения.
4. Корректно закрывать ресурсы: БД, логи, файлы и т.д.

# Пример кода

package main

import (
    "context"
    "log"
    "net/http"
    "os"
    "os/signal"
    "time"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        time.Sleep(3 * time.Second)
        w.Write([]byte("Request done"))
    })

    server := &http.Server{
        Addr:    ":8080",
        Handler: mux,
    }

    go func() {
        log.Println("Server starting on :8080")
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("ListenAndServe error: %v", err)
        }
    }()

    stop := make(chan os.Signal, 1)
    signal.Notify(stop, os.Interrupt, os.Kill)

    <-stop
    log.Println("Shutting down server...")

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    if err := server.Shutdown(ctx); err != nil {
        log.Fatalf("Forced shutdown: %v", err)
    }

    log.Println("Server exited gracefully")
}

Вывод

- Graceful shutdown — не просто “красивость”, а необходимая практика для надёжных Go-сервисов:
- минимизирует потери данных и ошибок для пользователей
- обеспечивает корректное завершение внутренних операций
- делает деплой и перезапуск безопасными и незаметными

https://blog.stackademic.com/graceful-shutdowns-in-go-http-servers-ensuring-zero-downtime-for-live-traffic-b8224b28ab4a

ХОЧЕШЬ ПОВЫСИТЬ ГРЕЙД В 2025 ГОДУ? 🚀

Если:
— код разваливается от правок,
— бизнес-логика размазана,
— Entity — просто структуры,
— а тесты живут своей жизнью —
вам точно сюда.

📦 Научитесь строить архитектуру, устойчивую к изменениям.

Что будет на обучении?

✅ Создадим полноценный микросервис
✅ Разберем все тактические паттерны DDD
✅ Реализуем Use Case и Domain Service
✅ Напишем много тестов
✅ Реализуем HTTP, gRPC и Kafka адаптеры


📢 Повышайте свою ценность, как специалиста, прямо сейчас👉 https://microarch.ru/courses/ddd/languages/go?utm_source=posev&utm_medium=erid:2Vtzqvvi8v1&utm_campaign=5

Реклама. ИП Ветчинкин К.Е. ИНН: 773376451099 Erid: 2Vtzqvvi8v1

💡 Структуры в Go: под капотом они интереснее, чем кажется

На первый взгляд struct — это просто контейнер с полями. Но стоит углубиться, и появляются вопросы:

- Почему структура занимает больше памяти, чем сумма её полей?
- Почему одни структуры можно сравнивать и использовать как ключ в map, а другие — нет?

🗄️ Память, выравнивание и паддинг
Go хранит поля в памяти в порядке объявления. Чтобы данные были выровнены по границам процессора, компилятор добавляет "пустые байты" — padding.

type A struct {
    B bool   // 1 byte (+7 padding)
    I int64  // 8 bytes
} 
// Sizeof(A) = 16

type B struct {
    I int64  // 8 bytes
    B bool   // 1 byte (+7 padding)
} 
// Sizeof(B) = 16

Хотя тут одинаково, в больших структурах порядок полей может сэкономить десятки байт.
👉 Лайфхак: ставьте "тяжёлые" типы (int64, float64) выше "лёгких" (bool, byte), чтобы сократить паддинг.

⚖️ Сравнимость и ключи в map
Структуры можно сравнивать (==) и использовать как ключи в map, если все поля сравнимые.

type KeyGood struct {
    ID   int
    Name string
} 
// сравнимо, работает как ключ

type KeyBad struct {
    Data []byte
} 
// ошибка: []byte несравнимый тип

✅ Как обойти:

Использовать фиксированный массив:

type KeyArr struct { Digest [16]byte }


Преобразовать срез в строку:

key := string(digestBytes)
m := map[string]string{key: "value"}

Или хранить хэш (uint64, строка) вместо самого среза.

📌 Вывод: структуры в Go — это не только про хранение данных. Зная про выравнивание и правила сравнимости, можно писать код, который будет и эффективным по памяти, и удобным в работе с map.

#golang #struct #memory #map