Skip to content

HTTP Шпаргалка

Протокол передачи гипертекста для взаимодействия клиента и сервера.

01

Начало работы

HTTP-запрос и ответ

HTTP — протокол «запрос-ответ». Клиенты отправляют запросы (метод, путь, заголовки, необязательное тело), серверы отвечают статусом, заголовками и телом. HTTP/1.1 текстовый, HTTP/2 и HTTP/3 используют бинарные фреймы.

http
# HTTP Request
GET /api/users HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0
Accept: application/json

# HTTP Response
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 45

{"id": 1, "name": "Alice", "email": "[email protected]"}

Структура URL

URL идентифицируют ресурсы. Схема выбирает протокол. Хост разрешается через DNS. Порт по умолчанию подразумевается, если не указан. Фрагмент (#) существует только на клиенте и отбрасывается перед отправкой на сервер. Query-строки обычно используются для фильтрации и пагинации.

http
# Generic URL format
scheme://userinfo@host:port/path?query#fragment

# Example
https://user:[email protected]:8443/api/v1/users?page=2#section

# Components
# scheme    - https (protocol)
# userinfo  - user:pass (rare, deprecated)
# host      - example.com (domain or IP)
# port      - 8443 (default: 80 for http, 443 for https)
# path      - /api/v1/users (resource location)
# query     - page=2 (key=value pairs, & separated)
# fragment  - section (client-only, never sent to server)

Обзор версий HTTP

HTTP/0.9 был минимальным прототипом. HTTP/1.0 добавил заголовки и типы содержимого, но открывал новое соединение на каждый запрос. HTTP/1.1 ввёл постоянные соединения, обязательный заголовок Host (включив виртуальные хосты) и конвейеризацию. HTTP/2 добавил бинарное мультиплексирование. HTTP/3 работает поверх QUIC, устраняя блокировку начала очереди на транспортном уровне.

http
# HTTP/0.9 (1991) - single GET, no headers
GET /page.html

# HTTP/1.0 (1996) - headers, status codes, multiple types
GET /page.html HTTP/1.0

# HTTP/1.1 (1997) - persistent connections, Host header, pipelining
GET /page.html HTTP/1.1
Host: example.com

# HTTP/2 (2015) - binary, multiplexing, header compression
# (negotiated via ALPN or h2c upgrade)

# HTTP/3 (2022) - over QUIC (UDP-based)
# (negotiated via Alt-Svc header)

Жизненный цикл соединения

HTTP/1.1 по умолчанию держит TCP-соединения открытыми (keep-alive), избегая затрат на повторные рукопожатия. Несколько запросов можно отправить по одному соединению. Заголовок Connection: close сигнализирует о последнем запросе. HTTP/2 мультиплексирует много потоков по одному соединению. Таймаут и максимум Keep-Alive настраиваются на сервере.

http
# HTTP/1.1 persistent connection (keep-alive)
GET /page1 HTTP/1.1
Host: example.com
Connection: keep-alive

# (server responds, connection stays open)
HTTP/1.1 200 OK
Content-Length: 128
Connection: keep-alive

# Client reuses same TCP connection for next request
GET /page2 HTTP/1.1
Host: example.com

# Closing the connection
GET /final HTTP/1.1
Host: example.com
Connection: close

Формат сообщения

HTTP-сообщения начинаются со стартовой строки (request-line или status-line), затем идут заголовки, пустая строка и необязательное тело. Строки завершаются CRLF. Имена заголовков нечувствительны к регистру. Пустая строка обязательна и сигнализирует начало тела. Тела могут быть любой длины (chunked) или фиксированной (Content-Length).

http
# Request format
<METHOD> <PATH> <VERSION>

<Header-Name>: <value>

...



<optional body>

# Response format
<VERSION> <STATUS> <REASON>

<Header-Name>: <value>

...



<optional body>

# Lines end with CRLF (
). Headers are case-insensitive.
# A blank line (
) separates headers from body.

Отладка через telnet / сырой HTTP

На HTTP можно говорить напрямую по TCP через nc или telnet (порт 80) либо openssl s_client (HTTPS). Это бесценно для отладки. В HTTP/1.1+ обязательно указывайте заголовок Host. Две пустые строки завершают запрос. curl -v показывает обмен в сетевом формате вместе с заголовками.

http
# Manual HTTP request via netcat/nc
nc example.com 80
GET / HTTP/1.1
Host: example.com

# (press Enter twice to send blank line)

# Using openssl for HTTPS
openssl s_client -connect example.com:443
GET / HTTP/1.1
Host: example.com

# curl with --http1.1 to force version
curl -v --http1.1 https://example.com
curl -v --http2 https://example.com
curl -v --http3 https://example.com
02

HTTP-методы

GET — получение ресурса

GET получает представление ресурса. Он должен быть безопасным (без побочных эффектов) и идемпотентным (повторяемым). GET-запросы кешируются и сохраняются в закладках. Хотя спецификация допускает тело, это не рекомендуется: прокси и CDN могут его отбросить. Для фильтрации используйте query-параметры.

http
# Basic GET
GET /api/users/42 HTTP/1.1
Host: api.example.com
Accept: application/json

# GET with query parameters
GET /api/users?role=admin&active=true HTTP/1.1
Host: api.example.com

# GET should be safe & idempotent
# - safe: no server state change
# - idempotent: repeating yields same result
# - cacheable: yes
# - body allowed but discouraged (some clients/servers reject)

POST — создание ресурса

POST отправляет данные на обработку. Используется для создания новых ресурсов, когда URI назначает сервер (например, /api/users → /api/users/43). POST не безопасен и не идемпотентен: повторная отправка может создать два ресурса. Ответ 201 Created должен содержать заголовок Location со ссылкой на новый ресурс.

http
# POST creating a new resource
POST /api/users HTTP/1.1
Host: api.example.com
Content-Type: application/json
Content-Length: 52

{"name": "Bob", "email": "[email protected]", "age": 30}

# Response typically 201 Created with Location header
HTTP/1.1 201 Created
Location: /api/users/43
Content-Type: application/json

{"id": 43, "name": "Bob"}

# POST is neither safe nor idempotent.
# Repeating may create duplicate resources.

PUT — замена ресурса

PUT заменяет весь ресурс по целевому URI телом запроса. Он идемпотентен: повторение того же PUT даёт то же конечное состояние. PUT нацелен на конкретный URI (например, /users/43), в отличие от POST, направленного на коллекцию. Если поле в PUT опущено, оно обычно удаляется (полная замена).

http
# PUT replaces the entire resource at the given URI
PUT /api/users/43 HTTP/1.1
Host: api.example.com
Content-Type: application/json
Content-Length: 60

{"id": 43, "name": "Robert", "email": "[email protected]", "age": 31}

# Idempotent: sending the same PUT again yields the same state.
# If the resource doesn't exist, PUT may create it (server-dependent).

# Response
HTTP/1.1 200 OK
# or 204 No Content if no body returned

PATCH — частичное обновление

PATCH применяет частичные изменения к ресурсу, а PUT заменяет его целиком. Простейшая форма — JSON Merge Patch (RFC 7396): отправляйте только изменяемые поля. JSON Patch (RFC 6902) использует массив операций (add, remove, replace, move, copy, test). PATCH по умолчанию НЕ идемпотентен, хотя merge-patch идемпотентен.

http
# PATCH applies partial modifications
PATCH /api/users/43 HTTP/1.1
Host: api.example.com
Content-Type: application/merge-patch+json
Content-Length: 22

{"email": "[email protected]"}

# Only the email field is updated; other fields remain.

# JSON Patch (RFC 6902) - structured operations
PATCH /api/users/43 HTTP/1.1
Content-Type: application/json-patch+json

[
  {"op": "replace", "path": "/email", "value": "[email protected]"},
  {"op": "remove", "path": "/age"}
]

DELETE — удаление ресурса

DELETE удаляет целевой ресурс. Он идемпотентен: повторное удаление того же ресурса должно оставлять сервер в том же состоянии. Частые коды успеха: 204 (без тела), 200 (с подтверждением в теле) или 202 (асинхронное удаление). Большинство API требуют аутентификации. Спорно, возвращать ли 404 на отсутствующий ресурс, — для идемпотентности безопаснее 204.

http
# Delete a resource
DELETE /api/users/43 HTTP/1.1
Host: api.example.com
Authorization: Bearer <token>

# Successful responses:
HTTP/1.1 204 No Content        # most common
HTTP/1.1 200 OK                 # if body returned
HTTP/1.1 202 Accepted           # async deletion queued

# Idempotent: deleting an already-deleted resource
# should still return 204 (or 404 — debatable).

HEAD и OPTIONS

HEAD идентичен GET, но сервер возвращает только заголовки (без тела) — удобно проверить Content-Length, Content-Type или Last-Modified, не скачивая тело. OPTIONS спрашивает, какие методы разрешены (заголовок Allow), и используется браузерами для CORS preflight. Оба безопасны и идемпотентны.

http
# HEAD: like GET but returns headers only (no body)
HEAD /api/users/42 HTTP/1.1
Host: api.example.com

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 128
# (no body)

# OPTIONS: describe communication options
OPTIONS /api/users HTTP/1.1
Host: api.example.com

HTTP/1.1 200 OK
Allow: GET, POST, HEAD, OPTIONS
Access-Control-Allow-Methods: GET, POST
03

Коды состояния

1xx — информационные

Коды 1xx информационные: запрос получен, обработка продолжается. 100 Continue позволяет клиенту проверить, стоит ли отправлять большое тело (в паре с заголовком Expect: 100-continue). 101 Switching Protocols включает WebSocket. 103 Early Hints позволяет серверу подсказать браузеру предзагрузить ресурсы до готовности финального ответа.

http
# 100 Continue - server received headers, client may send body
POST /upload HTTP/1.1
Host: example.com
Expect: 100-continue
Content-Length: 1048576

# Server replies:
HTTP/1.1 100 Continue
# (client now sends the request body)

# 101 Switching Protocols - used for WebSocket upgrade
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade

# 103 Early Hints - preload resources before final response
HTTP/1.1 103 Early Hints
Link: </style.css>; rel=preload; as=style

2xx — успех

Коды 2xx означают успех. 200 OK — общий успех. 201 Created — создан новый ресурс (с заголовком Location). 202 Accepted — запрос поставлен в очередь на асинхронную обработку (например, долгая задача). 204 No Content — успех без тела, типично для DELETE/PUT. 206 Partial Content возвращает часть ресурса (Range-запрос).

http
# 200 OK - standard success
HTTP/1.1 200 OK

# 201 Created - new resource created (POST/PUT)
HTTP/1.1 201 Created
Location: /api/users/43

# 202 Accepted - request queued for async processing
HTTP/1.1 202 Accepted

# 204 No Content - success, no body (DELETE, PUT)
HTTP/1.1 204 No Content

# 206 Partial Content - Range request result
HTTP/1.1 206 Partial Content
Content-Range: bytes 0-1023/2048

3xx — перенаправление

Коды 3xx означают перенаправление. 301/308 постоянные (кешируются, SEO-вес переходит), 302/307 временные. Ключевая разница: 301 и 302 исторически допускали преобразование POST→GET (с потерей данных), а 307 и 308 строго сохраняют метод. 304 Not Modified возвращается на условные запросы, когда кеш валиден, — без тела.

http
# 301 Moved Permanently - cacheable, change bookmarks
HTTP/1.1 301 Moved Permanently
Location: https://newsite.com/page

# 302 Found - temporary redirect (don't update bookmarks)
HTTP/1.1 302 Found
Location: /login

# 304 Not Modified - cache is still valid (conditional GET)
HTTP/1.1 304 Not Modified
ETag: "abc123"

# 307 Temporary Redirect - preserves method (POST stays POST)
HTTP/1.1 307 Temporary Redirect
Location: /new-endpoint

# 308 Permanent Redirect - permanent, preserves method
HTTP/1.1 308 Permanent Redirect
Location: https://newsite.com/api

4xx — ошибки клиента

Коды 4xx означают ошибку клиента. 400 Bad Request — некорректный ввод. 401 — нет или неверная аутентификация (обязателен WWW-Authenticate). 403 — аутентификация есть, но нет прав. 404 — ресурс отсутствует. 429 — ограничение частоты (добавьте Retry-After). Другие частые: 405 Method Not Allowed, 409 Conflict, 422 Unprocessable Entity.

http
# 400 Bad Request - malformed syntax
HTTP/1.1 400 Bad Request
Content-Type: application/json

{"error": "Invalid JSON in request body"}

# 401 Unauthorized - authentication required
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer realm="api"

# 403 Forbidden - authenticated but not allowed
HTTP/1.1 403 Forbidden

# 404 Not Found - resource doesn't exist
HTTP/1.1 404 Not Found

# 429 Too Many Requests - rate limit hit
HTTP/1.1 429 Too Many Requests
Retry-After: 60

5xx — ошибки сервера

Коды 5xx означают сбой сервера. 500 — общий код для необработанных ошибок (смотрите логи сервера). 501 — сервер не реализует метод. 502 — прокси или шлюз получил плохой ответ от вышестоящего сервера. 503 — временная перегрузка (используйте Retry-After). 504 — таймаут вышестоящего сервера. Клиенты могут повторять 502/503/504 с задержкой.

http
# 500 Internal Server Error - generic server failure
HTTP/1.1 500 Internal Server Error

# 501 Not Implemented - server doesn't support the method
HTTP/1.1 501 Not Implemented

# 502 Bad Gateway - upstream server returned invalid response
HTTP/1.1 502 Bad Gateway

# 503 Service Unavailable - temporary overload or maintenance
HTTP/1.1 503 Service Unavailable
Retry-After: 300

# 504 Gateway Timeout - upstream didn't respond in time
HTTP/1.1 504 Gateway Timeout

Паттерны кодов состояния

Последовательное сопоставление кодов делает API предсказуемым. 2xx — успех с семантической точностью (201 при создании, 204 без тела). 4xx — ошибки клиента с самым конкретным кодом (409 для конфликтов, 422 для валидации). Самая частая путаница — 401 против 403: 401 = «кто вы?», 403 = «я знаю, кто вы, но вам это нельзя».

http
# REST API common mapping
GET     /users      -> 200
POST    /users      -> 201 (Created)
GET     /users/42   -> 200 | 404
PUT     /users/42   -> 200 | 201 (if created) | 404
PATCH   /users/42   -> 200 | 404
DELETE  /users/42   -> 204 | 404

# Validation errors
400 -> malformed JSON, missing required field
409 -> duplicate resource / version conflict
422 -> semantic validation failure (some APIs)

# Auth flow
401 -> no/invalid token (login required)
403 -> logged in but lacking permission
404 -> hide existence from unauthorized users

# Use 418 I'm a teapot for fun (RFC 2324 joke).
04

Заголовки запроса

Частые заголовки запроса

Частые заголовки запроса передают идентичность клиента (User-Agent), желаемый формат ответа (семейство Accept), управление соединением (Connection), аутентификацию (Authorization), состояние (Cookie) и источник (Referer/Origin). Host обязателен в HTTP/1.1+ для виртуального хостинга. Content-Type и Content-Length описывают тело запроса.

http
GET /api/data HTTP/1.1
Host: api.example.com          # target host (mandatory in HTTP/1.1)
User-Agent: Mozilla/5.0        # client identity
Accept: application/json        # desired response format
Accept-Language: en-US,en;q=0.9
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Authorization: Bearer <token>
Cookie: session=abc123; theme=dark
Referer: https://example.com/
Origin: https://example.com
Content-Type: application/json
Content-Length: 42

Accept-заголовки (согласование содержимого)

Семейство Accept управляет согласованием содержимого. Значения качества (q, 0-1) выражают предпочтение: выше — предпочтительнее. */* — подстановочный знак. Сервер выбирает лучшее совпадение из поддерживаемых; если совпадений нет, он возвращает 406 Not Acceptable (хотя большинство серверов отдают формат по умолчанию вместо 406). Brotli (br) и zstd сжимают лучше gzip.

http
# Accept: desired media types with quality (q) values
Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8

# Accept-Language: preferred languages
Accept-Language: en-US,en;q=0.9, zh-CN;q=0.8, fr;q=0.7

# Accept-Encoding: accepted compression algorithms
Accept-Encoding: gzip, deflate, br, zstd;q=0.9

# q=1.0 is default. Higher q = more preferred.
# */* matches any type.
# Server responds with 406 Not Acceptable if it can't satisfy.

Authorization и заголовки аутентификации

Authorization несёт учётные данные. Basic auth отправляет base64 от username:password в каждом запросе (всегда используйте HTTPS). Bearer-токены — непрозрачные строки (часто JWT) для OAuth 2.0. Свои схемы (X-API-Key) обычны для API-шлюзов. Base64 в Basic auth — кодирование, а не шифрование: без TLS он не даёт защиты.

http
# Basic Authentication (base64 of user:pass)
Authorization: Basic dXNlcjpwYXNz
# dXNlcjpwYXNz = base64("user:pass")

# Bearer Token (OAuth 2.0 / JWT)
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...

# API Key in header (custom)
X-API-Key: abc123def456

# Proxy authentication
Proxy-Authorization: Basic dXNlcjpwYXNz

# WARNING: Basic auth sends credentials on every request.
# Always use HTTPS to prevent eavesdropping.

User-Agent и Referer

User-Agent идентифицирует клиента, но большинство браузеров подделывают Mozilla/5.0 ради обратной совместимости (историческое определение браузера). Referer (опечатка в спецификации, так и не исправленная) говорит серверу, какая страница ссылается на запрос, — используется для аналитики и защиты от хотлинка. Origin — это схема+хост+порт, отправляется браузерами в CORS-запросах и POST.

http
# User-Agent identifies the client software
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

# Common browsers prepend "Mozilla/5.0" for historical compatibility
# (servers used to serve different content to different browsers)

# Referer: page that linked to this request
Referer: https://example.com/search?q=hello

# Origin: scheme + host + port (used by CORS)
Origin: https://example.com

# Note: "Referer" is the official spelling (misspelled in the original spec)

Условные заголовки запроса

Условные заголовки обеспечивают эффективное кеширование и контроль конкурентности. If-None-Match (с ETag) и If-Modified-Since (с Last-Modified) делают GET условным: сервер возвращает 304, если кеш валиден. If-Match и If-Unmodified-Since защищают PUT/PATCH от потерянных обновлений (оптимистичная блокировка). If-Range делает range-запросы атомарными.

http
# Conditional GET - only fetch if changed
If-Modified-Since: Wed, 21 Oct 2023 07:28:00 GMT
If-None-Match: "abc123"

# If-Match / If-Unmodified-Since - for safe PUT/PATCH
If-Match: "abc123"
If-Unmodified-Since: Wed, 21 Oct 2023 07:28:00 GMT

# If-Range - for range requests (all-or-nothing)
If-Range: "abc123"
Range: bytes=0-1023

# Typical flow:
# 1. Server sends ETag/Last-Modified with response
# 2. Client sends If-None-Match/If-Modified-Since on next request
# 3. Server replies 304 if unchanged, 200 if changed

Свои заголовки и X-заголовки

Свои заголовки исторически использовали префикс X-, но RFC 6648 в 2012 году отменил это соглашение. Новые заголовки должны обходиться без X- (например, Request-ID, а не X-Request-ID). X-Forwarded-For и X-Forwarded-Proto передают данные клиента через прокси (их можно подделать). Стандартная альтернатива — Forwarded (RFC 7239). Traceparent/Tracestate включают распределённую трассировку (W3C).

http
# X- prefixed headers (deprecated convention, but widely used)
X-Request-ID: 550e8400-e29b-41d4-a716-446655440000
X-Correlation-ID: abc-123
X-Forwarded-For: 203.0.113.1, 70.41.3.18
X-Forwarded-Proto: https
X-Real-IP: 203.0.113.1
X-RateLimit-Remaining: 42

# Modern recommendation: avoid X- prefix (RFC 6648)
# Use a namespace instead:
Request-ID: 550e8400-e29b-41d4-a716-446655440000
Traceparent: 00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01

# Forwarded (RFC 7239) - standardized proxy info
Forwarded: for=203.0.113.1; proto=https; host=example.com
05

Заголовки ответа

Частые заголовки ответа

Частые заголовки ответа описывают сервер (Server), тело ответа (Content-Type, Content-Length), управление соединением (Connection), кеширование (Cache-Control, ETag, Last-Modified), согласование содержимого (Vary), состояние (Set-Cookie) и CORS (Access-Control-*). Date обязателен и использует формат RFC 1123 в GMT.

http
HTTP/1.1 200 OK
Server: nginx/1.25.0
Date: Wed, 21 Oct 2023 07:28:00 GMT
Content-Type: application/json; charset=utf-8
Content-Length: 128
Connection: keep-alive
Cache-Control: public, max-age=3600
ETag: "abc123"
Last-Modified: Mon, 20 Oct 2023 10:00:00 GMT
Vary: Accept-Encoding
Set-Cookie: session=xyz; HttpOnly; Secure
Access-Control-Allow-Origin: https://example.com

Заголовки содержимого

Заголовки Content-* описывают тело. Content-Type — MIME-тип, он критичен. Content-Length даёт точное число байт (обязателен, если не используется chunked). Content-Encoding указывает сжатие (gzip, br). Content-Disposition заставляет скачать файл с именем. Content-Range сопровождает ответы 206 Partial Content.

http
# Body metadata
Content-Type: application/json; charset=utf-8
Content-Length: 128                # exact byte count
Content-Encoding: gzip             # applied encoding
Content-Language: en-US
Content-Location: /api/users/42.json
Content-Disposition: attachment; filename="report.pdf"
Content-Range: bytes 0-1023/2048   # for partial content

# For chunked transfer (no Content-Length known upfront)
Transfer-Encoding: chunked

# MIME type format: type/subtype; parameter=value
# e.g., text/html; charset=UTF-8

Заголовки безопасности

Заголовки безопасности защищают браузеры от типовых атак. HSTS принудительно включает HTTPS и предотвращает SSL stripping. X-Content-Type-Options: nosniff запрещает определение MIME по содержимому. X-Frame-Options (или CSP frame-ancestors) блокирует кликджекинг. CSP — самый мощный: управляет тем, какие ресурсы могут загружаться и выполняться. Referrer-Policy ограничивает утечку referrer. Задавайте их в каждом ответе.

http
# Force HTTPS for 6 months (incl. subdomains)
Strict-Transport-Security: max-age=15768000; includeSubDomains; preload

# Prevent MIME-type sniffing
X-Content-Type-Options: nosniff

# Prevent clickjacking
X-Frame-Options: DENY
# Or modern CSP frame-ancestors:
Content-Security-Policy: frame-ancestors 'none'

# Referrer policy
Referrer-Policy: strict-origin-when-cross-origin

# Permissions policy (feature lockdown)
Permissions-Policy: geolocation=(), camera=()

# Full Content-Security-Policy
Content-Security-Policy: default-src 'self'; script-src 'self' https://cdn.example.com

CORS-заголовки ответа

CORS-заголовки позволяют серверу разрешить межсайтовые запросы. Access-Control-Allow-Origin обязателен для любого межсайтового чтения: конкретный origin или *. Если используются учётные данные, нужен Allow-Credentials: true И конкретный origin (без шаблона). Ответы preflight (OPTIONS) содержат Allow-Methods/Headers. Expose-Headers позволяет JS читать нестандартные заголовки ответа.

http
# Allow a specific origin
Access-Control-Allow-Origin: https://example.com
# Or wildcard (but credentials won't work with *)
Access-Control-Allow-Origin: *

# Allow credentials (cookies, Authorization)
Access-Control-Allow-Credentials: true

# Allowed methods (preflight response)
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS

# Allowed headers (preflight response)
Access-Control-Allow-Headers: Content-Type, Authorization

# How long browser can cache preflight (seconds)
Access-Control-Max-Age: 86400

# Headers the JS can read from the response
Access-Control-Expose-Headers: X-Request-ID, X-Total-Count

Заголовки кеширования

Cache-Control — современный (HTTP/1.1) заголовок кеширования с директивами: public/private (кто может кешировать), max-age (свежесть в секундах), no-cache (нужна ревалидация), no-store (не кешировать), immutable (URL никогда не меняется). ETag и Last-Modified — валидаторы для условных запросов. Expires (HTTP/1.0) — запасной вариант. Age говорит, сколько ответ уже в кеше.

http
# Cache-Control directives (HTTP/1.1 - preferred)
Cache-Control: public, max-age=3600
Cache-Control: private, max-age=600
Cache-Control: no-cache              # revalidate before use
Cache-Control: no-store              # never cache
Cache-Control: must-revalidate
Cache-Control: immutable

# Validators
ETag: "abc123"                       # opaque version tag
Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT

# HTTP/1.0 fallbacks (deprecated)
Expires: Wed, 21 Oct 2023 08:28:00 GMT
Pragma: no-cache

# Age: time a response has been in a cache (seconds)
Age: 120
06

Cookie и Set-Cookie

Установка cookie (Set-Cookie)

Set-Cookie велит браузеру сохранить cookie. Атрибуты управляют областью и сроком: Domain/Path ограничивают, куда он отправляется; Max-Age (в секундах) или Expires задают срок; Secure ограничивает HTTPS; HttpOnly блокирует доступ из JS; SameSite управляет межсайтовой отправкой. Чтобы удалить cookie, задайте Max-Age=0 с теми же Path/Domain.

http
# Basic cookie
HTTP/1.1 200 OK
Set-Cookie: session=abc123

# With attributes
Set-Cookie: session=abc123; Path=/; Domain=example.com; Max-Age=3600; HttpOnly; Secure; SameSite=Lax

# Multiple cookies = multiple Set-Cookie headers
Set-Cookie: session=abc123; HttpOnly; Secure
Set-Cookie: theme=dark; Max-Age=86400
Set-Cookie: lang=en-US; Path=/

# Deleting a cookie: set Max-Age=0 or expired Expires
Set-Cookie: session=; Max-Age=0; Path=/

Атрибуты cookie

Атрибуты cookie управляют безопасностью и областью. Secure + HttpOnly + SameSite — современный минимум. SameSite=Lax — значение по умолчанию в браузерах: разрешает cookie при навигации верхнего уровня, но блокирует в сторонних контекстах (отражает большинство CSRF). Префикс __Host- требует Path=/, отсутствия Domain и Secure — предотвращает инъекцию cookie с поддомена. __Secure- требует Secure.

http
# Security attributes
Secure           # only sent over HTTPS
HttpOnly         # not accessible via document.cookie (XSS protection)
SameSite=Strict  # never sent on cross-site requests
SameSite=Lax     # sent on top-level navigation (default in modern browsers)
SameSite=None    # sent cross-site (requires Secure)

# Scope attributes
Domain=example.com    # visible to subdomains too
Path=/                # visible to all paths
Path=/api             # only /api and below

# Lifetime attributes
Max-Age=3600          # seconds (preferred)
Expires=Wed, 21 Oct 2025 07:28:00 GMT  # absolute date

# __Host- and __Secure- prefixes (extra protection)
Set-Cookie: __Host-session=abc; Path=/; Secure; HttpOnly; SameSite=Lax

Отправка cookie (Cookie)

Заголовок запроса Cookie отправляет все подходящие cookie парами name=value (без атрибутов). Браузер отправляет cookie автоматически в каждом подходящем запросе. Для межсайтового fetch с cookie клиент должен указать credentials: 'include', а сервер — вернуть конкретный origin (не *) с Access-Control-Allow-Credentials: true.

http
# Browser sends stored cookies back to the server
GET /api/profile HTTP/1.1
Host: example.com
Cookie: session=abc123; theme=dark; lang=en-US

# Format: name=value pairs separated by "; "
# No attributes are sent back - only name=value

# Server reads cookies (Express.js example)
# const sessionId = req.headers.cookie
#   .split(';').find(c => c.trim().startsWith('session='))
#   .split('=')[1];

# Cross-site requests (with credentials)
fetch('https://api.example.com/data', {
  credentials: 'include'  # sends cookies cross-origin
});
# Server must respond with:
# Access-Control-Allow-Origin: https://app.example.com (specific, no *)
# Access-Control-Allow-Credentials: true

Cookie против токена

Cookie хранит и отправляет браузер автоматически; токены (JWT) хранятся в JS и отправляются вручную. Cookie уязвимы к CSRF (защита через SameSite). Токены уязвимы к XSS (защита — короткий срок жизни и безопасное хранение). Cookie подходят для same-origin веб-приложений; токены — для API и SPA. Лучшее из двух: refresh-токен в HttpOnly cookie, access-токен в памяти.

http
# Cookie-based auth (stateful server-side session)
POST /login HTTP/1.1
Host: example.com
Content-Type: application/json

{"user": "alice", "password": "secret"}

# Server response
HTTP/1.1 200 OK
Set-Cookie: session=abc123; HttpOnly; Secure; SameSite=Lax

# Subsequent requests carry cookie automatically
GET /api/profile HTTP/1.1
Cookie: session=abc123

# Token-based auth (stateless, e.g., JWT)
# Server response
HTTP/1.1 200 OK
Content-Type: application/json

{"token": "eyJhbGc..."}

# Subsequent requests carry token in header (manual)
GET /api/profile HTTP/1.1
Authorization: Bearer eyJhbGc...

Сторонние cookie и SameSite

Сторонние cookie ставятся доменом, отличным от страницы, которую посещает пользователь, — их давно используют для трекинга и рекламы. Для них нужен SameSite=None+Secure. Современные браузеры (Chrome, Firefox, Safari) постепенно отказываются от сторонних cookie. Альтернативы: CHIPS (разделённые cookie, привязанные к сайту верхнего уровня), Storage Access API и серверный трекинг. ITP в Safari блокирует их полностью.

http
# First-party cookie: domain matches the page
Set-Cookie: session=abc; Domain=example.com
# Visiting example.com -> sent to example.com (first-party)

# Third-party cookie: embedded in another site's page
# e.g., analytics.com cookie loaded via <img> on shop.com
Set-Cookie: tracker=xyz; Domain=analytics.com; SameSite=None; Secure

# SameSite behavior:
# Strict  -> NOT sent on shop.com -> analytics.com requests
# Lax     -> NOT sent on embedded cross-site requests
#            (sent on top-level navigation)
# None    -> sent cross-site (requires Secure)

# Browsers are phasing out third-party cookies (2024+).
# Alternatives: Partitioned cookies (CHIPS)
Set-Cookie: tracker=xyz; Partitioned; Secure; SameSite=None
07

Аутентификация

Basic-аутентификация

Basic auth отправляет учётные данные в base64 при каждом запросе. Она проста и универсально поддерживается, но без HTTPS не даёт никакой защиты: base64 легко декодируется. Заголовок WWW-Authenticate предлагает клиенту войти (браузеры показывают нативное окно). Basic auth редка в современных веб-приложениях, но обычна для API-токенов и внутренних инструментов.

http
# Basic auth: base64(user:pass) sent on every request
GET /api/data HTTP/1.1
Host: example.com
Authorization: Basic dXNlcjpwYXNz

# dXNlcjpwYXNz = base64("user:pass")
# In curl: curl -u user:pass https://example.com/api/data

# Server challenge (401 with WWW-Authenticate)
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Basic realm="Restricted Area", charset="UTF-8"

# WARNING: base64 is encoding, NOT encryption.
# Always pair Basic auth with HTTPS.

Bearer-токен (OAuth 2.0)

Bearer-токены — непрозрачные строки, предъявляемые как доказательство авторизации. Серверу достаточно их проверить: они не хранят состояние, если самодостаточны (JWT), или ищутся в хранилище. OAuth 2.0 определяет потоки получения токенов (authorization code, client credentials, refresh token). Всегда передавайте Bearer-токены по HTTPS. У токенов конечный срок жизни; refresh-токены дают новые.

http
# Bearer token: opaque string proving authorization
GET /api/profile HTTP/1.1
Host: api.example.com
Authorization: Bearer SlAV32hkKG...

# Token obtained from OAuth 2.0 flow:
POST /oauth/token HTTP/1.1
Content-Type: application/x-www-form-urlencoded

grant_type=password&username=alice&password=secret&client_id=...

# Response
HTTP/1.1 200 OK
Content-Type: application/json

{
  "access_token": "SlAV32hkKG...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "GmR..."
}

Структура JWT

JWT состоит из трёх частей в base64url, разделённых точками: header (алгоритм), payload (утверждения) и signature. Подпись доказывает, что токен не изменён. Частые утверждения: sub (субъект), iat (выдан в), exp (истекает), iss (издатель), aud (аудитория). Payload НЕ шифруется — никогда не кладите туда секреты. Алгоритмы подписи: HS256 (HMAC), RS256 (RSA), ES256 (ECDSA).

http
# JWT = header.payload.signature (base64url-encoded)
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkFsaWNlIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

# Decoded:
# Header
{"alg": "HS256", "typ": "JWT"}

# Payload (claims)
{
  "sub": "1234567890",        # subject (user id)
  "name": "Alice",
  "iat": 1516239022,          # issued at
  "exp": 1516242622,          # expiration
  "iss": "example.com",       # issuer
  "aud": "api.example.com"    # audience
}

# Signature (HMAC-SHA256 of header.payload with secret)
HMAC-SHA256(secret, "eyJhbGc...")

Валидация JWT

Валидация JWT: проверьте подпись (ловит изменения), затем утверждения (exp, iss, aud). exp важнее всего — отклоняйте просроченные токены с 401. JWT не хранят состояние: после выдачи их нельзя отозвать до истечения. Для отзыва используйте короткоживущие access-токены (5-15 мин) + refresh-токены на сервере или чёрный список (что убивает statelessness).

http
# Server-side JWT validation steps:
# 1. Parse three parts (header.payload.signature)
# 2. Verify signature using secret (HS256) or public key (RS256)
# 3. Check claims:
#    - exp (must be in future)
#    - iat (must be in past, optional)
#    - iss (must match expected issuer)
#    - aud (must match expected audience)
# 4. Check revocation list (if using short-lived + refresh)

# Common errors:
# 401 - invalid signature, expired, wrong issuer
# 401 - "Bearer" prefix missing
# 403 - valid token but lacking permission (scope)

# Token expired response
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer error="invalid_token", error_description="The token has expired"

Поток Authorization Code в OAuth 2.0

Authorization Code — стандарт для серверных веб-приложений. Шаг 1 перенаправляет пользователя на сервер авторизации. Шаг 2 возвращает короткоживущий код на redirect URI. Шаг 3 обменивает код (плюс client_secret) на токены между серверами. PKCE (Proof Key for Code Exchange) заменяет секрет парой code challenge/verifier — необходимо для SPA и мобильных приложений, где секрет нельзя безопасно хранить.

http
# Step 1: Redirect user to authorization endpoint
GET /authorize?response_type=code&client_id=CLIENT_ID&redirect_uri=https://app.com/callback&scope=read&state=random123 HTTP/1.1
Host: auth.example.com

# Step 2: User logs in & grants consent, redirected back with code
HTTP/1.1 302 Found
Location: https://app.com/callback?code=AUTH_CODE&state=random123

# Step 3: Server exchanges code for token (server-to-server)
POST /oauth/token HTTP/1.1
Host: auth.example.com
Content-Type: application/x-www-form-urlencoded
Authorization: Basic base64(client_id:client_secret)

grant_type=authorization_code&code=AUTH_CODE&redirect_uri=https://app.com/callback

# Step 4: Token response
{"access_token": "...", "refresh_token": "...", "expires_in": 3600}

# Use PKCE for SPAs/mobile (no client_secret)
# code_challenge = base64url(SHA256(code_verifier))

API-ключи

API-ключи — простые непрозрачные секреты, идентифицирующие клиента. Их передают в заголовках (предпочтительно) или query-строке (избегайте: попадают в логи URL и прокси). API-ключи хранят состояние (сервер их ищет) и отзываемы. В отличие от JWT, они не несут утверждений — права хранит сервер. Лучшие практики: хешировать ключи при хранении, ограничивать область, регулярно ротировать и давать интерфейс самостоятельной ротации.

http
# API key in header (most common)
GET /api/data HTTP/1.1
X-API-Key: abc123def456

# API key as Bearer token
Authorization: Bearer abc123def456

# API key in query string (less secure - logged in URLs)
GET /api/data?api_key=abc123def456 HTTP/1.1

# API key in custom header with prefix
Authorization: ApiKey abc123def456

# Best practices:
# - Rotate keys periodically
# - Scope keys to specific permissions
# - Store keys hashed at rest (like passwords)
# - Never commit keys to source control
08

Согласование содержимого

Заголовок Accept

Заголовок Accept перечисляет медиатипы, которые клиент может обработать, со значениями качества (q), выражающими предпочтение. Шаблоны (text/*, */*) расширяют совпадение. Сервер выбирает лучшее совпадение и отвечает выбранным Content-Type. Если ничего не совпало, сервер в идеале вернёт 406, но на практике многие API отдают формат по умолчанию.

http
# Single type
Accept: application/json

# Multiple types with preferences (q values, 0-1)
Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8

# Wildcard media types
Accept: text/*           # any text/* subtype
Accept: */*              # anything
Accept: image/png, image/*;q=0.8

# Parameters
Accept: text/html;charset=utf-8

# Server picks best match and returns it in Content-Type.
# If no match, server returns 406 Not Acceptable (or a default).

Accept-Language

Accept-Language сообщает серверу предпочитаемые языки пользователя со значениями качества для ранжирования. RFC 5646 определяет языковые теги (язык[-script][-region]). Сервер отвечает Content-Language. Браузеры ставят его по настройкам ОС и локали. Для i18n аккуратно откатывайтесь: если запрошенного языка нет, верните язык по умолчанию. CDN иногда кешируют по Accept-Language — используйте заголовок Vary.

http
# Single language
Accept-Language: en-US

# Multiple languages with preferences
Accept-Language: en-US,en;q=0.9, zh-CN;q=0.8, fr;q=0.7, de;q=0.5

# Wildcard
Accept-Language: *

# Server responds with the selected language:
Content-Language: en-US

# RFC 5646 language tags:
# en       - language
# en-US    - language + region
# zh-Hans  - language + script (Simplified Chinese)
# es-419   - language + region (Latin America)

Accept-Encoding

Accept-Encoding перечисляет алгоритмы сжатия, которые клиент может декодировать. Сервер выбирает один, применяет и возвращает Content-Encoding. Brotli (br) сжимает текст лучше gzip и поддерживается всеми современными браузерами. zstd набирает популярность с ещё лучшей скоростью и степенью сжатия. identity означает без сжатия. Всегда включайте сжатие для текстовых ответов (HTML, CSS, JS, JSON) — экономия трафика огромна, но пропускайте уже сжатые форматы (изображения, видео).

http
# Accepted compression algorithms
Accept-Encoding: gzip, deflate, br, zstd

# With preferences
Accept-Encoding: br;q=1.0, gzip;q=0.8, identity;q=0.5, *;q=0

# identity = no encoding (raw)
# * = any encoding not listed

# Server response
Content-Encoding: br

# Common algorithms:
# gzip     - widespread, RFC 1952
# deflate  - zlib, RFC 1950
# br       - Brotli, better for text (modern browsers)
# zstd     - Zstandard, fast + good ratio (newer)
# identity - no compression

Заголовок Vary

Заголовок Vary говорит кешам (браузер, CDN, прокси), какие заголовки запроса влияют на ответ. Если сервер возвращает разное содержимое в зависимости от Accept-Encoding, он обязан указать Vary: Accept-Encoding, чтобы кеш не отдал gzip-ответ клиенту, принимающему только br. Избыточный Vary снижает долю попаданий в кеш; недостаточный ведёт к отравлению кеша (отдаче неверного содержимого). Vary: * фактически отключает кеширование.

http
# Server response telling caches to vary by Accept-Encoding
HTTP/1.1 200 OK
Content-Type: text/html
Content-Encoding: gzip
Vary: Accept-Encoding

# Vary on multiple headers
Vary: Accept-Encoding, Accept-Language

# Vary on Accept (full content negotiation)
Vary: Accept

# Vary: * means "varies on everything" (effectively no-cache)
Vary: *

# CDN/cache key includes the Vary header values.
# A gzip+en response is cached separately from a br+fr response.

Значения качества (q)

Значения качества (q, 0-1) выражают силу предпочтения в заголовках семейства Accept. q=1.0 — по умолчанию (наиболее предпочтительно); q=0 означает «неприемлемо». Сервер перечисляет, что может произвести, сопоставляет с клиентским списком и выбирает совпадение с наибольшим q. При равенстве решает конкретность: application/json важнее */* при том же q. Допускаются три знака после запятой, но нужны они редко.

http
# q values appear in Accept, Accept-Language, Accept-Encoding, Accept-Charset
# Format: ;q=0.000 to ;q=1.000 (default is 1.0)

Accept: text/html;q=1.0, application/json;q=0.9, */*;q=0.1

# Meaning:
# q=1.0    - strongly preferred
# q=0.5    - acceptable
# q=0      - NOT acceptable (refuse)

# Server algorithm (RFC 7231):
# 1. List media types the server can produce
# 2. Match each against the client's Accept
# 3. Pick the match with the highest q value
# 4. Ties broken by specificity (concrete > wildcard)

# Example: client prefers JSON over XML
Accept: application/json, application/xml;q=0.5
09

Кеширование

Директивы Cache-Control

Cache-Control — современный заголовок кеширования с директивами. public/private определяют, кто может кешировать; max-age задаёт свежесть в секундах; no-cache требует ревалидации; no-store запрещает кеширование; must-revalidate запрещает отдачу устаревшего; s-maxage задаёт отдельный TTL для общих кешей (CDN). immutable говорит браузерам, что ресурс никогда не меняется, — пропускайте ревалидацию при перезагрузке. stale-while-revalidate и stale-if-error включают мягкую деградацию.

http
# Response directives (server -> cache)
Cache-Control: public, max-age=3600           # cacheable by all, fresh 1h
Cache-Control: private, max-age=600           # browser only, fresh 10min
Cache-Control: no-cache                       # revalidate before use
Cache-Control: no-store                       # never cache (sensitive data)
Cache-Control: must-revalidate                # never serve stale
Cache-Control: proxy-revalidate               # proxies must revalidate
Cache-Control: immutable                      # URL never changes
Cache-Control: max-age=0, must-revalidate     # always revalidate
Cache-Control: s-maxage=3600, max-age=600     # CDN caches 1h, browser 10min

# Request directives (client -> cache)
Cache-Control: no-cache                       # send request to origin
Cache-Control: no-store                       # don't store the response
Cache-Control: only-if-cached                 # only from cache

ETag и If-None-Match

ETag — непрозрачный тег версии (часто хеш содержимого), прикреплённый к ответу. В следующем запросе клиент отправляет If-None-Match с сохранённым ETag. Если ресурс не изменился, сервер возвращает 304 Not Modified без тела, экономя трафик. Сильные ETag гарантируют побайтово идентичное содержимое; слабые (W/) допускают семантически эквивалентные ответы (например, различия в пробелах).

http
# Server tags a response with an ETag
HTTP/1.1 200 OK
ETag: "abc123"
Content-Type: application/json

{"data": "..."}

# Client sends conditional request on next fetch
GET /api/data HTTP/1.1
If-None-Match: "abc123"

# Server compares:
# - If matches: 304 Not Modified (no body)
HTTP/1.1 304 Not Modified
ETag: "abc123"

# - If changed: 200 OK with new body + new ETag
HTTP/1.1 200 OK
ETag: "def456"

# Strong vs weak ETags:
# "abc123"      - strong (byte-identical)
# W/"abc123"    - weak (semantically equivalent)

Last-Modified и If-Modified-Since

Last-Modified — валидатор на основе времени. У него точность 1 секунда, поэтому изменения внутри секунды можно пропустить. If-Modified-Since даёт 304, если ресурс не изменился. If-Unmodified-Since защищает от потерянных обновлений: если другой клиент изменил ресурс, сервер вернёт 412 Precondition Failed. При наличии ETag предпочтительнее он (точнее), но Last-Modified — полезный запасной вариант.

http
# Server includes Last-Modified
HTTP/1.1 200 OK
Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT

# Client sends conditional request
GET /api/data HTTP/1.1
If-Modified-Since: Wed, 21 Oct 2023 07:28:00 GMT

# Server: if not modified since that time -> 304
HTTP/1.1 304 Not Modified

# Server: if modified since -> 200 with new content
HTTP/1.1 200 OK
Last-Modified: Thu, 22 Oct 2023 09:00:00 GMT

# If-Unmodified-Since (for safe updates - optimistic locking)
PUT /api/users/42 HTTP/1.1
If-Unmodified-Since: Wed, 21 Oct 2023 07:28:00 GMT
# 412 Precondition Failed if modified elsewhere

Поток валидации кеша

Поток кеша: свежий (в пределах max-age) — отдаётся из кеша без сети. Устаревший (после max-age) — условный запрос с валидаторами. 304 обновляет таймер кеша без повторной загрузки тела. 200 заменяет запись в кеше. Это резко снижает трафик и нагрузку на origin. Для данных, которые часто меняются, но допускают небольшую устарелость, используйте stale-while-revalidate.

http
# 1. First request - server sends validators
GET /api/users HTTP/1.1

HTTP/1.1 200 OK
Cache-Control: max-age=60
ETag: "v1"
Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT

# 2. Within max-age (60s): cache serves directly, no network
GET /api/users  (served from cache)

# 3. After max-age: stale - revalidate (conditional GET)
GET /api/users HTTP/1.1
If-None-Match: "v1"
If-Modified-Since: Wed, 21 Oct 2023 07:28:00 GMT

# 4a. Unchanged -> 304 (revalidate resets the cache timer)
HTTP/1.1 304 Not Modified
Cache-Control: max-age=60
ETag: "v1"

# 4b. Changed -> 200 with new body
HTTP/1.1 200 OK
Cache-Control: max-age=60
ETag: "v2"

Сброс и инвалидация кеша

Сброс кеша: давайте неизменяемым ресурсам (JS, CSS, изображения) версионированные URL (app.v1a2b3c.js) и кешируйте их на год с immutable. При деплое URL меняется — браузеры скачивают новый файл. HTML-точка входа использует no-cache, чтобы пользователи всегда ревалидировали и получали новые URL ресурсов. Такой паттерн даёт и мгновенные обновления, и долгий кеш. Избегайте версионирования через query-строку (?v=123): некоторые прокси его не кешируют.

http
# Immutable assets with long cache + versioned URLs
GET /assets/app.v1a2b3c.js HTTP/1.1
HTTP/1.1 200 OK
Cache-Control: public, max-age=31536000, immutable

# When deploying a new version, the URL changes:
GET /assets/app.v4d5e6f.js HTTP/1.1
# (browser fetches new file; old one stays cached but unused)

# HTML entry point: short cache, must revalidate
GET /index.html HTTP/1.1
HTTP/1.1 200 OK
Cache-Control: no-cache
# (revalidate every time, but 304 if unchanged)

# Anti-pattern: caching HTML forever (users see stale entry)
# Anti-pattern: querying JS with ?ts=123 (defeats CDN caching)

# Manual cache purge via CDN API (vendor-specific)
10

CORS (межсайтовые запросы)

Same-Origin Policy и CORS

Same-Origin Policy (SOP) — модель безопасности браузера, по умолчанию запрещающая страницам читать межсайтовые ответы. CORS — способ это разрешить: сервер объявляет, какие origin могут читать его ответы. Origin определяется схемой+хостом+портом: различие в любом из них делает запрос межсайтовым. CORS важен только для запросов из браузера; вызовы между серверами не ограничены.

http
# Same-Origin Policy (SOP): browsers block cross-origin reads by default
# Origin = scheme + host + port
# https://app.com  vs  https://api.com  -> DIFFERENT origins
# http://app.com   vs  https://app.com  -> DIFFERENT (scheme)
# https://app.com  vs  https://app.com:8443 -> DIFFERENT (port)

# CORS lets a server OPT IN to cross-origin requests
# via Access-Control-Allow-Origin response header.

# Simple cross-origin GET (no preflight)
GET /api/data HTTP/1.1
Host: api.example.com
Origin: https://app.example.com

# Server allows the origin
HTTP/1.1 200 OK
Access-Control-Allow-Origin: https://app.example.com

Простые запросы (без preflight)

Простые запросы минуют preflight и идут прямо на сервер. Ограничения консервативны: только GET/HEAD/POST, только безопасные заголовки и только простые Content-Type. Любое отклонение (например, Content-Type: application/json, свои заголовки, PUT/DELETE) делает запрос «непростым» и вызывает preflight. Сервер всё равно должен вернуть CORS-заголовки, иначе браузер заблокирует чтение.

http
# A "simple" request is sent directly (no preflight):
# - Method: GET, HEAD, or POST
# - Only CORS-safelisted headers:
#     Accept, Accept-Language, Content-Language, Content-Type
# - Content-Type limited to:
#     application/x-www-form-urlencoded
#     multipart/form-data
#     text/plain
# - No event listeners on upload
# - No ReadableStream

# Example: simple cross-origin POST form submit
POST /api/login HTTP/1.1
Host: api.example.com
Origin: https://app.example.com
Content-Type: application/x-www-form-urlencoded

user=alice&pass=secret

# Server must respond with Allow-Origin for browser to expose response

Preflight-запросы (OPTIONS)

Preflight — это OPTIONS, который браузер отправляет перед непростым межсайтовым запросом. Он проверяет, разрешены ли фактический метод и заголовки. Сервер отвечает Allow-Methods и Allow-Headers. Access-Control-Max-Age кеширует результат preflight (по умолчанию 5 с, браузеры ограничивают 24 ч). Preflight добавляет задержку — избегайте его на горячих путях, по возможности оставаясь в простых запросах.

http
# Browser sends preflight OPTIONS before non-simple requests
OPTIONS /api/data HTTP/1.1
Host: api.example.com
Origin: https://app.example.com
Access-Control-Request-Method: PUT
Access-Control-Request-Headers: Content-Type, Authorization

# Server preflight response
HTTP/1.1 204 No Content
Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Max-Age: 86400  # cache preflight for 24h

# Only then does the browser send the actual request
PUT /api/data HTTP/1.1
Host: api.example.com
Origin: https://app.example.com
Content-Type: application/json
Authorization: Bearer ...

{"key": "value"}

CORS с учётными данными

По умолчанию межсайтовые fetch не отправляют cookie. Чтобы их включить, клиент задаёт credentials: 'include'. Сервер должен ответить Access-Control-Allow-Credentials: true И указать конкретный origin (не шаблон *). Всегда добавляйте Vary: Origin, чтобы кеши не отдавали ответ, согласованный для одного origin, другому. Неверно настроенный CORS+credentials — дыра в безопасности: ограничивайте origin известным белым списком.

http
# Client: opt in to sending cookies/auth
fetch('https://api.example.com/data', {
  credentials: 'include'   # send cookies cross-origin
});

# Browser sends:
GET /data HTTP/1.1
Origin: https://app.example.com
Cookie: session=abc123

# Server response MUST:
# 1. Echo the SPECIFIC origin (NOT *)
# 2. Set Allow-Credentials: true
HTTP/1.1 200 OK
Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Credentials: true
Vary: Origin   # important: caches must vary by Origin

# Wildcard origin + credentials = browser blocks response
# (Access-Control-Allow-Origin: * with credentials fails)

Частые ошибки CORS

Ошибки CORS видны в консоли браузера. Самые частые: отсутствует Allow-Origin (сервер не разрешил), шаблон вместе с credentials (запрещённая комбинация), нет Allow-Headers/Methods в ответе на preflight. CORS применяет браузер, а не сервер: запрос всё равно доходит до сервера, но браузер скрывает ответ от JS. Смотрите вкладку Network: если OPTIONS-preflight провалился, фактический запрос не отправляется.

http
# Error: No 'Access-Control-Allow-Origin' header
# Cause: server didn't send CORS header, or origin not allowed
# Fix: add Access-Control-Allow-Origin on the server

# Error: Credentials flag is true, but Allow-Origin is *
# Cause: wildcard not allowed with credentials
# Fix: echo the specific request Origin instead of *

# Error: preflight missing Allow-Methods / Allow-Headers
# Cause: server didn't allow the method/header
# Fix: add them to Access-Control-Allow-Methods/Headers

# Error: Allow-Origin doesn't match Origin
# Cause: server echoed a different origin (or scheme mismatch)
# Fix: dynamically echo req.headers.origin if allowlisted

# Debug:
# - Check browser DevTools Console for exact error
# - Check Network tab -> see the OPTIONS preflight response
# - Verify headers in the response
11

HTTPS и SSL/TLS

Рукопожатие TLS (HTTPS)

HTTPS оборачивает HTTP в шифрование TLS. Рукопожатие TLS аутентифицирует сервер (сертификат), согласует шифрование и обменивается ключами. TLS 1.2 занимает 2 round trip; TLS 1.3 — 1 (или 0 при возобновлении). SNI (Server Name Indication) передаёт целевое имя хоста открыто, чтобы сервер выбрал верный сертификат, — это раскрывает хост eavesdropper'ам; ECH (Encrypted Client Hello) его шифрует.

http
# HTTPS = HTTP over TLS
# 1. TCP connection (port 443)
# 2. TLS handshake:
ClientHello -> server
  - supported TLS versions, cipher suites, extensions
  - SNI: hostname (example.com)
ServerHello + Certificate + ServerHelloDone <- server
  - selected cipher, certificate (public key)
ClientKeyExchange + ChangeCipherSpec -> server
  - encrypted pre-master secret (RSA) or ECDHE params
ChangeCipherSpec + Finished <- server
# 3. Encrypted HTTP exchange begins
GET /page HTTP/1.1
Host: example.com

# TLS 1.3 collapses this to 1 round trip (1-RTT)
# 0-RTT resumption for returning connections

HTTPS-соединение

HTTPS — это HTTP поверх TLS, обычно на порту 443. Сами HTTP-сообщения не меняются: TLS шифрует нижележащий TCP-трафик. Чтобы принудить HTTPS, перенаправляйте HTTP→HTTPS (301) и задайте заголовок HSTS, чтобы браузеры запоминали использование HTTPS на указанный срок. Списки HSTS preload (поддерживаемые браузерами) жёстко закрепляют это поведение, так что даже первый запрос идёт по HTTPS.

http
# HTTP on port 80 (plaintext)
GET /page HTTP/1.1
Host: example.com

# HTTPS on port 443 (TLS-encrypted)
# Same HTTP messages, but the wire traffic is encrypted.
GET /page HTTP/1.1
Host: example.com

# Force HTTPS via redirect
HTTP/1.1 301 Moved Permanently
Location: https://example.com/page

# Force HTTPS via HSTS (browser remembers)
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload

# Modern browsers default to https:// for bare domains
# (some even refuse plain HTTP for sensitive endpoints)

Сертификаты

Сертификаты X.509 связывают публичный ключ с доменом и подписаны удостоверяющим центром (CA). Цепочка доверия идёт от сертификата сервера через промежуточные к корневому CA, предустановленному в браузере. Браузеры проверяют цепочку, срок действия и соответствие SAN (Subject Alternative Name) запрошенному хосту. Wildcard-сертификаты (*.example.com) и мультидоменные (несколько SAN) покрывают несколько имён.

http
# X.509 certificate contains:
# - Subject: example.com (CN is deprecated; use SAN)
# - Subject Alternative Name (SAN): example.com, www.example.com
# - Issuer: Let's Encrypt / DigiCert (CA)
# - Validity: Not Before / Not After
# - Public key (RSA or ECDSA)
# - Signature by CA

# Chain of trust:
# Root CA (self-signed, in browser trust store)
#   -> Intermediate CA
#     -> Server cert (your domain)

# Server sends leaf + intermediate during handshake.
# Browser verifies: signature chain back to a trusted root.

# Inspect a cert:
openssl s_client -connect example.com:443 -showcerts
openssl x509 -in cert.pem -text -noout

HSTS (HTTP Strict Transport Security)

HSTS велит браузерам всегда использовать HTTPS для домена, предотвращая SSL-stripping. max-age задаётся в секундах (1 год = 31536000). includeSubDomains распространяет на все поддомены. preload отправляет домен в жёстко зашитый список браузера, так что даже первый визит идёт по HTTPS — сильная защита, но трудно отменяемая (удаление занимает месяцы). Сначала настройте редирект HTTP→HTTPS, затем добавьте HSTS, затем при желании preload.

http
# Tell browser to use HTTPS for 6 months
Strict-Transport-Security: max-age=15768000

# Include subdomains
Strict-Transport-Security: max-age=15768000; includeSubDomains

# Submit to preload list (browsers hardcode the domain)
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload

# Effects:
# - http://example.com -> browser rewrites to https://
# - Self-signed cert -> browser blocks (no override)
# - prevents SSL stripping attacks (downgrade to HTTP)

# Preload list: https://hstspreload.org
# Once preloaded, removal is slow and difficult.

Версии TLS и шифры

Отключите SSLv2/v3 и TLS 1.0/1.1: у них известные уязвимости (POODLE, BEAST). TLS 1.3 (2018) — современный стандарт: быстрее рукопожатие, убраны слабые шифры, обязательна прямая секретность. TLS 1.2 с ECDHE + AES-GCM допустим. Проверяйте конфигурацию инструментами вроде SSL Labs. Прямая секретность (ECDHE) гарантирует, что прошлый трафик останется зашифрованным, даже если приватный ключ утечёт позже.

http
# TLS versions (deprecate old ones!)
# SSLv2, SSLv3  - BROKEN (POODLE), disable
# TLS 1.0, 1.1  - deprecated (2020), disable
# TLS 1.2       - widely supported, OK
# TLS 1.3       - fastest, most secure (preferred)

# Modern cipher suites (TLS 1.3):
# TLS_AES_256_GCM_SHA384
# TLS_CHACHA20_POLY1305_SHA256
# TLS_AES_128_GCM_SHA256

# TLS 1.2 recommended:
# ECDHE-ECDSA-AES256-GCM-SHA384 (forward secrecy + AEAD)
# ECDHE-RSA-AES256-GCM-SHA384

# Server config (nginx example)
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers off;
ssl_ciphers ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;

# Test: https://www.ssllabs.com/ssltest/
12

HTTP/2

Возможности HTTP/2

HTTP/2 сохраняет семантику HTTP (методы, коды, заголовки), но меняет формат передачи на бинарные фреймы. Главные плюсы: мультиплексирование множества запросов по одному TCP-соединению (без блокировки начала очереди на уровне HTTP), сжатие заголовков HPACK и приоритизация потоков. Согласуется через ALPN поверх TLS (чаще всего) или h2c upgrade в открытом виде. Server Push устарел в 2022 из-за плохой реальной производительности.

http
# HTTP/2 (RFC 9113, 2015) - binary, multiplexed
# - Binary framing (not text)
# - Multiplexing: many streams over 1 TCP connection
# - Header compression (HPACK)
# - Server Push (deprecated in 2022)
# - Stream prioritization
# - Single connection per origin

# Negotiation:
# - Over TLS: ALPN extension advertises "h2"
# - Over plaintext: h2c upgrade (rare in practice)

#curl with HTTP/2:
curl -v --http2 https://example.com
# (Connection header shows HTTP/2)

# Backward compatible: same methods, status codes, headers, semantics
# Only the wire format changes.

Мультиплексирование

Мультиплексирование — главная фича HTTP/2. Многие потоки делят одно TCP-соединение, фреймы перемежаются: больше нет лимита в 6 соединений на origin и блокировки начала очереди на уровне HTTP. Это устраняет хаки HTTP/1.1 вроде domain sharding, склейки файлов и встраивания изображений. Учтите: блокировка начала очереди на уровне TCP остаётся (потерянный пакет тормозит все потоки до повторной передачи) — именно это исправляет HTTP/3 через QUIC.

http
# HTTP/1.1: 6 parallel connections per origin, each request blocks its connection
# (head-of-line blocking at the HTTP level)

# HTTP/2: 1 connection, many parallel streams
# Each request/response is a stream with a unique ID.

# Frames carry data for multiple streams interleaved:
# Stream 1: HEADERS, DATA (request 1)
# Stream 3: HEADERS, DATA (request 2)
# Stream 5: HEADERS, DATA (request 3)
# Server responds with interleaved frames on each stream.

# Browser opens one TCP+TLS connection per origin,
# then sends all requests as concurrent streams.

# Eliminates: domain sharding, concatenation, inlining
# (those were HTTP/1.1 optimization hacks)

Server Push (устарел)

Server Push позволял серверу отправить ресурсы до запроса клиента. Теоретически это экономит round trip для критичных ресурсов. На практике механизм устарел в 2022: сервер не знает состояние кеша клиента, поэтому пушит лишнее и часто тратит трафик. Браузеры теперь игнорируют кадры PUSH_PROMISE. Современные альтернативы: <link rel=preload> в HTML или 103 Early Hints (сервер отправляет подсказки о предзагрузке до финального ответа).

http
# Server proactively sends resources the client will need
GET /index.html HTTP/2
Host: example.com

HTTP/2 200 OK
Content-Type: text/html
Link: </style.css>; rel=preload; as=style

# Server then pushes style.css on a new stream
PUSH_PROMISE (stream 2, /style.css)
<headers + body of /style.css>

# Then the actual /index.html body follows.

# DEPRECATED (2022): browsers ignore it because:
# - Client cache might already have the asset
# - Server can't know what client has cached
# - Net performance negative in real deployments

# Modern alternative: <link rel="preload" href="...">
# or 103 Early Hints

Приоритизация потоков

HTTP/2 позволял клиентам задавать приоритет потоков деревом зависимостей с весами. Сервер использовал это для распределения полосы: например, CSS раньше изображений. RFC 9113 (2022) убрал явный кадр PRIORITY, оставив планирование серверу — многие реализовали своё. Extensible Prioritization Scheme (RFC 9218) — необязательная современная альтернатива. Приоритизация важнее всего на медленных соединениях.

http
# HTTP/2 streams have priority (weight + dependency tree)
# Originally: client sends PRIORITY frames
# Client says: "CSS (stream 3) is more important than image (stream 5)"

# PRIORITY frame (original model):
# - stream dependency (parent)
# - weight (1-256)

# RFC 9113 (2022) removed explicit prioritization
# - Leaves it to the server
# - Many servers implement their own scheduler

# Practical effect: server allocates bandwidth
# - HTML, CSS, JS -> high priority
# - Images, fonts -> lower priority
# - Critical render path optimized

# Clients can still signal via Extensible Prioritization Scheme
# (RFC 9218) - optional.

Сжатие заголовков HPACK

HPACK сжимает HTTP-заголовки через статическую таблицу частых заголовков, динамическую таблицу на соединение, запоминающую недавние значения, и кодирование Хаффмана. Это резко снижает накладные расходы: cookie в 1 КБ в каждом запросе превращается в крошечную индексированную ссылку. HPACK специально спроектирован, чтобы избежать атак на оракул сжатия CRIME/BREACH, мучивших раннее сжатие TLS. HTTP/3 использует похожую схему QPACK.

http
# HTTP/1.1: headers sent as plaintext on every request (redundant)
# Cookies alone can exceed 1KB per request.

# HTTP/2: HPACK compresses headers
# - Static table: 61 common headers (e.g., :method GET)
# - Dynamic table: per-connection, learns recently sent headers
# - Huffman coding for strings

# Example: first request sends full User-Agent (200 bytes)
# Subsequent requests reference the dynamic table entry (2 bytes)

# Indexed header representation:
# 1 bit set + index -> "use entry N"

# Literal with incremental indexing:
# "add this to the dynamic table for future reuse"

# Security: CRIME attack exploited compression oracles.
# HPACK mitigates by never compressing sensitive + attacker-controlled
# data together.
13

HTTP/3 и QUIC

Протокол QUIC

QUIC — транспортный протокол поверх UDP, объединяющий TLS 1.3 и дающий надёжные мультиплексированные потоки. Переход на UDP позволяет QUIC развиваться быстрее, чем TCP в ядре. Главные преимущества: нет блокировки начала очереди на уровне TCP (потеря пакета тормозит только один поток), 0-RTT возобновление для повторных подключений и миграция соединения (телефон, переключающийся с Wi-Fi на сотовую сеть, сохраняет соединение). HTTP/3 работает поверх QUIC.

http
# QUIC = Quick UDP Internet Connections (Google, then IETF)
# - Transport protocol over UDP (not TCP)
# - Built-in TLS 1.3 encryption
# - Multiple streams, independent per-stream delivery
# - 0-RTT connection resumption
# - Connection migration (survives IP changes)
# - Better loss recovery than TCP

# Why UDP? TCP is in the kernel and hard to evolve.
# QUIC moves reliability + congestion control to user space.

# Wire format: UDP packets containing QUIC packets
# - Initial, Handshake, 1-RTT, 0-RTT packets
# - Frames carry stream data, acks, flow control

# Negotiation:
# Server advertises HTTP/3 via Alt-Svc header on HTTP/2 response:
Alt-Svc: h3=":443"; ma=86400
# Browser caches this and uses HTTP/3 next time.

Возможности HTTP/3

HTTP/3 сохраняет семантику HTTP, но работает поверх QUIC вместо TCP. Главный выигрыш — отсутствие блокировки начала очереди. В HTTP/2 один потерянный TCP-пакет останавливает все мультиплексированные потоки до повторной передачи; в HTTP/3 ждёт только затронутый поток. Плюс 0-RTT возобновление и миграция соединения. Цена — больше CPU (QUIC в пользовательском пространстве) и иногда блокировки/ограничения UDP в сетях. Распространение растёт: большинство крупных сайтов его поддерживают.

http
# HTTP/3 (RFC 9114, 2022) - HTTP semantics over QUIC
# Same methods, status codes, headers as HTTP/2
# - Binary framing (similar to HTTP/2)
# - Multiplexing over QUIC streams (no HoL blocking!)
# - QPACK header compression (HPACK variant)
# - 0-RTT for returning clients
# - Connection migration

# Loss recovery: per-stream, not per-connection
# A lost packet stalls only that stream, others continue.

# Head-of-line blocking eliminated at the transport layer:
# HTTP/2: lost TCP packet blocks ALL streams (kernel retransmit)
# HTTP/3: lost QUIC packet blocks only that stream

# curl with HTTP/3 (requires special build):
curl -v --http3 https://example.com

0-RTT возобновление соединения

0-RTT позволяет повторным клиентам отправить данные в первом полёте (без round trip до запроса). Это экономит от десятков до сотен миллисекунд при повторных визитах. Подвох: ранние данные могут быть воспроизведены атакующим, поэтому их следует ограничивать идемпотентными операциями (GET, HEAD, PUT/DELETE, если идемпотентны). Серверы должны отклонять 0-RTT для POST и других изменяющих методов. Механизмы защиты от воспроизведения добавляют сложность.

http
# TLS 1.3 + QUIC: 0-RTT resumption for returning clients
# First visit: full handshake (1-RTT in TLS 1.3)
Client -> Server: ClientHello + key share
Server -> Client: ServerHello + key share + Finished
Client -> Server: Finished + first HTTP request

# Returning visit (0-RTT):
Client -> Server: ClientHello + early data (HTTP request)
# Server can respond immediately, no round trip!

# Trade-offs:
# + Saves 1 RTT on subsequent visits (faster page loads)
# - Vulnerable to replay attacks on early data
# - Only safe for idempotent methods (GET, HEAD)
# - Server should reject 0-RTT for non-idempotent requests

# Configure carefully:
# - Limit early data to safe methods
# - Use anti-replay mechanisms

Миграция соединения

Соединения QUIC идентифицируются connection ID, а не 4-кортежем IP/порт. Поэтому соединение переживает смену IP: телефон, переходящий с Wi-Fi на сотовую сеть, или ноутбук, меняющий сеть, сохраняет соединение. Сервер проверяет новый путь через PATH_CHALLENGE/PATH_RESPONSE. TCP так не умеет, потому что ядро идентифицирует соединения по 4-кортежу. Большой плюс для мобильных.

http
# TCP connection identified by 4-tuple:
# (src IP, src port, dst IP, dst port)
# If your phone switches Wi-Fi -> cellular, IP changes ->
# the TCP connection dies. Browser must reconnect.

# QUIC uses a connection ID (random, in every packet).
# The 4-tuple can change mid-connection; the connection ID
# identifies the connection.

# Scenario:
# 1. Phone on Wi-Fi, downloading a large file over HTTP/3
# 2. Phone walks out, switches to cellular
# 3. Packets now arrive from a new IP, same connection ID
# 4. Server continues serving the same connection!
# 5. No reconnect, no re-handshake, no failed download.

# Validation: server sends PATH_CHALLENGE, client replies PATH_RESPONSE.

HTTP/1.1 против HTTP/2 против HTTP/3

HTTP/1.1 — текст поверх TCP с 6 параллельными соединениями. HTTP/2 — бинарный поверх TCP с мультиплексированием (но с блокировкой начала очереди на уровне TCP). HTTP/3 — бинарный поверх QUIC без такой блокировки, с обязательным шифрованием, 0-RTT и миграцией соединения. Внедрение постепенное: серверы объявляют HTTP/3 через заголовок Alt-Svc в ответах HTTP/2, а браузеры обновляются при следующем визите. Все три разделяют семантику HTTP.

http
# Feature comparison
# Property         | HTTP/1.1     | HTTP/2       | HTTP/3
# -----------------+--------------+--------------+--------------
# Transport        | TCP          | TCP          | QUIC (UDP)
# Format           | Text         | Binary       | Binary
# Multiplexing     | No (6 conns) | Yes          | Yes
# HoL blocking     | HTTP-level   | TCP-level    | None
# Header compress  | No           | HPACK        | QPACK
# Server Push      | No           | Yes (deprecated) | No
# Encryption       | Optional     | Optional     | Mandatory (TLS 1.3)
# 0-RTT            | No           | No           | Yes
# Connection migration | No       | No           | Yes
# Handshake RTT    | 1+           | 1+           | 0-1 (with resumption)

# Most sites today: HTTP/2 over TLS, with HTTP/3 available via Alt-Svc
14

Перенаправления (3xx)

301 против 302

301 означает постоянно: браузеры кешируют редирект, закладки обновляются, SEO-вес переходит на новый URL. 302 означает временно: ничего не кешируется, SEO остаётся у оригинала. Исторически оба преобразовывали POST→GET (нарушение спецификации, ставшее де-факто). Чтобы строго сохранить метод, используйте 307 (временно) или 308 (постоянно). Для SEO-миграций используйте 301; для редиректов после входа — 302 или 307.

http
# 301 Moved Permanently
HTTP/1.1 301 Moved Permanently
Location: https://newsite.com/page
# - Permanent; browser & SEO caches it
# - Link juice transfers to new URL (SEO)
# - Bookmark updates
# - HTTP/1.1 spec: should preserve method, but historically
#   POST -> GET (causing data loss)

# 302 Found
HTTP/1.1 302 Found
Location: /login
# - Temporary
# - Don't update bookmarks
# - SEO link juice stays with original URL
# - HTTP/1.1 spec: should preserve method, but historically
#   POST -> GET

# Use 301 for permanent moves (site migrations).
# Use 302 for temporary redirects (login flows, A/B tests).

307 против 308

307 и 308 — сохраняющие метод аналоги 302 и 301. Они исправляют историческую ошибку преобразования POST→GET. 307 временный, 308 постоянный: оба сохраняют исходный метод и тело. Используйте их при редиректах не-GET запросов, особенно в API, где преобразование POST→GET молча потеряло бы тело. 308 — современный выбор для постоянного переноса endpoint API.

http
# 307 Temporary Redirect (HTTP/1.1, method-preserving)
HTTP/1.1 307 Temporary Redirect
Location: /new-endpoint
# - Temporary
# - Method PRESERVED: POST stays POST, body stays intact
# - Browser prompts before re-issuing POST to different host

# 308 Permanent Redirect (RFC 7538)
HTTP/1.1 308 Permanent Redirect
Location: https://newsite.com/api
# - Permanent
# - Method PRESERVED
# - Like 301 but without the POST->GET conversion

# When to use:
# - 307: temporary redirect that must preserve method
# - 308: permanent redirect that must preserve method
#   (e.g., API endpoint moved, clients still POSTing)

# Most browsers support both since ~2015.

303 See Other (паттерн PRG)

303 See Other явно говорит браузеру перейти далее GET-запросом — правильный инструмент для Post/Redirect/Get (PRG). После обработки POST перенаправляйте через 303 на GET-страницу. Если пользователь обновит страницу, он повторит безопасный GET, а не POST, избегая дублирующей отправки формы. 303 для PRG, 307/308 для сохранения метода, 301/302 для обычной навигации.

http
# 303 See Other - explicitly converts to GET
HTTP/1.1 303 See Other
Location: /success
# - Always converts to GET (no body)
# - Used in Post/Redirect/Get (PRG) pattern

# PRG pattern: avoid double-submit on refresh
# 1. User submits form
POST /checkout HTTP/1.1
Host: shop.com
Content-Type: application/x-www-form-urlencoded

item=book&qty=1

# 2. Server processes, redirects to a GET page
HTTP/1.1 303 See Other
Location: /order/123/confirmation

# 3. Browser issues GET (safe to refresh)
GET /order/123/confirmation HTTP/1.1
Host: shop.com

HTTP/1.1 200 OK
# "Order confirmed!"

Цепочки и циклы редиректов

Цепочки редиректов добавляют задержку (каждый переход — round trip), их нужно сокращать: направляйте исходный URL сразу на финальный адрес. Циклы редиректов фатальны: браузеры обнаруживают их через несколько шагов и показывают ошибку. Частые причины: неверная настройка HTTPS↔HTTP за балансировщиком (используйте X-Forwarded-Proto) или конфликты завершающего слэша. HSTS избавляет от циклов HTTP→HTTPS: браузер переписывает адрес внутренне.

http
# Redirect chain: A -> B -> C
GET /a  -> 301 -> /b
GET /b  -> 301 -> /c
GET /c  -> 200 OK

# Each hop adds a round trip; chains hurt performance.
# Browsers cap redirects (typically 20), then error.

# Redirect loop (fatal):
GET /a -> 302 -> /b
GET /b -> 302 -> /a
GET /a -> 302 -> /b  (browser detects loop, shows error)

# Common cause: HTTPS <-> HTTP loop
# Server A redirects HTTP -> HTTPS
# Server B (behind TLS terminator) sees HTTP internally,
# redirects to HTTPS again -> loop

# Fix: trust X-Forwarded-Proto, or use HSTS instead of redirects

# Common cause: trailing slash mismatch
# /api/users -> 301 -> /api/users/ -> 301 -> /api/users/
# (server config bug)

Частые случаи редиректов

Частые случаи: HTTP→HTTPS (301), apex↔www (301), миграции старый→новый URL (301), редиректы после входа (302/303), паттерн PRG (303), перенос endpoint API (308) и запасные варианты origin у CDN. Для постоянных переносов всегда предпочитайте 301/308, чтобы кеши и SEO обновлялись. Где возможно, используйте HSTS вместо редиректов HTTP→HTTPS: он избавляет от round trip редиректа при последующих визитах.

http
# 1. HTTP -> HTTPS upgrade
HTTP/1.1 301 Moved Permanently
Location: https://example.com/

# 2. www -> apex (or vice versa)
HTTP/1.1 301 Moved Permanently
Location: https://example.com/

# 3. Old URL -> new URL (site migration)
HTTP/1.1 301 Moved Permanently
Location: https://example.com/new-page

# 4. Login required (temporary)
HTTP/1.1 302 Found
Location: /login?return=/dashboard

# 5. POST form -> confirmation (PRG)
HTTP/1.1 303 See Other
Location: /success

# 6. API endpoint moved (preserve method)
HTTP/1.1 308 Permanent Redirect
Location: /v2/users

# 7. CDN origin fallback (when content not cached)
HTTP/1.1 302 Found
Location: https://origin.example.com/asset
15

Типы содержимого (MIME)

Частые MIME-типы

MIME-типы (медиатипы) описывают формат тела. Они состоят из type/subtype и необязательных параметров (charset, boundary). Частые типы: text/html для страниц, application/json для API, image/* и video/* для медиа. application/octet-stream — запасной для неизвестных бинарных данных: браузеры скачивают, а не пытаются отрисовать. Официальный реестр ведёт IANA.

http
# Text
text/html                    # HTML pages
text/plain                   # plain text
text/css                     # stylesheets
text/csv                     # comma-separated values
text/javascript              # JavaScript (legacy, was application/javascript)

# Application
application/json             # JSON
application/xml              # XML
application/javascript       # JavaScript (modern, text/javascript also OK)
application/pdf              # PDF
application/zip              # ZIP archive
application/octet-stream     # binary (unknown type, forces download)
application/x-www-form-urlencoded  # form data
application/ld+json          # JSON-LD (linked data)

# Image
image/jpeg, image/png, image/gif, image/webp, image/svg+xml, image/avif

# Audio/Video
audio/mpeg, audio/ogg, video/mp4, video/webm

# Multipart
multipart/form-data          # file uploads
multipart/byteranges         # partial content

Заголовок Content-Type

Заголовок Content-Type объявляет MIME-тип тела. Для текстовых типов charset задаёт кодировку (по умолчанию для text/* — ISO-8859-1; всегда явно указывайте UTF-8). Для multipart-тел boundary разделяет части. Браузеры могут «определять» тип, если он отсутствует или расплывчат, — предотвращайте это через X-Content-Type-Options: nosniff, который заставляет следовать объявленному типу (защита от XSS через загрузку файлов).

http
# Response Content-Type
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8

# Request Content-Type (for bodies)
POST /api/users HTTP/1.1
Content-Type: application/json

{"name": "Alice"}

# charset parameter (text types)
Content-Type: text/html; charset=UTF-8

# boundary parameter (multipart)
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary

# X-Content-Type-Options: nosniff
# tells browser not to sniff/override the declared type

multipart/form-data

multipart/form-data кодирует несколько частей (поля и файлы) в одном теле, разделённых boundary. У каждой части свои Content-Disposition (с необязательным filename) и Content-Type. Это формат, который используют браузеры при отправке форм с файлами. Это единственный практичный способ загрузки файлов через HTML-формы, хотя для API часто проще base64 в JSON или прямая отправка PUT на URL хранилища.

http
# File upload form
POST /upload HTTP/1.1
Content-Type: multipart/form-data; boundary=----boundary123

------boundary123
Content-Disposition: form-data; name="title"

My Photo
------boundary123
Content-Disposition: form-data; name="file"; filename="photo.jpg"
Content-Type: image/jpeg

<binary JPEG bytes>
------boundary123--

# Each part has its own headers (Content-Disposition, Content-Type).
# Final boundary has trailing --.
# Used for file uploads (browsers' <input type="file">).
# Less efficient than JSON for plain fields - overhead per part.

application/json

application/json — доминирующий формат API: лёгкий, читаемый и нативно поддерживается в любом языке. JSON по умолчанию UTF-8 (параметр charset избыточен, но безвреден). Вендорские медиатипы (application/vnd.api+json, application/vnd.github.v3+json) включают версионирование и согласование профилей. RFC 7807 (application/problem+json) стандартизирует ответы с ошибками.

http
# Most common API Content-Type
POST /api/users HTTP/1.1
Content-Type: application/json
Accept: application/json

{
  "name": "Alice",
  "age": 30,
  "tags": ["admin", "user"],
  "metadata": null
}

# Variants:
# application/json             - standard
# application/json; charset=utf-8  - JSON is UTF-8 by default, charset is redundant
# application/ld+json          - JSON-LD (linked data with @context)
# application/vnd.api+json     - JSON:API spec
# application/problem+json     - RFC 7807 problem details for errors

# Vendor types: application/vnd.company.v1+json
# (custom versioned JSON)

Параметр charset

Параметр charset объявляет кодировку текста. Всегда задавайте его для типов text/*: по умолчанию ISO-8859-1 даёт кракозябры для не-ASCII символов. UTF-8 — универсальный лучший выбор. Для JSON charset избыточен (JSON по спецификации UTF-8). Для XML спецификация по умолчанию UTF-8, но явное указание избавляет от накладных расходов на определение BOM. Несовпадение кодировок даёт мусорные символы.

http
# charset specifies the text encoding
Content-Type: text/html; charset=UTF-8      # preferred
Content-Type: text/html; charset=iso-8859-1 # legacy

# For JSON, charset is redundant (JSON spec mandates UTF-8)
Content-Type: application/json              # correct
Content-Type: application/json; charset=utf-8  # harmless but redundant

# Default charsets (when omitted):
# text/*                  -> ISO-8859-1 (legacy, problematic)
# application/json        -> UTF-8 (mandatory per spec)
# application/xml         -> UTF-8 (per XML spec)

# Always declare charset for text types to avoid mojibake.
# Mismatched charset = broken characters.

# In HTML, also declare in the document:
<meta charset="UTF-8">
16

Chunked-передача

Transfer-Encoding: chunked

Chunked transfer encoding позволяет серверу передавать тело потоком, не зная заранее общую длину. Каждый чанк предваряется длиной в hex, затем CRLF, данные и CRLF. Чанк нулевой длины сигнализирует конец. Это необходимо для динамически генерируемых ответов (рендеринг шаблонов, запросы к БД), где размер неизвестен до генерации данных. HTTP/2 и HTTP/3 не используют chunked: у них своя фрейминг.

http
# When the server doesn't know the final Content-Length
# (e.g., streaming, dynamically generated content),
# it sends the body in chunks.

HTTP/1.1 200 OK
Content-Type: text/plain
Transfer-Encoding: chunked

4

Wiki

6

pedia 

E

in chunks.

0




# Each chunk: <hex-length>
<data>

# Final chunk: 0
 (zero length)
# Then optional trailer headers + final 

Потоковые ответы

Потоковые ответы используют chunked-кодирование для инкрементальной отправки. Server-Sent Events (SSE) — канонический паттерн: сервер держит соединение открытым и пишет события как 'data: <payload>\n\n'. EventSource в браузере получает их по мере прихода. Другое применение: прогрессивный рендеринг HTML (сбрасывать по мере готовности), большие JSON-массивы, чтение логов. Убедитесь, что промежуточный прокси не буферизует ответ: для nginx задайте X-Accel-Buffering: no.

http
# Server-Sent Events (SSE): one-way streaming over HTTP
HTTP/1.1 200 OK
Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive
Transfer-Encoding: chunked

data: {"msg": "hello"}


data: {"msg": "world"}


data: {"msg": "done"}



# Each event: "data: <payload>

"
# Browser keeps the connection open via EventSource API.

# Other streaming patterns:
# - Server-side rendering: flush HTML as it's generated
# - Large JSON: stream array elements
# - Logs tailing: continuous chunk stream

# Don't buffer: set X-Accel-Buffering: no (nginx)

Trailer-заголовки

Trailer-заголовки отправляются после тела при chunked-кодировании. Они полезны для итоговой статистики, вычисляемой во время потока: число строк, контрольная сумма, длительность обработки. Заголовок Trailer объявляет, какие трейлеры будут. Некоторые заголовки запрещены как трейлеры (Host, Content-Length, Transfer-Encoding, заголовки аутентификации), так как влияют на фрейминг соединения. Поддержка клиентами неоднородна — многие трейлеры игнорируют.

http
# Trailer headers are sent AFTER the body (with chunked encoding)
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Trailer: X-Total-Count, X-Duration

5

{"a":1

5

,"b":2

0

X-Total-Count: 2

X-Duration: 0.045s




# Use case: compute summary stats during streaming
# (e.g., total count, checksum) and send at the end.

# The "Trailer" header declares which trailers to expect.
# Some headers are forbidden as trailers:
# - Transfer-Encoding, Content-Length, Host
# - Authentication-related headers

Content-Length против chunked

Content-Length заранее сообщает точный размер тела: просто, позволяет индикаторы прогресса и чисто переиспользовать соединение. Chunked позволяет передавать поток, не зная размера. Нужно использовать одно или другое (либо закрывать соединение в конце). Оба сразу — неоднозначно; по спецификации побеждает chunked, но старые клиенты могут сбоить. Для статических файлов всегда Content-Length; для динамики и потоков — chunked.

http
# Content-Length: known body size up front
HTTP/1.1 200 OK
Content-Type: text/plain
Content-Length: 11

Hello World

# Pros: simple, allows progress bars, enables persistent conn reuse
# Cons: requires knowing the size before sending

# Transfer-Encoding: chunked: stream without knowing size
HTTP/1.1 200 OK
Content-Type: text/plain
Transfer-Encoding: chunked

5
Hello

6
 World

0



# Pros: can stream as data is produced
# Cons: no progress bar, slightly more overhead per chunk

# Rule: you must use ONE of these (or close the connection).
# Using both is ambiguous - chunked wins per spec but is buggy in old clients.

Потоки в HTTP/2 (без chunked)

HTTP/2 и HTTP/3 не используют chunked-кодирование: у них свой бинарный фрейминг. Кадры DATA несут байты тела; флаг END_STREAM сигнализирует конец. Это даёт ту же потоковость без накладных расходов на шестнадцатеричную длину каждого чанка. Заголовок Transfer-Encoding в HTTP/2 запрещён (RFC 9113). Content-Length по-прежнему разрешён, но необязателен. Семантика потоков сохраняется, меняется только механизм передачи.

http
# HTTP/2 and HTTP/3 don't use Transfer-Encoding: chunked.
# They have their own framing: DATA frames carry body bytes,
# END_STREAM flag marks the end.

# In HTTP/2, "streaming" means sending multiple DATA frames
# on a single stream, with the END_STREAM flag on the last.

# Server push of partial response:
# HEADERS frame (status, headers)
# DATA frame (chunk 1)
# DATA frame (chunk 2)
# DATA frame + END_STREAM (chunk 3, final)

# Effect: same streaming behavior as chunked,
# but at the framing layer, not the encoding layer.

# Transfer-Encoding header is illegal in HTTP/2.
# Content-Length is allowed but optional.
17

Range-запросы

Заголовок Range

Range-запросы позволяют клиенту получить часть ресурса — необходимо для докачки, перемотки видео и параллельной загрузки частями. Заголовок Range задаёт диапазоны байт. Сервер отвечает 206 Partial Content и заголовком Content-Range о том, что вернул. Если сервер не поддерживает диапазоны, он игнорирует заголовок и возвращает 200 с полным телом. Всегда сначала проверяйте Accept-Ranges.

http
# Request a portion of a resource (e.g., resume downloads, video seeking)
GET /video.mp4 HTTP/1.1
Host: example.com
Range: bytes=0-1023        # first 1024 bytes

# Server response: 206 Partial Content
HTTP/1.1 206 Partial Content
Content-Range: bytes 0-1023/1048576
Content-Length: 1024
Content-Type: video/mp4

<1024 bytes of video>

# Range formats:
Range: bytes=0-1023        # bytes 0 through 1023
Range: bytes=1024-         # from byte 1024 to end
Range: bytes=-1024         # last 1024 bytes
Range: bytes=0-1023,2048-3071  # multiple ranges (multipart response)

Заголовок Accept-Ranges

Заголовок Accept-Ranges сообщает, поддерживает ли сервер range-запросы. bytes — да; none (или отсутствие) — нет. Клиенты должны проверить это до использования Range: сервер, игнорирующий Range, вернёт полное тело с 200. Браузеры применяют это автоматически для перемотки <video> (переход к метке времени = range-запрос) и докачки. Большинство CDN и статических серверов поддерживают диапазоны; динамические endpoint — часто нет.

http
# Server advertises range support
HTTP/1.1 200 OK
Accept-Ranges: bytes        # supports byte-range requests
Content-Length: 1048576

# Server doesn't support ranges
HTTP/1.1 200 OK
Accept-Ranges: none

# (or omit the header entirely - same as "none")

# Client checks before sending Range:
# 1. HEAD or GET request to inspect Accept-Ranges
# 2. If "bytes", send Range: bytes=...
# 3. If "none" or missing, expect 200 with full body

# Browsers handle this transparently for video/audio,
# resumable downloads, and PDF preview.

Ответ 206 Partial Content

206 Partial Content — ответ на успешный range-запрос. Content-Range показывает единицу (bytes), возвращённый диапазон и общий размер. Если запрошенный диапазон выходит за ресурс, сервер возвращает 416 Range Not Satisfiable. If-Range делает диапазон условным: если валидатор (ETag или дата) совпадает, вернуть 206; если ресурс изменился — 200 с полным телом, предотвращая частичное повреждение.

http
# Single range request
GET /file.bin HTTP/1.1
Range: bytes=100-199

# 206 Partial Content
HTTP/1.1 206 Partial Content
Content-Range: bytes 100-199/1024
Content-Length: 100
Content-Type: application/octet-stream

<100 bytes>

# Content-Range format: <unit> <start>-<end>/<total>
# total can be "*" if unknown (streaming)

# If range is out of bounds:
# Range: bytes=1000-2000 on a 500-byte file ->
HTTP/1.1 416 Range Not Satisfiable
Content-Range: bytes */500

# If-Range: only return range if validator still matches
GET /file.bin HTTP/1.1
Range: bytes=0-1023
If-Range: "etag123"
# If etag matches: 206 (partial)
# If etag differs: 200 (full body, resource changed)

Запросы нескольких диапазонов

Запросы нескольких диапазонов просят несколько диапазонов байт за один раз. Сервер отвечает multipart/byteranges: у каждой части свои Content-Type и Content-Range. На практике мультидиапазоны используются редко: клиенты обычно делают параллельные одиночные запросы (проще, дружелюбнее к кешу, легче восстановиться после ошибки). Некоторые серверы ограничивают число диапазонов или объединяют перекрывающиеся. Не полагайтесь на мультидиапазоны в критичных путях.

http
# Request multiple ranges in one request
GET /file.bin HTTP/1.1
Range: bytes=0-99,200-299,400-499

# Server responds with multipart/byteranges
HTTP/1.1 206 Partial Content
Content-Type: multipart/byteranges; boundary=THIS_STRING_SEPARATES

--THIS_STRING_SEPARATES
Content-Type: application/octet-stream
Content-Range: bytes 0-99/1024

<100 bytes>
--THIS_STRING_SEPARATES
Content-Type: application/octet-stream
Content-Range: bytes 200-299/1024

<100 bytes>
--THIS_STRING_SEPARATES
Content-Type: application/octet-stream
Content-Range: bytes 400-499/1024

<100 bytes>
--THIS_STRING_SEPARATES--

# Most clients use single-range; multi-range is rare in practice.

Применение Range

Range-запросы обеспечивают перемотку видео (переход к метке времени), докачку (продолжение после паузы), параллельную загрузку (менеджеры загрузок делят файл на части), предпросмотр страниц PDF и чтение метаданных в конце файла (ID3-теги). Во всех случаях сервер должен поддерживать диапазоны и объявлять это через Accept-Ranges: bytes. Без поддержки перемотка видео деградирует до полной загрузки, а докачка невозможна.

http
# 1. Video seeking (HTML5 <video>)
# Browser sends Range when user jumps to a timestamp
GET /video.mp4 HTTP/1.1
Range: bytes=5242880-    # seek to ~5MB offset

# 2. Resumable downloads
# Pause at 50%, resume later
GET /bigfile.zip HTTP/1.1
Range: bytes=524288000-  # continue from 500MB

# 3. Parallel downloads (download managers)
# Split file into N chunks, fetch concurrently
GET /bigfile.zip HTTP/1.1
Range: bytes=0-10485759      # chunk 1 (first 10MB)
# (parallel connection)
GET /bigfile.zip HTTP/1.1
Range: bytes=10485760-20971519  # chunk 2

# 4. PDF preview (load only visible pages)
GET /doc.pdf HTTP/1.1
Range: bytes=102400-204800   # specific page region

# 5. Streaming audio with metadata at the end
# Fetch ID3 tag without downloading the whole file
18

Управление сессиями

Сессии на cookie

Сессии на cookie хранят серверную сессию (в памяти, Redis или БД) с ключом по случайному session ID. Cookie содержит только ID. Плюсы: отзываемость (удалить сессию), маленькая cookie, зрелость. Минусы: состояние на сервере, горизонтальное масштабирование требует общего хранилища сессий (Redis), уязвимость к CSRF (защита через SameSite). Лучший выбор для традиционных веб-приложений с серверным рендерингом.

http
# 1. User logs in
POST /login HTTP/1.1
Host: example.com
Content-Type: application/json

{"username": "alice", "password": "secret"}

# 2. Server validates, creates session, stores in DB/Redis,
#    returns session ID in a cookie
HTTP/1.1 200 OK
Set-Cookie: session=abc123; HttpOnly; Secure; SameSite=Lax

# 3. Subsequent requests carry the cookie
GET /dashboard HTTP/1.1
Cookie: session=abc123

# 4. Server looks up session ID, finds user, serves request
# 5. Logout: delete session server-side, expire cookie
POST /logout HTTP/1.1
Cookie: session=abc123

HTTP/1.1 200 OK
Set-Cookie: session=; Max-Age=0; Path=/

Сессии на токенах (JWT)

Сессии на токенах (обычно JWT) хранят состояние сессии В токене. Сервер проверяет подпись без запроса к БД — stateless. Плюсы: масштабируемость (нет хранилища сессий), работа между сервисами, дружелюбность к мобильным. Минусы: нельзя отозвать до истечения (защита — короткие access-токены + refresh-токены на сервере), больше ID сессии, уязвимость к XSS при хранении в localStorage. Лучший выбор для API и SPA.

http
# 1. Login returns a JWT (no server-side state)
POST /login HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{"token": "eyJhbGciOiJIUzI1NiJ9..."}

# 2. Client stores token (memory, sessionStorage)
# 3. Each request includes the token in a header
GET /api/profile HTTP/1.1
Authorization: Bearer eyJhbGciOiJIUzI1NiJ9...

# 4. Server validates signature + claims, no DB lookup needed
# 5. Logout: client discards token (no server-side invalidation
#    until exp - this is the stateless tradeoff)

# Refresh token flow:
# - Short-lived access token (5-15 min)
# - Long-lived refresh token (days), stored server-side, revocable
# - When access token expires, exchange refresh token for new one

Сессия в заголовках

Сессии через заголовки (Authorization, X-API-Key) не хранят состояние и работают для любого клиента (браузеры, мобильные, CLI, сервер-сервер). Поток refresh-токена решает истечение: короткоживущие access-токены ограничивают ущерб от кражи, а refresh-токен (хранится безопасно, в идеале в HttpOnly cookie) даёт новые access-токены без повторного входа. Обнаруживайте украденные refresh-токены через ротацию.

http
# Bearer token in Authorization header
GET /api/data HTTP/1.1
Authorization: Bearer eyJhbGc...

# Custom header (e.g., API gateway)
GET /api/data HTTP/1.1
X-API-Key: abc123def456

# Basic auth (per-request credentials)
GET /api/data HTTP/1.1
Authorization: Basic dXNlcjpwYXNz

# Bearer + refresh flow:
# 1. Access token expires -> API returns 401
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer error="invalid_token"

# 2. Client uses refresh token to get a new access token
POST /token HTTP/1.1
Content-Type: application/x-www-form-urlencoded

grant_type=refresh_token&refresh_token=GmR...

# 3. New access token returned
{"access_token": "...", "expires_in": 900}

Истечение и скользящая сессия

Политики истечения сессий: абсолютная (фиксированный срок с момента входа), скользящая (сбрасывается при активности) или комбинированная (что наступит раньше). Комбинированная безопаснее: ограничивает общую длину сессии, допуская разумное время простоя. Cookie используют Max-Age; серверные сессии имеют отдельный TTL. JWT не скользят: exp фиксирован при выдаче. Чтобы «продлить» JWT, выдайте новый (поток refresh-токена), а не меняйте старый.

http
# Absolute expiration: session dies after fixed time from login
# e.g., 8 hours after login, regardless of activity
session.expires_at = session.created_at + 8h

# Sliding/Idle expiration: resets on each activity
# e.g., session dies after 30 min of inactivity
session.expires_at = NOW() + 30min   # updated on each request

# Combined (most secure):
# - Absolute cap (e.g., 24h max from login)
# - Idle timeout (e.g., 30min inactivity)
# Whichever comes first.

# Set-Cookie with Max-Age sets cookie lifetime,
# but server-side session may expire earlier (DB cleanup).
Set-Cookie: session=abc; Max-Age=1800  # 30 min

# JWT exp claim (absolute):
# {"exp": 1516242622}  # hardcoded, can't slide

Защита от CSRF

CSRF-атаки эксплуатируют автоматическую отправку cookie браузером. Cookie SameSite (по умолчанию Lax в современных браузерах) блокируют большинство CSRF, не отправляя cookie при межсайтовых POST. Паттерн CSRF-токена добавляет в формы сгенерированный сервером токен и проверяет его при отправке: атакующий не может прочитать токен из-за SOP. Double-submit и защита через свои заголовки добавляют эшелонированность. API на Bearer-токенах (без cookie) не подвержены CSRF.

http
# CSRF (Cross-Site Request Forgery): attacker tricks the user's
# browser into sending a state-changing request using their cookies.

# Defense 1: SameSite cookies (modern default)
Set-Cookie: session=abc; SameSite=Lax   # blocks most CSRF
Set-Cookie: session=abc; SameSite=Strict # blocks all cross-site

# Defense 2: CSRF token (synchronizer pattern)
# Server embeds a random token in the form
<form action="/transfer" method="POST">
  <input type="hidden" name="csrf" value="randomtoken123">
  ...
</form>
# Server validates the token on POST

# Defense 3: Double-submit cookie
Set-Cookie: csrf=xyz
# JS reads cookie, includes value in a custom header
X-CSRF-Token: xyz
# (custom headers can't be sent cross-site without preflight)

# Defense 4: Require custom header on state-changing requests
# (browsers block cross-site custom headers without CORS preflight)
19

WebSocket

Upgrade до WebSocket

WebSocket начинается как HTTP-запрос с заголовком Upgrade. Если сервер согласен, он отвечает 101 Switching Protocols. После этого то же TCP-соединение говорит по бинарному протоколу WebSocket: полнодуплексно, с малыми накладными расходами, без HTTP-оверхеда на каждое сообщение. Значение Sec-WebSocket-Accept (SHA-1 от ключа клиента плюс фиксированный GUID) доказывает намеренный апгрейд. Origin позволяет серверу авторизовать источник.

http
# Client initiates HTTP upgrade
GET /ws HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13
Origin: https://example.com

# Server accepts upgrade
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

# After 101, the TCP connection is "upgraded" - HTTP is done.
# Both sides send WebSocket frames (binary protocol).

# Sec-WebSocket-Accept = base64(SHA1(key + magic GUID))
# Server must compute this to prove it understood the upgrade.

Рукопожатие WebSocket (JS-клиент)

WebSocket API в браузере событийно: onopen после успешного апгрейда, onmessage на каждый входящий фрейм, onclose при отключении, onerror при сбоях. Отправляйте строки или бинарные данные (ArrayBuffer, Blob). Закрывайте с кодом (1000 = нормально) и причиной. Соединение полнодуплексное: обе стороны могут отправлять в любой момент. WSS (WebSocket Secure) использует TLS, аналог HTTPS.

http
# Browser client
const ws = new WebSocket('wss://example.com/ws');

ws.onopen = () => {
  console.log('connected');
  ws.send('Hello Server');
};

ws.onmessage = (event) => {
  console.log('received:', event.data);
};

ws.onclose = (event) => {
  console.log('closed:', event.code, event.reason);
};

ws.onerror = (error) => {
  console.error('error:', error);
};

# Send binary
ws.send(new ArrayBuffer(8));

# Close
ws.close(1000, 'normal closure');

Фреймы WebSocket

Фреймы WebSocket бинарны: бит FIN (завершение сообщения), opcode (text/binary/close/ping/pong), бит маски (фреймы клиента обязаны быть замаскированы, чтобы предотвратить отравление кеша посредниками), длина полезной нагрузки и данные. Коды закрытия объясняют причину: 1000 — норма, 1006 — аномально (без кадра close, часто обрыв сети). Кадры ping/pong держат соединение живым и обнаруживают мёртвых участников. Фреймы могут фрагментироваться на несколько.

http
# After the handshake, communication is via binary frames:
# - FIN bit (1 = final fragment of a message)
# - Opcode (4 bits): 0x1 text, 0x2 binary, 0x8 close,
#                    0x9 ping, 0xA pong
# - Mask bit (client->server frames are masked)
# - Payload length (7, 7+16, or 7+64 bits)
# - Masking key (4 bytes, client->server only)
# - Payload data

# Close codes:
# 1000  Normal closure
# 1001  Endpoint going away
# 1006  Abnormal closure (no close frame)
# 1008  Policy violation
# 1011  Internal server error
# 4000-4999  Application-defined

# Ping/Pong: keep-alive and liveness check
# Server: ping -> Client: pong (within timeout)

# Frames can be fragmented (FIN=0) and reassembled.

WebSocket против HTTP

WebSocket полнодуплексный и двунаправленный — идеален для реального времени (чат, игры, живые дашборды, совместное редактирование). HTTP — запрос-ответ: клиент спрашивает, сервер отвечает. Для односторонних обновлений сервер→клиент SSE проще (построен на HTTP, сам переподключается, дружелюбен к прокси). Для stateless CRUD правильный выбор — HTTP/REST. У WebSocket наименьшие накладные расходы на сообщение, но наибольшая стоимость установки (апгрейд, фрейминг).

http
# HTTP: request-response, half-duplex (client initiates)
# WebSocket: full-duplex, either side can send anytime

# Use HTTP when:
# - Client asks, server answers (CRUD APIs)
# - Stateless, cacheable resources
# - Occasional data fetches

# Use WebSocket when:
# - Real-time updates (chat, live sports, dashboards)
# - Bidirectional streaming (collaborative editing, gaming)
# - High-frequency, low-latency messaging
# - Server pushes events without client polling

# Alternatives:
# - SSE (Server-Sent Events): one-way server->client over HTTP
# - HTTP/2 streaming: server can push via DATA frames
# - Long polling: HTTP hack (client polls, server holds open)

# WebSocket has lower per-message overhead than HTTP.

Применение WebSocket

WebSocket раскрывается в реальном времени с двусторонним обменом: чат, живые дашборды, многопользовательские игры, совместное редактирование, уведомления и сигнализация WebRTC. Сложность — масштабирование: клиент подключается к конкретному серверу, поэтому для рассылки всем клиентам нужен pub/sub-бэкенд (Redis, Kafka), раздающий сообщения между экземплярами. Используйте sticky sessions на балансировщике или проектируйте stateless-серверы, маршрутизирующие сообщения через слой pub/sub.

http
# 1. Chat application
# Client sends: {"type": "message", "text": "hi"}
# Server broadcasts to all connected clients

# 2. Live dashboard (stock prices, sports scores)
# Server pushes updates every second
# Client just listens

# 3. Multiplayer game
# Low-latency bidirectional: position, actions, events

# 4. Collaborative editing (Google Docs style)
# Operational Transform / CRDT messages both ways

# 5. Live notifications
# Server pushes: "you have a new message"

# 6. Voice/video signaling (WebRTC)
# WS carries SDP offers/answers before media flows over UDP

# Scaling WebSockets: sticky sessions or a pub/sub backend
# (Redis Pub/Sub, Kafka) so any server can reach any client.
20

Проектирование REST API

Именование ресурсов

Ресурсы REST — существительные (во множественном числе: /users, а не /user), действие выражают HTTP-методы. Не кладите глаголы в URL (/createUser неверно — верно POST /users). Подресурсы выражают связи (/users/42/orders). Query-параметры отвечают за фильтрацию, сортировку и пагинацию — никогда не зашивайте их в путь. Для сегментов из нескольких слов используйте kebab-case (/password-resets, а не /passwordResets). Последовательность — важнейшее правило.

http
# Resources are nouns, pluralized
GET /api/users            # list users
POST /api/users           # create user
GET /api/users/42         # get user 42
PUT /api/users/42         # replace user 42
PATCH /api/users/42       # update user 42
DELETE /api/users/42      # delete user 42

# Sub-resources for relationships
GET /api/users/42/orders              # user 42's orders
GET /api/users/42/orders/1001         # specific order

# Use query params for filtering/sorting/pagination
GET /api/users?role=admin&sort=-created_at&page=2&limit=20

# Bad (verbs in URL):
POST /api/createUser     # should be POST /api/users
GET /api/getUser/42      # should be GET /api/users/42

# Good: nouns + HTTP methods express the action.

HTTP-методы в REST

Стандартное сопоставление CRUD в REST: POST=создание, GET=чтение, PUT=замена, PATCH=обновление, DELETE=удаление. GET/HEAD/OPTIONS безопасны (без побочных эффектов). PUT и DELETE идемпотентны. POST — нет (повтор создаёт дубликаты). Для действий вне CRUD (lock, archive, send-email) используйте подресурс с POST: /users/42/lock. Этот «люк в RPC» прагматичен: чистый REST не моделирует каждую операцию аккуратно.

http
# Standard CRUD mapping:
POST    /users         # Create (server assigns ID)
GET     /users         # List (with filtering/pagination)
GET     /users/:id     # Read one
PUT     /users/:id     # Replace (full update)
PATCH   /users/:id     # Update (partial)
DELETE  /users/:id     # Delete

# Safe (no side effects): GET, HEAD, OPTIONS
# Idempotent (repeatable): GET, HEAD, OPTIONS, PUT, DELETE
# Neither: POST (creates new resource each time)
# PATCH: idempotency depends on the patch format

# Custom "actions" on a resource (RPC-style escape hatch):
POST /users/42/lock      # lock the user (not pure REST)
POST /users/42/unlock
POST /users/42:lock      # Google AIP style
POST /users/42/actions/lock  # explicit escape hatch

Коды состояния в REST

Используйте коды состояния семантически. 200 — общий успех; 201 — создание (с Location); 204 — успех без тела. 400 — некорректный ввод; 422 (WebDAV) — синтаксически верный, но семантически невалидный (валидация). 401 против 403 — самая путаемая пара: 401 = «кто вы?», 403 = «я знаю, кто вы, но вам это нельзя». 5xx означает сбой сервера — клиенты могут повторять с задержкой. Будьте последовательны во всём API.

http
# Success (2xx)
200 OK              # generic success, returns data
201 Created         # POST/PUT created a resource (Location header)
202 Accepted        # async job queued (return job URL)
204 No Content      # success, no body (DELETE, PUT)

# Client errors (4xx)
400 Bad Request     # malformed input, validation failure
401 Unauthorized    # not authenticated (needs login)
403 Forbidden       # authenticated but lacks permission
404 Not Found       # resource doesn't exist
409 Conflict        # version conflict, duplicate
422 Unprocessable   # semantic error (well-formed but invalid)
429 Too Many Requests  # rate limited (Retry-After)

# Server errors (5xx)
500 Internal Server Error  # unexpected failure
503 Service Unavailable    # maintenance, overload

# Idempotency: 204 for DELETE/PUT is conventional.
# 201 vs 200 for POST: 201 if a resource was created.

Пагинация

Пагинация по страницам (offset/limit) проста, но неэффективна на больших данных (OFFSET сканирует пройденные строки) и нестабильна (новые вставки сдвигают строки). Пагинация по курсору использует непрозрачный токен, указывающий на последний элемент: стабильна при конкурентных вставках и быстра (индексный поиск по колонке курсора). Курсор — для бесконечных лент и больших потоков; страницы — для админок с «перейти на страницу N». Заголовок Link (RFC 5988) — способ HATEOAS-стиля отдавать URL пагинации.

http
# Page-based (offset/limit)
GET /api/users?page=2&limit=20
# Response:
{
  "data": [...],
  "page": 2,
  "limit": 20,
  "total": 1000,
  "total_pages": 50
}

# Cursor-based (token, better for large/realtime datasets)
GET /api/users?cursor=abc123&limit=20
# Response:
{
  "data": [...],
  "next_cursor": "def456",
  "has_more": true
}

# Link header (RFC 5988):
Link: <https://api.example.com/users?page=3>; rel="next",
      <https://api.example.com/users?page=50>; rel="last"

# Pros of cursor: stable under inserts/deletes,
# faster on large datasets (no OFFSET scan).
# Cons: can't jump to arbitrary page.

Версионирование API

Версионирование API не даёт ломающим изменениям вредить существующим клиентам. Версии в URI (/v1/, /v2/) — самый частый и явный подход: легко отлаживать, маршрутизировать и кешировать. Версии в заголовке сохраняют URL чистыми, но сложнее тестировать в браузере. При выводе из эксплуатации используйте заголовки Sunset и Deprecation (RFC 8594), чтобы объявить дату окончания поддержки, дайте клиентам время (6-24 месяца) и опишите путь миграции. Не ломающие изменения (добавление необязательных полей) не требуют новой версии.

http
# 1. URI versioning (most common, explicit)
GET /api/v1/users
GET /api/v2/users

# 2. Header versioning (cleaner URLs)
GET /api/users
Accept: application/vnd.example.v2+json

# 3. Custom header
X-API-Version: 2

# 4. Query parameter
GET /api/users?version=2

# Deprecation flow:
# - Mark old version as deprecated (Sunset header)
Sunset: Sat, 31 Dec 2025 23:59:59 GMT
Deprecation: true
# - Document migration guide
# - Maintain old version for a transition period (6-24 months)
# - Notify clients via email, response headers, logs
# - Eventually shut down the old version

# Breaking changes require a new major version.
# Non-breaking changes (adding fields) don't.

Лучшие практики REST

Лучшие практики REST: существительные во множественном числе, действия через методы, семантические коды состояния, пагинация по умолчанию, фильтрация через query-строки, единый формат ошибок (стандарт — RFC 7807 problem+json) и гипермедиа-ссылки для обнаружимости (HATEOAS). Для POST-endpoint, которые не идемпотентны по природе (платежи, создание заказов), принимайте заголовок Idempotency-Key, чтобы клиенты могли безопасно повторять запросы без дублирования эффектов: сервер хранит ответ по UUID и повторяет его при повторах.

http
# 1. Use plural nouns: /users not /user
# 2. HTTP methods express actions (no verbs in URLs)
# 3. Status codes are semantic (201 for create, 404 for missing)
# 4. Pagination on list endpoints (default limit, max cap)
# 5. Filtering via query params: ?role=admin&active=true
# 6. Consistent error format (RFC 7807 problem+json):
HTTP/1.1 422 Unprocessable Entity
Content-Type: application/problem+json

{
  "type": "https://example.com/errors/validation",
  "title": "Validation failed",
  "status": 422,
  "detail": "Email is required",
  "instance": "/api/users",
  "errors": [{"field": "email", "message": "required"}]
}

# 7. Hypermedia (HATEOAS) links in responses (optional):
{"data": {...}, "_links": {"self": "/users/42", "orders": "/users/42/orders"}}
# 8. Idempotency keys for safe POST retries (Stripe pattern)
Idempotency-Key: client-generated-uuid

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.