We are excited to announce a new minor version of KumuluzEE Security - 1.3.0.

This release adds support for new authentication provider - Firebase Authentication.

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.

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.

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

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

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

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:

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.

We are announcing the availability of KumuluzEE version 4.1.0.

This release brings improvements to the configuration framework, such as configuration profiles, improved variable interpolation, and more!

We are happy to announce the next major release of KumuluzEE 4.0.0. This release includes a major Jetty upgrade, support for the latest released versions of Java, including the Java 17 LTS version and the use of JakartaEE 8 artifacts replacing the JavaEE 8 artifacts.

We are happy to announce the first Beta of KumuluzEE 4.0.0. This is the first prerelease of the major release, which brings a major Jetty upgrade, support for the latest released versions of Java, including the Java 17 LTS version and the use of JakartaEE 8 artifacts replacing the JavaEE 8 artifacts.

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.

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:

• kumuluzee-graphql-jpa-simple
• kumuluzee-graphql-jpa-security
• kumuluzee-graphql-advanced

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

We are excited to announce a new KumuluzEE minor version - KumuluzEE 3.12.0! The most significant feature in this release is the support for Java 15. Dependencies have been updated to their latest minor versions, and a collection of tough bugs have been cracked. Check out the full changelog below:

New versions of KumuluzEE OpenAPI MP and KumuluzEE Health were released today.

We have just released new versions of KumuluzEE OpenAPI MP and KumuluzEE Health. New features include a Maven plugin which generates OpenAPI schema at compile-time, a new health check for Kafka clusters and integration between the two extensions.

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.

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.

We are happy to announce the release of KumuluzEE 3.9.0, which brings support for MicroProfile 3.3.

We’re announcing the availability of KumuluzEE Logs 1.4.0, which introduces two big features; support for Fluentd logging provider and an audit logging module.

We are happy to announce a release of KumuluzEE Rest Client 1.4.1. This release implements the MicroProfile Rest Client 1.4.1 specification.

We are happy to announce a release of KumuluzEE Metrics 2.3.0. This release implements the MicroProfile Metrics 2.3 specification.

We are happy to announce the release of the KumuluzEE 3.8.0. The new release brings a new database connection pool implementation which improves the JTA transaction handling.

We are happy to announce the release of KumuluzEE 3.7.0. This release includes new profiles for MicroProfile 3.1 and 3.2 specifications.

We are releasing the first version of KumuluzEE JCache. It allows usage of JCache annotations and JCache programmatic API in your KumuluzEE applications. Currently used JCache implementation is Caffeine.

We are releasing a first version of KumuluzEE Version, a simple KumuluzEE extension that provides mechanisms for exposing version details of your microservices.

We are happy to announce a new version of the KumuluzEE Health. This version implements the MicroProfile Health 2.1 specification.

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:

• KumuluzEE Config MP (integrates MicroProfile configuration with KumuluzEE configuration framework)
• KumuluzEE Fault Tolerance SmallRye (fault tolerance patterns e.g. retry, circuit breaker, …)
• KumuluzEE Health (predefined and custom health-checks)
• KumuluzEE Metrics (collection of application and user-defined metrics)
• KumuluzEE JWT Auth (authentication using JSON Web Tokens)
• KumuluzEE OpenTracing Jaeger (OpenTracing compliant instrumentation)
• KumuluzEE OpenAPI MP (documentation of REST resources using OpenAPI specification)
• KumuluzEE Rest Client (type-safe client for accessing REST resources)

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.

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

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.

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:

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.

We are pleased to announce the support for fluentd in KumuluzEE Logs. The module includes support for logging to Fluentd logger. It also introduces JAX-RS filters for logging contextual data for requests.

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:

• KumuluzEE Config MP (integrates MicroProfile configuration with KumuluzEE configuration framework)
• KumuluzEE Fault Tolerance SmallRye (fault tolerance patterns e.g. retry, circuit breaker, …)
• KumuluzEE Health (predefined and custom health-checks)
• KumuluzEE Metrics (collection of application and user-defined metrics)
• KumuluzEE JWT Auth (authentication using JSON Web Tokens)
• KumuluzEE OpenTracing Jaeger (OpenTracing compliant instrumentation)
• KumuluzEE OpenAPI MP (documentation of REST resources using OpenAPI specification)
• KumuluzEE Rest Client (type-safe client for accessing REST resources)

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.

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:

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.

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.

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!

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.

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:

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.

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.

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:

We are announcing the release of Go packages for KumuluzEE, kumuluz/kumuluzee-go-config and kumuluz/kumuluzee-go-discovery.

We are pleased to announce the first version of the KumuluzEE AMQP project. This version provides support for the RabbitMQ message broker.

KumuluzEE AMQP supports sending and receiving messages with a few simple annotations. Broker configuration can be defined with the configuration framework, which makes it fairly simple.

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.

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:

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!

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:

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;

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.

We are announcing a minor release of KumuluzEE Health. This release comes with updated dependencies, support for Java 9+ and support for disabling the extension through configuration.

We are announcing a minor release of KumuluzEE Metrics. This release brings some important bug fixes and adds support for Java 9+. Dependencies have also been updated to their latest versions.

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+.

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.

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.

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);

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.

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.

We’re releasing the KumuluzEE Nodejs Discovery 1.1.0. This version updates node-etcd dependency to provide better support for latest nodejs lts version. It also fixes bugs related to node-etcd.

Samples have been updated to use latest version.

We’re releasing the KumuluzEE Nodejs Config 1.1.0. This version updates node-etcd dependency to provide better support for latest nodejs lts version. It also fixes bugs related to node-etcd.

Samples have been updated to use latest version.

We’re releasing the KumuluzEE MicroProfile Config 1.3.0. This version implements the MicroProfile Config specification 1.3, which introduces a better implicit converter and removes redundant converters. This release also brings full support for Java 9+.

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.

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.

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.

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.

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.

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.

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.

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.

We are happy to announce the third prerelease of the KumuluzEE 3.0.0 Beta. The v3.0.0-beta.3 prerelease of KumuluzEE framework further improves on the v3.0.0-beta.2 prerelease.

We have entered the second phase of KumuluzEE Beta testing. The v3.0.0-beta.2 prerelease of KumuluzEE framework continues to improve on the already stable v3.0.0-beta.1 prerelease.

We are announcing new version of the KumuluzEE Swagger extension - v1.1.1.

KumuluzEE Swagger v1.1.1 brings the following updates:

• Support for JDK9+.
• Changes to the extension configuration.

Read more at KumuluzEE Swagger

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

We’re happy to announce the release of KumuluzEE Metrics 1.1.1. This release implements the MicroProfile Metrics 1.1.1 specification, which brings a new reusable flag, integration with KumuluzEE MicroProfile Config and some general improvements to the programmatic API.

We’re announcing the KumuluzEE Config MicroProfile v1.2.1. This version implements the MicroProfile Config specification v1.2.1, which introduces array converters and common sense converters.

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.

We are announcing the release of libraries for Node.js platform @kumuluz/kumuluzee-config@1.0.0-snapshot and @kumuluz/kumuluzee-discovery@1.0.0-snapshot.

We are happy to announce the support for widely used CXF implementation of Java API for XML Web Services (JAX-WS). The release 3.0.0 of KumuluzEE microservice framework will bring the support for SOAP web services with context dependency injection (CDI).

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.

We’re announcing the availability of KumuluzEE gRPC extension (1.0.0-SNAPSHOT), first beta release, which provides easy-to-implement gRPC based communication between microservices.

Pre-release version of Ethereum extension for KumuluzEE framework is now available.

Extension provides support for interacting with smart contracts on the ethereum network using web3j. You can write your own smart contracts and deploy them on the network right from IDE.

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.

KumuluzEE CORS version 1.0.3 is now released. The new version now works together with other extensions.

Integration testing with the KumuluzEE framework has just become a lot easier with the KumuluzEE Arquillian Container Adapter.

The newly developed adapter brings support for the popular Arquillian framework. KumuluzEE Arquillian Container Adapter starts the KumuluzEE server before running the tests, which enables the tests to interact with the environment closely resembling the one in production.

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

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.

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.

We’re announcing the availability of KumuluzEE Config 1.1.0, an update to the configuration management extension, which extends basic configuration framework with etcd and Consul configuration sources.

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>

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>

Learn how to deploy and run KumuluzEE microservices on Kubernetes by reading the following DZone article: Java EE Microservices on Kubernetes With KumuluzEE.

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

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).

We are announcing the release of KumuluzEE Reactive extension for developing reactive microservices and integration with reactive streams (Vert.x and similar).

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.

KumuluzEE Health extension health check set has been expanded with an EtcdHealthCheck.

KumuluzEE Health extension health check set has been expanded with a HttpHealthCheck.

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.

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.

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() {...} 
    ...
}

KumuluzEE is adding support for OpenAPI v3! KumuluzEE OpenAPI extension provides OpenAPI v3 compliant annotations that you can use to provide OpenAPI v3 specification for your APIs.

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();
    }
}

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.

We have published an interesting article to the Eclipse newsletter, in which we talk about the importance of service discovery in the microservice architecture. We also present some advanced scenarios of service discovery and how to handle them with the KumuluzEE Discovery extension.

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.

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

We are announcing the initial version of KumuluzEE Health extension. KumuluzEE Health is a health check extension for the KumuluzEE microservice framework.

We are announcing the release of KumuluzEE CORS extension providing Cross-Origin Resource Sharing support to Java web applications.

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>

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>

We are announcing the release of KumuluzEE Security extension which provides support for OpenID authentication through standard Java EE security annotations.

More details at KumuluzEE Security.

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>

We’re happy to announce the initial version of the KumuluzEE REST extension v1.1.0 for the KumuluzEE framework.

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

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

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.

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.

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:

We are announcing the release of KumuluzEE Streaming extension which provides easy-to-use annotations for developing microservices that produce or consume event streams.

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.

We are announcing the release of KumuluzEE Logs extension providing a lightweight open-source logging framework specifically designed for logging microservices.

More details at KumuluzEE Logs.

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.