Démarrage
Requête et réponse HTTP
HTTP est un protocole requête-réponse. Les clients envoient des requêtes (méthode, chemin, en-têtes, corps optionnel), les serveurs répondent avec statut, en-têtes et corps. HTTP/1.1 est textuel, HTTP/2 et HTTP/3 emploient un tramage binaire.
# 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]"}Structure d'URL
Les URLs identifient des ressources. Le schéma choisit le protocole. L'hôte se résout par le DNS. Le port par défaut est sous-entendu quand omis. Le fragment (#) reste côté client et est retiré avant l'envoi au serveur. Les query strings servent couramment au filtrage/à la pagination.
# 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)Aperçu des versions HTTP
HTTP/0.9 était un prototype minimal. HTTP/1.0 a ajouté en-têtes et types de contenu mais ouvrait une connexion par requête. HTTP/1.1 a introduit les connexions persistantes, l'en-tête Host obligatoire (permettant les hôtes virtuels) et le pipelining. HTTP/2 a ajouté le multiplexage binaire. HTTP/3 tourne sur QUIC, éliminant le blocage head-of-line à la couche transport.
# 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)Cycle de vie de la connexion
HTTP/1.1 garde les connexions TCP ouvertes par défaut (keep-alive), évitant le coût de poignées de main répétées. Plusieurs requêtes peuvent passer sur une même connexion. L'en-tête Connection: close signale la dernière requête. HTTP/2 multiplexe beaucoup de flux sur une seule connexion. Les timeout et max de Keep-Alive se configurent côté serveur.
# 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: closeFormat des messages
Les messages HTTP commencent par une start-line (request-line ou status-line), suivie des en-têtes, d'une ligne vide et d'un corps optionnel. Les lignes emploient des fins de ligne CRLF. Les noms d'en-têtes sont insensibles à la casse. La ligne vide est obligatoire et signale le début du corps. Les corps peuvent être de longueur quelconque (chunked) ou fixe (Content-Length).
# 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.Débogage HTTP brut (Telnet)
On peut parler HTTP brut par TCP avec nc ou telnet (port 80) ou openssl s_client (HTTPS). Inestimable pour le débogage. Il faut inclure l'en-tête Host en HTTP/1.1+. Deux lignes vides terminent la requête. curl -v montre la conversation au format fil, en-têtes compris.
# 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.comMéthodes HTTP
GET — lire une ressource
GET récupère une représentation d'une ressource. Il doit être sûr (sans effet de bord) et idempotent (répétable). Les requêtes GET sont cachables et favorisables. Bien que la spécification autorise un corps, c'est déconseillé — proxys et CDN peuvent le retirer. Employez des paramètres de requête pour le filtrage.
# 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 — créer une ressource
POST soumet des données à traiter. Il sert à créer de nouvelles ressources dont le serveur attribue l'URI (ex. /api/users → /api/users/43). POST n'est ni sûr ni idempotent — soumettre deux fois peut créer deux ressources. La réponse 201 Created devrait porter un en-tête Location pointant vers la nouvelle ressource.
# 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 — remplacer une ressource
PUT remplace intégralement la ressource à l'URI cible par le corps de la requête. Il est idempotent — répéter le même PUT produit le même état final. PUT vise un URI précis (ex. /users/43), contrairement à POST qui vise une collection. Si un champ est omis dans PUT, il est typiquement retiré (remplacement complet).
# 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 returnedPATCH — mise à jour partielle
PATCH applique des mises à jour partielles à une ressource, contrairement à PUT qui la remplace entièrement. La forme la plus simple est JSON Merge Patch (RFC 7396) : n'envoyer que les champs à changer. JSON Patch (RFC 6902) emploie un tableau d'opérations (add, remove, replace, move, copy, test). PATCH n'est PAS idempotent par défaut, bien que merge-patch le soit.
# 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 — supprimer une ressource
DELETE supprime la ressource cible. Il est idempotent — supprimer deux fois la même ressource devrait laisser le serveur dans le même état. Les codes de succès courants : 204 (sans corps), 200 (avec corps de confirmation) ou 202 (suppression asynchrone). La plupart des API exigent une authentification. Renvoyer 404 sur une ressource absente est débattu — 204 est plus sûr pour l'idempotence.
# 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 et OPTIONS
HEAD est identique à GET mais le serveur ne renvoie que les en-têtes (pas de corps) — utile pour vérifier Content-Length, Content-Type ou Last-Modified sans télécharger le corps. OPTIONS demande quelles méthodes sont autorisées (en-tête Allow) et sert aux navigateurs pour le preflight CORS. Les deux sont sûrs et idempotents.
# 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, POSTCodes de statut
1xx Informationnel
Les codes 1xx sont informationnels, indiquant que la requête est reçue et le traitement se poursuit. 100 Continue laisse un client vérifier s'il doit envoyer un gros corps (associé à l'en-tête Expect: 100-continue). 101 Switching Protocols active WebSocket. 103 Early Hints laisse le serveur suggérer au navigateur de précharger des ressources avant que la réponse finale soit prête.
# 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=style2xx Succès
Les codes 2xx indiquent un succès. 200 OK est le succès générique. 201 Created signale qu'une nouvelle ressource est créée (avec un en-tête Location). 202 Accepted signifie que la requête est en file pour traitement asynchrone (ex. un long job). 204 No Content signale un succès sans corps — courant pour DELETE/PUT. 206 Partial Content renvoie une partie d'une ressource (requête Range).
# 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/20483xx Redirection
Les codes 3xx indiquent une redirection. 301/308 sont permanents (cachables, l'équité SEO des liens se transmet) ; 302/307 temporaires. La différence cruciale : 301 et 302 ont historiquement permis la conversion POST→GET (causant des pertes de données), tandis que 307 et 308 préservent strictement la méthode. 304 Not Modified revient sur les requêtes conditionnelles quand le cache est valide — sans corps.
# 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/api4xx Erreurs client
Les codes 4xx signifient une erreur du client. 400 Bad Request est une entrée malformée. 401 signifie pas d'authentification ou invalide (doit porter WWW-Authenticate). 403 authentifié mais permission manquante. 404 ressource manquante. 429 indique une limitation de débit (incluez Retry-After). Autres courants : 405 Method Not Allowed, 409 Conflict, 422 Unprocessable Entity.
# 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: 605xx Erreurs serveur
Les codes 5xx signifient un échec du serveur. 500 est le fourre-tout des erreurs non gérées (vérifiez les logs serveur). 501 signifie que le serveur n'implémente pas la méthode. 502 qu'un proxy/passerelle a reçu une mauvaise réponse de l'amont. 503 une surcharge temporaire (employez Retry-After). 504 un timeout amont. Les clients peuvent réessayer 502/503/504 avec backoff.
# 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 TimeoutPatterns de codes de statut
Une correspondance cohérente de codes de statut rend les API prévisibles. Employez 2xx pour le succès avec précision sémantique (201 pour créer, 204 sans corps). 4xx pour les erreurs client avec le code le plus spécifique (409 pour les conflits, 422 pour la validation). 401 vs 403 est la confusion la plus courante : 401 = « qui êtes-vous ? », 403 = « je sais qui vous êtes, mais vous ne pouvez pas faire cela ».
# 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).En-têtes de requête
En-têtes de requête courants
Les en-têtes de requête courants transportent l'identité du client (User-Agent), le format de réponse souhaité (famille Accept), le contrôle de connexion (Connection), l'authentification (Authorization), l'état (Cookie) et l'origine (Referer/Origin). Host est obligatoire en HTTP/1.1+ pour l'hébergement virtuel. Content-Type et Content-Length décrivent tout corps de requête.
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: 42En-têtes Accept (négociation de contenu)
La famille Accept pilote la négociation de contenu. Les valeurs de qualité (q, 0-1) expriment la préférence — plus haut = plus préféré. */* est un joker fourre-tout. Le serveur choisit la meilleure correspondance parmi ce qu'il gère ; si rien ne matche, il renvoie 406 Not Acceptable (bien que la plupart des serveurs replient vers un défaut plutôt que 406). Brotli (br) et zstd offrent une meilleure compression que gzip.
# 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.En-têtes d'autorisation
Authorization transporte les identifiants. L'auth basique envoie username:password encodé en base64 à chaque requête (toujours en HTTPS). Les tokens Bearer sont des chaînes opaques (souvent des JWT) employées en OAuth 2.0. Les schémas d'auth personnalisés (X-API-Key) sont courants pour les passerelles d'API. Le base64 de l'auth basique est de l'encodage, pas du chiffrement — aucune sécurité sans TLS.
# 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 et Referer
User-Agent identifie le client, mais la plupart des navigateurs feignent Mozilla/5.0 pour la compatibilité ascendante (sniffing historique). Referer (faute d'orthographe dans la spec, jamais corrigée) dit au serveur quelle page a lié vers la requête — employé pour l'analytique et la protection anti-hotlink. Origin est schéma+hôte+port, envoyé par les navigateurs sur les requêtes CORS et les POST.
# 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)En-têtes de requête conditionnelle
Les en-têtes conditionnels permettent un cache efficace et le contrôle de concurrence. If-None-Match (avec ETag) et If-Modified-Since (avec Last-Modified) rendent le GET conditionnel — le serveur renvoie 304 si le cache est valide. If-Match et If-Unmodified-Since protègent PUT/PATCH contre les mises à jour perdues (concurrence optimiste). If-Range permet des requêtes de plage atomiques.
# 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 changedEn-têtes personnalisés et X-
Les en-têtes personnalisés employaient historiquement le préfixe X-, mais la RFC 6648 a déprécié cette convention en 2012. Les nouveaux en-têtes devraient abandonner X- (ex. Request-ID plutôt que X-Request-ID). X-Forwarded-For et X-Forwarded-Proto transportent les infos client à travers les proxys (note : falsifiables). L'alternative standardisée est Forwarded (RFC 7239). Traceparent/Tracestate activent le traçage distribué (W3C).
# 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.comEn-têtes de réponse
En-têtes de réponse courants
Les en-têtes de réponse courants décrivent le serveur (Server), le corps de la réponse (Content-Type, Content-Length), le contrôle de connexion (Connection), le cache (Cache-Control, ETag, Last-Modified), la négociation de contenu (Vary), l'état (Set-Cookie) et le CORS (Access-Control-*). Date est obligatoire et emploie le format RFC 1123 en GMT.
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.comEn-têtes de contenu
Les en-têtes Content-* décrivent le corps. Content-Type est le type MIME et critique. Content-Length donne le compte exact d'octets (requis sauf encodage chunked). Content-Encoding indique la compression (gzip, br). Content-Disposition force le téléchargement avec un nom de fichier. Content-Range accompagne les réponses 206 Partial Content.
# 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-8En-têtes de sécurité
Les en-têtes de sécurité durcissent les navigateurs face aux attaques courantes. HSTS force le HTTPS et prévient le décapage SSL. X-Content-Type-Options: nosniff empêche le sniffing MIME. X-Frame-Options (ou CSP frame-ancestors) bloque le clickjacking. CSP est le plus puissant — il contrôle quelles ressources peuvent se charger et s'exécuter. Referrer-Policy limite les infos de référent qui fuient. Réglez-les sur chaque réponse.
# 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.comEn-têtes de réponse CORS
Les en-têtes CORS (Cross-Origin Resource Sharing) laissent un serveur accepter les requêtes cross-origin. Access-Control-Allow-Origin est requis pour toute lecture cross-origin ; soit une origine précise, soit *. Avec des identifiants, Allow-Credentials: true ET une origine spécifique (pas de joker). Les réponses de preflight (OPTIONS) incluent Allow-Methods/Headers. Expose-Headers laisse le JS lire les en-têtes de réponse non par défaut.
# 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-CountEn-têtes de cache
Cache-Control est l'en-tête de cache moderne (HTTP/1.1) avec des directives : public/private (qui peut cacher), max-age (fraîcheur en secondes), no-cache (doit revalider), no-store (jamais cacher), immutable (URL ne changeant jamais). ETag et Last-Modified sont des validateurs employés avec les requêtes conditionnelles. Expires (HTTP/1.0) est un repli. Age indique depuis combien de temps une réponse est en cache.
# 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: 120Authentification
Authentification basique
L'auth basique envoie des identifiants encodés en base64 à chaque requête. Simple et universellement gérée mais sans aucune sécurité hors HTTPS — le base64 se décode trivialement. L'en-tête WWW-Authenticate défie le client (les navigateurs montrent un dialogue de connexion natif). L'auth basique est rare dans les apps web modernes mais courante pour les tokens d'API et l'outillage interne.
# 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.Token Bearer (OAuth 2.0)
Les tokens Bearer sont des chaînes opaques présentées comme preuve d'autorisation. Le serveur n'a qu'à les valider — ils sont sans état s'ils sont autoportants (JWT) ou consultés dans un magasin. OAuth 2.0 définit des flux pour obtenir des tokens (code d'autorisation, identifiants client, token de refresh). Envoyez toujours les tokens Bearer en HTTPS. Les tokens ont une durée de vie finie ; employez des tokens de refresh pour en obtenir de nouveaux.
# 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..."
}Structure du JWT
Un JWT a trois parties encodées base64url séparées par des points : header (algorithme), payload (claims) et signature. La signature prouve que le token n'a pas été falsifié. Claims courants : sub (sujet), iat (émis à), exp (expiration), iss (émetteur), aud (audience). Le payload n'est PAS chiffré — n'y mettez jamais de secrets. Algorithmes de signature : HS256 (HMAC), RS256 (RSA), ES256 (ECDSA).
# 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...")Validation du JWT
Validation du JWT : vérifiez la signature (attrape la falsification), puis les claims (exp, iss, aud). exp est le plus important — rejetez les tokens expirés avec 401. Les JWT sont sans état : une fois émis, ils ne peuvent être révoqués avant expiration. Pour la révocation, employez des tokens d'accès de courte durée (5-15 min) + des tokens de refresh stockés côté serveur, ou tenez une liste noire (annule le caractère sans état).
# 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"Flux de code d'autorisation OAuth 2.0
Le flux de code d'autorisation est le standard des apps web côté serveur. Étape 1 : rediriger l'utilisateur vers le serveur d'auth. Étape 2 : renvoyer un code de courte durée vers l'URI de redirection. Étape 3 : échanger le code (plus client_secret) contre des tokens, de serveur à serveur. PKCE (Proof Key for Code Exchange) remplace le secret par une paire challenge/verifier — essentiel pour les SPA et apps mobiles où le secret ne peut être stocké en sécurité.
# 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))Clés API
Les clés API sont des secrets opaques simples identifiant un client. Elles s'envoient en en-têtes (préféré) ou en query strings (à éviter — journalisées dans les URLs et les logs de proxys). Les clés API sont avec état (le serveur les consulte) et révocables. Contrairement aux JWT, elles ne portent pas de claims — le serveur stocke les permissions. Bonne pratique : hacher les clés au repos, les borner étroitement, les renouveler, et fournir une UI de renouvellement en libre-service.
# 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 controlNégociation de contenu
En-tête Accept
L'en-tête Accept liste les types de médias que le client peut traiter, avec des valeurs de qualité (q) exprimant la préférence. Les jokers (text/*, */*) élargissent la correspondance. Le serveur choisit la meilleure correspondance et répond avec le Content-Type retenu. Si aucun type ne matche, le serveur devrait idéalement renvoyer 406, mais en pratique beaucoup d'API replient vers un format par défaut.
# 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 dit au serveur les langues préférées de l'utilisateur, avec valeurs de qualité pour le classement. La RFC 5646 définit les tags de langue (langue[-scripte][-région]). Le serveur répond avec Content-Language. Les navigateurs le règlent selon les réglages OS/locale de l'utilisateur. Pour l'i18n, repliez avec grâce : si la langue demandée est indisponible, renvoyez le défaut. Les CDN font parfois varier les caches selon Accept-Language — employez l'en-tête Vary.
# 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 liste les algorithmes de compression que le client peut décoder. Le serveur en choisit un et l'applique, renvoyant Content-Encoding. Brotli (br) compresse le texte mieux que gzip et est géré par tous les navigateurs modernes. zstd émerge avec une vitesse/un ratio encore meilleurs. identity signifie pas de compression. Activez toujours la compression pour les réponses texte (HTML, CSS, JS, JSON) — grosses économies de bande passante, mais sautez les formats déjà compressés (images, vidéo).
# 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 compressionEn-tête Vary
L'en-tête Vary dit aux caches (navigateur, CDN, proxy) quels en-têtes de requête affectent la réponse. Si un serveur renvoie un contenu différent selon Accept-Encoding, il doit poser Vary: Accept-Encoding pour que le cache ne serve pas une réponse gzip à un client n'acceptant que br. Trop de Vary nuit au taux de hit du cache ; pas assez cause un empoisonnement de cache (mauvais contenu servi). Vary: * désactive de fait le cache.
# 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.Valeurs de qualité (q)
Les valeurs de qualité (q, 0-1) expriment la force de préférence dans les en-têtes de la famille Accept. q=1.0 est le défaut (le plus préféré) ; q=0 signifie « inacceptable ». Le serveur liste ce qu'il peut produire, compare à la liste du client, et retient la correspondance au q le plus haut. La spécificité départage les égalités : application/json bat */* même à q égal. Trois décimales sont permises mais rarement nécessaires.
# 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.5Cache
Directives de Cache-Control
Cache-Control est l'en-tête de cache moderne avec des directives. public/private contrôle qui peut cacher ; max-age fixe la fraîcheur en secondes ; no-cache force la revalidation ; no-store interdit le cache ; must-revalidate interdit de servir périmé ; s-maxage fixe un TTL séparé pour les caches partagés (CDN). immutable dit aux navigateurs que la ressource ne change jamais — sautez la revalidation au rechargement. Stale-while-revalidate et stale-if-error permettent une dégradation gracieuse.
# 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 cacheETag et If-None-Match
ETag est un tag de version opaque (souvent un hachage du contenu) attaché à une réponse. À la requête suivante, le client envoie If-None-Match avec l'ETag enregistré. Si la ressource n'a pas changé, le serveur renvoie 304 Not Modified sans corps — économisant la bande passante. Les ETags forts garantissent un contenu identique à l'octet ; les ETags faibles (W/) tolèrent des réponses sémantiquement équivalentes (ex. différences d'espaces).
# 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 et If-Modified-Since
Last-Modified est un validateur basé sur un horodatage. Il a une précision d'une seconde — les changements sub-seconde peuvent passer inaperçus. If-Modified-Since déclenche un 304 si inchangé. If-Unmodified-Since protège contre les mises à jour perdues : si un autre client a modifié la ressource, le serveur renvoie 412 Precondition Failed. ETag est préféré quand disponible (plus précis), mais Last-Modified est un repli utile.
# 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 elsewhereFlux de validation du cache
Flux du cache : frais (dans max-age) → servi depuis le cache, pas de réseau. Périmé (après max-age) → requête conditionnelle avec validateurs. 304 rafraîchit le minuteur du cache sans re-télécharger le corps. 200 remplace l'entrée en cache. Cela coupe drastiquement la bande passante et la charge d'origine. Pour des données changeant souvent mais dont vous tolérez un léger périmètre, employez stale-while-revalidate.
# 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"Cache busting et invalidation
Cache busting : donnez aux ressources immuables (JS, CSS, images) des URLs versionnées (app.v1a2b3c.js) et mettez-les en cache un an avec immutable. Au déploiement, changez l'URL — les navigateurs vont chercher le nouveau fichier. Le point d'entrée HTML emploie no-cache pour que les utilisateurs revalident toujours et prennent les nouvelles URLs de ressources. Ce pattern donne mises à jour instantanées et caches de longue durée. Évitez le versionnage par query string (?v=123) — certains proxys ne le cachent pas.
# 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)CORS (cross-origin)
Politique same-origin et CORS
La politique same-origin (SOP) est un modèle de sécurité navigateur qui bloque par défaut la lecture des réponses cross-origin par les pages web. CORS (Cross-Origin Resource Sharing) est l'option d'acceptation : le serveur déclare quelles origines peuvent lire ses réponses. L'origine se définit comme schéma+hôte+port — que l'un diffère signifie cross-origin. CORS ne concerne que les requêtes navigateur ; les appels serveur à serveur sont libres.
# 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.comRequêtes simples (sans preflight)
Les requêtes simples sautent l'étape de preflight et vont droit au serveur. Les restrictions sont conservatrices : seulement GET/HEAD/POST, seulement les en-têtes de la liste sûre, et seulement des Content-Types simples. Tout écart (ex. Content-Type: application/json, en-têtes personnalisés, PUT/DELETE) rend la requête « non simple » et déclenche un preflight. Le serveur doit quand même inclure les en-têtes CORS sur la réponse ou le navigateur bloque la lecture.
# 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 responseRequêtes de preflight (OPTIONS)
Un preflight est une requête OPTIONS que le navigateur envoie avant une requête cross-origin non simple. Il vérifie si la méthode et les en-têtes réels sont autorisés. Le serveur répond avec Allow-Methods et Allow-Headers. Access-Control-Max-Age met le résultat du preflight en cache (défaut 5 s, plafond navigateur 24 h). Les preflight ajoutent de la latence — évitez-les sur les chemins chauds en vous tenant aux requêtes simples quand possible.
# 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 avec identifiants
Par défaut, les fetch cross-origin n'envoient pas de cookies. Pour les inclure, le client règle credentials: 'include'. Le serveur doit répondre avec Access-Control-Allow-Credentials: true ET refléter l'origine précise (pas le joker *). Incluez toujours Vary: Origin pour que les caches ne servent pas à une origine une réponse négociée pour une autre. Un CORS+identifiants mal configuré est une faille — restreignez les origines à une liste blanche connue.
# 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)Erreurs CORS courantes
Les erreurs CORS remontent dans la console du navigateur. Les plus courantes : Allow-Origin manquant (le serveur n'a pas accepté), joker-avec-identifiants (combinaison interdite), et Allow-Headers/Methods manquants sur les réponses de preflight. CORS est imposé par le navigateur, pas le serveur — la requête atteint quand même le serveur, mais le navigateur masque la réponse au JS. Vérifiez l'onglet Réseau : si le preflight OPTIONS échoue, la requête réelle n'est jamais envoyée.
# 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 responseHTTPS et SSL/TLS
Poignée de main TLS (HTTPS)
HTTPS enveloppe HTTP dans le chiffrement TLS. La poignée de main TLS authentifie le serveur (certificat), négocie le chiffrement et échange les clés. TLS 1.2 prend 2 allers-retours ; TLS 1.3 en prend 1 (ou 0 avec reprise). SNI (Server Name Indication) envoie le nom d'hôte cible en clair pour que le serveur choisisse le bon certificat — cela fuit le nom aux oreilles indiscrètes ; ECH (Encrypted Client Hello) le chiffre.
# 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 connectionsConnexion HTTPS
HTTPS est HTTP sur TLS, typiquement sur le port 443. Les messages HTTP eux-mêmes ne changent pas — TLS chiffre simplement le trafic TCP sous-jacent. Pour imposer le HTTPS, redirigez HTTP→HTTPS (301) et réglez l'en-tête HSTS pour que les navigateurs se souviennent d'employer HTTPS pour la durée indiquée. Les listes de préchargement HSTS (tenues par les navigateurs) codent en dur ce comportement pour que même la première requête passe en HTTPS.
# 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)Certificats
Les certificats X.509 lient une clé publique à un domaine, signés par une autorité de certification (CA). La chaîne de confiance va du certificat du serveur en remontant par les intermédiaires jusqu'à une CA racine pré-installée dans le navigateur. Les navigateurs vérifient la chaîne, la date d'expiration et que le SAN (Subject Alternative Name) correspond au nom d'hôte demandé. Les certificats wildcard (*.example.com) et multi-domaines (plusieurs SANs) couvrent plusieurs noms d'hôte.
# 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 -nooutHSTS (HTTP Strict Transport Security)
HSTS dit aux navigateurs d'employer toujours HTTPS pour un domaine, prévenant les attaques de décapage SSL. max-age est en secondes (1 an = 31536000). includeSubDomains l'étend à tous les sous-domaines. preload soumet le domaine à une liste de navigateurs codée en dur pour que même la première visite soit HTTPS — protection forte mais difficile à annuler (le retrait prend des mois). Redirigez toujours d'abord HTTP→HTTPS, puis ajoutez HSTS, puis éventuellement preload.
# 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.Versions TLS et ciphers
Désactivez SSLv2/v3 et TLS 1.0/1.1 — ils ont des vulnérabilités connues (POODLE, BEAST). TLS 1.3 (2018) est le standard moderne : poignée de main plus rapide, retire les ciphers faibles, impose la confidentialité persistante. TLS 1.2 avec ECDHE + AES-GCM est acceptable. Employez des outils comme SSL Labs pour noter votre configuration. La confidentialité persistante (ECDHE) garantit que le trafic passé reste chiffré même si la clé privée fuite plus tard.
# 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/HTTP/2
Fonctionnalités HTTP/2
HTTP/2 garde la sémantique HTTP (méthodes, codes de statut, en-têtes) mais change le format fil en frames binaires. Gains clés : multiplexage de nombreuses requêtes sur une connexion TCP (pas de blocage head-of-line au niveau HTTP), compression d'en-têtes HPACK, et priorisation des flux. Négocié via ALPN sur TLS (le plus courant) ou upgrade h2c en clair. Server Push a été déprécié en 2022 à cause de médiocres performances réelles.
# 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.Multiplexage
Le multiplexage est la vedette de HTTP/2. Beaucoup de flux partagent une connexion TCP, avec des frames entrelacées — fini la limite de 6 connexions par origine, pas de blocage head-of-line à la couche HTTP. Cela élimine les hacks HTTP/1.1 comme le sharding de domaine, la concaténation de fichiers et l'inlining d'images. Note : le blocage head-of-line au niveau TCP existe toujours (un paquet perdu bloque tous les flux jusqu'à la retransmission) — c'est ce que HTTP/3 corrige avec QUIC.
# 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 (déprécié)
Server Push laissait le serveur envoyer des ressources avant que le client ne les demande. En théorie, cela économise un aller-retour pour les ressources critiques. En pratique, déprécié en 2022 : le serveur ne peut connaître l'état du cache du client, donc il sur-pousse, gaspillant souvent la bande passante. Les navigateurs ignorent désormais les frames PUSH_PROMISE. Alternatives modernes : <link rel=preload> en HTML, ou 103 Early Hints (le serveur envoie des indices de preload avant la réponse finale).
# 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 HintsPriorisation des flux
HTTP/2 laissait les clients exprimer la priorité des flux via un arbre de dépendances avec poids. Le serveur s'en servait pour allouer la bande passante : ex. le CSS avant les images. La RFC 9113 (2022) a retiré la frame PRIORITY explicite, laissant l'ordonnancement au serveur — beaucoup ont implémenté le leur. Le schéma de priorisation extensible (RFC 9218) est une alternative moderne optionnelle. La priorisation compte surtout sur les connexions lentes.
# 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.Compression d'en-têtes HPACK
HPACK compresse les en-têtes HTTP grâce à une table statique d'en-têtes courants, une table dynamique par connexion qui apprend les valeurs récemment envoyées, et le codage de Huffman. Cela coupe drastiquement la surcharge — un cookie de 1 Ko envoyé à chaque requête devient une minuscule référence indexée. HPACK est soigneusement conçu pour éviter les attaques par oracle de compression CRIME/BREACH qui tourmentaient la compression TLS antérieure. HTTP/3 emploie un schéma semblable appelé QPACK.
# 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.HTTP/3 et QUIC
Protocole QUIC
QUIC est un protocole de transport sur UDP qui intègre TLS 1.3 et fournit des flux fiables et multiplexés. Passer à l'UDP laisse QUIC évoluer plus vite que le TCP du noyau. Avantages clés : pas de blocage head-of-line au niveau TCP (un paquet perdu ne bloque qu'un seul flux), reprise 0-RTT pour les connexions de retour, et migration de connexion (un téléphone passant du Wi-Fi au cellulaire garde la connexion). HTTP/3 tourne sur QUIC.
# 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.Fonctionnalités HTTP/3
HTTP/3 préserve la sémantique HTTP mais tourne sur QUIC au lieu de TCP. Le grand gain : pas de blocage head-of-line. En HTTP/2, un seul paquet TCP perdu bloque tous les flux multiplexés jusqu'à la retransmission ; en HTTP/3, seul le flux affecté attend. Plus la reprise 0-RTT et la migration de connexion. Le coût : plus de CPU (QUIC en espace utilisateur) et l'UDP parfois bloqué/étranglé par les réseaux. L'adoption croît — la plupart des grands sites le gèrent.
# 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.comReprise de connexion 0-RTT
0-RTT laisse les clients de retour envoyer des données dès leur premier vol (pas d'aller-retour avant la requête). Cela économise des dizaines à des centaines de millisecondes sur les visites répétées. Le hic : les données précoces peuvent être rejouées par un attaquant, il faut donc les limiter aux opérations idempotentes (GET, HEAD, PUT/DELETE si idempotent). Les serveurs devraient rejeter le 0-RTT pour POST et les autres méthodes changeant l'état. Les mécanismes anti-rejeu ajoutent de la complexité.
# 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 mechanismsMigration de connexion
Les connexions QUIC s'identifient par un ID de connexion plutôt que par le quadruplet IP/port. Une connexion survit donc aux changements d'IP — un téléphone passant du Wi-Fi au cellulaire, ou un portable changeant de réseau, garde la connexion en vie. Le serveur valide le nouveau chemin avec PATH_CHALLENGE/PATH_RESPONSE. TCP ne peut pas le faire car le noyau identifie les connexions par le quadruplet. Grand gain pour le mobile.
# 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 vs HTTP/2 vs HTTP/3
HTTP/1.1 est du texte sur TCP avec 6 connexions parallèles. HTTP/2 est du binaire sur TCP avec multiplexage (mais blocage HoL au niveau TCP). HTTP/3 est du binaire sur QUIC sans blocage HoL, chiffrement obligatoire, 0-RTT et migration de connexion. L'adoption est incrémentale : les serveurs annoncent HTTP/3 via l'en-tête Alt-Svc sur les réponses HTTP/2, et les navigateurs montent à la visite suivante. Les trois partagent la sémantique 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-SvcRedirection (3xx)
301 vs 302
301 signifie permanent : les navigateurs mettent la redirection en cache, les favoris se mettent à jour et l'équité SEO des liens passe à la nouvelle URL. 302 signifie temporaire : rien n'est mis en cache, le SEO reste à l'original. Historiquement, les deux convertissaient POST→GET (une violation de spec devenue de facto). Pour préserver strictement la méthode, employez 307 (temporaire) ou 308 (permanent). Pour les migrations SEO, 301 ; pour les redirections de connexion, 302 ou 307.
# 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 vs 308
307 et 308 sont les homologues préservant la méthode de 302 et 301. Ils corrigent le bug historique de conversion POST→GET. 307 est temporaire, 308 permanent — les deux gardent la méthode et le corps d'origine. Employez-les pour rediriger des requêtes non GET, surtout dans les API où une conversion POST→GET perdrait silencieusement le corps. 308 est le choix moderne pour les déplacements permanents d'endpoints d'API.
# 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 (pattern PRG)
303 See Other dit explicitement au navigateur de suivre avec un GET — le bon outil du pattern Post/Redirect/Get (PRG). Après le traitement d'un POST, redirigez avec 303 vers une page GET. Si l'utilisateur rafraîchit, il ré-émet le GET sûr (pas le POST), évitant les soumissions de formulaires dupliquées. Employez 303 pour le PRG, 307/308 pour préserver la méthode d'origine, 301/302 pour la navigation simple.
# 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!"Chaînes et boucles de redirection
Les chaînes de redirection ajoutent de la latence (chaque saut = aller-retour) et devraient s'aplatir — pointez l'URL d'origine directement vers la destination finale. Les boucles de redirection sont fatales : les navigateurs les détectent après quelques sauts et montrent une page d'erreur. Causes courantes : mauvaise config HTTPS↔HTTP derrière un load balancer (employez X-Forwarded-Proto), ou conflits de slash final. HSTS évite les boucles HTTP→HTTPS en faisant réécrire en interne par le navigateur.
# 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)Cas d'usage de redirection courants
Cas d'usage courants : HTTP→HTTPS (301), apex↔www (301), migrations d'URL ancien→nouveau (301), redirections de connexion (302/303), pattern PRG (303), déplacements d'endpoints d'API (308), et replis d'origine CDN. Préférez toujours 301/308 pour les déplacements permanents pour que caches et SEO se mettent à jour. Employez HSTS plutôt que des redirections HTTP→HTTPS quand possible — cela évite l'aller-retour de redirection aux visites suivantes.
# 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/assetTypes de contenu (MIME)
Types MIME courants
Les types MIME (types de médias) décrivent le format d'un corps. Ils se composent de type/sous-type et de paramètres optionnels (charset, boundary). Types courants : text/html pour les pages, application/json pour les API, image/* et video/* pour les médias. application/octet-stream est le repli des données binaires inconnues — les navigateurs téléchargeront plutôt que d'essayer de rendre. L'IANA tient le registre officiel.
# 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 contentEn-tête Content-Type
L'en-tête Content-Type déclare le type MIME du corps. Pour les types texte, charset précise l'encodage (le défaut de text/* est ISO-8859-1 ; réglez toujours UTF-8 explicitement). Pour les corps multipart, boundary sépare les parties. Les navigateurs peuvent « sniffer » le type s'il manque ou est vague — prévenez-le avec X-Content-Type-Options: nosniff, qui les force à honorer le type déclaré (durcissement de sécurité contre le XSS via uploads de fichiers).
# 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 typemultipart/form-data
multipart/form-data encode plusieurs parties (champs et fichiers) dans un corps, séparées par une boundary. Chaque partie a son propre Content-Disposition (avec filename optionnel) et Content-Type. C'est le format que les navigateurs emploient à la soumission de formulaires avec des inputs de fichiers. C'est la seule façon pratique d'envoyer des fichiers via des formulaires HTML, bien que pour les API, le base64-en-JSON ou un PUT direct vers une URL de stockage soit souvent plus simple.
# 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 est le format d'API dominant — léger, lisible par humains et nativement géré dans chaque langage. JSON est UTF-8 par défaut (le paramètre charset est redondant mais inoffensif). Les types de médias spécifiques au vendeur (application/vnd.api+json, application/vnd.github.v3+json) permettent le versionnage et la négociation de profil. La RFC 7807 (application/problem+json) standardise les réponses d'erreur.
# 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)Paramètre charset
Le paramètre charset déclare l'encodage du texte. Réglez-le toujours pour les types text/* — le défaut ISO-8859-1 cause du mojibake pour les caractères non ASCII. UTF-8 est le choix universel. Pour JSON, charset est redondant (JSON est UTF-8 par spec). Pour XML, la spec par défaut est UTF-8 mais le déclarer explicitement évite la surcharge de sniffing du BOM. Des charsets dépareillés produisent des caractères bizarres.
# 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">Transfert chunked
Transfer-Encoding: chunked
L'encodage de transfert chunked laisse le serveur diffuser un corps sans connaître sa longueur totale à l'avance. Chaque chunk est préfixé de sa longueur en hexa, suivi de CRLF, des données, et de CRLF. Un chunk de longueur nulle signale la fin. Essentiel pour les réponses générées dynamiquement (rendu de template, requêtes de base) dont la taille n'est connue qu'à la production des données. HTTP/2 et HTTP/3 n'emploient pas le chunked — ils ont leur propre tramage.
# 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
Réponses en flux
Les réponses en flux emploient l'encodage chunked pour pousser les données de façon incrémentale. Server-Sent Events (SSE) est le pattern canonique : le serveur garde la connexion ouverte et écrit les événements en 'data: <charge>\n\n'. L'API EventSource du navigateur les reçoit à mesure qu'ils arrivent. Autres usages : rendu HTML progressif (flush au fil de l'eau), grands tableaux JSON, suivi de logs. Assurez qu'aucun proxy intermédiaire ne tamponne la réponse — réglez X-Accel-Buffering: no pour nginx.
# 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)En-têtes de remorque (Trailer)
Les en-têtes de remorque s'envoient après le corps en encodage chunked. Utiles pour des statistiques de synthèse calculées pendant le flux — ex. un compte de lignes, une somme de contrôle ou une durée de traitement. L'en-tête Trailer annonce quelles remorques apparaîtront. Certains en-têtes sont interdits en remorque (Host, Content-Length, Transfer-Encoding, en-têtes d'auth) car ils affectent le tramage de la connexion. Le support client est inégal — beaucoup de clients ignorent les remorques.
# 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 headersContent-Length vs chunked
Content-Length dit au client la taille exacte du corps à l'avance — simple, permet des barres de progression et laisse réutiliser la connexion proprement. L'encodage chunked permet de diffuser sans connaître la taille. Il faut employer l'un ou l'autre (ou fermer la connexion à la fin). Envoyer les deux est ambigu ; selon la spec, chunked l'emporte, mais les vieux clients peuvent mal se comporter. Pour les fichiers statiques, toujours Content-Length ; pour le dynamique/le flux, chunked.
# 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.Flux HTTP/2 (sans chunked)
HTTP/2 et HTTP/3 n'emploient pas l'encodage chunked — ils ont leur propre tramage binaire. Les frames DATA portent les octets du corps ; le flag END_STREAM signale la fin. Cela donne la même capacité de flux sans la surcharge par chunk du tramage longueur-hexa. L'en-tête Transfer-Encoding est illégal en HTTP/2 (RFC 9113). Content-Length reste autorisé mais optionnel. La sémantique du flux est préservée ; seul le mécanisme fil change.
# 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.Requêtes Range
En-tête Range
Les requêtes Range laissent un client récupérer une partie d'une ressource — essentiel pour les téléchargements reprenables, la navigation vidéo et les téléchargements parallèles par chunks. L'en-tête Range précise des plages d'octets. Le serveur répond avec 206 Partial Content et un en-tête Content-Range montrant ce qui a été renvoyé. Si le serveur ne gère pas les plages, il ignore l'en-tête et renvoie 200 avec le corps complet. Vérifiez toujours Accept-Ranges d'abord.
# 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)En-tête Accept-Ranges
L'en-tête Accept-Ranges annonce si le serveur gère les requêtes de plage. bytes signifie oui ; none (ou l'absence) non. Les clients devraient le vérifier avant de compter sur Range — un serveur qui ignore Range renverra le corps complet avec 200. Les navigateurs l'emploient automatiquement pour la navigation vidéo (<video>, sauter à un horodatage = requête de plage) et les téléchargements reprenables. La plupart des CDN et serveurs statiques gèrent les plages ; les endpoints dynamiques souvent non.
# 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.Réponse de contenu partiel (206)
206 Partial Content est la réponse à une requête de plage réussie. Content-Range montre l'unité (bytes), la plage renvoyée et la taille totale. Si la plage demandée dépasse la ressource, le serveur renvoie 416 Range Not Satisfiable. If-Range rend la plage conditionnelle : si le validateur (ETag ou date) correspond, renvoyer 206 ; si la ressource a changé, renvoyer 200 avec le corps complet — prévenant les problèmes de corruption partielle.
# 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)Requêtes multi-plages
Les requêtes multi-plages demandent plusieurs plages d'octets en une requête. Le serveur répond avec multipart/byteranges — chaque partie a son propre Content-Type et Content-Range. En pratique, le multi-range est rarement employé : les clients émettent typiquement des requêtes mono-plage parallèles (plus simple, plus amical au cache, plus facile à récupérer en cas d'erreur). Certains serveurs plafonnent le nombre de plages ou fusionnent les chevauchantes. Évitez de compter sur le multi-range pour les chemins critiques.
# 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.Cas d'usage du Range
Les requêtes Range motorisent la navigation vidéo (sauter à un horodatage), les téléchargements reprenables (continuer après une pause), les téléchargements parallèles (les gestionnaires découpent les fichiers en chunks), l'aperçu de pages PDF et la lecture de métadonnées stockées en fin de fichier (tags ID3). Pour tout cela, le serveur doit gérer les plages et l'annoncer via Accept-Ranges: bytes. Sans support des plages, la navigation vidéo se dégrade en téléchargement complet, et les téléchargements reprenables sont impossibles.
# 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 fileGestion des sessions
Sessions basées cookies
Les sessions basées cookies stockent une session côté serveur (en mémoire, Redis ou une base) indexée par un ID de session aléatoire. Le cookie ne porte que l'ID. Avantages : révocable (supprimer la session), petit cookie, mature. Inconvénients : avec état (le serveur doit stocker les sessions), la mise à l'échelle horizontale exige un stockage de session partagé (Redis), vulnérable au CSRF (atténuez avec SameSite). Idéal pour les apps web traditionnelles à pages rendues côté serveur.
# 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=/Sessions basées tokens (JWT)
Les sessions basées tokens (généralement JWT) stockent l'état de session DANS le token. Le serveur valide la signature sans consultation de base — sans état. Avantages : scalable (pas de magasin de sessions), fonctionne entre services, amical au mobile. Inconvénients : irrévocable avant expiration (atténuez avec des tokens d'accès courts + des tokens de refresh stockés côté serveur), plus grand qu'un ID de session, vulnérable au XSS si stocké en localStorage. Idéal pour les API et SPA.
# 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 oneSession dans les en-têtes
Les sessions par en-têtes (Authorization, X-API-Key) sont sans état et fonctionnent pour tout client (navigateurs, mobile, CLI, serveur à serveur). Le flux de refresh-token gère l'expiration : des tokens d'accès de courte durée limitent le rayon d'un token volé, tandis que le token de refresh (stocké en sécurité, idéalement en cookie HttpOnly) laisse le client obtenir de nouveaux tokens d'accès sans se ré-authentifier. Détectez les tokens de refresh volés par rotation.
# 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}Expiration et glissement de session
Politiques d'expiration de session : absolue (durée de vie fixe depuis la connexion), glissante (se remet à l'activité) ou combinée (la première des deux). La combinée est la plus sûre — plafonne la durée totale de session tout en tolérant un temps d'inactivité raisonnable. Les cookies emploient Max-Age ; les sessions côté serveur ont un TTL séparé. Les JWT ne peuvent glisser — la claim exp est fixée à l'émission. Pour « étendre » un JWT, émettez-en un nouveau (flux refresh-token) plutôt que de muter l'ancien.
# 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 slideProtection CSRF
Les attaques CSRF exploitent le fait que les navigateurs envoient les cookies automatiquement. Les cookies SameSite (Lax par défaut dans les navigateurs modernes) bloquent la plupart du CSRF en refusant d'envoyer les cookies sur les POST cross-site. Le pattern du token CSRF ajoute un token généré par le serveur aux formulaires et le valide à la soumission — les attaquants ne peuvent le lire à cause de la SOP. La double soumission et les en-têtes personnalisés ajoutent de la défense en profondeur. Les API employant des tokens Bearer (sans cookies) sont immunisées au CSRF de par leur conception.
# 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)WebSocket
Upgrade WebSocket
WebSocket démarre comme une requête HTTP avec l'en-tête Upgrade. Si le serveur accepte, il renvoie 101 Switching Protocols. Ensuite, la même connexion TCP parle le protocole binaire WebSocket — full-duplex, faible surcharge, pas de surcharge HTTP par message. La valeur Sec-WebSocket-Accept (SHA-1 de la clé du client plus un GUID fixe) prouve que le serveur a voulu la montée. Origin laisse le serveur autoriser la source de la montée.
# 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.Poignée de main WebSocket (client JS)
L'API WebSocket du navigateur est pilotée par événements : onopen se déclenche après le succès de la montée, onmessage à chaque frame entrante, onclose à la déconnexion, onerror aux échecs. Envoyez des chaînes ou du binaire (ArrayBuffer, Blob). Fermez avec un code (1000 = normal) et une raison. La connexion est full-duplex — les deux côtés peuvent envoyer à tout moment. WSS (WebSocket Secure) emploie TLS, équivalent du HTTPS.
# 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');Frames WebSocket
Les frames WebSocket sont binaires : un bit FIN (fin de message), opcode (texte/binaire/close/ping/pong), bit de masque (les frames du client doivent être masquées pour prévenir l'empoisonnement de cache par les intermédiaires), longueur de charge et données. Les codes de close disent pourquoi la connexion s'est terminée — 1000 est normal, 1006 anormal (pas de frame de close, souvent une coupure réseau). Les frames ping/pong maintiennent la connexion en vie et détectent les pairs morts. Les frames peuvent se fragmenter sur plusieurs frames.
# 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 vs HTTP
WebSocket est full-duplex et bidirectionnel, idéal pour les apps temps réel (chat, jeux, dashboards en direct, édition collaborative). HTTP est requête-réponse — le client demande, le serveur répond. Pour des mises à jour unidirectionnelles serveur vers client, SSE est plus simple (fondé sur HTTP, se reconnecte automatiquement, s'entend bien avec les proxys). Pour du CRUD sans état, HTTP/REST convient. WebSocket a la plus faible surcharge par message mais le plus haut coût d'installation (upgrade, tramage).
# 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.Cas d'usage WebSocket
WebSocket brille pour les apps bidirectionnelles temps réel : chat, dashboards en direct, jeux multijoueurs, édition collaborative, notifications et signalisation WebRTC. Le défi est la mise à l'échelle : un client se connecte à un serveur précis, donc diffuser à tous les clients exige un backend pub/sub (Redis, Kafka) pour répartir entre instances de serveurs. Employez des sessions épinglées au load balancer, ou concevez des serveurs sans état qui routent les messages via la couche pub/sub.
# 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.Conception d'API REST
Nommage des ressources
Les ressources REST sont des noms (au pluriel : /users pas /user), avec les méthodes HTTP exprimant l'action. Ne mettez pas de verbes dans les URLs (/createUser est faux — POST /users est juste). Les sous-ressources expriment les relations (/users/42/orders). Les paramètres de requête gèrent filtrage, tri, pagination — ne les cuisez jamais dans le chemin. Employez le kebab-case pour les segments de chemin multi-mots (/password-resets, pas /passwordResets). La cohérence est la règle la plus importante.
# 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.Méthodes HTTP en REST
La correspondance CRUD REST standard : POST=créer, GET=lire, PUT=remplacer, PATCH=mettre à jour, DELETE=supprimer. GET/HEAD/OPTIONS sont sûrs (sans effet de bord). PUT et DELETE sont idempotents. POST ne l'est pas (répéter crée des doublons). Pour des actions hors CRUD (lock, archive, send-email), employez une sous-ressource avec POST : /users/42/lock. Cette « échappatoire RPC » est pragmatique — le REST pur ne modélise pas proprement chaque opération.
# 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 hatchCodes de statut en REST
Employez les codes de statut sémantiquement. 200 est le succès générique ; 201 indique une création (avec Location) ; 204 un succès sans corps. 400 est une entrée malformée ; 422 (WebDAV) bien formée mais sémantiquement invalide (validation). 401 vs 403 est la paire la plus confondue : 401 = « qui êtes-vous ? », 403 = « je sais qui vous êtes, mais vous ne pouvez pas faire cela ». 5xx signifie que le serveur a déraillé — les clients peuvent réessayer avec backoff. Soyez cohérent dans toute votre API.
# 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.Pagination
La pagination par page (offset/limit) est simple mais inefficace sur les grands jeux de données (OFFSET balaie les lignes passées) et instable (les nouvelles insertions décalent les lignes). La pagination par curseur emploie un token opaque pointant vers le dernier item — stable sous insertions concurrentes et rapide (recherche indexée sur la colonne du curseur). Employez le curseur pour les scrolls infinis et les grands flux ; la page pour les UI d'admin exigeant « aller à la page N ». L'en-tête Link (RFC 5988) est une façon HATEOAS d'exposer les URLs de pagination.
# 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.Versionnage d'API
Le versionnage d'API empêche les changements cassants de nuire aux clients existants. Le versionnage par URI (/v1/, /v2/) est l'approche la plus courante et explicite — facile à déboguer, router et mettre en cache. Le versionnage par en-tête garde les URLs propres mais est plus dur à tester dans un navigateur. En dépréciant, employez les en-têtes Sunset et Deprecation (RFC 8594) pour annoncer la date de fin de vie, laissez aux clients ample temps (6-24 mois) et documentez le chemin de migration. Les changements non cassants (ajouter des champs optionnels) n'exigent pas de montée de version.
# 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.Bonnes pratiques REST
Bonnes pratiques REST : noms au pluriel, les méthodes expriment les actions, codes de statut sémantiques, pagination par défaut, filtrage par query strings, format d'erreur cohérent (le problem+json de la RFC 7807 est le standard), et liens hypermédia pour la découvrabilité (HATEOAS). Pour les endpoints POST naturellement non idempotents (paiements, création de commandes), acceptez un en-tête Idempotency-Key pour que les clients puissent réessayer en sécurité sans dupliquer les effets — le serveur stocke la réponse indexée par l'UUID et la rejoue aux reprises.
# 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-uuidSnippets HTTP associés
Copy-paste ready code for common tasks.
Methods
Core HTTP request methods.
Status Codes
Five classes of response codes.
Headers
Common request and response headers.
Caching
Cache-Control, ETag, and conditional requests.
Cookies
Set, send, and expire cookies.
Authentication
Basic, Bearer, and challenge responses.
Content Negotiation
Negotiate representation with Accept headers.
CORS
Cross-origin preflight and responses.
Was this helpful?