Creando microservicios con Java MicroProfile y TomEE - OGBT

@CesarHgt @tomitribejugbaq.org
César Hernández
Creando Microservicios con Java,
MicroProﬁle y Apache TomEE

SPEAKER
César Hernández
● Senior Software Engineer at Tomitribe
● Java Champion & Oracle Groundbreaker Ambassador
● Duke’s Choice Award 2016, 2017
● Oracle Certiﬁed Professional
● +14 experience with Java Enterprise
● Apache TomEE, Jakarta EE Committer, Contributor
for Microproﬁle.
● Open Source advocate, teacher and public speaker

Agenda
● Introduction and setup
● Microservices
● Eclipse MicroProfile
● MicroProfile Configuration
● MicroProfile Health
● MicroProfile Metrics
● MicroProfile JWT
● MicroProfile Fault Tolerance
●

Microservices

A microservice architectural style is an approach to
developing a single application as a suite of small services,
each running in its own process and communicating with
lightweight mechanisms, often an HTTP resource API.
— Martin Fowler

● Infraestructura
● Arquitectura
● Investigación
Perspectivas Micro Servicios

Microservices
Source: http://eventuate.io/exampleapps.html

● Alcance
● Distribuídos
● Orquestación
● Adopción
Retos Microservices

Microservices Patterns teaches enterprise developers and
architects how to build applications with the microservice
architecture.
— Chris Richardson

Patrones Microservices
Source: http://eventuate.io/exampleapps.html

● 39% plan to use Java to build microservices in the next year
● Using Java for cloud native applications
○ 44% Spring/Spring Boot ( - 13%)
○ 35% Jakarta EE
● Architectural Approach
○ 39% Microservices
○ 25% Monolithic (2x since 2019)
○ 23% Hybrid
Microservices and Cloud-native
Source: Jakarta EE Developer Survey 2020 - The Eclipse Foundation’s global survey of 2180 Java developers.
○ 29% MicroProﬁle
○ 16% Quarkus

Eclipse MicroProﬁle

● An open-source community speciﬁcation
● Focus on Enterprise Java microservices
● Generates: SPEC, API, and TCK.
● https://microproﬁle.io
● Implemented by different vendors.

MicroProﬁle 3.3
JAX-RS 2.1JSON-P 1.1CDI 2.0
Conﬁg
Fault
Tolerance
JWT
Propagation
HealthMetrics
Open
Tracing
Open API Rest Client
JSON-B 1.0

Eclipse Foundation
https://www.eclipse.org/membership/documents/eclipse-foundation-overview.pdf
360+
Projects
275+
Members
1550+
Committers
195M+
Lines of code
15
Years
30
Members

Eclipse foundation, EE4J, JavaEE, and JakartaEE

MicroProﬁle Implementations

Apache TomEE

● Apache Tomcat + Java EE = Apache TomEE
● Built from Apache components
● MicroProﬁle compliant
● Footprint: 30MB zip, 100~MB memory
● TomEE 9.0.0-M2 (javax -> jakarta)
● tomee.apache.org

TomEE JAX-RS (~ Microproﬁle)
TomEE JAX-RS Microproﬁle
Java Server Pages
(JSP)
Java Server Faces
(JSF)
Java Transaction
API (JTA)
Bean Validation
Enterprise
JavaBeansJavaMail API
Java API for RESTful
Web Services
(JAX-RS)
Java Persistence
API (JPA)
Contexts and
Dependency
Injection (CDI)
Java Servlets
Java Authentication
and Authorization
Service (JAAS)
Java Authorization
Contract for
Containers (JACC)

New to TomEE?
https://www.katacoda.com/cesarhernandezgt/scenarios/1

https://start.microproﬁle.io
Hola mundo
1. unzip demo
2. cd demo
3. mvn package tomee:run
4. http://localhost:8080/data/hello
5. Revisa la estructura del proyecto en
tu IDE.

● Command-line Interface
● Visual Studio Code extension
start.microproﬁle.io
https://microprofile.io/2019/07/08/command-line-interface-for-microprofile-starter-is-available-now/
https://microprofile.io/2019/09/17/announcing-visual-studio-code-extension-for-microprofile-starter/
https://www.tomitribe.com/blog/how-to-create-a-microservice-with-eclipse-microprofile-and-apache-tomee/

MicroProfile Specifications

MicroProﬁle 3.3
JAX-RS 2.1JSON-P 1.1CDI 2.0
Conﬁg
Fault
Tolerance
JWT
Propagation
HealthMetrics
Open
Tracing
Open API Rest Client
JSON-B 1.0
● Why?
● How?
● Code
● Integrate

MicroProﬁle Health

Health Feature
● Probes state of services and resources.
● Infrastructure beneﬁts
● It’s intended as a machine to machine (M2M) mechanism
● Examples: CloudFoundry Health Checks and Kubernetes Liveness and
Readiness Probes.

Familiarize yourself with the API
● Default endpoints:
○ http://host:port/health
○ http://host:port/<app-context>/health
● General output:
○ {"checks":[],"outcome":"UP","status":"UP"}

{
"status": "UP",
"checks": [
{
"name": "second-check",
"status": "UP"
}
]
}
Producer Consumer
Health
Check
Procedure
DB

{
"status": "UP",
"checks": [
{
"name": "spotify-service",
"status": "UP",
"data": {
"key": "foo",
"foo": "bar"
}
},
{
"name": "db-check",
"status": "UP"
}
]
}
Producer Consumer
DB
Service

¿Cómo puedo seguir aprendiendo?

Recursos de ayuda
● https://microprofile.io/
● https://tomee.apache.org/
● https://github.com/apache/tomee
● https://www.tomitribe.com/blog/category/microprofile/
● https://kodnito.com/posts/building-an-api-backend-with-microprofile-
ebook/

Descargar los Ejemplos
1. wget https://github.com/apache/tomee/archive/tomee-8.0.2.zip
2. unzip tomee-8.0.2.zip
3. cd tomee-tomee-8.0.2/examples/
4. cesar:examples$ ll -d mp-*
mp-config-example/ mp-faulttolerance-timeout/
mp-metrics-gauge/ mp-rest-client/
mp-config-source-database/ mp-jsonb-configuration/
mp-metrics-histogram/ mp-rest-jwt/
mp-custom-healthcheck/ mp-jwt-bean-validation/
mp-metrics-metered/ mp-rest-jwt-jwk/
mp-faulttolerance-fallback/ mp-jwt-bean-validation-strongly-typed/
mp-metrics-timed/ mp-rest-jwt-principal/
mp-faulttolerance-retry/ mp-metrics-counted/
mp-opentracing-traced/ mp-rest-jwt-public-key/
Descripciones de los ejemplos: https://tomee.apache.org/tomee-8.0/examples/

MicroProﬁle Conﬁguration

● External configuration
● Cloud Native development lifecycle
● Influences and History
○ DeltaSpike Config (http://deltaspike.apache.org/documentation/configuration.html)
○ Extracted parts of DeltaSpike Config (https://github.com/struberg/javaConfig/)
○ Apache Tamaya (http://tamaya.incubator.apache.org/)

MicroProﬁle conﬁg examples
import org.eclipse.microprofile.config.inject.ConfigProperty;
@Inject
@ConfigProperty(name = "injected.value")
private String value;
@Inject
@ConfigProperty(name = "app.year", defaultValue = "2020")
private int year;

● Where to store configurations?
○ The default config sources always available by default are:
■ System properties (ordinal=400)
■ Environment properties (ordinal=300)
■ /META-INF/microprofile-config.properties (ordinal=100)
○ The priority will be used to order the ConfigSource implementations to search for
the configuration key.

MicroProﬁle Metrics

Telemetry
● Uniﬁed Monitoring data ("Telemetry")
● Uniﬁed Java API
● Polyglot environment
● Open standards API path

Difference to health checks
● Health checks
○ "Is my application still running ok?".
● Metrics:
○ Determine the overall the microservices health.
○ Provide long term trend data.

● Application Scope Rest endpoint
● Metrics aggregation services
● Metrics types:
○ @Counted
○ @Gauge
○ @Metered
Metrics API
○ @Timed
○ Histogram

Metrics aggregation services

Ejemplo de Metrics

MicroProﬁle JWT

What is JWT?
● Stands for JSON Web Token.
● It’s a JSON-based text format for exchanging information between
parties.
● It’s an open standard speciﬁed under RFC 7519.
● Standards such as OpenID Connect and OAuth 2 use JWT to represent
their own tokens.

https://tribestream.io/tools/jwt

● Standard
● Interoperability across the enterprise and vendors that favors
microservices development.
● JWT can be both veriﬁed and propagated by each microservice.
Why do we need MicroProﬁle JWT?

MicroProﬁle JWT big picture

JsonWebToken
import javax.ws.rs.Path;
import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import org.eclipse.microprofile.jwt.JsonWebToken;
@Path("/pizza")
@RequestScoped
public class PizzaEndpoint {
@Inject
private JsonWebToken callerPrincipal;
@Inject
@Claim("address") // Custom claim
private JsonObject address;

● Cons
○ Base64 encoding isn’t encryption
○ Larger Payload
○ Token Expiration
● Pros
○ JSON
○ Speed and Reliability
○ Secure
○ Claims
The Pros and Cons to using JWT

Example

MicroProﬁle Fault Tolerance

The Rise of Resilience and Eventual Consistency
● Distributed systems
● All-or-nothing approach.
● Resilience
● Design patterns under the Fault Tolerance umbrella:
○ Bulkhead – isolate failures in part of the system.
○ Circuit breaker – offer a way to fail fast.
○ Retry – deﬁne criteria on when to retry.
○ Fallback – provide an alternative solution for a failed execution.
○ Timeout

@Timeout @Retry
import org.eclipse.microprofile.faulttolerance.Timeout;
@Timeout(500)
public String callSomeServiceLogic() {...}
@Retry(retryOn = IOException.class)
public String callSomeServiceLogic() {...}
@Timeout(500)
@Retry(maxRetries = 1)
public String callSomeService() {...}

Creando Microservicios con
Java, MicroProﬁle y TomEE
Thank you

Creando microservicios con Java MicroProfile y TomEE - OGBT

More Related Content

What's hot

Similar to Creando microservicios con Java MicroProfile y TomEE - OGBT

More from César Hernández

Recently uploaded

Creando microservicios con Java MicroProfile y TomEE - OGBT