Integrating Applications with Kamelets

Procedure

1. In the OpenShift Container Platform web console, log in by using an account with cluster administrator privileges.

2. Create a new OpenShift project:

   1. In the left navigation menu, click Home > Project > Create Project.
   2. Enter a project name, for example, my-camel-k-project, and then click Create.
3. In the left navigation menu, click Operators > OperatorHub.
4. In the Filter by keyword text box, type Camel K and then click the Red Hat Integration - Camel K Operator card.
5. Read the information about the operator and then click Install. The Operator installation page opens.

6. Select the following subscription settings:

   • Update Channel > 1.6.x
   • Installation Mode > A specific namespace on the cluster > my-camel-k-project

   • Approval Strategy > Automatic

     Note

     The Installation mode > All namespaces on the cluster and Approval Strategy > Manual settings are also available if required by your environment.

7. Click Install, and then wait a few moments until the Camel K Operator is ready for use.

8. Download and install the Camel K CLI tool:

   1. From the Help menu (?) at the top of the OpenShift web console, select Command line tools.
   2. Scroll down to the kamel - Red Hat Integration - Camel K - Command Line Interface section.
   3. Click the link to download the binary for your local operating system (Linux, Mac, Windows).
   4. Unzip and install the CLI in your system path.

   5. To verify that you can access the Kamel K CLI, open a command window and then type the following:

      kamel --help

      This command shows information about Camel K CLI commands.

1. In a Terminal window, login to your OpenShift cluster.

2. Viewing the list of available Kamelets depends on how the Camel K operator was installed (in a specific namespace or cluster-mode):

   • If the Camel K operator is installed in cluster-mode, use this command to view the available Kamelets:

     oc get kamelet -n openshift-operators

   • If the Camel K operator is installed in a specific namespace:

     1. Open a project in which the Camel K operator is installed.

        oc project <camelk-project>

        For example, if the Camel K operator is installed in the my-camel-k-project project:

        oc project my-camel-k-project

     2. Run the following command:

        oc get kamelets

Procedure

1. Login to your OpenShift cluster.

2. Open your working project where the Camel K operator is installed. If you installed the Camel K operator in cluster-mode, it is available to any project on the cluster.

   For example, to open an existing project named my-camel-k-project:

   oc project my-camel-k-project

3. Create a new Kamelet Binding by using one of the following options:

   • Use the kamel bind command to create and run a Kamelet Binding (this option is useful for simple Kamelet Bindings that are conducive for a command line definition)

   • Create a YAML file to define a Kamelet Binding and then use the oc apply command to run it (this option is useful when the Kamelet Binding configuration is more complicated).

     Create a new Kamelet Binding by using the kamel bind command

     Specify the source and sink Kamelets and any configuration parameters by using the following kamel bind syntax:

     kamel bind <kamelet-source> -p “<property>=<property-value>” <kamelet-sink> -p “<property>=<property-value>”

     For example:

     kamel bind coffee-source -p “source.period=5000” log-sink -p "sink.showStreams=true"

     The Camel K operator generates a KameletBinding resource and runs a corresponding Camel K integration.

     Create a new Kamelet Binding by using a YAML file

     1. In an editor of your choice, create a YAML file with the following structure:

        apiVersion: camel.apache.org/v1alpha1
        kind: KameletBinding
        metadata:
          name:
        spec:
          source:
          sink:

     2. Add a name for the Kamelet Binding.

        For this example, the name is coffee-to-log because the binding connects the coffee-source Kamelet to the log-sink Kamelet.

        apiVersion: camel.apache.org/v1alpha1
        kind: KameletBinding
        metadata:
          name: coffee-to-log
        spec:
          source:
          sink:

     3. Specify the source Kamelet (for example, coffee-source) and configure any parameters for the Kamelet.

        Note: For this example, the parameter is defined within the Kamelet Binding’s YAML file. Alternatively, you can configure a Kamelet’s parameters in a property file, ConfigMap, or Secret as described in Configuring Kamelet instance parameters.

        apiVersion: camel.apache.org/v1alpha1
        kind: KameletBinding
        metadata:
          name: coffee-to-log
        spec:
          source:
            ref
              kind: Kamelet
              apiVersion: camel.apache.org/v1alpha1
              name: coffee-source
            properties:
              period: 5000
          sink:

     4. Specify the sink Kamelet (for example, log-sink) and configure any parameters for the Kamelet. Use the optional showStreams parameter for the log-sink Kamelet to show the message body.

        apiVersion: camel.apache.org/v1alpha1
        kind: KameletBinding
        metadata:
          name: coffee-to-log
        spec:
          source:
            ref:
              kind: Kamelet
              apiVersion: camel.apache.org/v1alpha1
              name: coffee-source
            properties:
              period: 5000
          sink:
            ref:
              kind: Kamelet
              apiVersion: camel.apache.org/v1alpha1
              name: log-sink
            properties:
              showStreams: true

     5. Save the YAML file (for example, coffee-to-log.yaml).

     6. Add the KameletBinding as a resource to your OpenShift namespace:

        oc apply -f <kamelet-binding>.yaml

        For example:

        oc apply -f coffee-to-log.yaml

        The Camel K operator generates and runs a Camel K integration by using the KameletBinding resource.

4. To see the status of the Kamelet Binding:

   oc get kameletbindings

5. To see the status of the corresponding integration: oc get integrations

6. To view the output:

   • To view the logs from the command line, open a Terminal window and then type the following command:

     kamel log <integration-name>

     For example, if the integration name is coffee-to-log, use this command:

     kamel log coffee-to-log

   • To view the logs from OpenShift web console:

     1. Select Workloads > Pods.

     2. Click the name of the Camel K integration’s pod, and then click Logs.

        You should see a list of coffee events similar to the following example:

        INFO  [log-sink-E80C5C904418150-0000000000000001] (Camel (camel-1) thread #0 - timer://tick) {"id":7259,"uid":"a4ecb7c2-05b8-4a49-b0d2-d1e8db5bc5e2","blend_name":"Postmodern Symphony","origin":"Huila, Colombia","variety":"Kona","notes":"delicate, chewy, black currant, red apple, star fruit","intensifier":"balanced"}

7. To stop the integration, delete the Kamelet Binding:

   oc delete kameletbindings/<kameletbinding-name>

   For example:

   oc delete kameletbindings/coffee-to-log

Procedure

1. Open a KameletBinding file in an editor.

   For example, here are the contents of the coffee-to-log.yaml file:

   apiVersion: camel.apache.org/v1alpha1
   kind: KameletBinding
   metadata:
     name: coffee-to-log
   spec:
     source:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: coffee-source
       properties:
         period: 5000
     sink:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: log-sink

2. Add an integration section above the source section and provide the following Builder trait configuration property (as required by the predicate-filter-action Kamelet):

   apiVersion: camel.apache.org/v1alpha1
   kind: KameletBinding
   metadata:
     name: coffee-to-log
   spec:
     integration:
            traits:
              builder:
                configuration:
                  properties:
                    - "quarkus.arc.unremovable- types=com.fasterxml.jackson.databind.ObjectMapper"
     source:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: coffee-source
       properties:
         period: 5000
     sink:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: log-sink

3. Add a steps section, between the source and sink sections and define the action Kamelet. For example:

   apiVersion: camel.apache.org/v1alpha1
   kind: KameletBinding
   metadata:
     name: coffee-to-log
     spec:
       integration:
              traits:
                builder:
                  configuration:
                    properties:
                      - "quarkus.arc.unremovable-types=com.fasterxml.jackson.databind.ObjectMapper"
     source:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: coffee-source
       properties:
         period: 5000
     steps:
     - ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: json-deserialize-action
     - ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: predicate-filter-action
       properties:
         expression: "@.intensifier =~ /.*deep/"
     - ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: json-serialize-action
     sink:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: log-sink

4. Save your changes.

5. Use the oc apply command to update the KameletBinding resource, for example:

   oc apply -f coffee-to-log.yaml

   The Camel K operator re-generates and runs the CamelK integration that it generates based upon the updated KameletBinding resource.

6. To see the status of the Kamelet Binding:

   oc get kameletbindings

7. To see the status of its corresponding integration:

   oc get integrations

8. To view the log file output for the integration:

   kamel logs <integration-name>

   For example, if the integration name is coffee-to-log:

   kamel logs coffee-to-log

9. To stop the integration, delete the Kamelet Binding:

   oc delete kameletbindings/<kameletbinding-name>

   For example:

   oc delete kameletbindings/coffee-to-log

1. Open a KameletBinding YAML file in an editor.

2. Add an error handler section to the spec section, after the sink definition:

   apiVersion: camel.apache.org/v1alpha1
   kind: KameletBinding
   metadata:
     name: example-kamelet-binding
   spec:
     source:
      ...
     sink:
      ...
     errorHandler: ...

   For example, in the coffee-to-log Kamelet Binding, specify the maximum number of times an error is sent to the log file by adding a log error handler:

   apiVersion: camel.apache.org/v1alpha1
   kind: KameletBinding
   metadata:
     name: coffee-to-log
   spec:
     source:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: coffee-source
       properties:
         period: 5000
     sink:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: log-sink
     errorHandler:
       log:
         parameters:
           maximumRedeliveries: 3

3. Save your file.

Procedure

1. Edit the Kamelet Binding to include the topic-name-matches-filter-action Kamelet as an intermediary step between the source and sink Kamelets.

   Typically, you use the kafka-source Kamelet, as the source Kamelet and you supply a topic as the value of the required topic parameter.

   In the following Kamelet Binding example, the kafka-source Kamelet specifies the test-topic, test-topic-2, and test-topic-3 Kafka topics and the topic-name-matches-filter-action Kamelet specifies to filter out the event data from the topic-test topic:

   apiVersion: camel.apache.org/v1alpha1
   kind: KameletBinding
   metadata:
     name: kafka-to-log-by-topic
   spec:
     source:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: kafka-source
       properties:
         bootstrapServers: "broker.url:9092"
         password: "testpassword"
         topic: "test-topic, test-topic-2, test-topic-3"
         user: "testuser"
         securityProtocol: "PLAINTEXT" // only for AMQ streams
   steps:
     - ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: topic-name-matches-filter-action
       properties:
         regex:  "test-topic"
   sink:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: log-sink
       properties:
           showStreams: true

   If you want to filter topics coming from a source Kamelet other than the kafka-source Kamelet, you must supply the Kafka topic information. You can use the insert-header-action Kamelet to add a Kafka topic field as an intermediary step, before the topic-name-matches-filter-action step in the Kamelet Binding as shown in the following example:

   apiVersion: camel.apache.org/v1alpha1
   kind: KameletBinding
   metadata:
     name: coffee-to-log-by-topic
   spec:
     source:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: coffee-source
       properties:
         period: 5000
   steps:
     - ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: insert-header-action
       properties:
         name:  "KAFKA.topic"
         value:  "test-topic"
     - ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: topic-name-matches-filter-action
       properties:
         regex:  "test-topic"
   sink:
       ref:
         kind: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: log-sink
       properties:
         showStreams: true

2. Save the Kamelet Binding YAML file.

Procedure

1. Log in to your OpenShift cluster.

2. Open the project in which you want to create your integration application. For example:

   oc project camel-k-knative

3. Create a channel by using the Knative (kn) CLI command

   kn channel create <channel_name> --type <channel_type>

   For example, to create a channel named mychannel:

   kn channel create mychannel --type messaging.knative.dev:v1:InMemoryChannel

4. To confirm that the channel now exists, type the following command to list all existing channels:

   kn channel list

   You should see your channel in the list.

Procedure

1. Log in to your OpenShift cluster.

2. Open the project in which you want to create your integration application. For example:

   oc project camel-k-knative

3. Create the broker by using this Knative (kn) CLI command:

   kn broker create default

4. To confirm that the broker now exists, type the following command to list all existing brokers:

   kn broker list