Curso de OpenJDK

Analizar el papel del proyecto OpenJDK como implementación abierta de referencia del ecosistema Java.

Diferenciar builds de Oracle OpenJDK, Eclipse Temurin, Microsoft Build of OpenJDK, Amazon Corretto, Azul Zulu, Red Hat OpenJDK e IBM Semeru.

Evaluar soporte, parches, plataformas, arquitecturas, frecuencia de actualización, garantías y canales de descarga.

Evitar mezclar distribuciones sin saber qué equipo soporta cada runtime.

Crear criterios para seleccionar distribución corporativa por entorno, aplicación y criticidad.

Revisar diferencias entre builds comunitarios, builds con soporte comercial y builds incluidos en distribuciones Linux.

Gestionar repositorios internos, mirrors, checksums, firmas y trazabilidad de binarios.

Documentar qué distribución se usa en desarrollo, CI, contenedores, servidores y producción.

Crear matriz de compatibilidad por sistema operativo, arquitectura y proveedor.

Taller: comparar tres distribuciones OpenJDK y justificar selección para una empresa.

Entender el calendario de releases de Java y el impacto de las versiones feature cada seis meses.

Diferenciar versiones LTS, versiones no LTS, updates trimestrales, parches de seguridad y builds early access.

Revisar estrategia entre JDK 21 LTS, JDK 25 LTS, JDK 26 y futuras versiones.

Evitar adoptar cada versión nueva en producción sin política de pruebas y soporte.

Diseñar política corporativa: LTS principal, versión piloto, versión de laboratorio y retirada de versiones obsoletas.

Identificar riesgos de permanecer en Java 8, 11 o 17 sin plan de actualización.

Crear calendario de revisión de versiones y parches.

Gestionar compatibilidad de frameworks, agentes, librerías y herramientas con cada versión.

Preparar proceso de excepción para aplicaciones legacy.

Taller: diseñar roadmap de actualización Java para un portfolio de 60 aplicaciones.

Instalar OpenJDK en Windows, Linux y macOS con paquetes, gestores de versiones o binarios controlados.

Configurar `JAVA_HOME`, `PATH`, alternativas del sistema, SDKMAN!, asdf, jEnv o herramientas equivalentes.

Evitar que IDE, terminal, Maven, Gradle y CI usen versiones distintas sin detectarlo.

Gestionar varias versiones de JDK por proyecto.

Validar runtime con `java -version`, `javac -version`, propiedades del sistema y comandos de entorno.

Preparar instalación offline o mediante repositorios internos.

Documentar rutas, permisos, actualización y desinstalación.

Crear scripts de validación de entorno para onboarding.

Separar JDK de desarrollo, runtime de producción e imagen base de contenedor.

Taller: configurar entorno multi-JDK reproducible para varios proyectos Java.

Usar `java` para ejecutar aplicaciones, jars, módulos, classpath, system properties y opciones de runtime.

Usar `javac` para compilar código con control de source, target, release, warnings y errores.

Usar `jar` para crear, inspeccionar, firmar y manipular archivos JAR.

Usar `javadoc` para generar documentación técnica útil y navegable.

Usar `jshell` para explorar APIs, probar snippets y validar comportamiento del lenguaje.

Usar `javap` para inspeccionar bytecode y entender compilación.

Usar `jdeps` para analizar dependencias internas y externas.

Usar `jdeprscan` para detectar APIs deprecadas en migraciones.

Usar `jcmd`, `jps`, `jstat` y herramientas diagnósticas con criterio operativo.

Taller: crear kit de comandos OpenJDK para desarrollo, análisis y soporte.

Configurar compilación con `--release` para garantizar compatibilidad de API y bytecode.

Diferenciar `source`, `target`, `release`, classpath, module path y annotation processing.

Evitar compilar con una versión y ejecutar en otra sin pruebas.

Gestionar warnings como señales tempranas de deuda técnica.

Configurar compilación incremental desde Maven, Gradle o IDE.

Revisar errores habituales de módulos, encoding, dependencias y APIs internas.

Usar argumentos reproducibles en CI/CD.

Analizar impacto de preview features en builds y producción.

Documentar política de compilación por versión Java.

Taller: corregir proyecto que compila localmente pero falla en CI por versión de JDK.

Configurar Maven Toolchains para controlar JDK de compilación.

Configurar Gradle Toolchains para builds reproducibles entre equipos.

Evitar depender del JDK local del desarrollador sin declararlo.

Gestionar builds multi-módulo con versiones Java diferentes.

Configurar tests, empaquetado, análisis y plugins para JDK actual.

Detectar incompatibilidades de plugins Maven/Gradle con versiones recientes de Java.

Integrar toolchains en CI/CD.

Documentar versión mínima, versión objetivo y versión de ejecución.

Crear perfiles para desarrollo, test, release y contenedor.

Taller: preparar proyecto Maven/Gradle con toolchain controlado y build reproducible.

Entender el Java Platform Module System y su impacto en encapsulación, dependencias y distribución.

Diferenciar classpath y module path.

Crear `module-info.java` con `requires`, `exports`, `opens`, `uses` y `provides`.

Evitar abrir módulos indiscriminadamente para solucionar errores de reflexión.

Analizar módulos del JDK y dependencias de aplicación.

Gestionar migración progresiva de proyectos no modulares.

Resolver errores de acceso por encapsulación fuerte.

Preparar librerías compatibles con uso modular y no modular.

Relacionar modularidad con `jlink` y reducción de runtime.

Taller: modularizar una librería Java y crear runtime mínimo.

Usar `jdeps` para detectar dependencias entre paquetes, módulos y JDK internals.

Identificar uso de APIs internas que pueden romper en versiones modernas.

Analizar JARs de terceros, aplicaciones legacy y dependencias transitivas.

Generar información útil para modularización y migración.

Evitar migrar a Java moderno sin revisar dependencias problemáticas.

Detectar dependencias innecesarias o acoplamientos ocultos.

Integrar `jdeps` en pipelines de calidad.

Documentar hallazgos y plan de remediación.

Crear informes para arquitectos y equipos de desarrollo.

Taller: analizar aplicación legacy con `jdeps` y preparar plan de migración.

Usar `jdeprscan` y release notes para detectar APIs deprecadas o eliminadas.

Diferenciar deprecación for removal, warnings, errores de compilación y cambios de comportamiento.

Evitar actualizar de golpe sin inventario de dependencias y APIs afectadas.

Crear backlog de remediación por aplicación.

Coordinar cambios con librerías de terceros y frameworks.

Revisar flags, módulos y opciones del JDK que desaparecen o cambian.

Preparar pruebas de regresión para funcionalidades afectadas.

Documentar alternativas recomendadas.

Integrar comprobaciones en CI.

Taller: corregir uso de APIs deprecadas antes de migrar a una versión LTS reciente.

Entender `jlink` como herramienta para crear imágenes runtime personalizadas.

Seleccionar módulos necesarios para una aplicación concreta.

Reducir tamaño, superficie de ataque y dependencias del runtime.

Evitar crear runtimes mínimos sin pruebas funcionales completas.

Usar `jdeps` para identificar módulos necesarios.

Configurar opciones de compresión, stripping y launchers.

Integrar runtimes personalizados en contenedores o distribuciones internas.

Gestionar actualización de runtime cuando hay parches de seguridad.

Documentar qué módulos incluye cada runtime y por qué.

Taller: crear runtime mínimo para una aplicación modular y compararlo con JDK completo.

Usar `jpackage` para generar instaladores y paquetes nativos para aplicaciones Java.

Diferenciar distribución en servidor, escritorio, contenedor y paquete instalable.

Crear paquetes para Windows, macOS y Linux cuando el caso lo requiere.

Incluir runtime personalizado generado con `jlink`.

Evitar entregar aplicaciones de escritorio que dependen del Java instalado por el usuario.

Configurar iconos, launchers, metadata, versión, nombre y rutas de instalación.

Gestionar firma, permisos, actualizaciones y distribución interna.

Probar instalación, actualización y desinstalación.

Documentar requisitos de plataforma y soporte.

Taller: empaquetar aplicación Java de escritorio con runtime incluido.

Usar JShell como REPL para probar código, APIs, snippets y comportamiento del lenguaje.

Explorar clases estándar sin crear proyecto completo.

Validar expresiones, colecciones, streams, records, pattern matching y APIs modernas.

Evitar usar JShell como sustituto de tests automatizados.

Cargar clases, paquetes y scripts útiles.

Usar JShell en formación interna y debugging conceptual.

Probar cambios de comportamiento entre versiones de JDK.

Documentar snippets reutilizables para equipos.

Integrar exploración con aprendizaje de APIs.

Taller: crear sesión JShell para validar nuevas APIs antes de incorporarlas al proyecto.

Crear JARs ejecutables con manifest correcto.

Diferenciar JAR simple, fat JAR, shaded JAR, modular JAR y multi-release JAR.

Evitar conflictos de dependencias por empaquetado agresivo.

Gestionar classpath, module path y main class.

Revisar firma de JARs y validación de integridad.

Analizar contenido de JARs con `jar`, `jdeps` y herramientas de build.

Documentar estrategia de empaquetado por tipo de aplicación.

Controlar tamaño, duplicidades y dependencias incluidas.

Preparar artefactos para repositorio interno.

Taller: convertir una aplicación mal empaquetada en artefacto reproducible y ejecutable.

Entender qué son los multi-release JARs y cuándo aportan valor.

Crear código específico por versión de Java manteniendo compatibilidad base.

Evitar complejidad innecesaria si la empresa puede estandarizar una versión única.

Configurar Maven o Gradle para empaquetar variantes por versión.

Probar ejecución en varias versiones de JDK.

Documentar APIs usadas por versión.

Revisar impacto en debugging, soporte y análisis de dependencias.

Validar comportamiento con `jar` y herramientas del JDK.

Definir política interna para librerías compartidas.

Taller: crear multi-release JAR con implementación optimizada para una versión moderna.

Generar documentación Javadoc de calidad para librerías y APIs internas.

Configurar enlaces externos, módulos, paquetes y visibilidad.

Evitar documentación generada automáticamente sin utilidad real.

Integrar Javadoc en pipelines de release.

Revisar errores y warnings de documentación.

Publicar documentación interna por versión.

Relacionar Javadoc con contratos de API y consumidores.

Documentar ejemplos, restricciones, excepciones y comportamiento esperado.

Definir estándares de documentación para librerías corporativas.

Taller: mejorar documentación de una librería Java y publicarla como artefacto de release.

Entender heap, metaspace, stack, direct buffers, code cache, native memory y memoria total del proceso.

Configurar `-Xms`, `-Xmx`, `MaxRAMPercentage` y límites según entorno.

Evitar asignar memoria sin considerar contenedor, sistema operativo y procesos auxiliares.

Medir memoria usada, committed, RSS, heap y native memory.

Detectar fugas, presión de memoria, OOM y exceso de buffers directos.

Configurar dumps ante errores de memoria.

Relacionar memoria con GC, latencia, coste y densidad de servicios.

Crear perfiles de memoria por tipo de aplicación.

Documentar flags de memoria aprobados.

Taller: diagnosticar OOM en aplicación Java y ajustar memoria de forma justificada.

Revisar políticas de GC disponibles en HotSpot: G1, ZGC, Shenandoah, Serial y Parallel según distribución y versión.

Elegir GC según latencia, throughput, tamaño de heap, CPU, memoria y criticidad.

Evitar cambiar el GC sin medir antes y después.

Interpretar logs de GC, pausas, ciclos, memoria antes/después y causas.

Configurar logging de GC con rotación y contexto.

Relacionar GC con latencia p95/p99, throughput y consumo CPU.

Ajustar heap y flags de GC con prudencia.

Crear alertas por pausas, frecuencia y comportamiento anómalo.

Documentar criterios de selección de GC.

Taller: comparar G1 y una política de baja latencia sobre workload controlado.

Entender cómo la JVM interpreta, perfila y compila código caliente.

Analizar warm-up, tiered compilation, code cache y optimizaciones dinámicas.

Evitar benchmarks que ignoran calentamiento, compilación y estabilización.

Medir startup, first request, ramp-up y estado estable.

Relacionar JIT con microservicios, batch, funciones de vida corta y aplicaciones long-running.

Diagnosticar CPU inicial elevada por compilación o carga de clases.

Revisar flags de compilación solo cuando existe evidencia.

Documentar patrones de rendimiento por tipo de aplicación.

Crear pruebas de rendimiento representativas.

Taller: medir curva de warm-up de una API Java y explicar resultados.

Entender Class Data Sharing como mecanismo para compartir metadata de clases y mejorar arranque/footprint.

Diferenciar CDS por defecto, AppCDS y otros enfoques de reducción de startup.

Identificar escenarios donde CDS aporta valor: microservicios, contenedores, arranque frecuente y densidad.

Evitar activar optimizaciones de arranque sin medir efecto real.

Generar archivos de clases compartidas cuando el caso lo justifica.

Gestionar compatibilidad entre runtime, clases, versión y build.

Integrar CDS en imágenes de contenedor.

Medir startup, RSS y CPU inicial.

Documentar proceso de regeneración al cambiar dependencias.

Taller: aplicar CDS/AppCDS en microservicio y comparar resultados.

Usar `jcmd` para obtener información de procesos Java, flags, VM, system properties y comandos diagnósticos.

Capturar thread dumps, heap histograms, JFR recordings y datos de runtime.

Evitar ejecutar comandos diagnósticos de alto impacto sin valorar riesgo.

Crear procedimientos seguros para producción.

Relacionar `jcmd` con incidentes de CPU alta, memoria, bloqueo o latencia.

Documentar comandos permitidos por nivel de soporte.

Automatizar recogida de evidencias básicas.

Integrar `jcmd` con runbooks y soporte N2/N3.

Proteger salidas que contienen información sensible.

Taller: resolver incidencia simulada usando `jcmd` y evidencias controladas.

Entender JDK Flight Recorder como mecanismo de grabación de eventos de baja sobrecarga.

Activar grabaciones en desarrollo, staging y producción con perfiles adecuados.

Configurar duración, tamaño, eventos, umbrales y destino de archivos.

Evitar grabaciones extensas sin política de retención y seguridad.

Capturar eventos de CPU, memoria, GC, locks, I/O, sockets, exceptions y allocations.

Correlacionar JFR con logs, métricas y despliegues.

Usar JFR bajo demanda o de forma continua según criticidad.

Proteger archivos JFR que puedan contener datos sensibles.

Crear perfiles de grabación corporativos.

Taller: capturar JFR durante prueba de carga y preparar análisis técnico.

Usar JDK Mission Control para analizar grabaciones JFR.

Identificar hot methods, allocations, pausas, locks, latencia, I/O, sockets y eventos anómalos.

Evitar interpretar una grabación sin contexto de carga y versión.

Crear informes de diagnóstico con hallazgos, evidencia y recomendaciones.

Comparar grabaciones antes/después de un cambio.

Analizar reglas automáticas de JMC y validar conclusiones.

Usar JMC como herramienta de soporte y performance engineering.

Documentar metodología de análisis de JFR.

Preparar sesiones de revisión con desarrollo y SRE.

Taller: analizar una grabación JFR y priorizar mejoras de rendimiento.

Capturar thread dumps con herramientas del JDK.

Interpretar estados de threads, locks, monitors, deadlocks, pools saturados y esperas prolongadas.

Evitar reiniciar procesos sin recoger evidencias de bloqueo.

Tomar series de dumps para detectar evolución y no solo fotografía puntual.

Relacionar thread dumps con logs, métricas de pool, CPU y latencia.

Detectar problemas en executors, virtual threads, conexiones, colas y sincronización.

Documentar causa probable y solución.

Crear runbook de diagnóstico de aplicación colgada.

Coordinar análisis entre desarrollo, SRE y soporte.

Taller: diagnosticar deadlock y saturación de pool con thread dumps.

Capturar heap dumps ante OOM, crecimiento sostenido o sospecha de fuga.

Configurar generación automática de dump con rutas seguras.

Evitar almacenar heap dumps en discos pequeños o sin cifrado.

Analizar objetos dominadores, referencias, classloaders, caches, colecciones y leaks.

Diferenciar fuga real, cache esperada y pico temporal.

Relacionar heap dump con GC logs, métricas y cambios recientes.

Usar Eclipse MAT u otras herramientas compatibles.

Proteger dumps por posible contenido sensible.

Documentar análisis y plan de remediación.

Taller: analizar heap dump de fuga simulada y preparar informe técnico.

Usar Native Memory Tracking para investigar consumo fuera del heap.

Diferenciar memoria de threads, class metadata, code cache, GC, arenas, direct buffers y librerías nativas.

Evitar solucionar todos los problemas aumentando `-Xmx`.

Medir memoria nativa antes y después de cambios.

Diagnosticar consumo por Netty, buffers directos, JNI, drivers o agentes.

Configurar NMT con nivel adecuado y coste asumible.

Relacionar memoria nativa con límites de contenedor.

Documentar hallazgos y ajustes.

Crear alertas de RSS o memoria total del proceso.

Taller: investigar diferencia entre heap estable y proceso Java que crece en memoria.

Usar JMH para microbenchmarks y pruebas controladas de código Java.

Entender warm-up, forks, iterations, measurement, state, blackholes y modos de benchmark.

Evitar benchmarks caseros con `System.nanoTime()` mal usados.

Diseñar benchmarks que no sean engañosos por optimizaciones del compilador.

Separar microbenchmark, carga de aplicación, prueba de estrés y test de regresión.

Medir con varias versiones de JDK y hardware controlado.

Interpretar resultados con desviación, intervalos y variabilidad.

Integrar JMH en análisis de cambios críticos.

Documentar límites de cada benchmark.

Taller: crear benchmark JMH para comparar dos implementaciones y evitar trampas habituales.

Diseñar metodología de performance engineering con baseline, hipótesis, cambio, medición y rollback.

Medir latencia p50, p95, p99, throughput, errores, CPU, memoria, GC y saturación.

Evitar optimizar flags JVM si el problema está en base de datos, red, I/O o código.

Crear pruebas de carga representativas.

Correlacionar rendimiento con versión de JDK, librerías, contenedor y despliegue.

Analizar impacto de cambios de versión Java.

Crear perfiles de rendimiento por tipo de servicio.

Integrar resultados en CI/CD o pruebas previas a release.

Documentar conclusiones accionables.

Taller: diagnosticar degradación de rendimiento tras migrar de versión Java.

Crear imágenes de contenedor con OpenJDK de forma segura y eficiente.

Elegir imagen base, versión, distribución, arquitectura y tamaño.

Evitar imágenes con JDK completo cuando solo se necesita runtime reducido.

Ejecutar aplicación con usuario no root, healthchecks, logs stdout y configuración externa.

Ajustar memoria JVM a límites del contenedor.

Gestionar timezone, certificados, locales, fonts y dependencias nativas.

Escanear imágenes y generar SBOM.

Usar multi-stage builds para reducir tamaño.

Documentar contrato de runtime por imagen.

Taller: construir imagen Java optimizada con OpenJDK, jlink y usuario no root.

Desplegar aplicaciones Java con requests, limits, probes, ConfigMaps, Secrets y service accounts.

Ajustar memoria, CPU y heap para evitar OOMKilled y CPU throttling.

Configurar readiness, liveness y startup probes según comportamiento real.

Evitar probes demasiado agresivas durante warm-up o GC.

Exponer métricas JVM y aplicación.

Recoger dumps y JFR en pods sin perder evidencias.

Gestionar rolling updates, canary, rollback y HPA.

Integrar OpenJDK con OpenShift, Kubernetes y plataformas internas.

Crear runbooks para incidentes Java en cluster.

Taller: desplegar microservicio Java con OpenJDK y observabilidad completa en Kubernetes.

Integrar OpenJDK en pipelines de build, test, análisis, empaquetado y despliegue.

Controlar versión del JDK usada en cada etapa.

Evitar que CI compile con una versión distinta a la de producción.

Crear matrices de compatibilidad entre JDK 21, JDK 25, JDK 26 u otras versiones adoptadas.

Ejecutar tests unitarios, integración, seguridad, performance smoke y análisis de dependencias.

Generar artefactos reproducibles, SBOM, reports y evidencias.

Escanear imágenes y dependencias.

Publicar paquetes en repositorios internos.

Crear política de promoción por entorno.

Taller: diseñar pipeline Java con OpenJDK, Maven/Gradle, tests, SBOM e imagen de contenedor.

Controlar procedencia de JDKs, imágenes base, dependencias, plugins y herramientas de build.

Generar SBOM de aplicaciones Java y runtimes.

Revisar CVEs de JDK, dependencias, sistema operativo e imágenes base.

Evitar dependencias no fijadas, repositorios externos no controlados y builds no reproducibles.

Firmar artefactos o validar checksums cuando la política lo requiere.

Controlar secretos en repositorios, logs y pipelines.

Integrar SCA, SAST, container scanning y policy gates.

Documentar excepciones y plazos de remediación.

Mantener inventario de aplicaciones afectadas por vulnerabilidades.

Taller: crear pipeline de seguridad para aplicación OpenJDK con SBOM y escaneo.

Diseñar proceso de actualización de OpenJDK por parches trimestrales y releases.

Diferenciar actualización menor, actualización de seguridad y salto de versión principal.

Evitar mantener runtimes obsoletos por falta de pruebas automatizadas.

Crear calendario de patching por criticidad.

Probar parches en staging con tests funcionales, rendimiento y observabilidad.

Coordinar actualizaciones con equipos de desarrollo, seguridad y operaciones.

Documentar CVEs, impacto, aplicaciones afectadas y decisión de remediación.

Preparar rollback de runtime o imagen.

Medir cobertura de patching por aplicación.

Taller: gestionar actualización de seguridad OpenJDK en portfolio de microservicios.

Inventariar aplicaciones, frameworks, dependencias, plugins, flags, agentes y sistemas afectados.

Analizar cambios de lenguaje, APIs, módulos, seguridad, GC, encapsulación y deprecaciones.

Evitar saltos de versión sin pruebas de regresión y análisis de dependencias.

Actualizar Maven/Gradle, plugins, frameworks y librerías antes del salto.

Revisar cambios en TLS, certificados, XML, reflection, classloading y acceso a internals.

Ejecutar tests funcionales, integración, carga y observabilidad.

Preparar rollback y coexistencia temporal.

Documentar incidencias recurrentes por versión.

Crear oleadas de migración según riesgo.

Taller: preparar plan de migración Java 11 → Java 25 LTS para aplicaciones corporativas.

Validar Spring Boot, Quarkus, Micronaut, Jakarta EE, Hibernate, Netty, gRPC y librerías frecuentes.

Revisar compatibilidad de drivers JDBC, agentes APM, librerías nativas y herramientas de bytecode.

Evitar actualizar JDK sin revisar matriz de compatibilidad del stack.

Crear pruebas de smoke por framework.

Identificar dependencias abandonadas o sin soporte.

Documentar incompatibilidades y alternativas.

Gestionar coexistencia de versiones por equipo.

Preparar comunicación a owners de aplicación.

Integrar verificación en CI.

Taller: crear matriz de compatibilidad Java para un stack Spring Boot corporativo.

Entender virtual threads y su impacto en aplicaciones concurrentes.

Diferenciar virtual threads de threads de plataforma, reactive programming y pools tradicionales.

Identificar casos adecuados: I/O blocking, APIs, integraciones y servicios con muchas esperas.

Evitar migrar a virtual threads sin revisar librerías, pools, sincronización y pinning.

Medir latencia, throughput, memoria y número de threads.

Revisar observabilidad y thread dumps con virtual threads.

Ajustar pools de conexión y límites externos.

Comparar enfoque reactivo, blocking clásico y virtual threads.

Documentar patrones seguros de adopción.

Taller: adaptar endpoint bloqueante a virtual threads y medir impacto.

Revisar records, sealed classes, pattern matching, switch moderno, text blocks y mejoras de colecciones.

Identificar mejoras que reducen boilerplate y aumentan expresividad.

Evitar incorporar features modernas sin guía de estilo y compatibilidad.

Revisar APIs nuevas relevantes para concurrencia, I/O, seguridad, HTTP y herramientas.

Crear estándares de uso por equipo.

Gestionar preview features con prudencia y sin producción salvo decisión explícita.

Actualizar linters, formatters e IDEs.

Preparar formación interna para nuevas capacidades.

Documentar ejemplos corporativos.

Taller: refactorizar código legacy usando APIs modernas sin romper compatibilidad.

Gestionar truststores, keystores, certificados, CA corporativas y configuración TLS en aplicaciones Java.

Diferenciar `cacerts`, truststore propio, keystore de servidor y certificados cliente.

Evitar importar certificados manualmente en servidores sin trazabilidad.

Diagnosticar errores TLS, handshake, algoritmos deshabilitados y cadenas incompletas.

Configurar TLS en clientes HTTP, JDBC, gRPC y servicios internos.

Gestionar rotación y caducidad de certificados.

Revisar cambios de seguridad entre versiones de JDK.

Documentar política corporativa de certificados Java.

Integrar certificados en contenedores y pipelines.

Taller: resolver error TLS en aplicación Java desplegada con OpenJDK.

Configurar ejecución con mínimo privilegio en servidores y contenedores.

Evitar aplicaciones Java ejecutadas como root sin necesidad.

Proteger propiedades del sistema, variables, rutas, dumps y logs.

Revisar permisos de filesystem, temporales, certificados y configuración.

Gestionar exposición de puertos de debug, JMX, Actuator, métricas y herramientas diagnósticas.

Aplicar hardening en imágenes de contenedor.

Evitar flags inseguros o APIs internas no justificadas.

Crear checklist de seguridad para runtime Java.

Integrar controles en CI/CD y despliegue.

Taller: auditar runtime Java inseguro y aplicar hardening.

Entender JMX como mecanismo de gestión y monitorización de aplicaciones Java.

Exponer MBeans con seguridad, TLS, autenticación y restricciones de red.

Evitar JMX remoto abierto o sin cifrado.

Usar JMX para métricas, diagnóstico, configuración y soporte.

Integrar JMX con Prometheus, Jolokia, APM o herramientas corporativas si procede.

Controlar impacto de métricas y frecuencia de scraping.

Documentar endpoints administrativos.

Crear alertas basadas en MBeans útiles.

Gestionar diferencias entre entornos.

Taller: exponer métricas JVM de forma segura y consumirlas desde observabilidad.

Instrumentar aplicaciones Java con OpenTelemetry Java Agent o SDK.

Recoger trazas, métricas y logs con contexto de servicio, versión, entorno y release.

Evitar agentes que cambian rendimiento sin pruebas.

Configurar exporters, sampling, propagación de contexto y atributos.

Relacionar eventos JVM, GC, latencia y trazas de negocio.

Integrar observabilidad con Prometheus, Grafana, Tempo, Jaeger, Elastic, Datadog o equivalente.

Controlar datos sensibles en spans y logs.

Medir overhead del agente.

Crear dashboard JVM + aplicación.

Taller: instrumentar microservicio OpenJDK con OpenTelemetry y analizar trazas.

Configurar Logback, Log4j2, JUL o framework equivalente con salida estructurada.

Evitar logs excesivos, sin contexto, sin correlación o con datos sensibles.

Añadir trace ID, span ID, request ID, usuario técnico, versión y entorno.

Gestionar niveles por entorno y cambios controlados.

Rotar logs en servidores y usar stdout en contenedores.

Integrar logs con SIEM, APM o plataforma central.

Crear alertas a partir de errores relevantes.

Revisar impacto de logging en rendimiento.

Documentar estándares corporativos de logging Java.

Taller: transformar logging caótico en logging estructurado y trazable.

Entender jtreg como harness usado por el framework de tests del JDK.

Diferenciar tests unitarios, integración, regresión, conformance y tests del propio JDK.

Revisar cuándo interesa usar jtreg en proyectos internos o contribuciones OpenJDK.

Ejecutar tests relacionados con el JDK cuando se trabaja cerca de la plataforma.

Evitar confundir jtreg con JUnit o frameworks de aplicación.

Preparar entorno para pruebas de compatibilidad de runtime.

Documentar evidencias de regresión al migrar JDK.

Integrar tests críticos en pipelines.

Revisar salida y diagnóstico de fallos.

Taller: crear prueba jtreg sencilla y compararla con test JUnit convencional.

Entender cuándo tiene sentido compilar OpenJDK desde fuente y cuándo no.

Preparar entorno de build con dependencias, bootstrap JDK, toolchain, memoria y espacio suficiente.

Revisar estructura del repositorio, configuración, build profiles y targets.

Evitar builds propios para producción sin capacidad de soporte y pruebas.

Ejecutar build local para aprendizaje, investigación o parche controlado.

Ejecutar pruebas básicas y validar binarios generados.

Documentar versión, commit, flags y entorno de compilación.

Gestionar artefactos resultantes y trazabilidad.

Analizar coste de mantener builds internos.

Taller: preparar build de OpenJDK de laboratorio y documentar requisitos.

Entender proyectos, JEPs, mailing lists, repositorios, reviews y flujo de contribución.

Revisar diferencias entre usar OpenJDK y contribuir al proyecto.

Analizar roles, OCA, revisión de parches y estándares de calidad.

Evitar modificar OpenJDK internamente sin plan de upstream o mantenimiento.

Identificar proyectos relevantes: JDK, JMC, JMH, jtreg, Valhalla, Loom, Panama, Leyden y otros.

Seguir early access builds para validar compatibilidad de aplicaciones.

Participar en quality outreach cuando aporta valor.

Documentar hallazgos y reportes de bugs.

Crear estrategia de vigilancia tecnológica Java.

Taller: preparar informe de seguimiento de proyectos OpenJDK relevantes para la empresa.

Diseñar política de uso de JFR en producción con bajo impacto.

Definir perfiles de grabación por incidente, carga, memoria, CPU o latencia.

Activar grabaciones bajo demanda desde `jcmd` o configuración controlada.

Evitar grabaciones sin límites de tamaño y tiempo.

Automatizar captura ante eventos críticos.

Proteger ficheros JFR por posible sensibilidad.

Integrar análisis con JDK Mission Control.

Crear procedimiento de envío a soporte interno.

Medir overhead real en aplicaciones críticas.

Taller: capturar JFR ante latencia p99 elevada y crear informe de causa probable.

Diferenciar CPU alta por aplicación, GC, JIT, logging, bucles, locks, serialización, cifrado o librerías nativas.

Recoger evidencias con métricas, JFR, thread dumps, logs y sistema operativo.

Evitar reiniciar antes de capturar datos.

Correlacionar CPU con tráfico, despliegues, cambios de configuración y dependencias.

Identificar métodos calientes con JMC.

Analizar impacto de agentes y observabilidad.

Crear plan de mitigación temporal y corrección definitiva.

Documentar causa raíz.

Preparar alerta de CPU sostenida con contexto.

Taller: resolver caso de CPU alta usando JFR y thread dumps.

Analizar latencia p50, p95, p99, timeouts, colas, saturación y errores.

Separar latencia de aplicación, JVM, GC, red, base de datos, APIs externas y contenedor.

Usar JFR, trazas distribuidas, logs y métricas para localizar cuello de botella.

Evitar optimizar JVM si la causa es una dependencia externa lenta.

Medir throughput bajo carga y estabilidad en el tiempo.

Revisar pools de threads, conexiones, backpressure y límites.

Crear runbook de latencia elevada.

Documentar mejora medida tras cambios.

Integrar test de carga en pipeline.

Taller: diagnosticar degradación de p99 en API Java.

Medir tiempo de JVM, framework, carga de clases, inicialización, conexión a dependencias y readiness.

Diferenciar startup de warm-up y primera petición.

Usar JFR, logs de arranque y métricas de aplicación.

Evitar probes agresivas que reinician la aplicación antes de estar lista.

Aplicar jlink, CDS, lazy initialization o ajustes de framework cuando procede.

Reducir classpath, dependencias y configuración innecesaria.

Medir impacto de contenedor e imagen base.

Documentar baseline de arranque por servicio.

Crear objetivo de startup por tipo de aplicación.

Taller: optimizar arranque de microservicio Java con OpenJDK.

Diseñar ejecución Java para procesos batch, ETL, integraciones y jobs programados.

Ajustar memoria, GC, logs y salida según duración y volumen de datos.

Evitar dejar configuración pensada para APIs en procesos batch intensivos.

Gestionar reintentos, idempotencia, checkpoints y errores parciales.

Medir throughput, tiempo total, memoria pico y uso de I/O.

Configurar dumps y diagnósticos ante fallos.

Integrar jobs con schedulers, Kubernetes Jobs, cron o plataformas batch.

Documentar contratos de entrada, salida y recursos.

Optimizar coste en ejecución puntual.

Taller: configurar job Java batch con OpenJDK, métricas y recuperación.

Evaluar OpenJDK para aplicaciones Java desktop, Swing, JavaFX u otras tecnologías.

Gestionar distribución con runtime incluido para evitar dependencia del Java instalado.

Usar `jpackage` y `jlink` para paquetes instalables.

Controlar certificados, actualización, permisos, iconos, launchers y logs locales.

Evitar problemas de compatibilidad por versiones de Java en equipos de usuario.

Preparar instaladores para Windows, macOS y Linux según alcance.

Documentar soporte, requisitos y proceso de actualización.

Gestionar crash logs y diagnóstico en cliente.

Revisar firma de código y políticas corporativas.

Taller: crear paquete instalable de aplicación Java con runtime OpenJDK incluido.

Analizar aplicaciones antiguas con dependencias, flags, APIs internas, XML, reflection, seguridad y librerías obsoletas.

Identificar bloqueos para migrar desde Java 8 o 11.

Evitar actualizar runtime sin revisar framework, servidor de aplicaciones y drivers.

Crear estrategia por fases: inventario, build moderno, tests, dependencias, runtime y despliegue.

Aislar riesgos de librerías abandonadas.

Diseñar compatibilidad temporal y rollback.

Documentar cambios necesarios de código y configuración.

Medir impacto de rendimiento tras migración.

Preparar plan de soporte para equipos con deuda técnica.

Taller: diagnosticar aplicación legacy y preparar hoja de ruta de modernización OpenJDK.

Gestionar versiones, parches, soporte, evidencias y trazabilidad en sectores regulados.

Documentar procedencia del JDK, checksums, distribución y ciclo de vida.

Evitar runtimes descargados manualmente sin control de compliance.

Mantener inventario de aplicaciones y versiones Java.

Crear evidencias de pruebas de actualización y aprobación.

Proteger dumps, logs y grabaciones JFR por posible información sensible.

Revisar licencias, soporte y obligaciones de terceros.

Integrar runtime governance con GRC, CMDB, SIEM y auditoría.

Preparar reportes de obsolescencia y riesgo.

Taller: diseñar control audit-ready de runtimes OpenJDK para empresa regulada.

Crear inventario de aplicaciones, JDK, versión, distribución, owner, entorno, imagen y criticidad.

Detectar versiones obsoletas, duplicadas, no autorizadas o sin soporte.

Definir versiones permitidas, versiones en retirada y versiones de laboratorio.

Evitar que cada equipo elija runtime sin control.

Integrar inventario con repositorios, registros de contenedores, CMDB y escáneres.

Crear política de actualización, excepciones y retirada.

Medir cobertura de gobierno por aplicación.

Preparar reporting para CIO, CTO, CISO y arquitectura.

Definir responsables de plataforma Java.

Taller: crear modelo de gobierno OpenJDK para una organización con múltiples equipos.

Crear plantillas corporativas para servicios Java basados en OpenJDK.

Estandarizar Dockerfile, Helm chart, pipeline, flags JVM, observabilidad, logs y health checks.

Evitar que cada equipo cree su propio runtime desde cero.

Diseñar golden path para API, worker, batch y librería.

Añadir controles de versión, SBOM, escaneo, tests y despliegue.

Integrar jlink, jpackage o JFR cuando el caso lo requiere.

Crear documentación de onboarding para nuevos proyectos Java.

Mantener plantillas actualizadas con releases y parches.

Medir adopción y reducción de errores de configuración.

Taller: construir golden path de microservicio Java con OpenJDK.

Relacionar versión de OpenJDK, memoria, GC, contenedor y configuración con coste cloud.

Medir coste por servicio, pod, instancia, transacción y entorno.

Evitar reducir memoria sin validar latencia, GC y estabilidad.

Aplicar rightsizing tras observabilidad y pruebas de carga.

Detectar servicios sobredimensionados por configuraciones antiguas.

Optimizar imágenes, runtimes, startup y densidad de despliegue.

Integrar métricas JVM con reporting FinOps.

Documentar ahorro real y riesgo operativo.

Crear recomendaciones por familia de aplicaciones.

Taller: reducir coste de microservicios Java manteniendo SLOs.

Instalar un JDK distinto en desarrollo, CI y producción sin control.

Migrar de versión Java sin revisar dependencias, deprecaciones, flags y agentes.

Usar `latest` en imágenes de contenedor Java.

Ejecutar aplicaciones con heap mal dimensionado en Kubernetes.

Desplegar JDK completo cuando bastaría un runtime reducido.

Ignorar parches de seguridad del JDK durante meses.

Hacer benchmarks con métodos caseros y sin warm-up.

No recoger JFR, heap dump o thread dump antes de reiniciar un proceso problemático.

Mantener aplicaciones Java sin owner, sin inventario y sin política de soporte.

Taller: auditar un ecosistema Java desordenado y convertirlo en modelo OpenJDK gobernado.

Evaluar madurez actual: versiones, distribuciones, builds, contenedores, seguridad, CI/CD, observabilidad y soporte.

Identificar quick wins: inventario, actualización LTS, toolchains, imágenes base, SBOM, JFR y estándares de flags.

Priorizar aplicaciones por criticidad, riesgo, obsolescencia, coste, facilidad de migración e impacto de negocio.

Definir versión corporativa principal, versión piloto y calendario de retirada.

Crear pilotos con aplicaciones representativas.

Preparar estándares de runtime, contenedor, pipeline, diagnóstico, seguridad y documentación.

Medir mejoras en seguridad, estabilidad, coste, rendimiento y soporte.

Escalar adopción por oleadas.

Crear plan a 30, 60, 90 y 180 días.

Taller: construir roadmap OpenJDK para una organización con 100 aplicaciones Java.

Definir una organización con aplicaciones Java, versiones mezcladas, frameworks, entornos, contenedores, CI/CD y problemas operativos.

Crear inventario de runtimes con distribución, versión, owner, entorno, criticidad, soporte, imagen base y riesgo.

Seleccionar una aplicación candidata y preparar baseline de ejecución, memoria, GC, startup, latencia, throughput y errores.

Configurar OpenJDK corporativo con versión objetivo, toolchain Maven/Gradle, flags, certificados, logs y observabilidad.

Analizar dependencias con `jdeps`, APIs deprecadas con `jdeprscan` y compatibilidad de frameworks y agentes.

Crear imagen de contenedor segura con OpenJDK, usuario no root, SBOM, healthchecks, configuración externa y límites de memoria.

Generar runtime mínimo con `jlink` cuando proceda y comparar tamaño, startup, seguridad y mantenimiento.

Capturar JFR, thread dumps, heap dumps o GC logs durante prueba de carga o incidencia simulada.

Diseñar pipeline CI/CD con build reproducible, tests, escaneo, SBOM, publicación, despliegue y rollback.

Presentar roadmap final con política de versiones, gobierno, seguridad, FinOps, observabilidad, migración y mejora continua.