Как оптимизировать скорость ответа сервера?

Как оптимизировать скорость ответа сервера

Быстрый ответ сервера — это фундамент хорошего пользовательского опыта. Есть множество техник для оптимизации на разных уровнях: от архитектуры до кэширования.

1. Оптимизация запросов к БД

Problem: N+1 запросы

// ❌ Плохо — множество запросов
async function getUsers() {
  const users = await db.query('SELECT * FROM users');
  
  // Для каждого пользователя отдельный запрос!
  for (let user of users) {
    user.posts = await db.query('SELECT * FROM posts WHERE user_id = ?', user.id);
  }
  
  return users;
}
// Результат: 1 запрос для users + N запросов для posts = N+1 запросов

// ✅ Хорошо — один запрос с JOIN
async function getUsers() {
  const users = await db.query(`
    SELECT u.*, p.id as post_id, p.title
    FROM users u
    LEFT JOIN posts p ON u.id = p.user_id
  `);
  
  // Группируем результаты в памяти
  const grouped = users.reduce((acc, row) => {
    if (!acc[row.id]) acc[row.id] = { ...row, posts: [] };
    if (row.post_id) acc[row.id].posts.push({ id: row.post_id, title: row.title });
    return acc;
  }, {});
  
  return Object.values(grouped);
}
// Результат: 1 запрос

Добавить индексы

-- Медленный поиск
SELECT * FROM orders WHERE user_id = 123;

-- Добавляем индекс
CREATE INDEX idx_orders_user_id ON orders(user_id);

-- Теперь поиск быстрее: O(log n) вместо O(n)

Пагинация вместо загрузки всего

// ❌ Плохо — загружаем все
async function getProducts() {
  return await db.query('SELECT * FROM products'); // 1 миллион товаров!
}

// ✅ Хорошо — пагинация
async function getProducts(page = 1, limit = 20) {
  const offset = (page - 1) * limit;
  return await db.query('SELECT * FROM products LIMIT ? OFFSET ?', [limit, offset]);
}

2. Кэширование

Redis для горячих данных

const redis = require('redis');
const client = redis.createClient();

async function getUser(id) {
  // Проверяем кэш
  const cached = await client.get(`user:${id}`);
  if (cached) return JSON.parse(cached);
  
  // Если нет — запрашиваем БД
  const user = await db.query('SELECT * FROM users WHERE id = ?', id);
  
  // Сохраняем в кэш на 1 час
  await client.setex(`user:${id}`, 3600, JSON.stringify(user));
  
  return user;
}

HTTP кэширование

app.get('/api/products/:id', (req, res) => {
  // Кэшируем на 1 час для браузеров и CDN
  res.set('Cache-Control', 'public, max-age=3600');
  res.json({ id: req.params.id, name: 'Product' });
});

app.get('/api/auth/me', (req, res) => {
  // Не кэшируем личные данные
  res.set('Cache-Control', 'private, no-cache');
  res.json({ user: 'John' });
});

CDN для статики

<!-- Используем CDN для быстрой доставки -->
<script src="https://cdn.example.com/react.min.js"></script>
<link rel="stylesheet" href="https://cdn.example.com/bootstrap.min.css">

3. Сжатие данных

GZIP компрессия

const compression = require('compression');

app.use(compression()); // Сжимает JSON, HTML, CSS, JS

// Результат: 100KB -> 20KB (5x меньше!)

Минификация

// ❌ Оригинальный код
const calculatePrice = (quantity, price) => {
  return quantity * price;
}; // 50 байт

// ✅ Минифицированный
const a=(q,p)=>q*p; // 20 байт

4. Асинхронные операции

Параллельные запросы

// ❌ Последовательные (медленно)
async function getUserData(userId) {
  const user = await getUser(userId);      // 100ms
  const posts = await getPosts(userId);    // 100ms
  const comments = await getComments(userId); // 100ms
  return { user, posts, comments };        // Итого: 300ms
}

// ✅ Параллельные (быстро)
async function getUserData(userId) {
  const [user, posts, comments] = await Promise.all([
    getUser(userId),        // 100ms
    getPosts(userId),       // 100ms (одновременно!)
    getComments(userId)     // 100ms (одновременно!)
  ]);
  return { user, posts, comments }; // Итого: 100ms
}

Streaming для больших данных

// ❌ Плохо — загружаем в память и отправляем
app.get('/api/export', async (req, res) => {
  const data = await db.query('SELECT * FROM huge_table'); // Может не поместиться в памяти!
  res.json(data);
});

// ✅ Хорошо — streaming
app.get('/api/export', (req, res) => {
  res.setHeader('Content-Type', 'application/json');
  res.write('[');
  
  db.stream('SELECT * FROM huge_table')
    .on('data', (row) => {
      res.write(JSON.stringify(row) + ',');
    })
    .on('end', () => {
      res.write(']');
      res.end();
    });
});

5. Оптимизация кода

Выбери правильную алгоритмическую сложность

// ❌ O(n^2) сложность
function findDuplicates(array) {
  const duplicates = [];
  for (let i = 0; i < array.length; i++) {
    for (let j = i + 1; j < array.length; j++) {
      if (array[i] === array[j]) {
        duplicates.push(array[i]);
      }
    }
  }
  return duplicates;
}

// ✅ O(n) сложность
function findDuplicates(array) {
  const seen = new Set();
  const duplicates = new Set();
  
  for (const item of array) {
    if (seen.has(item)) {
      duplicates.add(item);
    }
    seen.add(item);
  }
  
  return Array.from(duplicates);
}

Ленивая загрузка

// ❌ Загружаем сразу
const largeModule = require('./large-module');

// ✅ Загружаем при необходимости
let largeModule;
function getLargeModule() {
  if (!largeModule) {
    largeModule = require('./large-module');
  }
  return largeModule;
}

6. Мониторинг

Отслеживание медленных запросов

app.use((req, res, next) => {
  const startTime = Date.now();
  
  res.on('finish', () => {
    const duration = Date.now() - startTime;
    
    if (duration > 1000) { // Больше 1 секунды
      console.warn(`Slow request: ${req.method} ${req.path} took ${duration}ms`);
    }
  });
  
  next();
});

Логирование в БД

// Записываем метрики в БД для анализа
async function logMetric(endpoint, duration) {
  await db.query(
    'INSERT INTO metrics (endpoint, duration, timestamp) VALUES (?, ?, NOW())',
    [endpoint, duration]
  );
}

7. Load balancing

Используй несколько инстансов

┌──────────────┐
│   Nginx      │ (балансировщик нагрузки)
└──────────────┘
      |
      +-------+-------+
      |       |       |
   ┌──┴─┐  ┌──┴─┐  ┌──┴─┐
   │ v1 │  │ v2 │  │ v3 │  (Node.js инстансы)
   └────┘  └────┘  └────┘

Пример конфига Nginx

upstream backend {
  server localhost:3001;
  server localhost:3002;
  server localhost:3003;
}

server {
  listen 80;
  server_name api.example.com;
  
  location / {
    proxy_pass http://backend;
  }
}

8. Чеклист оптимизации

[ ] БД запросы оптимизированы (нет N+1)
[ ] Добавлены индексы для частых фильтраций
[ ] Используется кэширование (Redis, HTTP cache)
[ ] Включена GZIP компрессия
[ ] Статика минифицирована и лежит на CDN
[ ] Асинхронные операции параллельны (Promise.all)
[ ] Нет утечек памяти (profiling)
[ ] Медленные запросы залогированы
[ ] Используется load balancing
[ ] Проводился performance testing

Инструменты для анализа

# Node.js профилирование
node --prof app.js
node --prof-process isolate-*.log > profile.txt

# Измерение времени
console.time('label');
// код
console.timeEnd('label');

# Apache Bench для нагрузки
ab -n 1000 -c 10 http://localhost:3000/

Вывод

Ключевые методы оптимизации:

1. БД: JOIN вместо N+1, индексы, пагинация
2. Кэширование: Redis, HTTP cache, CDN
3. Сжатие: GZIP, минификация
4. Асинхронность: Promise.all, streaming
5. Алгоритмы: правильная сложность (O(n) вместо O(n^2))
6. Мониторинг: логирование медленных запросов
7. Масштабирование: load balancing

Оптимизируй от больших проблем к малым: сначала БД, потом кэширование, потом код.