Otimização de ferro e recursos

Resumo curto

A otimização não é «acelerar uma coisa», mas equilibrar a produtividade ↔ o custo ↔ a confiabilidade ↔ a energia. Passos básicos: medir SLI/SLO e perfis, encontrar estreitos, «dimensionar» adequadamente a potência, automatizar a escala e fixar melhorias em imagens/listas/políticas.

Objetivos e princípios

De UX para ferro: Começamos pelo SLO (p95 latency, sucesso de operações) → procuramos um recurso limitador.
Tamanho correto (rightsizing): recursos e tipos de instância sob a natureza da carga.
Dinheiro e intimidade: reduza as caminhadas «caras» para armazéns e redes.
Automação: autoscaling, políticas de ciclo de vida, IaC.
Observabilidade: métricas de quatro sinais, perfis CPU/alloc, trailing.
Segurança = desempenho: mTLS/assinaturas/limites - com aceleração de hardware sempre que possível.

CPU e planejamento

Tarefas: Minimizar contêineres e falhas em dinheiro, levar em conta NUMA e interrupções.

NUMA conscientização: pinning por nó ('numactl --cpunodebind --membind'), para BD/corretores - fixar no nó.
IRQ/softirq: distribuir em núcleos (RSS/RPS), fixar filas quentes para o CPU sem concorrência com os workers.
Hiperflexividade: para «sensíveis à latência» - fixar os workers nos núcleos físicos.
Contexto-pergaminho: reduzir através de longas filas/batchings/asinhrão.
Compiladores/JIT: inclua PGO/LTO (C/C + +), Graal/HotSpot perfis (Java), 'GOMAXPROCs' e seleção de worker (Go).

bash
IRQ affinity: bind NIC queue to specific CPU echo 2 >/ proc/irq/XX/smp_affinity # kernel mask
Softirq balance on sysctl -w net network cores. core. netdev_budget=600 sysctl -w net. core. netdev_max_backlog=5000

Memória e controle de alocações

THP/HugePages: para JVM/DB - normalmente desativar THP e usar hugepages manualmente (reduz falhas de TLB).
Balanço NUMA: Para o stateful, fixar a memória no nó local.

• JVM: G1/ZGC, '-Xms = -Xmx' igual, razoável 'MaxGCPauseMillis'.
• Go: 'GOGC' (começar com 100-200), evitar alocações extras, perfis 'pprof'.
• Python: usar 'uvloop', 'asyncio', extensões C, pool de conexões.
• Swap/zswap: em venda normalmente swap off para serviços críticos; em nódulos de uso geral - zswap para cargas «suaves».

Armazenamento e I/O

Tipos de disco: NVMe sob hot-path, pool individual para logs/checkapoint/ritmo.
FS: XFS para arquivos/registros de base de dados maiores; ext4 para pequenos/versáteis.
FLASH/EC: RAID10 para atrasos baixos, RAID6/EC - sob dados frios.
Planejadores I/O: 'none '/' mq-deadline' para NVME.
Async/Batch: Agrupe os registros, use Write-Behind/Group-Commit.

bash fio --name=randread --filename=/data/test --size=20G --bs=4k \
--iodepth=64 --rw=randread --ioengine=libaio --numjobs=4 --time_based --runtime=60

Rede

MTU e offload: 9000 MTU no datacenter (se end-to-end), incluir GRO/LRO onde for permitido.
RSS/RPS/RFS: filas multicanais para NIC, distribuídas por núcleos; irqbalance - controle.
SO _ REUSEPORT: listen-socks escaláveis distribuídos por núcleos.
Temporizações de cliente e pulings: curto TCP-keepalive, limite de conectórios abertos, backpressure.
TLS: TLS 1. 3, instruções de hardware AES-NI, sessão resumpção, OCSP stapling.

bash sysctl -w net. core. rmem_max=268435456 sysctl -w net. core. wmem_max=268435456 sysctl -w net. ipv4. tcp_rmem="4096 87380 134217728"
sysctl -w net. ipv4. tcp_wmem="4096 65536 134217728"

GPU/FPGA/SmartNIC (se apropriado)

GPU: Infernização antifrode, recomendação, CPI; vigiar 'util', 'mem', 'sm _ efficiency'.
SmartNIC/eBPF/DPDK: descarga L4/L7, filtragem, telemetria sem transitar para o núcleo.
Energoprofili: fixar as frequências sob latência estável; evitar os agressivos power-save.

Aplicativos e RCBD

Pool de conexões: Limite a 'max _ conns', aplicar a conexion pooling (PgBouncer/Hikari).
Índices/Planeadores: Perfis EXPLAIN/ANALYZE que cobrem índices, particionamento.
Armazenamento em dinheiro: Redis/em-processo em dinheiro, CDN para estático, edge-dinheiro para API quente.
Idempotidade e filas: evite cascatas de retais, inclua dedup.
Gzip/Brotli: compressão de respostas com valor CPU; escolha o balanço.

Contêineres e Kubernetes

Requests/Limits и bin-packing

Requests = «garantia», Limits = «teto». Limits incorretos por CPU → throttling e p99.
Leve em conta a carga burst (picos de torneios/jogos) - reserva em p95.
Bin-packing: separe os pool de nós (latency-crit, batch, GPU, spot). Use topologia (anti-affinity, spread).

Escala automática

HPA em métricas custômicas (RPS/p95, não CPU).
VPA para «longas vidas» e «níticas».
Cluster Autoscaler + grupos node individuais (on-demand/spot).
KEDA para cargas de eventos (filas, Kafka, cron).

Planejador e gerentes

CPU Gerente: 'static' para o pinning de núcleos completos latency-critic.
Topology Gerente: alinhamento por NUMA.
Plugins: para BD/baixa latência e GPU/FPGA.

yaml apiVersion: autoscaling/v2 kind: HorizontalPodAutoscaler metadata: { name: api-gw }
spec:
scaleTargetRef:
apiVersion: apps/v1 kind: Deployment name: api-gw minReplicas: 6 maxReplicas: 60 metrics:
- type: Pods pods:
metric:
name: http_latency_p95_ms target:
type: AverageValue averageValue: 120

FinOps e custo

Perfis de tarifas: selecione as instâncias de CPU/RAM/disco/rede (compute-optimized, memory-optimized, armazenamento-optimized).
Spot/Preemptible: para batch/estagiário/caju com redundância multifacetada.
Reserva/Savings: Reservas de 1 a 3 anos para a parte «permanente».
Quente/frio: tiered-armazenamento, objeto de arquivo, retino de logs.
Recursos Idle: noite/fim de semana, paragens de ambientes não críticos.

Eficiência energética (GreenOps)

Power profiles: performance vs balanced por serviços.
Co-colocação: compactação em relógios «frios», desligamento de nós não utilizados.
KPI: watts para consulta, p95/watts, CO₂ - métricas do provedor.

Observabilidade e testes

Метрики: CPU steal/throttle, `cycles/instructions`, LLC miss, RSS/working set, page faults, disk lat p95/99, NIC drops, retransmits.
Tracing, trailers distribuídos para as vias douradas.
Perfil: «pprof »/ .
Testes de carga: orientação SLO, com operações de mix real, fase de aquecimento, injeção fault.

promql
CPU throttling доля sum(rate(container_cpu_cfs_throttled_seconds_total[5m])) by (pod)
/ sum(rate(container_cpu_usage_seconds_total[5m])) by (pod)

Network loss sum (rate (node_net_dropped_total[5m])) by (instance)

Folha de cheque de otimização

• Definidos SLO e «caminhos dourados» (API/pagamentos/pagamentos).
• Os perfis CPU/alloc/IO/redes foram coletados e foram encontrados estreitos top-N.
• NUMA/IRQ/RSS são configurados em nódulos críticos latencos.
• THP off (se necessário), hugepages para serviços BD/Java.
• NVMe para dados quentes, XFF/IO-sched configurados, fio-bench confirmado.
• Pilha de rede: MTU, RPS/RFS, SO _ REUSEPORT; temporizadores/pulas.
• Kubernetes: Recalls são corretos, Limits não são sufocados, HPA em métricas de negócios, VPA/CA incluídos.
• Armazenamento e CDN em caminhos «caros»; Redis/edge-dinheiro.
• FinOps: rightsizing/reserva/pool de spot; Parar os ambientes idle.
• Autopeças de desempenho em CI, regressão em p95/p99.

Especificidades para iGaming/Fintech

Picos programados: torneios/jogos/promoções → «elástico» pool de frentes, pré-aquecimento de dinheiro/CDN, HPA RPS/latência.
Pagamentos e pagamentos: IP/domínios de ouro individuais, filas prioritárias, isolação de recursos (taants/tolerações), reserva de base de dados.
Antibot/antifrod: modelos heavy - em workers GPU; screening online ≤ 50 ms p95; O dinheiro das fichas.
Regulação: logs e criptografia imutáveis não devem quebrar o SLO - inclua acelerações de hardware e piplyne asincrona.

Mini-playbooks

1. Encurtar burn-rate SLO; 2) perfis 'cpu/alloc'; 3) reversão/fichflag; 4) aumentar as réplicas/API em dinheiro; 5) RCA e fixação do teste.

1. Aquecer CDN/dinheiro; 2) levantar o minReplicas; 3) incluir os limites burst; 4) espalhar as filas; 5) ativar o modo read-only para funções secundárias.

Erros típicos

Limits CPU «sufocam» os orcloados de pico → p99 alto.
Pool de nódulos inválido: misturam latency critic e batch.
Nenhuma configuração de NUMA/IRQ em BB/corretores.
«Curando sintomas» (adicionando CPU) em vez de corrigir algoritmos/dinheiro/SQL.
O HPA por CPU em vez de RPS/latency → vai chegar tarde.
Não há testes de desempenho em CI regressão em venda.

Resultado

Otimização é um trabalho de sistema: mede o SLI/SLO, perfilhe, corrija algoritmos, configure o ferro (NUMA/IRQ/IO/rede), dimensione os recursos corretamente e automatize o zoom. Estabeleça melhorias em modelos (imagens, listas, políticas), controle de custos e energia - e sua plataforma permanecerá rápida, econômica e sustentável, mesmo em picos extremos.