Esta serie de videotutoriales ha sido preparada para que el desarrollador con conocimientos básicos de Java pueda adentrarse en la creación de microservicios con MicroProfile.
Los vídeos han sido creados como capítulos independientes, por lo que pueden analizarse de forma individual y los ejercicios se ejecutan de principio a fin en cada vídeo. Para la elaboración de los ejercicios los requerimientos técnicos son:
- Java 11
- Maven 3.8.1 o posterior
- Un IDE/editor de código de preferencia
- Docker
- Kubernetes -e.g. Minikube, Kind, Docker Desktop-
Durante los 13 vídeos se discuten distintas implementaciones de MicroProfile y todo el código fuente utiliza únicamente código basado en especificaciones -i.e. MicroProfile, Jakarta EE-, haciendolo intercambiable entre implementaciones con soporte a la misma versión de MicroProfile.
¿Porqué estos tutoriales?
Actualmente me desempeño como director de tecnología, consultor, profesor universitario y capacitador para la industria (puedes ver mi blog acá). Una de mis labores diarias es enseñar a mis compañeros de trabajo y alumnos acerca de frameworks modernos de desarrollo en diversos lenguajes de programación. Durante la última decada he sido testigo de una transición en el mundo Java desde aplicaciones monolíticas hasta aplicaciones basadas en microservicios y sistemas distribuidos.
En mi opinión MicroProfile es un camino que promueve la innovación conjunta de fabricantes y garantiza la independencia de proveedor en implementaciones, lo cual me ha llevado a utilizarlo en la mayoría de mis consultorias actuales. Durante mi trabajo identifiqué que no existia material disponible en Español que esclareciera “quien, como y porqué” existe una especificación/API y cuales son sus usos en el mundo real, así que en línea con el espíritu de código abierto decidí crear el material yo mismo y mostrar al mundo hispano porqué MicroProfile puede ser su siguiente paso en la búsqueda del Cloud Native Java.
¿Qué es MicroProfile?
En este vídeo se explica la historia de MicroProfile, su relación con Java EE, Jakarta EE, Eclipse y porqué diversos fabricantes lo han adoptado
Puntos importantes
- 00:00 – Que es Java EE
- 01:34 – Java Community Process
- 03:21 – Java EE 8
- 06:20 – Oracle libera Java EE
- 07:18 – Que es MicroProfile
- 09:58 – Jakarta EE
- 11:18 – Implementaciones de Jakarta EE
- 11:41 – Implementaciones de MicroProfile
Servicios REST con MicroProfile, JAX-RS y Apache TomEE
Como un punto fundamental en la creación de microservicios, se explica a detalle la creación de APIs REST (y RESTLike) con JAX-RS y Apache TomEE
Puntos importantes
- 00:00 – Qué es JAX-RS
- 01:52 – Apache TomEE
- 03:35 – Microservicios con MicroProfile Starter y Maven
- 06:23 – UberJar y TomEE Maven Plugin
- 10:06 – Creando un servicio JAX-RS
- 26:25 – Probando el microservicio REST
Inyección de dependencias con CDI, MicroProfile y Payara Micro
Dado que MicroProfile utiliza CDI como su modelo de programación, en este vídeo se explora a fondo la creación de componentes con CDI mediante Payara Micro
Puntos importantes
- 00:00 – Que es CDI
- 01:53 – Payara Micro
- 03:15 – Microservicios con Payara Maven Plugin
- 10:00 – Inyección de dependencias con CDI
- 21:30 – Ciclos de vida y scopes en CDI
- 30:55 – Productores
Serialización de JSON y Java con MicroProfile, JSON-B y Wildfly Bootable JAR
La serialización es el proceso de transformación de objetos JSON a Java y viceversa. En este vídeo se demuestra el control de serialización declarativo ofrecido por JSON-B a través de Wildfly Bootable Jar.
Puntos importantes
- 00:00 – Que es JSON-B
- 02:15 – Wildfly
- 03:58 – Wildfly Bootable Jar
- 06:38 – Creando un proyecto con MicroProfile Starter y Wildfly Bootable Jar
- 14:05 – Wildfly Bootable Jar dev-watch
- 17:17 – Serialización con JSON-B y JAX-RS
- 28:06 – Serialización manual con JSON-B
Manipulación de JSON con MicroProfile, JSON-P y OpenLiberty
Cuando la serialización declarativa con JSON-B no es suficiente, JSON-P ofrece un control granular e imperativo sobre diversos aspectos de la serialización. En consecuencia se describen sus aspectos más importantes utilizando OpenLiberty.
Puntos importantes
- 00:00 – Que es JSON-B
- 02:10 – OpenLiberty
- 06:38 – Creando un proyecto con MicroProfile Starter y OpenLiberty
- 11:14 – OpenLiberty development mode
- 12:45 – Creación de objetos JSON con JSON-P
- 20:17 – Manipulación de objetos JSON con Json Pointers
- 26:58 – Manipulación de objetos JSON con Json Patch
Externalización de configuración de servicios con MicroProfile, Kubernetes y Helidon
En línea con los 12 factores Cloud Native, uno de los aspectos más importantes es la externalización de la configuración. Para ello se demuestra su uso correcto mediante MicroProfile Config y Helidon.
Puntos importantes
- 00:00 – Que es MicroProfile Config
- 04:07 – Oracle Helidon
- 06:25 – Creando un proyecto con Helidon CLI
- 10:29 – Analizando el proyecto Maven de Helidon
- 11:45 – Externalización de la configuración con Java y MicroProfile Config
- 15:53 – Externalización de la configuración con microprofile-config.properties
- 17:00 – Externalización de la configuración con variables de entorno
- 18:50 – Externalización de la configuración con Docker y Kubernetes
- 25:23 – Despliegue del microservicio en Oracle Cloud
Documentación de APIs con MicroProfile, KumuluzEE, Swagger UI y Docker
Para descubrir las operaciones de una API, la especificacion OpenAPI establece un márco de trabajo mediante el cual las APIs publicadas pueden ofrecer su documentación a potenciales consumidores. Para ello se demuestra su implementación utilizando MicroProfile OpenAPI sobre KumuluzEE.
Puntos importantes
- 00:00 – Que es MicroProfile OpenAPI
- 03:31 – KumuluzEE
- 05:43 – Creando un proyecto con KumuluzEE
- 08:02 – KumuluzEE Generator
- 11:35 – Creación rapida de un API REST y documentación automatica de OpenAPI
- 19:00 – Documentación con OpenAPI mediante archivo manifest YAML
- 22:00 – Documentación con OpenAPI y anotaciones Java
- 27:55 – Integración de Swagger UI
- 30:14 – Creación de un contenedor docker con Liberica JVM
Tolerancia a fallas con MicroProfile, Quarkus y Docker
La resilencia es un aspecto fundamental en la creación de sistemas distribuidos, en esta línea se demuestra la implementación de tolerancia a fallas mediante MicroProfile Fault Tolerance, Quarkus y Docker.
Puntos importantes
- 00:00 – Que es MicroProfile Fault Tolerance
- 09:00 – Quarkus
- 10:43 – Creando un proyecto con Quarkus
- 16:45 – API REST con Quarkus
- 19:15 – Fallas en servicios REST
- 24:20 – Tolerancia a fallas con Fallback
- 28:09 – Timeout
- 31:04 – Retry
- 32:30 – Circuit Breaker
- 34:53 – Bulkhead
- 38:27 – Empaquetando servicios Quarkus con Docker
Cliente Rest Typesafe Java con MicroProfile, GraalVM Native y Kubernetes
En línea con la filosofia de Java, MicroProfile Rest Client permite la creación de clientes TypeSafe. Demostramos su uso mediante Helidon, Kubernetes y como bonus se demuestran las ventajas de la compilación AOT con GraalVM.
Puntos importantes
- 00:00 – Que es MicroProfile Rest Client
- 05:42 – Creando un cliente con MicroProfile Rest Client y Quarkus
- 22:00 – Compilación nativa de Java con GraalVM Native
- 30:52 – Compilación de una aplicación Java nativa para Docker
- 35:35 – Minikube
- 36:35 – Creando un plan de despliegue para Kubernetes
- 40:06 – Despliegue de 50 replicas del servicio en Minikube
- 44:22 – Despliegue de 99 replicas del servicio en Minikube
Health checks y reinicios automaticos con Java, MicroProfile y Kubernetes Probes
Los health checks son los mecanismos mediante los cuales diversos orquestadores implementan escalamiento y reinicios automáticos de microservicios. Demostramos su uso mediante Kubernetes y MicroProfile Health.
Puntos importantes
- 00:00 – Que es MicroProfile Health
- 04:10 – Creando un servicio con Oracle Helidon
- 06:57 – Tipos de Health check y Health check automaticos con Helidon
- 10:02 – Creando Health check personalizados con MicroProfile
- 16:41 – Configurando Docker y Minikube
- 17:39 – Compilación nativa con GraalVM
- 19:07 – Creando Liveness Probes con Kubernetes
- 26:38 – Desplegando 100 servicios nativos con Oracle Cloud y ejecutando Liveness Probes
Métricas en Java con MicroProfile Metrics, Payara, Prometheus, Grafana y Kubernetes
La impementación de métricas contituye el punto central de Ops en DevOps, para obtener observabilidad del funcionamiento de nuestras aplicaciones. Demostramos su uso mediante MicroProfile Metrics y una instalación de Kube-prometheus que incluye Grafana y Prometheus.
Puntos importantes
- 00:00 – Que es MicroProfile Metrics
- 02:15 – Creando microservicio con Payara Micro y MicroProfile 4.0
- 05:18 – Ajustando el plugin de Payara Micro
- 07:49 – Creando un servicio REST para demostrar métricas
- 08:56 – Counted (métrica) con CDI
- 11:13 – Metricas base, metricas vendor y metricas application
- 13:58 – Counted (métrica) con decoradores (anotaciones)
- 13:58 – Counted (métrica) con decoradores (anotaciones)
- 16:33 – ConcurrenteGauge (métrica)
- 22:47 – Gauge (métrica)
- 27:48 – Timed (métrica)
- 34:43 – Metered (métrica)
- 38:26 – Subiendo el servicio a Docker Hub
- 40:00 – Publicando el servicio en Oracle Cloud y recolectando las métricas con Kube Prometheus
- 44:53 – Creando el service monitor
- 52:00 – Accediendo a Prometheus y probando la recolección de métricas
- 55:00 – Accediendo a Grafana y probando un dashboard simple
Seguridad en microservicios Java con MicroProfile JWT, Quarkus, Keycloak y Kubernetes
El modelo de procesamiento distribuido implica la preferencia a servicios sin almacenamiento de estado, por lo qué la propagación de sesiones generalmente es implementada a través de JWT. En este video ejemplificamos el ciclo completo de JWT incluyendo un proveedor (Keycloack) y su consumo mediante MicroProfile JWT Propagation.
Puntos importantes
- 00:00 – Que es MicroProfile JWT Propagation
- 04:40 – Instalación de Keycloak sobre Kubernetes (Oracle Cloud)
- 08:54 – Creando un servicio REST para demostrar JWT con Quarkus
- 12:39 – Creación de grupos, usuarios y roles en Keycloak
- 20:30 – Generando un token con Keycloak
- 23:35 – Protegiendo servicios REST con MicroProfile JWT
Tracing de microservicios en Java con MicroProfile OpenTracing, Helidon, Zipkin y Kubernetes
Finalizamos el recorrido explorando a fondo la trazabilidad de microservicios con OpenTracing. Para ello utilizamos dos microservicios con MicroProfile OpenTracing recolectando sus puntos de control (spans) mediante Zipkin. La demostración incluye su uso básico y un despliegue complejo a través de Kubernetes.
Puntos importantes
- 00:00 – Que es MicroProfile OpenTracing
- 08:35 – Creando microservicio uno con Oracle Helidon
- 16:55 – Creando microservicio dos con Oracle Helidon
- 25:05 – Ejecutando Zipkin a través de Docker
- 27:02 – Agregando soporte para Zipkin a proyectos basados en Oracle Helidon y MicroProfile
- 30:28 – Probando el tracing con Zipkin
- 31:29 – Agregando componentes CDI a Tracing
- 35:39 – Utilizando Zipkin en Oracle Cloud
- 36:22 – Preparando los microservicios para Docker y Kubernetes
- 52:43 – Probando Zipkin sobre Oracle Cloud
