Hero shape 1Hero shape 2

iPaaS Insights

Integration tutorials, tips and best practices

Why You Should Build Your iPaaS in Apache Camel

June 23, 2022

Modern integrations require modern integration solutions. The days of integrating your software and legacy systems with enterprise service buses is over. Integration platform as a service (iPaaS) solutions let you create powerful integrations that are cloud-native, scalable horizontally and vertically, and cost-efficient to deploy.

But say your company wants to create its own iPaaS, letting your development team build routes and APIs from scratch while not relying on an external platform. It's certainly possible, but what should the underlying framework of your custom iPaaS be?

Let's explore a well-known open source integration framework, Apache Camel — and see why it should be your foundation when you build your own iPaaS.

Why Build Your Own iPaaS in Apache Camel?

With so many integration vendors out there now advertising their own iPaaS solutions, creating one from scratch may seem like too much of a hassle. Perhaps you don't have many (or any) integration specialists on hand, or your developers aren't specifically trained for building integrations. For some, purchasing an iPaaS solution rather than building one might be the better option.

But if you have the resources to do it, then building your own iPaaS gives you complete freedom over building, running, and deploying your integrations. To do this, you'll need a powerful integration framework at the core. Frameworks provide the backbone for integration development, consisting of routing engines, processors, and various different components to make specific, targeted connections between your apps and systems.

These frameworks not only deliver the toolset to create an iPaaS deployment, but also the freedom to expand your iPaaS as you see fit. Especially if you go the open source route.

Components of iPaaS

Open source integration frameworks give you everything you need to create an iPaaS from the ground up. They combine established enterprise integration patterns with the freedom to deploy standalone, containerized, or embedded integrations. With support for multiple data formats as well, these frameworks give you complete control over how your developers create and deliver integrations.

There are a number of open source frameworks to choose from if you're looking to develop your own iPaaS. So how can you create a custom-built iPaaS on a framework like Apache Camel?

Start Building Your iPaaS Today with Apache Camel

Camel is built in Java and designed to handle complex integrations based on established integration patterns. With Camel's powerful integration engine and pre-built connectors, building your own integrations from scratch is simple. Let's see it in action:

Camel K Timer Tutorial Figure 1

Figure 1

One of the benefits of Camel K is that you can use the Java DSL for a cleaner interface and smaller lines of codes to handle many functionalities. In the example above using Figure 1, we use the Camel K script in a groovy file to run our timer integration.

In this example, four Camel K components (from, header, body, and log) are used to test a simple integration. Here's some brief notes on each component:

  • From: The from component define the endpoint which is starts the integration. It could be a file, URL endpoint, timer scheduler, etc. In this example, we've set the from component to a timer named test. This is where you can also set query parameters for your from component based on your needs; for this integration, we've added repeatCount = 5 to repeat the process five times.
  • Header: You can assign values to your header to use in your integration. Define values using proper methods, like constant(), simple(), jsonPath(), etc. For our example, we set the header of Time to correspond to date:now:hh.mm.ss.
  • Body: The body can also be assigned with values using the same method as the header. We've set the body to return a statement: The time for now is ${header.Time}.
  • Log: To view a specific output of your routes or sections, you can specify the output using the log component. Above, we've set the log to generate the body content.

Now it's time to generate the output:

Camel K Timer Tutorial Figure 2

Figure 2

To run this integration, simply open a command line and run kamel run <file-name>. Or run kamel run <file-name> --dev to run it in developer mode. (See above in Figure 2.)

NOTE: Make sure you've also included the proper Maven dependencies in your project as well.

Why is Apache Camel the Framework for You?

You may be asking whether or not Camel is mature enough to handle all your company's integrations. Rest assured: whatever your integration needs — whether it's simple, isolated connections or an intricate web of integrations that cross various parts of your company — Camel has you covered.

Since it first launched in 2007, several developers and companies have used Camel as the framework for their integration projects. A number of open source and commerical tools either natively integrate with Camel or operate it at the foundation of their solution. Integration software like Red Hat Fuse, OpenHub, Fabric8, CaerusOne, and many others work directly with or are built on Apache Camel.

Camel has also already earned merits as an iPaaS-ready framework. Some commercially-available iPaaS and enterprise service bus (ESB) platforms currently use Camel at their foundation, including Huawei Cloud ROMA Connect and ModusBox PortX.

Camel iPaaS and ESB projects

Why do these companies trust Apache Camel with their integration needs? There's a number of reasons: its powerful component library, cost-efficiency, native support for various software, etc. Two of the most important for iPaaS deployment is its versatility and scalability. You can run Apache Camel anywhere, either as a standalone deployment or inside a container.

Because of this, Camel gives you the tools necessary to create a truly cloud-native, cloud-agnostic integration platform. And Camel can automatically scale horizontally or vertically to meet the increasing (or decreasing) needs of your organization.

Of course, setting up Apache Camel on your cloud environment, Kubernetes cluster, etc. can take a long time. You need to configure both your environment of choice and Camel deployment to work with each other. Jetic makes it easy for you to set up and run integrations within minutes.

You can learn more about Jetic by reading our documentation here.