Skip to content
Weik.io
Book a demoTry Weik.io

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.

finance/erp-invoice-export/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"

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/.

  1. Put the files in a folder

    Each integration gets its own folder inside a project folder that has a project.yaml, as erp-invoice-export does in the example project finance. The integration.yaml file 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.jar
  2. Publish a version

    weikio apply uploads 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-export
    You see
    Target: 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 devtest
  3. Run it in devtest

    weikio deploy starts the version on every agent that serves devtest and is allowed to run the project.

    Terminal
    $ weikio deploy finance/erp-invoice-export --env devtest
    You see
    Target: 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"

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.

Docs: Versions and the developer loop

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.

Docs: Dependencies and kamelets

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.

Docs: Camel versions

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.

Docs: Variables and secrets

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.

Docs: One copy at a time

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.

Docs: Invoke a route

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.

Docs: Versions and the developer loop

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.

Docs: Integration folders and routes

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.

Docs: Schedules

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.

/integrations/finance/erp-invoice-export/metrics
The Metrics page of finance/erp-invoice-export in production with six numbers, a chart of messages per minute with deploy markers and a memory chartThe Metrics page of finance/erp-invoice-export in production with six numbers, a chart of messages per minute with deploy markers and a memory chartThe Metrics page of finance/erp-invoice-export in production with six numbers, a chart of messages per minute with deploy markers and a memory chartThe Metrics page of finance/erp-invoice-export in production with six numbers, a chart of messages per minute with deploy markers and a memory chart
Metrics charts the messages and memory of an integration in one environment, with a marker at each deploy, and opens on six numbers that include failed messages and restarts.

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

Questions

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.

Sign in to the live demo

Sign in with the shared viewer account, which can open every screen of the example projects and can't change anything.

E-mail
viewer@demo.weik.io
Password
try-weikio-live-demo
Open the live demo