Создаем микросервисы с Go и Kubernetes

// Пример клиента gRPC на Go
conn, err := grpc.Dial("user-service:50051", grpc.WithInsecure())
if err != nil {
    log.Fatalf("не удалось подключиться: %v", err)
}
defer conn.Close()
client := pb.NewUserServiceClient(conn)
 
// Вызов метода
resp, err := client.GetUser(context.Background(), &pb.GetUserRequest{Id: userID})

// Упрощенный Circuit Breaker
type CircuitBreaker struct {
    failures int
    maxFailures int
    resetTimeout time.Duration
    lastFailure time.Time
    state string // "closed", "open", "half-open"
}
 
func (cb *CircuitBreaker) Execute(req func() error) error {
    if cb.state == "open" {
        if time.Since(cb.lastFailure) > cb.resetTimeout {
            cb.state = "half-open"
        } else {
            return errors.New("circuit open")
        }
    }
    
    err := req()
    if err != nil {
        cb.failures++
        cb.lastFailure = time.Now()
        if cb.failures >= cb.maxFailures {
            cb.state = "open"
        }
        return err
    }
    
    if cb.state == "half-open" {
        cb.state = "closed"
    }
    cb.failures = 0
    return nil
}

// Реализация Saga-паттерна
type OrderSaga struct {
    orderService    *OrderService
    paymentService  *PaymentService
    inventoryService *InventoryService
    notificationService *NotificationService
}
 
func (s *OrderSaga) Execute(ctx context.Context, orderData OrderData) error {
    // Шаг 1: Создаем заказ
    order, err := s.orderService.CreateOrder(ctx, orderData)
    if err != nil {
        return err
    }
    
    // Шаг 2: Списываем деньги
    payment, err := s.paymentService.ProcessPayment(ctx, order.ID, orderData.Amount)
    if err != nil {
        // Компенсирующее действие: отменяем заказ
        s.orderService.CancelOrder(ctx, order.ID)
        return err
    }
    
    // Шаг 3: Резервируем товар
    err = s.inventoryService.ReserveItems(ctx, order.ID, orderData.Items)
    if err != nil {
        // Компенсирующие действия: возвращаем деньги и отменяем заказ
        s.paymentService.RefundPayment(ctx, payment.ID)
        s.orderService.CancelOrder(ctx, order.ID)
        return err
    }
    
    // Шаг 4: Отправляем уведомление
    err = s.notificationService.SendOrderConfirmation(ctx, order.ID)
    // Даже если отправка уведомления не удалась, заказ уже создан
    // Можно просто залогировать ошибку
    
    return nil
}

// Пример с использованием NATS
nc, _ := nats.Connect(nats.DefaultURL)
defer nc.Close()
 
// Подписка на события
nc.Subscribe("user.created", func(m *nats.Msg) {
    var user User
    json.Unmarshal(m.Data, &user)
    // Обработка события о создании пользователя
})
 
// Публикация события
user := User{ID: "123", Name: "Алексей"}
data, _ := json.Marshal(user)
nc.Publish("user.created", data)

// Получение секрета из K8s
config, err := rest.InClusterConfig()
if err != nil {
    log.Fatal(err)
}
clientset, err := kubernetes.NewForConfig(config)
if err != nil {
    log.Fatal(err)
}
 
secret, err := clientset.CoreV1().Secrets("default").Get(context.TODO(), "api-keys", metav1.GetOptions{})
if err != nil {
    log.Fatal(err)
}
 
apiKey := string(secret.Data["api-key"])

// Пример трейсинга с OpenTelemetry
tracer := global.Tracer("order-service")
ctx, span := tracer.Start(ctx, "process-order")
defer span.End()
 
// Добавление метаданных
span.SetAttributes(attribute.String("order.id", orderID))
 
// Вызов другого сервиса с передачей контекста
resp, err := inventoryClient.CheckStock(ctx, &pb.CheckStockRequest{ItemID: itemID})

/cmd            # Точки входа
  /api          # HTTP API сервис
  /worker       # Фоновые задачи
/internal       # Приватный код
  /domain       # Бизнес-модели и интерфейсы
  /repository   # Доступ к данным
  /service      # Бизнес-логика
  /api          # API обработчики
/pkg            # Переиспользуемые пакеты
/config         # Конфигурация

package main
 
import (
    "context"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
 
    "github.com/gorilla/mux"
)
 
func main() {
    r := mux.NewRouter()
    
    // Регистрируем роуты
    r.HandleFunc("/api/v1/books", getBooks).Methods(http.MethodGet)
    r.HandleFunc("/api/v1/books/{id}", getBook).Methods(http.MethodGet)
    
    // Добавляем middleware
    r.Use(loggingMiddleware)
    
    // Создаем HTTP сервер
    srv := &http.Server{
        Addr:    ":8080",
        Handler: r,
    }
    
    // Запускаем сервер в горутине
    go func() {
        log.Printf("Сервер запущен на %s", srv.Addr)
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Ошибка при запуске сервера: %v", err)
        }
    }()
    
    // Канал для сигналов
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    
    // Блокируемся до получения сигнала
    <-quit
    log.Println("Получен сигнал остановки, завершаем работу...")
    
    // Graceful shutdown
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    
    if err := srv.Shutdown(ctx); err != nil {
        log.Fatalf("Ошибка при остановке сервера: %v", err)
    }
    
    log.Println("Сервер остановлен")
}

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // Оборачиваем ResponseWriter для перехвата статус-кода
        ww := NewWrappedResponseWriter(w)
        
        // Вызываем следующий обработчик
        next.ServeHTTP(ww, r)
        
        // Логируем информацию о запросе
        log.Printf(
            "%s %s %d %s",
            r.Method,
            r.RequestURI,
            ww.Status(),
            time.Since(start),
        )
    })
}
 
// WrappedResponseWriter для отслеживания статус-кода
type WrappedResponseWriter struct {
    http.ResponseWriter
    statusCode int
}
 
func NewWrappedResponseWriter(w http.ResponseWriter) *WrappedResponseWriter {
    return &WrappedResponseWriter{w, http.StatusOK}
}
 
func (ww *WrappedResponseWriter) Status() int {
    return ww.statusCode
}
 
func (ww *WrappedResponseWriter) WriteHeader(code int) {
    ww.statusCode = code
    ww.ResponseWriter.WriteHeader(code)
}

type Book struct {
    ID     string `json:"id"`
    Title  string `json:"title"`
    Author string `json:"author"`
}
 
var books = []Book{
    {ID: "1", Title: "Война и мир", Author: "Лев Толстой"},
    {ID: "2", Title: "Преступление и наказание", Author: "Федор Достоевский"},
}
 
func getBooks(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(books)
}
 
func getBook(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    
    // Получаем ID из URL
    vars := mux.Vars(r)
    id := vars["id"]
    
    for _, book := range books {
        if book.ID == id {
            json.NewEncoder(w).Encode(book)
            return
        }
    }
    
    // Если книга не найдена
    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(map[string]string{"error": "Книга не найдена"})
}

func createBook(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    
    var book Book
    decoder := json.NewDecoder(r.Body)
    if err := decoder.Decode(&book); err != nil {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(map[string]string{"error": "Невалидный JSON"})
        return
    }
    
    // Простая валидация
    if book.Title == "" || book.Author == "" {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(map[string]string{"error": "Название и автор обязательны"})
        return
    }
    
    // Генерируем новый ID
    book.ID = strconv.Itoa(len(books) + 1)
    
    // Добавляем книгу
    books = append(books, book)
    
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(book)
}

type CreateBookRequest struct {
    Title  string `json:"title" validate:"required,min=1,max=100"`
    Author string `json:"author" validate:"required,min=1,max=50"`
    Year   int    `json:"year" validate:"required,gt=0,lt=2100"`
}
 
func createBookWithValidator(w http.ResponseWriter, r *http.Request) {
    var req CreateBookRequest
    
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        respondWithError(w, http.StatusBadRequest, "Некорректный JSON")
        return
    }
    
    validate := validator.New()
    if err := validate.Struct(req); err != nil {
        errors := err.(validator.ValidationErrors)
        respondWithError(w, http.StatusBadRequest, fmt.Sprintf("Ошибка валидации: %v", errors))
        return
    }
    
    // Теперь создаем книгу...
}

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tokenString := r.Header.Get("Authorization")
        if tokenString == "" {
            w.WriteHeader(http.StatusUnauthorized)
            json.NewEncoder(w).Encode(map[string]string{"error": "Требуется авторизация"})
            return
        }
        
        // Удаляем префикс "Bearer "
        tokenString = strings.TrimPrefix(tokenString, "Bearer ")
        
        // Парсим токен
        token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
            // Проверяем метод подписи
            if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
                return nil, fmt.Errorf("неожиданный метод подписи: %v", token.Header["alg"])
            }
            
            // Возвращаем ключ для проверки подписи
            return []byte("ваш-секретный-ключ"), nil
        })
        
        if err != nil || !token.Valid {
            w.WriteHeader(http.StatusUnauthorized)
            json.NewEncoder(w).Encode(map[string]string{"error": "Невалидный токен"})
            return
        }
        
        // Извлекаем claims
        claims, ok := token.Claims.(jwt.MapClaims)
        if !ok {
            w.WriteHeader(http.StatusUnauthorized)
            json.NewEncoder(w).Encode(map[string]string{"error": "Невалидные claims"})
            return
        }
        
        // Добавляем userID в контекст запроса
        userID := claims["sub"].(string)
        ctx := context.WithValue(r.Context(), "userID", userID)
        
        // Передаем запрос дальше
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

package main
 
import (
    "go.uber.org/zap"
    "net/http"
    "time"
)
 
var logger *zap.Logger
 
func initLogger() {
    var err error
    
    // В продакшене используем Production конфиг
    // В разработке - Development для более читаемых логов
    if os.Getenv("ENV") == "production" {
        logger, err = zap.NewProduction()
    } else {
        logger, err = zap.NewDevelopment()
    }
    
    if err != nil {
        panic("не удалось инициализировать логгер: " + err.Error())
    }
}
 
func loggingMiddlewareWithZap(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        ww := NewWrappedResponseWriter(w)
        next.ServeHTTP(ww, r)
        
        latency := time.Since(start)
        
        // Структурированный лог с полями
        logger.Info("HTTP запрос",
            zap.String("method", r.Method),
            zap.String("url", r.URL.String()),
            zap.Int("status", ww.Status()),
            zap.Duration("latency", latency),
            zap.String("user-agent", r.UserAgent()),
            zap.String("remote-addr", r.RemoteAddr),
        )
    })
}

package config
 
import (
    "github.com/spf13/viper"
    "log"
)
 
type Config struct {
    Server struct {
        Port int
        Host string
    }
    Database struct {
        Host     string
        Port     int
        User     string
        Password string
        Name     string
    }
    JWT struct {
        Secret string
        TTL    int // время жизни токена в минутах
    }
}
 
func LoadConfig(path string) (*Config, error) {
    viper.SetConfigFile(path)
    viper.AutomaticEnv() // Читаем переменные окружения
    
    // Значения по умолчанию
    viper.SetDefault("server.port", 8080)
    viper.SetDefault("server.host", "0.0.0.0")
    
    if err := viper.ReadInConfig(); err != nil {
        log.Printf("Предупреждение: не удалось прочитать конфиг файл: %v", err)
        // Продолжаем работу, используя переменные окружения и значения по умолчанию
    }
    
    var config Config
    if err := viper.Unmarshal(&config); err != nil {
        return nil, err
    }
    
    return &config, nil
}

package main
 
import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
    "net/http"
)
 
var (
    httpRequestsTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "http_requests_total",
            Help: "Количество HTTP запросов",
        },
        []string{"method", "endpoint", "status"},
    )
    
    httpRequestDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "http_request_duration_seconds",
            Help:    "Длительность HTTP запросов в секундах",
            Buckets: []float64{0.1, 0.3, 0.5, 0.7, 1, 3, 5, 7, 10},
        },
        []string{"method", "endpoint"},
    )
)
 
func init() {
    // Регистрируем метрики
    prometheus.MustRegister(httpRequestsTotal)
    prometheus.MustRegister(httpRequestDuration)
}
 
// Middleware для сбора метрик
func metricsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        ww := NewWrappedResponseWriter(w)
        next.ServeHTTP(ww, r)
        
        duration := time.Since(start).Seconds()
        
        // Инкрементируем счетчик запросов
        httpRequestsTotal.WithLabelValues(r.Method, r.URL.Path, fmt.Sprintf("%d", ww.Status())).Inc()
        
        // Записываем длительность запроса
        httpRequestDuration.WithLabelValues(r.Method, r.URL.Path).Observe(duration)
    })
}

FROM golang:1.20
 
WORKDIR /app
 
COPY . .
 
RUN go build -o main .
 
EXPOSE 8080
 
CMD ["./main"]

# Этап сборки
FROM golang:1.20-alpine AS builder
 
WORKDIR /app
 
# Копируем только файлы, необходимые для загрузки модулей
COPY go.mod go.sum ./
RUN go mod download
 
# Копируем исходный код
COPY . .
 
# Компилируем с отключеными отладочными символами
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-w -s" -o app cmd/api/main.go
 
# Финальный образ
FROM alpine:3.18
 
# Добавляем CA-сертификаты и timezone для корректной работы с HTTPS и временем
RUN apk --no-cache add ca-certificates tzdata
 
WORKDIR /app
 
# Копируем скомпилированое приложение из предыдущего этапа
COPY --from=builder /app/app .
 
# Копируем файлы конфигурации, если нужно
COPY --from=builder /app/configs ./configs
 
# Запускаем как непривилегированый пользователь
RUN adduser -D appuser
USER appuser
 
EXPOSE 8080
 
CMD ["./app"]

# Финальный этап
FROM scratch
 
# Копируем файлы CA сертификатов из промежуточного образа
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 
# Копируем скомпилированое приложение
COPY --from=builder /app/app /app
 
EXPOSE 8080
 
# Запускаем приложение
CMD ["/app"]

# Плохой пример
RUN apt-get update && apt-get install -y curl htop vim netcat
 
# Хороший пример - устанавливаем только то, что действительно нужно
RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates

# Многоплатформенная сборка с помощью BuildKit
FROM --platform=$BUILDPLATFORM golang:1.20-alpine AS builder
 
ARG TARGETPLATFORM
ARG BUILDPLATFORM
 
# Определяем архитектуру и ОС для компиляции
RUN echo "Building on $BUILDPLATFORM for $TARGETPLATFORM"
 
WORKDIR /app
COPY . .
 
# Настраиваем GOOS и GOARCH на основе TARGETPLATFORM
RUN \
  if [ "$TARGETPLATFORM" = "linux/amd64" ]; then \
    GOOS=linux GOARCH=amd64 go build -o app .; \
  elif [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
    GOOS=linux GOARCH=arm64 go build -o app .; \
  else \
    echo "Unsupported platform: $TARGETPLATFORM"; \
    exit 1; \
  fi
 
FROM --platform=$TARGETPLATFORM alpine:3.18
COPY --from=builder /app/app /app
CMD ["/app"]

# Пример с использованием SSH ключа для скачивания приватных зависимостей
RUN --mount=type=ssh mkdir -p ~/.ssh && ssh-keyscan github.com >> ~/.ssh/known_hosts
RUN --mount=type=ssh go mod download

books-service/
  Chart.yaml           # Метаданные чарта
  values.yaml          # Значения по умолчанию
  templates/           # YAML-шаблоны
    deployment.yaml
    service.yaml
    ingress.yaml
    configmap.yaml
    secret.yaml

func healthHandler(w http.ResponseWriter, r *http.Request) {
    // Тут можно добавить проверки БД, кеша и т.д.
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
}

// Создаем клиент Consul
config := consulapi.DefaultConfig()
config.Address = "consul:8500"
client, err := consulapi.NewClient(config)
if err != nil {
    log.Fatalf("Ошибка при создании клиента Consul: %v", err)
}
 
// Регистрируем сервис
serviceID := "user-api-" + uuid.New().String()
registration := &consulapi.AgentServiceRegistration{
    ID:      serviceID,
    Name:    "user-api",
    Port:    8080,
    Address: getHostIP(),
    Check: &consulapi.AgentServiceCheck{
        HTTP:     "http://localhost:8080/health",
        Interval: "10s",
        Timeout:  "3s",
    },
}
 
if err := client.Agent().ServiceRegister(registration); err != nil {
    log.Fatalf("Ошибка при регистрации сервиса: %v", err)
}
 
// Не забываем дерегистрировать при завершении
defer client.Agent().ServiceDeregister(serviceID)

// Ищем сервис в Consul
services, _, err := client.Health().Service("user-api", "", true, nil)
if err != nil {
    log.Fatalf("Ошибка при поиске сервиса: %v", err)
}
 
if len(services) == 0 {
    log.Fatal("Сервис не найден")
}
 
// Выбираем случайный экземпляр
rand.Seed(time.Now().UnixNano())
service := services[rand.Intn(len(services))]
serviceAddr := fmt.Sprintf("%s:%d", service.Service.Address, service.Service.Port)
 
// Теперь можем обращаться к сервису
resp, err := http.Get("http://" + serviceAddr + "/users")

/bookstore
  /user-service     # Сервис пользователей
  /order-service    # Сервис заказов
  /k8s              # Манифесты Kubernetes
  /monitoring       # Конфигурация мониторинга

// user-service/internal/domain/user.go
type User struct {
    ID        string    [INLINE]json:"id"[/INLINE]
    Email     string    [INLINE]json:"email"[/INLINE]
    Password  string    [INLINE]json:"-"[/INLINE]
    Name      string    [INLINE]json:"name"[/INLINE]
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"updated_at"`
}
 
// user-service/internal/repository/postgres_repository.go
func (r *PostgresRepository) GetUserByID(ctx context.Context, id string) (*domain.User, error) {
    var user domain.User
    query := `SELECT id, email, name, created_at, updated_at FROM users WHERE id = $1`
    err := r.db.QueryRowContext(ctx, query, id).Scan(
        &user.ID, &user.Email, &user.Name, &user.CreatedAt, &user.UpdatedAt,
    )
    if err == sql.ErrNoRows {
        return nil, domain.ErrUserNotFound
    }
    if err != nil {
        return nil, fmt.Errorf("ошибка получения пользователя: %w", err)
    }
    return &user, nil
}

// order-service/internal/domain/order.go
type Order struct {
    ID        string    [INLINE]json:"id"[/INLINE]
    UserID    string    [INLINE]json:"user_id"[/INLINE]
    Items     []Item    [INLINE]json:"items"[/INLINE]
    Status    string    [INLINE]json:"status"[/INLINE]
    Total     float64   [INLINE]json:"total"[/INLINE]
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"updated_at"`
}
 
// order-service/internal/service/order_service.go
func (s *OrderService) CreateOrder(ctx context.Context, userID string, items []domain.Item) (*domain.Order, error) {
    // Проверяем существование пользователя через gRPC
    userResp, err := s.userClient.GetUser(ctx, &pb.GetUserRequest{Id: userID})
    if err != nil {
        return nil, fmt.Errorf("ошибка проверки пользователя: %w", err)
    }
    
    // Рассчитываем общую стоимость
    var total float64
    for _, item := range items {
        total += item.Price * float64(item.Quantity)
    }
    
    // Создаем заказ в БД
    order := &domain.Order{
        ID:        uuid.New().String(),
        UserID:    userID,
        Items:     items,
        Status:    "created",
        Total:     total,
        CreatedAt: time.Now(),
        UpdatedAt: time.Now(),
    }
    
    if err := s.repo.CreateOrder(ctx, order); err != nil {
        return nil, err
    }
    
    // Отправляем событие в Kafka о создании заказа
    s.eventPublisher.PublishOrderCreated(order)
    
    return order, nil
}

// migrations/1_create_users_table.up.sql
CREATE TABLE users (
    id UUID PRIMARY KEY,
    email TEXT NOT NULL UNIQUE,
    password TEXT NOT NULL,
    name TEXT NOT NULL,
    created_at TIMESTAMP NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
 
// migrations/2_create_orders_table.up.sql
CREATE TABLE orders (
    id UUID PRIMARY KEY,
    user_id UUID NOT NULL REFERENCES users(id),
    status TEXT NOT NULL,
    total DECIMAL(10, 2) NOT NULL,
    created_at TIMESTAMP NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);

// common/metrics/metrics.go
package metrics
 
import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
)
 
var (
    RequestCounter = promauto.NewCounterVec(
        prometheus.CounterOpts{
            Name: "http_requests_total",
            Help: "Количество HTTP запросов",
        },
        []string{"method", "endpoint", "status"},
    )
    
    RequestDuration = promauto.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "http_request_duration_seconds",
            Help:    "Длительность HTTP запросов",
            Buckets: prometheus.DefBuckets,
        },
        []string{"method", "endpoint"},
    )
    
    ActiveOrders = promauto.NewGauge(
        prometheus.GaugeOpts{
            Name: "active_orders",
            Help: "Количество активных заказов",
        },
    )
)

// order-service/internal/repository/postgres_repository_test.go
func TestOrderRepository(t *testing.T) {
    ctx := context.Background()
    
    // Запускаем PostgreSQL в Docker
    postgres, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
        ContainerRequest: testcontainers.ContainerRequest{
            Image:        "postgres:13",
            ExposedPorts: []string{"5432/tcp"},
            Env: map[string]string{
                "POSTGRES_USER":     "test",
                "POSTGRES_PASSWORD": "test",
                "POSTGRES_DB":       "testdb",
            },
            WaitingFor: wait.ForLog("database system is ready to accept connections"),
        },
        Started: true,
    })
    if err != nil {
        t.Fatal(err)
    }
    defer postgres.Terminate(ctx)
    
    // Получаем хост и порт
    host, err := postgres.Host(ctx)
    if err != nil {
        t.Fatal(err)
    }
    port, err := postgres.MappedPort(ctx, "5432")
    if err != nil {
        t.Fatal(err)
    }
    
    // Подключаемся к БД
    dsn := fmt.Sprintf("host=%s port=%s user=test password=test dbname=testdb sslmode=disable", host, port.Port())
    db, err := sql.Open("postgres", dsn)
    if err != nil {
        t.Fatal(err)
    }
    defer db.Close()
    
    // Применяем миграции
    migrate.Up(db)
    
    // Создаем репозиторий и тестируем
    repo := NewPostgresRepository(db)
    // ...тесты...
}

// common/logging/elasticsearch.go
package logging
 
import (
  "github.com/olivere/elastic/v7"
  "github.com/sirupsen/logrus"
  "github.com/sirupsen/logrus/hooks/writer"
  "os"
  "time"
)
 
type ElasticsearchHook struct {
  client    *elastic.Client
  host      string
  index     string
  levels    []logrus.Level
  ctx       context.Context
  ctxCancel context.CancelFunc
  fireFunc  func(entry *logrus.Entry, hook *ElasticsearchHook) error
}
 
func NewElasticsearchHook(client *elastic.Client, host, index string, levels []logrus.Level) (*ElasticsearchHook, error) {
  ctx, cancel := context.WithCancel(context.Background())
  
  return &ElasticsearchHook{
      client:    client,
      host:      host,
      index:     index,
      levels:    levels,
      ctx:       ctx,
      ctxCancel: cancel,
      fireFunc:  syncFireFunc,
  }, nil
}
 
func (hook *ElasticsearchHook) Fire(entry *logrus.Entry) error {
  return hook.fireFunc(entry, hook)
}
 
func (hook *ElasticsearchHook) Levels() []logrus.Level {
  return hook.levels
}
 
func syncFireFunc(entry *logrus.Entry, hook *ElasticsearchHook) error {
  // Форматируем лог для Elasticsearch
  type LogEntry struct {
      Timestamp time.Time     [INLINE]json:"@timestamp"[/INLINE]
      Message   string        [INLINE]json:"message"[/INLINE]
      Level     string        [INLINE]json:"level"[/INLINE]
      Data      logrus.Fields `json:"data"`
  }
  
  logEntry := LogEntry{
      Timestamp: entry.Time,
      Message:   entry.Message,
      Level:     entry.Level.String(),
      Data:      entry.Data,
  }
  
  // Отправляем в Elasticsearch
  _, err := hook.client.Index().
      Index(hook.index + "-" + time.Now().Format("2006.01.02")).
      BodyJson(logEntry).
      Do(hook.ctx)
  
  return err
}
 
func SetupLogging(serviceName string, elasticsearchURL string) *logrus.Logger {
  logger := logrus.New()
  logger.SetFormatter(&logrus.JSONFormatter{})
  logger.SetOutput(os.Stdout)
  
  // Настраиваем хук для Elasticsearch
  if elasticsearchURL != "" {
      client, err := elastic.NewClient(
          elastic.SetURL(elasticsearchURL),
          elastic.SetSniff(false),
      )
      if err != nil {
          logger.Warnf("Не удалось подключиться к Elasticsearch: %v", err)
      } else {
          levels := []logrus.Level{
              logrus.PanicLevel,
              logrus.FatalLevel,
              logrus.ErrorLevel,
              logrus.WarnLevel,
              logrus.InfoLevel,
          }
          hook, err := NewElasticsearchHook(client, elasticsearchURL, serviceName, levels)
          if err != nil {
              logger.Warnf("Не удалось создать хук для Elasticsearch: %v", err)
          } else {
              logger.AddHook(hook)
          }
      }
  }
  
  return logger
}

// order-service/cmd/main.go
func main() {
  // ...
  logger := logging.SetupLogging("order-service", os.Getenv("ELASTICSEARCH_URL"))
  // ...
}

// tests/integration/order_test.go
package integration
 
import (
  "context"
  "encoding/json"
  "net/http"
  "testing"
  "time"
  
  "github.com/stretchr/testify/assert"
)
 
func TestCreateOrder(t *testing.T) {
  // Создаем тестового пользователя
  userReq := map[string]interface{}{
      "email": "test@example.com",
      "name":  "Test User",
      "password": "password123",
  }
  userJSON, _ := json.Marshal(userReq)
  
  userResp, err := http.Post(
      "http://user-service/api/v1/users",
      "application/json",
      bytes.NewBuffer(userJSON),
  )
  assert.NoError(t, err)
  assert.Equal(t, http.StatusCreated, userResp.StatusCode)
  
  var user map[string]interface{}
  json.NewDecoder(userResp.Body).Decode(&user)
  userID := user["id"].(string)
  
  // Создаем заказ
  orderReq := map[string]interface{}{
      "user_id": userID,
      "items": []map[string]interface{}{
          {
              "id": "item1",
              "quantity": 2,
              "price": 10.5,
          },
      },
  }
  orderJSON, _ := json.Marshal(orderReq)
  
  orderResp, err := http.Post(
      "http://order-service/api/v1/orders",
      "application/json",
      bytes.NewBuffer(orderJSON),
  )
  assert.NoError(t, err)
  assert.Equal(t, http.StatusCreated, orderResp.StatusCode)
  
  var order map[string]interface{}
  json.NewDecoder(orderResp.Body).Decode(&order)
  orderID := order["id"].(string)
  
  // Проверяем статус заказа
  time.Sleep(2 * time.Second) // Даем время на обработку
  
  statusResp, err := http.Get("http://order-service/api/v1/orders/" + orderID)
  assert.NoError(t, err)
  assert.Equal(t, http.StatusOK, statusResp.StatusCode)
  
  var orderStatus map[string]interface{}
  json.NewDecoder(statusResp.Body).Decode(&orderStatus)
  assert.Equal(t, "processing", orderStatus["status"])
}

/bookstore
  /user-service
    /cmd
      /api
        main.go
    /internal
      /domain
        user.go
      /repository
        postgres_repository.go
      /service
        user_service.go
      /api
        handlers.go
    /pkg
      /auth
        jwt.go
    /migrations
      1_create_users_table.up.sql
      1_create_users_table.down.sql
    Dockerfile
    go.mod
    go.sum
  
  /order-service
    /cmd
      /api
        main.go
    /internal
      /domain
        order.go
        item.go
      /repository
        postgres_repository.go
      /service
        order_service.go
      /api
        handlers.go
      /client
        user_client.go
    /pkg
      /events
        kafka_publisher.go
    /migrations
      1_create_orders_table.up.sql
      1_create_orders_table.down.sql
    Dockerfile
    go.mod
    go.sum
  
  /k8s
    /user-service
      deployment.yaml
      service.yaml
    /order-service
      deployment.yaml
      service.yaml
    /databases
      postgres.yaml
    /kafka
      kafka.yaml
    /monitoring
      prometheus.yaml
      grafana.yaml
    /logging
      elasticsearch.yaml
      kibana.yaml
  
  /common
    /metrics
      prometheus.go
    /logging
      elasticsearch.go
  
  /tests
    /integration
      order_test.go
    integration-pod.yaml
  
  docker-compose.yaml
  README.md

// order-service/internal/client/user_client.go
package client
 
import (
  "context"
  "time"
  
  "google.golang.org/grpc"
  "google.golang.org/grpc/credentials/insecure"
  pb "github.com/yourusername/bookstore/user-service/api/proto"
)
 
type UserClient struct {
  conn   *grpc.ClientConn
  client pb.UserServiceClient
}
 
func NewUserClient(userServiceURL string) (*UserClient, error) {
  // Настраиваем gRPC соединение с таймаутом и ретраями
  ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
  defer cancel()
  
  conn, err := grpc.DialContext(
      ctx,
      userServiceURL,
      grpc.WithTransportCredentials(insecure.NewCredentials()),
      grpc.WithBlock(),
  )
  if err != nil {
      return nil, err
  }
  
  client := pb.NewUserServiceClient(conn)
  
  return &UserClient{
      conn:   conn,
      client: client,
  }, nil
}
 
func (c *UserClient) GetUser(ctx context.Context, userID string) (*pb.UserResponse, error) {
  ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
  defer cancel()
  
  return c.client.GetUser(ctx, &pb.GetUserRequest{Id: userID})
}
 
func (c *UserClient) Close() error {
  return c.conn.Close()
}

// order-service/internal/service/order_service.go
package service
 
import (
  "context"
  "fmt"
  "time"
  
  "github.com/yourusername/bookstore/order-service/internal/domain"
  "github.com/yourusername/bookstore/order-service/internal/repository"
  "github.com/yourusername/bookstore/order-service/internal/client"
  "github.com/yourusername/bookstore/order-service/pkg/events"
  "github.com/google/uuid"
  "go.uber.org/zap"
)
 
type OrderService struct {
  repo           repository.OrderRepository
  userClient     *client.UserClient
  eventPublisher *events.KafkaPublisher
  logger         *zap.Logger
}
 
func NewOrderService(
  repo repository.OrderRepository,
  userClient *client.UserClient,
  eventPublisher *events.KafkaPublisher,
  logger *zap.Logger,
) *OrderService {
  return &OrderService{
      repo:           repo,
      userClient:     userClient,
      eventPublisher: eventPublisher,
      logger:         logger,
  }
}
 
func (s *OrderService) CreateOrder(ctx context.Context, userID string, items []domain.Item) (*domain.Order, error) {
  // Реализация паттерна Saga
  // Шаг 1: Проверяем существование пользователя
  user, err := s.userClient.GetUser(ctx, userID)
  if err != nil {
      s.logger.Error("Ошибка при получении пользователя", zap.String("user_id", userID), zap.Error(err))
      return nil, fmt.Errorf("ошибка при получении пользователя: %w", err)
  }
  
  // Шаг 2: Рассчитываем общую стоимость
  var total float64
  for _, item := range items {
      total += item.Price * float64(item.Quantity)
  }
  
  // Шаг 3: Создаем заказ
  order := &domain.Order{
      ID:        uuid.New().String(),
      UserID:    userID,
      Items:     items,
      Status:    "created",
      Total:     total,
      CreatedAt: time.Now(),
      UpdatedAt: time.Now(),
  }
  
  if err := s.repo.CreateOrder(ctx, order); err != nil {
      s.logger.Error("Ошибка при создании заказа", zap.String("user_id", userID), zap.Error(err))
      return nil, fmt.Errorf("ошибка при создании заказа: %w", err)
  }
  
  // Шаг 4: Публикуем событие о создании заказа
  if err := s.eventPublisher.PublishOrderCreated(order); err != nil {
      // Компенсирующее действие: отменяем заказ
      s.logger.Error("Ошибка при публикации события", zap.String("order_id", order.ID), zap.Error(err))
      if err := s.repo.UpdateOrderStatus(ctx, order.ID, "cancelled"); err != nil {
          s.logger.Error("Ошибка при отмене заказа", zap.String("order_id", order.ID), zap.Error(err))
      }
      return nil, fmt.Errorf("ошибка при публикации события: %w", err)
  }
  
  // Шаг 5: Обновляем статус заказа
  if err := s.repo.UpdateOrderStatus(ctx, order.ID, "processing"); err != nil {
      s.logger.Error("Ошибка при обновлении статуса заказа", zap.String("order_id", order.ID), zap.Error(err))
      // Заказ уже создан, так что просто логируем ошибку
  }
  
  return order, nil
}
 
func (s *OrderService) GetOrder(ctx context.Context, orderID string) (*domain.Order, error) {
  return s.repo.GetOrderByID(ctx, orderID)
}
 
func (s *OrderService) ListUserOrders(ctx context.Context, userID string) ([]*domain.Order, error) {
  return s.repo.GetOrdersByUserID(ctx, userID)
}
 
func (s *OrderService) CancelOrder(ctx context.Context, orderID string) error {
  // Проверяем существование заказа
  order, err := s.repo.GetOrderByID(ctx, orderID)
  if err != nil {
      return err
  }
  
  // Можно отменить только заказы в статусе "created" или "processing"
  if order.Status != "created" && order.Status != "processing" {
      return fmt.Errorf("нельзя отменить заказ в статусе %s", order.Status)
  }
  
  // Обновляем статус
  if err := s.repo.UpdateOrderStatus(ctx, orderID, "cancelled"); err != nil {
      return err
  }
  
  // Публикуем событие об отмене
  if err := s.eventPublisher.PublishOrderCancelled(order); err != nil {
      s.logger.Error("Ошибка при публикации события об отмене", zap.String("order_id", orderID), zap.Error(err))
      // Статус уже обновлен, так что просто логируем ошибку
  }
  
  return nil
}