Terminaison SSL et équilibreurs

Résumé succinct

La terminaison SSL/TLS supprime la charge crypto des applications et ouvre la voie au routage L7, WAF, rate-limit, mTLS, versions canaries. Solutions clés : où terminer TLS (edge/ingress/in mesh), comment équilibrer (L4 vs L7), quels profils de cryptage utiliser, comment mettre à jour les certificats sans downtime et comment garder p95 latences et erreurs dans SLO.

Où terminer TLS

Au bord (CDN/Anycast/WAF) : latence minimale pour l'utilisateur, protection globale, contrôle cache/bot. Ensuite, re-encrypt jusqu'au backend.
Sur ingress L7 (Nginx/Envoy/HAProxy/ALB) : routage fin par URI/en-têtes, mTLS, validation JWT.
TLS de bout en bout (passthrough L4) : lorsque vous avez besoin d'un end-to-end mTLS à un pod/service (par exemple, une zone de conformité stricte).
Service Mesh (Envoy/Istio/Linkerd) : mTLS automatisé dans le cluster, la politique et la télémétrie.

Pratique : plus souvent - edge terminate → re-encrypt to ingress ; pour les IPI/paiements - mTLS avant le service.

L4 vs L7 équilibrage

L4 (TCP/UDP) : délai minimum, tests de santé simples (port/TSR), passthrough TLS. Convient pour gRPC sur TLS en cas de pénurie de L7 fich.
L7 (HTTP/HTTPS/HTTP3) : routage par hôte/chemin/en-têtes/cookies, WAF, rate-limits, versions canaries, sticky-sessions, retrai/timaouts.

TLS : versions, clés, codes

Versions : TLS 1. 3 partout, TLS 1. 2 comme fallback. Débranchez 1. 0/1. 1.
Clés/serts : ECDSA (P-256) - plus rapide que RSA ; peut-être une double pile (ECDSA + RSA) pour l'ancien.
ALPN: `h2` и `http/1. 1`; pour le HTTP/3, « h3 » (QUIC/UDP).
Stapling OCSP : inclure ; HSTS sur les domaines publics.
Pools de clés : stockage dans KMS/HSM ; renouvellement automatique (ASME/arbre de confiance).
0-RTT (TLS 1. 3) : inclure ponctuellement (GET/idempotent), prendre en compte le risque de replay.

Profil de chiffrement de base (TLS 1. 2): `ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-CHACHA20-POLY1305`

Performances TLS

Resumption : tickets de session/IDs - réduisent le coût handshake.
ECDSA + ChaCha20 aide sur mobile/sans AES-NI.
OCSP Stapling + chaînes courtes réduit p95.
HTTP/2/3 : multiplexage, moins de connexions → en dessous de p95.
Offload : pin CPU core sous crypto, activer les tampons reuseport, tune socket.

Sécurité

mTLS : exiger un client-cert pour les opérateurs Amiral/API ; CRL/OCSP pour rappel.
SNI/ECH : SNI est la norme ; ECH (Encr. ClientHello) cache le domaine (si le fournisseur edge le prend en charge).
Strict Transport Security (HSTS) : les domaines pro, avec prudence au départ.
TLS entre hop-ami : re-encrypt avant le service, même au sein de DC (Zero-Trust).
Rate-limit/grise-bœuf : sur L7, protéger les apis contre les bots/brutforce.

Observabilité et SLO

SLO (exemples)

p95 TLS-handshake ≤ 80-120 ms (global), p95 TTFB ≤ 200-300 ms.
Erreurs TLS (handshake/peer-verify) ≤ 0. 1%.
La proportion de mpshen ≥ 70 % pour les visites répétées.

Métriques

`handshake_time`, `tls_version`, `alpn`, `cert_expiry_days`, `ocsp_staple_status`.
L7: `p50/p95/p99`, `5xx`, `429`, `upstream_rq_time`, `retry_budget`.
Capacity : connexions actives, CPS (connexions per second), RPS.

Configues types

Nginx (L7 terminate + HTTP/2 + OCSP stapling)

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

ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:...:ECDHE-RSA-CHACHA20-POLY1305';
ssl_ecdh_curve X25519:P-256;
ssl_certificate   /etc/ssl/cert.pem;    # полная цепочка ssl_certificate_key /etc/ssl/key.pem;
ssl_stapling on; ssl_stapling_verify on;
ssl_session_cache shared:SSL:50m; ssl_session_timeout 1d;

add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

location / {
proxy_set_header Host $host;
proxy_set_header X-Forwarded-Proto https;
proxy_pass https://upstream_pool;
}
}

upstream upstream_pool {
zone backends 64k;
server 10.0.1.10:8443 max_fails=3 fail_timeout=10s;
server 10.0.1.11:8443 max_fails=3 fail_timeout=10s;
keepalive 256;
}

HAProxy (L7 terminate + stick....+ mTLS au backend)

haproxy frontend fe_https bind:443 ssl crt /etc/haproxy/certs/ alpn h2,http/1.1 mode http http-response set-header Strict-Transport-Security max-age=31536000 default_backend be_api

backend be_api mode http balance roundrobin cookie SRV insert indirect nocache 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 (L7 terminate + mTLS du client + canari)

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.router transport_socket:
name: envoy.transport_sockets.tls typed_config:
"@type": type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext common_tls_context:
tls_certificates:
- certificate_chain: { filename: "/etc/tls/cert.pem" }
private_key:   { filename: "/etc/tls/key.pem" }
validation_context:       # mTLS (опционально)
trusted_ca: { filename: "/etc/tls/ca.pem" }
require_client_certificate: true

AWS ALB/NLB (concept)

ALB (L7 terminate): HTTPS listener 443 (TLS 1. 2/1. 3), target group HTTPs:8443, health-check `/healthz`, stickiness (cookie).
NLB (L4 passthrough) : TLS listener 443, TCP health-checks, SNI de bout en bout jusqu'au pod.
CloudFront/Cloudflare : TLS edge + WAF + Bot Management ; origin — HTTPS only.

Mise à jour des certificats sans downtime

ACME (Let's Encrypt/Private CA) avec mise à jour automatique et redémarrage à chaud (Nginx 'reload', Envoy SDS).
Double certificat (ECDSA + RSA) lors des migrations.
Contrôle des chaînes : vérification des AC intermédiaires ; L'OCSP stapling après rotation.
Alert : 'cert _ expiry _ days <21' et 'ocsp _ status ! = good'.

Health-checks et routage

L4: TCP connect, TLS handshake.
L7 : HTTP 200/JSON, gRPC health.
Politiques : failover, weighted, latency, consistent-hash (cookie/IP) pour sticky.
Retrai/Timaouts : équilibre entre durabilité et duplications de demandes (idempotence !).

Modèles de Kubernetes

Ingress Controller (Nginx/Envoy/HAProxy) : terminaison sur ingress, 'ExternalDNS' pour les enregistrements DNS, 'cert-manager' pour ACME.
API Gateway : déclaration TLSRoute/HTTPRoute avec canaris.
Service Mesh : automatique mTLS pod↔pod, stratégies au niveau 'PeerAuthentication '/' DestinationRule'.

Chèque de sécurité

TLS 1. 3 inclus ; 1. 0/1. 1 est éteint.
Codes modernes ; ECDSA-serts là où le support le permet.
stapling OCSP, chaînes complètes, HSTS.
mTLS pour les amiraux/interconnexions ; Revocation des serts clients.
Filtres rate-limit/bot sur le bord ; protection contre le slowloris/oversized headers.
Re-encrypt to backends (Zero-Trust).
Secrets/clés dans KMS/HSM ; rotation et audit de l'émission.

Observabilité et alertes

Метрики: TLS handshakes/sec, failure rate, session resumption rate, OCSP, p95/99, open conns, CPS, RPS.
Logs : SNI/ALPN/version TLS, cipher, certificat client (pour mTLS), codes upstream, latency breakdown.
Alerts : hauteur '5xx/525', baisse de résumption, 'cert _ expiry _ days', 'ocsp _ failed', excès p95, éclats '429'.

Erreurs typiques

Terminaison sur le bord et plain HTTP à l'intérieur sans protection.
Chaînes de CA trop longues → croissance p95 handshake.
Aucun stapling OCSP → verrouillage sur les clients/navigateurs.
Sticky-session sans tenir compte du failover → « collage » sur le nœud dégradé.
0-RTT inclus pour les demandes de modification → le risque de réapprovisionnement.
L'absence de sérmes hot-reload → des drops de secondes lors de la rotation.

Spécificité pour iGaming/fintech

Pics (tournois/matchs) : échauffement des séances TLS (pré-connect), chaînes courtes, forte proportion de respect, HTTP/2/3 pour les fronts.
Passerelles de paiement/PSP : mTLS, ciphers/versions strictes, CA pinned, domaines individuels/ALB avec des règles strictes.
Filtres antifrod/bot : L7-rate-limit par IP/ASN/device-fingerprint, bœufs gris canaris (challenge/capcha) sur un domaine distinct.
Réglementation : HSTS, journaux de paramètres TLS audités, rapports de version, rappels de serts clients par incident.

Mini-plejbouki

Sortie Canaries via l'équilibreur L7

1. Ajouter un cluster 'api-canary' pesant 5 %; 2) surveillez p95/erreurs ; 3) 5→25→50→100%; 4) auto-retournement en cas de dégradation.

Rotation d'urgence du certificat

1. Télécharger un nouveau cert/key ; 2) « reload » sans chute des connexions (SDS/remplacement à chaud) ; 3) vérification OCSP ; 4) dashboard p95 handshake.

Activation des HTTP/3

1. Ouvrez le UDP/443 ; 2) ajouter l'ALPN'h3 "; 3) des métriques individuelles QUIC loss/RTT ; 4) A/B pour la part des clients.

Total

Une terminaison SSL efficace est un profil TLS moderne, un bon emplacement d'achèvement, un routage intelligent L7, une observabilité et une sécurité stricte (mTLS, HSTS, re-encrypt). Enregistrez tout dans l'IaC, automatisez les rotations, mesurez les erreurs p95/et utilisez les canaris - de sorte que le front survivra aux pics et sera prévisible rapide et sûr.