Camel integrations
Integrations in Weik.io are Apache Camel routes in YAML, XML or Java, and they can use Camel's components and kamelets. If your team already uses Camel, you can manage your separate Camel integrations in Weik.io, which adds logs, metrics and traces, role-based access and an audit log to them. Each integration runs in its own JVM on an agent, with the Camel version you choose, 4.18 or 4.22. You promote each version from devtest to production with the weikio CLI or the admin UI.
- route:
id: export-invoices
from:
uri: "file:{{invoice-inbox}}"
parameters:
include: '.*\.json'
move: .done
steps:
- setHeader:
name: Authorization
simple: "Bearer {{erp-api-key}}"
- setHeader:
name: Content-Type
constant: application/json
- to:
uri: "{{erp-url}}/api/invoices"
parameters:
httpMethod: POST
- to: micrometer:counter:invoices_processed
- to: "kamelet:weikio-event-sink?channel=invoice-created"Already running Camel
Many teams chose Apache Camel first and run their integrations as separate Spring Boot, Quarkus or JBang applications. In Weik.io each of them becomes a folder of Camel files. The routes, beans, kamelets and properties move into the folder, and dependencies become Maven coordinates or jars in libs/.
Put the files in a folder
Each integration gets its own folder inside a project folder that has a
project.yaml. Theintegration.yamlfile is optional, and you add it to set a version number, a Camel version or extra dependencies.finance/finance/ project.yaml erp-invoice-export/ integration.yaml application.properties README.md routes/ export-invoices.camel.yaml beans/ InvoiceMapper.java kamelets/ erp-paging-source.kamelet.yaml libs/ erp-client.jarPublish a version
weikio applyuploads the folder, resolves its jars at the hub and stores the result as version 1.0.0 without starting it.Terminal$ weikio apply -f ./finance/erp-invoice-exportYou seeTarget: https://hub.example, project finance (from finance/project.yaml) integration finance/erp-invoice-export created (version 1.0.0, built in 20.8 s) Nothing new is running yet. To run it: weikio deploy -f ./finance/erp-invoice-export --env devtestRun it in devtest
weikio deploystarts the version on every agent that serves devtest and is allowed to run the project.Terminal$ weikio deploy finance/erp-invoice-export --env devtestYou seeTarget: https://hub.example, project finance (context), environment devtest (--env) Deploying finance/erp-invoice-export 1.0.0 (latest) to devtest... deployment devtest/finance/erp-invoice-export created (version 1.0.0) Agents: 1 of 1 running after 3.4 s
One integration, three syntaxes
This is the route of finance/erp-invoice-export in YAML, XML and Java. It picks up each invoice file and posts it to the ERP at the address in the erp-url variable, with the key from the erp-api-key secret, and then publishes the invoice to the channel invoice-created. The Micrometer counter invoices_processed shows on the integration's Metrics page beside Camel's own numbers.
# routes/export-invoices.camel.yaml
- route:
id: export-invoices
from:
uri: "file:{{invoice-inbox}}"
parameters:
include: '.*\.json'
move: .done
steps:
- setHeader:
name: Authorization
simple: "Bearer {{erp-api-key}}"
- setHeader:
name: Content-Type
constant: application/json
- to:
uri: "{{erp-url}}/api/invoices"
parameters:
httpMethod: POST
- to: micrometer:counter:invoices_processed
- to: "kamelet:weikio-event-sink?channel=invoice-created"<!-- routes/export-invoices.camel.xml -->
<routes xmlns="http://camel.apache.org/schema/spring">
<route id="export-invoices">
<from uri="file:{{invoice-inbox}}?include=.*\.json&move=.done"/>
<setHeader name="Authorization">
<simple>Bearer {{erp-api-key}}</simple>
</setHeader>
<setHeader name="Content-Type">
<constant>application/json</constant>
</setHeader>
<to uri="{{erp-url}}/api/invoices?httpMethod=POST"/>
<to uri="micrometer:counter:invoices_processed"/>
<to uri="kamelet:weikio-event-sink?channel=invoice-created"/>
</route>
</routes>// routes/ExportInvoices.java
import org.apache.camel.builder.RouteBuilder;
public class ExportInvoices extends RouteBuilder {
@Override
public void configure() {
from("file:{{invoice-inbox}}?include=.*\\.json&move=.done")
.routeId("export-invoices")
.setHeader("Authorization", simple("Bearer {{erp-api-key}}"))
.setHeader("Content-Type", constant("application/json"))
.to("{{erp-url}}/api/invoices?httpMethod=POST")
.to("micrometer:counter:invoices_processed")
.to("kamelet:weikio-event-sink?channel=invoice-created");
}
}What Weik.io adds
Versions and environments
weikio apply publishes an immutable version of the folder, and weikio deploy runs it in an environment. weikio promote copies a tested version to the next environment without a rebuild, and weikio rollback returns to the previous one.
Dependencies and kamelets
The Camel components your routes use are resolved automatically. Other jars come from Maven coordinates or from a libs/ folder, projects share their kamelets, and a hub without internet access fetches everything through one Maven mirror.
Camel versions
Each integration chooses Camel 4.18.5 or 4.22.1 with one line in integration.yaml. weikio get camel-lines lists the Camel versions your installation allows and the kamelet catalog that comes with each.
Variables and secrets
Values differ per environment and reach the route as ordinary Camel properties such as {{erp-url}}. Secrets are encrypted at the hub, and the agent gives them to the route in a file that only the agent's user can open.
One copy at a time
With singleton: true or Camel's master: component, an integration on two matching agents runs as two copies, and a lock at the hub lets one copy work while the other waits. The waiting copy takes over when the first agent goes away, and no site needs ZooKeeper for the lock.
Invoke a route
You can send a message to any endpoint with a producer, such as direct: or seda:, from the CLI or the admin UI. weikio invoke prints the reply and the command that opens the message's trace.
Local runs
weikio dev run runs the folder on your machine with Camel JBang, devtest's values and the project's kamelets before anything is published.
README on the integration's page
The README.md of the folder shows on the integration's page in the admin UI, Mermaid diagrams included, beside its versions and environments.
What a running integration shows
Every log line, metric and trace of an integration carries its version, environment and agent. The Metrics page opens on six numbers and a chart with a marker at each deploy. A trace follows each message through its routes and into the integrations that read its events, and it shows each retry of a call as a numbered attempt.








Measured
- 16 s
- First build of the hello integration, most of it Camel resolving the jars
- 1 to 2 s
- Build after a change to values only
- 131 to 136 MB
- Memory of one running Camel JVM
- < 1 KB
- Fetched by an agent for one changed route, from an 88 MB jar set the hub resolves once per version
- < 2 GB
- Memory of a hub and a site on one machine with five integrations
Camel track
The short videos of the Camel track start with your first integration and end with custom metrics, and each one has the commands to follow along.
Camel 1 · 3:15 Your first integration Watched
Camel 2 · 3:36 Change it and run it again Watched
Camel 3 · 4:04 What a running integration is doing Watched
Camel 4 · 3:56 Where the values live Watched
Camel 5 · 3:59 Connecting to another system Watched
Camel 6 · 3:03 Custom metrics Watched
Patterns 3 · 3:15 Running an integration on a schedule Watched
Patterns 5 · 2:58 One copy at a time WatchedQuestions
Do I need Kubernetes?
Weik.io doesn't use Kubernetes. The hub runs with Docker Compose on one server, or on three or five for high availability, and agents run on any Linux host with Docker, including hosts inside your own network.
Which Java runs my integrations?
Your integrations run on OpenJDK 21, which comes in the agent image, and each running integration has its own JVM.
Can I use my own Java code?
Java beans in beans/*.java are compiled when the hub builds the version, and a jar anywhere in the folder, such as in libs/, goes on the classpath as it is.
Where do the jars come from without internet access?
The hub fetches them from one Maven mirror that you set when you install it, and builds on both Camel versions work behind that mirror.
How are teams kept apart?
Each team works in its own projects, and roles are granted per project and environment. An agent's credential reaches only the projects and environments an admin allowed for it.
Can an integration start from a file transfer or an event?
An integration that starts from the weikio-event-source kamelet receives the events of a channel, such as the run summary of each file transfer or the events that other integrations and event sources publish.
Is Weik.io open source?
Weik.io is open source under the Apache License 2.0 and runs on your own servers, in your cloud or in Weik.io Cloud.
Run it on your machine
The dev container runs Camel 4.22.1 and 4.18.5 with the whole platform around them.