Как будешь действовать, если нужно ускорить запрос?

Подход к оптимизации медленных запросов в Go

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

1. Диагностика и профилирование

Сначала необходимо определить точное место и причину замедления. Я использую несколько инструментов:

import (
    "net/http/pprof"
    "runtime/pprof"
    "time"
)

// Добавляем эндпоинты pprof для профилирования
func setupProfiling() {
    http.HandleFunc("/debug/pprof/", pprof.Index)
    http.HandleFunc("/debug/pprof/profile", pprof.Profile)
}

Основные методы диагностики:

• CPU profiling (go tool pprof) для анализа загрузки процессора
• Memory profiling для поиска утечек памяти
• Execution tracer для анализа латентности горутин
• Бенчмарки для изолированного тестирования компонентов

// Пример бенчмарка для выявления узких мест
func BenchmarkDatabaseQuery(b *testing.B) {
    db := setupTestDB()
    for i := 0; i < b.N; i++ {
        rows, _ := db.Query("SELECT * FROM users WHERE active = ?", true)
        rows.Close()
    }
}

2. Анализ и оптимизация SQL-запросов

Большинство медленных запросов связаны с базой данных:

-- Анализируем план выполнения
EXPLAIN ANALYZE SELECT * FROM orders WHERE user_id = 123 AND status = 'completed';

Оптимизационные стратегии:

• Добавление недостающих индексов (составных, покрывающих)
• Переписывание запросов для устранения N+1 проблемы
• Использование JOIN вместо множественных запросов
• Пагинация через LIMIT/OFFSET или ключевой курсор
• Реализация ленивой загрузки связей

3. Кэширование на разных уровнях

Многоуровневая стратегия кэширования:

// Пример двухуровневого кэша (память + Redis)
type CacheService struct {
    localCache *lru.Cache
    redisClient *redis.Client
}

func (c *CacheService) GetUser(id int) (*User, error) {
    // 1. Проверяем локальный кэш
    if user, ok := c.localCache.Get(id); ok {
        return user.(*User), nil
    }
    
    // 2. Проверяем Redis
    userData, err := c.redisClient.Get(ctx, fmt.Sprintf("user:%d", id)).Bytes()
    if err == nil {
        user := &User{}
        json.Unmarshal(userData, user)
        c.localCache.Add(id, user) // Наполняем локальный кэш
        return user, nil
    }
    
    // 3. Запрос к базе данных
    user := fetchFromDB(id)
    
    // Асинхронное обновление кэшей
    go c.updateCaches(id, user)
    
    return user, nil
}

4. Конкурентное выполнение и параллелизм

Использование возможностей Go-рутин для параллельного выполнения независимых операций:

func fetchUserData(ctx context.Context, userID int) (*UserData, error) {
    var wg sync.WaitGroup
    var user *User
    var orders []Order
    var err1, err2 error
    
    wg.Add(2)
    
    // Параллельный сбор данных
    go func() {
        defer wg.Done()
        user, err1 = fetchUser(userID)
    }()
    
    go func() {
        defer wg.Done()
        orders, err2 = fetchOrders(userID)
    }()
    
    wg.Wait()
    
    if err1 != nil || err2 != nil {
        return nil, fmt.Errorf("errors: %v, %v", err1, err2)
    }
    
    return &UserData{User: user, Orders: orders}, nil
}

5. Оптимизация сериализации и сетевых взаимодействий

Ключевые подходы:

• Использование бинарных форматов (Protocol Buffers, MessagePack) вместо JSON
• Настройка пулов соединений к базе данных
• Сжатие ответов (gzip, brotli)
• Минимизация размера передаваемых данных

// Использование protobuf для эффективной сериализации
func sendProtobufResponse(w http.ResponseWriter, data proto.Message) {
    w.Header().Set("Content-Type", "application/protobuf")
    binaryData, _ := proto.Marshal(data)
    w.Write(binaryData)
}

6. Мониторинг и постоянное улучшение

После внедрения оптимизаций необходимо:

1. Установить метрики и алерты для ключевых эндпоинтов
2. Реализовать медленный лог запросов с автоматическим оповещением
3. Проводить регулярный ревью наиболее частых запросов
4. Использовать A/B тестирование для сравнения разных подходов

// Middleware для логирования медленных запросов
func slowQueryMiddleware(next http.Handler, threshold time.Duration) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // Обертка для ResponseWriter для захвата статуса
        rw := &responseWriter{ResponseWriter: w}
        
        next.ServeHTTP(rw, r)
        
        duration := time.Since(start)
        if duration > threshold {
            log.Printf("SLOW REQUEST: %s %s took %v, status: %d",
                r.Method, r.URL.Path, duration, rw.status)
        }
    })
}

7. Архитектурные изменения

В долгосрочной перспективе может потребоваться:

• Внедрение репликации и шардинга базы данных
• Использование read-only реплик для операций чтения
• Переход на event-driven архитектуру с асинхронной обработкой
• Денормализация данных для часто используемых запросов

Важный принцип: начинать с простых оптимизаций (индексы, кэширование), переходя к сложным архитектурным изменениям только при необходимости. Каждое изменение должно быть измеримым и обоснованным данными профилирования.