October 30, 2018 Product Developers Urban Malc

KumuluzEE Fault Tolerance 1.0.1 released

We are happy to announce the release of KumuluzEE Fault Tolerance 1.0.1. This release brings improved compatibility with the MicroProfile specification.

KumuluzEE Fault Tolerance is now integrated with MicroProfile Config, which enables greater flexibility when configuring fault tolerance mechanisms. Check out the MicroProfile specification to learn about various ways to influence fault tolerance behavior directly from the configuration files (or other configuration sources).

We have also added another implementation of Circuit Breaker alongside existing Hystrix implementation. The main feature of our implementation is the support for the successThreshold parameter and full compatibility with the MicroProfile specification.

October 18, 2018 Product Announcement Developers Benjamin Kastelic

KumuluzEE JWT Auth 1.0.1 released

We’re announcing the release of the KumuluzEE JWT Auth 1.0.1. This release adds the MP-JWKS support for KumuluzEE JWT Auth. This allows the library to use JWKS as a source of verification keys.

More details about this release can be found on GitHub.

Please note that this release is not yet compliant with the MicroProfile JWT Auth 1.1 specification. A new version will be available in the near future.

October 12, 2018 Product Developers Urban Malc

KumuluzEE Testing 1.1.0 released

We’re announcing the release of the KumuluzEE Testing 1.1.0. The KumuluzEE Arquillian Container Adapter has been updated and delivers improved dependency handling, better exception reporting, support for Uber JAR package deployment and more.

October 12, 2018 Product Announcement Developers Domen Kajdič

KumuluzEE GraphQL officially released!

After a few months of development and testing, KumuluzEE GraphQL is now officially released. You can now use GraphQL in your microservices. Extension is designed to be as user-friendly as possible; you can create your first GraphQL endpoint with as little as two annotations in the code!

Features:

  • GraphQL endpoint setup using the KumuluzEE servlet,
  • GraphiQL integration,
  • Code-first style of developing (schema is automatically created from annotated GraphQL resolver functions; using the GraphQL SPQR)
  • Built-in utilities for pagination, sorting and filtering,
  • Integration with KumuluzEE REST for optimized JPA queries,
  • Integration with KumuluzEE Security for securing your endpoint,
  • Wide JDK support (from Java 8-11).

Get started with the extension by checking out samples at GitHub. Source code and documentation can be found here.

October 12, 2018 Product Announcement Developers Matija Kljun

KumuluzEE Event Streaming 1.0.0 released

We’re happy to announce the KumuluzEE Event Streaming extension v1.0.0 for the KumuluzEE framework.

The extension enables developers to easily integrate their microservices with the Apache Kafka platform, produce and consume events, and build stream processors. All the features can be easily implemented with provided annotations.

October 11, 2018 Product Announcement Developers Primož Hrovat

KumuluzEE-gRPC extension v1 released!

We are happy to announce first stable release of KumuluzEE-gRPC extension. This extension provides an easy way to include gRPC communication protocol in your existing KumuluzEE microservices. Define API (using Protobufs), extend generated classes, provide configuration and you are good to go! gRPC client is also supported, basic configuration is provided automatically to you by extension. For more advanced scenarios, you should consider using grpc-java library directly. This release supports JWT token based authentication and client-server verification using asymetric crypthography.

Features:

  • Added gRPC communication protocol to KumuluzEE services
  • Support for authentication using JWT and asymetric cryptography

Source code and documentation: GitHub Sample: GitHub

NOTE

JDK8 is the highest version currently supported. JDK9+ will be included in the near future.

October 3, 2018 Product Announcement Developers Urban Malc

KumuluzEE 3.0.0 is released!

We are happy to announce the final release of the KumuluzEE 3.0.0. The new major release brings full support for Java 9+ and support for Java EE 8 with some new components and a bunch of updated components.

The following components from Java EE 8 have been added:

  • JSON-B 1.0
  • Java Mail 1.6

We’re including the reference implementation for both of the new components, with alternative implementations planned in the future when they become available.

The following components were updated to their Java EE 8 versions:

  • JSF 2.3
  • JPA 2.2
  • JAX-RS 2.1
  • CDI 2.0
  • Bean Validation 2.0
  • JSON-P 1.1

All implementations of the listed components have been updated to the latest Java EE component versions, so you’re free to use any of them.

October 2, 2018 Product Developers Announcement Zvone Gazvoda

KumuluzEE Swagger 1.2.0 released!

New release of KumuluzEE Swagger has arrived. With version 1.2.0 we are bringing new features and enhancements.

Features:

  • Added support for OAuth authentication to SwaggerUI.

Enhancements:

  • Added support for hostname and base path overriding by setting kumuluzee.swagger.base-url.
July 10, 2018 Product Developers Announcement Zvone Gazvoda

KumuluzEE OpenAPI 1.0.0 is released!

The first version of the KumuluzEE OpenAPI extension is now available.

KumuluzEE OpenAPI project allows you to document microservice APIs using OpenAPI v3 compliant annotations. The extension will automatically hook-up servlet that will serve your API specifications. Furthermore, the extension allows you to integrate Swagger-UI into your microservice that will visualize APIs documentation and allow you to interact with your API resources.

The extension supports JDK9+.

Read more at KumuluzEE OpenAPI

June 19, 2018 Product Developers Urban Malc

KumuluzEE Testing released

We’re announcing the first release of the KumuluzEE Testing tools. The first release contains the KumuluzEE Arquillian Container Adapter, which brings the popular integration testing framework Arquillian to the KumuluzEE.

April 24, 2018 Product Developers Domen Kajdič

Introducing KumuluzEE GraphQL extension (1.0.0-SNAPSHOT)

We have released the first snapshot of KumuluzEE GraphQL extension.

GraphQL is a data query language developed internally at Facebook in 2012 before being publicly released in 2015. It provides an alternative to REST and ad-hoc webservice architectures. It allows clients to define the structure of the data required, and exactly the same structure of the data is returned from the server. It is a strongly typed runtime which allows clients to dictate what data is needed. This avoids both the problems of over-fetching as well as under-fetching of data.

KumuluzEE GraphQL enables you to easily create your GraphQL endpoint or convert an exsisting REST endpoint with the use of annotations. Learn more about GraphQL or get started with a basic sample.

March 18, 2018 Product Developers Announcement Zvone Gazvoda

KumuluzEE Swagger 1.0.0 release is here!

We’re happy to announce the initial version of the KumuluzEE Swagger extenion v1.0.0 for the KumuluzEE framework.

KumuluzEE Swagger (OpenAPI 2.0) extension provides support for documenting APIs using Swagger/OpenAPI v2 compliant annotations. Extension automatically hooks-up servlet that exposes API specification on endpoint /api-specs//swagger.[json|yaml]. Extension also provides SwaggerUI which is added to your project to visualize API documentation and allow API consumers to interact with API endpoints.

March 11, 2018 Product Announcement Developers Tilen Faganel

KumuluzEE 3.0.0 beta 1 release with Java EE 8 and Java 9+ is here!

We’re exited to announce the first Beta of KumuluzEE version 3.0.0. It’s the first of a series of prerelease versions that will feature full support for Java EE 8 as a baseline for KumuluzEE components, replacing Java EE 7. We’re also bringing better support for Java 9 and above, with continuously increased streamlined modules support throughout the betas.

This release focuses on updating all Java EE components available in KumuluzEE to their Java EE 8 versions as well as further integration between them. Updated components are:

  • JSF 2.3
  • JPA 2.2
  • JAX-RS 2.1
  • CDI 2.0
  • Bean Validation 2.0
  • JSON-P 1.1

All implementations of the listed components have been updated to the latest Java EE component versions, so you’re free to use any of them. In addition to the ones listed, this updated also brings the following new components that are new to KumuluzEE:

  • JSON-B 1.0
  • Java Mail 1.6
January 24, 2018 Product Developers Urban Malc

KumuluzEE MicroProfile Metrics now implements MicroProfile Metrics 1.1

KumuluzEE Metrics, an implementation of the Eclipse MicroProfile Metrics API, has been updated to support the Eclipse MicroProfile Metrics 1.1.

New version adds a flag reusable to the Metadata object, which primarily means, that a metric can be injected multiple times in multiple places. Acquisition of global tags was changed from environment variable MP_METRICS_TAGS to MicroProfile Config property with the same name. This means, that global tags can additionally be supplied via the MicroProfile Config extension.

January 24, 2018 Product Developers Jan Meznarič

KumuluzEE MicroProfile Config now implements MicroProfile Config 1.2

KumuluzEE MicroProfile Config, an implementation of the Eclipse MicroProfile Config API, has been updated to support the Eclipse MicroProfile Config 1.2.

New version adds the support for the array converter that converts configuration values into arrays of types with available converters or into types Array, List or Set. Common sense converter, used where there is no corresponding type of converters provided for a given class, and a Class converter are also supported.

January 14, 2018 Product Developers Zvone Gazvoda

KumuluzEE Swagger usage - Updated

KumuluzEE Swagger (OpenAPI 2.0) extension provides support for documenting APIs using Swagger/OpenAPI v2 compliant annotations. Extension automatically hooks-up servlet that exposes API specification on endpoint /api-specs/<jax-rs application-base-path>/swagger.[json|yaml]. Extension also provides SwaggerUI which is added to your project to visualize API documentation and allow API consumers to interact with API endpoints.

More details about Swagger Specification.

Usage

You can enable the KumuluzEE Swagger support by adding the following dependency:

<dependency>
    <groupId>com.kumuluz.ee.swagger</groupId>
    <artifactId>kumuluzee-swagger</artifactId>
    <version>${kumuluzee-swagger.version}</version>
</dependency>
January 14, 2018 Product Developers Zvone Gazvoda

KumuluzEE OpenAPI in action - Updated

KumuluzEE OpenAPI extension allows you to document microservice APIs using OpenAPI v3 compliant annotations. Extension will automatically hook-up servlet that will serve your API specifications on endpoint /api-specs/<jax-rs application-base-path>/openapi.[json|yaml]. Furthermore, extensions allows you to integrate Swagger-UI into your microservice that will visualize APIs documentation and allow you to interact with your APIs resources.

More details: OpenAPI v3 Specification.

Usage

You can enable KumuluzEE OpenAPI support by adding the following dependency:

<dependency>
    <groupId>com.kumuluz.ee.openapi</groupId>
    <artifactId>kumuluzee-openapi</artifactId>
    <version>${kumuluzee-openapi.version}</version>
</dependency>
December 17, 2017 Product Developers Žan Ožbot

Using KumuluzEE Reactive Vert.x

KumuluzEE Reactive is an extension for developing reactive microservices for the KumuluzEE microservice framework.

KumuluzEE Reactive provides integration with Vert.x distributed event bus, integration with Vert.x service discovery, easy-to-use annotations for developing microservices that listen to or produce messages on the Vert.x distributed event bus and a service discovery bridge for importing and exporting services from Vert.x Service Discovery to KumuluzEE Discovery (for Consul and etcd).

December 14, 2017 Product Developers Zvone Gazvoda

Running KumuluzEE microservices on Kubernetes (Part 2)

Implementing cloud-native applications by following microservice architecture brings quite a few challenges. Because of the distributed nature, microservices have to be able to deal with unexpected failures caused by node crashes, deadlocks, connectivity issues etc. To build truly resilient systems, failures have to be tackled with different mechanisms such as circuit breakers, retries/timeouts and health checks, at the same time in order to cover all the aspects of the failures.

December 3, 2017 Product Developers Zvone Gazvoda

Running KumuluzEE microservices on Kubernetes (Part 1)

Today Kubernetes is one of the most commonly used runtime platforms for the containerized applications. Providing automatic binpacking, horizontal scaling, automated rollouts and rollbacks, self-healing, service discovery, load balancing and other services out of the box, Kubernetes is a platform that suits microservices down to the ground.

However, equally as important as the utilities provided by the runtime environment is the ability of microservice framework to exploit provided utilities. In this three-part blog, we will demonstrate how KumuluzEE microservice framework is able to make use of Kubernetes for optimal execution of the microservices.

November 9, 2017 Product Developers Jan Meznarič

Eclipse MicroProfile 1.2 with KumuluzEE

KumuluzEE is fully compliant with the Eclipse MicroProfile 1.2 specification. It provides the implementations of the following MicroProfile APIs:

  • Config 1.1
  • Health Check 1.0
  • Metrics 1.0
  • Fault Tolerance 1.0
  • JWT Authentication 1.0

You can use our online pom generator to quicly generate pom files with selected profiles or individual Maven dependencies.

October 27, 2017 Product Developers Zvone Gazvoda

KumuluzEE OpenAPI in action

KumuluzEE OpenAPI was recently updated! with separate dependency for the OpenAPI UI. Check KumuluzEE OpenAPI - Updated

KumuluzEE OpenAPI extension allows you to document microservice APIs using OpenAPI v3 compliant annotations. Extension will automatically hook-up servlet that will serve your API specifications on endpoint /api-specs/<jax-rs application-base-path>/openapi.[json|yaml]. Furthermore, extensions allows you to integrate Swagger-UI into your microservice that will visualize APIs documentation and allow you to interact with your APIs resources.

More details: OpenAPI v3 Specification.

Usage

You can enable KumuluzEE OpenAPI support by adding the following dependency:

<dependency>
    <groupId>com.kumuluz.ee.openapi</groupId>
    <artifactId>kumuluzee-openapi</artifactId>
    <version>${kumuluzee-openapi.version}</version>
</dependency>

OpenAPI configuration

When kumuluzee-openapi dependency is included in the project, you can start documenting your REST API using Swagger-Core Annotations.

Documenting application class

@SecurityScheme(name = "openid-connect", type = SecuritySchemeType.OPENIDCONNECT, 
                openIdConnectUrl = "http://auth-server-url/.well-known/openid-configuration")
@OpenAPIDefinition(info = @Info(title = "Rest API", version = "v1", description = "JavaSI API for managing conference.", 
                    security = @SecurityRequirement(name = "openid-connect"), servers = @Server(url ="http://localhost:8080/v1")))
@ApplicationPath("v1")
public class JavaSiApplication extends Application {...}

Documenting resource class and operations

@Path("sessions")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public class SessionsResource {

    @Operation(description = "Returns list of sessions.", summary = "Sessions list", tags = "sessions", responses = {
            @ApiResponse(responseCode = "200",
                    description = "List of sessions",
                    content = @Content(
                            schema = @Schema(implementation
                            = Session.class)),
                    headers = {@Header(name = "X-Total-Count",
                            schema = @Schema(type = "int"))}
                    )})
    @SecurityRequirement(name = "openid-connect")
    @GET
    public Response getSessions() {...} 
    ...
}
October 25, 2017 Product Developers Zvone Gazvoda

KumuluzEE Swagger usage

KumuluzEE Swagger was recently updated! with separate dependency for the Swagger UI. Check KumuluzEE Swagger - Updated

KumuluzEE Swagger (OpenAPI 2.0) extension provides support for documenting APIs using Swagger/OpenAPI v2 compliant annotations. Extension automatically hooks-up servlet that exposes API specification on endpoint /api-specs/<jax-rs application-base-path>/swagger.[json|yaml]. Extension also provides SwaggerUI which is added to your project to visualize API documentation and allow API consumers to interact with API endpoints.

More details about Swagger Specification.

Usage

You can enable the KumuluzEE Swagger support by adding the following dependency:

<dependency>
    <groupId>com.kumuluz.ee.swagger</groupId>
    <artifactId>kumuluzee-swagger</artifactId>
    <version>${kumuluzee-swagger.version}</version>
</dependency>

Swagger configuration

When kumuluzee-swagger dependnecy is included in the project, you can start documenting your REST API using Swagger-Core Annotations.

Documenting application class

@SwaggerDefinition(info = @Info(title = "CustomersAPI", version = "v1.0.0"), host = "localhost:8080")
@ApplicationPath("v1")
public class CustomerApplication extends Application { ... }

Documenting resource class and operations

@Path("customer")
@Api
@Produces(MediaType.APPLICATION_JSON)
public class CustomerResource {

    @GET
    @ApiOperation(value = "Get customers list", tags = {"customers"}, notes = "Returns a list of customers.")
    @ApiResponses(value = {@ApiResponse(message = "List of customers", code = 200, response = Customer.class)})
    public Response getCustomers() {

        List<Customer> customers = new ArrayList<>();
        Customer c = new Customer("1", "John", "Doe");

        customers.add(c);

        return Response.status(Response.Status.OK).entity(customers).build();
    }
}
October 24, 2017 Product Developers Zvone Gazvoda

KumuluzEE Swagger extension

KumuluzEE Swagger extension is released! You can now provide Swagger/OpenAPI v2 specification for your APIs simply by including KumuluzEE Swagger dependency and annotating your REST API. KumuluzEE Swagger will expose Swagger specification for your API when your microservice is started.

September 28, 2017 Product Developers Jan Meznarič

Tutorial: Cloud-native Java EE Microservices with KumuluzEE

We published a tutorial on developing a cloud-native Java EE microservice application, using KumuluzEE microservice framework and KumuluzEE extensions.

In this tutorial we develop a sample application for managing customers and their orders. The application consists of two microservices; one for managing customer entities and one for managing order entities. We demonstrate important cloud-native concepts and functionalities that are essential in microservice architecture, such as dynamic configuration (with config server), service discovery, fault tolerance, centralized logging, performance metrics collection, and security mechanisms.

September 26, 2017 Product Developers Zvone Gazvoda

Using KumuluzEE CORS

KumuluzEE CORS filter extension for the KumuluzEE microservice framework supports:

  • Browser script perspective: Allowing cross-domain requests, which are subject to tihter controls on the types of data that is exchanged. Cookies, for instance, are blocked unless specifically requested by the XHR author and allowed by the cross-domain web-service.
  • Web service perspective: By utilising the origin URL reported by the browser the target cross-domain web service can determine, based on its origin policy, wheather to allow or deny the request.

Usage

To enable Cross-Origin support for your microservice you need to include the following dependency:

<dependency>
    <groupId>com.kumuluz.ee.cors</groupId>
    <artifactId>kumuluzee-cors</artifactId>
    <version>${kumuluzee-cors.version}</version>
</dependency>

CORS filter configuration

CORS filter can be configured in two ways: using @CrossOrigin annotation or using servlet filter by providing cors-filter configuration section in prefered config source (i.e. config.yaml, etcd etc.).

@CrossOrigin annotation

Annotation can be put on the following classes of the JAX-RS application:

  • Application class (with @ApplicationPath annotation)
  • Resource classes (classes with annotation @Path)
  • Resource operations
September 17, 2017 Product Developers Benjamin Kastelic

Using KumuluzEE Security

KumuluzEE Security is a security extension for the KumuluzEE microservice framework. It provides support for OpenID authentication through standard Java EE security annotations for roles. It is specifically targeted towards securing REST services. Roles are mapped to the selected OpenID provider. KumuluzEE Security has been designed to work with different OpenID providers. Currently only Keycloak is supported. Contributions for other OpenID providers are welcome.

Usage

You can enable the KumuluzEE Security authentication with Keycloak by adding the following dependency:

<dependency>
    <groupId>com.kumuluz.ee.security</groupId>
    <artifactId>kumuluzee-security-keycloak</artifactId>
    <version>${kumuluzee-security.version}</version>
</dependency>
September 15, 2017 Product Developers Urban Malc

Using KumuluzEE Discovery

KumuluzEE Discovery is a service discovery extension for the KumuluzEE microservice framework. It provides support for service registration, service discovery and client side load balancing.

KumuluzEE Discovery provides full support for microservices packed as Docker containers. It also provides full support for executing microservices in clusters and cloud-native platforms with full support for Kubernetes.

KumuluzEE Discovery has been designed to support modularity with pluggable service discovery frameworks. Currently, etcd and Consul are supported. In the future, other discovery frameworks will be supported too (contributions are welcome).

Usage

You can enable etcd-based service discovery by adding the following dependency:

<dependency>
    <groupId>com.kumuluz.ee.discovery</groupId>
    <artifactId>kumuluzee-discovery-etcd</artifactId>
    <version>${kumuluzee-discovery.version}</version>
</dependency>

You can enable Consul-based service discovery by adding the following dependency:

<dependency>
    <groupId>com.kumuluz.ee.discovery</groupId>
    <artifactId>kumuluzee-discovery-consul</artifactId>
    <version>${kumuluzee-discovery.version}</version>
</dependency>
September 11, 2017 Product Developers Luka Šarc

Using KumuluzEE Fault Tolerance

KumuluzEE Fault Tolerance is a fault tolerance extension for the KumuluzEE microservice framework. It provides support for fault tolerance and latency tolerance with circuit breaker, bulkhead, timeout, retry and fallback patterns. KumuluzEE Fault Tolerance supports basic fault tolerance configuration using annotations. Additionally, configuring via KumuluzEE Config is supported. Dependency calls are wrapped and executed using Hystrix, a latency and fault tolerance library.

Usage

You can enable the KumuluzEE Fault Tolerance with Hystrix by adding the following dependency:

<dependency>
    <groupId>com.kumuluz.ee.fault.tolerance</groupId>
    <artifactId>kumuluzee-fault-tolerance-hystrix</artifactId>
    <version>${kumuluzee-fault-tolerance.version}</version>
</dependency>
September 8, 2017 Product Developers Marko Škrjanec

KumuluzEE Logs extension

We are announcing the release of KumuluzEE Logs extension version 1.3.0.

This version marks an important milestone, since the extension was restructured and Java Util Logging implementation was added to the existing Log4J2 implementation. Beside the restructuring and another implementation the logging extension can now be configured by KumuluzEE Config.

More details at KumuluzEE Logs.

September 3, 2017 Product Developers Luka Šarc

KumuluzEE Fault Tolerance extension

We are announcing the release of KumuluzEE Fault Tolerance extension which provides support for fault tolerance patterns. Circuit breaker, retry, bulkhead, timeout and fallback patterns are available. We are partially supporting Microprofile Fault Tolerance and are planning to fully support the specification with the final release of API.

More details at KumuluzEE Fault Tolerance.

August 13, 2017 Product Developers Zvone Gazvoda and Matjaz B. Juric

KumuluzAPI - API Monitoring

Monitoring of APIs is one of the essential functionalities of API Management tools. API Gateways collect and record different metrics of API invocations.

API Monitoring in KumuluzAPI

KumuluzAPI provides multiple API monitoring views with different granularity. One of the most important monitoring views provided on the level of the API. KumuluzAPI allows you to view metrics for each environment and runtime platform on which API is running. The following metrics are recorded for each API:

  • Usage - shows number of API calls on the level of API, API endpoint and client application.
  • Response type - shows the statistic of API calls based on the response type (success, fail and error). Statistics are shown for the level of API, API endpoint and client application.
  • Duration - shows the average response type on the level of API, API endpoints and client applications.
  • Availability - shows the API availability monitoring status which is performed periodically by KumuluzAPI to detect API unavailability (it also includes automatic alerts to inform API owner).

All metrics can be viewed for the following time periods: 1 hour, 24 hours, 7 days, 30 days and 90 days.

The following picture shows response type view metrics on the level of API:

API level Response type statistics

May 3, 2017 Product Developers Tilen Faganel and Matjaz B. Juric

Develop microservices with Java EE and KumuluzEE - updated

This article explores the way the microservices can be used together with Java EE using KumuluzEE. It expands on the benefits and drawbacks compared to the monolithic architecture that’s popular in Java EE. It shows how to quickly and simply develop two microservices with standard Java EE using KumuluzEE. You can find the examples produced in this article on GitHub under the name microservice-simple.

This is an updated version of the original article from 2015.

Why microservices?

The industry standard approach for deploying Java EE applications is packing all components into single EAR/WAR archive and deploying the archive on an application server. Although this approach has several advantages, particularly from the ease-of-development perspective, it leads to monolithic architecture, makes applications difficult to maintain, and - particularly important - makes such applications more difficult and sometimes impossible to scale to meet today’s real world demands, especially in PaaS (cloud) environments.

Microservice architecture addresses these shortcomings by decomposing an application into a set of microservices. Each microservice has well-defined functionalities and an interface to communicate with other microservices (such as REST, WSDL, or if needed even RMI). Most often, microservices are stateless.

Instead of packing all microservices into a single archive (EAR/WAR), each microservice is developed and deployed independently of each other. This brings several advantages, such as:

  • With microservices, applications are more flexible;
  • Every microservice can be developed independently of other microservices, which simplifies lifecycle and change management, makes it easier to use different technologies or upgrade to newer versions;
  • Makes it easier to adopt new technologies for parts of an application;
  • Makes it much more efficient to scale applications in PaaS and Docker-like environments.
June 4, 2015 Product Developers Tilen Faganel and Matjaz B. Juric

Microservices with Java EE and KumuluzEE

This article explores the way the microservice architecture can be used together with Java EE using the new KumuluzEE framework. It expands on the benefits and drawbacks compared to the monolithic architecture that’s popular in Java EE. It shows how to quickly and simply develop two microservices with standard Java EE using KumuluzEE. You can find the examples produced in this article on GitHub under the name microservice-simple.

Why microservices?

The industry standard approach for deploying Java EE applications is packing all components into single EAR/WAR archive and deploying the archive on an application server. Although this approach has several advantages, particularly from the ease-of-development perspective, it leads to monolithic architecture, makes applications difficult to maintain, and - particularly important - makes such applications more difficult and sometimes impossible to scale to meet today’s real world demands, especially in PaaS (cloud) environments.

Microservice architecture addresses these shortcomings by decomposing an application into a set of microservices. Each microservice has well-defined functionalities and an interface to communicate with other microservices (such as REST, WSDL, or if needed even RMI). Most often, microservices are stateless.

Instead of packing all microservices into a single archive (EAR/WAR), each microservice is developed and deployed independently of each other. This brings several advantages, such as:

  • With microservices, applications are more flexible;
  • Every microservice can be developed independently of other microservices, which simplifies lifecycle and change management, makes it easier to use different technologies or upgrade to newer versions;
  • Makes it easier to adopt new technologies for parts of an application;
  • Makes it much more efficient to scale applications in PaaS and Docker-like environments.

Subscribe to our mailing list

Subscribe to our mailing list to get the latest news and updates.