Микросервисы на Go: с чего начать и не бросить

Почему Go — лучший выбор для микросервисов (и когда это не так)

Представьте, что вы строите торговый центр. Вместо того чтобы возводить одно гигантское здание, вы строите отдельные павильоны: кофейню, книжный, продуктовый. Каждый работает сам по себе, но вместе они образуют единый комплекс. Где-то сломался лифт? Книжный продолжает работать. Закончились стаканчики в кофейне? Закрываем только её, а не весь комплекс.

Это и есть микросервисная архитектура. А Go (Golang) — идеальный материал для строительства таких «павильонов». Почему?

• Быстрый старт: компиляция в один бинарник. Никаких JDK, виртуальных машин или node_modules.
• Производительность: Go работает на уровне C++, но пишется как Python.
• Встроенная конкурентность: горутины (goroutines) и каналы (channels) — это суперсила для обработки сотен запросов в секунду.
• Простота: Go намеренно ограничен. Нет дженериков (до Go 1.18 их не было), нет наследования. Код читается как инструкция к пылесосу — сразу понятно, что делает каждая строчка.

Но есть и минусы. Go не подойдёт, если вам нужно:

• Тяжёлое наследование классов (здесь его вообще нет).
• Огромное количество готовых библиотек под любую задачу (экосистема беднее, чем у Java или Python).
• Динамическая типизация (Go — строго типизирован, придётся писать больше boilerplate).

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

Этап 1. Собираем чемодан: инструменты и структура проекта

Что нужно установить

Прежде чем писать код, давайте настроим окружение. Вам понадобится:

• Go (версия 1.21+). Скачивайте с go.dev.
• Docker (для контейнеризации).
• curl или Postman (для тестирования API).
• Любая IDE: GoLand, VS Code с плагином Go, Vim. Советую VS Code — бесплатно и удобно.

Правильная структура папок

Давайте сразу договоримся: никакой халявы. Вот стандартная структура для микросервиса на Go:

/user-service
├── cmd/
│   └── server/
│       └── main.go        # точка входа
├── internal/
│   ├── handler/           # HTTP-обработчики
│   ├── service/           # бизнес-логика
│   ├── repository/        # работа с БД
│   └── model/             # структуры данных
├── pkg/
│   └── middleware/        # общие утилиты
├── Dockerfile
├── go.mod
└── go.sum

Почему так? Go — это язык, где структура папок диктует архитектуру. cmd/ — точка входа. internal/ — всё, что нельзя импортировать извне (защита от дурака). pkg/ — то, чем можно делиться с другими сервисами.

Этап 2. Пишем первый микросервис: Hello, World! 2.0

Давайте напишем простой HTTP-сервер на Go, который будет возвращать JSON. Это будет наш «микросервис приветствий».

Шаг 1. Инициализация модуля

mkdir hello-service
cd hello-service
go mod init github.com/ваш-username/hello-service

Шаг 2. Пишем main.go

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "time"
)

// GreetingResponse — структура ответа
type GreetingResponse struct {
    Message   string `json:"message"`
    Timestamp string `json:"timestamp"`
}

func greetHandler(w http.ResponseWriter, r *http.Request) {
    // Устанавливаем заголовки
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)

    // Создаём ответ
    response := GreetingResponse{
        Message:   "Привет, микросервисы!",
        Timestamp: time.Now().Format(time.RFC3339),
    }

    // Кодируем в JSON
    json.NewEncoder(w).Encode(response)
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/greet", greetHandler)

    log.Println("Сервер запущен на :8080")
    log.Fatal(http.ListenAndServe(":8080", mux))
}

Шаг 3. Запускаем и тестируем

go run cmd/server/main.go
# В другом терминале:
curl http://localhost:8080/api/greet
# Вывод: {"message":"Привет, микросервисы!","timestamp":"2025-03-15T12:00:00Z"}

Важно: Обратите внимание на json:"message" в структуре. Это теги — они говорят Go, как называть поля в JSON. Без них ключи будут с большой буквы (Message), а это дурной тон.

Этап 3. Добавляем бизнес-логику: разбиваем на слои

Один файл — это хорошо для старта, но для реального микросервиса нужно разделение ответственности. Давайте применим Clean Architecture в Go-стиле.

Слой handler (транспорт)

// internal/handler/greet.go
package handler

import (
    "encoding/json"
    "net/http"
    "hello-service/internal/service"
)

type GreetHandler struct {
    svc *service.GreetService
}

func NewGreetHandler(svc *service.GreetService) *GreetHandler {
    return &GreetHandler{svc: svc}
}

func (h *GreetHandler) Greet(w http.ResponseWriter, r *http.Request) {
    response := h.svc.GetGreeting()
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(response)
}

Слой service (бизнес-логика)

// internal/service/greet.go
package service

import (
    "time"
    "hello-service/internal/model"
)

type GreetService struct{}

func NewGreetService() *GreetService {
    return &GreetService{}
}

func (s *GreetService) GetGreeting() *model.Greeting {
    return &model.Greeting{
        Message:   "Привет из сервиса!",
        Timestamp: time.Now(),
    }
}

Слой model (данные)

// internal/model/greeting.go
package model

import "time"

type Greeting struct {
    Message   string    `json:"message"`
    Timestamp time.Time `json:"timestamp"`
}

Теперь main.go выглядит так:

package main

import (
    "log"
    "net