MicroProfile

The JAX-RS, CDI, JSON-B, and JSON-P Java EE technologies provide the base for MicroProfile. If you’re new to Java EE and MicroProfile, this is a good place to start. JAX-RS is a Java API that allows you to build REST APIs by creating resource classes and adding appropriate annotations to create the necessary web endpoints. Context and Dependency Injection (CDI) provides objects with the dependencies that they need through the @Inject annotation rather than directly creating an object or finding them using a factory. JSON-P and JSON-B make it easy to automatically serialize and deserialize classes to and from JSON.

Try it now: Learn how to create a REST service with JAX-RS, JSON-P, and Open Liberty in our guide to Creating a RESTful web service.

MicroProfile Rest Client provides a type-safe approach for invoking REST services over HTTP. This API greatly simplifies the client-side API as defined by JAX-RS. MicroProfile Rest Client handles the communication between the client and service. You only need to define and annotate an interface that describes the actions that you need to perform on a REST resource. An implementation of this interface is automatically generated for you when CDI is used to inject your client into a dependent class.

Try it now: Learn how to use MicroProfile Rest Client to invoke RESTful microservices over HTTP in a type-safe way in our guide to Consuming RESTful services with template interfaces.

For more information, see REST clients.

MicroProfile OpenAPI provides a Java API for the OpenAPI specification that you can use to expose API documentation for your REST APIs. You can natively produce OpenAPI documents from your JAX-RS applications. OpenAPI is a standardization of the Swagger specification.

Try it now: Explore how to document and filter RESTful APIs by using MicroProfile OpenAPI in our guide to Documenting RESTful APIs.

For more information, see API documentation with OpenAPI.

MicroProfile Fault Tolerance provides an API and annotations for building robust behavior to cope with unexpected failures in the service you depend on. Aspects of fault tolerance include timeouts, retries, fallbacks, bulkhead processing, and circuit breakers.

Try it now: Explore how to manage the impact of failures by using MicroProfile Fault Tolerance in the following guides that are written by our team:

For more information, see Fault tolerance in microservices.

MicroProfile JSON Web Token (JWT) provides for interoperable authentication and role-based access control for your services. It allows an authenticated JWT token to be shared across multiple microservices even if these services are running on multiple vendor implementations. It also allows access to microservice operations to be controlled based on user and role information that is passed within the JWT token.

Try it now: Explore how to control user and role access to microservices with MicroProfile JWT in our guide to Securing microservices with JSON Web Tokens.

For more information, see Single sign on: JSON Web Token.

MicroProfile Config externalizes configuration from the application to improve portability of the application. A core principle is to be able to override configuration at deployment time by using system properties and environment variables. This capability means you can build your microservice once and deploy it many times through your CI/CD pipeline by changing the configuration for each deployment.

Try it now: Learn how to configure microservices using MicroProfile Config in these guides, written by our team:

For more information, see External configuration of microservices.

MicroProfile Health Check provides a common REST endpoint format to determine whether a microservice is healthy or not. Health can be determined by the service itself and might be based on the availability of necessary resources (for example, a database) and services. The service itself might be running but considered unhealthly if the things it requires for normal operation are unavailable. The Health Check endpoints are also designed to be easily integrated into Kubernetes liveness and readiness probes.

Try it now: Explore how to report and check the health of a microservice with MicroProfile Health in these guides, written by our team:

For more information, see Health checks for microservices.

MicroProfile Metrics provides common REST endpoints for monitoring the telemetry data of a running microservice, similar in nature to JMX, but a much simpler API that uses JAX-RS. Both built-in and application-defined metrics are accessible, with the output in either JSON or Prometheus text formats. This API provides more extensive detail than the simple up and down reporting provided by MicroProfile Health.

Try it now: Explore how to provide system and application metrics from a microservice with MicroProfile Metrics in our guide to Providing metrics from a microservice.

For more information, see Microservice observability with metrics.

MicroProfile OpenTracing allows services to easily participate in a distributed tracing environment. OpenTracing defines behaviors and an API for accessing an OpenTracing-compliant Tracer object within your microservice. These trace logs can then be consumed by a third-party distributed tracing facility such as Zipkin or Jaeger.

Try it now: Explore how to enable and customize tracing of JAX-RS and non-JAX-RS methods by using MicroProfile OpenTracing in our guide to Enabling distributed tracing in microservices.

Concurrency, or the ability to coordinate and track multiple tasks at once, is a key capability in microservice-based applications. MicroProfile Context Propagation enhances Java SE and Java EE concurrency support by providing context awareness between concurrent tasks, which improves consistency and visibility across an application. With MicroProfile Context Propagation, your applications react to events as they happen, under a dependable thread context, and backed by the performance of Liberty threading.

Try it now: Explore how to obtain consistent, reliable thread contexts with MicroProfile Context Propagation in our overview of Concurrency with MicroProfile Context Propagation.

Try it now: Learn how to implement pipelines that manage flow-control and error handling in this blog post on Reactive programming in microservices.

For more information, see Concurrency in microservices.

MicroProfile Reactive Messaging provides an easy way to send, receive, and process messages between microservices in an application. It also provides a Connector API that enables your methods to be connected to external messaging systems. With MicroProfile Reactive Messaging, Liberty converts your annotated application bean methods to reactive streams-compatible publishers, subscribers, and processors, and connects them to each other.

Try it now: Explore how to enable messaging between your microservices and with external systems in our blog post on Sending and receiving messages between microservices with MicroProfile Reactive Messaging

MicroProfile Reactive Streams Operators provides a way to implement publish/subscribe pipelines that provide flow control and elegant error handling for asynchronous data streams. This implementation enables the processing of streams of data without publishers overwhelming downstream subscribers. Reactive Streams Operators can increase efficiency under potentially overloading conditions by using a ticketing system that creates 'back pressure' between the publisher and subscriber. Because you can directly connect publishers and subscribers regardless of underlying technology, Reactive Streams Operators serves as an abstraction that can efficiently bind together different technologies.