Apache Kafka is an open-source stream processing platform developed by the Apache Software Foundation written in Scala and Java. The Kafka event streaming platform is used by thousands of companies for high-performance data pipelines, streaming analytics, data integration, and mission-critical applications.
N/A
TIBCO Messaging
Score 8.1 out of 10
N/A
TIBCO offers high-performance messaging technology, and gives customers flexibility and unique choice between Commercial and Open-source messaging solutions. TIBCO Messaging is a comprehensive messaging portfolio available to meet a wide variety of use cases and deployment models.
Kafka is not a real messaging broker implementation as RabbitMQ or TIBCO EMS/JMS are. Although it can be used as messaging, we like the idea behind the Kafka (data isn't "passing by," instead it remains centra, so the client can revisit the data if necessary). This also …
We also use other messaging products: IBM MQ, especially for integration with other systems (server2server), which has been an industry standard for a long time, and Apache Kafka for cloud-native applications. EMS is a worse option compared to them, but it is still acceptable.
We chose TIBCO Messaging not just for its performance but because it looked like the natural way to pave our existing TIBCO Integration architecture. Setting up TIBCO EMS servers and objects seems more straightforward than with most of competitors. It is easy to configure and …
IBM MQ was the old product we used, and we migrated from it to TIBCO EMS. We use also RabbitMQ for our light-weight IPC scenarios and Kafka for our data stream use cases. They 3 compose our complete messaging and streaming solution.
TIBCO Enterprise Message Service was selected because of the contract with TIBCO. We generally see company buying other TIBCO products such as TIBCO BusinessWorks and then TIBCO offers some discount on their "minor" products. If I would compare technical capabilities of EMS …
We selected TIBCO EMS because we selected TIBCO BW as an ESB. TIBCO EMS must be installed in the TIBCO BW stack. I prefer TIBCO EMS because it implements very powerful functionality like bridges and routing.
Apache Kafka is well-suited for most data-streaming use cases. Amazon Kinesis and Azure EventHubs, unless you have a specific use case where using those cloud PaAS for your data lakes, once set up well, Apache Kafka will take care of everything else in the background. Azure EventHubs, is good for cross-cloud use cases, and Amazon Kinesis - I have no real-world experience. But I believe it is the same.
If you need a robust, extensible, reliable Enterprise Service Bus, with "Enterprise" being the key word here, TIBCO [Enterprise Message Service] will be able to fulfill every expectation. As proof of concept, or ad-hoc implementations, it might not be as well suited due to the infrastructure required.
Really easy to configure. I've used other message brokers such as RabbitMQ and compared to them, Kafka's configurations are very easy to understand and tweak.
Very scalable: easily configured to run on multiple nodes allowing for ease of parallelism (assuming your queues/topics don't have to be consumed in the exact same order the messages were delivered)
Not exactly a feature, but I trust Kafka will be around for at least another decade because active development has continued to be strong and there's a lot of financial backing from Confluent and LinkedIn, and probably many other companies who are using it (which, anecdotally, is many).
Tibco EMS performs very well, and it meets our stringent performance requirements for corporate messaging backbone.
Tibco EMS scales well, and this is another of our stringent requirements.
Tibco provides good support for the EMS product, and continues to improve it. This is important as we don't want to use something that does not keep up with the changes in the technology landscape.
Sometimes it becomes difficult to monitor our Kafka deployments. We've been able to overcome it largely using AWS MSK, a managed service for Apache Kafka, but a separate monitoring dashboard would have been great.
Simplify the process for local deployment of Kafka and provide a user interface to get visibility into the different topics and the messages being processed.
Learning curve around creation of broker and topics could be simplified
In terms of TIBCO Messaging, it would nice to have a more out-of-the-box way of linking its objects (queues, topics) directly to those of other popular solutions like MQ or Kafka.
Not being able to filter (that is, using selectors) through patterns/subtexts on the message body is missed on occasions.
Given the current trends and state-of-art, lift & shift of on-premise EMS clusters to cloud architectures should be more directly attainable.
EMS is a solid system and I see no reason to abandon it, in fact I am eager to see what the next versions will offer and future road maps. Knowing we have support to help us in case of problems is invaluable, both in case of critical issues and to improve overall performance.
Apache Kafka is highly recommended to develop loosely coupled, real-time processing applications. Also, Apache Kafka provides property based configuration. Producer, Consumer and broker contain their own separate property file
Support for Apache Kafka (if willing to pay) is available from Confluent that includes the same time that created Kafka at Linkedin so they know this software in and out. Moreover, Apache Kafka is well known and best practices documents and deployment scenarios are easily available for download. For example, from eBay, Linkedin, Uber, and NYTimes.
I used other messaging/queue solutions that are a lot more basic than Confluent Kafka, as well as another solution that is no longer in the market called Xively, which was bought and "buried" by Google. In comparison, these solutions offer way fewer functionalities and respond to other needs.
We also use other messaging products: IBM MQ, especially for integration with other systems (server2server), which has been an industry standard for a long time, and Apache Kafka for cloud-native applications. EMS is a worse option compared to them, but it is still acceptable.
Positive: Get a quick and reliable pub/sub model implemented - data across components flows easily.
Positive: it's scalable so we can develop small and scale for real-world scenarios
Negative: it's easy to get into a confusing situation if you are not experienced yet or something strange has happened (rare, but it does). Troubleshooting such situations can take time and effort.
