Skip to content

Assimbly 3.0

Some say that version 2.0 is the real 1.0. But where is Assimbly 2.0? From 0.1 till 1.9 this versioning scheme was closely followed. So why the ‘Microsoft-like’ move to go directly to 3.0? The version 3 number reflects 3 things:

1. Apache Camel 3

Assimbly moved to Apache Camel 3 (3.3 at this time). Camel 3 brings many improvements around the framework as Claus Ibsen blogged on the Camel website.

2. Jhipster 6

One of the biggest changes is the move of the web framework Jhipster from version 5 to 6. This updates Spring Boot, Angular and hundreds of other libraries.

3. New features

With both the latest Camel as Integration Framework and JHipster as Web Application Framework it feels like Assimbly is standing on the shoulder of giants. From there we can easily add new functionality as described later in this blog. First we shortly discuss what Assimbly does.

What is Assimbly?

Almost anyone needs data from multiple systems. Apache Camel is the most powerful integration framework in the world. It supports many protocols and has extensive documentation. It’s a perfect solution to integrate systems with each other.

One common way to create an integration is by using the Camel DSL (Domain Specific Language for writing integrations). Like for example send something from a database to a webservice. The Camel DSL makes it a lot easier to write such integrations:

from(“sql:select order from table”).to(“”)

It’s however not that easy. As you first need a CamelContext to run such routes. The context as well as the route needs to be configured. The route is wrapped in a Java class, some error handling is needed, some options are needed etc. Last, but not least the route needs to be managed (start, stopped, paused etc).

What if you don’t need to write the integration, but just configure and manage the integration in your browser?

No Java, no Maven, no IDE and no deployment. In Assimbly you can do everything within the browser. An example of SQL to HTTPS will look in Assimbly like this:

Assimbly focuses on connecting applications and other software. These are just connecting endpoints, while leaving other software (middleware, applications, databases etc) handle other application or integration logic. This makes connecting software easier for intergration specialist as well as less technological users.

What’s new?

Here is a high level overview of what’s new in version 3.0.


In Assimbly a flow connects multiple endpoints with each other. The flow page lists all these flows of the gateway. This page used to have buttons for managing flows and text with extra information about the flow.

Old flows page:

Now these two are combined to give a clearer look. Also, basic actions like getting stats and cloning, editing or deleting a flow can be done directly from this page.

New flows page:


Camel recently released version 3. The Assimbly Connector API is an interface on top of integration software like Camel and ActiveMQ. This API could support both Camel 2 and 3, but since there aren’t a lot of compatibility issues we decided to support version 3 from now on as the only option.

For Assimbly the main benefits are performance improvements, lower footprint, more components and support for Java 11. In the future we hope to benefit from the more modular approach of Camel 3.

Jhipster is a great framework to generate web applications. Often you only get frameworks that are part of the web application. For example the backend, the database, the frontend, the user interface and so on. Jhipster brings them all together. This leads to a full-functional web application, but also to well-structured code. With Jhipster 6 we moved to:

  • Spring Boot 2.2
  • Angular 8
  • Swagger UI v3
  • Gradle 5

These frameworks and hundreds of other library upgrades brings Java 11 support, performance improvements and better security.

Upgrading those libraries with Jhipster saves a lot of manual work, however it is also quite hard because this upgrades all libraries at once. This broke our custom code that we of course want to keep. So a lot of debugging needed to be done. Thanks to Achraf Adbib for making this happen!

Within Assimbly DocConverter (which is a subproject of Assimbly) is used for converting between different data formats. This let users define flows in XML, JSON and YAML.

In version 3.0 it also allowed calling DocConverter from a flow with special headers with a flow (as explained in the documentation). This converts the data format of the input message to XML, JSON, CSV or YAML.

Startup improvements

With all the updated frameworks we can now support Java 11, the latest long term support version of Java. In the old days of the Java world only Oracle’s Java JDK was used (and sometimes you saw IBM’s JDK). In the last few year we see a faster pace of versions and more builds. You can read more on my article on Java JDK’s.

In the old version Assimbly was only running well on Oracle JDK 8, but it was slow. With all the framework upgrades, startup fixes and JDK 11 we saw major improvements on startup time. Here are some stats on the several JDK’s:

Assimbly 1.8.0 (Jhipster 5 / Camel 2)

Jar Size: 300 MB

JDK                         Fastest startup time MemoryJDK 8 (231)               77 seconds              1610  MB
OpenJDK 11 (11.0.6) Did not run
OpenJDK 14 (14+36) Did not run
OpenJ9 11 Did not run

Jar Size: 220 MB

JDK                        Fastest startup time   MemoryJDK 8 (231)              13 seconds                1805 MB
OpenJDK 11 (11.0.6) 16 seconds 215 MB
OpenJDK 14 (14+36) 16 seconds 220 MB
OpenJ9 11 17 seconds 205 MB
GraalVM 8 (20.0) 14 seconds 1840 MB
GraalVM 11 (20.0) 14 seconds 1280 MB
Azul Zulu 8 13 seconds 1696 MB
Azul Zulu 11 13 seconds 995 MB
Azul Zulu 14 12 seconds 553 MB
Amazon Correto 8 13 seconds 1716 MB
Amazon Correto 11 14 seconds 976 MB

So in the new version Assimbly is running on any JDK without problems. Azul Zulu 14 had the fastest startup and OpenJDK 11 (hotspot) the lowest memory footprint. A native image was also created for Assimbly, but that only gained 1 or 2 seconds. This will probably improve when Spring Boot will have official support for Native Image.

Other enhancements

In Assimbly headers can be set as one or more key/value pairs. This group of headers can be (re)used within multiple flows.

The header value can be either set as constant, but now also from an expression (simple, groovy, xpath and jsonpath are supported).


Besides Apache Camel, Assimbly supports ActiveMQ. Both ActiveMQ Classic as ActiveMQ Artemis are supported. Flows can send or receive messages from ActiveMQ. The broker can be configured from within the browser.

Assimbly is designed with several layers in mind. At the lowest layer there is the implementation of Apache Camel and Apache ActiveMQ. On top of that there is a Java API to configure and manage Camel and ActiveMQ.

Currently, Camel 3 is the only flow implementation as Apache Camel fulfills all our needs. It’s however possible to write a custom implementation or to use other integration frameworks like for example Spring Integration. In Assimbly 3.0 the Java API, Assimbly connector, is enhanced to use 68 methods.

Assimbly connector can be seen as a convention-over-configuration library for Camel. It starts the CamelContext with things like the catalog, registry and ssl support. The connector can also be used separately from Assimbly gateway (the web application).

For example to embed in a command line application or other middleware like I recently did with Apache NiFi.

Assimbly comes as a single ‘fat’ jar file which runs on any server or laptop. The project also supports docker:

docker pull skin27/assimbly:latest

Several logging improvements has been done. Firstly the logs on startup were improved. The logged printed previously only the URL were Assimbly was running, now it prints lots of extra information like startup time, java version and so on.

Overall there is more logging for example when importing/exporting flows. It’s also now available to set the loglevel to debug or trace the flow.

Current JDK versions already support most common TLS certificates. It’s however possible to whitelist extra URL’s or upload certificates manually.

These certificates are managed centrally. This means even when there are multiple instances every instance gets all the certificates. These certificates are automatically loaded in flows.


In Assimbly we provide contextual documentation. This means when a user selects for example the ‘File’ components it gets

  • A link to the official Camel documentation about the File component.
  • A link to the Assimbly documentation with additional examples and screenshots.
  • Placeholders for the URI syntax.
  • Info on the URI syntax in an info box.

The Assimbly wiki has now more than 50 articles. Including a quick start guide and tutorials.

What’s next?

Experimental features

We are now working on new experimental features in 3.1 (Currently alpha status):

  • Support for all Camel components
  • Modularization
  • Microservices: Running Assimbly on Kubernetes

Read more in a separate blog.


Our hope is that people find Assimbly 3.0 useful. As an open source project everyone is welcome to create or discuss issues on Github.

Please star the repo on Github when you like Assimbly.

Share on twitter
Share on linkedin
Share on facebook
Share on email


Share on twitter
Share on linkedin
Share on facebook
Share on email

Recente berichten