Couche proxy et routage inverse

Résumé succinct

La couche proxy est le « bus avant » de la plate-forme : elle complète TLS, certifie les clients, distribue le trafic, lisse les pics et rend la sortie sûre (canaris, bleu-vert). Ensemble minimum de maturité : stratification claire des rôles proxy, règles de routage déterministes, contrôle des délais/retraits, cache + rate-limit, observabilité de bout en bout et automatisation.

Taxonomie du proxy

Forward proxy - trafic sortant des clients/services vers l'extérieur (egress), filtres/miroirs, DLP.
Reverse proxy - accepte les demandes externes et route vers les backends (notre focus principal).

Calques dans le tracé :

1. Edge/CDN/WAF (Anycast, filtres de bot, cache)

2. L7 Ingress/API-gateway (routage, authentification, politiques)

3. Couche de service/Mesh (sidecar) pour east-west, mTLS et retraits

4. Egress-gateway pour les intégrations sortantes (PSP, partenaires)

Routage (L4/L7) et algorithmes

L4 (TCP/UDP, passthrough TLS) : délai minimum, sans compréhension HTTP.
L7 (HTTP/1. 1, HTTP/2, HTTP/3/gRPC) : règles sur host/path/header/cookie, transformation, WAF, cache.

Algorithmes :

Round-robin/Least-connexions/EWMA - cas courants.
Consistent-hash (par cookie/ID) - sticky-sessions et cache-localité.
Header-/Geo-/Latency-based - ciblage par région/fournisseur, PoP rapide.
Canary/Weighted - pas à pas (5→25→50→100 %).
Shadow/Mirroring est une copie du trafic vers le nouveau service sans impact sur les réponses.

Transformation des requêtes/réponses

URL rewrite/redirect : unification des chemins, versioning ('/v1/ →/svc/v1/').
Titres : normaliser 'X-Forwarded-For/Proto/Host', ajouter 'traceparent '/' x-request-id', filtrer l'excès.
CORS/CSRF : centralisez dans la passerelle, ne produisez pas de réglages dans chaque service.
Compression/Decompression : Brotli/gzip, contrôle par type.
Body-limits et protection contre le slowloris/oversized headers.

Authentification et sécurité

TLS 1. 3 + stapling OCSP + HSTS sur les fronts extérieurs.
mTLS : administrateurs, API d'exploitation, canaux partenaires.
OAuth2/OIDC : autorisation via gateway (token introspection/JWT-verify) → une déviation vers les clims dans upstream.
API clés/signatures (HMAC) pour les intégrations interservices et partenaires.
WAF/filtres de bot : signatures + règles de comportement, greypass/capcha.
CSP/X-Frame-Options/Referrer-Policy - Titres de sécurité sur le bord.

Fiabilité : Retrai/Timeouts/SV

Temps d'attente : connect/read/write sur le L4/L7, stratégie unique (par exemple, 'connect 500ms', 'read 3-5s'pour l'API).
Retrai : idempotent seulement ('GET/HEAD'), limite de temps/quantité, 'retry-budget'.
Circuit-breaker : restrictions sur les requêtes/erreurs simultanées, défaillance rapide et dégradation.
Détection Outlier : exclure les instances « mauvaises » du pool.
Backoff + jitter : pour ne pas créer d'effet de troupeau.

Cache et gestion du trafic

Cache L7 : statique/semi-dynamique (catalogues, configi), 's-maxage' + 'stale-while-revalidate'.
Rate-limit/Quota : par IP/ASN/device/cookie, compteur distribué (Redis/Rate-service).
Sticky-sessions : cookie/consistent-hash ; Prenez en compte le failover et le « crochet ».
Request collapsing (dedupe) : protéger l'origin contre une « tempête » de GET identiques.

Protocoles et caractéristiques

HTTP/2 : multiplexage, priorités ; tenez 'ALPN : h2'.
HTTP/3/QUIC : résistance à la perte/au gitter ; ouvrez le UDP/443, regardez MTU/PMTUD.
gRPC: health-checks, streaming, deadlines; le proxy prend en charge 'grpc-status'.
WebSocket/SSE : connexions longues-livrées, idle-tiemauts alphabétisés et limites.

Observabilité et SLO

Métriques :

L4/L7: `p50/p95/p99`, ошибки (`4xx/5xx/Grpc-codes`), `open_conns`, `CPS/RPS`, `retry_rate`.
TLS : version/chiffrement, p95 handshake, résumption.
Routage : parts par route/cluster, outlier-ecriptions.
Rate-limit/WAF : actionnements/FP-rate.
Logs : accès (sans PII), raisons de routage, en-têtes de trace.
Tracés : « traceparent »/B3, sample.

SLO (exemples) :

p95 API TTFB ≤ 250-300 ms ; erreur L7 ≤ 0. 5%.
Le succès des canaries (pas de dégradation des métriques) ≥ 99 % des lancements.
FP-rate WAF ≤ 0. 1%.

Configues types

Nginx (reverse proxy, HTTP/2, canari, compression)

nginx map $http_x_canary $upstream_pool {
default "stable";
~^1$ "canary";
}

upstream api_stable { zone zst 64k; server 10. 0. 1. 10:8443; server 10. 0. 1. 11:8443; keepalive 256; }
upstream api_canary { zone zcn 64k; server 10. 0. 2. 10:8443; keepalive 64; }

server {
listen 443 ssl http2 reuseport;
server_name api. example. com;

ssl_protocols TLSv1. 2 TLSv1. 3;
ssl_stapling on; ssl_stapling_verify on;
add_header Strict-Transport-Security "max-age=31536000" always;

basic limits/protection client_max_body_size 10m;
sendfile on; brotli on; gzip on;

location / {
proxy_http_version 1. 1;
proxy_set_header Host $host;
proxy_set_header X-Request-Id $request_id;
proxy_set_header X-Forwarded-Proto https;
proxy_connect_timeout 500ms;
proxy_read_timeout 5s;
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 1; # Retrays are limited to proxy_pass https://api_$upstream_pool;
}
}

HAProxy (JWT-verify + mTLS au backend + rate-limit)

haproxy frontend fe_https bind:443 ssl crt /etc/haproxy/certs/ alpn h2,http/1. 1 http-request set-header X-Request-Id %[unique-id]
http-request lua. jwt_verify # external verification script JWT stick-table type ip size 1m expire 10m store http_req_rate (10s)
http-request deny if { src_http_req_rate(10s) gt 100 }

default_backend be_api

backend be_api balance roundrobin option httpchk GET /healthz server s1 10. 0. 1. 10:8443 check ssl verify required ca-file /etc/haproxy/ca. pem server s2 10. 0. 1. 11:8443 check ssl verify required ca-file /etc/haproxy/ca. pem

Envoy (JWT + weighted routes + outlier detection)

yaml static_resources:
listeners:
- name: https address: { socket_address: { address: 0. 0. 0. 0, port_value: 443 } }
filter_chains:
- filters:
- name: envoy. filters. network. http_connection_manager typed_config:
"@type": type. googleapis. com/envoy. extensions. filters. network. http_connection_manager. v3. HttpConnectionManager stat_prefix: ingress route_config:
virtual_hosts:
- name: api domains: ["api. example. com"]
routes:
- match: { prefix: "/" }
route:
weighted_clusters:
clusters:
- { name: api-stable, weight: 95 }
- { name: api-canary, weight: 5 }
http_filters:
- name: envoy. filters. http. jwt_authn typed_config: { "@type": type. googleapis. com/envoy. extensions. filters. http. jwt_authn. v3. JwtAuthentication }
- name: envoy. filters. http. router clusters:
- name: api-stable connect_timeout: 0. 5s type: STRICT_DNS lb_policy: ROUND_ROBIN outlier_detection: { consecutive_5xx: 3, interval: 2s, base_ejection_time: 30s }
transport_socket:
name: envoy. transport_sockets. tls
- name: api-canary connect_timeout: 0. 5s type: STRICT_DNS lb_policy: ROUND_ROBIN transport_socket:
name: envoy. transport_sockets. tls

Traefik (itinéraires rule-based, concept)

yaml http:
routers:
api:
rule: "Host(`api. example. com`) && PathPrefix(`/v1/`)"
service: api-svc tls: { certResolver: letsencrypt }
services:
api-svc:
loadBalancer:
servers:
- url: "https://10. 0. 1. 10:8443"
- url: "https://10. 0. 1. 11:8443"

Performances du proxy

Connection pooling et keepalive aux backends, limite de connexions par instance.
Reuseport, pin CPU/IRQ, tampons de socket suffisants.
TLS : ECDSA + chaînes courtes, resumption ≥ 70 %, HTTP/2/3 inclus.
Cache dans le proxy pour les réponses « à chaud » (y compris 304-validation).
Warm-up : échauffement des connexions DNS/TLS avant les pics.

DR et tolérance aux pannes

L'automate des nœuds dégradés ('outlier-ejection').
Health-checks L4/L7 (HTTP body-jeton version).
Fail-open/Fail-closed - choisissez consciemment pour les chemins de paiement/critiques.
Mode Shadow avant de passer au nouveau service.
Runbooks : « effondrement du cluster », « boucle des radiés », « fuite des connexions », « tempête des rétrograves ».

Chèque d'implémentation

la Stratification : Edge → Ingress/API-GW → Mesh/Egress, les rôles et les frontières de la responsabilité.
Politiques de routage : host/path/header/weight, canary/blue-green, shadow.
Sécurité : TLS 1. 3, mTLS pour les voies sensibles, JWT/OAuth2, WAF.
Taimauts/retrai/SV : valeurs uniques, idempotence, retry-budget.
Cash/Rate-limit/Request-collapsing le cas échéant.
Observabilité : métriques/logs/tracés, identifiants de corrélation.
SLO : p95/erreurs/ressources ; alerte sur les défaillances de périmètre.
IaC/GitOps : procurations dans le référentiel, versions canaries, rollback rapide.
Tests : itinéraires e2e, scénarios chaos, charge devant ivents.

Erreurs typiques

La moissonneuse proxy « magique » sans séparation des rôles → un RCA complexe et un rayon blast élevé.
Les retraits pour les demandes non identifiables → les transactions en double.
Pas de normalisation des titres/URL → cache-poisoning et clés incorrectes.
Sticky-sessions sans plans de failover → la soudure sur une instance dégradée.
L'absence de 'traceparent '/' x-request-id' → ne peut pas coroller les problèmes.
Dur 301/302 au niveau du proxy → « boucles » et perte de contrôle des versions de l'API.

Spécificité pour iGaming/fintech

Paiements/PSP : egress-gateway dédié avec mTLS, délais stricts, clés idempotent, listes blanches IP/ASN.
Pics (matchs/tournois) : canary/weighted, itinéraires gris pour les bots, GET kesh agressif, protection origin contre la « tempête ».
Réglementation/logique : enregistrez les versions des politiques et les raisons de l'itinéraire dans les logs d'audit ; Minimiser le PII.
Fournisseurs de contenu : consistent-hash par clé fournisseur pour la localisation cache et la distribution uniforme.

Mini-playbooks

1) Sortie de l'API Canaries

1. Inclure 5 % de poids par 'api-canary' ; 2) surveillance p95/erreurs ; 3) accroître la part ; 4) retour automatique en cas de dégradation.

2) Retrait d'urgence d'un nœud dégradé

1. Outlier-ejection ou « drain » manuel ; 2) vérification du pool et du hit de kesh ; 3) RCA post-incident.

3) Fonction de miroir

1. Activer le shadow sans affecter les réponses ; 2) comparer les métriques/le diff des réponses ; 3) décider de changer.

4) La tempête des retraits

1. Abaisser les délais et les délais ; 2) activer la request-collapsing ; 3) bouchons/cache locaux ; 4) stabiliser l'origin.

Total

Une couche proxy bien conçue est la séparation des rôles, le routage déterministe, les politiques robustes (temporisation/rétraction/SV), la sécurité (mTLS/JWT/WAF) et l'observabilité. Fixez les configurations dans l'IaC, utilisez les canaries et le shadow, mesurez le SLO - et votre plate-forme sera évolutive, prévisible et protégée même aux heures de pointe les plus chaudes.