Terminação SSL e balanceadores

Resumo breve

A terminação SSL/TLS alivia a carga cripto das aplicações e abre caminho para o roteiro L7, WAF, rate-limit, mTLS, canários. Soluções-chave: onde completar TLS (edge/ingress/dentro do mesh), como equilibrar (L4 vs L7), quais perfis de código usar, como atualizar certificados sem downthame e como manter p95 laticínios e erros no SLO.

Onde concluir TLS

Na borda (CDN/Anycast/WAF): latência mínima ao usuário, proteção global, controle de kesh/bot. A seguir, ré-encrypt até o backand.
No insress L7 (Nginx/Envoy/HAProxy/ALB): rotação fina por URI/cabeçalho, mTLS, validação JWT.
TLS (passthrough L4): quando você precisa de end-to-end mTLS até pod/serviço (por exemplo, área de complacência rigorosa).
Serviço Mesh (Envoy/Istio/Linkerd): mTLS automatizado dentro do cluster, política e telemetria.

Prática: mais frequente - edge terminate → re-encrypt antes do ingress; para PII/pagamentos - mTLS para serviço.

L4 vs L7 balanceamento

L4 (TCP/UDP): atraso mínimo, simples health-checks (porta/TSD), passthrough TLS. Adequado para gRPC em TLS com falta de L7-Fic.
L7 (HTTP/HTTPS/HTTP3): Roading por hóspedes/caminhos/cabeçalhos/cookies, WAF, rate-limits, canários, sessões de sticky, retrações/temporizadores.

TLS: versões, chaves, códigos

Versões: TLS 1. 3 em todo o lado, TLS 1. 2 como fallback. Desliga 1. 0/1. 1.
Chaves/sertos: ECDSA (P-256) - mais rápido que RSA; pode ser duplo-pilha (ECDSA + RSA) para o velho.
ALPN: `h2` и `http/1. 1`; para HTTP/3 - 'h3' (QUIC/UDP).
OCSP Stapling: incluir; HSTS em domínios públicos.
Pulas de chave: armazenamento em KMS/HSM; extensão automática (ACME/árvore de confiança).
0-RTT (TLS 1. 3): Incluir por pontos (GET/idumpotentes), levar em conta o risco replay.

Perfil de código básico (TLS 1. 2): `ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-CHACHA20-POLY1305`

Desempenho do TLS

Resumpition: sessão tickets/IDs - reduzem o valor handshake.
O ECDSA + ChaCha20 ajuda no celular/sem AES-NI.
OCSP Stapling + cadeias curtas reduzem p95.
HTTP/2/3: multiplexagem, menos conexões → menos p95.
Offload: pin núcleos CPU sob crypto, incluir reuseport, tune socket-buffers.

Segurança

mTLS: exija um cliente-cert para as operadoras/API; CRL/OCSP para retirada.
SNI/ECH: SNI - padrão; ECH (Encr. ClientHello) esconde o domínio (se suporta o provedor edge).
Strict Transportation Security (HSTS): domínios de prod, com cuidado no início.
TLS entre hop-ami: re-encrypt antes do serviço, mesmo dentro do DC (Zero-Trust).
Rate-limit/grey-wes: em L7 protegem o api contra bots/brutos.

Observabilidade e SLO

SLO (exemplos)

p95 TLS-handshake ≤ 80-120 ms (global), p95 TTFB ≤ 200-300 ms.
Erros TLS (handshake/peer-verify) ≤ 0. 1%.
A proporção de MPS ≥ de 70% para visitas repetidas.

Métricas

`handshake_time`, `tls_version`, `alpn`, `cert_expiry_days`, `ocsp_staple_status`.
L7: `p50/p95/p99`, `5xx`, `429`, `upstream_rq_time`, `retry_budget`.
Capacity: conectórios ativos, CPS (connectividades por segundo), RPS.

Configs típicos

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 + stickiness + mTLS para 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 do cliente + canário)

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 (conceito)

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-check, SNI até pod.
CloudFront/Cloudflare: TLS edge + WAF + Gestão de Bot; origin — HTTPS only.

Atualizar certificados sem downthame

ACME (Let' s Encrypt/CA privado) com atualização automática e reinício a quente (Nginx 'reload', Envoy SDS).
Certificados duplos (ECDSA + RSA) nas migrações.
Controle de cadeias: verificação de CA intermediário; OCSP stapling após rotação.
Alerts: 'cert _ expedy _ days <21' e 'ocsp _ status! = good'.

Health-checks e rotação

L4: TCP connect, TLS handshake.
L7: HTTP 200/JSON marca versão, gRPC health.
Políticas: failover, weighted, latency, consent-hash (cookies/IP) para sticky.
Retrações/temporizações: equilíbrio entre sustentabilidade e duplicação de solicitações (idempotidade!).

Kubernetes-pattern

Origins Controler (Nginx/Envoy/HAProxy): terminação em Ingresso, 'ExternalDNS' em gravações DNS, 'cert-management' em ACME.
Gateway API: SLSroute/HTTPRoute declarados com canários.
Serviço Mesh: mTLS automático de pod↔pod, políticas de 'PeerAuthentication '/' DestinationRule'.

Folha de segurança de cheque

TLS 1. 3 incluído; 1. 0/1. 1 desligado.
Códigos modernos; Os sertões ECDSA estão onde o suporte permite.
OCSP stapling, cadeias completas, HSTS.
mTLS para almirantes/interconectados; receituário de sertões de clientes.
Filtros rate-limit/bot na borda; proteção contra slowloris/oversized headers.
Re-encrypt a backends (Zero-Trust).
Segredos/chaves no KMS/HSM; rotação e auditoria da emissão.

Observabilidade e alertas

Метрики: TLS handshakes/sec, failure rate, session resumption rate, OCSP, p95/99, open conns, CPS, RPS.
Logi: SNI/ALPN/versão TLS, cipher, certificado de cliente (para mTLS), códigos upstream, latency breakdown.
Alerts: altura de '5xx/525', queda de resposta, 'cert _ expedy _ days', 'ocsp _ failed', excesso de p95, saltos '429'.

Erros típicos

Terminação na borda e plain HTTP dentro sem proteção.
Cadeias CA excessivamente longas → crescimento p95 handshake.
Nenhum OCSP stapling → bloqueio em clientes/navegadores.
Sessões de Sticky sem contar failover → «derrapagem» em um nó degradado.
O 0-PTT está ativado para as solicitações modificadoras → risco de reaproveitamento.
Falta de sertões hot-reload → draps de segundos na rotação.

Especificidades para iGaming/Fintech

Picos (torneios/jogos): aquecimento de sessões TLS (pré-connect), cadeias curtas, alta proporção de resposta, HTTP/2/3 para frentes.
Passagens de pagamento/PSP: mTLS, ciphers/versões rigorosas, pinned CA, domínios individuais/ALB com regras rígidas.
Antifrod/bot-filtros: L7-rate-limit por IP/ASN/device-fingerprint, gray-vozes canários (challenge/capcha) em um domínio separado.
Regulação: HSTS, registros TLS auditados, relatórios de versões, resenhas de clientes sobre incidentes.

Mini playbooks

Lançamento de canário por L7-balanceador

1. Adicione o cluster 'api-canary' com peso de 5%; 2) acompanhe a r95/erros; 3) 5→25→50→100%; 4) desligamento automático na degradação.

Rotação de certificado de emergência

1. Carregue o novo cert/key; 2) 'reload' sem queda de conectórios (SDS/quente); 3) Verificação OCSP; 4) dashboard p95 handshake.

Ativar HTTP/3

1. Abra o UDP/443; 2) adicione ALPN 'h3'; 3) métricas individuais QUIC loss/PTT; 4) A/B em relação aos clientes.

Resultado

Terminação SSL eficiente é um perfil TLS moderno, local certo para terminar, rotação L7 inteligente, observabilidade e segurança rigorosa (mTLS, HSTS, re-encrypt). Fixe tudo no IaC, automatize rotações, mede p95/erros e use canários - assim a frente sobreviverá aos picos e será previsivelmente rápida e segura.