March 28, 2023 Product Announcement Developers Urban Malc

KumuluzEE REST 2.0.1 released

We are excited to announce a new major version of KumuluzEE REST - 2.0.1.

This release brings support for Java 17, along with the support for LocalDateTime, LocalDate, LocalTime and OffsetTime temporal fields and a couple of new filters - the BETWEEN and NBETWEEN filters.

The minimum supported Java version is now Java 11. If you are still using older versions of Java, please use the 1.x.x version of KumuluzEE REST instead.

December 3, 2022 Product Announcement Developers Urban Malc

KumuluzEE JCache 2.0.0 released

We are excited to announce the next major version of KumuluzEE JCache - 2.0.0. This release adds support for the newest KumuluzEE version 4 and adds support for Java 17 LTS and Java 18.

This release also uses the new configuration prefix kumuluzee.jcache.caffeine.caches instead of kumuluzee.jcache.caffeine.caffeine.jcache and adds support for the entire configuration framework instead only yaml files, including overriding properties from ENV variables.

December 2, 2022 Product Announcement Developers Urban Malc

KumuluzEE CORS 2.0.0 released

We are excited to announce the next major version of KumuluzEE CORS - 2.0.0. This release adds support for the newest KumuluzEE version 4 and adds support for Java 17 LTS and Java 18. Since the support for Java 1.8 is dropped by KumuluzEE 4.x, the KumuluzEE CORS 2.0.0 also drops support for Java 1.8.

Features

  • Added support for KumuluzEE 4.0.0 and above
  • Added support for Java 17 LTS and Java 18

Note: This release of KumuluzEE Config MP requires the KumuluzEE 4.0 or higher in order to work correctly. Consequently, Java 11 or higher is also required.

Check out the release on GitHub: KumuluzEE CORS v2.0.0

December 1, 2022 Product Announcement Developers Urban Malc

KumuluzEE Rest Client 2.0.0 released

We are excited to announce the next major version of KumuluzEE REST Client - 2.0.0. This release adds support for the newest KumuluzEE version 4 and adds support for Java 17 LTS and Java 18. Since the support for Java 1.8 is dropped by KumuluzEE 4.x, the KumuluzEE REST Client 2.0.0 also drops support for Java 1.8.

Features

  • Added support for KumuluzEE 4.0.0 and above
  • Added support for Java 17 LTS and Java 18

Bugs

  • Fixed issue with @FormParam processing and content-type header

Note: This release of KumuluzEE Config MP requires the KumuluzEE 4.0 or higher in order to work correctly. Consequently, Java 11 or higher is also required.

Check out the release on GitHub: KumuluzEE Rest Client v2.0.0

November 30, 2022 Product Announcement Developers Urban Malc

KumuluzEE Health 2.4.4 released

We have released a minor release of KumuluzEE Health 2.4.4 with the following: This patch release fixes a initialization bug, where built-in health checks were not initialized from configuration. Bugs:

  • Fixed built-in health check configuration detection - use getMapKeys and getListSize instead of yaml-specific Map/List detection, that was removed in KumuluzEE 4.1.0

Note: This release of KumuluzEE Config MP requires the KumuluzEE 4.1.0 or higher in order to work correctly. Consequently, Java 11 or higher is also required.

Check out the release on GitHub: KumuluzEE Health v2.4.4

July 14, 2022 Product Announcement Developers Urban Malc

KumuluzEE MicroProfile Config 2.0.0 released

We are excited to announce the next major release of KumuluzEE Config MP. KumuluzeEE Config MP 2.0.0 implements the MicroProfile Config 2.0 specification, which includes many improvements, among others the support for the @ConfigProperties annotation which extracts bulk config properties into a POJO, the API which allows developers to determine the winning source for a configuration value, and more.

Note: This release of KumuluzEE Config MP requires the KumuluzEE 4.1.0 or higher in order to work correctly. Consequently, Java 11 or higher is also required.

Some of the bigger changes in the MicroProfile Config 2.0 specification like property expressions (configuration value interpolation) and configuration profiles were added to the core KumuluzEE and can be used with or without KumuluzEE Config MP extension. To read more about these changes see the KumuluzEE 4.1.0 release notes.

The @ConfigProperties annotation allows bulk extraction of config properties into a CDI bean and works similarly to the KumuluzEE native @ConfigBundle annotation. It works in the MicroProfile Config’s environment and supports its features (e.g. converters, custom ConfigSource implementations, …). For example, take a look at the following class:

July 4, 2022 Product Announcement Developers Din Music

Announcing KumuluzEE Database Schema Migrations 1.0.0 release

We are pleased to announce the first stable release of the KumuluzEE Database Schema Migration extension for the KumuluzEE microservice framework.

The extension provides an easy way to migrate database schemas with Liquibase. It allows migrations at application startup or, if necessary, when the application is already running. Therefore, the extension can speed up the development process by ensuring that database schemas are up to date when the application starts.

The extension can be configured in the common KumuluzEE configuration file. The only requirement is a configured data source where the schema migrations can be performed. Since the extension is based on the Liquibase, all data sources supported by the Liquibase can be used in conjunction with this extension.

The main advantages of the extension are:

  • Ensures that the database schema is up to date
  • Eliminates the need to perform migrations manually
  • Allows database schema migrations to be managed in the runtime
  • Enables database schema migrations for multiple databases
  • Manages database schema migrations on a per-application basis
  • Optionally starts each application run with fresh database state

To get started quickly, configure the desired data source and link the migration to it.

kumuluzee:
  datasources:
    - jndi-name: jdbc/ExampleDS
      connection-url: jdbc:postgresql://localhost:5432/postgres
      username: postgres
      password: postgres
      pool:
        max-size: 20
  database-schema-migrations:
    liquibase:
      changelogs:
        - jndi-name: jdbc/ExampleDS
          startup:
            drop-all: false
            update: true

For step-by-step guide (example) see KumuluzEE migrations with Liquibase.

February 26, 2022 Product Developers Din Music

KumuluzEE Database Schema Migrations - Liquibase extension

In the rapidly growing world of automation, there is a constant need for application updates. Every change made to the application is nowadays version controlled, making it easy to automate deployment and, if necessary, roll back changes. Today, it is not uncommon to have multiple versions of an application deployed on the same day. Following this pattern, it quickly becomes clear that database schemas need to be managed in the same way.

KumuluzEE is pleased to announce the Liquibase extension for database schema migration. It allows you to migrate your schemas right at the application startup, so that you get the desired database state every time you run the application. Moreover, it also offers a possibility to drop the database before migration, making it a perfect choice for development and testing purposes. Not to be confused, Liquibase migrations via the Maven plugin are still infallible, especially in environments where we want to have full control.

To get started with the Liquibase extension, all you need to do is add the Liquibase database schema migration extension to your existing pom file.

<dependency>
    <groupId>com.kumuluz.ee.database-schema-migrations</groupId>
    <artifactId>kumuluzee-database-schema-migrations-liquibase</artifactId>
    <version>${kumuluzee-database-schema-migrations.version}</version>
</dependency>

Furthermore, the known KumuluzEE configuration file has to be adjusted.

kumuluzee:
  ...
  database-schema-migrations:
    liquibase:
      changelogs:
        - jndi-name: jdbc/example-db
          file: db/changelog-master.xml
          startup:
            drop-all: false           # default: false  
            update: true              # default: false

The above configuration instructs the Liquibase extension to update the current database schemas. The update is performed when the application is started. This involves making changes to a pre-configured data source with the appropriate JNDI name, which in our case is jdbc/example-db. What changes will take place is defined in a Liquibase changelog file (db/changelog-master.xml).

After we have everything set up, we can launch our application and see how it manages the migrations for us.

For more information and detailed walkthrough, we recommend you take a look at the KumuluzEE database schema migrations documentation on GitHub.

If you are not yet familiar with Liquibase, we also recommend you to give it a try.

February 9, 2021 Product Announcement Developers Urban Malc

KumuluzEE GraphQL 1.1.0 released!

We are excited to announce a new minor release - KumuluzEE GraphQL 1.1.0. This release includes a new MicroProfile compatible implementation, we have updated the GraphiQL (GraphQL UI) to support better schema exploration and fixed some bugs in our existing implementation.

To use the new MP-compatible implementation use the following dependency:

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

Note that the existing implementation (artifact kumuluzee-graphql) is still being updated. However, we advise new users to start with the MP implementation since this implementation is more likely to receive new features in the future.

GraphiQL now includes the explorer plugin, which enables you to interactively construct a query or mutation. This makes schema exploration and API usage even easier.

Integration with KumuluzEE REST has also been revamped to be more intuitive and future-proof. Sort and filter arguments are now string-based and limit/offset are now top level arguments. This makes queries more readable and easier to process. The QueryParameters object can be constructed and used with any KumuluzEE REST implementation (currently StreamUtils and JPAUtils).

The samples for MP-compatible implementation are already available:

Features:

  • Added MP-compatible implementation by SmallRye
  • Added GraphiQL Explorer plugin

Enhancements:

  • Converted GraphQL manual kumuluzee-rest processing to StreamUtils
  • Upped dependency versions

Bugs:

  • Fixed GraphiQL servlet mapping
  • Fixed pagination limit bug

Check out the release on GitHub: KumuluzEE GraphQL v1.1.0

June 15, 2020 Product Developers Klemen F.

KumuluzEE Kafka Streaming with Schema Registry

Apache Kafka is an excellent tool enabling asynchronous architecture in the modern microservice world. While Kafka offers very high-level abstractions in the form of Producer/Consumer APIs, Streams API, and Processor APIs, there is no out of the box support for managing the schema of records. Confluent Schema Registry is a tool solving this problem. This guide will show how you can use Schema Registry with kumuluzee-streaming and suggest a typical development flow for this setup.

June 11, 2020 Product Announcement Developers Jan Meznarič

Introducing new KumuluzEE releases

We are announcing new releases in the KumuluzEE family. The new release of the core microservice framework KumuluzEE 3.10.0 brings support for Java 14 and a set of new features and enhancements. Supporting projects, including Config, Security, Rest Client, CORS, REST and JWT Auth, have also been updated.

November 22, 2019 Product Announcement Developers Jan Meznarič

Support for MicroProfile 3.0 is here!

We are happy to announce the release of KumuluzEE 3.6.0. This release includes a brand new profile for MicroProfile 3.0 specification.

MicroProfile 3.0 specification consists of the following components:

  • KumuluzEE Core
  • KumuluzEE Servlet Jetty
  • KumuluzEE CDI Weld
  • KumuluzEE JAX-RS Jersey
  • KumuluzEE JSON-P
  • KumuluzEE JSON-B Yasson

And the following extensions:

Dependency versions have also been updated to their latest versions.

Features:

  • Added MicroProfile 3.0 profile.
  • Added Jetty etag header support for static content.

Enhancements:

  • Upped dependency versions.
  • Added caching EeExtensionGroup in preparation for JCache extension.

Bugs:

  • Downgraded snakeyaml version due to breakage of log4j2 initialization.

More details about this release can be found on GitHub.

September 2, 2019 Product Announcement Developers Blaž Mrak

First version of the KumuluzEE Feature Flags project published

We are pleased to announce the first version of the KumuluzEE Feature Flags project. This version provides support for the Unleash implementation.

KumuluzEE Feature Flags supports feature flags with a few simple methods. Unleash configuration can be defined with the configuration framework, which makes it fairly simple.

A quick example:

  • configuration:
kumuluzee:
  name: "Sample App"
  feature-flags:
    unleash:
      unleash-api: "http://localhost:4242/api"
  • checking a flag:
@Inject
private FeatureFlags featureFlags;

if(featureFlags.isEnabled("test-feature"){
	//do something
} else {
	//do something else
}

A sample is available on GitHub: KumuluzEE Feature Flags sample with Unleash. More details about the project can be found on the project home page

August 8, 2019 Product Developers Urban Malc

KumuluzEE MicroProfile Metrics 2.0.1 released

We are happy to announce a new major version of KumuluzEE Metrics - 2.0.1. This release implements the MicroProfile Metrics 2.0. Programming interface and REST format include a number of breaking changes which integrate the extension even better with popular cloud-native metric processing tools like Prometheus.

In order to avoid confusion, the monotonic flag has been removed from the @Counted annotation. All counters are now by default monotonic (increasing only). A new metric type has been added in order to compensate for monotonic flag removal - ConcurrentGauge (with accompanying annotation @ConcurrentGauge). This metric type also reports the minimum and maximum value reached in the previous minute.

July 17, 2019 Product Developers Urban Malc

KumuluzEE Rest Client 1.3.3 released

We are happy to present a new release of KumuluzEE Rest Client. This version implements the MicroProfile Rest Client 1.3.3 specification. It includes support for advanced SSL configuration, enables simpler configuration with configuration keys and other enhancements.

The RestClientBuilder now supports methods for configuring SSL (sslContext, trustStore, keyStore and hostnameVerifier). SSL can also be configured through configuration which is especially useful when constructing rest clients using CDI.

The @RegisterRestClient now supports additional argument configKey which can replace fully qualified class name in the configuration. It also enables sharing of the configuration across multiple rest client interfaces. For example you could use the following definition:

July 16, 2019 Product Developers Urban Malc

KumuluzEE Health 2.0.1 released

We are happy to announce a new major version of the KumuluzEE Health. This version implements the MicroProfile Health 2.0 specification. This release contains updates which improve the compatibility of health checks with Kubernetes and its readiness and liveness probes.

NOTE: This release contains breaking changes. Upgrade with caution.

The health checks are now divided into two groups: readiness and liveness checks. In short - if a liveness check fails it means that the service is stuck and should be restarted. If a readiness check fails it means that the service is temporary unavailable and should not receive requests until all readiness checks succeed.

June 29, 2019 Product Announcement Developers Urban Malc

Support for MicroProfile 2.2 and Java 12 is here!

We are happy to announce the release of KumuluzEE 3.5.0. This release includes a brand new profile for MicroProfile 2.2. MicroProfile 2.2 contains upgrades to existing extensions which are now better than ever. This release also fully supports Java 12.

MicroProfile 2.2 profile consists of following components:

  • KumuluzEE Core
  • KumuluzEE Servlet Jetty
  • KumuluzEE CDI Weld
  • KumuluzEE JAX-RS Jersey
  • KumuluzEE JSON-P
  • KumuluzEE JSON-B Yasson

And the following extensions:

Dependency versions have also been updated to their latest versions and the KumuluzEE framework is now fully compatible with the latest Java 12.

Features:

  • Added MicroProfile 2.2 profile.

Enhancements:

  • Upped dependency versions

More details about this release can be found on GitHub.

June 28, 2019 Product Developers Urban Malc

KumuluzEE Event Streaming 1.2.0 released

We are pleased to announce the release of KumuluzEE Streaming 1.2.0. This release includes ready-to-use JSON Serializer, Deserializer and SerDe. Producers with generic types defined can now also be injected and listeners have been improved with explicit parameter validation.

JSON Serializer, Deserializer and SerDe are useful when you want to transfer objects in JSON format. For example to serialize values of a producer to JSON use the following configuration:

June 14, 2019 Product Developers Urban Malc

KumuluzEE OpenAPI Microprofile 1.1.2 released

We are happy to announce the release of KumuluzEE OpenAPI MicroProfile 1.1.2. It implements the updated MicroProfile OpenAPI specification 1.1.2. It features the support for JAX-RS PATCH method and improves usability of various annotations. We have also optimized the scanning process which greatly reduces the startup time. Another addition is the inclusion of Swagger UI which can be served right from your microservice.

June 11, 2019 Product Developers Urban Malc

Announcing KumuluzEE Fault Tolerance 2.0.0

We are happy to announce the release of KumuluzEE Fault Tolerance 2.0.0. This release brings a new implementation - kumuluzee-fault-tolerance-smallrye.

KumuluzEE Fault Tolerance SmallRye uses the SmallRye fault-tolerance implementation which in term uses Hystrix and adapts it to the MicroProfile specification. We decided to use this implementation instead of out own in order to streamline the upgrade process and bring you updated versions of MicroProfile Fault Tolerance as fast as possible. It also means our team can focus on innovation in other parts of KumuluzEE platform.

April 17, 2019 Product Developers Domen Kajdič

GraphQL with KumuluzEE

GraphQL is becoming more relevant every day. Its usage is rapidly spreading across the internet. KumuluzEE was among the first frameworks to offer a standalone GraphQL extension, which offers a simple way to integrate GraphQL to new/existing microservices. Our efforts have been recognized across the community with the post of an article about the GraphQL extension published at https://jefrajames.wordpress.com/2019/03/08/graphql-with-kumuluzee/. If you still have not familiarized yourself with the topic, this article is a good place to start!

April 12, 2019 Product Announcement Developers Urban Malc

KumuluzEE 3.4.0 released!

We are happy to announce the release of KumuluzEE version 3.4.0.

This release brings a new utility class JsonConfigurationUtil, a companion to the familiar ConfigurationUtil. It enables retrieval of a part of the configuration hierarcy as a JSON-P object. For more information and a few examples check out the PR. To start using this feature simply add the JSON-P dependency (kumuluzee-json-p-jsonp) and start using the utility class.

April 1, 2019 Product Announcement Developers Urban Malc

Announcing KumuluzEE 3.3.0

We are releasing KumuluzEE version 3.3.0.

This release adds a new feature that enables you to intercept and apply transformation to a value that is being read from the configuration. The feature is called Configuration Decoder and to use it simply implement the ConfigurationDecoder interface and register it using a service file. For example:

March 31, 2019 Product Developers Domen Kajdič

Tracing KumuluzEE Microservices With Jaeger and Zipkin!

We are proud to announce that one of our latest blog posts about OpenTracing has now been published on the DZone. The article explains how to trace KumuluzEE microservices using Jaeger and Zipkin. If you have been waiting for that, now is the perfect time to read it and get familiar with the topic. Nevertheless, the article serves as a good starting point to the world of OpenTracing, so make sure you check it out: https://dzone.com/articles/tracing-kumuluzee-microservices-with-jaeger-and-zi.

March 18, 2019 Product Developers Urban Malc

Announcing release of KumuluzEE OpenTracing 1.3.1

We are releasing KumuluzEE OpenTracing v1.3.1. It implements the MicroProfile OpenTracing specification 1.3.1. This version brings integration with the KumuluzEE Rest Client.

Integration with Rest Client is automatically enabled when both KumuluzEE OpenTracing and KumuluzEE Rest Client versions are present on the classpath. Note that KumuluzEE Rest Client versions 1.2.1 and above are supported.

To start using the new integration simply create a Rest Client interface. All calls made through the created interface will automatically be traced.

March 15, 2019 Product Developers Urban Malc

Release of KumuluzEE Rest Client 1.2.1

We are pleased to announce the release of KumuluzEE Rest Client 1.2.1. This release brings support for better header generation and propagation of headers from incoming requests, read and connect timeouts and other enhancements. KumuluzEE Rest Client 1.2.1 implements the MicroProfile Rest Client 1.2 specification.

Headers can now be generated using the @ClientHeaderParam annotation. Headers can be statically defined or dynamically generated with a method reference. For example:

March 1, 2019 Product Developers Urban Malc

KumuluzEE 2.6.0 released

NOTE: The KumuluzEE 2.x.x releases are meant for projects still dependent on Java EE 7. If starting a new project the usage of KumuluzEE 3.x.x is highly recommended.

We are releasing KumuluzEE version 2.6.0. This release brings the features developed in the 3.x.x branch (compliant with Java EE 8) to the older KumuluzEE version (compliant with Java EE 7).

This release includes the support for Apache CXF JAX-WS implementation, configurable classpath scanning and MicroProfile profiles version 1.3 and 1.4. For a more detailed change-log see the corresponding 3.x.x releases in which the features were introduced.

February 28, 2019 Product Announcement Developers Urban Malc

KumuluzEE 3.2.0 brings MicroProfile 2.1 compliancy

We are announcing the availability of KumuluzEE version 3.2.0.

This release brings compliancy with the MicroProfile 1.3, 1.4, 2.0 and 2.1. MicroProfile is an open initiative extending Enterprise Java with standardized APIs in order to optimize Java EE for a microservice architecture. These APIs allow you to collect and expose application metrics in a standardized way, trace requests across multiple microservices, invoke RESTful APIs in a type-safe and intuitive way, introduce common fault-tolerance patterns, document microservices using the OpenAPI and much more.

To start using MicroProfile with KumuluzEE pick the version that suits your needs and use one of the following dependencies:

February 22, 2019 Product Developers Domen Kajdič

Initial release of KumuluzEE OpenAPI MicroProfile is here!

We are releasing the first version of KumuluzEE OpenAPI MicroProfile. It implements the MicroProfile OpenAPI specification 1.0.1. Initial version of KumuluzEE OpenAPI enables intuitive documentation of your REST resources using the MicroProfile OpenAPI annotations.

To start using the extension, simply add the following dependency to your application:

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

The sample showcasing some basic features is already available so go check it out! We will also update the sample to showcase some more advanced usages in the upcoming days.

For more information, read the extension documentation.

We are excited to bring this extension into your hands!

February 18, 2019 Product Developers Domen Kajdič

Announcing initial release of KumuluzEE OpenTracing!

The first version of KumuluzEE OpenTracing has been released. It implements the MicroProfile OpenTracing specification 1.2.1. Initial version of KumuluzEE OpenTracing brings full power of distributed tracing to your new/existing microservices. From automatic tracing of incoming JAX-RS requests to tracing function calls with annotations, the extensions has all the necessary features.

Full feature list includes:

February 12, 2019 Product Developers Urban Malc

KumuluzEE Event Streaming 1.1.0 released

We are pleased to announce the release of KumuluzEE Streaming 1.1.0. This release includes support for configuration overrides through annotations. Kafka client has also been updated and some bugs have been fixed.

Kafka configuration properties can now be overridden by using the @ConfigurationOverride annotation. For example:

@Inject
@StreamProducer(configOverrides = {@ConfigurationOverride(key = "bootstrap-servers", value = "localhost:9092")})
private Producer orderProducer;
February 11, 2019 Developers Community Domen Kajdič

Tracing KumuluzEE microservices with Jaeger

When it comes to developing applications within the microservice architecture, the number of microservices can grow quickly. Managing microservices becomes harder with each new or updated microservice. When an application experiences a slowdown and its »data flow« goes through several different microservices, pinpointing the exact location of a slowdown may be difficult for a developer.

This blog post will cover the basics of distributed tracing. It will demonstrate the usage of KumuluzEE OpenTracing extension with Jaeger to fight the challenges mentioned above.

January 29, 2019 Product Announcement Developers Urban Malc

KumuluzEE JWT Auth 1.1.1 released

We are announcing the release of KumuluzEE JWT Auth 1.1.1. This release brings simplified configuration, as manual import of the JWT filter and dynamic feature is no longer required and is done automatically. KumuluzEE JWT Auth now implements the MicroProfile JWT Authentication 1.1. It also fully supports Java 9+.

January 29, 2019 Product Announcement Developers Primož Hrovat

KumuluzEE gRPC release 1.1.0!

With shiny new KumuluzEE release we are bringing JDK9+ support to Kumuluzee gRPC too! Project can now be compiled and will run without errors. Though, running service on Java 11 will print some warnings to the console. These are warnings from JVM caused by some reflection lookups in the dependencies.

January 28, 2019 Product Announcement Developers Urban Malc

Announcing KumuluzEE 3.1.0!

We are announcing the availability of KumuluzEE version 3.1.0.

This release enables configurable classpath scanning and includes an updated Jetty dependency and a minor bug fix.

Configurable classpath scanning enables scanning of application dependencies in addition to the main application module. This means that you can put JAX-RS providers and other classes that need to be scanned in any module, whereas before these classes had to reside in the main application module or be correctly proxied in the main application module.

January 24, 2019 Product Developers Urban Malc

Release of KumuluzEE Rest Client 1.1.0

We are pleased to announce the release of KumuluzEE Rest Client 1.1.0. This release supports asynchronous requests and client builder interceptors. KumuluzEE Rest Client 1.1.0 implements the MicroProfile Rest Client 1.1 specification.

Asynchronous requests are now possible with the updated Rest Client. To make an request asynchronous, change the return type of the interface method to CompletionStage.

Example of an asynchronous request definition:

@POST
CompletionStage<Void> createCustomerAsynch(Customer customer);
December 28, 2018 Product Developers Urban Malc

Initial release of KumuluzEE Rest Client is here

We’re happy to announce the first release of KumuluzEE Rest Client. This release implements the MicroProfile Rest Client 1.0.1 specification.

KumuluzEE MicroProfile Rest Client supports generation of rest clients from simple definitions. APIs are defined using interfaces and well-known JAX-RS annotations. Generated rest clients provide a type-safe way to invoke defined APIs and support a wide variety of providers which allow fine-grained but natural configuration at various stages of requests.

December 27, 2018 Product Developers Urban Malc

Announcing KumuluzEE Fault Tolerance 1.1.3

We are pleased to announce the release of KumuluzEE Fault Tolerance 1.1.3. This release brings the update to the 1.1.3 version of the MicroProfile Fault Tolerance specification and Java 9+ support.

KumuluzEE Fault Tolerance is now integrated with MicroProfile Metrics and includes instrumentation of all Fault Tolerance patterns. This enables developers and operations team to monitor critical points of the system, detect and locate faults as soon as possible and make adjustments to the parameters of the fault tolerance patterns if needed.

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.