Оглавление

• Почему это важно бизнесу
• Как работает HTTP‑кэш: ключевые заголовки
  • Основные заголовки
• Стратегии: статические файлы и API
  • Статические файлы: «неизменяемые» и длинный срок
  • API (GET): ре‑валидация вместо бесконечного хранения
  • API (PUT/PATCH/DELETE): предикаты для согласованности
• Примеры конфигурации и кода
  • Nginx: статика с длинным TTL и HTML без кэша
  • Nginx как обратный прокси для API с защитой от лавины запросов
  • Node.js (Express): ETag, Last-Modified и 304
  • Go (net/http): условный GET
• Работа с CDN и инвалидация
  • Разделяем кэш для браузера и для CDN
  • Теги (surrogate keys) и точечная очистка
  • Вытягиваем максимум из stale-while-revalidate
• Безопасность и частые грабли
• Наблюдаемость: что мерить
• План внедрения по шагам
• Чек‑лист перед выкладкой
• Итоги

Почему это важно бизнесу

Медленная выдача страниц и тяжёлые API‑ответы бьют по конверсии и бюджету. Каждый кэш‑хит экономит запрос к бэкенду, уменьшает трафик и время ответа. Правильные заголовки Cache‑Control, ETag и Last‑Modified позволяют:

• ускорить первую отрисовку интерфейса и сделку пользователя;
• снизить нагрузку на базы и микросервисы без усложнения архитектуры;
• уменьшить счета за CDN и исходящий трафик;
• безопасно кэшировать даже персонализированные части интерфейса — через условные запросы и ре‑валидацию.

Как работает HTTP‑кэш: ключевые заголовки

HTTP‑кэширование держится на двух идеях: «кэшировать можно» и «ресурс не изменился».

Основные заголовки

• Cache-Control — директивы для браузеров и прокси:
  • public / private — можно ли кэшировать в общедоступном кэше (CDN, прокси) или только в браузере;
  • max-age=<секунды> — сколько хранить копию;
  • s-maxage=<секунды> — срок для общедоступных кэшей (перекрывает max-age для CDN);
  • no-store — вообще не хранить;
  • no-cache — хранить можно, но перед использованием проверять у сервера;
  • stale-while-revalidate=<секунды> — можно отдать устаревшую копию, пока идёт фоноваf ре‑валидация;
  • stale-if-error=<секунды> — можно отдать устаревшую копию, если бэкенд падает.
• ETag — «отпечаток» версии ресурса (обычно хеш). Совпал — ресурс не менялся.
  • Сильный ETag: "abc" — побайтное равенство.
  • Слабый ETag: W/"abc" — равенство по содержанию, допускает мелкие отличия.
• Last-Modified — когда ресурс менялся в последний раз.
• If-None-Match — условный запрос: «отдай 304, если мой ETag актуален».
• If-Modified-Since — условный запрос по дате: «отдай 304, если не менялось с даты».
• Vary — от чего зависит ответ (например, Vary: Accept-Encoding, Authorization).
• Age и Date — помогают понять «возраст» ответа.

304 Not Modified — ответ без тела. Клиент использует локальный кэш, экономя трафик и CPU сервера.

Стратегии: статические файлы и API

Статические файлы: «неизменяемые» и длинный срок

• Генерируйте имя файла с хешем содержимого (fingerprint): app.4f2a8.css.
• Для них ставьте Cache-Control: public, max-age=31536000, immutable.
• HTML и манифесты — короткий срок или no-cache, чтобы быстро подтягивать новые версии.

Так вы получаете почти 100% кэш‑хитов на статику и ноль проблем с «протухшими» файлами: меняется содержимое — меняется имя.

API (GET): ре‑валидация вместо бесконечного хранения

Для данных, которые иногда меняются (каталоги, карточки, профили), используйте:

• Cache-Control: public, max-age=0, s-maxage=60, stale-while-revalidate=300, stale-if-error=86400.
• Отдавайте ETag и Last-Modified.
• На запросы с If-None-Match и If-Modified-Since отдавайте 304, если не менялось.

Так CDN/браузеры часто отдают копию, а при сомнениях быстро проверяют актуальность без тяжёлой отдачи тела.

API (PUT/PATCH/DELETE): предикаты для согласованности

Чтобы не перезаписать изменения друг друга, используйте предикаты:

• Клиент читает ресурс с ETag.
• При изменении отправляет If-Match: "etag".
• Если версия на сервере другая — 412 Precondition Failed. Клиент решает конфликт.

Примеры конфигурации и кода

Nginx: статика с длинным TTL и HTML без кэша

server {
    listen 80;
    server_name example.com;
    root /var/www/app;

    # Статические ассеты с fingerprint в имени
    location ~* \.(?:css|js|png|jpg|jpeg|gif|svg|webp|ico|woff2?)$ {
        try_files $uri =404;
        add_header Cache-Control "public, max-age=31536000, immutable" always;
    }

    # HTML — короткий TTL и ре-валидация
    location ~* \.(?:html)$ {
        try_files $uri =404;
        add_header Cache-Control "no-cache, public" always;
    }
}

Nginx как обратный прокси для API с защитой от лавины запросов

proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=apicache:100m inactive=10m max_size=5g;

server {
    listen 80;
    server_name api.example.com;

    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;

        proxy_cache apicache;
        proxy_cache_bypass $http_cache_control;
        proxy_cache_valid 200 1m;
        add_header X-Cache-Status $upstream_cache_status;

        # Отдавать устаревшее при ошибке и пока идёт обновление
        proxy_cache_use_stale error timeout updating http_500 http_502 http_503 http_504;
        proxy_cache_lock on;
        proxy_cache_lock_timeout 10s;
    }
}

• proxy_cache_use_stale updating позволяет не устроить «штурм бэкенда» при одновременной ре‑валидации.
• X-Cache-Status помогает видеть HIT/MISS в логах и клиентах.

Node.js (Express): ETag, Last-Modified и 304

import express from 'express';
import crypto from 'crypto';

const app = express();

// Мнимое хранилище
let product = {
  id: 42,
  name: 'Кофемолка',
  price: 4990,
  updatedAt: new Date('2025-01-01T10:00:00Z')
};

function makeEtag(bodyBuffer) {
  // Короткий, но достаточно устойчивый отпечаток
  const hash = crypto.createHash('sha256').update(bodyBuffer).digest('base64url');
  return '"' + hash.slice(0, 27) + '"';
}

app.get('/api/products/:id', (req, res) => {
  if (String(product.id) !== req.params.id) {
    return res.status(404).json({ error: 'not found' });
  }
  const body = Buffer.from(JSON.stringify(product));
  const etag = makeEtag(body);
  const lastModified = product.updatedAt.toUTCString();

  // Условные заголовки клиента
  const inm = req.get('If-None-Match');
  const ims = req.get('If-Modified-Since');

  res.set('ETag', etag);
  res.set('Last-Modified', lastModified);
  res.set('Cache-Control', 'public, max-age=0, s-maxage=60, stale-while-revalidate=300, stale-if-error=86400');

  const notModifiedByEtag = inm && inm.split(',').map(s => s.trim()).includes(etag);
  const notModifiedByDate = ims && new Date(ims) >= product.updatedAt;

  if (notModifiedByEtag || notModifiedByDate) {
    return res.status(304).end();
  }

  res.type('application/json').send(body);
});

app.put('/api/products/:id', express.json(), (req, res) => {
  if (String(product.id) !== req.params.id) {
    return res.status(404).json({ error: 'not found' });
  }
  const ifMatch = req.get('If-Match');
  const currentEtag = makeEtag(Buffer.from(JSON.stringify(product)));
  if (ifMatch && ifMatch !== currentEtag) {
    return res.status(412).json({ error: 'precondition failed' });
  }
  product = { ...product, ...req.body, updatedAt: new Date() };
  const body = Buffer.from(JSON.stringify(product));
  res.set('ETag', makeEtag(body));
  res.set('Last-Modified', product.updatedAt.toUTCString());
  res.json(product);
});

app.listen(3000, () => console.log('API on http://localhost:3000'));

• GET: если ETag или дата совпадают — 304 и пустой ответ.
• PUT: If-Match защищает от потери обновлений.

Go (net/http): условный GET

package main

import (
    "crypto/sha256"
    "encoding/base64"
    "encoding/json"
    "log"
    "net/http"
    "time"
)

type Product struct {
    ID        int       `json:"id"`
    Name      string    `json:"name"`
    Price     int       `json:"price"`
    UpdatedAt time.Time `json:"updatedAt"`
}

var product = Product{ID: 42, Name: "Кофемолка", Price: 4990, UpdatedAt: time.Date(2025, 1, 1, 10, 0, 0, 0, time.UTC)}

func makeETag(b []byte) string {
    sum := sha256.Sum256(b)
    return "\"" + base64.RawURLEncoding.EncodeToString(sum[:])[:27] + "\""
}

func productHandler(w http.ResponseWriter, r *http.Request) {
    body, _ := json.Marshal(product)
    etag := makeETag(body)
    lastModified := product.UpdatedAt.UTC().Format(http.TimeFormat)

    w.Header().Set("ETag", etag)
    w.Header().Set("Last-Modified", lastModified)
    w.Header().Set("Cache-Control", "public, max-age=0, s-maxage=60, stale-while-revalidate=300, stale-if-error=86400")

    inm := r.Header.Get("If-None-Match")
    ims := r.Header.Get("If-Modified-Since")

    if inm == etag {
        w.WriteHeader(http.StatusNotModified)
        return
    }
    if ims != "" {
        if t, err := time.Parse(http.TimeFormat, ims); err == nil && !product.UpdatedAt.After(t) {
            w.WriteHeader(http.StatusNotModified)
            return
        }
    }

    w.Header().Set("Content-Type", "application/json")
    w.Write(body)
}

func main() {
    http.HandleFunc("/api/products/42", productHandler)
    log.Fatal(http.ListenAndServe(":3000", nil))
}

Работа с CDN и инвалидация

Разделяем кэш для браузера и для CDN

• Для браузера — max-age.
• Для CDN — s-maxage. Это позволяет держать в CDN копию дольше, чем в браузере, и чаще делать быструю ре‑валидацию из браузера.

Пример: Cache-Control: public, max-age=0, s-maxage=300, stale-while-revalidate=600.

Теги (surrogate keys) и точечная очистка

Поддерживается в ряде CDN. Идея — пометить ответ ключами, а потом чистить по ключу без перечисления URL.

В ответ:

Surrogate-Key: product:42 catalog:home
Cache-Control: public, s-maxage=300, stale-while-revalidate=600

Инвалидация (Fastly):

curl -X POST \
  -H "Fastly-Key: $FASTLY_API_TOKEN" \
  -H "Accept: application/json" \
  https://api.fastly.com/service/$SERVICE_ID/purge/product:42

Так вы не выбиваете весь кэш и не создаёте шторм запросов к бэкенду.

Вытягиваем максимум из stale-while-revalidate

• Убедитесь, что CDN его понимает. Если нет — используйте настройки провайдера (аналогичная опция есть почти у всех).
• На бэкенде поддерживайте быстрый HEAD/условный GET: CDN сможет проверить актуальность без передачи тела.

Безопасность и частые грабли

• Персонифицированные ответы и кэш. Не кэшируйте публично то, что зависит от куки/токенов. Ставьте Cache-Control: private либо Vary: Authorization. Иначе чужие данные могут утечь в общий кэш.
• Set-Cookie ломает общий кэш. Если в ответе Set-Cookie, многие CDN по умолчанию не кэшируют. Разделяйте: данные отдельно, куки отдельно.
• Vary без фанатизма. Лишние измерения в Vary распиливают кэш на мелкие корзины. Типовые: Accept-Encoding, Accept-Language (если реально разный контент), Authorization.
• ETag и приватность. Не включайте в ETag персональные идентификаторы — они могут всплыть в заголовках и логах.
• no-store для чувствительного. Платёжные страницы, токены, медицинские данные — ставьте Cache-Control: no-store.
• Дата округлением. Для Last-Modified используйте секунды (стандартный формат), не миллисекунды — меньше ложных промахов и утечек точного времени изменений.
• Защита от отравления кэша (cache poisoning). Валидируйте входные заголовки, не подмешивайте произвольные параметры в ключи кэша без проверки.

Наблюдаемость: что мерить

• Доля кэш‑хитов (request hit ratio) и экономия байтов (byte hit ratio) по CDN и по браузерам.
• Доля ответов 304. Чем выше без роста ошибок — тем лучше работает ре‑валидация.
• Время ответа P50/P95/P99 для кэшируемых маршрутов — должно заметно просесть.
• Нагрузка на бэкенд: QPS, CPU, чтения из базы — ожидаем снижение.

Пример логов Nginx с отметкой статуса кэша:

log_format main '$remote_addr "$request" $status $body_bytes_sent ' 
                 'rt=$request_time uct=$upstream_connect_time uht=$upstream_header_time ' 
                 'ucs=$upstream_cache_status';
access_log /var/log/nginx/access.log main;

В метриках стройте дашборды по $upstream_cache_status: HIT, MISS, BYPASS, EXPIRED, STALE.

План внедрения по шагам

1. Статика. Включите fingerprint в сборке (Webpack/Vite/Rollup), настройте Cache-Control: immutable, а HTML — no-cache. Проверьте обновление версии после релиза.

2. CDN поверх статики. Поднимите TTL, включите компрессию и brotli, измерьте byte hit ratio.

3. API‑GET с ре‑валидацией. Добавьте ETag/Last-Modified, If-None-Match/If-Modified-Since, Cache-Control с s-maxage и stale-while-revalidate. Начните с самых горячих эндпоинтов чтения.

4. Предикаты на запись. Для конфликтующих сущностей потребуйте If-Match (или версионное поле) на PUT/PATCH/DELETE.

5. Защита от лавины. Для обратного прокси включите proxy_cache_lock и отдачу устаревшего при обновлении/ошибке.

6. Точечная инвалидация. Включите surrogate keys (если поддерживается CDN) и чистите кэш по сущности при изменениях.

7. Наблюдаемость. Добавьте метрики HIT/MISS/304, сравните стоимость и латентность до/после, зафиксируйте экономию.

Чек‑лист перед выкладкой

• Заголовки Cache-Control для каждой категории ответов: статика, HTML, публичные API, приватные API.
• ETag и Last-Modified корректно меняются при изменении данных.
• 304 отдаётся при If-None-Match/If-Modified-Since, тело не отправляется.
• Vary проставлен осознанно (минимально необходим).
• Приватные ответы помечены private или no-store.
• CDN понимает stale-while-revalidate и отдаёт устаревшее при ошибке.
• Настроены дашборды по HIT/MISS/304 и алерты на падение hit ratio.

Итоги

HTTP‑кэширование — дешёвый рычаг для ускорения продукта и разгрузки серверов. Начните со статики, добавьте ре‑валидацию для API и аккуратно включите инвалидацию по тегам. Управляйте заголовками осознанно, следите за метриками, и вы увидите: страницы откликаются быстрее, пиковые нагрузки перестают пугать, а счета за инфраструктуру становятся приятнее.