Chapter 3. Using Camel JBang

Camel JBang provides shell completion for bash and zsh out of the box. To enable shell completion for Camel JBang, run:

source <(camel completion)

To make it permanent, run:

echo 'source <(camel completion)' >> ~/.bashrc

You can run routes from more than one file, for example to run two YAML files:

camel run one.yaml two.yaml

You can run routes from two different files such as yaml and Java:

camel run one.yaml hello.java

You can use wildcards (i.e. *) to match multiple files, such as running all the yaml files:

camel run *.yaml

You can run all files starting with foo*:

camel run foo*

To run all the files in the directory, use:

camel run *

For very small Java routes, it is possible to provide the route as CLI argument, as shown below:

camel run --code='from("kamelet:beer-source").to("log:beer")'

This is very limited as the CLI argument is a bit cumbersome to use than files. When you run the routes from input parameter, remember that:

You can enable the dev mode that comes with live reload of the route(s) when the source file is updated (saved), using the --dev options as shown:

camel run foo.yaml --dev

Then while the Camel integration is running, you can update the YAML route and update when saving. This option works for all DLS including java, for example:

camel run hello.java --dev

You can enable the developer console, which presents a variety of information to the developer. To enable the developer console, run:

camel run hello.java --console

The console is then accessible from a web browser at http://localhost:8080/q/dev (by default). The link is also displayed in the log when the Camel is starting up.

The console can give you insights into your running Camel integration, such as reporting the top routes that takes the longest time to process messages. You can then identify the slowest individual EIPs in these routes.

The developer console can also output the data in JSON format, that can be used by 3rd-party tooling to capture the information. For example, to output the top routes via curl, run:

curl -s -H "Accept: application/json"  http://0.0.0.0:8080/q/dev/top/

If you have jq installed, that can format and output the JSON data in colour, run:

curl -s -H "Accept: application/json"  http://0.0.0.0:8080/q/dev/top/ | jq

A profile in Camel JBang is a name (id) that refers to the configuration that is loaded automatically with Camel JBang. The default profile is named as the application which is a (smart default) to let Camel JBang automatic load application.properties (if present). This means that you can create profiles that match to a specific properties file with the same name.

For example, running with a profile named local means that Camel JBang will load local.properties instead of application.properties. To use a profile, specify the command line option --profile as shown:

camel run hello.java --profile=local

You can only specify one profile name at a time, for example, --profile=local,two is not valid.

In the properties files you can configure all the configurations from Camel Main. To turn off and enable log masking run the following command:

camel.main.streamCaching=false
camel.main.logMask=true

You can also configure Camel components such as camel-kafka to declare the URL to the brokers:

camel.component.kafka.brokers=broker1:9092,broker2:9092,broker3:9092

By default, Camel JBang automatically resolves the dependencies needed to run Camel, this is done by JBang and Camel respectively. Camel itself detects at runtime if a component has a need for the JARs that are not currently available on the classpath, and can then automatically download the JARs.

Camel downloads these JARs in the following order:

If you do not want the Camel JBang to download over the internet, you can turn this off with the --download option, as shown:

camel run foo.java --download=false

Camel JBang automatically detects the dependencies for the Camel components, languages, and data formats from its own release. This means that it is not necessary to specify which JARs to use. However, if you need to add 3rd-party custom JARs then you can specify these with the --deps as CLI argument in Maven GAV syntax (groupId:artifactId:version), such as:

camel run foo.java --deps=com.foo:acme:1.0

To add a Camel dependency explicitly you can use a shorthand syntax (starting with `camel:` or `camel-`):

camel run foo.java --deps=camel-saxon

You can specify multiple dependencies separated by comma:

camel run foo.java --deps=camel-saxon,com.foo:acme:1.0

Camel JBang downloads from the local repository first, and then from the online Maven Central repository. To download from the 3rd-party Maven repositories, you must specify this as CLI argument, or in the application.properties file.

camel run foo.java --repos=https://packages.atlassian.com/maven-external

The configuration for the 3rd-party Maven repositories is configured in the application.properties file with the key camel.jbang.repos as shown:

camel.jbang.repos=https://packages.atlassian.com/maven-external

When you run Camel route, the application.properties is automatically loaded:

camel run foo.java

You can also explicitly specify the properties file to use:

camel run foo.java application.properties

Or you can specify this as a profile:

camel run foo.java --profile=application

Where the profile id is the name of the properties file.

By default, the existing ~/.m2/settings.xml file is loaded, so it is possible to alter the behavior of the Maven resolution process. Maven settings file provides the information about the Maven mirrors, credential configuration (potentially encrypted) or active profiles and additional repositories.

Maven repositories can use authentication and the Maven-way to configure credentials is through <server> elements:

<server>
    <id>external-repository</id>
    <username>camel</username>
    <password>{SSVqy/PexxQHvubrWhdguYuG7HnTvHlaNr6g3dJn7nk=}</password>
</server>

While the password may be specified using plain text, it si recommended to configure the maven master password first and then use it to configure repository password:

$ mvn -emp
Master password: camel
{hqXUuec2RowH8dA8vdqkF6jn4NU9ybOsDjuTmWvYj4U=}

The above password must be added to ~/.m2/settings-security.xml file as shown:

<settingsSecurity>
  <master>{hqXUuec2RowH8dA8vdqkF6jn4NU9ybOsDjuTmWvYj4U=}</master>
</settingsSecurity>

Then you can configure a normal password:

$ mvn -ep
Password: camel
{SSVqy/PexxQHvubrWhdguYuG7HnTvHlaNr6g3dJn7nk=}

Then you can use this password in the <server>/<password> configuration.

By default, Maven reads the master password from ~/.m2/settings-security.xml file, but you can override it. Location of the settings.xml file itself can be specified as shown:

camel run foo.java --maven-settings=/path/to/settings.xml --maven-settings-security=/path/to/settings-security.xml

If you want to run Camel application without assuming any location (even ~/.m2/settings.xml), use this option:

camel run foo.java --maven-settings=false

You can run a route that is hosted on the GitHub using the Camels resource loader. For example, to run one of the Camel K examples, use:

camel run github:apache:camel-kamelets-examples:jbang/hello-java/Hey.java

You can also use the https URL for the GitHub. For example, you can browse the examples from a web-browser and then copy the URL from the browser window and run the example with Camel JBang:

camel run https://github.com/apache/camel-kamelets-examples/tree/main/jbang/hello-java

You can also use wildcards (i.e. \*) to match multiple files, such as running all the groovy files:

camel run https://github.com/apache/camel-kamelets-examples/tree/main/jbang/languages/*.groovy

Or you can run all files starting with rou*:

camel run https://github.com/apache/camel-kamelets-examples/tree/main/jbang/languages/rou*

camel run https://gist.github.com/davsclaus/477ddff5cdeb1ae03619aa544ce47e92

You can use Camel JBang to download the existing examples from GitHub to local disk, which allows to modify the example and to run locally. For example, you can download the dependency injection example by running the following command:

camel init https://github.com/apache/camel-kamelets-examples/tree/main/jbang/dependency-injection

Then the files (not sub folders) are downloaded to the current directory. You can then run the example locally with:

camel run *

You can also download to the files to a new folder using the --directory option, for example to download the files to a folder named myproject, run:

camel init https://github.com/apache/camel-kamelets-examples/tree/main/jbang/dependency-injection --directory=myproject

You can run the example in dev mode, to hot-deploy on the source code changes.

camel run * --dev

You can download a single file, for example, to download one of the Camel K examples, run:

camel init https://github.com/apache/camel-k-examples/blob/main/generic-examples/languages/simple.groovy

This is a groovy route, which you can run with (or use *):

camel run simple.groovy

camel init https://gist.github.com/davsclaus/477ddff5cdeb1ae03619aa544ce47e92

camel run *

camel init https://gist.github.com/davsclaus/477ddff5cdeb1ae03619aa544ce47e92 --directory=foobar

You can specify which Camel version to run as shown:

jbang run -Dcamel.jbang.version=3.20.1 camel@apache/camel [command]

You can also try bleeding edge development by using SNAPSHOT such as:

jbang run --fresh -Dcamel.jbang.version=3.20.1-SNAPSHOT camel@apache/camel [command]

Camel supports running the Camel K integrations and binding files, that are in the CRD format (Kubernetes Custom Resource Definitions).For example, to run a kamelet binding file named joke.yaml:

#!/usr/bin/env jbang camel@apache/camel run
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
  name: joke
spec:
  source:
    ref:
      kind: Kamelet
      apiVersion: camel.apache.org/v1
      name: chuck-norris-source
    properties:
      period: 2000
  sink:
    ref:
      kind: Kamelet
      apiVersion: camel.apache.org/v1
      name: log-sink
    properties:
      show-headers: false

camel run joke.yaml

You can run the Camel routes directly from the OS clipboard. This allows to copy some code, and then quickly run the route.

camel run clipboard.<extension>

Where <extension> is the type of the content of the clipboard is, such as java, xml, or yaml.

For example, you can copy this to your clipboard and then run the route:

<route>
  <from uri="timer:foo"/>
  <log message="Hello World"/>
</route>

camel run clipboard.xml

To list the Camel integrations that are currently running, use the ps option:

camel ps
  PID   NAME                          READY  STATUS    AGE
 61818  sample.camel.MyCamelApplica…   1/1   Running  26m38s
 62506  test1                          1/1   Running   4m34s

This lists the PID, the name and age of the integration.

You can use the stop command to stop any of these running Camel integrations. For example to stop the test1, run:

camel stop test1
Stopping running Camel integration (pid: 62506)

You can use the PID to stop the integration:

camel stop 62506
Stopping running Camel integration (pid: 62506)

To stop all integrations, use the --all option as follows:

camel stop --all
Stopping running Camel integration (pid: 61818)
Stopping running Camel integration (pid: 62506)

The Camel JBang CLI by default only controls the Camel integrations that are running using the CLI, for example, camel run foo.java.

For the CLI to be able to control and manage the Spring Boot or Quarkus applications, you need to add a dependency to these projects to integrate with the Camel CLI.

<dependency>
    <groupId>org.apache.camel.springboot</groupId>
    <artifactId>camel-cli-connector-starter</artifactId>
</dependency>

<dependency>
    <groupId>org.apache.camel.quarkus</groupId>
    <artifactId>camel-quarkus-cli-connector</artifactId>
</dependency>

The get command in the Camel JBang is used for getting the Camel specific status for one or all of the running Camel integrations. To display the status of the running Camel integrations, run:

camel get
  PID   NAME      CAMEL            PLATFORM            READY  STATUS    AGE    TOTAL  FAILED  INFLIGHT  SINCE-LAST
 61818  MyCamel   3.20.1-SNAPSHOT  Spring Boot v2.7.3   1/1   Running  28m34s    854       0         0     0s/0s/-
 63051  test1     3.20.1-SNAPSHOT  JBang                1/1   Running     18s     14       0         0     0s/0s/-
 63068  mygroovy  3.20.1-SNAPSHOT  JBang                1/1   Running      5s      2       0         0     0s/0s/-

The camel get command displays the default integrations, which is equivalent to typing the camel get integrations or the camel get int commands.

This displays the overall information for the every Camel integration, where you can see the total number of messages processed. The column Since Last shows how long time ago the last processed message for three stages (started/completed/failed).

The value of 0s/0s/- means that the last started and completed message just happened (0 seconds ago), and that there has not been any failed message yet. In this example, 9s/9s/1h3m means that last started and completed message is 9 seconds ago, and last failed is 1 hour and 3 minutes ago.

You can also see the status of every routes, from all the local Camel integrations with camel get route:

camel get route
  PID   NAME      ID      FROM                        STATUS    AGE   TOTAL  FAILED  INFLIGHT  MEAN  MIN  MAX  SINCE-LAST
 61818  MyCamel   hello   timer://hello?period=2000   Running  29m2s    870       0         0     0    0   14     0s/0s/-
 63051  test1      java    timer://java?period=1000    Running    46s     46       0         0     0    0    9     0s/0s/-
 63068  mygroovy  groovy  timer://groovy?period=1000  Running    34s     34       0         0     0    0    5     0s/0s/-

camel top
  PID   NAME     JAVA     CAMEL            PLATFORM            STATUS    AGE         HEAP        NON-HEAP     GC     THREADS   CLASSES
 22104  chuck    11.0.13  3.20.1-SNAPSHOT  JBang               Running   2m10s  131/322/4294 MB  70/73 MB  17ms (6)      7/8  7456/7456
 14242  MyCamel  11.0.13  3.20.1-SNAPSHOT  Spring Boot v2.7.3  Running  33m40s  115/332/4294 MB  62/66 MB  37ms (6)    16/16  8428/8428
 22116  bar      11.0.13  3.20.1-SNAPSHOT  JBang               Running    2m7s   33/268/4294 MB  54/58 MB  20ms (4)      7/8  6104/6104

camel top route
  PID   NAME     ID                     FROM                                 STATUS    AGE    TOTAL  FAILED  INFLIGHT  MEAN  MIN  MAX  SINCE-LAST
 22104  chuck    chuck-norris-source-1  timer://chuck?period=10000           Started     10s      1       0         0   163  163  163          9s
 22116  bar      route1                 timer://yaml2?period=1000            Started      7s      7       0         0     1    0   11          0s
 22104  chuck    chuck                  kamelet://chuck-norris-source        Started     10s      1       0         0     0    0    0          9s
 22104  chuck    log-sink-2             kamelet://source?routeId=log-sink-2  Started     10s      1       0         0     0    0    0          9s
 14242  MyCamel  hello                  timer://hello?period=2000            Started  31m41s    948       0         0     0    0    4          0s

camel cmd stop-route chuck

camel get route
  PID   NAME     ID                     FROM                                 STATUS    AGE   TOTAL  FAILED  INFLIGHT  MEAN  MIN  MAX  SINCE-LAST
 81663  chuck    chuck                  kamelet://chuck-norris-source        Stopped           600       0         0     0    0    1          4s
 81663  chuck    chuck-norris-source-1  timer://chuck?period=10000           Stopped           600       0         0    65   52  290          4s
 81663  chuck    log-sink-2             kamelet://source?routeId=log-sink-2  Stopped           600       0         0     0    0    1          4s
 83415  bar      route1                 timer://yaml2?period=1000            Started  5m30s    329       0         0     0    0   10          0s
 83695  MyCamel  hello                  timer://hello?period=2000            Started  3m52s    116       0         0     0    0    9          1s

camel cmd start-route chuck

camel cmd stop-route --all

camel cmd start-route --all

camel cmd logger
  PID   NAME   AGE   LOGGER  LEVEL
 90857  bar   2m48s  root    INFO
 91103  foo     20s  root    INFO

camel cmd logger --level=DEBUG foo

camel get service
 PID   NAME       COMPONENT      PROTOCOL  SERVICE
 1912  netty      netty          tcp       tcp:localhost:4444
 2023  greetings  platform-http  rest      http://0.0.0.0:7777/camel/greetings/{name} (GET)
 2023  greetings  platform-http  http      http://0.0.0.0:7777/q/dev

camel get circuit-breaker
  PID   NAME  COMPONENT     ROUTE   ID               STATE      PENDING  SUCCESS  FAIL  REJECT
 56033  mycb  resilience4j  route1  circuitBreaker1  HALF_OPEN        5        2     3       0

The web console allows inspecting running the Camel integrations, such as all the JMX management information, and not but least to visualize the Camel routes with live performance metrics.

To allow Hawtio to inspect the Camel integrations, the Jolokia JVM Agent must be installed in the running integration. This is done explicitly as follows:

camel ps
  PID   NAME                          READY  STATUS    AGE
 61818  sample.camel.MyCamelApplica…   1/1   Running  26m38s
 62506  test1.java                      1/1   Running   4m34s

With the PID, you can then attach Jolokia:

camel jolokia 62506
Started Jolokia for PID 62506
http://127.0.0.1:8778/jolokia/

Instead of using the PID you can also attach by the name pattern. In this example, the two Camel integrations have unique names (foo and test1), you can attach Jolokia without the PID as follows:

camel jolokia te
Started Jolokia for PID 62506
http://127.0.0.1:8778/jolokia/

Then you can launch the Hawtio using Camel JBang:

camel hawtio

This will automatically download and start the Hawtio, and then open in the web browser.

When the Hawtio launches in the web browser, click the Discover tab which lists the all local available Jolokia Agents. You can use camel jolokia PID to connect to multiple different Camel integrations and from this list select which to load.

Click the green lightning icon to connect to the specific running Camel integration.

You can uninstall the Jolokia JVM Agent in a running Camel integration when no longer needed:

camel jolokia 62506 --stop
Stopped Jolokia for PID 62506

It is also possible to achieve this with only one command, as follows:

camel hawtio test1

Where test1 is the name of the running Camel integration. When you stop Hawtio (using ctrl + c), then Camel will attempt to uninstall the Jolokia JVM Agent, however this is not successful sometimes, because the JVM is being terminated which can prevent camel-jbang from doing JVM process communication to the running Camel integration.

You can execute a Camel JBang file as a script that is used for terminal scripting with pipes and filters.

This requires to add the following line in top of the file, for example, as in the upper.yaml file below:

///usr/bin/env jbang --quiet camel@apache/camel pipe "$0" "$@" ; exit $?

# Will upper-case the input
- from:
    uri: "stream:in"
    steps:
      - setBody:
          simple: "${body.toUpperCase()}"
      - to: "stream:out"

To execute this as a script, you need to set the execute file permission:

chmod +x upper.yaml

Then you can then execute this as a script:

echo "Hello\nWorld" | ./upper.yaml

This outputs:

HELLO
WORLD

You can turn on the logging using --logging=true which then logs to .camel-jbang/camel-pipe.log file. The name of the logging file cannot be configured.

echo "Hello\nWorld" | ./upper.yaml --logging=true

You can use Camel JBang to try local Kamelets, without the need to publish them on GitHub or package them in a jar.

camel run --local-kamelet-dir=/path/to/local/kamelets earthquake.yaml

You can also point to a folder in a GitHub repository. For example:

camel run --local-kamelet-dir=https://github.com/apache/camel-kamelets-examples/tree/main/custom-kamelets user.java

When a route is started from platform-http then the Camel JBang automatically includes a VertX HTTP server running on port 8080. following example shows the route in a file named server.yaml:

- from:
    uri: "platform-http:/hello"
    steps:
      - set-body:
          constant: "Hello World"

You can run this example with:

camel run server.yaml

And then call the HTTP service with:

$ curl http://localhost:8080/hello
Hello World%

There is basic support for including regular Java source files together with Camel routes, and let the Camel JBang runtime compile the Java source. This means you can include smaller utility classes, POJOs, Camel Processors that the application needs.

When running the Camel integrations with camel-jbang, the runtime is camel-main based. This means there is no Spring Boot, or Quarkus available. However, there is a support for using annotation based dependency injection in Java classes.

There are two kinds of debugging available:

jbang --debug  camel@apache/camel run hello.yaml
Listening for transport dt_socket at address: 4004

The status of health checks is accessed using the Camel JBang from the CLI as follows:

camel get health
  PID   NAME    AGE  ID             RL  STATE  RATE    SINCE   MESSAGE
 61005  mybind   8s  camel/context   R   UP    2/2/-  1s/3s/-

Here you can see the Camel is UP. The application has been running for 8 seconds, and there are two health checks invoked.

The output shows the default level of checks as:

The RATE column shows three numbers separated by /. So 2/2/- means 2 checks in total, 2 successful and no failures. The two last columns will reset when a health check changes state as this number is the number of consecutive checks that was successful or failure. So if the health check starts to fail then the numbers could be:

camel get health
  PID   NAME     AGE   ID             RL  STATE   RATE    SINCE    MESSAGE
 61005  mybind   3m2s  camel/context   R   UP    77/-/3  1s/-/17s  some kind of error

Here you can see the numbers is changed to 77/-/3. This means the total number of checks is 77. There is no success, but the check has been failing 3 times in a row. The SINCE column corresponds to the RATE. So in this case you can see the last check was 1 second ago, and that the check has been failing for 17 second in a row.

You can use --level=full to output every health checks that will include consumer and route level checks as well.

A health check may often be failed due to an exception was thrown which can be shown using --trace flag:

camel get health --trace
  PID   NAME      AGE   ID                                      RL  STATE    RATE       SINCE     MESSAGE
 61038  mykafka  6m19s  camel/context                            R   UP    187/187/-  1s/6m16s/-
 61038  mykafka  6m19s  camel/kafka-consumer-kafka-not-secure…   R  DOWN   187/-/187  1s/-/6m16s  KafkaConsumer is not ready - Error: Invalid url in bootstrap.servers: value


------------------------------------------------------------------------------------------------------------------------
                                                       STACK-TRACE
------------------------------------------------------------------------------------------------------------------------
    PID: 61038
    NAME: mykafka
    AGE: 6m19s
    CHECK-ID: camel/kafka-consumer-kafka-not-secured-source-1
    STATE: DOWN
    RATE: 187
    SINCE: 6m16s
    METADATA:
        bootstrap.servers = value
        group.id = 7d8117be-41b4-4c81-b4df-cf26b928d38a
        route.id = kafka-not-secured-source-1
        topic = value
    MESSAGE: KafkaConsumer is not ready - Error: Invalid url in bootstrap.servers: value
    org.apache.kafka.common.KafkaException: Failed to construct kafka consumer
        at org.apache.kafka.clients.consumer.KafkaConsumer.<init>(KafkaConsumer.java:823)
        at org.apache.kafka.clients.consumer.KafkaConsumer.<init>(KafkaConsumer.java:664)
        at org.apache.kafka.clients.consumer.KafkaConsumer.<init>(KafkaConsumer.java:645)
        at org.apache.kafka.clients.consumer.KafkaConsumer.<init>(KafkaConsumer.java:625)
        at org.apache.camel.component.kafka.DefaultKafkaClientFactory.getConsumer(DefaultKafkaClientFactory.java:34)
        at org.apache.camel.component.kafka.KafkaFetchRecords.createConsumer(KafkaFetchRecords.java:241)
        at org.apache.camel.component.kafka.KafkaFetchRecords.createConsumerTask(KafkaFetchRecords.java:201)
        at org.apache.camel.support.task.ForegroundTask.run(ForegroundTask.java:123)
        at org.apache.camel.component.kafka.KafkaFetchRecords.run(KafkaFetchRecords.java:125)
        at java.base/java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:515)
        at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:264)
        at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
        at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
        at java.base/java.lang.Thread.run(Thread.java:829)
    Caused by: org.apache.kafka.common.config.ConfigException: Invalid url in bootstrap.servers: value
        at org.apache.kafka.clients.ClientUtils.parseAndValidateAddresses(ClientUtils.java:59)
        at org.apache.kafka.clients.ClientUtils.parseAndValidateAddresses(ClientUtils.java:48)
        at org.apache.kafka.clients.consumer.KafkaConsumer.<init>(KafkaConsumer.java:730)
        ... 13 more

Here you can see that the health check fails because of the org.apache.kafka.common.config.ConfigException which is due to invalid configuration: Invalid url in bootstrap.servers: value.

The doc goal can show quick documentation for every component, dataformat, and kamelets. For example, to see the kafka component run:

camel doc kafka

To see the documentation for jackson dataformat:

camel doc jackson

In some rare cases then there may be a component and dataformat with the same name, and the doc goal prioritizes components. In such a situation you can prefix the name with dataformat, for example:

camel doc dataformat:thrift

You can also see the kamelet documentation such as shown:

camel doc aws-kinesis-sink

camel doc kafka --open-url

camel doc aws-kinesis-sink --open-url

camel doc kafka --filter=security

camel doc kafka --filter=timeout

The command export --runtime=spring-boot exports your current Camel JBang file(s) to a Maven based Spring Boot project with files organized in src/main/ folder structure.

For example, to export to the Spring Boot using the Maven groupId com.foo and the artifactId acme and with version 1.0-SNAPSHOT, run:

camel export --runtime=spring-boot --gav=com.foo:acme:1.0-SNAPSHOT

To export to another directory, run:

camel export --runtime=spring-boot --gav=com.foo:acme:1.0-SNAPSHOT --directory=../myproject

When exporting to the Spring Boot, the Camel version defined in the pom.xml or build.gradle is the same version as Camel JBang uses. However, you can specify the different Camel version as shown:

camel export --runtime=spring-boot --gav=com.foo:acme:1.0-SNAPSHOT --directory=../myproject --camel-spring-boot-version=3.20.1.redhat-00064

When exporting to Spring Boot, Quarkus or Camel Main, the Camel JBang CLI is not included out of the box. To continue to use the Camel CLI (that is camel), you need to add camel:cli-connector in the --deps option, as shown:

camel export --runtime=quarkus --gav=com.foo:acme:1.0-SNAPSHOT --deps=camel:cli-connector --directory=../myproject

The export command by default loads the configuration from application.properties file which is used for exporting specific parameters such as selecting the runtime and java version.

The following options related to exporting, can be configured in the application.properties file: