10 промтов для Go: микросервисы, API, утилиты командной строки

Напиши на Go 1.23 RESTful API для управления задачами (CRUD). Используй:
- Чистую архитектуру: handlers / services / repository / models
- HTTP-роутер chi
- PostgreSQL через database/sql + pgx
- Middleware для логирования и CORS
- Обработку ошибок через errgroup
Сгенерируй полный код: main.go, handler.go, service.go, repository.go, модель Task с полями ID, Title, Status, CreatedAt.

package handlers

import (
    "encoding/json"
    "net/http"
    "your-project/services"
    "github.com/go-chi/chi/v5"
)

type TaskHandler struct {
    service *services.TaskService
}

func NewTaskHandler(service *services.TaskService) *TaskHandler {
    return &TaskHandler{service: service}
}

func (h *TaskHandler) Create(w http.ResponseWriter, r *http.Request) {
    var input struct {
        Title string `json:"title"`
    }
    if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
        http.Error(w, "invalid JSON", http.StatusBadRequest)
        return
    }
    task, err := h.service.Create(r.Context(), input.Title)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(task)
}

Сгенерируй gRPC сервер и клиент на Go для сервиса "UserService" с методами GetUser (UserRequest -> UserResponse) и ListUsers (Empty -> UserList). Используй:
- google.golang.org/grpc
- protobuf для определения сообщений
- Graceful shutdown через signal.NotifyContext
- Логирование через log/slog
Напиши файлы: user.proto, server.go, client.go.

package main

import (
    "context"
    "log/slog"
    "net"
    "os/signal"
    "syscall"

    "google.golang.org/grpc"
    pb "your-project/proto"
)

type userServer struct {
    pb.UnimplementedUserServiceServer
}

func (s *userServer) GetUser(ctx context.Context, req *pb.UserRequest) (*pb.UserResponse, error) {
    slog.Info("GetUser called", "user_id", req.UserId)
    return &pb.UserResponse{Name: "Alice", Email: "alice@example.com"}, nil
}

func main() {
    ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
    defer cancel()

    lis, _ := net.Listen("tcp", ":50051")
    s := grpc.NewServer()
    pb.RegisterUserServiceServer(s, &userServer{})

    go func() {
        <-ctx.Done()
        slog.Info("Shutting down...")
        s.GracefulStop()
    }()

    slog.Info("Server started on :50051")
    s.Serve(lis)
}

Напиши CLI-утилиту на Go с использованием библиотеки cobra. Команды:
- root: выводит приветствие
- convert: конвертирует JSON в CSV, флаг --input и --output
- analyze: анализирует лог-файл и выводит статистику (количество строк, ошибок, предупреждений)
Добавь: флаг --verbose для подробного вывода, обработку ошибок через fmt.Errorf.

package cmd

import (
    "encoding/csv"
    "encoding/json"
    "fmt"
    "os"

    "github.com/spf13/cobra"
)

var convertCmd = &cobra.Command{
    Use:   "convert",
    Short: "Convert JSON to CSV",
    RunE: func(cmd *cobra.Command, args []string) error {
        input, _ := cmd.Flags().GetString("input")
        output, _ := cmd.Flags().GetString("output")
        if input == "" || output == "" {
            return fmt.Errorf("both --input and --output are required")
        }
        data, err := os.ReadFile(input)
        if err != nil {
            return fmt.Errorf("failed to read input: %w", err)
        }
        var records []map[string]interface{}
        if err := json.Unmarshal(data, &records); err != nil {
            return fmt.Errorf("invalid JSON: %w", err)
        }
        file, _ := os.Create(output)
        defer file.Close()
        writer := csv.NewWriter(file)
        defer writer.Flush()
        // ... запись заголовков и строк
        return nil
    },
}

func init() {
    rootCmd.AddCommand(convertCmd)
    convertCmd.Flags().String("input", "", "Input JSON file")
    convertCmd.Flags().String("output", "", "Output CSV file")
}

Напиши unit-тесты для сервиса TaskService (из промта 1). Используй:
- testify/assert и testify/mock
- Мок для TaskRepository
- Тесты на Create, GetByID, Update, Delete
- Table-driven тесты для граничных случаев (пустой title, несуществующий ID)

package services

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
)

type MockTaskRepo struct {
    mock.Mock
}

func (m *MockTaskRepo) Create(ctx context.Context, task *models.Task) error {
    args := m.Called(ctx, task)
    return args.Error(0)
}

func TestCreate_Success(t *testing.T) {
    repo := new(MockTaskRepo)
    service := NewTaskService(repo)

    repo.On("Create", mock.Anything, mock.AnythingOfType("*models.Task")).Return(nil)

    task, err := service.Create(context.Background(), "Test Task")
    assert.NoError(t, err)
    assert.Equal(t, "Test Task", task.Title)
    repo.AssertExpectations(t)
}

Напиши middleware для Go HTTP-сервера (chi) для:
- JWT-аутентификации: проверяет токен из заголовка Authorization, извлекает userID
- Логирования: записывает метод, путь, статус, длительность через log/slog
- Rate limiting: ограничение 100 запросов в минуту на IP с использованием sync.Map
Каждый middleware должен быть отдельной функцией, возвращающей http.Handler.

func JWTAuth(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token == "" {
            http.Error(w, "missing token", http.StatusUnauthorized)
            return
        }
        // parse JWT
        userID := extractUserID(token)
        ctx := context.WithValue(r.Context(), "userID", userID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

Напиши пакет config для Go-приложения, который загружает настройки из config.yaml и env. Используй:
- github.com/spf13/viper
- Структуру Config с полями: Database (Host, Port, User, Password), Server (Port, Timeout), Logging (Level, Output)
- Поддержку env-переменных (DB_HOST, SERVER_PORT и т.д.)
- Функцию LoadConfig(path string) (*Config, error)

package config

import (
    "fmt"
    "github.com/spf13/viper"
)

type Config struct {
    Database DatabaseConfig `mapstructure:"database"`
    Server   ServerConfig   `mapstructure:"server"`
    Logging  LoggingConfig  `mapstructure:"logging"`
}

type DatabaseConfig struct {
    Host     string `mapstructure:"host"`
    Port     int    `mapstructure:"port"`
    User     string `mapstructure:"user"`
    Password string `mapstructure:"password"`
}

func LoadConfig(path string) (*Config, error) {
    viper.SetConfigFile(path)
    viper.AutomaticEnv()
    viper.SetEnvPrefix("APP")

    if err := viper.ReadInConfig(); err != nil {
        return nil, fmt.Errorf("failed to read config: %w", err)
    }

    var cfg Config
    if err := viper.Unmarshal(&cfg); err != nil {
        return nil, fmt.Errorf("failed to unmarshal: %w", err)
    }
    return &cfg, nil
}

Напиши worker pool на Go для обработки задач из канала. Требования:
- Фиксированное количество воркеров (10)
- Graceful shutdown через контекст
- Обработка ошибок в errgroup
- Логирование старта/остановки воркера
- Функция processTask(task Task) error

package worker

import (
    "context"
    "log/slog"
    "golang.org/x/sync/errgroup"
)

type Task struct {
    ID   int
    Data string
}

func StartPool(ctx context.Context, tasks <-chan Task, workers int) error {
    g, ctx := errgroup.WithContext(ctx)
    for i := 0; i < workers; i++ {
        g.Go(func() error {
            slog.Info("worker started", "id", i)
            defer slog.Info("worker stopped", "id", i)
            for {
                select {
                case <-ctx.Done():
                    return ctx.Err()
                case task, ok := <-tasks:
                    if !ok {
                        return nil
                    }
                    if err := processTask(task); err != nil {
                        return err
                    }
                }
            }
        })
    }
    return g.Wait()
}

func processTask(t Task) error {
    slog.Info("processing", "task_id", t.ID)
    return nil
}

Напиши Go-пакет для работы с миграциями PostgreSQL через golang-migrate/migrate. Создай:
- Функцию RunMigrations(dbURL string, migrationsPath string) error
- Две миграции: 001_create_users.up.sql и 001_create_users.down.sql
- В up: CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT, email UNIQUE)
- В down: DROP TABLE users

package migrations

import (
    "github.com/golang-migrate/migrate/v4"
    _ "github.com/golang-migrate/migrate/v4/database/postgres"
    _ "github.com/golang-migrate/migrate/v4/source/file"
)

func RunMigrations(dbURL, migrationsPath string) error {
    m, err := migrate.New("file://"+migrationsPath, dbURL)
    if err != nil {
        return err
    }
    if err := m.Up(); err != nil && err != migrate.ErrNoChange {
        return err
    }
    return nil
}

Напиши бенчмарки для функции ParseJSON(data []byte) (User, error) и для функции FindUserByID(users []User, id int) (User, bool). Используй:
- testing.B
- Разные размеры входных данных (10, 100, 1000 записей)
- b.ReportAllocs() для отслеживания аллокаций
- Вывод результатов в формате таблицы

func BenchmarkFindUserByID(b *testing.B) {
    users := make([]User, 1000)
    for i := range users {
        users[i] = User{ID: i, Name: fmt.Sprintf("User_%d", i)}
    }

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, _ = FindUserByID(users, 500)
    }
}

Реализуй health check и метрики Prometheus для Go HTTP-сервера. Используй:
- github.com/prometheus/client_golang/prometheus/promhttp
- /metrics эндпоинт с кастомными метриками: http_requests_total, http_request_duration_seconds
- /health эндпоинт, проверяющий соединение с БД (ping)
- Middleware для автоматического сбора метрик

package main

import (
    "net/http"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

var (
    httpRequestsTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{Name: "http_requests_total"},
        []string{"method", "path"},
    )
)

func init() {
    prometheus.MustRegister(httpRequestsTotal)
}

func MetricsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        httpRequestsTotal.WithLabelValues(r.Method, r.URL.Path).Inc()
        next.ServeHTTP(w, r)
    })
}

func healthHandler(w http.ResponseWriter, r *http.Request) {
    // ping DB
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"status":"ok"}`))
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/health", healthHandler)
    mux.Handle("/metrics", promhttp.Handler())
    http.ListenAndServe(":8080", MetricsMiddleware(mux))
}