Chapter 4. Configuring Camel K integrations

Procedure

1. Develop a Camel integration that uses a property. The following simple example includes a {{my.message}} property placeholder:

   ...
   - from:
      uri: "timer:tick"
      steps:
        - set-body:
            constant: "{{my.message}}"
        - to: "log:info"
   ...

2. Run the integration by using the following syntax to set the property value at runtime.

   kamel run --property <property>=<value> <integration>

   Alternately, you can use the --p shorthand notation (in place of --property):

   kamel run --property <property>=<value> <integration>

   For example:

   kamel run --property my.message="Hola Mundo" HelloCamelK.java --dev

   or

   kamel run --p my.message="Hola Mundo" HelloCamelK.java --dev

   Here is the example result:

   ...
   [1] 2020-04-13 15:39:59.213 INFO  [main] ApplicationRuntime - Listener org.apache.camel.k.listener.RoutesDumper@6e0dec4a executed in phase Started
   [1] 2020-04-13 15:40:00.237 INFO  [Camel (camel-k) thread #1 - timer://java] info - Exchange[ExchangePattern: InOnly, BodyType: String, Body: Hola Mundo from java]
   ...

Procedure

1. Create an integration properties file. The following example is from a file named my.properties:

   my.key.1=hello
   my.key.2=world

2. Develop a Camel integration that uses properties that are defined in the properties file. The following example Routing.java integration uses the {{my.key.1}} and {{my.key.2=world}} property placeholders:

   import org.apache.camel.builder.RouteBuilder;
   
   public class Routing extends RouteBuilder {
     @Override
     public void configure() throws Exception {
   
       from("timer:property-file")
          .routeId("property-file")
          .log("property file content is: {{my.key.1}} {{my.key.2}}");
   
     }
   }

3. Run the integration by using the following syntax to reference the property file:

   kamel run --property file:<my-file.properties> <integration>

   Alternately, you can use the --p shorthand notation (in place of --property):

   kamel run --p file:<my-file.properties> <integration>

   For example:

   kamel run Routing.java --property:file=my.properties --dev

Procedure

1. Create a Camel K integration that references the text file that contains configuration values.

   For example, the following integration (ConfigFileRoute.java) expects the resources-data.txt file to be available on the classpath at runtime:

   import org.apache.camel.builder.RouteBuilder;
   
   public class ConfigFileRoute extends RouteBuilder {
     @Override
     public void configure() throws Exception {
   
       from("timer:config-file")
           .setBody()
               .simple("resource:classpath:resources-data.txt")
           .log("resource file content is: ${body}");
   
     }
   }

2. Run the integration and use the --config option to specify the text file so that it is available to the running integration. For example:

   kamel run --config file:resources-data.txt ConfigFileRoute.java --dev

   Optionally, you can provide more than one file by adding the --config option repeatedly, for example:

   kamel run --config file:resources-data1.txt --config file:resources-data2.txt ConfigFileRoute.java --dev

Procedure

1. Create a Camel K integration that references the ConfigMap.

   For example, the following integration (named ConfigConfigmapRoute.java) references a configuration value named my-configmap-key in a ConfigMap named my-cm.

   import org.apache.camel.builder.RouteBuilder;
   
   public class ConfigConfigmapRoute extends RouteBuilder {
     @Override
     public void configure() throws Exception {
   
       from("timer:configmap")
           .setBody()
                .simple("resource:classpath:my-configmap-key")
           .log("configmap content is: ${body}");
   
     }
   }

2. Run the integration and use the --config option to materialize the ConfigMap file so that it is available to the running integration. For example:

   kamel run --config configmap:my-cm ConfigConfigmapRoute.java --dev

   When the integration starts, the Camel K operator mounts an OpenShift volume with the ConfigMap’s content.

Procedure

1. Create a Camel K integration that references the ConfigMap.

   For example, the following integration (named ConfigSecretRoute.java) references the my-secret property that is in a Secret named my-sec:

   import org.apache.camel.builder.RouteBuilder;
   
   public class ConfigSecretRoute extends RouteBuilder {
     @Override
     public void configure() throws Exception {
   
       from("timer:secret")
           .setBody()
               .simple("resource:classpath:my-secret")
           .log("secret content is: ${body}");
   
     }
   }

2. Run the integration and use the --config option to materialize the Secret so that it is available to the running integration. For example:

   kamel run --config secret:my-sec ConfigSecretRoute.java --dev

   When the integration starts, the Camel K operator mounts an OpenShift volume with the Secret’s content.

Procedure

1. Create a text file that contains properties.

   For example, create a file named my.properties that contains the following properties:

   my.key.1=hello
   my.key.2=world

2. Create a ConfigMap or a Secret based on the properties file.

   For example, use the following command to create a secret from the my.properties file:

   oc create secret generic my-sec --from-file my.properties

3. In the integration, refer to the properties defined in the Secret.

   For example, the following integration (named ConfigSecretPropertyRoute.java) references the my.key.1 and my.key.2 properties:

   import org.apache.camel.builder.RouteBuilder;
   
   public class ConfigSecretPropertyRoute extends RouteBuilder {
     @Override
     public void configure() throws Exception {
   
       from("timer:secret")
           .routeId("secret")
           .log("{{my.key.1}} {{my.key.2}}");
   
     }
   }

4. Run the integration and use the --config option to specify the Secret that contains the my.key.1 and my.key.2 properties.

   For example:

   kamel run --config secret:my-sec ConfigSecretPropertyRoute.java --dev

Procedure

1. Create an integration that uses configuration values from only one of the sources in the ConfigMap or Secret.

   For example, the following integration (ConfigSecretKeyRoute.java) uses the property from only one of the sources in the my-sec-multi secret.

   import org.apache.camel.builder.RouteBuilder;
   
   public class ConfigSecretKeyRoute extends RouteBuilder {
     @Override
     public void configure() throws Exception {
   
       from("timer:secret")
         .setBody()
             .simple("resource:classpath:my-secret-key-2")
         .log("secret content is: ${body}");
     }
   }

2. Run the integration by using the --config secret option and the /key notation.

   For example:

   kamel run --config secret:my-sec-multi/my-secret-key-2 ConfigSecretKeyRoute.java --dev

3. Check the integration pod to verify that only the specified source (for example, my-secret-key-2) is mounted.

   For example, run the following command to list all volumes for a pod:

   oc set volume pod/<pod-name> --all

Procedure

1. Create a Camel K integration that reads the contents of a file that you provide.

   For example, the following integration (ResourceFileBinaryRoute.java) unzips and reads the resources-data.zip file:

   import org.apache.camel.builder.RouteBuilder;
   
   public class ResourceFileBinaryRoute extends RouteBuilder {
     @Override
     public void configure() throws Exception {
   
       from("file:/etc/camel/resources/?fileName=resources-data.zip&noop=true&idempotent=false")
           .unmarshal().zipFile()
           .log("resource file unzipped content is: ${body}");
   
     }
   }

2. Run the integration and use the --resource option to copy the file to the default destination directory (/etc/camel/resources/). For example:

   kamel run --resource file:resources-data.zip ResourceFileBinaryRoute.java -d camel-zipfile --dev

   Note: If you specify a binary file, a binary representation of the contents of the file is created and decoded transparently in the integration.

   Optionally, you can provide more than one resource by adding the --resource option repeatedly, for example:

   kamel run --resource file:resources-data1.txt --resource file:resources-data2.txt ResourceFileBinaryRoute.java -d camel-zipfile --dev

Procedure

1. Create a Camel K integration that references a ConfigMap stored on your OpenShift cluster.

   For example, the following integration (named ResourceConfigmapRoute.java) references a ConfigMap named my-cm that contains my-configmap-key.

   import org.apache.camel.builder.RouteBuilder;
   
   public class ResourceConfigmapRoute extends RouteBuilder {
     @Override
     public void configure() throws Exception {
   
       from("file:/etc/camel/resources/my-cm/?fileName=my-configmap-key&noop=true&idempotent=false")
           .log("resource file content is: ${body}");
   
     }
   }

2. Run the integration and use the --resource option to materialize the ConfigMap file in the default /etc/camel/resources/ directory so that it is available to the running integration.

   For example:

   kamel run --resource configmap:my-cm ResourceConfigmapRoute.java --dev

   When the integration starts, the Camel K operator mounts a volume with the ConfigMap’s content (for example, my-configmap-key).

Procedure

1. Create a Camel K integration that references a Secret stored on your OpenShift cluster.

   For example, the following integration (named ResourceSecretRoute.java) references the my-sec Secret:

   import org.apache.camel.builder.RouteBuilder;
   
   public class ResourceSecretRoute extends RouteBuilder {
     @Override
     public void configure() throws Exception {
   
         from("file:/etc/camel/resources/my-sec/?fileName=my-secret-key&noop=true&idempotent=false")
             .log("resource file content is: ${body}");
   
     }
   }

2. Run the integration and use the --resource option to materialize the Secret in the default /etc/camel/resources/ directory so that it is available to the running integration.

   For example:

   kamel run --resource secret:my-sec ResourceSecretRoute.java --dev

   When the integration starts, the Camel K operator mounts a volume with the Secret’s content (for example, my-sec).

Procedure

1. Create a Camel K integration that references the file, ConfigMap or Secret that contains configuration properties. For example, the following integration (named ResourceFileLocationRoute.java) references the myprops file:

   import org.apache.camel.builder.RouteBuilder;
   
   public class ResourceFileLocationRoute extends RouteBuilder {
     @Override
     public void configure() throws Exception {
   
         from("file:/tmp/?fileName=input.txt&noop=true&idempotent=false")
            .log("resource file content is: ${body}");
   
     }
   }

2. Run the integration and use the --resource option with the @path syntax and specify where to mount the resource content (either a file, ConfigMap or Secret):

   For example, the following command specifies to use the /tmp directory to mount the input.txt file:

   kamel run --resource file:resources-data.txt@/tmp/input.txt ResourceFileLocationRoute.java --dev

3. Check the integration’s pod to verify that the file (for example, input.txt) was mounted in the correct location (for example, in the tmp directory ). For example, run the following command:

   oc exec <pod-name> -- cat /tmp/input.txt

Procedure

1. Create an integration that uses configuration values from only one of the resources in the ConfigMap or Secret. For example, the following integration (named ResourceConfigmapKeyLocationRoute.java) references the my-cm-multi ConfigMap:

   import org.apache.camel.builder.RouteBuilder;
   
   public class ResourceConfigmapKeyLocationRoute extends RouteBuilder {
     @Override
     public void configure() throws Exception {
   
       from("file:/tmp/app/data/?fileName=my-configmap-key-2&noop=true&idempotent=false")
          .log("resource file content is: ${body} consumed from
           ${header.CamelFileName}");
   
     }
   }

2. Run the integration and use the --resource option with the @path syntax and specify where to mount the source content (either a file, ConfigMap or Secret):

   For example, the following command specifies to use only one of the sources (my-configmap-key-2@) contained within the ConfigMap and to use the /tmp/app/data directory to mount it:

   kamel run --resource configmap:my-cm-multi/my-configmap-key-2@/tmp/app/data ResourceConfigmapKeyLocationRoute.java --dev

3. Check the integration’s pod to verify that only one file (for example, my-configmap-key-2) was mounted in the correct location (for example, in the /tmp/app/data directory). For example, run the following command:

   oc exec <pod-name> -- cat /tmp/app/data/my-configmap-key-2