Cloud-native e produção

TL;DR

Este galho fecha o ciclo: pega o jar que os galhos anteriores produziram e o leva a produção, num cluster — empacotamento em imagem (Dockerfile, Buildpacks, Jib), a JVM ciente do container, GraalVM Native Image, o contrato com o Kubernetes (probes, config, graceful shutdown), a observabilidade de operação (métricas, traces, logs), profiling sob carga e o pipeline de CI/CD. A tese que atravessa tudo: “production-ready” não é uma feature que se liga, é uma sequência de contratos — com o build, com a JVM, com o orquestrador, com o coletor de observabilidade. Cada nota é uma estação dessa linha de montagem. São 22 notas em 3 fases (Iniciado, Adepto, Magus).

Sobre este galho

A audiência é o desenvolvedor pleno avançando para senior, preparando-se para entrevista internacional de plataforma/SRE, que precisa não só “fazer subir no Kubernetes” mas defender cada decisão: por que distroless, por que MaxRAMPercentage e não -Xmx, quando native vale o trade-off, por que readiness e liveness são contratos distintos, e onde o trace daquele pod vai parar.

Este é o último galho do bloco de plataforma distribuída e produção. A fronteira-assinatura é sêxtupla — este galho linka, não re-explica:

• Galho 3 (JVM) — a mecânica interna de heap, GC, JFR, heap/thread dumps e tuning. Aqui só se decide quanto heap a JVM se concede do cgroup e quando disparar cada sinal; o como ler é lá.
• Galho 8 (Spring Core e Boot) — o Actuator e seus endpoints de saúde/métricas. Aqui se usa o Actuator como fachada; sua configuração-base é lá.
• Galho 15 (Build e tooling) — empacotamento do jar (fat/thin/layered) e supply chain/SBOM. Aqui se consome o layered jar e se escaneia a imagem; a mecânica de build é lá.
• Galho 16 (Microservices) — o tracing distribuído no código (spans, correlação). Aqui se opera o stack que recebe esse trace (Collector, sampling); a instrumentação em código é lá.
• Galho 13 (Testes) — JMH e microbenchmark. Aqui o profiling de produção é o contraponto operacional; o benchmark controlado é lá.
• Galho 6 (JavaFX) — empacotamento desktop (jlink, jpackage). Paralelo conceitual de “imagem auto-contida”, mas para outro alvo.

Iniciado

• Production-ready e cloud-native — a tese honesta — o que “pronto para produção” realmente significa e por que é uma sequência de contratos, não um checkbox.
• A JVM dentro de um container — container-awareness, cgroup, MaxRAMPercentage vs -Xmx fixo e o OOM-kill.
• Empacotando o app numa imagem — o panorama — o mapa das três formas de virar imagem (Dockerfile, Buildpacks, Jib) antes do detalhe de cada uma.

Adepto

• Dockerfile na prática — multi-stage e layered jar — multi-stage, extração do layered jar (jarmode=tools) e cache eficiente de camadas.
• Imagem enxuta e segura — distroless e scanning — bases distroless, usuário não-root e scan de CVE no pipeline.
• Buildpacks — imagem sem Dockerfile — Cloud Native Buildpacks/Paketo via spring-boot:build-image, convenção sobre configuração.
• Jib — imagem daemonless — construir imagem sem Docker daemon, ideal para CI.
• GraalVM Native Image — conceito e trade-offs — compilação AOT closed-world, o que se ganha (startup, footprint) e o que se perde.
• Native Image com Spring — Spring AOT na prática — Spring AOT, hints de reflexão/proxy e native:compile.
• Health e probes — o contrato com o orquestrador — liveness vs readiness como contratos distintos com o Kubernetes.
• Config e recursos no Kubernetes — ConfigMap/Secret → env, e requests/limits casados com o heap da JVM.
• Graceful shutdown e deploy sem downtime — drenar conexões no SIGTERM, preStop e terminationGracePeriodSeconds.
• Observabilidade de operação — o panorama e os 3 seams — os três sinais (métrica, trace, log) e onde cada seam (G3/G16/G17) começa e termina.
• Métricas em produção — Micrometer e Prometheus — Micrometer como fachada, /actuator/prometheus e o modelo de scraping.
• Dashboards e alertas — Grafana — visualizar as métricas e disparar alertas sobre elas.
• OpenTelemetry Collector e sampling de produção — operar o stack que recebe o trace; head vs tail sampling.
• Logs estruturados em produção — JSON no stdout, correlação por traceId e o coletor de logs.

Magus

• Profiling e diagnóstico sob carga — produção — o workflow de incidente sintoma → sinal → ferramenta, capturando sem derrubar o pod.
• Continuous profiling no cluster — Pyroscope e async-profiler — perfilar a frota inteira o tempo todo, com baixo overhead, correlacionado ao trace.
• CI-CD e o caminho até produção — o pipeline que constrói, testa, escaneia, publica e aplica o manifesto sem humano no terminal.
• Native vs JVM — a decisão honesta — o trade-off de plataforma decidido por perfil de carga, sem dogma e sem benchmark de blog.
• Capstone — do jar ao cluster — o order-service indo a produção ponta a ponta, com tabelas de decisão e cheatsheet problema → nota.

Rotas alternativas

• Completa: 01 → 02 → 03 → 04 → 05 → 06 → 07 → 08 → 09 → 10 → 11 → 12 → 13 → 14 → 15 → 16 → 17 → 18 → 19 → 20 → 21 → 22, em ordem.
• Entrevista internacional: 01 (a tese honesta) → 02 (JVM no container) → 08 (native, conceito) → 10 (probes) → 12 (graceful shutdown) → 13 (os 3 seams) → 18 (profiling sob carga) → 21 (native vs JVM) → 22 (capstone ponta a ponta).
• Empacotamento e imagem: 03 (panorama) → 04 (Dockerfile) → 05 (distroless e scanning) → 06 (Buildpacks) → 07 (Jib) → 08 (native, conceito) → 09 (Spring AOT).
• O contrato com o Kubernetes: 02 (JVM no container) → 10 (probes) → 11 (config e recursos) → 12 (graceful shutdown) → 22 (capstone).
• Observabilidade e diagnóstico: 13 (os 3 seams) → 14 (métricas) → 15 (Grafana) → 16 (Collector e sampling) → 17 (logs) → 18 (profiling sob carga) → 19 (continuous profiling).

Veja também

• Trilha Java
• Microservices e sistemas distribuídos (Galho 16)
• Build e tooling (Galho 15)
• JVM (Galho 3)
• Spring Core e Boot (Galho 8)
• Testes (Galho 13)
• Dicionário de Java

Notas do galho

TABLE fase, status
FROM "03-Dominios/Java/Cloud-native e produção"
WHERE type = "concept"
SORT file.name ASC