Livelli proxy e routing reverse

Breve riepilogo

Il livello proxy è il bus frontale della piattaforma: completa TLS, certifica i clienti, distribuisce il traffico, arrotonda i picchi e rende il rilascio sicuro (i canarini, blue-green). Set minimo di maturità: strazione chiara dei ruoli proxy, regole di instradamento definite, controllo timeout/retrai, cache + rate-limit, osservabilità completa e automazione.

Tassonomia proxy

Forward proxy - Traffico in uscita client/servizi all'esterno (egress), filtri/mirroring, DLP.
Reverse proxy - Accetta le richieste esterne e installa ai backend (il nostro focus principale).

Livelli nel tracciato prod:

1. Edge/CDN/WAF (Anycast, bot, cash)

2. L7 Ingress/API-gateway (routing, autenticazione, criteri)

3. Livello di servizio/Mesh (sidecar) per east-west, mTLS e retrai

4. Egress-gateway per le integrazioni in uscita (PSP, partner)

Routing (L4/L7) e algoritmi

L4 (TCP/UDP, passthrough TLS) - Ritardo minimo, senza comprensione HTTP.
L7 (HTTP/1. 1, HTTP/2, HTTP/3/gRPC): regole su host/path/header/cookie, trasformazione, WAF, cash.

Algoritmi:

Round-robin/Least-connection/EWMA sono casi comuni.
Consistent-hash (cookie/ID) - Sticky sessioni e cache locale.
Header/Geo-/Latency-based - targeting per regione/provider, rapido.
Canary/Weighted - rollout graduale (5→25→50→100%).
Shadow/Mirroring è una copia del traffico sul nuovo servizio senza alcuna influenza sulle risposte.

Trasforma richieste/risposte

URL rewrite/redirect: unificazione dei percorsi, versioning ('/v1/ →/svc/v1/').
Intestazioni: regolarizzà X-Forwarded-For/Proto/Host ", aggiungi" traceparent "/" x-sollest-id ", e filtra di più.
CORS/CSRF: centralizza in gateway, non generare impostazioni in ogni servizio.
Compressione/Decompressione: Brotli/gzip, controllo per tipo.
Body-limits e protezione contro slowloris/oversized headers.

Autenticazione e protezione

TLS 1. 3 + OCSP stapling + HSTS sui fronti esterni.
Admink, API operative, canali di partnership.
OAUTh2/OIDC - Autorizzazioni tramite gateway (token introspection/JWT-verify) per il passaggio a clims in upstream.
Chiavi/firme API (HMAC) per le integrazioni tra server e partnership.
Filtri WAF/bot: firme + regole comportamentali, greypass/goccia.
CSP/X-Frame-Options/Referrer-Policy - Intestazioni di sicurezza al bordo.

Affidabilità: retrai/timeout/SAN

Timeout: connect/read/write su L4/L7, un'unica regola (ad esempio, connect 500ms, read 3-5s per API).
Retrai: solo Idempotent («GET/HEAD»), limite tempo/quantità, «retry-budget».
Circuito-breaker - Limitazioni a query/errori simultanei, guasto rapido e degrado.
Outlier detection - Esclude le istanze «cattive» dal pool.
Backoff + jitter per non creare «effetto gregge».

Kash e controllo del traffico

Kesh L7: statica/semidinamica (cataloghi, confighi), 's-maxage' + 'stale-while-revalidate'.
Rate-limit/Quota: per IP/ASN/device/cookie, contatore distribuito (Redis/Rate-Service).
Sessioni Sticky: cookie/consistent-hash; tenete conto di failover e sovraccarico.
Sollest collapsing (dedupe) - Protegge l'origin da una tempesta identica a GET.

Protocolli e caratteristiche

HTTP/2: multiplexing, priorità; tenete'ALPN: h2 '.
HTTP/3/QUIC: resistenza alla perdita/jitter; aprite UDP/443, seguite MTU/PMTUD.
gRPC: health-checks, streaming, deadlines; il proxy deve supportare «grpc-status».
WebSocket/SSE: connettori long-lived, idle-timeout ben abili e limiti.

Osservabilità e SLO

Metriche:

L4/L7: `p50/p95/p99`, ошибки (`4xx/5xx/Grpc-codes`), `open_conns`, `CPS/RPS`, `retry_rate`.
TLS: versione/cifratura, p95 handshake, respumption.
Routing: quote di route/cluster, outlier-ejtions.
Rate-limit/WAF: attivazioni/FP-rate.
Logi: accesso (senza PII), motivi di instradamento, intestazioni di traccia.
Trail: «traceparent »/B3, sampling.

SLO (esempi):

API p95 TTFB 250-300 ms; errore L7 0. 5%.
Il successo delle canarie (senza il degrado delle metriche) ha raggiunto il 99% dei lanci.
FP-rate WAF ≤ 0. 1%.

Configi tipici

Nginx (reverse proxy, HTTP/2, canarino, compressione)

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 a 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 (rotte 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"

Prestazioni proxy

Connection pooling e keepalive ai backend, il limite di connessione per istanza.
Reuseport, pin CPU/IRQ, buffer socket sufficienti.
TLS: ECDSA + brevi catene, Respumption 70%, HTTP/2/3 abilitato.
Cache proxy per le risposte hot (ad esempio 304-convalida).
Warm-up: riscaldamento DNS/TLS/connettori prima dei picchi.

DR e disponibilità in errore

Controllo automatico dei nodi degradati («outlier-ejection»).
Health-checks L4/L7 (HTTP body).
Fail-open/Fail-closed - Scegli consapevolmente per i percorsi di pagamento/criticità.
Modalità Shadow prima di passare al nuovo servizio.
Runbooks: «collasso del cluster», «loop di reading», «fuga di connettori», «tempesta di retro».

Assegno foglio di implementazione

Strazione: Edge Ingress/API-GW da Mesh/Egress, ruoli e limiti di responsabilità.
Criteri di instradamento: host/path/header/weight, canary/blue-green, shadow.
Protezione: TLS 1. 3, mTLS per vie sensibili, JWT/OAuth2, WAF.
Timeout/retrai/SAN: valori uniformi, idampotenza, retry-budget.
Kash/Rate-limit/Sollest-collapsing se necessario.
Osservabilità: metriche/logi/trailer, identificatori correlation.
SLO: p95/errori/risorse; Gli alert per i guasti perimetrali.
IaC/GitOps: conferme proxy nel repository, release canarie, rollback rapido.
Test: percorsi e2e, script chaos, carico di lavoro davanti agli iventi.

Errori tipici

Il proxy «magico» senza separazione dei ruoli è un RCA complesso e un raggio blast alto.
I retrai per le richieste non idonee includono duplicati delle transazioni.
Nessuna normalizzazione intestazione/URL di cache-poisoning e chiavi non valide.
Sessioni Sticky senza piani di failover per l'infestazione in un'istanza degradata.
Nessun «traceparent »/« x-sollest-id» può essere risolto.
Rigidi 301/302 a livello proxy e perdita del controllo delle API.

Specifico per iGaming/Fintech

Pagamenti/PSP: egress-gateway dedicato con mTLS, timeout rigoroso, chiavi idipotenti, white list IP/ASN.
Picchi (partite/tornei): canary/weighted, percorsi grigi per i bot, aggressivo kash GET, protezione origin da «tempesta».
Regolazione/loging: fissa le versioni dei criteri e le ragioni del percorso nei loghi di controllo Ridurre al minimo il PII.
Provider di contenuti: consistent-hash in chiave di provider per la cache e la distribuzione regolare.

Mini playbook

1) Rilascio canarino API

1. Includere il 5% del peso su «api-canary»; 2) monitoraggio p95/errori; 3) espandere la quota; 4) recupero automatico in caso di degrado.

2) Rimozione di emergenza di un nodo degradato

1. Outler-ejection o manuale «drain»; 2) Controllo del pool e dell'hit di cache 3) RCA post-incidente.

3) Mirroring funzione

1. Abilita shadow senza influire sulle risposte 2) confrontare le metriche/diff delle risposte; 3) decidere se cambiare.

4) Tempesta di retrai

1. Riduzione dei limiti di tempo e retry 2) Abilitare il sollest-collapsing; 3) stub/cache locali; 4) stabilizzare origin.

Totale

Uno strato proxy ben progettato è la divisione dei ruoli, il instradamento definito, le regole affidabili (timeout/retrai/SAN), la sicurezza (mTLS/JWT/WAF) e l'osservabilità. Fissare le configurazioni nel IaC, usare i canarini e lo shadow, misurare lo SLO - e la piattaforma sarà scalabile, prevedibile e protetta anche nei picchi più caldi.