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 with the Camel version you choose, 4.18 or 4.22, and 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, aserp-invoice-exportdoes in the example projectfinance. 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 to Weik.io, which resolves its jars 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 (argument), environment devtest (--env) Deploying finance/erp-invoice-export 1.0.0 (latest) to devtest... deployment devtest/finance/erp-invoice-export created (follows latest) Agents: 1 of 1 running after 3.4 s
YAML, XML and Java
The example's route 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, and projects share their kamelets. An installation without internet access fetches everything through one Maven mirror.
Camel versions
Each integration chooses Camel 4.18.5 or 4.22.1 with a 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}}. Weik.io stores secrets encrypted, 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 kept by Weik.io lets one copy work while the other waits. The waiting copy takes over when the first agent goes away, and no agent 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.
Scheduled commands
A schedule document runs a command on an agent, such as curl or a script, at set times in UTC, with no route to write. It runs one copy at a time, and each run leaves a record with its start, end and exit code that other integrations can react to.
What a running integration shows
Every log line, metric and trace of an integration carries its version, environment and agent. A trace follows each message through its Camel routes and shows each retry of a call as a numbered attempt.








Build times and memory
- 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
- An agent fetches under 1 KB for one changed route, and Weik.io resolves the 88 MB jar set once per version
- < 2 GB
- Memory of Weik.io and an agent on one machine with five integrations
Camel track
The Camel track goes from your first integration to custom metrics, and two pattern videos run an integration on a schedule and in one copy at a time.
Camel 1 · 3:15 Your first integration Watched
Camel 2 · 4:01 Change it and run it again Watched
Camel 3 · 4:24 What a running integration is doing Watched
Camel 4 · 4:37 Where the values live Watched
Camel 5 · 3:59 Connecting to another system Watched
Camel 6 · 3:14 Custom metrics Watched
Patterns 3 · 3:21 Running an integration on a schedule Watched
Patterns 5 · 3:01 One copy at a time WatchedQuestions
Do I need Kubernetes?
No, Weik.io runs with Docker Compose on Linux servers, and an agent runs with Docker Compose on Linux or as Windows services on Windows Server.
Which Java runs my integrations?
Your integrations run on OpenJDK 21, which comes in the agent image on Linux and in the agent installer on Windows Server, and each running integration has its own JVM.
Can I use my own Java code?
Java beans in beans/*.java are compiled when Weik.io 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?
Weik.io 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?
Yes, 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?
Yes, 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 the whole platform with Camel 4.22.1 and 4.18.5.