Why Teams call analytics are critical to your entire business
Introduction to Eclipse Microprofile
1. Eclipse MicroProfile
Enterprise Java microservices specification
Cesar Saavedra
Senior Principal Product Marketing Manager - EAP & MicroProfile
@cesar_saavedr
October 2017
2. 2
● Eclipse MicroProfile is an open-source community specification for
Enterprise Java microservices
● A community of individuals, organizations, and vendors
collaborating within an open source (Eclipse) project to bring
microservices to the Enterprise Java community
What is Eclipse MicroProfile?
4. 4
Java Community Process
Standards organization
Large multi-feature releases
Spec Lead controls pace
Eclipse MicroProfile
(Open Source) Project
Incremental feature release
Community controls pace
Innovation vs. Standardization
5. 5
Time between Java EE releases
JPE J2EE 1.2 J2EE 1.3 J2EE 1.4 Java EE 5 Java EE 6 Java EE 7 Java EE 8
19 mos
21 mos
25 mos
30 months
42 months
42 months
52 months
8. 8
Eclipse MicroProfile 1.1 (August, 2017)
MicroProfile 1.1
= New
= No change from last release
JAX-RS 2.0JSON-P 1.0CDI 1.2
Config 1.0
9. 9
Applications need to be configured based on a running environment. It
must be possible to modify configuration data from outside an
application so that the application itself does not need to be repackaged
Configuration 1.0
Dev
Test
Prod
10. 10
Multiple projects directly influenced this proposal and acted as basis for
this API, such as:
● 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/)
● Sabot, merged into Tamaya (https://tomitribe.io/p/sabot)
Current implementations:
● Apache Geronimo Config
● WebSphere Liberty (Beta)
Configuration 1.0 - Influence and Implementations
11. 11
● MicroProfile Configuration 1.0 was introduced as a Java
Specification Request to the Java Community Process Executive
Committee meeting on August 2017
● At the September 2017 EC meeting, Eclipse will formally propose
the Configuration JSR for discussion and vote
● This fulfills one of the goals of Eclipse MicroProfile to serve as an
innovation open source project to the Java community in regards to
Enterprise Java microservices
Configuration 1.0 - as a JSR
12. 12
● Contexts and Dependency Injection (CDI 1.2)
● Java API for RESTful Web Services (JAX-RS 2.0)
● Java API for JSON Processing (JSON-P 1.0)
● Eclipse MicroProfile Specification PDF document
● Config 1.0:
o Technology Compatibility Kit (TCK)
o Javadocs
o Config 1.0 Specification PDF document
o API Maven artifact coordinates
o Git tag
Eclipse MicroProfile 1.1 release content
13. 13
Eclipse MicroProfile 1.2 (Q4 CY2017)
MicroProfile 1.2
= New
= No change from last release
JAX-RS 2.0JSON-P 1.0CDI 1.2
Config 1.1
Fault
Tolerance
1.0
JWT
Propagation
1.0
Health
Check 1.0
Metrics 1.0
14. Metrics 1.0
To ensure reliable operation of software it is necessary to monitor essential
system parameters. Metrics adds well-known monitoring endpoints and metrics for
each process
14
Metric Registry
Required Base metrics
Application metrics
Vendor-specific metrics
15. Metrics 1.0 - Influence
Multiple projects directly influenced this proposal and acted as basis for this API,
such as:
● DropWizard Metrics 3.2.3
● CDI extension for DropWizard Metrics 1.4.0
● UoM, JSR 363
● Jolokia JMX-HTTP bridge
● Metrics 2.0
Metrics are different from Health Checks, which are primarily targeted at a quick
yes/no response to the question "Is my application still running ok?".
15
16. Health Check 1.0
Health checks are used to probe the state of a computing node from another
machine (i.e. kubernetes service controller) with the primary target being cloud
infrastructure environments where automated processes maintain the state of
computing nodes
16
17. Health Check 1.0 - Goals
● MUST be compatibility with well known cloud platforms
(i.e. http://kubernetes.io/docs/user-guide/liveness/)
● MUST be appropriate for machine-to-machine
communication
● SHOULD give enough information for a human
administrator
17
18. Fault Tolerance 1.0
Fault tolerance is about leveraging different strategies to guide the execution and
result of some logic. Retry policies, bulkheads, and circuit breakers are popular
concepts in this area. They dictate whether and when executions should take
place, and fallbacks offer an alternative result when an execution does not
complete successfully
18
19. Fault Tolerance 1.0 - Influence and goal
Multiple projects directly influenced this proposal and acted as basis for this API,
such as:
● Hystrix
● Failsafe
Goal:
● Separate the responsibility of executing logic (Runnables/Callables/etc) from
guiding when execution should take place (through retry policies, bulkheads,
circuit breakers)
19
20. JWT Propagation 1.0
The security requirements that involve microservice architectures are strongly
related with RESTful Security. In a RESTful architecture style, services are usually
stateless and any security state associated with a client is sent to the target
service on every request in order to allow services to re-create a security context
for the caller and perform both authentication and authorization checks
20
21. JWT Propagation 1.0 - Influence and goals
Multiple projects/standards directly influenced this proposal and acted as basis for this API, such as:
● OAuth2
● OpenID Connect(OIDC), and
● JSON Web Tokens(JWT)
Goal:
● One of the main strategies to propagate the security state from clients to services or even from
services to services involves the use of security tokens.
● For RESTful based microservices, security tokens offer a very lightweight and interoperable way to
propagate identities across different services.
21
22. Eclipse MicroProfile 1.2 - release content
● Contexts and Dependency Injection (CDI 1.2)
● Java API for RESTful Web Services (JAX-RS 2.0)
● Java API for JSON Processing (JSON-P 1.0)
● Eclipse MicroProfile 1.2 Specification PDF document
22
Config 1.1 Health Check 1.0 Metrics 1.0 Fault Tolerance 1.0 JWT Propagation 1.0
- Product page
- Technology
Compatibility Kit
(TCK)
- Javadocs
- Spec PDF doc
- API Maven artifact
coordinates
- Git tag
- Product page
- Technology
Compatibility Kit
(TCK)
- Javadocs
- Spec PDF doc
- API Maven artifact
coordinates
- Git tag
- Product page
- Technology
Compatibility Kit
(TCK)
- Javadocs
- Spec PDF doc
- API Maven artifact
coordinates
- Git tag
- Product page
- Technology
Compatibility Kit
(TCK)
- Javadocs
- Spec PDF doc
- API Maven artifact
coordinates
- Git tag
- Product page
- Technology
Compatibility Kit
(TCK)
- Javadocs
- Spec PDF doc
- API Maven artifact
coordinates
- Git tag
23. Eclipse MicroProfile 1.3 (Q4 CY2017?)
MicroProfile 1.x
= New
= No change from last release
JAX-RS 2.0JSON-P 1.0CDI 1.2 Config 1.1
Fault
Tolerance
1.0
JWT
Propagation
1.0
Health
Check 1.0
Metrics 1.0
Open
Tracing 1.0
Open API
1.0
Roadmap
24. Eclipse MicroProfile 2.0 (Q4 CY2017?)
MicroProfile 2.0
= New
= No change from last release
JAX-RS 2.1JSON-P 1.1CDI 2.0 Config 1.1
Fault
Tolerance
1.0
JWT
Propagation
1.0
Health
Check 1.0
Metrics 1.0
Open
Tracing 1.0
Open API
1.0
JSON-B 1.0
Roadmap
29. 29
Red Hat OpenShift Application Runtimes (RHOAR)
Providing a key set of integrated and curated runtimes, frameworks and developer tools
INTEGRATED AND MANAGED RUNTIMES
(Container images and Maven artifacts)
JAVA EE
(Red Hat JBoss®
EAP)
MICROPROFIL
E
(WildFly
Swarm)
RED HAT
OPENSHIFT SERVICES
REACTIVE
(vert.x)
NODE.JS
APACHE
TOMCAT
CERTIFIED FRAMEWORKS
(Maven artifacts)
SPRING BOOT /
CLOUD
NETFLIX OSS
Ribbon
OpenShift.io
(Developer
SaaS)
Generators
IDE
etc.
Management
APM
Metrics
Service
discovery
Config.
Logging
Health
check
Load
balancing
CI/CDSSOMessaging IMDG API Mgmt
NETFLIX OSS
Hystrix
...
30. 30
● RHOAR includes both MicroProfile and Spring Boot/Cloud
● MicroProfile is an open source project truly owned and managed by
the community whereas Spring is really managed/run by a single
vendor, Pivotal
● We fully support MicroProfile on RHOAR and certify Spring
Boot/Cloud
MicroProfile and Spring Boot
31. 31
● It’s an open community-based specification
● Open-source implementation in WildFly Swarm
● Fast innovation, constant improvement, and introduction of new
capabilities in specification and implementation
● Little to no learning curve for your experienced Java and Java EE
developers
● Delivered in a container-based polyglot platform, RHOAR
Advantages of using Eclipse MicroProfile
32. Java EE going to The Eclipse Foundation
● Strong experience and involvement with Java EE and related
technologies
● Vendor-friendly, vendor-neutral
● It will help Oracle:
○ transition Java EE rapidly
○ create community-friendly processes for evolving the platform,
and
○ leverage complementary projects such as MicroProfile
33. 33
● Java EE & GlassFish technologies, including RIs, TCKs &
documentation
● Build compatible implementation that passes Java EE 8 TCKs.
● Existing javax package names & “Java” in JSR names remain
● Define branding strategy (new name for Java EE)
● Define process for existing specs to evolve & new specs
● Recruit and enable developers, community members & vendors, to
sponsor platform technologies to bring platform forward, including the
potential incorporation of Eclipse MicroProfile into the platform
What assets are moving over to Eclipse
Oracle’s intention - plans are always subject to change
34. 34
Java EE move to open source foundation
Good news for developers, organizations, and Red Hat
will have a channel
for their innovations,
not owned by any
single company
Java will continue to
innovate for their
needs as they move
apps to containers
We support Java EE
in EAP, as well as in
RHOAR and EAP on
OpenShift
Java developers Enterprises Red Hat
35. Benefits to customers
The future is looking very bright
● COMMUNITY POWERED, not vendor controlled
○ new Java EE functionality that results from community collaboration and market
needs
● FASTER releases
○ new Java EE functionality delivered faster to customers and developers
● EVOLUTION, not revolution
○ continued use of Java EE to develop modern architectures and applications, and
○ cost savings from not having to re-train your developers on another framework
36. 36
● Check out the MicroProfile.io website
● Check out the WildFly Swarm website
● Check out our RHOAR announcement
● Check out the value of a Red Hat Subscription
● Contact your Red Hat account executive if you would like to
participate in our Tech Program for RHOAR
Call to action
37. For help getting started, visit
http://brand.redhat.com/applications/presentations
For more information on how to use this template within Google Slides,
view this step-by-step guide.
Notes de l'éditeur
This presentation is about the open source community project called Eclipse MicroProfile. We will go over what Eclipse MicroProfile is, how Red Hat participates in the open source project, and how Red Hat implements and delivers this product to the market. Lastly, we will go over the benefits of using Eclipse MicroProfile and will make a call to action.
Eclipse MicroProfile is an open-source community that is collaborating around Enterprise Java microservices. The first release was based on 3 Java EE JSRs/libraries/APIs, but this doesn’t necessarily mean that everything that Eclipse MicroProfile does will be Java EE-centric, some API specifications may end up just being part of MicroProfile, depending on the community itself and the spec leads for Java EE.
Eclipse MicroProfile is a community of individuals, vendors, and organizations collaborating to work on microservices patterns for Enterprise Java and integrating our applications with the infrastructures they run on, i.e. a cloud environment, with patterns like health checks, metrics, etc.
This is a list of some of the members that are part of Eclipse MicroProfile. A lot of the vendors are collaborating on the specifications and many of them are creating implementations of the specification on their own products.
One of the questions that’s often asked is how does Eclipse MicroProfile compare to the Java Community Process? Many of the members of MicroProfile are also members of the Java Community Process (JCP). The JCP is a standards organization and is intended to take mature ideas and potentially mature implementations and standardizes them. Eclipse MicroProfile is an innovation project that could potentially lead to JSRs in the future. MicroProfile is able to move much faster and has incremental releases at a much quicker pace, the community can try things that may work out and some things may not, which is part of the innovation process. MicroProfile’s not trying to standardize but innovate.
Java EE has basically come down to roughly a 3 ½ to 4 year cadence in term of releases. This is because, Java EE, as a traditional platform, is relatively mature but it’s also about standardizing mature technologies.
=========
ReleaseDate ReleaseName # of months
5/1/1998 JPE
12/12/1999 J2EE 1.2 19
9/24/2001 J2EE 1.3 21
11/11/2003 J2EE 1.4 25
5/11/2006 Java EE 5 30
12/10/2009 Java EE 6 42 April 20, 2009 Oracle acquires Sun
6/12/2013 Java EE 7 42
9/21/2017 Java EE 8 54?
Goal is to have 2-4 releases per year. Goal is to innovate in open source and to then propose JSRs.
========
However, Eclipse MicroProfile does want to accelerate the adoption of microservices within the Java EE community. MicroProfile is all about innovating. MicroProfile wants to quickly iterate around a lot of these technologies and potentially submit JSRs as well once the MicroProfile community thinks the technology is mature enough within the MicroProfile and the community agrees that it has gone from rapid API change mode to something relatively stable for a specification.
One more thing I’d like to mention is that the implementations of the MicroProfile specification EITHER run within the context of an Java EE application server extending the application server, OR run on standalone implementations that don’t include the full suite of JSRs that are available in the Java EE platform.
MicroProfile 1.0 was released back in September of 2016, at JavaOne 2016; this was before it was part of Eclipse (hence Eclipse was not part of its name). It was limited to very specific Java EE technologies that were relevant to microservices. The project didn’t want to include too many because they wanted community involvement and feedback as to the direction of MicroProfile. So, the project started with a simple set of features and vendors implemented them using their own runtimes and showcased a combined demo (the “Conference Application”) composed of multiple microservices each running on a different vendor implementation and all collaborating around the Conference Application using these technologies.
Eclipse MicroProfile 1.1 was released on August 8, 2017 and it adds the Configuration API to the MicroProfile specification.
The Configuration 1.0 API is all about externalizing a configuration from an application. If you think about traditional application development, this has always been a pain point. Where do you put your configuration? You don’t really want to bind it tightly to your application because as it moves from Dev to Test and to Prod, the configuration options change. In addition, in a cloud environment, where you have a rapidly changing environment, with DevOps and CI/CD processes in place for example, being able to change configuration fast is very important. So the ability to externalize your configuration away from your application is a key feature needed for microservices.
In going about the Configuration API, the Eclipse MicroProfile community didn’t attempt to define it from scratch, reinventing the wheel. Instead, they considered existing projects and implementations, lessons learned, and best practices when designing the Configuration API, which has laid down a common API, which could be implemented by existing projects and implementations, thus giving a developer the option to select which implementation they would like to use.
https://groups.google.com/d/msg/microprofile/rmGrb3kCrJQ/hbf8wL0EBAAJ
Note from Kevin Sutter (MicroProfile leadership member from IBM) on August 31, 2017 (https://groups.google.com/d/msg/microprofile/rmGrb3kCrJQ/XRqOpP-VBwAJ):
“The JSR was "introduced" at the August JCP EC meeting. But, it was not formally proposed. As you know, David gave a quick introductory presentation just to set the stage for the next JCP EC meeting. At the Sept meeting, Mike Milinkovich (Eclipse) will be formally proposed the Configuration JSR for discussion and vote.”
In terms of what Eclipse MicroProfile 1.1, it includes the existing JSRs from MicroProfile 1.0 plus the Configuration 1.0 API. For Config 1.0, it includes a Technology Compatibility Kit that developers can use to test their implementations for compliance with Config 1.0, Javadocs, a spec PDF doc for developers, Maven artifact coordinates, and Git tag.
As we look forward, Eclipse MicroProfile will extend beyond configuration, such as Health Check, Metrics, Fault Tolerance, JWT Propagation, etc. Beyond 1.x and with Java EE 8 coming out soon, the Eclipse MicroProfile will include updates to existing specifications as well as possibly include new JSRs, such as JSON binding (which is new in Java EE 8). These may be in Eclipse MicroProfile 2.0
https://github.com/eclipse/microprofile-config/releases/tag/1.0
- Javadoc
- PDF document for download
- API maven artifact coordinates
- running the TCK
- git tag in the github repository
As we look forward, Eclipse MicroProfile will extend beyond configuration, such as Health Check, Metrics, Fault Tolerance, JWT Propagation, etc. Beyond 1.x and with Java EE 8 coming out soon, the Eclipse MicroProfile will include updates to existing specifications as well as possibly include new JSRs, such as JSON binding (which is new in Java EE 8). These may be in Eclipse MicroProfile 2.0
As we look forward, Eclipse MicroProfile will extend beyond configuration, such as Health Check, Metrics, Fault Tolerance, JWT Propagation, etc. Beyond 1.x and with Java EE 8 coming out soon, the Eclipse MicroProfile will include updates to existing specifications as well as possibly include new JSRs, such as JSON binding (which is new in Java EE 8). These may be in Eclipse MicroProfile 2.0
These are some of the Eclipse MicroProfile implementations. <go through icons across slide>.
The “Conference Application”, first demoed during Devoxx Belgium back in November 2016, is a MicroProfile demo that showcases the integration of different MicroProfile vendor implementations. The demo consisted of a variety of microservices, each implemented by a different vendor implementation of MicroProfile. This demo is maintained by the community and it evolves as releases of MicroProfile come out.
You can find a video of this demo on YouTube:
https://www.youtube.com/watch?v=iG-XvoIfKtg
A MicroProfile-based microservice can be leveraged by many Red Hat offerings. Here are some examples:
3scale could manage the API for a MicroProfile-based microservice
EAP could execute an application that leverages MicroProfile-based microservices
Fuse could host an integration orchestration that invokes MicroProfile-based microservices
Data Grid could call out to a MicroProfile-based microservice as part of a query or computation
BPM Suite could have a BPMN process where activities call out to MicroProfile-based microservices
BRMS could have a rule that invokes MicroProfile-based microservices
Data Virtualization could define a data structure, whose components are populated by calling MicroProfile-based microservices
And, Mobile Application Platform could host a mobile application that invokes MicroProfile-based microservices
So, how does Red Hat deliver MicroProfile to our customers? Red Hat OpenShift Application Runtimes (RHOAR) is our polycloud, polyglot application development and modernization platform.
RHOAR includes, among other runtimes, MicroProfile as implemented in WildFly Swarm. RHOAR includes other runtimes as well, Vert.x, EAP, Node.js, and Tomcat, and it is also has certified versions of Spring Boot, Netflix OSS Ribbon and Hystrix.
Some customers ask us whether they should use MicroProfile or Spring Boot to implement Enterprise Java microservices. The answer is that it depends on what the customer’s preference is. We support both on RHOAR. One important point to bring up, however, is that MicroProfile is a true open source project managed and run by its community whereas Spring is run practically by a single vendor, Pivotal. This is why we can fully support MicroProfile but only certify Spring Boot/Cloud on RHOAR.
<go over each bullet>
We support this move to Eclipse
We support the move to Eclipse and senior individuals at Red Hat were working with IBM and Oracle on this decision. This move will allow a better future for enterprise Java and for the entire Java EE ecosystem than would have remained if the project remained under Oracle's sole control. The acceptance and preference for open source has driven innovations into open source, and the leading platform for the leading software language needs to be held within an open source, open community, open process project / foundation.
Java EE moving to an open source foundation is great news for developers, organizations, Red Hat and you, as EAP sellers. As you probably know, although Java EE was run by the JCP (Java Community Process), an open organization, it was effectively owned and managed by a single company, namely Oracle. So, now that Java EE is going to be under the Eclipse Foundation, it will truly be run and managed by the community, without having a single vendor control the entire project. In addition, we believe that the innovation cadence and evolution of the project will increase with the feedback and input and for the benefit of the entire community. And as far as Red Hat, we have a fully compliant Java EE application server in EAP, and we also support EAP on OpenShift and RHOAR, our multi-cloud, multi-tech, polyglot offering.
=========
That new innovations will be coming
That this move will encourage corporate or individual developers to contribute to the future, new unforseen innovations that benefit the world ecosystem. Because the foundation is fully open source AND open community, that innovations will move here because this will allow innovators the ability to contribute to the world community through an open process.
new Java EE functionality that results from community collaboration and market needs
new Java EE functionality delivered faster to customers and developers
continued use of Java EE to develop modern architectures and applications, and
cost savings from not having to re-train your developers on another framework