Apache Camel is popular. In this blog, we break down what Apache Camel is, share the top Camel benefits, and give you an overview of the Camel framework and how Camel works.
Apache Camel is an open source framework for message-oriented middleware.
Apache Camel is the industry standard for reducing boilerplate code for complex integrations — while maintaining features like:
Camel is a domain-specific language that’s an implementation of the enterprise integration patterns. It helps organizations solve some very specific problems.
Camel Is Just One Part of Your StackCamel is just one part of your open source stack. You're likely leveraging other open source technologies alongside Camel. Find out how you can build the ideal open source stack and make open source work even better for your business. Use the OpenLogic Stack Builder and get a report from our open source experts.Build My Stack
Camel is just one part of your open source stack. You're likely leveraging other open source technologies alongside Camel. Find out how you can build the ideal open source stack and make open source work even better for your business. Use the OpenLogic Stack Builder and get a report from our open source experts.
Build My Stack
There are many benefits to using Camel. One of the biggest Camel benefits is that the testing of the Camel framework is outsourced to the community.
For example, the Camel framework is based on Spring. If you’re utilizing Spring data to consume data from a Postgres database, the only business logic your team is responsible for writing a test harness for is in your implementation of the Spring framework. Your development team isn’t writing unit tests to validate that Spring Data returns rows and columns as it should from the JDBC datasource, or any of the underlying technology that that framework is built off of. JNDI, the JVM, the Linux Kernel.
There’s a lot that goes into a stack. And Apache Camel is the best choice to handle complexities of the code for handling the routing, transformation, scheduling, error handing, redelivery, and aggregation of batches and streams of messages.
There’s a little exercise I like to do when introducing Apache Camel to new developers and development managers. I ask about a complex integration problem that the enterprise is currently facing or has written a solution around in the past.
For example, I've heard about the output of a timekeeping system disconnected from an API in a remote site like a factory that needs to be consumed to run payroll. Shell scripts automate the movement of this file via FTP. Certain columns need to be dropped for privacy, maybe because of GDPR or State of California privacy requirements regarding PII.
There are sed, awk, and complicated, hard-to-test, easy-to-fail transformations that eventually connect to another integration, such as curling against a real API into the main NetSuite system for payroll.
Then, I ask about how many total lines of code are used to create the solution. Usually. it takes 100s or even 1,000s of lines of code if there’s error handling, complex transformations, routing, and aggregation.
Apache Camel can handle even the most complex of scenarios in 10, maybe 20 lines of code.
Camel can handle complexity because it is an amazing component-driven, message-oriented routing, and normalization framework. The Camel framework is based on Spring. So, you can program Camel “routes” as XML, Scala, and — my favorite — fluent-style Java code.
Camel provides an inversion of control (IoC) approach to data routing. This approach allows for a seamless transition of messaging data between a wide variety of integration components.
This variety can mean 100s of well-tested components. Consuming from OracleMQ, stripping a sensitive field like SSN from the JSON, and placing those messages onto a Kafka queue? Three lines of code.
Here's how it looks in the Camel framework:
The first line consumes messages from JMS, like ActiveMQ. The second uses JsonPath to pull the SSN from the record and replaces all SSN patterns with XXX-XXX-1234. The third line places the transformed message onto a Kafka topic.
Here's how Camel works.
Camel's URI-based routing methodology allows for the composition of message consumers and producers at runtime based on config flags and environment variables. A Docker container can be written to dynamically route messages to and from locations based on operator need.
I recently worked an architecture out with a financial institution where we would utilize Camel as a cron runner, with a definitive “finished” state, and allow Kubernetes to schedule it. Their use-case was log shipping from a black box system to ElasticSearch and Kibana for reporting. But there are a ton of integrations for Camel — including over 333 stable ones.
Camel works great in modern DevOps environments that rely on containers and Kubernetes. Compatible with the GraalVM and Quarkus, Camel can create native images that utilize 10% of the same memory of a traditional cloud stack. This is game-changing for distributed cloud applications.
Camel makes it simple and scalable to attach 100s of different heterogeneous service endpoints in an efficient way. It’s component-driven approach focuses on the reduction of boilerplate code while writing integration logic.
When you use Camel, you spend more time writing code that matters to the enterprise.
There are many benefits to using Camel. But making Camel work for you, especially if you're part of a large organization, can be tricky. That's why it's best to partner with the experts.
OpenLogic by Perforce has Camel experts available to support you. We offer Apache Camel training, consultative support, and so much more.
Our Camel experts can help you with:
Get in touch with a Camel expert today and find out how we can help you maximize Camel.
talk to a CAMEL EXPERT
Enterprise Architect, OpenLogic by Perforce
With over a decade of experience in enterprise software architecture, engineering, and operations for the Fortune 500, Connor is working to build and support cloud native solutions for OpenLogic customers around the world.