Reactive Integrations For Enterprises

 

The Alpakka initiative started in 2016 with the idea to apply the Reactive Streams principles to Enterprise Integration by connecting Akka Streams to other technologies.

Alpakka Kafka was the first project building on that idea when it started using the experimental Akka Stream implementation in 2015. At the time the project was called Reactive Kafka.

For some time Alpakka was a side-activity of the Akka team which always had other great additions and improvements for Akka in the makings, and they had a hard time to keep up with the community engagement Alpakka saw.

In April 2018 Lightbend decided to have a dedicated Alpakka Team so that Alpakka could get the attention a project with almost 30 technologies involved requires.

During this year we’ve tried to improve the developer experience both for Alpakka users and contributors. With this 1.0.0 release, Alpakka is another member of the Akka family promising great Open Source software with the Reactive Manifesto in mind.

Compatibility

A major goal before turning to 1.0 was to improve chances all Alpakka modules can evolve without breaking users’ code. There are two sides to that: One is binary-compatibility which effectively means you can replace just the jar with a later version’s jar in your installation and everything will work. This becomes extremely important as soon as you use other libraries that rely on the same jar. They will continue to work without recompilation. The other is source-compatibility which, when upgrading to a later minor version, would not require any code changes. Akka and Alpakka strive for binary-compatibility and source-compatibility, but we do not guarantee source-compatibility.

All modules of Alpakka can be used independently, you may mix Alpakka versions for different libraries. With Akka though, it is important to be strictly using one version (never blend eg. akka-actor 2.5.21 and akka-stream 2.5.12), and do not use an Akka version lower than the one the Alpakka dependency requires (sometimes Alpakka modules depend on features of the latest Akka release).

Alpakka 1.0.0 modules require at least Akka 2.5.21. Some modules depend on Akka HTTP 10.1.7.

Documentation

The Alpakka documentation consists of three parts: The reference documentation for every module, the code snippets that show in the reference documentation, and the API documentation created by Scaladoc. Every Alpakka module has at least one page to show how it can be used and we try to show example code which is enough to get you started. If it doesn’t reveal enough, try the little icon in the upper right corner to hop over to the code which in most cases belongs to the test suite of the module.

Alpakka Kafka’s reference documentation and API documentation is separated from “main” Alpakka’s, partly for historic reasons, partly to let it have its own life-cycle.

Community

Akka and Alpakka wouldn’t be what they are without the tremendous open source community around the world. Almost 200 individuals have contributed to Alpakka to date.

With its wide span of different technologies, Alpakka depends on contributors with deep knowledge and experience in those. Lightbend’s Alpakka team focuses on shepherding all the efforts contributors make to improve Alpakka.

Support

Lightbend sponsors Alpakka and encourages contributions from the active community.

If you already have a Lightbend Platform Subscription, please reach out to the Expert Support via Lightbend Portal.

For community support please ask questions or discuss ideas in the Lightbend discuss forum.

For professional support, for instance if you need faster response times, Lightbend provides:

From version 1.0.0 on the official support covers

Lightbend puts pride in trying to assist you with the other Alpakka modules on a best-effort basis.

Future

Since Alpakka started, more and more technologies have started to offer asynchronous and reactive APIs.

Most recently AWS released their AWS SDK 2.0 which offers asynchronous API to communicate with their services.

We expect other technologies to follow and move away from the old “one thread per request model” and make use of the asynchronous APIs such as Java 8’s CompletionStage and the Reactive Streams interfaces introduced in Java 9: Flow.PublisherFlow.Processor and Flow.Subscriber. These Flow interfaces are meant for easy integration of different Reactive Streams-compliant technologies.

Release notes

The Alpakka 1.0.x release notes enlist what has changed.

Happy hakking!

– The Alpakka Team

Share



Comments


View All Posts or Filter By Tag


Questions?