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

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. 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, 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-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 (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"

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, projects share their kamelets, and a hub 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 one 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}}. 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.

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

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

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.

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

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

Questions

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.