Given that your applications typically use many different languages and runtimes, you want to integrate 3rd party commercial and open source software in frameworks you don’t control, and you may want to connect to external mobile and IoT devices as part of your application.  You often need to support older application environments while moving to more modern environments like Node.js.

As stated by the creators of Apache Kafka: “Only a couple of languages have very good client support because writing high performance Kafka clients is very challenging compared to clients for other systems because of its very general, flexible pub-sub model.”

Solace takes a very different approach. We embrace open protocols and APIs to simplify application integration and make applications more portable. Below is the spectrum of open protocols supported.

Below is a summary comparison of application interface support between Solace PubSub+ and Apache Kafka. Support is designated as follows:

API maintained by a company or named group, not a single individual, with at least one release in the last 6 months.

API exists, but maintained by an individual or having no releases in the last 6 months

No such API, or no releases of that AP

APIApache KafkaSolace PubSub+
Java
JMS
JCA
.NET
Node.js
C/C++
JavaScript
iOS
OpenMAMA
MQTT
REST
Ruby
Go
Python
Clojure

Apache Kafka Application Integration

Apache Kafka provides only a Java API.  This API is specific to Apache Kafka as opposed to being JMS compliant, for example, so applications must be coded to this Apache Kafka specification. This typically means that there is no ready-made integration with 3rd party products like ESBs, API gateways, JEE containers and the like.

APIs in other languages are available but these are outside of the Apache Kafka project and are each maintained by individuals or in some cases a company – not a community.  This means that support, API consistency, quality and feature availability are dependent on the individual maintainer. There are currently no APIs that are the same revision as the current broker release.

Note that Confluent does offer a MQTT Proxy as a one-way gateway as a workaround for Apache Kafka users.

Recall that Apache Kafka APIs are sophisticated APIs:  they need to interact with Zookeeper and many Apache Kafka brokers, determine what partitions of what topics are located where as this changes over time, consumers track where they are in the replay log, publishers track where to publish each message based on topic + key, etc. There is a lot to do.

With a sophisticated API architecture, as new messaging features are added, significant changes are required in each API vs being implemented mostly in the broker.  This impedes the rate of development of new features and new APIs and makes the quality of new features very dependent on the API being used.

A key aspect of the Apache Kafka wireline is that consumers move sequentially through the messages in a given log, processing each in order. This means that supporting an architecture such as using thread pools for application scaling is much more complex as it requires use of manually committing the consumer’s position in the log and coordinating different order of completion among processing threads.

Solace Application Integration

Solace provides many types of messaging application interfaces so we can support all kinds of client applications:  from Message Driven Beans running in an app server with JMS/JCA, to iPhones, iPads with our iOS API and other mobile devices with Javascript, to the smallest IoT sensor using MQTT or REST, to 3rd party business systems over the WAN to desktop applications with Java or C# to 3rd party ESB/BPM/API Gateway applications or even market data applications using OpenMAMA.

We provide interoperability among all these APIs and protocols so an MQTT application can send messages to a JMS app, a JavaScript app can talk to a C# app, message driven bean (MDB) applications can receive messaging events from Node.js applications.

For languages where we do not provide a software API, one of our open wireline interfaces can be used such as REST messaging for use cases where rates are in the hundreds of messages per second per client, or MQTT for streaming messaging with APIs from Paho and others.

Solace has many proven integrations and integration guides for third party products from major enterprise players like IBM, Oracle, TIBCO, for the Hadoop ecosystem of Spark Streaming, Apex & Flume and many open source applications and frameworks like Apache Kafka, Spring, JBOSS, Mule, ElasticSearch and more.

In some scenarios, it makes sense to deploy both Apache Kafka and Solace PubSub+. Apache Kafka is used for log aggregation and data ingest and Solace for robust bi-directional event distribution between diverse applications and IoT devices running in hybrid clouds and around the world. In these scenarios, we provide two free, open source connectors based on the Apache Kafka Connect specification — one Source and one Sink — that make it easy to integrate Apache Kafka and Solace so that information can flow seamlessly between the environments. Details about the connectors are located here.

Solace PubSub+ message brokers are backward compatible with APIs from all supported past releases, so you can upgrade your message broker now and upgrade the API in your applications over time as applications are modified.  PubSub+ message brokers even display the API version of each connected application, so you can track down applications using very old APIs for governance reasons.

You can find more information on our Open APIs here and our Solace-specific APIs here.

Conclusion

Solace provides much richer options for application integration than Apache Kafka allowing you to easily onboard more applications and devices using a single messaging technology.

Suggested Next Steps