Red Hat Summit Red Hat SummitSupportConsoleDevelopersStart a trialContact

Kaoto

Red Hat build of Apache Camel 4.10

Create and edit integrations based on Apache Camel with Kaoto

Abstract

This guide provides a comprehensive overview of Kaoto, a visual design tool tailored for creating Apache Camel integrations. It covers both the installation process and the utilization of Kaoto to expedite the development lifecycle.

Chapter 1. Overview of Kaoto

Kaoto is an acronym for Kamel Orchestration Tool. It is a low code and no code integration designer to create and edit integrations based on Apache Camel. Kaoto is extendable, flexible, and adaptable to different use cases.

Kaoto offers a rich catalog of building blocks for use in graphical design. By default, Kaoto loads the official upstream Camel Catalog and Kamelet Catalog, while also providing Red Hat supported Catalogs.

Kaoto stands out as an intuitive visual platform for Apache Camel integrations, specifically designed to streamline the development process. It offers an accessible entry point for junior integration engineers through its low-code/no-code capabilities, making the initial steps of integration development straightforward. Moreover, Kaoto supports a seamless transition to more sophisticated features, allowing expert Camel developers to develop and fine-tune complex integration routes effectively.

The audience for this guide is Apache Camel developers. This guide assumes familiarity with Apache Camel and the processing requirements for your organization.

Benefits of using Kaoto can be listed as follows:

  • Enhanced Visual Development Experience

    By leveraging Kaoto’s visual designing capabilities, users can intuitively create, view, and edit Camel integrations through the user interface. This low-code/no-code approach significantly reduces the learning curve for new users and accelerates the development process for seasoned developers.

  • Comprehensive Component Catalog Accessibility

    Kaoto provides immediate access to a rich catalog of Camel components, enterprise integration patterns (EIPs), and Kamelets. This extensive Catalog enables developers to easily find and implement the necessary components for their integration solutions. By having these resources readily available, developers can focus more on solving business problems rather than spending time searching for and learning about different components.

  • Streamlined Integration Development Process

    The platform is designed with an efficient user experience in mind, optimizing the steps required to create comprehensive integrations. This efficiency is achieved through features like auto-completion, configuration forms, and interactive feedback mechanisms. As a result, developers can quickly assemble and configure integrations, reducing the overall development time. This streamlined process encourages experimentation and innovation by making it easier to prototype and test different approaches.

Chapter 2. Installing Kaoto

2.1. Pre-requisites

2.1.1. Microsoft Visual Studio Code

Kaoto ships as a Microsoft Visual Studio Code extension. If you haven’t installed VS Code on your manchine yet, please do that now.

Visit the download page and follow the installation instructions that apply best for you.

2.1.2. Camel CLI

To give you the best user experience we recommend to install the Camel CLI, which offers various functionalities for Camel developers.

Please follow the below steps to install it.

  1. Install JBang following these instructions.

  2. Verify that JBang is working by executing the following from a command shell. This should output the version of installed JBang. 

    jbang version
    Copy to Clipboard

  3. Run the following command from a command shell to install the Camel CLI: 

    jbang app install camel@apache/camel
    Copy to Clipboard

  4. Check if the Camel CLI is working by executing the following from a command shell. This should output the version of the installed Camel CLI. 

    camel version
    Copy to Clipboard

2.1.3. Citrus Testing

If you want to work with the Citrus testing framework, we strongly recommend to install the Citrus JBang plugin.

Please follow the below steps to install it.

  1. Install JBang following these instructions.

  2. Verify that JBang is working by executing the following from a command shell. This should output the version of installed JBang. 

    jbang version
    Copy to Clipboard

  3. Run the following command from a command shell to install the Citrus JBang plugin: 

    jbang app install citrus@citrusframework/citrus
    Copy to Clipboard

  4. Check if the Citrus JBang plugin is working by executing the following from a command shell. This should output the version of the installed Citrus JBang plugin. 

    citrus --version
    Copy to Clipboard

2.2. Kaoto Extension

  1. Open VS Code.
  2. Open the Extensions view on the left side panel (or press CTRL+SHIFT+X).
  3. Type Kaoto in the search field

  4. Click the Install button.

    Kaoto Extension Installation
  5. After the installation is complete, you will see a new icon in the left side panel.

Chapter 3. Getting started with Kaoto

This section describes how to:

  • Setup a workspace in VS Code
  • Access the important commands to create your integration
  • Create your first Camel Route
  • Run your Camel Route locally
  • Get access to the source code of the Camel Route

3.1. Preparing the Workspace

Visual Studio Code requires you to create a workspace for your project to access the full functionality of the environment.

  1. If you haven’t done so yet, please open your Visual Studio Code instance. You can do that by finding the right launcher on your computer or by opening a command shell and executing code.

  2. This should leave you with a window like the one below. (In the picture below we selected already the Kaoto view - see the Kaoto Camel icon)

    empty vscode (1)
  3. Next we need to select our workspace folder which will store our project files.
  4. You can either click on the Open Folder button or you can also go to the File menu and select the entry Open Folder.

  5. In the following screen browse to the folder you would like to use and select it.

    open folder

3.2. Creating first Camel Route

  1. With the Kaoto view (the Kaoto Camel icon) on the left sidebar open you will see the Integration section on top.
  2. When moving the mouse to the right side of the Integrations headline you will see some small icons, one of the is a file with a plus sign.
  3. Click on it, select New Camel Route and follow the instructions to create your first Camel Route.

  4. Once done, the new file will be created and the Kaoto editor should appear as shown in the video below. If the editor does not appear, revisit the earlier steps to ensure you have followed all instructions correctly.

    create integration

  5. At this point, you have successfully created your first working Camel Route, which can be tested immediately.

    Note

    If the execution fails you should double check if you have installed the Camel CLI correctly. Follow the instructions outline in the section Camel CLI section.

  6. You should now see a similar screen like the one below.

    new route (1)

3.2.1. Launching the Camel Route

Testing your integration is easy and straight-forward.

  1. In the Integrations section hover over the file name of your integration and this will reveal some useful buttons. One of these buttons is a Camel icon with a green play button.
  2. Click it to launch your integration locally using Camel JBang.

  3. Please check the below video which will show you how to launch the integration and possible actions to interact with a running integration.

    launch integration
  4. As you can see in the video your integration is launched in Dev Mode and changes to the integration via the Kaoto editor or the source code will be reloaded whenever you save. This will help you prototyping faster.

3.2.2. Accessing the Source Code

You might wonder how the source of your new Camel Route looks like. While Kaoto tries relief users from the burden of working with the source code, we still allow access to it via the default Visual Studio Code Text Editor.

There are two ways to achieve this.

  1. The first one is to use the Open Source Code toggle button on the top right of the Kaoto editor. This is the most convenient way.

  2. The second one is to invoke the context menu on the tab with the file name of your integration and then use the Reopen Editor with item. Both ways are shown in the following video.

    show source

Chapter 4. The Visual Designer

The following picture shows the different parts of the Kaoto Visual Editor.

ui overview
  1. The Explorer View with the opened file selected.
  2. The currently displayed Integration.
  3. The configuration panel where you can adjust and customize settings for the selected step.
  4. Drop down showing the currently selected integration type, here Camel Route.
  5. Drop down showing the currently selected Camel Route. This is handy if you have more than one Camel Route defined in your file. You can rename, delete, select and switch the visibility for each Camel Route here.
  6. Drop down enabling you to add more Routes or other global elements to your integration. Only visible for Camel Routes!
  7. Copies the full source code of your integration to the Clipboard.
  8. Exports the currently visible Integration as a PNG image.
  9. Generate a documentation for your integration and download it in Markdown format.
  10. Drop down showing the available Camel versions. Different runtimes are available, like Camel Main, Springboot and Quarkus.
  11. A step in your Integration with an Error-Marker to indicate a problem with the configuration of the step.
  12. The toolbar of the selected step. It provides available actions for the current selection.
  13. This button bar provides you with functionalities like Zoom In / Out, Reset the View, Switching the layout direction between horizontal and vertical and grants you access to the comprehensive Camel Catalog, containing all the available Components/Connectors, Enterprise Integration Patterns, and Kamelets.

4.1. Working with Camel Routes

In Apache Camel, a route is a set of processing steps that are applied to a message as it travels from a source to a destination. A route typically consists of a series of processing steps that are connected in a linear sequence.

A Camel Route is where the integration flow is defined. For example, you can write a Camel Route to specify how two systems can be integrated. You can also specify how the data can be manipulated, routed, or mediated between the systems.

4.1.1. Creating a new Camel Route

We already covered how to create a new Camel Route YAML file in the chapter Section 3.2, “Creating first Camel Route”.

Let’s use another way of creating a new Camel Route.

  1. If you have your route from the other chapter still open, click on the Route selection drop down and then delete all the routes using the trashbin icon.

    delete route

  2. Once you have confirmed the deletion of all your routes you should see a blank screen like below.

    no route
  3. You can now create a new Camel Route by either clicking the + New button in the center of the canvas or by using the same button in the upper menu bar of the Canvas, next to the Route selection drop down, which will both put a template route in place which uses a Timer component to send every second a message to the Log component.

4.1.2. Adding a step

Now lets add a new step between the Timer and the Log component to modify the message body.

There are two ways of adding a step to the route.

  1. You can either Right-Click on the step you want to insert before or after. This will bring up a context menu with the available actions to choose from.
  2. An easier alternative would be to hover over the connection between the two steps you want to insert between and then click on the + button that appears.

  3. Hover over the connection between the Timer and the Log steps now and click the + button to execute the Add step action.

    step actions
    Important

    When using the right-click context menu, the set of available actions depend on the selected step and can vary. There are actions for appending, prepending, replacing and deleting steps as well as some more specialized actions.

  4. This will open up the Camel Catalog where you can search the step you want to add.

    catalog

  5. As already mentioned we would like to modify the message body before sending it along to the Log component. To achieve that we need to add a Processor called setBody. Let’s enter this name into the filter text field on top of the Catalog.

    catalog setbody

  6. You can now select the setBody tile to add it to your route. Select the new added step now on the canvas to open the configuration form to the right.

    setbody step
  7. Let’s change the Expression text field to Hello from Kaoto!.

  8. Now the Log component will receive a Hello from Kaoto! message every second and logs it to the console.

    Important

    When using the right click context menu of a step, adding new steps is usually done with two actions. Prepend can be used to add a step before the selected step and Append will add the new step after the selected step.

    However, on the first step of a flow and on steps that can have children, the Add Step action is used.

4.1.3. Replacing a step

  1. You can replace any step on the canvas by hovering over or by selecting the step. This will spawn a toolbar which contains a button for the Replace action.

    replace button
  2. Alternatively you can do that also by invoking the context menu on a step and selecting the item Replace. Both ways it will open up the Camel Catalog and you can choose the replacement from there.

4.1.4. Deleting a step

Warning

When invoking the Delete action on a step with children or on a container element containing children there will be a confirmation dialog because you are about to delete not just the single step or container but also all the contained children. Be cautious!

  1. You can delete any step on the canvas by hovering over or by selecting the step. This will spawn a toolbar which contains a button for the Delete action.

    delete button
  2. Alternatively you can do that also by invoking the context menu on a step and selecting the item Delete. This will remove the step from your integration.

4.1.5. Enable / Disable a step

  1. You can enable or disable any step on the canvas by hovering over or by selecting the step. This will spawn a toolbar which contains a button for the Enable / Disable action.

    Important

    Disabling a step will instruct the Apache Camel runtime to ignore the step when executing the flow. This can be convenient when prototyping a new route.

    disable button

  2. Alternatively you can enable / disable any step in your route by invoking the context menu on a step and selecting the item Enable / Disable.

    disabled step
  3. In the picture above the Log component has been disabled. The icon is grayed out and there is a marker icon at the top right of the step to indicate it is disabled.

4.1.6. Generate Integration Documentation

  1. You can use the built-in documentation generating feature to create a Markdown file containing all the steps in your integration and all the changed parameters for these steps together with an image of your integration.

    generate docs button

  2. When you click the button it will open up a dialog with a preview of your integration documentation.

    generate documentation
  3. You can use the Visible Entities control in the top left of the dialog to control which routes are part of the documentation.
  4. You can either select all, just a subset or even just a single route. Once you have made your choice you can specify a file name in the top right and then hit the Download button to retrieve the file in ZIP format.

Chapter 5. Kaoto DataMapper

Note

Currently Kaoto DataMapper is only supported inside the Visual Studio Code extension as a technical preview feature. In the future we will aim to bring this functionality also to the pure web version of Kaoto.

Note

At the moment the DataMapper only supports XML schema for rendering the data structure and it internally generates a single XSLT step to perform configured data mappings at runtime. While you can consume multiple XML documents with using Camel Variables and/or Message Headers which are mapped to XSLT parameters, the output is only a Camel Message Body.

datamapper done

In addition to the regular Camel steps, Kaoto now supports a Kaoto DataMapper step to be placed in the Camel Route. The Kaoto DataMapper step provides a graphical user interface to create data mappings inside the Camel Route.

5.1. Adding a DataMapper step

  1. Add a Kaoto DataMapper step in your Camel route. When you Append, Prepend, or Replace a step in the Kaoto Design view, you can find the Kaoto DataMapper step in the catalog.

    catalog datamapper tile

  1. Click the added Kaoto DataMapper step in the Kaoto Design to open the config form.

    kaoto datamapper step

  2. In the Kaoto DataMapper config form, click the Configure button.

    datamapper configure button

  3. This will open the visual DataMapper editor.

    datamapper blank

5.2. Source and Target

In the DataMapper canvas, you can see Source at the left and Target section at the right side.

datamapper source target

The Source section represents the input side of your mappings, where the DataMapper step reads the data from. This is mapped to the incoming Camel Message as well as possible Camel Variables.

The Target section represents the output side of your mappings, where the DataMapper step writes the data to. This is mapped to the outgoing Camel Message.

5.3. Parameters

The Parameters section inside the Source is mapped to any of incoming Camel Variables and Message Headers. For example, if there is an incoming Camel Variable orderSequence, you can consume it by adding a Parameter orderSequence in the DataMapper Source/Parameters section.

Follow the below steps to add a parameter:

  1. Click the plus (+) button on the right side of the Parameters title.

    datamapper add parameter

  2. Now type the parameter name and click the check button on the right.

    datamapper add parameter confirm
Note

While Camel Exchange Properties are also mapped to Parameters in current camel-xslt-saxon implementation, after the Camel Variables has been introduced, it is no longer recommended to store application data into Camel Exchange Properties. We encourage to use Camel Variables instead.

5.4. Attaching Document schema files

If any of Source Body, Target Body and/or Parameter(s) are structured data, you can attach a schema file and visualize the data structure in a tree style view.

Note

If the data is not structured and just a primitive value, you don’t need to attach a schema file.

Follow the below steps to attach a schema file:

  1. Place schema file(s) inside the workspace directory.

  2. Click Attach a schema button in one of the Source Body, Target Body or Parameters sections.

    datamapper attach schema

  1. Select the schema file to attach

    datamapper select schema

  2. Now the document structure is rendered inside a tree.

    datamapper schema attached

5.5. Creating simple mappings

5.5.1. Creating a mapping by dragging and dropping a field

When you perform drag and drop between the source and the target, a mapping is created and a line is drawn between the fields.

Example: Mapping the Name fields by dragging and dropping the source Name field on the target Name field.

Before:

datamapper drag name

After:

datamapper drop name

5.5.2. Creating a mapping by typing XPath expression

You can also create a mapping by entering a XPath expression.

  1. Click the 3 dots context menu and selecton the target field and choose Add selector expression.

    datamapper add selector

  2. Then enter the XPath expression

    datamapper type xpath

5.6. Creating conditional mappings

The DataMapper supports creating 3 types of conditional mappings:

  1. if - The mapping is created only when the specified condition is met.
  2. choose-when-otherwise - The mapping is created depending on how the condition is satisfied. If the when branch condition is satisfied, the when branch mapping is .created. If no when branch condition is satisfied, then the otherwise branch mapping is created.
  3. for-each - The mapping is created for each item in the collection. Collection means multiple occurrences, which is often represented as an array.

5.6.1. Creating an if mapping

  1. Click the 3 dots context menu on the target section’s field. Then select wrap with "if" to create a mapping.

    datamapper if 3dots
    datamapper if if

  2. Configure the if condition. You can drag the source field and drop it into the input field to build a condition, or alternatively type everything manually.

    datamapper if condition

  3. Configure the mapping by using drag and drop or by typing it manually.

    datamapper if mapping

5.6.2. Creating a choose-when-otherwise mapping

  1. Click the 3 dots context menu on the target section’s field. Then select wrap with "choose-when-otherwise" to create a mapping.

    datamapper choose choose

  2. Configure the when condition.

    datamapper choose when condition

  3. Configure the mapping for the when branch.

    datamapper choose when mapping

  4. Configure the mapping for the otherwise branch.

    datamapper choose otherwise mapping

  5. If required, you can add one or more when branches. To add another when branch you can click the 3 dots menu on the choose field in the Target section and then select Add "when".

    datamapper choose add when
    datamapper choose when added

5.6.3. Creating a for-each mapping

When a field is a collection field (means multiple occurrences, often represented as an array), you can create a for-each mapping. The layer icon on the field indicates that it is a collection field.

datamapper collection field

  1. Click the 3 dots context menu on the target section’s collection field. Then select wrap with "for-each" to create a mapping.

    datamapper for each for each

  2. Configure the for-each condition by specifying the source collection field to iterate over.

    datamapper for each condition

  3. Configure the mappings below. Note that the mapping field path is now a relative path from the collection field specified in the for-each condition.

    datamapper for each mappings

5.7. Using XPath expression editor

Note

The XPath editor is still under initial development and it currently supports only limited drag and drop. In future releases, more syntax assisting features will be added.

If you want to write something more in XPath expression rather than just a field path, you can launch the XPath expression editor and work with it. There is a pencil icon on the target field which launches the XPath expression editor when you click it.

  1. Click the pencil button on a target field which has a mapping.

    datamapper xpath pencil

  2. This will open up the XPath editor.

    datamapper xpath editor

  3. You can then type in the editor at the right or drag a Field from the left and drop onto the editor.

    datamapper xpath dnd fields

  4. You can also drag and drop XPath functions from the Function tab on the left side.

    datamapper xpath functions

  5. Drag the function and drop it onto the editor.

    datamapper xpath functions dnd

  6. Once it’s completed, click the Close button at the bottom left.

    datamapper xpath close

  7. Now you can see the new mapping in the tree view.

    datamapper xpath done

5.8. Deleting a mapping

  1. To delete a mapping you can click the dustbin button next to the target field.

    datamapper delete mapping btn

  2. You then have to confirm the deletion by clicking the Confirm button.

    datamapper delete mapping confirm

  3. Mapping is deleted.

    datamapper delete mapping done

5.9. Deleting a parameter

  1. To delete a parameter, click the dustbin button next to the parameter.

    datamapper delete param trash

  2. You then have to confirm the deletion by clicking the Confirm button.

    datamapper delete param confirm

  3. The parameter is deleted.

    datamapper delete param done

5.10. Detaching a schema

Similar to attaching a schema you can also remove / detach a schema.

  1. Click the Detach schema button.

    datamapper detach button

  2. Click the Confirm button.

    datamapper detach confirm

  3. Now the Document got back to be a primitive value.

    datamapper detach done

Chapter 6. Generating a catalog

6.1. Overview

By default, every Kaoto release includes the latest Camel version available at the moment of the build, nevertheless, generating a different set of catalogs is possible.

6.2. Catalog generator CLI

Kaoto provides a Camel catalog generator CLI to ease this process, it supports the following runtimes:

  1. Main
  2. Quarkus
  3. Springboot

6.2.1. Using Camel catalog

  1. Clone the Kaoto project
  2. Navigate to the packages/catalog-generator directory

  3. Install the project dependencies: 

    ./mvnw install
    Copy to Clipboard

  4. Run the project with the following command: 

    ./mvnw package; java -jar ./target/catalog-generator-0.0.1-SNAPSHOT.jar -o ./dist/camel-catalog -k 4.10.3.redhat-00017 -m 4.10.3.redhat-00020 -n "My Catalog"
    Copy to Clipboard

  5. This will generate a Catalog library containing:

    1. Camel Main 4.6.0
    2. Camel Kamelets 4.6.0
  6. The resulting files will be in the packages/catalog-generator/dist/camel-catalog folder
  7. Providing that folder through a http server will make it available for using it in Kaoto

6.2.2. Creating a Catalog library with different runtimes

  1. In order to add multiple runtimes to the Catalog library, we can provide each runtime with its version using the following flags: 

     -m,--main <version>               Camel Main version. If not specified,
                                   it will use the generator installed
                                   version
 -q,--quarkus <version>            Camel Extensions for Quarkus version
 -s,--springboot <version>         Camel SpringBoot version
    Copy to Clipboard

  2. For instance, running the following command will create a Catalog library with Camel Main 4.6.0 and Camel extensions for Quarkus 3.8.0: 

    ./mvnw package; java -jar ./target/catalog-generator-0.0.1-SNAPSHOT.jar -o ./dist/camel-catalog -k 4.6.0 -m 4.6.0 -q 3.8.0 -n "My Catalog"
    Copy to Clipboard

  3. For a different Kamelets catalog version, the --kamelets or -k flag can be specified. 

    ./mvnw package; java -jar ./target/catalog-generator-0.0.1-SNAPSHOT.jar -o ./dist/camel-catalog -k 4.5.0 -m 4.6.0  -n "My Catalog"
    Copy to Clipboard

6.2.3. Instructing Kaoto to use a specific Catalog library

  1. In VSCode, go to the settings page and look for “Kaoto”

    vscode kaoto settings

  2. In the TextField, provide the URL of the index.json file that specifies the location of the subsequent catalogs, for instance, the public Kaoto catalog can be used:

    setting kaoto catalog url

  3. Restart Kaoto for the changes to have effect

    kaoto runtime selector

Legal Notice

Copyright © 2025 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
Back to top
Red Hat logoGithubredditYoutubeTwitter

Learn

Try, buy, & sell

Communities

About Red Hat Documentation

We help Red Hat users innovate and achieve their goals with our products and services with content they can trust. Explore our recent updates.

Making open source more inclusive

Red Hat is committed to replacing problematic language in our code, documentation, and web properties. For more details, see the Red Hat Blog.

About Red Hat

We deliver hardened solutions that make it easier for enterprises to work across platforms and environments, from the core datacenter to the network edge.

Theme

© 2025 Red Hat