Developing and Managing Integrations Using Camel K

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

1. Log in to your OpenShift cluster’s web console.
2. Create or open a project in which you plan to create your integration, for example my-camel-k-kafka.
3. Install the Camel K operator and Camel K CLI as described in Installing Camel K.

4. Install the AMQ streams operator:

   1. From any project, select Operators > OperatorHub.
   2. In the Filter by Keyword field, type AMQ Streams.

   3. Click the Red Hat Integration - AMQ Streams card and then click Install.

      The Install Operator page opens.

   4. Accept the defaults and then click Install.
5. Select Operators > Installed Operators to verify that the Camel K and AMQ Streams operators are installed.
6. Set up Kafka authentication as described in Managing secure access to Kafka.

1. Log in to your OpenShift cluster’s web console.
2. Select Projects and then click the project in which you installed the Red Hat Integration - AMQ Streams operator. For example, click the my-camel-k-kafka project.
3. Select Operators > Installed Operators and then click Red Hat Integration - AMQ Streams.

4. Create a Kafka cluster:

   1. Under Kafka, click Create instance.
   2. Type a name for the cluster, for example kafka-test.

   3. Accept the other defaults and then click Create.

      The process to create the Kafka instance might take a few minutes to complete.

      When the status is ready, continue to the next step.

5. Create a Kafka topic:

   1. Select Operators > Installed Operators and then click Red Hat Integration - AMQ Streams.
   2. Under Kafka Topic, click Create Kafka Topic.
   3. Type a name for the topic, for example test-topic.
   4. Accept the other defaults and then click Create.

Procedure

1. Log in to your OpenShift web console with a cluster admin account.

2. Create the OpenShift project for your Camel K or kamelets application.

   1. Select Home > Projects.
   2. Click Create Project.
   3. Type the name of the project, for example my-camel-k-kafka, then click Create.

3. Install the RHOAS operator:

   1. From any project, select Operators > OperatorHub.
   2. In the Filter by Keyword field, type RHOAS.

   3. Click the OpenShift Application Services (RHOAS) card (it is a community operator) and then click Install.

      The Install Operator page opens.

   4. Accept the default mode (All namespaces on the cluster) or select the namespace for your project, then click Install.
4. Download and install the RHOAS CLI as described in Getting started with the rhoas CLI.
5. Install the Camel K operator and Camel K CLI as described in Installing Camel K.
6. To verify that the Red Hat Integration - Camel K and OpenShift Application Services (RHOAS) operators are installed, click Operators > Installed Operators.

1. From the command line, log in to your OpenShift cluster.

2. Open your project, for example:

   oc project my-camel-k-kafka

3. Verify that the necessary operators are installed in your project:

   oc get csv

   The result lists the Red Hat Camel K and RHOAS operators and indicates that they are in the Succeeded phase.

4. Prepare and connect a Kafka instance to RHOAS:

   1. Login to the RHOAS CLI by using this command:

      rhoas login

   2. Create a kafka instance, for example kafka-test:

      rhoas kafka create kafka-test

      The process to create the Kafka instance might take a few minutes to complete.

5. To check the status of your Kafka instance:

   rhoas status

   You can also view the status in the web console:

   https://cloud.redhat.com/beta/application-services/streams/kafkas/

   When the status is ready, continue to the next step.

6. Create a new Kafka topic:

   rhoas kafka topic create test-topic

7. Connect your Kafka instance (cluster) with the Openshift Application Services instance:

   rhoas cluster connect

8. Follow the script instructions for obtaining a credential token.

   You should see output similar to the following:

   Token Secret "rh-cloud-services-accesstoken-cli" created successfully
   Service Account Secret "rh-cloud-services-service-account" created successfully
   KafkaConnection resource "kafka-test" has been created
   KafkaConnection successfully installed on your cluster.

   The RHOAS operator sets up the KafkaConnection custom resource named kafka-test.

Procedure

1. Obtain the Kafka Broker URL (Bootstrap URL):

   rhoas status kafka

   This command returns output similar to the following:

     Kafka
     ---------------------------------------------------------------
     ID:                     1ptdfZRHmLKwqW6A3YKM2MawgDh
     Name:                   my-kafka
     Status:                 ready
     Bootstrap URL:        my-kafka--ptdfzrhmlkwqw-a-ykm-mawgdh.kafka.devshift.org:443

2. To obtain a username and password, create a service account by using the following syntax:

   rhoas service-account create --name "<account-name>" --file-format json

   Note

   When creating a service account, you can choose the file format and location to save the credentials. For more information, type rhoas service-account create --help

   For example:

   rhoas service-account create --name "my-service-acct" --file-format json

   The service account is created and saved to a JSON file.

3. To verify your service account credentials, view the credentials.json file:

   cat credentials.json

   This command returns output similar to the following:

   {"user":"srvc-acct-eb575691-b94a-41f1-ab97-50ade0cd1094", "password":"facf3df1-3c8d-4253-aa87-8c95ca5e1225"}

Procedure

1. Edit the application.properties file and add the Kafka credentials.

   application.properties file

   camel.component.kafka.brokers = <YOUR-KAFKA-BOOTSTRAP-URL-HERE>
   camel.component.kafka.security-protocol = SASL_SSL
   camel.component.kafka.sasl-mechanism = PLAIN
   camel.component.kafka.sasl-jaas-config=org.apache.kafka.common.security.plain.PlainLoginModule required username='<YOUR-SERVICE-ACCOUNT-ID-HERE>' password='<YOUR-SERVICE-ACCOUNT-SECRET-HERE>';
   consumer.topic=<TOPIC-NAME>
   producer.topic=<TOPIC-NAME>

2. Run the following command to create a secret that contains the sensitive properties in the application.properties file:

   oc create secret generic kafka-props --from-file application.properties

   You use this secret when you run a Camel K integration.

Procedure

1. Edit the application-oauth.properties file and add the Kafka credentials.

   application-oauth.properties file

   camel.component.kafka.brokers = <YOUR-KAFKA-BOOTSTRAP-URL-HERE>
   camel.component.kafka.security-protocol = SASL_SSL
   camel.component.kafka.sasl-mechanism = OAUTHBEARER
   camel.component.kafka.sasl-jaas-config = org.apache.kafka.common.security.oauthbearer.OAuthBearerLoginModule required \
   oauth.client.id='<YOUR-SERVICE-ACCOUNT-ID-HERE>' \
   oauth.client.secret='<YOUR-SERVICE-ACCOUNT-SECRET-HERE>' \
   oauth.token.endpoint.uri="https://identity.api.openshift.com/auth/realms/rhoas/protocol/openid-connect/token" ;
   consumer.topic=<TOPIC-NAME>
   producer.topic=<TOPIC-NAME>

2. Run the following command to create a secret that contains the sensitive properties in the application.properties file:

   oc create secret generic kafka-props --from-file application-oauth.properties

   You use this secret when you run a Camel K integration.