{
  "timestamp": "2026-09-02T14:30:00Z",
  "level": "INFO",
  "message": "User logged in",
  "user_id": "12345",
  "username": "john.doe",
  "ip_address": "203.0.113.42",
  "user_agent": "Mozilla/5.0..."
}

Trace ID: abc123
├─ Span: API Gateway (20ms)
│  ├─ Span: Auth Service (5ms)
│  ├─ Span: Product Service (80ms)
│  │  └─ Span: PostgreSQL Query (60ms)
│  └─ Span: Inventory Service (30ms)
│     └─ Span: Redis Cache (2ms)
└─ Total: 135ms

package main

import (
    "log/slog"
    "os"
)

func main() {
    // Створення JSON-логера, що пише у stdout
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
    
    // Встановлення як глобального логера за замовчуванням
    slog.SetDefault(logger)
    
    // Логування повідомлень різних рівнів
    slog.Info("Server starting", "port", 8080, "environment", "production")
    slog.Warn("High memory usage detected", "usage_mb", 1024, "threshold_mb", 900)
    slog.Error("Database connection failed", "error", "connection timeout", "retry_count", 3)
    
    // Логування з додатковими атрибутами
    userID := "user_12345"
    slog.Info("User action performed",
        "user_id", userID,
        "action", "purchase",
        "amount", 99.99,
        "currency", "USD",
    )
}

{"time":"2026-09-02T14:30:00.123456Z","level":"INFO","msg":"Server starting","port":8080,"environment":"production"}
{"time":"2026-09-02T14:30:01.234567Z","level":"WARN","msg":"High memory usage detected","usage_mb":1024,"threshold_mb":900}
{"time":"2026-09-02T14:30:02.345678Z","level":"ERROR","msg":"Database connection failed","error":"connection timeout","retry_count":3}
{"time":"2026-09-02T14:30:03.456789Z","level":"INFO","msg":"User action performed","user_id":"user_12345","action":"purchase","amount":99.99,"currency":"USD"}

// Створення обробника з мінімальним рівнем WARNING
handlerOptions := &slog.HandlerOptions{
    Level: slog.LevelWarn, // Ігноруються DEBUG та INFO
}
handler := slog.NewJSONHandler(os.Stdout, handlerOptions)
logger := slog.New(handler)

logger.Debug("This will not be logged")  // Пропускається
logger.Info("This will not be logged")   // Пропускається
logger.Warn("This will be logged")       // Виводиться
logger.Error("This will be logged")      // Виводиться

// Створення логера з постійними атрибутами
serviceLogger := logger.With(
    "service", "payment-processor",
    "version", "v2.3.1",
    "instance_id", "i-abc123",
)

// Усі подальші логи автоматично містять ці атрибути
serviceLogger.Info("Transaction started", "transaction_id", "tx_789")
// {"time":"...","level":"INFO","msg":"Transaction started","service":"payment-processor","version":"v2.3.1","instance_id":"i-abc123","transaction_id":"tx_789"}

// Групування атрибутів для ієрархічної структури
serviceLogger.Info("User profile updated",
    slog.Group("user",
        "id", "12345",
        "username", "john.doe",
        "email", "john@example.com",
    ),
    slog.Group("changes",
        "field", "phone_number",
        "old_value", "+380501234567",
        "new_value", "+380509876543",
    ),
)

{
  "time": "2026-09-02T14:30:00Z",
  "level": "INFO",
  "msg": "User profile updated",
  "service": "payment-processor",
  "version": "v2.3.1",
  "instance_id": "i-abc123",
  "user": {
    "id": "12345",
    "username": "john.doe",
    "email": "john@example.com"
  },
  "changes": {
    "field": "phone_number",
    "old_value": "+380501234567",
    "new_value": "+380509876543"
  }
}

package main

import (
    "log/slog"
    "net/http"
    "time"
)

// LoggingMiddleware логує кожен HTTP-запит із метриками продуктивності
func LoggingMiddleware(logger *slog.Logger, next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // Обгортка ResponseWriter для захоплення статус-коду
        wrapped := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
        
        // Виконання наступного обробника
        next.ServeHTTP(wrapped, r)
        
        // Обчислення тривалості обробки
        duration := time.Since(start)
        
        // Логування після завершення запиту
        logger.Info("HTTP request completed",
            "method", r.Method,
            "path", r.URL.Path,
            "status", wrapped.statusCode,
            "duration_ms", duration.Milliseconds(),
            "remote_addr", r.RemoteAddr,
            "user_agent", r.UserAgent(),
        )
    })
}

// responseWriter обгортає http.ResponseWriter для захоплення статус-коду
type responseWriter struct {
    http.ResponseWriter
    statusCode int
}

func (rw *responseWriter) WriteHeader(code int) {
    rw.statusCode = code
    rw.ResponseWriter.WriteHeader(code)
}

func main() {
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
    
    mux := http.NewServeMux()
    mux.HandleFunc("/api/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte(`{"status":"healthy"}`))
    })
    
    // Застосування middleware до всіх маршрутів
    handler := LoggingMiddleware(logger, mux)
    
    slog.Info("Starting server", "port", 8080)
    http.ListenAndServe(":8080", handler)
}

package main

import (
    "net/http"
    "time"

    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

var (
    // Counter: загальна кількість HTTP-запитів
    httpRequestsTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "http_requests_total",
            Help: "Total number of HTTP requests",
        },
        []string{"method", "path", "status"}, // Мітки для фільтрації
    )
    
    // Histogram: розподіл тривалості запитів
    httpRequestDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "http_request_duration_seconds",
            Help:    "HTTP request duration in seconds",
            // Buckets визначають межі корзин для групування вимірювань
            // Вибір buckets критично важливий для точності перцентилів
            Buckets: []float64{0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1.0, 2.0, 5.0},
        },
        []string{"method", "path"},
    )
    
    // Gauge: поточна кількість активних з'єднань
    activeConnections = prometheus.NewGauge(
        prometheus.GaugeOpts{
            Name: "active_connections",
            Help: "Number of active connections",
        },
    )
)

func init() {
    // Реєстрація метрик у глобальному реєстрі
    prometheus.MustRegister(httpRequestsTotal)
    prometheus.MustRegister(httpRequestDuration)
    prometheus.MustRegister(activeConnections)
}

// MetricsMiddleware збирає метрики для кожного HTTP-запиту
func MetricsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        activeConnections.Inc() // Збільшення лічильника активних з'єднань
        defer activeConnections.Dec() // Зменшення після завершення
        
        wrapped := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
        next.ServeHTTP(wrapped, r)
        
        duration := time.Since(start).Seconds()
        
        // Оновлення метрик
        httpRequestsTotal.WithLabelValues(
            r.Method,
            r.URL.Path,
            http.StatusText(wrapped.statusCode),
        ).Inc()
        
        httpRequestDuration.WithLabelValues(
            r.Method,
            r.URL.Path,
        ).Observe(duration)
    })
}

func main() {
    mux := http.NewServeMux()
    
    // Ендпоінт для збору метрик Prometheus
    mux.Handle("/metrics", promhttp.Handler())
    
    // Бізнес-логіка
    mux.HandleFunc("/api/users", func(w http.ResponseWriter, r *http.Request) {
        time.Sleep(50 * time.Millisecond) // Симуляція роботи
        w.WriteHeader(http.StatusOK)
        w.Write([]byte(`{"users": []}`))
    })
    
    handler := MetricsMiddleware(mux)
    
    http.ListenAndServe(":8080", handler)
}

# HELP http_requests_total Total number of HTTP requests
# TYPE http_requests_total counter
http_requests_total{method="GET",path="/api/users",status="OK"} 1234
http_requests_total{method="POST",path="/api/users",status="Created"} 567

# HELP http_request_duration_seconds HTTP request duration in seconds
# TYPE http_request_duration_seconds histogram
http_request_duration_seconds_bucket{method="GET",path="/api/users",le="0.005"} 102
http_request_duration_seconds_bucket{method="GET",path="/api/users",le="0.01"} 450
http_request_duration_seconds_bucket{method="GET",path="/api/users",le="0.05"} 1150
http_request_duration_seconds_bucket{method="GET",path="/api/users",le="+Inf"} 1234
http_request_duration_seconds_sum{method="GET",path="/api/users"} 45.678
http_request_duration_seconds_count{method="GET",path="/api/users"} 1234

# HELP active_connections Number of active connections
# TYPE active_connections gauge
active_connections 12

// Швидкі API (кешовані запити, in-memory операції)
Buckets: prometheus.LinearBuckets(0.001, 0.001, 10) // 1ms, 2ms, 3ms, ..., 10ms

// Типові веб-запити (БД запити, зовнішні API)
Buckets: []float64{0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0}

// Повільні операції (генерація звітів, обробка файлів)
Buckets: prometheus.ExponentialBuckets(0.1, 2, 10) // 0.1, 0.2, 0.4, 0.8, 1.6, 3.2, ...

// Універсальний (DefBuckets у Prometheus)
Buckets: prometheus.DefBuckets // 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10

global:
  scrape_interval: 15s     # Інтервал збору метрик
  evaluation_interval: 15s # Інтервал оцінки правил алертів

scrape_configs:
  - job_name: 'go-app'
    static_configs:
      - targets: ['localhost:8080']
        labels:
          environment: 'production'
          region: 'eu-west'

docker run -d \
  --name prometheus \
  -p 9090:9090 \
  -v $(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml \
  prom/prometheus

rate(http_requests_total[5m])

histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))

sum(rate(http_requests_total{status=~"5.."}[5m])) 
/ 
sum(rate(http_requests_total[5m])) * 100

topk(5, 
  histogram_quantile(0.99, 
    rate(http_request_duration_seconds_bucket[10m])
  )
)

package main

import (
    "context"
    "database/sql"
    "encoding/json"
    "net/http"
    "sync"
    "time"

    _ "github.com/lib/pq"
)

// HealthStatus представляє стан окремого компоненту
type HealthStatus struct {
    Status  string                 `json:"status"`  // "healthy", "degraded", "unhealthy"
    Message string                 `json:"message,omitempty"`
    Details map[string]interface{} `json:"details,omitempty"`
}

// HealthResponse агрегує стан всіх компонентів
type HealthResponse struct {
    Status     string                  `json:"status"`
    Version    string                  `json:"version"`
    Uptime     float64                 `json:"uptime_seconds"`
    Timestamp  time.Time               `json:"timestamp"`
    Components map[string]HealthStatus `json:"components"`
}

var (
    startTime = time.Now()
    db        *sql.DB
)

// CheckDatabase перевіряє з'єднання з БД
func CheckDatabase(ctx context.Context) HealthStatus {
    if db == nil {
        return HealthStatus{
            Status:  "unhealthy",
            Message: "Database connection not initialized",
        }
    }

    // Таймаут на перевірку підключення
    // Критично важливо: без таймауту зависла БД заблокує health check назавжди
    ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()

    if err := db.PingContext(ctx); err != nil {
        return HealthStatus{
            Status:  "unhealthy",
            Message: "Database ping failed",
            Details: map[string]interface{}{"error": err.Error()},
        }
    }

    // Перевірка кількості активних з'єднань
    stats := db.Stats()
    return HealthStatus{
        Status: "healthy",
        Details: map[string]interface{}{
            "open_connections": stats.OpenConnections,
            "in_use":           stats.InUse,
            "idle":             stats.Idle,
            "max_open":         stats.MaxOpenConnections,
        },
    }
}

### Важливість Context.Context у Health Checks

Використання `context.Context` у функціях перевірки здоров'я є критичним для запобігання каскадним збоям:

**Проблема без таймаутів:**

Уявіть ситуацію: база даних PostgreSQL перестала відповідати через перевантаження або мережеві проблеми. Якщо health check виконує `db.Ping()` без таймауту, виклик заблокується на невизначений час (типово 30–60 секунд або більше). У Kubernetes це призведе до:

1. Readiness probe провалюється після timeout (наприклад, 5 секунд).
2. Под видаляється з балансувальника → трафік перенаправляється на інші поди.
3. **Проте горутина health check все ще блокована!** Вона продовжує споживати ресурси (горутину, з'єднання до БД).
4. При частих запитах health check (кожні 5 секунд) накопичується сотні заблокованих горутин → **витік горутин і з'єднань**.

**Рішення через Context:**

```go
// ❌ Небезпечно: без таймауту
func CheckDatabaseBad() error {
    return db.Ping() // Може блокуватися хвилинами
}

// ✅ Безпечно: з таймаутом через Context
func CheckDatabaseGood(ctx context.Context) error {
    ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()
    
    return db.PingContext(ctx) // Гарантовано завершиться за 2 секунди
}

func CheckExternalAPI(ctx context.Context) HealthStatus {
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()
    
    req, _ := http.NewRequestWithContext(ctx, "GET", "https://api.external.com/health", nil)
    
    client := &http.Client{Timeout: 3 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        // Розрізняємо таймаут vs інші помилки
        if errors.Is(err, context.DeadlineExceeded) {
            return HealthStatus{
                Status:  "unhealthy",
                Message: "External API timeout",
                Details: map[string]interface{}{"timeout": "3s"},
            }
        }
        return HealthStatus{
            Status:  "unhealthy",
            Message: "External API unreachable",
            Details: map[string]interface{}{"error": err.Error()},
        }
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != 200 {
        return HealthStatus{
            Status:  "degraded",
            Message: fmt.Sprintf("External API returned %d", resp.StatusCode),
        }
    }
    
    return HealthStatus{Status: "healthy"}
}

if freeSpaceGB < 5.0 {
    return HealthStatus{
        Status:  "unhealthy",
        Message: "Critical: Low disk space",
        Details: map[string]interface{}{"free_gb": freeSpaceGB},
    }
} else if freeSpaceGB < 20.0 {
    return HealthStatus{
        Status:  "degraded",
        Message: "Warning: Disk space below threshold",
        Details: map[string]interface{}{"free_gb": freeSpaceGB},
    }
}

return HealthStatus{
    Status:  "healthy",
    Details: map[string]interface{}{"free_gb": freeSpaceGB},
}

// Паралельна перевірка всіх компонентів
var wg sync.WaitGroup
components := make(map[string]HealthStatus)
mu := sync.Mutex{}

checks := map[string]func() HealthStatus{
    "database": func() HealthStatus { return CheckDatabase(ctx) },
    "disk":     CheckDiskSpace,
}

for name, checkFunc := range checks {
    wg.Add(1)
    go func(name string, check func() HealthStatus) {
        defer wg.Done()
        status := check()
        mu.Lock()
        components[name] = status
        mu.Unlock()
    }(name, checkFunc)
}

wg.Wait()

// Визначення загального статусу
overallStatus := "healthy"
for _, component := range components {
    if component.Status == "unhealthy" {
        overallStatus = "unhealthy"
        break
    } else if component.Status == "degraded" && overallStatus != "unhealthy" {
        overallStatus = "degraded"
    }
}

response := HealthResponse{
    Status:     overallStatus,
    Version:    "v1.2.3",
    Uptime:     time.Since(startTime).Seconds(),
    Timestamp:  time.Now(),
    Components: components,
}

// Статус-код залежить від загального стану
statusCode := http.StatusOK
if overallStatus == "degraded" {
    statusCode = http.StatusOK // 200, але із попередженням
} else if overallStatus == "unhealthy" {
    statusCode = http.StatusServiceUnavailable // 503
}

w.Header().Set("Content-Type", "application/json")
w.WriteHeader(statusCode)
json.NewEncoder(w).Encode(response)

ctx, cancel := context.WithTimeout(r.Context(), 1*time.Second)
defer cancel()

if err := db.PingContext(ctx); err != nil {
    w.WriteHeader(http.StatusServiceUnavailable)
    w.Write([]byte(`{"ready": false, "reason": "database unavailable"}`))
    return
}

w.WriteHeader(http.StatusOK)
w.Write([]byte(`{"ready": true}`))

http.HandleFunc("/health", HealthCheckHandler)
http.HandleFunc("/ready", ReadinessHandler)
http.HandleFunc("/live", func(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"alive": true}`))
})

http.ListenAndServe(":8080", nil)

**Приклад відповіді `/health`:**

```json
{
  "status": "healthy",
  "version": "v1.2.3",
  "uptime_seconds": 3600.5,
  "timestamp": "2026-09-02T14:30:00Z",
  "components": {
    "database": {
      "status": "healthy",
      "details": {
        "open_connections": 5,
        "in_use": 2,
        "idle": 3,
        "max_open": 25
      }
    },
    "disk": {
      "status": "healthy",
      "details": {
        "free_gb": 50
      }
    }
  }
}

package main

import (
    "fmt"
    "golang.org/x/crypto/bcrypt"
)

// HashPassword генерує bcrypt-хеш пароля
func HashPassword(password string) (string, error) {
    // Cost=12 означає 2^12 = 4096 раундів хешування
    // Кожне збільшення cost на 1 подвоює час обчислення
    bytes, err := bcrypt.GenerateFromPassword([]byte(password), 12)
    if err != nil {
        return "", err
    }
    return string(bytes), nil
}

// CheckPassword перевіряє пароль проти хешу
func CheckPassword(password, hash string) bool {
    err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
    return err == nil
}

func main() {
    password := "MySecureP@ssw0rd!"
    
    // Хешування при реєстрації
    hash, _ := HashPassword(password)
    fmt.Println("Хеш:", hash)
    // Виведе: $2a$12$KIXxJ1eV8... (60 символів)
    
    // Перевірка при вході
    isValid := CheckPassword("MySecureP@ssw0rd!", hash)
    fmt.Println("Пароль правильний:", isValid) // true
    
    isValid = CheckPassword("WrongPassword", hash)
    fmt.Println("Неправильний пароль:", isValid) // false
}

func CheckAndRehashIfNeeded(password, oldHash string, db *Database, userID string) (bool, error) {
    // Перевірка пароля з існуючим хешем
    if err := bcrypt.CompareHashAndPassword([]byte(oldHash), []byte(password)); err != nil {
        return false, nil // Неправильний пароль
    }
    
    // Витягання поточного cost із хешу
    cost, _ := bcrypt.Cost([]byte(oldHash))
    
    // Якщо cost застарілий (нижче 12), перехешуємо
    if cost < 12 {
        newHash, err := bcrypt.GenerateFromPassword([]byte(password), 12)
        if err != nil {
            return true, err
        }
        
        // Оновлення хешу в БД
        if err := db.UpdatePasswordHash(userID, string(newHash)); err != nil {
            return true, err
        }
        
        log.Printf("Password rehashed for user %s: cost %d → 12", userID, cost)
    }
    
    return true, nil
}

// SecurityHeadersMiddleware додає захисні заголовки до відповідей
func SecurityHeadersMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 1. Content-Security-Policy: блокує XSS атаки
        // Дозволяє завантажувати ресурси лише з довірених джерел
        w.Header().Set("Content-Security-Policy", 
            "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:")
        
        // 2. X-Frame-Options: захист від Clickjacking
        // Забороняє вбудовування сторінки у <iframe>
        w.Header().Set("X-Frame-Options", "DENY")
        
        // 3. X-Content-Type-Options: запобігає MIME-sniffing
        // Браузер не намагатиметься "вгадати" тип контенту
        w.Header().Set("X-Content-Type-Options", "nosniff")
        
        // 4. Strict-Transport-Security: примусове HTTPS
        // Браузер автоматично перенаправляє HTTP на HTTPS протягом року
        w.Header().Set("Strict-Transport-Security", "max-age=31536000; includeSubDomains")
        
        // 5. X-XSS-Protection: застарілий, але для сумісності
        w.Header().Set("X-XSS-Protection", "1; mode=block")
        
        // 6. Referrer-Policy: контроль передачі Referer
        w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
        
        // 7. Permissions-Policy: обмеження доступу до API браузера
        w.Header().Set("Permissions-Policy", 
            "geolocation=(), microphone=(), camera=()")
        
        next.ServeHTTP(w, r)
    })
}

package main

import (
    "net/http"
    "sync"
    "time"

    "golang.org/x/time/rate"
)

// RateLimiter зберігає лімітери для кожного клієнта (за IP)
type RateLimiter struct {
    limiters map[string]*rate.Limiter
    mu       sync.RWMutex
    r        rate.Limit // Кількість запитів за секунду
    b        int        // Розмір burst bucket
}

func NewRateLimiter(r rate.Limit, b int) *RateLimiter {
    return &RateLimiter{
        limiters: make(map[string]*rate.Limiter),
        r:        r,
        b:        b,
    }
}

// GetLimiter повертає або створює лімітер для IP
func (rl *RateLimiter) GetLimiter(ip string) *rate.Limiter {
    rl.mu.RLock()
    limiter, exists := rl.limiters[ip]
    rl.mu.RUnlock()

    if !exists {
        rl.mu.Lock()
        limiter = rate.NewLimiter(rl.r, rl.b)
        rl.limiters[ip] = limiter
        rl.mu.Unlock()
    }

    return limiter
}

// RateLimitMiddleware обмежує кількість запитів від одного IP
func (rl *RateLimiter) RateLimitMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        limiter := rl.GetLimiter(ip)

        if !limiter.Allow() {
            http.Error(w, "Rate limit exceeded. Please try again later.", 
                http.StatusTooManyRequests) // 429
            return
        }

        next.ServeHTTP(w, r)
    })
}

func main() {
    // Дозволити 10 запитів/секунду з burst до 20
    rateLimiter := NewRateLimiter(10, 20)

    mux := http.NewServeMux()
    mux.HandleFunc("/api/data", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Data"))
    })

    handler := rateLimiter.RateLimitMiddleware(mux)
    http.ListenAndServe(":8080", handler)
}

# ❌ Антипатерн: використання повного образу Debian
FROM golang:1.22

# Встановлення робочої директорії
WORKDIR /app

# Копіювання коду
COPY . .

# Завантаження залежностей та компіляція
RUN go mod download
RUN go build -o server cmd/server/main.go

# Запуск від імені root (небезпечно!)
CMD ["./server"]

# ========================================
# Етап 1: Збірка застосунку (Build Stage)
# ========================================
FROM golang:1.22-alpine AS builder

# Встановлення git (для деяких Go-модулів)
RUN apk add --no-cache git

WORKDIR /build

# Копіювання лише файлів залежностей для кешування
COPY go.mod go.sum ./
RUN go mod download

# Копіювання коду
COPY . .

# Компіляція статичного бінарника
# CGO_ENABLED=0 вимикає C-залежності для повної статичної лінковки
# -ldflags="-w -s" видаляє символьну інформацію та debug-дані (зменшує розмір на ~30%)
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
    -ldflags="-w -s" \
    -o server \
    cmd/server/main.go

# ========================================
# Етап 2: Фінальний продакшн-образ
# ========================================
FROM scratch

# Копіювання кореневих сертифікатів для HTTPS-запитів
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/

# Створення non-root користувача (для безпеки)
# У scratch немає /etc/passwd, тому копіюємо з builder
COPY --from=builder /etc/passwd /etc/passwd

# Копіювання скомпільованого бінарника
COPY --from=builder /build/server /app/server

# Створення користувача та групи
USER nobody:nobody

# Експонування порту (документаційна директива)
EXPOSE 8080

# Запуск застосунку
ENTRYPOINT ["/app/server"]

COPY go.mod go.sum ./
RUN go mod download
COPY . .

FROM golang:1.22-alpine AS builder
# ... (етап збірки ідентичний)

FROM gcr.io/distroless/static-debian12:nonroot

COPY --from=builder /build/server /app/server

USER nonroot:nonroot
EXPOSE 8080
ENTRYPOINT ["/app/server"]

# Збірка образу з тегом
docker build -t my-go-app:v1.0.0 .

# Перевірка розміру образу
docker images my-go-app:v1.0.0
# REPOSITORY    TAG       SIZE
# my-go-app     v1.0.0    12MB  (замість 800MB!)

# Запуск контейнера
docker run -d \
  --name go-server \
  -p 8080:8080 \
  --memory="256m" \
  --cpus="0.5" \
  --restart unless-stopped \
  my-go-app:v1.0.0

# Перегляд логів
docker logs -f go-server

# Зупинка та видалення
docker stop go-server
docker rm go-server

version: '3.9'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://user:password@postgres:5432/mydb?sslmode=disable
      - REDIS_URL=redis://redis:6379
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    restart: unless-stopped
    networks:
      - app-network

  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydb
    ports:
      - "5432:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user"]
      interval: 5s
      timeout: 3s
      retries: 5
    networks:
      - app-network

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    networks:
      - app-network

  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
    networks:
      - app-network

volumes:
  postgres-data:
  redis-data:

networks:
  app-network:
    driver: bridge

# Запуск всіх сервісів у фоновому режимі
docker compose up -d

# Перегляд логів конкретного сервісу
docker compose logs -f app

# Зупинка та видалення контейнерів
docker compose down

# Пересборка після зміни коду
docker compose up -d --build

# Масштабування сервісу (запуск декількох інстансів)
docker compose up -d --scale app=3

apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-app-deployment
  labels:
    app: go-app
spec:
  replicas: 3  # Кількість інстансів (для високої доступності)
  selector:
    matchLabels:
      app: go-app
  template:
    metadata:
      labels:
        app: go-app
    spec:
      containers:
      - name: go-server
        image: my-go-app:v1.0.0
        imagePullPolicy: IfNotPresent
        
        ports:
        - containerPort: 8080
          name: http
        
        # Змінні оточення
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: url
        - name: LOG_LEVEL
          value: "info"
        
        # Ліміти ресурсів
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "500m"
        
        # Health Checks
        livenessProbe:
          httpGet:
            path: /live
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10
          timeoutSeconds: 2
          failureThreshold: 3
        
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 3
          periodSeconds: 5
          timeoutSeconds: 2
          successThreshold: 1
          failureThreshold: 2
        
        # Security Context
        securityContext:
          runAsNonRoot: true
          runAsUser: 65534  # nobody
          allowPrivilegeEscalation: false
          capabilities:
            drop:
              - ALL
          readOnlyRootFilesystem: true

apiVersion: v1
kind: Service
metadata:
  name: go-app-service
spec:
  type: ClusterIP  # Внутрішній IP у кластері (для зовнішнього доступу: LoadBalancer)
  selector:
    app: go-app
  ports:
  - port: 80        # Порт, що слухає Service
    targetPort: 8080 # Порт контейнера
    protocol: TCP
    name: http

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: go-app-ingress
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - api.example.com
    secretName: go-app-tls
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: go-app-service
            port:
              number: 80

# Виключити Git-репозиторій
.git
.gitignore

# Виключити локальні налаштування
.env
*.local

# Виключити тести та документацію
*_test.go
docs/
README.md

# Виключити директорії збірки
bin/
dist/
vendor/

# Виключити Docker-файли
Dockerfile*
docker-compose.yml

VERSION=$(git describe --tags --always)
docker build -t my-go-app:${VERSION} -t my-go-app:latest .

# Trivy — популярний сканер вразливостей
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  aquasec/trivy:latest image my-go-app:v1.0.0

# Snyk
snyk container test my-go-app:v1.0.0

my-go-app:v1.0.0 (alpine 3.18.4)

Total: 5 (UNKNOWN: 0, LOW: 2, MEDIUM: 2, HIGH: 1, CRITICAL: 0)

┌─────────────┬──────────────┬──────────┬───────────────────┬──────────────┬────────────────────────┐
│   Library   │ Vulnerability│ Severity │ Installed Version │ Fixed Version│        Title           │
├─────────────┼──────────────┼──────────┼───────────────────┼──────────────┼────────────────────────┤
│ libcrypto3  │ CVE-2023-5678│ HIGH     │ 3.1.3-r0          │ 3.1.4-r0     │ OpenSSL: Buffer Overflow│
│ libssl3     │ CVE-2023-5678│ HIGH     │ 3.1.3-r0          │ 3.1.4-r0     │ OpenSSL: Buffer Overflow│
│ busybox     │ CVE-2023-1234│ MEDIUM   │ 1.36.1-r2         │ 1.36.1-r5    │ BusyBox: Path Traversal │
└─────────────┴──────────────┴──────────┴───────────────────┴──────────────┴────────────────────────┘

# Замість фіксованої версії
FROM alpine:3.18.4

# Використовуйте останню патч-версію
FROM alpine:3.18

# Або останню мінорну (для non-breaking changes)
FROM alpine:3

# .trivyignore
CVE-2023-1234  # BusyBox не використовується у scratch-образі

# GitLab CI
security_scan:
  image: aquasec/trivy:latest
  script:
    - trivy image --exit-code 1 --severity CRITICAL,HIGH $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
  only:
    - merge_requests
    - main

export DOCKER_BUILDKIT=1
docker build --build-arg GO_VERSION=1.22 -t my-go-app:v1.0.0 .

# GitLab CI приклад
build:
  image: docker:latest
  services:
    - docker:dind
  before_script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    - docker build --cache-from $CI_REGISTRY_IMAGE:latest -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA