将应用程序与 Kamelets 集成


Red Hat build of Apache Camel K 1.10

配置连接器以简化应用程序集成

Red Hat build of Apache Camel K Documentation Team

摘要

Kamelets 提供了应用程序集成的替代方法。您可以配置红帽构建的 Apache Camel K Kamelets (组合路由模板)来创建连接,而不是直接使用 Camel 组件。

前言

kamelet 是可重复使用的路由组件,可隐藏创建连接到外部系统的数据管道的复杂性。

使开源包含更多

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。我们从这四个术语开始:master、slave、黑名单和白名单。由于此项工作十分艰巨,这些更改将在即将推出的几个发行版本中逐步实施。有关更多详情,请参阅我们的首席技术官 Chris Wright 提供的消息

第 1 章 Kamelets 概述

kamelet 是高级连接器,可作为事件驱动的架构解决方案中的构建块。这些是您可以在 OpenShift 集群上安装并用于 Camel K 集成的自定义资源。kamelets 加快您的开发工作。它们简化了如何连接数据源(发送事件)和数据接收器(这消耗事件)。由于您要配置 Kamelet 参数而不是编写代码,因此您不需要熟悉 Camel DSL 来使用 Kamelets。

您可以使用 Kamelets 直接将应用程序和服务相互连接,或者:

1.1. 关于 Kamelets

kamelets 是路由组件(封装代码),它们充当 Camel 集成中的连接器。您可以将 Kamelets 视为模板,用于定义使用位置(源)以及将数据发送到(接收器) - 允许您编译数据管道。kamelets 也可以过滤、掩码和执行数据上的简单计算逻辑。

Kamelets 有三种不同类型的:

  • Source - 生成数据的路由。您可以使用 source Kamelet 从组件检索数据。
  • sink - 消耗数据的路由。您可以使用 sink Kamelet 将数据发送到组件。
  • action - 对数据执行操作的路由。当一个从源 Kamelet 传递给一个 sink Kamelet 时,您可以使用 Kamelet 操作数据。

1.1.1. 为什么使用 Kamelets?

微服务和 事件驱动的构架解决方案中,Knativedumps 可以充当发送事件的事件和接收器的源的构建块。

kamelet 提供抽象(隐藏连接到外部系统的复杂性)和可重复利用(它们是重复使用代码并将其应用到不同的用例的简单方法)。

以下是一些用例示例:

  • 您希望应用程序消耗来自 192.168.1.0/24gram 的事件,您可以使用 Kamelets 将 definegram 源绑定到事件频道。之后,您可以将应用程序连接到该频道,以便其响应这些事件。
  • 您希望您的应用程序将 Salesforce 直接连接到 Slack。

kamelets 允许您和集成开发团队更有效地。您可以重复使用 Kamelets,并将它们与团队成员共享,这些成员可根据其特定需求配置实例。底层 Camel K operator 执行硬工作:它会编译、构建、软件包和部署 Kamelet 定义的集成。

1.1.2. 谁使用 Kamelets?

由于 Kamelets 允许您减少 Camel 集成中所需的编码量,因此他们对于不熟悉 Camel DSL 的开发人员来说是理想的选择。kamelets 可以帮助平稳处理非 Camel 开发者的学习曲线。不需要学习另一个框架或语言来获取 Camel 运行。

kamelets 对于希望将复杂 Camel 集成逻辑封装到可重复使用的 Kamelet,然后将其与其他用户共享的熟悉的 Camel 开发人员也很有用。

1.1.3. 使用 Kamelets 的先决条件是什么?

要使用 Kamelets,您需要以下环境设置:

  • 您可以使用正确的访问级别访问 OpenShift 4.6 (或更新版本)集群、创建项目并安装 Operator 的功能,以及在本地系统上安装 OpenShift 和 Camel K CLI 工具。
  • 您在命名空间或集群范围安装了 Camel K operator,如 安装 Camel K所述
  • 已安装 OpenShift 命令行(oc)接口工具。
  • (可选)您使用 Camel K 插件安装 VS 代码或其他开发工具。基于 Camel 的工具扩展包括基于嵌入式 Kamelet Catalog 自动完成 Camel URI 等功能。如需更多信息,请参阅 Camel K 入门中的 Camel K 开发工具部分。

    注: Visual Studio (VS)代码工具扩展仅是社区。

1.1.4. 如何使用 Kamelets?

使用 Kamelet 通常涉及两个组件: Kamelet 本身,它定义了一个可重复使用的路由片断,以及一个 Kamelet Binding,在其中引用并绑定一个或多个 Kamelets。Kamelet Binding 是一个 OpenShift 资源(KameletBinding)。

在 Kamelet Binding 资源中,您可以:

  • 将 sink 或源 Kamelet 连接到事件频道: Kafka 主题或 Knative 目的地(频道或代理)。
  • 将接收器 Kamelet 直接连接到 Camel 统一资源标识符(URI)。您还可以将源 Kamelet 连接到 Camel URI,但连接 URI 和接收器 Kamelet 是最常见的用例。
  • 将接收器和源 Kamelet 直接连接到彼此,而无需将事件频道用作中间层。
  • 在同一 Kamelet Binding 中多次引用同一 Kamelet。
  • 添加 action Kamelets,以便在从源 Kamelet 传递给 sink Kamelet 时操作数据。
  • 定义错误处理策略,以指定在发送或接收事件数据时出现问题时 Camel K 应该做什么。

在运行时,Camel K operator 使用 Kamelet Binding 生成并运行 Camel K 集成。

注: 虽然 Camel DSL 开发人员可以直接在 Camel K 集成中使用 Kamelets,但实现 Kamelets 的更简单方法是通过指定 Kamelet Binding 资源来构建高级别事件流。

1.2. 连接源和接收器

当您要连接两个或多个组件(外部应用程序或服务)时,请使用 Kamelets。每个 Kamelet 基本上是一个带有配置属性的路由模板。您需要知道您要从中获取数据的组件(源),以及您要将数据发送到哪个组件(接收器)。您可以通过在 Kamelet Binding 中添加 Kamelets 来连接源和目标组件,如图 1.1 所示。

kamelet Binding 源到 sink

图 1.1: Kamelet Binding 源到 sink

以下是在 Kamelet Binding 中使用 Kamelets 的步骤概述:

  1. 安装 Camel K operator。它包含一个 Kamelets 目录,作为 OpenShift 项目中的资源。
  2. 创建 Kamelet Binding。决定您要在 Kamelet Binding 中连接的服务或应用程序。
  3. 查看 Kamelet Catalog,以查找您要使用的源和目标组件的 Kamelets。
  4. 对于您要包含在 Kamelet Binding 中的每个 Kamelet,请确定您需要设置的配置属性。
  5. 在 Kamelet Binding 代码中,添加对每个 Kamelet 的引用并配置所需的属性。
  6. 将 Kamelet Binding 应用为 OpenShift 项目中的资源。

Camel K operator 使用 Kamelet Binding 生成并运行集成。

1.2.1. 安装 Camel K

您可以从 OperatorHub 在 OpenShift 集群上安装 Red Hat Integration - Camel K Operator。OperatorHub 可从 OpenShift Container Platform Web 控制台获得,集群管理员提供了一个界面来发现和安装 Operator。

安装 Camel K Operator 后,您可以安装 Camel K CLI 工具以便命令行访问所有 Camel K 功能。

先决条件

  • 您可以使用正确的访问级别访问 OpenShift 4.6 (或更新版本)集群、创建项目并安装 Operator 的功能,以及在本地系统上安装 CLI 工具。

    注意

    从 OpenShift OperatorHub 安装 Camel K 时,您不需要创建 pull secret。Camel K Operator 会自动重复使用 OpenShift 集群级别的身份验证,以从 registry.redhat.io 中拉取 Camel K 镜像。

  • 已安装 OpenShift CLI 工具(oc),以便您可以在命令行中与 OpenShift 集群交互。有关如何安装 OpenShift CLI 的详细信息,请参阅安装 OpenShift CLI

流程

  1. 在 OpenShift Container Platform Web 控制台中,使用具有集群管理员权限的账户登录。
  2. 创建新 OpenShift 项目:

    1. 在左侧导航菜单中,点击 Home > Project > Create Project
    2. 输入项目名称,如 my-camel-k-project,然后单击 Create
  3. 在左侧导航菜单中,点 Operators > OperatorHub
  4. Filter by keyword 文本框中,输入 Camel K,然后点 Red Hat Integration - Camel K Operator 卡。
  5. 阅读 Operator 的信息,然后单击 Install。此时会打开 Operator 安装页面。
  6. 选择以下订阅设置:

    • 更新频道 & gt; latest
    • Installation Mode > A specific namespace on the cluster > my-camel-k-project
    • Approval Strategy > Automatic

      注意

      如果您的环境需要,也可以使用 Installation mode > All namespaces on the clusterApproval Strategy > Manual 设置。

  7. Install,然后等待几分钟,直到 Camel K Operator 准备就绪。
  8. 下载并安装 Camel K CLI 工具:

    1. 在 OpenShift Web 控制台顶部的 Help 菜单(?)中选择 Command line tools
    2. 向下滚动到 kamel - Red Hat Integration - Camel K - 命令行界面 部分。
    3. 单击链接,以下载本地操作系统的二进制文件(Linux、Mac、Windows)。
    4. 在您的系统路径中解压并安装 CLI。
    5. 要验证您可以访问 Kamel K CLI,请打开命令窗口,然后键入以下内容:

      kamel --help

      此命令显示有关 Camel K CLI 命令的信息。

后续步骤

(可选) 指定 Camel K 资源限值

1.2.2. 查看 Kamelet 目录

安装 Camel K operator 时,它包含一个在 Camel K 集成中使用的 Kamelets 目录。

前提条件

您在工作命名空间中或集群范围安装了 Camel K operator,如 安装 Camel K 所述。

流程

查看使用 Camel K operator 安装的 Kamelets 列表:

  1. 在终端窗口中,登录到您的 OpenShift 集群。
  2. 查看可用的 Kamelets 列表取决于 Camel K operator 的安装方式(在特定命名空间或集群模式中):

    • 如果在 cluster-mode 中安装 Camel K operator,使用以下命令查看可用的 Kamelets:

      oc get kamelet -n openshift-operators

    • 如果 Camel K operator 安装在特定命名空间中:

      1. 打开在其中安装 Camel K operator 的项目。

        oc project <camelk-project>

        例如,如果在 my-camel-k-project 项目中安装了 Camel K operator:

        oc project my-camel-k-project

      2. 运行以下命令:

        oc get kamelets

注意

有关红帽支持的 Kamelets 列表,请参阅 Red Hat Integration 发行注记

1.2.2.1. 在 Kamelet Catalog 中添加自定义 Kamelet

如果您没有在目录中看到符合您的要求的 Kamelet,Camel DSL 开发人员可以创建自定义 Kamelet,如 Apache Camel Kamelets Developers 指南 (推荐文档)中所述。Kamelet 以 YAML 格式代码,根据惯例,它有一个 .kamelet.yaml 文件扩展名。

先决条件

  • Camel DSL 开发人员已为您提供自定义 Kamelet 文件。
  • Kamelet 名称对于安装 Camel K operator 的 OpenShift 命名空间必须是唯一的。

流程

要使自定义 Kamelet 作为 OpenShift 命名空间中的资源提供:

  1. 将 Kamelet YAML 文件(如 custom-sink.kamelet.yaml)下载到本地文件夹。
  2. 登录您的 OpenShift 集群。
  3. 在终端窗口中,打开安装 Camel K operator 的项目,如 my-camel-k-project

    oc project my-camel-k-project

  4. 运行 oc apply 命令将自定义 Kamelet 作为资源添加到命名空间中:

    oc apply -f <custom-kamelet-filename>

    例如,使用以下命令添加位于当前目录中的 custom-sink.kamelet.yaml 文件:

    oc apply -f custom-sink.kamelet.yaml

  5. 要验证 Kamelet 是否作为资源可用,请使用以下命令查看当前命名空间中的所有 Kamelets 的字母顺序列表,然后查找您的自定义 Kamelet:

    oc get kamelets

1.2.2.2. 确定 Kamelet 的配置参数

在 Kamelet Binding 中,当添加对 Kamelet 的引用时,您可以指定 Kamelet 的名称并配置 Kamelet 参数。

前提条件

  • 您在工作命名空间中或集群范围安装了 Camel K operator。

流程

要确定 Kamelet 的名称和参数:

  1. 在终端窗口中,登录到您的 OpenShift 集群。
  2. 打开 Kamelet 的 YAML 文件:

    oc describe kamelets/<kamelet-name>

    例如,要查看 ftp-source Kamelet 的代码,如果在当前命名空间中安装 Camel K operator,请使用以下命令:

    oc describe kamelets/ftp-source

    如果在 cluster-mode 中安装 Camel K operator,使用以下命令:

    oc describe -n openshift-operators kamelets/ftp-source

  3. 在 YAML 文件中,向下滚动到 spec.definition 部分(以 JSON-schema 格式编写)以查看 Kamelet 的属性列表。在部分末尾,所需的字段列出了在引用 Kamelet 时必须配置的属性。

    例如,以下代码是 ftp-source Kamelet 的 spec.definition 部分的摘录。本节详细介绍了所有 Kamelet 的配置属性。这个 Kamelet 的必要属性是 connectionHost,connectionPort,username,password, 和 directoryName

    Copy to Clipboard Toggle word wrap
    spec:
      definition:
        title: "FTP Source"
        description: |-
          Receive data from an FTP Server.
        required:
          - connectionHost
          - connectionPort
          - username
          - password
          - directoryName
        type: object
        properties:
          connectionHost:
            title: Connection Host
            description: Hostname of the FTP server
            type: string
          connectionPort:
            title: Connection Port
            description: Port of the FTP server
            type: string
            default: 21
          username:
            title: Username
            description: The username to access the FTP server
            type: string
          password:
            title: Password
            description: The password to access the FTP server
            type: string
            format: password
            x-descriptors:
            - urn:alm:descriptor:com.tectonic.ui:password
          directoryName:
            title: Directory Name
            description: The starting directory
            type: string
          passiveMode:
            title: Passive Mode
            description: Sets passive mode connection
            type: boolean
            default: false
            x-descriptors:
            - 'urn:alm:descriptor:com.tectonic.ui:checkbox'
          recursive:
            title: Recursive
            description: If a directory, will look for files in all the sub-directories as well.
            type: boolean
            default: false
            x-descriptors:
            - 'urn:alm:descriptor:com.tectonic.ui:checkbox'
          idempotent:
            title: Idempotency
            description: Skip already processed files.
            type: boolean
            default: true
            x-descriptors:
            - 'urn:alm:descriptor:com.tectonic.ui:checkbox'

1.2.3. 在 Kamelet Binding 中连接源和目标(sink)组件

在 Kamelet Binding 中,您可以连接源和目标 sink 组件。

此流程中的示例使用以下 Kamelets,如图 1.2 所示:

  • 示例源 Kamelet 称为 coffee-source。这个简单的 Kamelet 从网站目录检索有关 coffee 类型的随机生成的数据。它有一个参数(句点 - 整数值 ),用于决定检索 coffee 数据的频率(以秒为单位)。不需要该参数,因为有一个默认值(1000 秒)。
  • sink Kamelet 示例名为 log-sink。它检索数据并将其输出到日志文件。log-sink Kamelet 在 Kamelet Catalog 中提供。
Kamelet Binding 示例

图 1.2: Kamelet Binding 示例

先决条件

  • 您知道如何创建和编辑 Camel K 集成。
  • Red Hat Integration - Camel K operator 安装在 OpenShift 命名空间或集群上,您已下载了 Red Hat Integration Camel K CLI 工具,如安装 Camel K 所述。
  • 您知道您要添加到 Camel K 集成及其所需实例参数的 Kamelets。
  • 您要使用的 Kamelets 位于 Kamelet Catalog 中。

    在本例中,log-sink Kamelet 在 Kamelet Catalog 中提供。如果要在本示例中使用 source Kamelet,将 coffee-source 代码 复制并保持到一个名为 coffee-source.kamelet.yaml 的本地文件中,然后运行以下命令将其添加到 Kamelet 目录中:

    oc apply -f coffee-source.kamelet.yaml

流程

  1. 登录您的 OpenShift 集群。
  2. 打开安装 Camel K operator 的工作项目。如果在 cluster-mode 中安装 Camel K operator,则集群上的任何项目都可以使用它。

    例如,要打开名为 my-camel-k-project 的现有项目:

    oc project my-camel-k-project

  3. 使用以下选项之一创建新的 Kamelet Binding:

    • 使用 kamel bind 命令创建并运行 Kamelet Binding (此选项对命令行定义而言是一致的 Kamelet Bindings 非常有用)
    • 创建一个 YAML 文件来定义 Kamelet Binding,然后使用 oc apply 命令运行它(在 Kamelet Binding 配置更为复杂时此选项很有用)。

      使用 kamel bind 命令创建一个新的 Kamelet Binding

      使用以下 kamel 绑定 语法指定 source 和 sink Kamelets 以及任何配置参数:

      Copy to Clipboard Toggle word wrap
      kamel bind <kamelet-source> -p “<property>=<property-value>” <kamelet-sink> -p “<property>=<property-value>”

      例如:

      Copy to Clipboard Toggle word wrap
      kamel bind coffee-source -p “source.period=5000” log-sink -p "sink.showStreams=true"

      Camel K operator 生成 KameletBinding 资源并运行对应的 Camel K 集成。

      使用 YAML 文件创建新的 Kamelet Binding

      1. 在您选择的编辑器中,使用以下结构创建一个 YAML 文件:

        Copy to Clipboard Toggle word wrap
        apiVersion: camel.apache.org/v1alpha1
        kind: KameletBinding
        metadata:
          name:
        spec:
          source:
          sink:
      2. 为 Kamelet Binding 添加名称。

        在本例中,名称为 coffee-to-log,因为绑定将 coffee-source Kamelet 连接到 log-sink Kamelet。

        Copy to Clipboard Toggle word wrap
        apiVersion: camel.apache.org/v1alpha1
        kind: KameletBinding
        metadata:
          name: coffee-to-log
        spec:
          source:
          sink:
      3. 指定源 Kamelet (如 coffee-source)并为 Kamelet 配置任何参数。

        注: 在本例中,该参数在 Kamelet Binding 的 YAML 文件中定义。另外,您还可以在属性文件、ConfigMap 或 Secret 中配置 Kamelet 的参数,如 配置 Kamelet 实例参数 中所述。

        Copy to Clipboard Toggle word wrap
        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. 指定 sink Kamelet (如 log-sink),并为 Kamelet 配置任何参数。使用 log-sink Kamelet 的可选 showStreams 参数来显示消息正文。

        Copy to Clipboard Toggle word wrap
        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. 保存 YAML 文件(例如,coffee-to-log.yaml)。
      6. KameletBinding 作为资源添加到 OpenShift 命名空间中:

        oc apply -f <kamelet-binding>.yaml

        例如:

        oc apply -f coffee-to-log.yaml

        Camel K operator 使用 KameletBinding 资源生成并运行 Camel K 集成。

  4. 查看 Kamelet Binding 的状态:

    oc get kameletbindings

  5. 查看对应集成的状态: oc get integrations
  6. 查看输出:

    • 要从命令行查看日志,请打开终端窗口,然后输入以下命令:

      kamel log <integration-name>

      例如,如果集成名称是 coffee-to-log,使用以下命令:

      kamel log coffee-to-log

    • 从 OpenShift Web 控制台查看日志:

      1. 选择 Workloads > Pods
      2. 单击 Camel K 集成 pod 的名称,然后单击 Logs

        您应该看到类似以下示例的事件列表:

        Copy to Clipboard Toggle word wrap
        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. 要停止集成,请删除 Kamelet Binding:

    oc delete kameletbindings/<kameletbinding-name>

    例如:

    oc delete kameletbindings/coffee-to-log

后续步骤

(可选):

1.2.4. 配置 Kamelet 实例参数

当您引用 Kamelet 时,您可以有以下选项来定义 Kamelet 的实例参数:

  • 直接在指定 Kamelet URI 的 Kamelet Binding 中。在以下示例中,Pretgram BotFather. 提供的 bot 授权令牌为 123456

    from("kamelet:telegram-source?authorizationToken=123456")

  • 全局配置 Kamelet 属性(因此您不必使用以下格式在 URI 中提供值:

    "camel.kamelet.<kamelet-name>.<property-name>=<value>”

    如使用 Camel K 开发和管理集成 中的 配置 Camel K 集成 一章中所述,您可以通过以下方法配置 Kamelet 参数:

    • 将它们定义为属性
    • 在属性文件中定义它们
    • 在 OpenShift ConfigMap 或 Secret 中定义它们

1.2.5. 连接到事件频道

Kamelets 的最常见用例是使用 Kamelet Binding 将它们连接到事件频道: Kafka 主题或 Knative 目的地(频道或代理)。这样做的优点是数据源和接收器相互独立且"不知道"。这种分离功能支持单独开发并管理您的业务场景中的组件。如果您有多个数据接收器和源作为您的业务场景的一部分,则分离各种组件更为重要。例如,如果需要关闭事件 sink,则事件源不会受到影响。另外,如果其他 sink 使用相同的源,它们不受影响。

图 1.3 演示了将源和接收器 Kamelets 连接到事件频道的流程。

将源和目标 sink Kamelets 连接到事件频道

图 1.3:将源和接收器 Kamelets 连接到事件频道

如果您使用 Apache Kafka 流处理框架,以了解有关如何连接到 Kafka 主题的详情,请参阅使用 Kamelets 连接到 Kafka

如果您使用 Knative 无服务器框架,了解如何连接到 Knative 目的地(频道或代理),请参阅使用 Kamelets 连接到 Knative

1.2.6. 连接到显式 Camel URI

您可以创建一个 Kamelet Binding,其中 Kamelet 将事件发送到或从显式 Camel URI 接收事件。通常,您可以将源 Kamelet 绑定到可以接收事件的 URI (即,您可以将 URI 指定为 Kamelet Binding 中的 sink)。接收事件的 Camel URI 示例是 HTTP 或 HTTPS 端点。

也可以(但不常见)指定 URI 作为 Kamelet Binding 中的源。发送事件的 Camel URI 示例包括计时器、邮件或 FTP 端点。

要将 Kamelet 连接到 Camel URI,请按照 Kamelet Binding 中的 Connecting source 和 sink 组件和 sink.uri 字段中的步骤,而不是 Kamelet,请指定显式 Camel URI。

在以下示例中,接收器的 URI 是一个模糊的 URI (https://mycompany.com/event-service):

Copy to Clipboard Toggle word wrap
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
  name: coffee-to-event-service
spec:
  source:
    ref:
      kind: Kamelet
      apiVersion: camel.apache.org/v1alpha1
      name: coffee-source
    properties:
      period: 5000
  sink:
    uri: https://mycompany.com/event-service

1.3. 将操作应用到连接中的数据

如果要对 Kamelet 和事件频道之间的数据执行操作,请在 Kamelet Binding 中使用 action Kamelets 作为中间步骤。例如,您可以使用 Kamelet 操作来序列化或反序列化数据,过滤数据,或者插入字段或消息标头。

操作操作(如过滤或添加字段)只能使用 JSON 数据(即,当 Content-Type 标头设置为 application/json时)。如果事件数据使用 JSON 以外的格式(如 Avro 或 Protocol Buffers),您必须在操作操作和反序列化步骤(例如,引用 protobuf-deserialize-actionavro-deserialize-action Kamelet)前,通过添加反序列化步骤(例如,引用 protobuf- serialize-action Kamelet)来转换数据的格式。有关在连接中转换数据格式的更多信息,请参阅数据转换 Kamelets

操作 Kamelets 包括:

1.3.1. 在 Kamelet Binding 中添加操作

要实现操作 Kamelet,在 Kamelet Binding 文件的 spec 部分,在 source 和 sink 部分添加一个 steps 部分。

先决条件

  • 您已创建了 Kamelet Binding,如 Kamelet Binding 中的 Connecting source 和 sink 组件 所述。
  • 您知道您要添加到 Kamelet Binding 的操作 Kamelet 以及 Kamelet 操作所需的参数。

    对于此过程中的示例,predicate-filter-action Kamelet 的参数 是一个字符串 类型 expression,它提供了一个 JSON 路径表达式,过滤 coffee 数据来仅记录具有"deep"截断器的数据。请注意,predicate-filter-action Kamelet 要求您在 Kamelet Binding 中设置 Builder trait 配置属性。

    这个示例还包括反序列化和序列化操作,在本例中是可选的,因为事件数据格式为 JSON。

流程

  1. 在编辑器中打开 KameletBinding 文件。

    例如,以下是 coffee-to-log.yaml 文件的内容:

    Copy to Clipboard Toggle word wrap
    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. source 部分添加一个 integration 部分,并提供以下 Builder 特征配置属性(如 predicate-filter-action Kamelet 要求):

    Copy to Clipboard Toggle word wrap
    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. 添加 steps 部分,在 sourcesink 部分定义操作 Kamelet。例如:

    Copy to Clipboard Toggle word wrap
    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. 保存您的更改。
  5. 使用 oc apply 命令更新 KameletBinding 资源,例如:

    oc apply -f coffee-to-log.yaml

    Camel K operator 会重新生成并运行基于更新的 KameletBinding 资源生成的 CamelK 集成。

  6. 查看 Kamelet Binding 的状态:

    oc get kameletbindings

  7. 查看其对应集成的状态:

    oc get integrations

  8. 查看集成的日志文件输出:

    kamel logs <integration-name>

    例如,如果集成名称是 coffee-to-log

    kamel logs coffee-to-log

  9. 要停止集成,请删除 Kamelet Binding:

    oc delete kameletbindings/<kameletbinding-name>

    例如:

    oc delete kameletbindings/coffee-to-log

1.3.2. 操作 kamelets

1.3.2.1. 数据过滤 Kamelets

您可以过滤源和接收器组件之间传递的数据,例如防止泄漏敏感数据或避免生成不必要的网络费用。

您可以根据以下条件过滤数据:

  • Kafka 主题名称 - 通过配置主题名称 Matches Filter Action Kamelet (topic-name-matches-filter-action),使用与给定 Java 正则表达式匹配的 Kafka 主题过滤事件。如需更多信息,请参阅 过滤特定 Kafka 主题的事件数据
  • header key - 通过配置 Header Filter Action Kamelet (has-header-filter-action)来过滤具有给定消息标头的事件。
  • null value - 通过配置 Tombstone Filter Action Kamelet (is-tombstone-filter-action)来过滤 tombstone 事件(带有 null 有效负载)。
  • predicate - 通过配置 Predicate Filter Action Kamelet (predicate-filter-action)来根据给定的 JSON 路径表达式过滤事件。predicate-filter-action Kamelet 要求您在 Kamelet Binding 中设置以下 Builder 特征 配置属性:

    Copy to Clipboard Toggle word wrap
    spec:
      integration:
        traits:
          builder:
            configuration:
              properties:
               - "quarkus.arc.unremovable-types=com.fasterxml.
                    jackson.databind.ObjectMapper"
注意

数据过滤 Kamelets 使用 JSON 数据(即,当 Content-Type 标头设置为 application/json 时)开箱即用。如果事件数据使用 JSON 以外的格式,您必须在操作操作和序列化步骤(如 protobuf-serialize-action 或 avro-deserialize-action )前添加反序列化步骤(如 protobuf-serialize-actionavro-deserialize-action)来转换数据的格式。有关在连接中转换数据格式的更多信息,请参阅数据转换 Kamelets

1.3.2.2. 数据转换 Kamelets

使用以下数据转换 Kamelets,您可以序列化并反序列化源和 sink 组件之间传递的数据格式。数据转换适用于事件数据的有效负载(而不是密钥或标头)。

  • Avro - 为 Apache Hadoop 提供数据序列化和数据交换服务的开源项目。

    • avro Deserialize Action Kamelet (avro-deserialize-action)
    • avro Serialize Action Kamelet (avro-serialize-action)
  • 协议缓冲 - Google 在内部使用它的高性能、紧凑的二进制线格式,以便它们与其内部网络服务通信。

    • protobuf Deserialize Action Kamelet (protobuf-deserialize-action)
    • protobuf Serialize Action Kamelet (protobuf-serialize-action)
  • JSON (JavaScript Object Notation)- 基于 JavaScript 编程语言子集的数据中断格式。JSON 是一种完全独立于语言的文本格式。

    • JSON Deserialize Action Kamelet (json-deserialize-action)
    • JSON Serialize Action Kamelet (json-serialize-action)
注意

您必须在 Avro 和 Protobuf serialize/deserialize Kamelets 中指定模式(作为单行,使用 JSON 格式)。对于 JSON serialize/deserialize Kamelets,您不需要这样做。

1.3.2.3. 数据转换 Kamelets

使用以下数据转换 Kamelets,您可以对源和目标组件之间传递的数据执行简单的操作:

  • extract Field - 使用 extract-field-action Kamelet 从数据正文中拉取字段,并将数据的整个正文替换为提取字段。
  • Hoist 字段 - 使用 hoist-field-action Kamelet 将数据正文嵌套到一个字段中。
  • insert Header - 使用 insert-header-action Kamelet 使用静态数据或记录元数据添加标头字段。
  • insert Field - 使用 insert-field-action Kamelet 使用静态数据或记录元数据来添加字段值。
  • mask 字段 - 使用 mask-field-action Kamelet 将字段值替换为字段类型 (如 0 或空字符串)的有效 null 值,或者替换为给定的替换(替换必须是非空字符串或数字值)。

    例如,如果要从关系数据库捕获到 Kafka 的数据,且数据包括受保护的(PCI / PII)信息,您必须在您的 Kafka 集群尚未认证时屏蔽受保护的信息。

  • 替换 Field - 使用 replace-field-action Kamelet 来过滤或重命名字段。您可以指定要重命名、禁用(不包括)或启用(包括)的字段。
  • 值 To Key - (用于 Kafka)使用 value-to-key-action Kamelet 将记录键替换为从有效负载中字段子集中获取的新键。您可以将 event 键设置为在将数据写入 Kafka 前基于事件信息的值。例如,当从数据库表中读取记录时,您可以根据客户 ID 在 Kafka 中对记录进行分区。

1.4. 处理连接中的错误

要指定如果正在运行的集成在发送或接收事件数据时遇到失败,您可以选择性地在 Kamelet Binding 中添加以下错误处理策略之一:

1.4.1. 在 Kamelet Binding 中添加错误处理程序策略

要在源和目标连接之间发送或接收事件数据时处理错误,请在 Kamelet Binding 中添加错误处理程序策略。

先决条件

  • 您知道您要使用的错误处理程序策略类型。
  • 您有一个现有的 KameletBinding YAML 文件。

流程

在 Kamelet Binding 中实施错误处理:

  1. 在编辑器中打开 KameletBinding YAML 文件。
  2. sink 定义后,在 spec 部分添加一个 error handler 部分:

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: example-kamelet-binding
    spec:
      source:
       ...
      sink:
       ...
      errorHandler: ...

    例如,在 coffee-to-log Kamelet Binding 中,通过添加日志错误处理程序来指定错误发送到日志文件的最大次数:

    Copy to Clipboard Toggle word wrap
    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. 保存您的文件。

1.4.2. 错误处理程序

1.4.2.1. 没有错误处理程序

如果要忽略集成中发生的任何失败,则无法在 Kamelet Binding 中包含 errorHandler 部分,或者将其设置为 none,如下例所示:

Copy to Clipboard Toggle word wrap
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
  name: my-kamelet-binding
spec:
  source:
...
  sink:
...
  errorHandler:
    none:
1.4.2.2. 日志错误处理程序

处理任何失败的默认行为是将日志消息发送到标准输出。另外,您可以使用日志错误处理程序指定其他行为,如重新发送或延迟策略,如下例所示:

Copy to Clipboard Toggle word wrap
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
  name: my-kamelet-binding
spec:
  source:
...
  sink:
...
  errorHandler:
    log:
      parameters:
        maximumRedeliveries: 3
        redeliveryDelay: 2000
1.4.2.3. 死信频道错误处理程序

Dead Letter Channel 允许您将任何失败的事件重定向到可处理失败的事件的任何其他组件(如第三方 URI、队列或其他 Kamelet),如以下示例所示:

Copy to Clipboard Toggle word wrap
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
  name: my-kamelet-binding
spec:
  source:
  ...
  sink:
  ...
  errorHandler:
    dead-letter-channel:
      endpoint:
        ref: 
1

          kind: Kamelet
          apiVersion: camel.apache.org/v1alpha1
          name: error-handler
        properties: 
2

          message: "ERROR!"
          ...
      parameters: 
3

        maximumRedeliveries: 1
  1. 对于 端点,您可以使用 refuri。根据 kind, apiVersionname 的值的 Camel K operator interprets ref。您可以使用任何 Kamelet、Kafka 主题频道或 Knative 目的地。
  2. 属于端点的属性(本例中为 Kamelet),名为 error-handler
  3. 属于 dead-letter-channel 错误处理程序类型 的参数
1.4.2.4. Bean 错误处理程序

使用 Bean 错误处理程序,您可以通过提供处理错误的自定义 bean 来扩展 Error Handler 的功能。对于 类型,请指定 ErrorHandlerBuilder 的完全限定名称。对于 属性,请配置您在 类型 中指定的 ErrorHandlerBuilder 所期望的属性。

Copy to Clipboard Toggle word wrap
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
  name: my-kamelet-binding
spec:
  source:
...
  sink:
...
  errorHandler:
    bean:
      type: "org.apache.camel.builder.DeadLetterChannelBuilder"
      properties:
        deadLetterUri: log:error
1.4.2.5. ref 错误处理程序

使用 Ref 错误处理程序,您可以使用在运行时 Camel registry 中预期可用的任何 bean。在以下示例中,my-custom-builder 是要查看运行时的 bean 的名称。

Copy to Clipboard Toggle word wrap
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
  name: my-kamelet-binding
spec:
  source:
   ...
  sink:
   ...
  errorHandler:
    ref: my-custom-builder

第 2 章 使用 Kamelets 连接到 Kafka

Apache Kafka 是一个开源、分布式、发布订阅消息传递系统,用于创建容错、实时数据源。Kafka 为大量用户(外部连接)快速存储和复制数据。

Kafka 可帮助您构建处理流事件的解决方案。分布式、事件驱动的架构需要一个"后端",用于捕获、沟通和帮助进程事件。Kafka 可以充当将数据源和事件连接到应用程序的通信后端。

您可以使用 Kamelets 来配置 Kafka 和外部资源之间的通信。通过kamelets,您可以配置数据如何在 Kafka 流处理框架中将数据从一个端点迁移到另一个端点,而无需编写代码。kamelets 是通过指定参数值来配置的路由模板。

例如,Kafka 以二进制形式存储数据。您可以使用 Kamelets 来序列化和反序列化要发送到的数据,并从外部连接接收数据。使用 Kamelets,您可以验证架构并对数据进行更改,如向其中添加、过滤或屏蔽它。kamelets 也可以处理和处理错误。

2.1. 使用 Kamelets 连接到 Kafka 概述

如果使用 Apache Kafka 流处理框架,您可以使用 Kamelets 将服务和应用程序连接到 Kafka 主题。Kamelet Catalog 提供以下 Kamelets,专门用于连接 Kafka 主题:

  • kafka-sink - 将事件从数据制作者移到 Kafka 主题。在 Kamelet Binding 中,将 kafka-sink Kamelet 指定为接收器。
  • kafka-source - 将事件从 Kafka 主题移到数据消费者。在 Kamelet Binding 中,指定 kafka-source Kamelet 作为源。

图 2.1 演示了将源和接收器 Kamelets 连接到 Kafka 主题的流程。

kafkafow generic

图 2.1:使用 Kamelets 和 Kafka 主题的数据流

以下是使用 Kamelets 和 Kamelet Bindings 将应用程序和服务连接到 Kafka 主题的基本步骤的概述:

  1. 设置 Kafka:

    1. 安装所需的 OpenShift 操作器。

      • 对于 Apache Kafka 的 OpenShift Streams,请安装 Camel K operator、Camel K CLI 和 Red Hat OpenShift Application Services (RHOAS) CLI。
      • 对于 AMQ 流,安装 Camel K 和 AMQ 流运算符和 Camel K CLI。
    2. 创建 Kafka 实例。Kafka 实例作为消息代理运行。代理包含主题并编配存储和传递信息。
    3. 创建 Kafka 主题。主题提供数据存储的目的地。
    4. 获取 Kafka 身份验证凭据。
  2. 决定您要连接到 Kafka 主题的服务或应用程序。
  3. 查看 Kamelet Catalog,以查找您要添加到集成的源和目标组件的 Kamelets。另外,确定您要使用的每个 Kamelet 所需的配置参数。
  4. 创建 Kamelet Bindings :

    • 创建一个 Kamelet Binding,它将数据源(生成数据的组件)连接到 Kafka 主题(通过使用 kafka-sink Kamelet)。
    • 创建一个 Kamelet Binding,它将 kafka 主题(使用 kafka-source Kamelet)连接到数据接收器(消耗数据的组件)。
  5. 另外,还可通过在 Kamelet Binding 中添加一个或多个操作 Kamelets 来操作 Kafka 主题和接收器之间传递的数据。
  6. (可选)定义如何处理 Kamelet Binding 中的错误。
  7. 将 Kamelet Bindings 作为资源应用到项目。

    Camel K operator 为每个 Kamelet Binding 生成单独的 Camel K 集成。

2.2. 设置 Kafka

设置 Kafka 涉及安装所需的 OpenShift operator、创建 Kafka 实例并创建 Kafka 主题。

使用以下红帽产品之一设置 Kafka:

  • Red Hat Advanced Message Queuing (AMQ)流 - 一个自我管理的 Apache Kafka 产品。AMQ Streams 基于开源 Strimzi,它包含在 Red Hat Integration 中。AMQ Streams 是一个基于 Apache Kafka 的分布式且可扩展的流平台,其中包括发布/订阅消息传递代理。Kafka Connect 提供了一个框架,用于将基于 Kafka 的系统与外部系统集成。使用 Kafka Connect,您可以配置源和接收器连接器,将来自外部系统的数据流传输到 Kafka 代理。
  • Red Hat OpenShift Streams for Apache Kafka - 受管云服务,简化了运行 Apache Kafka 的过程。它为构建、部署和扩展新的云原生应用程序或现代化现有系统提供了简化的开发人员体验。

2.2.1. 使用 AMQ 流设置 Kafka

AMQ Streams 简化了在 OpenShift 集群中运行 Apache Kafka 的过程。

2.2.1.1. 为 AMQ Streams 准备 OpenShift 集群

要使用 Camel K 或 Kamelets 和 Red Hat AMQ Streams,您必须安装以下 operator 和工具:

  • Red Hat Integration - AMQ Streams operator - 管理 Openshift Cluster 和 AMQ Streams for Apache Kafka 实例之间的通信。
  • Red Hat Integration - Camel K operator - 安装和管理 Camel K - 一个轻量级集成框架,它在 OpenShift 的云中原生运行。
  • Camel K CLI 工具 - 允许您访问所有 Camel K 功能。

先决条件

  • 熟悉 Apache Kafka 概念。
  • 您可以使用正确的访问级别访问 OpenShift 4.6 (或更新版本)集群,创建项目并安装 Operator,以及在本地系统上安装 OpenShift 和 Camel K CLI 的功能。
  • 已安装 OpenShift CLI 工具(oc),以便您可以在命令行中与 OpenShift 集群交互。

流程

使用 AMQ Streams 设置 Kafka:

  1. 登录 OpenShift 集群的 Web 控制台。
  2. 创建或打开您要在其中创建集成的项目,如 my-camel-k-kafka
  3. 安装 Camel K operator 和 Camel K CLI,如 安装 Camel K 所述。
  4. 安装 AMQ 流 Operator:

    1. 在任何项目中,选择 Operators > OperatorHub
    2. Filter by Keyword 字段中,键入 AMQ Streams
    3. Red Hat Integration - AMQ Streams 卡,然后点 Install

      此时会打开 Install Operator 页面。

    4. 接受默认值,然后点 Install
  5. 选择 Operators > Installed Operators 来验证是否安装了 Camel K 和 AMQ Streams operator。
2.2.1.2. 使用 AMQ Streams 设置 Kafka 主题

Kafka 主题为 Kafka 实例中数据存储提供目的地。您必须将数据发送到 Kafka 主题,您必须先设置 Kafka 主题。

先决条件

  • 您可以访问 OpenShift 集群。
  • 已安装 Red Hat Integration - Camel KRed Hat Integration - AMQ Streams operator,如 准备 OpenShift 集群 中所述。
  • 已安装 OpenShift CLI (oc)和 Camel K CLI (kamel)。

流程

使用 AMQ Streams 设置 Kafka 主题:

  1. 登录 OpenShift 集群的 Web 控制台。
  2. 选择 Projects,然后点击安装 Red Hat Integration - AMQ Streams operator 的项目。例如,单击 my-camel-k-kafka 项目。
  3. 选择 Operators > Installed Operators,然后点 Red Hat Integration - AMQ Streams
  4. 创建 Kafka 集群:

    1. Kafka 下,点 Create instance
    2. 为集群输入一个名称,如 kafka-test
    3. 接受其他默认值,然后单击 Create

      创建 Kafka 实例的过程可能需要几分钟时间才能完成。

      当状态就绪时,请继续下一步。

  5. 创建 Kafka 主题:

    1. 选择 Operators > Installed Operators,然后点 Red Hat Integration - AMQ Streams
    2. Kafka Topic 下,点 Create Kafka Topic
    3. 为主题输入名称,如 test-topic
    4. 接受其他默认值,然后单击 Create

2.2.2. 使用 OpenShift 流设置 Kafka

Red Hat OpenShift Streams for Apache Kafka 是一个受管云服务,简化了运行 Apache Kafka 的过程。

要将 OpenShift Streams 用于 Apache Kafka,您必须登录到您的红帽帐户。

2.2.2.1. 为 OpenShift Streams 准备 OpenShift 集群

要使用 Red Hat OpenShift Streams for Apache Kafka 受管云服务,您必须安装以下 operator 和工具:

  • OpenShift Application Services (RHOAS) CLI - 允许您从终端管理应用程序服务。
  • Red Hat Integration - Camel K operator 安装和管理 Camel K,它是一个轻量级集成框架,它在 OpenShift 的云中原生运行。
  • Camel K CLI 工具 - 允许您访问所有 Camel K 功能。

先决条件

  • 熟悉 Apache Kafka 概念。
  • 您可以使用正确的访问级别访问 OpenShift 4.6 (或更新版本)集群,创建项目并安装 Operator,以及在本地系统上安装 OpenShift 和 Apache Camel K CLI 的功能。
  • 已安装 OpenShift CLI 工具(oc),以便您可以在命令行中与 OpenShift 集群交互。

流程

  1. 使用集群管理员帐户登录 OpenShift Web 控制台。
  2. 为您的 Camel K 或 Kamelets 应用程序创建 OpenShift 项目。

    1. 选择 Home > Projects
    2. 点击 Create Project
    3. 输入项目的名称,如 my-camel-k-kafka,然后单击 Create
  3. 下载并安装 RHOAS CLI,如 开始使用 rhoas CLI 所述。
  4. 安装 Camel K operator 和 Camel K CLI,如 安装 Camel K 所述。
  5. 要验证是否安装了 Red Hat Integration - Camel K operator,请点击 Operators > Installed Operators
2.2.2.2. 使用 RHOAS 设置 Kafka 主题

Kafka 针对 主题 组织消息。每个主题都有一个名称。应用发送消息到主题并从主题检索消息。Kafka 主题为 Kafka 实例中数据存储提供目的地。您必须将数据发送到 Kafka 主题,您必须先设置 Kafka 主题。

先决条件

  • 您可以使用正确的访问级别访问 OpenShift 集群,创建项目并安装操作器,以及在本地系统上安装 OpenShift 和 Camel K CLI 的功能。
  • 已安装 OpenShift CLI (oc)、Camel K CLI (kamel)和 RHOAS CLI (rhoas)工具,如 准备 OpenShift 集群 中所述。
  • 已安装 Red Hat Integration - Camel K operator,如 准备 OpenShift 集群 中所述。
  • 已登陆到 Red Hat Cloud 站点

流程

使用 Red Hat OpenShift Streams for Apache Kafka 设置 Kafka 主题:

  1. 在命令行中登录到您的 OpenShift 集群。
  2. 打开项目,例如:

    oc project my-camel-k-kafka

  3. 验证在您的项目中是否安装了 Camel K operator:

    oc get csv

    结果列出了 Red Hat Camel K operator,并表示它处于 Succeeded 阶段。

  4. 准备 Kafka 实例并将其连接到 RHOAS:

    1. 使用以下命令登录到 RHOAS CLI:

      rhoas login

    2. 创建一个 kafka 实例,如 kafka-test

      rhoAS kafka create kafka-test

      创建 Kafka 实例的过程可能需要几分钟时间才能完成。

  5. 检查 Kafka 实例的状态:

    RHOAS 状态

    您还可以在 web 控制台中查看状态:

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

    当状态 就绪时,请继续下一步。

  6. 创建新的 Kafka 主题:

    rhoas kafka topic create --name test-topic

  7. 将 Kafka 实例(集群)与 Openshift Application Services 实例连接:

    RHOAS 集群连接

  8. 按照获取凭据令牌的脚本说明进行操作。

    您应该看到类似如下的输出:

    Copy to Clipboard Toggle word wrap
    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.

后续步骤

2.2.2.3. 获取 Kafka 凭证

要将应用程序或服务连接到 Kafka 实例,您必须首先获取以下 Kafka 凭证:

  • 获取 bootstrap URL。
  • 创建带有凭证(用户名和密码)的服务帐户。

对于 OpenShift Streams,身份验证协议为 SASL_SSL。

前提条件

  • 您已创建了 Kafka 实例,它的状态为 ready。
  • 您已创建了 Kafka 主题。

流程

  1. 获取 Kafka Broker URL (Bootstrap URL):

    RHOAS 状态

    这个命令返回类似如下的输出:

    Copy to Clipboard Toggle word wrap
      Kafka
      ---------------------------------------------------------------
      ID:                     1ptdfZRHmLKwqW6A3YKM2MawgDh
      Name:                   my-kafka
      Status:                 ready
      Bootstrap URL:        my-kafka--ptdfzrhmlkwqw-a-ykm-mawgdh.kafka.devshift.org:443
  2. 要获取用户名和密码,请使用以下语法创建服务帐户:

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

    注意

    在创建服务帐户时,您可以选择保存凭证的文件格式和位置。如需更多信息,请输入 rhoas service-account create --help

    例如:

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

    服务帐户已创建并保存到 JSON 文件中。

  3. 要验证服务帐户凭证,请查看 credentials.json 文件:

    cat credentials.json

    这个命令返回类似如下的输出:

    Copy to Clipboard Toggle word wrap
    {"clientID":"srvc-acct-eb575691-b94a-41f1-ab97-50ade0cd1094", "password":"facf3df1-3c8d-4253-aa87-8c95ca5e1225"}
  4. 授予向 Kakfa 主题发送和接收消息的权限。使用以下命令,其中 clientIDcredentials.json 文件中提供的值(第 3 步)。

    Copy to Clipboard Toggle word wrap
    rhoas kafka acl grant-access --producer --consumer --service-account $CLIENT_ID --topic test-topic --group all

    例如:

    Copy to Clipboard Toggle word wrap
    rhoas kafka acl grant-access --producer --consumer --service-account srvc-acct-eb575691-b94a-41f1-ab97-50ade0cd1094 --topic test-topic --group all

2.3. 将数据源连接到 Kamelet Binding 中的 Kafka 主题

要将数据源连接到 Kafka 主题,您可以创建一个 Kamelet Binding,如图 2.2 所示

Connecting a data source to a Kafka topic 图 2.2 将数据源连接到 Kafka 主题

先决条件

  • 您知道您要将事件发送到的 Kafka 主题的名称。

    此流程中的示例使用 test-topic 来接收事件。

  • 您知道 Kafka 实例的以下参数值:

    • bootstrapServers - Kafka Broker URL 的逗号分隔列表。
    • Password - 在 Kafka 中进行身份验证的密码。对于 OpenShift Streams,这是 credentials.json 文件中的 密码。对于 AMQ Streams 上的未经身份验证的 kafka 实例,您可以指定任何非空字符串。
    • User - 在 Kafka 中进行身份验证的用户名。对于 OpenShift Streams,这是 credentials.json 文件中的 clientID。对于 AMQ Streams 上的未经身份验证的 kafka 实例,您可以指定任何非空字符串。

      有关如何使用 OpenShift Streams 时如何获取这些值的详情,请参考包含 Kafka 凭证

    • SecurityProtocol - 您知道与 Kafka 代理通信的安全协议。对于 OpenShift Streams 上的 Kafka 集群,它是 SASL_SSL (默认)。对于 AMQ 流上的 Kafka 集群,它是 PLAINTEXT
  • 您知道您要添加到 Camel K 集成和所需的实例参数的 Kamelets。

    此流程的 Kamelets 示例如下:

    • coffee-source Kamelet - 有一个可选参数 period,用于指定发送每个事件的频率。您可以将代码从 Example source Kamelet 复制到名为 coffee-source.kamelet.yaml 的文件,然后运行以下命令将其作为资源添加到命名空间中:

      oc apply -f coffee-source.kamelet.yaml

    • Kamelet Catalog 提供的 kafka-sink Kamelet。您可以使用 kafka-sink Kamelet,因为 Kafka 主题在这个绑定中接收数据(即数据消费者)。

流程

要将数据源连接到 Kafka 主题,请创建一个 Kamelet Binding:

  1. 在您选择的编辑器中,使用以下基本结构创建一个 YAML 文件:

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name:
    spec:
      source:
      sink:
  2. 为 Kamelet Binding 添加名称。在本例中,名称为 coffees-to-kafka,因为绑定将 coffee-source Kamelet 连接到 kafka-sink Kamelet。

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: coffees-to-kafka
    spec:
      source:
      sink:
  3. 对于 Kamelet Binding 的源,请指定数据源 Kamelet (例如,coffee-source Kamelet 会生成包含 coffee 的数据)的事件,并为 Kamelet 配置任何参数。

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: coffees-to-kafka
    spec:
      source:
        ref:
          kind: Kamelet
          apiVersion: camel.apache.org/v1alpha1
          name: coffee-source
        properties:
          period: 5000
      sink:
  4. 对于 Kamelet Binding 的 sink,指定 kafka-sink Kamelet 及其所需属性。

    例如,当 Kafka 集群位于 OpenShift Streams 中时:

    • 对于 user 属性,指定 clientID,例如: srvc-acct-eb575691-b94a-41f1-ab97-50ade0cd1094
    • 对于 password 属性,指定 密码,例如: facf3df1-3c8d-4253-aa87-8c95ca5e1225
    • 您不需要设置 securityProtocol 属性。

      Copy to Clipboard Toggle word wrap
      apiVersion: camel.apache.org/v1alpha1
      kind: KameletBinding
      metadata:
        name: coffees-to-kafka
      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: kafka-sink
          properties:
            bootstrapServers: "my-kafka--ptdfzrhmlkwqw-a-ykm-mawgdh.kafka.devshift.org:443"
            password: "facf3df1-3c8d-4253-aa87-8c95ca5e1225"
            topic: "test-topic"
            user: "srvc-acct-eb575691-b94a-41f1-ab97-50ade0cd1094"

      对于另一个示例,当 Kafka 集群位于 AMQ Streams 上时,将 securityProtocol 属性设置为 "PLAINTEXT"

      Copy to Clipboard Toggle word wrap
      apiVersion: camel.apache.org/v1alpha1
      kind: KameletBinding
      metadata:
        name: coffees-to-kafka
      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: kafka-sink
          properties:
            bootstrapServers: "broker.url:9092"
            password: "testpassword"
            topic: "test-topic"
            user: "testuser"
            securityProtocol: "PLAINTEXT"
  5. 保存 YAML 文件(例如,coffees-to-kafka.yaml)。
  6. 登录您的 OpenShift 项目。
  7. 将 Kamelet Binding 作为资源添加到 OpenShift 命名空间中:

    oc apply -f <kamelet binding filename>

    例如:

    oc apply -f coffees-to-kafka.yaml

    Camel K operator 使用 KameletBinding 资源生成并运行 Camel K 集成。构建可能需要几分钟时间。

  8. 查看 KameletBinding 资源的状态:

    oc get kameletbindings

  9. 查看其集成的状态:

    oc get integrations

  10. 查看集成的日志:

    kamel logs <integration> -n <project>

    例如:

    kamel logs coffees-to-kafka -n my-camel-k-kafka

2.4. 将 Kafka 主题连接到 Kamelet Binding 中的数据接收器

要将 Kafka 主题连接到数据接收器,您可以创建一个 Kamelet Binding,如 过期 2.3 所示

Connecting a Kafka topic to a data sink 图 2.3 将 Kafka 主题连接到数据接收器

先决条件

  • 您知道您要从中发送事件的 Kafka 主题的名称。此流程中的示例使用 test-topic 来发送事件。这与您 将数据源连接到 Kamelet Binding 中的 Kafka 主题中的 coffee 源接收事件相同。
  • 您知道 Kafka 实例的以下参数值:

    • bootstrapServers - Kafka Broker URL 的逗号分隔列表。
    • Password - 在 Kafka 中进行身份验证的密码。
    • User - 在 Kafka 中进行身份验证的用户名。

      有关如何使用 OpenShift Streams 时如何获取这些值的详情,请参考包含 Kafka 凭证

  • 您知道与 Kafka 代理通信的安全协议。对于 OpenShift Streams 上的 Kafka 集群,它是 SASL_SSL (默认)。对于 AMQ 流上的 Kafka 集群,它是 PLAINTEXT
  • 您知道您要添加到 Camel K 集成和所需的实例参数的 Kamelets。此过程的 Kamelets 示例在 Kamelet Catalog 中提供:

    • kafka-source Kamelet - 使用 kafka-source Kamelet,因为 Kafka 主题在此绑定中发送数据(这是数据制作者)。所需参数的示例值为:

      • bootstrapServers - "broker.url:9092"
      • password - "testpassword"
      • user - "testuser"
      • topic - "test-topic"
      • SecurityProtocol - 对于 OpenShift Streams 上的 Kafka 集群,您不需要设置此参数,因为 SASL_SSL 是默认值。对于 AMQ 流上的 Kafka 集群,此参数值为 "PLAINTEXT "。
    • log-sink Kamelet - 使用 log-sink 记录它从 kafka-source Kamelet 接收的数据。(可选)指定 showStreams 参数来显示数据的消息正文。log-sink Kamelet 有助于调试目的。

流程

要将 Kafka 主题连接到数据接收器,请创建一个 Kamelet Binding:

  1. 在您选择的编辑器中,使用以下基本结构创建一个 YAML 文件:

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name:
    spec:
      source:
      sink:
  2. 为 Kamelet Binding 添加名称。在本例中,名称为 kafka-to-log,因为绑定将 kafka-source Kamelet 连接到 log-sink Kamelet。

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: kafka-to-log
    spec:
      source:
      sink:
  3. 对于 Kamelet Binding 的源,指定 kafka-source Kamelet 并配置其参数。

    例如,当 Kafka 集群在 OpenShift Streams 上时(您不需要设置 securityProtocol 参数):

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: kafka-to-log
    spec:
      source:
        ref:
          kind: Kamelet
          apiVersion: camel.apache.org/v1alpha1
          name: kafka-source
        properties:
          bootstrapServers: "broker.url:9092"
          password: "testpassword"
          topic: "test-topic"
          user: "testuser"
      sink:

    例如,当 Kafka 集群位于 AMQ Streams 上时,必须将 securityProtocol 参数设置为 "PLAINTEXT"

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: kafka-to-log
    spec:
      source:
        ref:
          kind: Kamelet
          apiVersion: camel.apache.org/v1alpha1
          name: kafka-source
        properties:
          bootstrapServers: "broker.url:9092"
          password: "testpassword"
          topic: "test-topic"
          user: "testuser"
          securityProtocol: "PLAINTEXT"
      sink:
  4. 对于 Kamelet Binding 的 sink,指定 data consumer Kamelet (如 log-sink Kamelet)并为 Kamelet 配置任何参数,例如:

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: kafka-to-log
    spec:
      source:
        ref:
          kind: Kamelet
          apiVersion: camel.apache.org/v1alpha1
          name: kafka-source
        properties:
          bootstrapServers: "broker.url:9092"
          password: "testpassword"
          topic: "test-topic"
          user: "testuser"
          securityProtocol: "PLAINTEXT" // only for AMQ streams
      sink:
        ref:
          kind: Kamelet
          apiVersion: camel.apache.org/v1alpha1
          name: log-sink
        properties:
          showStreams: true
  5. 保存 YAML 文件(如 kafka-to-log.yaml)。
  6. 登录您的 OpenShift 项目。
  7. 将 Kamelet Binding 作为资源添加到 OpenShift 命名空间中:

    oc apply -f <kamelet binding filename>

    例如:

    oc apply -f kafka-to-log.yaml

    Camel K operator 使用 KameletBinding 资源生成并运行 Camel K 集成。构建可能需要几分钟时间。

  8. 查看 KameletBinding 资源的状态:

    oc get kameletbindings

  9. 查看其集成的状态:

    oc get integrations

  10. 查看集成的日志:

    kamel logs <integration> -n <project>

    例如:

    kamel 日志 kafka-to-log -n my-camel-k-kafka

    在输出中,您应该看到 coffee 事件,例如:

    Copy to Clipboard Toggle word wrap
    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"}
  11. 要停止正在运行的集成,请删除关联的 Kamelet Binding 资源:

    oc delete kameletbindings/<kameletbinding-name>

    例如:

    oc delete kameletbindings/kafka-to-log

2.5. 将操作应用到 Kafka 连接中的数据

如果要在 Kamelet 和 Kafka 主题之间传递的数据执行操作,请在 Kamelet Binding 中使用 action Kamelets 作为中间步骤。

2.5.1. 将事件数据路由到不同的目的地主题

当您配置到 Kafka 实例时,您可以选择将主题信息从事件数据转换,以便事件路由到不同的 Kafka 主题。使用以下转换操作 Kamelets 之一:

  • regex Router - 使用正则表达式和替换字符串修改消息的主题。例如,如果要删除主题前缀,请添加前缀或删除主题名称的一部分。配置 Regex Router Action Kamelet (regex-router-action)。
  • timestamp - 根据原始主题和消息的时间戳修改消息的主题。例如,在使用需要写入不同表或基于时间戳的索引的接收器时。例如,当您要将事件从 Kafka 写入 Elasticsearch 时,每个事件都需要根据事件本身中的信息进入不同的索引。配置 Timestamp Router Action Kamelet (timestamp-router-action)。
  • message Time Stamp - 修改基于原始主题值的消息主题,以及来自消息值字段的时间戳字段。配置 Message Timestamp Router Action Kamelet (message-timestamp-router-action)。
  • predicate - 通过配置 Predicate Filter Action Kamelet (predicate-filter-action)来根据给定的 JSON 路径表达式过滤事件。

先决条件

流程

要转换目标主题,请在 Kamelet Binding 中使用一个转换操作 Kamelets 作为中间步骤。

有关如何在 Kamelet Binding 中添加操作 Kamelet 的详情,请参阅 在 Kamelet Binding 中添加操作

2.5.2. 过滤特定 Kafka 主题的事件数据

如果您使用源 Kamelet 将记录生成到许多不同的 Kafka 主题,并且您要将记录过滤到一个 Kafka 主题,请在 Kamelet Binding 中添加 topic-name-matches-filter-action Kamelet 作为中间步骤。

先决条件

  • 您已在 YAML 文件中创建了一个 Kamelet Binding。
  • 您知道要从中过滤出事件数据的 Kafka 主题的名称。

流程

  1. 编辑 Kamelet Binding,将 topic-name-matches-filter-action Kamelet 作为源和目标 Kamelets 之间的中间步骤包含。

    通常,您可以使用 kafka-source Kamelet 作为源 Kamelet,您提供了一个主题作为所需 主题 参数的值。

    在以下 Kamelet Binding 示例中,kafka-source Kamelet 指定 test-topic、test-topic-2 和 test-topic-3 Kafka 主题和 topic-name-matches-filter-action Kamelet 指定过滤出 topic-test 主题的事件数据:

    Copy to Clipboard Toggle word wrap
    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

    如果要过滤来自 kafka-source Kamelet 以外的源 Kamelet 的主题,您必须提供 Kafka 主题信息。您可以使用 insert-header-action Kamelet 将 Kafka 主题字段添加为中间步骤,在 Kamelet Binding 中的 topic-name-matches-filter-action 步骤前,如下例所示:

    Copy to Clipboard Toggle word wrap
    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. 保存 Kamelet Binding YAML 文件。

第 3 章 使用 Kamelets 连接到 Knative

您可以将 Kamelets 连接到 Knative 目的地(频道或代理)。Red Hat OpenShift Serverless 基于开源 Knative 项目,通过启用企业级无服务器平台在混合和多云环境之间提供可移植性和一致性。OpenShift Serverless 包括对 Knative Eventing 和 Knative Serving 组件的支持。

Red Hat OpenShift Serverless、Knative Eventing 和 Knative Serving 可让您使用带有无服务器应用程序的 事件驱动的架构,通过使用发布订阅或事件流模型来解码事件和消费者之间的关系。Knative Eventing 使用标准 HTTP POST 请求来发送和接收事件创建者和用户之间的事件。这些事件符合 CloudEvents 规范,它允许在任何编程语言中创建、解析、发送和接收事件。

您可以使用 Kamelets 将 CloudEvents 发送到 Knative,并将它们从 Knative 发送到事件用户。kamelet 可将消息转换为 CloudEvents,您可以使用它们应用 CloudEvents 中数据的任何预处理和后处理。

3.1. 使用 Kamelets 连接到 Knative 概述

如果使用 Knative 流处理框架,您可以使用 Kamelets 将服务和应用程序连接到 Knative 目的地(频道或代理)。

图 3.1 演示了将源和接收器 Kamelets 连接到 Knative 目的地的流程。

使用 Kamelets 和 Knative 目的地的数据流

图 3.1:使用 Kamelets 和 Knative 频道的数据流

以下是使用 Kamelets 和 Kamelet Bindings 将应用程序和服务连接到 Knative 目的地的基本步骤的概述:

  1. 设置 Knative:

    1. 通过安装 Camel K 和 OpenShift Serverless operator 来准备 OpenShift 集群。
    2. 安装所需的 Knative Serving 和 Eventing 组件。
    3. 创建 Knative 频道或代理。
  2. 决定您要连接到 Knative 频道或代理的服务或应用程序。
  3. 查看 Kamelet Catalog,以查找您要添加到集成的源和目标组件的 Kamelets。另外,确定您要使用的每个 Kamelet 所需的配置参数。
  4. 创建 Kamelet Bindings :

    • 创建一个 Kamelet Binding,将源 Kamelet 连接到 Knative 频道(或代理)。
    • 创建一个 Kamelet Binding,将 Knative 频道(或代理)连接到接收器 Kamelet。
  5. 另外,还可通过将一个或多个操作 Kamelets 作为 Kamelet Binding 中的中间步骤,在 Knative 频道(或代理)和数据源或接收器之间传输的数据。
  6. (可选)定义如何处理 Kamelet Binding 中的错误。
  7. 将 Kamelet Bindings 作为资源应用到项目。

Camel K operator 为每个 Kamelet Binding 生成单独的 Camel 集成。

当您将 Kamelet Binding 配置为使用 Knative 频道或代理作为事件源时,Camel K operator 将对应的集成化为 Knative Serving 服务,以利用 Knative 提供的自动扩展功能。

3.2. 设置 Knative

设置 Knative 涉及安装所需的 OpenShift operator 并创建一个 Knative 频道。

3.2.1. 准备 OpenShift 集群

要使用 Kamelets 和 OpenShift Serverless,请安装以下 operator、组件和 CLI 工具:

  • Red Hat Integration - Camel K operator 和 CLI 工具 - Operator 安装和管理 Camel K - 一个轻量级集成框架,它在 OpenShift 上的云中原生运行。kamel CLI 工具允许您访问所有 Camel K 功能。

    请参阅 安装 Camel K 中的安装说明。

  • OpenShift Serverless operator - 提供一组 API,使容器、微服务和功能能够运行 "serverless"。无服务器应用程序可以根据需要扩展和缩减(到零),并由多个事件源触发。安装 OpenShift Serverless Operator 时,它会自动创建 knative-serving 命名空间(用于安装 Knative Serving 组件)和 knative-eventing 命名空间(安装 Knative Eventing 组件是必需的)。
  • Knative Eventing 组件
  • Knative Serving 组件
  • Knative CLI 工具(kn)- 允许您从命令行或从 Shell 脚本中创建 Knative 资源。
3.2.1.1. 安装 OpenShift Serverless

您可以从 OperatorHub 在 OpenShift 集群上安装 OpenShift Serverless Operator。OperatorHub 可从 OpenShift Container Platform Web 控制台获得,集群管理员提供了一个界面来发现和安装 Operator。

OpenShift Serverless Operator 支持 Knative Serving 和 Knative Eventing 功能。如需了解更多详细信息,请参阅安装 OpenShift Serverless Operator

先决条件

  • 具有安装 Camel K Operator 的 OpenShift 项目的集群管理员访问权限。
  • 已安装 OpenShift CLI 工具(oc),以便您可以在命令行中与 OpenShift 集群交互。有关如何安装 OpenShift CLI 的详细信息,请参阅安装 OpenShift CLI

流程

  1. 在 OpenShift Container Platform Web 控制台中,使用具有集群管理员权限的账户登录。
  2. 在左侧导航菜单中,点 Operators > OperatorHub
  3. Filter by keyword 文本框中,输入 Serverless 来查找 OpenShift Serverless Operator
  4. 阅读 Operator 的信息,然后点 Install 以显示 Operator 订阅页面。
  5. 选择默认订阅设置:

    • 更新频道 > 选择与您的 OpenShift 版本匹配的频道,如 4.12
    • Installation Mode > All namespaces on the cluster
    • Approval Strategy > Automatic

      注意

      如果您的环境需要,也可以使用 Approval Strategy > Manual 设置。

  6. Install,然后等待几分钟,直到 Operator 准备就绪。
  7. 按照 OpenShift 文档中的步骤安装所需的 Knative 组件:

  8. (可选)下载并安装 OpenShift Serverless CLI 工具:

    1. 在 OpenShift Web 控制台顶部的 Help 菜单(?)中选择 Command line tools
    2. 向下滚动到 kn - OpenShift Serverless - 命令行界面 部分。
    3. 单击链接,以下载本地操作系统的二进制文件(Linux、Mac、Windows)
    4. 在您的系统路径中解压并安装 CLI。
    5. 要验证您可以访问 kn CLI,请打开命令窗口,然后键入以下内容:

      kn --help

      此命令显示有关 OpenShift Serverless CLI 命令的信息。

      如需了解更多详细信息,请参阅 OpenShift Serverless CLI 文档

3.2.2. 创建 Knative 频道

Knative 频道是一个转发事件的自定义资源。事件源或生成程序将事件发送到频道后,可使用订阅将这些事件发送到多个 Knative 服务或其他 sink。

本例使用 InMemoryChannel 频道,用于 OpenShift Serverless 用于开发目的。请注意, InMemoryChannel 类型频道有以下限制:

  • 事件没有持久性。如果 Pod 停机,则 Pod 上的事件将会丢失。
  • InMemoryChannel 频道没有实现事件排序,因此同时接收到的两个事件可能会以任何顺序传送给订阅者。
  • 如果订阅者拒绝某个事件,则不会默认重新发送尝试。您可以通过修改 Subscription 对象中的 delivery 规格来配置重新发送尝试。

先决条件

  • OpenShift Serverless operator、Knative Eventing 和 Knative Serving 组件已安装在 OpenShift Container Platform 集群中。
  • 已安装 OpenShift Serverless CLI (kn)。
  • 您已创建了一个项目,或者具有适当的角色和权限访问项目,以便在 OpenShift Container Platform 中创建应用程序和其他工作负载。

流程

  1. 登录您的 OpenShift 集群。
  2. 打开您要在其中创建集成应用程序的项目。例如:

    oc project camel-k-knative

  3. 使用 Knative (kn) CLI 命令创建频道

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

    例如,要创建一个名为 mychannel 的频道:

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

  4. 要确认频道现在存在,请输入以下命令列出所有现有频道:

    kn channel list

    您应该在列表中看到您的频道。

3.2.3. 创建 Knative 代理

Knative 代理是一个自定义资源,用于定义用于收集 CloudEvents 池的事件网格。OpenShift Serverless 提供了一个 default Knative 代理,您可以使用 kn CLI 创建该代理。

您可以在 Kamelet Binding 中使用代理,例如,当应用程序处理多个事件类型且您不想为每个事件类型创建频道时。

先决条件

  • OpenShift Serverless operator、Knative Eventing 和 Knative Serving 组件已安装在 OpenShift Container Platform 集群中。
  • 已安装 OpenShift Serverless CLI (kn)。
  • 您已创建了一个项目,或者具有适当的角色和权限访问项目,以便在 OpenShift Container Platform 中创建应用程序和其他工作负载。

流程

  1. 登录您的 OpenShift 集群。
  2. 打开您要在其中创建集成应用程序的项目。例如:

    oc project camel-k-knative

  3. 使用此 Knative (kn) CLI 命令创建代理:

    kn broker create default

  4. 要确认代理现在存在,请输入以下命令列出所有现有代理:

    kn broker list

您应该在列表中看到 default 代理。

3.3. 在 Kamelet Binding 中将数据源连接到 Knative 目的地

要将数据源连接到 Knative 目的地(通道或代理),您可以创建一个 Kamelet Binding,如图 3.2 所示

Connecting a data source to a Knative destination

图 3.2 将数据源连接到 Knative 目的地

Knative 目的地可以是 Knative 频道或 Knative 代理。

当您向频道发送数据时,频道只有一个事件类型。您不需要在 Kamelet Binding 中为频道指定任何属性值。

当您向代理发送数据时,因为代理可以处理多个事件类型,所以您必须在 Kamelet Binding 中引用代理时为 type 属性指定一个值。

先决条件

  • 您知道您要将事件发送到的 Knative 频道或代理的名称和类型。

    此流程中的示例使用名为 mychannelInMemoryChannel 频道或名为 default 的代理。对于代理示例,coffee 事件中的 type 属性值为 coffee

  • 您知道您要添加到 Camel 集成和所需的实例参数的 Kamelet。

    此流程的 Kamelet 示例是 coffee-source Kamelet。它有一个可选参数 period,用于指定发送每个事件的频率。您可以将代码从 Example source Kamelet 复制到名为 coffee-source.kamelet.yaml 的文件,然后运行以下命令将其作为资源添加到命名空间中:

    oc apply -f coffee-source.kamelet.yaml

流程

要将数据源连接到 Knative 目的地,请创建一个 Kamelet Binding:

  1. 在您选择的编辑器中,使用以下基本结构创建一个 YAML 文件:

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name:
    spec:
      source:
      sink:
  2. 为 Kamelet Binding 添加名称。在本例中,名称为 coffees-to-knative,因为绑定将 coffee-source Kamelet 连接到 Knative 目的地。

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: coffees-to-knative
    spec:
      source:
      sink:
  3. 对于 Kamelet Binding 的源,请指定数据源 Kamelet (例如,coffee-source Kamelet 会生成包含 coffee 的数据)的事件,并为 Kamelet 配置任何参数。

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: coffees-to-knative
    spec:
      source:
        ref:
          kind: Kamelet
          apiVersion: camel.apache.org/v1alpha1
          name: coffee-source
        properties:
          period: 5000
      sink:
  4. 对于 Kamelet Binding 的 sink,请指定 Knative 频道或代理以及所需的参数。

    这个示例将 Knative 频道指定为接收器:

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: coffees-to-knative
    spec:
      source:
        ref:
          kind: Kamelet
          apiVersion: camel.apache.org/v1alpha1
          name: coffee-source
        properties:
          period: 5000
      sink:
        ref:
          apiVersion: messaging.knative.dev/v1
          kind: InMemoryChannel
          name: mychannel

    本例将 Knative 代理指定为接收器:

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: coffees-to-knative
    spec:
      source:
        ref:
          kind: Kamelet
          apiVersion: camel.apache.org/v1alpha1
          name: coffee-source
        properties:
          period: 5000
      sink:
          ref:
            kind: Broker
            apiVersion: eventing.knative.dev/v1
            name: default
          properties:
            type: coffee
  5. 保存 YAML 文件(例如,coffees-to-knative.yaml)。
  6. 登录您的 OpenShift 项目。
  7. 将 Kamelet Binding 作为资源添加到 OpenShift 命名空间中:

    oc apply -f <kamelet binding filename>

    例如:

    oc apply -f coffees-to-knative.yaml

    Camel K operator 使用 KameletBinding 资源生成并运行 Camel K 集成。构建可能需要几分钟时间。

  8. 查看 KameletBinding 的状态:

    oc get kameletbindings

  9. 查看其集成的状态:

    oc get integrations

  10. 查看集成的日志:

    kamel logs <integration> -n <project>

    例如:

    kamel logs coffees-to-knative -n my-camel-knative

3.4. 将 Knative 目的地连接到 Kamelet Binding 中的数据接收器

要将 Knative 目的地连接到数据接收器,您可以创建一个 Kamelet Binding,如图 3.3 所示

Connecting a Knative destination to a data sink

图 3.3 将 Knative 目的地连接到数据接收器

Knative 目的地可以是 Knative 频道或 Knative 代理。

当您从频道发送数据时,频道只有一个事件类型。您不需要在 Kamelet Binding 中为频道指定任何属性值。

当您从代理发送数据时,因为代理可以处理多个事件类型,所以您必须在 Kamelet Binding 中引用代理时为 type 属性指定一个值。

先决条件

  • 您知道 Knative 频道的名称和类型,或您要接收事件的代理名称。对于代理,您还知道您要接收的事件类型。

    此流程中的示例使用名为 mychannel 的 InMemoryChannel 频道或名为 mybroker 和 coffee 的代理(用于 type 属性)。这些是 与从 coffee 源接收事件相同的示例目的地,在 Kamelet Binding 中将数据源连接到 Knative 频道

  • 您知道您要添加到 Camel 集成和所需的实例参数的 Kamelet。

    此流程的 Kamelet 示例是 log-sink Kamelet,它在 Kamelet Catalog 中提供,可用于测试和调试。指定 showStreams 参数来显示数据的消息正文。

流程

要将 Knative 频道连接到数据接收器,请创建一个 Kamelet Binding:

  1. 在您选择的编辑器中,使用以下基本结构创建一个 YAML 文件:

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name:
    spec:
      source:
      sink:
  2. 为 Kamelet Binding 添加名称。在本例中,名称为 knative-to-log,因为绑定将 Knative 目的地连接到 log-sink Kamelet。

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: knative-to-log
    spec:
      source:
      sink:
  3. 对于 Kamelet Binding 的源,指定 Knative 频道或代理以及所需的参数。

    本例指定一个 Knative 频道作为源:

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: knative-to-log
    spec:
      source:
        ref:
          apiVersion: messaging.knative.dev/v1
          kind: InMemoryChannel
          name: mychannel
      sink:

    本例指定一个 Knative 代理作为源:

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: knative-to-log
    spec:
      source:
        ref:
          kind: Broker
          apiVersion: eventing.knative.dev/v1
          name: default
        properties:
          type: coffee
    sink:
  4. 对于 Kamelet Binding 的 sink,指定 data consumer Kamelet (如 log-sink Kamelet)并为 Kamelet 配置任何参数,例如:

    Copy to Clipboard Toggle word wrap
    apiVersion: camel.apache.org/v1alpha1
    kind: KameletBinding
    metadata:
      name: knative-to-log
    spec:
      source:
        ref:
          apiVersion: messaging.knative.dev/v1
          kind: InMemoryChannel
          name: mychannel
      sink:
        ref:
          apiVersion: camel.apache.org/v1alpha1
          kind: Kamelet
          name: log-sink
        properties:
          showStreams: true
  5. 保存 YAML 文件(如 knative-to-log.yaml)。
  6. 登录您的 OpenShift 项目。
  7. 将 Kamelet Binding 作为资源添加到 OpenShift 命名空间: oc apply -f <kamelet binding filename>

    例如:

    oc apply -f knative-to-log.yaml

    Camel K operator 使用 KameletBinding 资源生成并运行 Camel K 集成。构建可能需要几分钟时间。

  8. 查看 KameletBinding 的状态:

    oc get kameletbindings

  9. 查看集成的状态:

    oc get integrations

  10. 查看集成的日志:

    kamel logs <integration> -n <project>

    例如:

    kamel 日志 knative-to-log -n my-camel-knative

    在输出中,您应该看到 coffee 事件,例如:

    Copy to Clipboard Toggle word wrap
    [1] INFO [sink] (vert.x-worker-thread-1) {"id":254,"uid":"8e180ef7-8924-4fc7-ab81-d6058618cc42","blend_name":"Good-morning Star","origin":"Santander, Colombia","variety":"Kaffa","notes":"delicate, creamy, lemongrass, granola, soil","intensifier":"sharp"}
    [1] INFO [sink] (vert.x-worker-thread-2) {"id":8169,"uid":"3733c3a5-4ad9-43a3-9acc-d4cd43de6f3d","blend_name":"Caf? Java","origin":"Nayarit, Mexico","variety":"Red Bourbon","notes":"unbalanced, full, granola, bittersweet chocolate, nougat","intensifier":"delicate"}
  11. 要停止正在运行的集成,请删除关联的 Kamelet Binding 资源:

    oc delete kameletbindings/<kameletbinding-name>

    例如:

    oc delete kameletbindings/knative-to-log

第 4 章 kamelets 参考

4.1. kamelet 结构

Kamelet 通常以 YAML 域特定语言进行编码。文件名前缀是 Kamelet 的名称。例如,名为 FTP sink 的 Kamelet 文件名为 ftp-sink.kamelet.yaml

请注意,在 OpenShift 中,一个 Kamelet 是一个资源,它显示 Kamelet 的名称(而不是文件名)。

在高级别上,一个 Kamelet 资源描述:

  • 包含 Kamelet 的 ID 和其他信息的 metadata 部分,如 Kamelet 类型(sinkaction)。
  • 包含一组参数的定义(JSON-schema 规格),可用于配置 Kamelet。
  • 一个 可选 type 部分,其中包含 Kamelet 期望的输入和输出信息。
  • YAML DSL 中的 Camel 模板,用于定义 Kamelet 的实施。

下图显示了 Kamelet 及其部分的示例。

Kamelet 结构示例

Copy to Clipboard Toggle word wrap
telegram-text-source.kamelet.yaml
apiVersion: camel.apache.org/v1alpha1
kind: Kamelet
metadata:
  name: telegram-source 
1

  annotations: 
2

    camel.apache.org/catalog.version: "master-SNAPSHOT"
    camel.apache.org/kamelet.icon: "data:image/..."
    camel.apache.org/provider: "Red Hat"
    camel.apache.org/kamelet.group: "Telegram"
  labels: 
3

    camel.apache.org/kamelet.type: "source"
spec:
  definition: 
4

    title: "Telegram Source"
    description: |-
        Receive all messages that people send to your telegram bot.
        To create a bot, contact the @botfather account using the
        Telegram app.
        The source attaches the following headers to the messages:
        - chat-id / ce-chatid: the ID of the chat where the
        message comes from
    required:
        - authorizationToken
    type: object
    properties:
        authorizationToken:
          title: Token
          description: The token to access your bot on Telegram, that you
                   can obtain from the Telegram "Bot Father".
          type: string
          format: password
        x-descriptors:
        - urn:alm:descriptor:com.tectonic.ui:password
  types: 
5

    out:
      mediaType: application/json
  dependencies:
  - "camel:jackson"
  - "camel:kamelet"
  - "camel:telegram"
  template: 
6

    from:
        uri: telegram:bots
        parameters:
            authorizationToken: "{{authorizationToken}}"
        steps:
        - set-header:
          name: chat-id
          simple: "${header[CamelTelegramChatId]}"
        - set-header:
          name: ce-chatid
          simple: "${header[CamelTelegramChatId]}"
        - marshal:
          json: {}
        - to: "kamelet:sink"
  1. Kamelet ID - 当您想引用 Kamelet 时,在 Camel K 集成中使用此 ID。
  2. 注解(如 icon)为 Kamelet 提供显示功能。
  3. 标签允许用户查询 Kamelets (例如: kind: "source"、"sink" 或 "action")
  4. JSON-schema 规格格式的 Kamelet 和参数描述。
  5. 输出的介质类型(可以包含 schema)。
  6. 定义 Kamelet 行为的路由模板。

4.2. 源 Kamelet 示例

以下是 coffee-source Kamelet 示例的内容:

Copy to Clipboard Toggle word wrap
apiVersion: camel.apache.org/v1alpha1
kind: Kamelet
metadata:
  name: coffee-source
  labels:
    camel.apache.org/kamelet.type: "source"
spec:
  definition:
    title: "Coffee Source"
    description: "Retrieve a random coffee from a catalog of coffees"
    properties:
      period:
        title: Period
        description: The interval between two events in seconds
        type: integer
        default: 1000
  types:
    out:
      mediaType: application/json
  template:
    from:
      uri: timer:tick
      parameters:
        period: "{{period}}"
      steps:
      - to: "https://random-data-api.com/api/coffee/random_coffee"
      - to: "kamelet:sink"

法律通告

Copyright © 2023 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
返回顶部
Red Hat logoGithubredditYoutubeTwitter

学习

尝试、购买和销售

社区

关于红帽文档

通过我们的产品和服务,以及可以信赖的内容,帮助红帽用户创新并实现他们的目标。 了解我们当前的更新.

让开源更具包容性

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。欲了解更多详情,请参阅红帽博客.

關於紅帽

我们提供强化的解决方案,使企业能够更轻松地跨平台和环境(从核心数据中心到网络边缘)工作。

Theme

© 2025 Red Hat, Inc.