Red Hat Camel K is deprecated
Red Hat Camel K is deprecated and the End of Life date for this product is June 30, 2025. For help migrating to the current go-to solution, Red Hat build of Apache Camel, see the Migration Guide.将应用程序与 Kamelets 集成
配置连接器以简化应用程序集成
摘要
前言
kamelet 是可重复使用的路由组件,可隐藏创建连接到外部系统的数据管道的复杂性。
使开源包含更多
红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。我们从这四个术语开始:master、slave、黑名单和白名单。由于此项工作十分艰巨,这些更改将在即将推出的几个发行版本中逐步实施。有关更多详情,请参阅我们的首席技术官 Chris Wright 提供的消息。
第 1 章 Kamelets 概述
kamelet 是高级连接器,可作为事件驱动的架构解决方案中的构建块。这些是您可以在 OpenShift 集群上安装并用于 Camel K 集成的自定义资源。kamelets 加快您的开发工作。它们简化了如何连接数据源(发送事件)和数据接收器(这消耗事件)。由于您要配置 Kamelet 参数而不是编写代码,因此您不需要熟悉 Camel DSL 来使用 Kamelets。
您可以使用 Kamelets 直接将应用程序和服务相互连接,或者:
- Kafka 主题,如使用 Kamelets 连接到 Kafka 所述。
- Knative 目的地(通道或代理),如使用 Kamelets 连接到 Knative 所述。
- 特定的 Camel URI,如 连接到显式 Camel URI 中所述。
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 所示。

图 1.1: Kamelet Binding 源到 sink
以下是在 Kamelet Binding 中使用 Kamelets 的步骤概述:
- 安装 Camel K operator。它包含一个 Kamelets 目录,作为 OpenShift 项目中的资源。
- 创建 Kamelet Binding。决定您要在 Kamelet Binding 中连接的服务或应用程序。
- 查看 Kamelet Catalog,以查找您要使用的源和目标组件的 Kamelets。
- 对于您要包含在 Kamelet Binding 中的每个 Kamelet,请确定您需要设置的配置属性。
- 在 Kamelet Binding 代码中,添加对每个 Kamelet 的引用并配置所需的属性。
- 将 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。
流程
- 在 OpenShift Container Platform Web 控制台中,使用具有集群管理员权限的账户登录。
创建新 OpenShift 项目:
- 在左侧导航菜单中,点击 Home > Project > Create Project。
-
输入项目名称,如
my-camel-k-project
,然后单击 Create。
- 在左侧导航菜单中,点 Operators > OperatorHub。
-
在 Filter by keyword 文本框中,输入
Camel K
,然后点 Red Hat Integration - Camel K Operator 卡。 - 阅读 Operator 的信息,然后单击 Install。此时会打开 Operator 安装页面。
选择以下订阅设置:
- 更新频道 & gt; latest
- Installation Mode > A specific namespace on the cluster > my-camel-k-project
Approval Strategy > Automatic
注意如果您的环境需要,也可以使用 Installation mode > All namespaces on the cluster 和 Approval Strategy > Manual 设置。
- 点 Install,然后等待几分钟,直到 Camel K Operator 准备就绪。
下载并安装 Camel K CLI 工具:
- 在 OpenShift Web 控制台顶部的 Help 菜单(?)中选择 Command line tools。
- 向下滚动到 kamel - Red Hat Integration - Camel K - 命令行界面 部分。
- 单击链接,以下载本地操作系统的二进制文件(Linux、Mac、Windows)。
- 在您的系统路径中解压并安装 CLI。
要验证您可以访问 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 列表:
- 在终端窗口中,登录到您的 OpenShift 集群。
查看可用的 Kamelets 列表取决于 Camel K operator 的安装方式(在特定命名空间或集群模式中):
如果在 cluster-mode 中安装 Camel K operator,使用以下命令查看可用的 Kamelets:
oc get kamelet -n openshift-operators
如果 Camel K operator 安装在特定命名空间中:
打开在其中安装 Camel K operator 的项目。
oc project <camelk-project>
例如,如果在
my-camel-k-project
项目中安装了 Camel K operator:oc project my-camel-k-project
运行以下命令:
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 命名空间中的资源提供:
-
将 Kamelet
YAML
文件(如custom-sink.kamelet.yaml
)下载到本地文件夹。 - 登录您的 OpenShift 集群。
在终端窗口中,打开安装 Camel K operator 的项目,如
my-camel-k-project
:oc project my-camel-k-project
运行
oc apply
命令将自定义 Kamelet 作为资源添加到命名空间中:oc apply -f <custom-kamelet-filename>
例如,使用以下命令添加位于当前目录中的
custom-sink.kamelet.yaml
文件:oc apply -f custom-sink.kamelet.yaml
要验证 Kamelet 是否作为资源可用,请使用以下命令查看当前命名空间中的所有 Kamelets 的字母顺序列表,然后查找您的自定义 Kamelet:
oc get kamelets
1.2.2.2. 确定 Kamelet 的配置参数
在 Kamelet Binding 中,当添加对 Kamelet 的引用时,您可以指定 Kamelet 的名称并配置 Kamelet 参数。
前提条件
- 您在工作命名空间中或集群范围安装了 Camel K operator。
流程
要确定 Kamelet 的名称和参数:
- 在终端窗口中,登录到您的 OpenShift 集群。
打开 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
在 YAML 文件中,向下滚动到
spec.definition
部分(以 JSON-schema 格式编写)以查看 Kamelet 的属性列表。在部分末尾,所需的字段列出了在引用 Kamelet 时必须配置的属性。例如,以下代码是
ftp-source
Kamelet 的spec.definition
部分的摘录。本节详细介绍了所有 Kamelet 的配置属性。这个 Kamelet 的必要属性是connectionHost
,connectionPort
,username
,password
, 和directoryName
:Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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'
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 中提供。

图 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
流程
- 登录您的 OpenShift 集群。
打开安装 Camel K operator 的工作项目。如果在 cluster-mode 中安装 Camel K operator,则集群上的任何项目都可以使用它。
例如,要打开名为
my-camel-k-project
的现有项目:oc project my-camel-k-project
使用以下选项之一创建新的 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 Copied! Toggle word wrap Toggle overflow kamel bind <kamelet-source> -p “<property>=<property-value>” <kamelet-sink> -p “<property>=<property-value>”
kamel bind <kamelet-source> -p “<property>=<property-value>” <kamelet-sink> -p “<property>=<property-value>”
例如:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow kamel bind coffee-source -p “source.period=5000” log-sink -p "sink.showStreams=true"
kamel bind coffee-source -p “source.period=5000” log-sink -p "sink.showStreams=true"
Camel K operator 生成
KameletBinding
资源并运行对应的 Camel K 集成。使用 YAML 文件创建新的 Kamelet Binding
在您选择的编辑器中,使用以下结构创建一个 YAML 文件:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:
为 Kamelet Binding 添加名称。
在本例中,名称为
coffee-to-log
,因为绑定将coffee-source
Kamelet 连接到log-sink
Kamelet。Copy to Clipboard Copied! Toggle word wrap Toggle overflow apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: coffee-to-log spec: source: sink:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: coffee-to-log spec: source: sink:
指定源 Kamelet (如
coffee-source
)并为 Kamelet 配置任何参数。注: 在本例中,该参数在 Kamelet Binding 的 YAML 文件中定义。另外,您还可以在属性文件、ConfigMap 或 Secret 中配置 Kamelet 的参数,如 配置 Kamelet 实例参数 中所述。
Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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:
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:
指定 sink Kamelet (如
log-sink
),并为 Kamelet 配置任何参数。使用log-sink
Kamelet 的可选showStreams
参数来显示消息正文。Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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
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
-
保存 YAML 文件(例如,
coffee-to-log.yaml
)。 将
KameletBinding
作为资源添加到 OpenShift 命名空间中:oc apply -f <kamelet-binding>.yaml
例如:
oc apply -f coffee-to-log.yaml
Camel K operator 使用
KameletBinding
资源生成并运行 Camel K 集成。
-
使用
查看 Kamelet Binding 的状态:
oc get kameletbindings
-
查看对应集成的状态:
oc get integrations
查看输出:
要从命令行查看日志,请打开终端窗口,然后输入以下命令:
kamel log <integration-name>
例如,如果集成名称是
coffee-to-log
,使用以下命令:kamel log coffee-to-log
从 OpenShift Web 控制台查看日志:
- 选择 Workloads > Pods。
单击 Camel K 集成 pod 的名称,然后单击 Logs。
您应该看到类似以下示例的事件列表:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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"}
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"}
要停止集成,请删除 Kamelet Binding:
oc delete kameletbindings/<kameletbinding-name>
例如:
oc delete kameletbindings/coffee-to-log
后续步骤
(可选):
- 将 action Kamelets 作为中间步骤添加,如 Adding a operation to a Kamelet Binding 所述。
- 在 Kamelet Binding 中添加错误处理,如将错误处理程序策略添加到 Kamelet Binding 所述。
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 连接到事件频道的流程。

图 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):
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
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-action
或 avro-deserialize-action
Kamelet)前,通过添加反序列化步骤(例如,引用 protobuf-
Kamelet)来转换数据的格式。有关在连接中转换数据格式的更多信息,请参阅数据转换 Kamelets。
serialize-action
操作 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。
流程
在编辑器中打开
KameletBinding
文件。例如,以下是
coffee-to-log.yaml
文件的内容:Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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
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
在
source
部分添加一个integration
部分,并提供以下 Builder 特征配置属性(如predicate-filter-action
Kamelet 要求):Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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
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
添加
steps
部分,在source
和sink
部分定义操作 Kamelet。例如:Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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
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
- 保存您的更改。
使用
oc apply
命令更新KameletBinding
资源,例如:oc apply -f coffee-to-log.yaml
Camel K operator 会重新生成并运行基于更新的
KameletBinding
资源生成的 CamelK 集成。查看 Kamelet Binding 的状态:
oc get kameletbindings
查看其对应集成的状态:
oc get integrations
查看集成的日志文件输出:
kamel logs <integration-name>
例如,如果集成名称是
coffee-to-log
:kamel logs coffee-to-log
要停止集成,请删除 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 Copied! Toggle word wrap Toggle overflow spec: integration: traits: builder: configuration: properties: - "quarkus.arc.unremovable-types=com.fasterxml. jackson.databind.ObjectMapper"
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
-actionprotobuf-serialize-action
或 avro-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
)
-
avro Deserialize Action Kamelet (
协议缓冲 - Google 在内部使用它的高性能、紧凑的二进制线格式,以便它们与其内部网络服务通信。
-
protobuf Deserialize Action Kamelet (
protobuf-deserialize-action
) -
protobuf Serialize Action Kamelet (
protobuf-serialize-action
)
-
protobuf Deserialize Action Kamelet (
JSON (JavaScript Object Notation)- 基于 JavaScript 编程语言子集的数据中断格式。JSON 是一种完全独立于语言的文本格式。
-
JSON Deserialize Action Kamelet (
json-deserialize-action
) -
JSON Serialize Action Kamelet (
json-serialize-action
)
-
JSON Deserialize Action Kamelet (
您必须在 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 中添加以下错误处理策略之一:
- 无错误处理程序 - Ignores 的集成中出现的任何故障。
- 日志错误处理程序 - 发送日志消息到标准输出。
- 死信频道错误处理程序 - 将失败的事件重定向到另一个组件,如第三方 URI、队列或其他 Kamelet,它们可以在失败事件中执行某些逻辑。还支持尝试恢复消息在将消息发送到死信端点前多次交换。
- bean 错误处理程序 - 指定使用自定义 bean 来处理错误。
- ref error handler - 指定使用 bean 来处理错误。bean 必须在运行时在 Camel 注册表中可用。
1.4.1. 在 Kamelet Binding 中添加错误处理程序策略
要在源和目标连接之间发送或接收事件数据时处理错误,请在 Kamelet Binding 中添加错误处理程序策略。
先决条件
- 您知道您要使用的错误处理程序策略类型。
-
您有一个现有的
KameletBinding
YAML 文件。
流程
在 Kamelet Binding 中实施错误处理:
-
在编辑器中打开
KameletBinding
YAML 文件。 在
sink
定义后,在spec
部分添加一个 error handler 部分:Copy to Clipboard Copied! Toggle word wrap Toggle overflow apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: example-kamelet-binding spec: source: ... sink: ... errorHandler: ...
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: example-kamelet-binding spec: source: ... sink: ... errorHandler: ...
例如,在
coffee-to-log
Kamelet Binding 中,通过添加日志错误处理程序来指定错误发送到日志文件的最大次数:Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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
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
- 保存您的文件。
1.4.2. 错误处理程序
1.4.2.1. 没有错误处理程序
如果要忽略集成中发生的任何失败,则无法在 Kamelet Binding 中包含 errorHandler
部分,或者将其设置为 none,如下例所示:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: my-kamelet-binding spec: source: ... sink: ... errorHandler: none:
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
name: my-kamelet-binding
spec:
source:
...
sink:
...
errorHandler:
none:
1.4.2.2. 日志错误处理程序
处理任何失败的默认行为是将日志消息发送到标准输出。另外,您可以使用日志错误处理程序指定其他行为,如重新发送或延迟策略,如下例所示:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: my-kamelet-binding spec: source: ... sink: ... errorHandler: log: parameters: maximumRedeliveries: 3 redeliveryDelay: 2000
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),如以下示例所示:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: my-kamelet-binding spec: source: ... sink: ... errorHandler: dead-letter-channel: endpoint: ref: kind: Kamelet apiVersion: camel.apache.org/v1alpha1 name: error-handler properties: message: "ERROR!" ... parameters: maximumRedeliveries: 1
apiVersion: camel.apache.org/v1alpha1
kind: KameletBinding
metadata:
name: my-kamelet-binding
spec:
source:
...
sink:
...
errorHandler:
dead-letter-channel:
endpoint:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1alpha1
name: error-handler
properties:
message: "ERROR!"
...
parameters:
maximumRedeliveries: 1
-
对于 端点,您可以使用
ref
或uri
。根据kind
,apiVersion
和name
的值的 Camel K operator interpretsref
。您可以使用任何 Kamelet、Kafka 主题频道或 Knative 目的地。 -
属于端点的属性(本例中为 Kamelet),名为
error-handler
。 - 属于 dead-letter-channel 错误处理程序类型 的参数。
1.4.2.4. Bean 错误处理程序
使用 Bean 错误处理程序,您可以通过提供处理错误的自定义 bean 来扩展 Error Handler 的功能。对于 类型
,请指定 ErrorHandlerBuilder
的完全限定名称。对于 属性
,请配置您在 类型
中指定的 ErrorHandlerBuilder
所期望的属性。
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
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 的名称。
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: my-kamelet-binding spec: source: ... sink: ... errorHandler: ref: my-custom-builder
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 主题的流程。

图 2.1:使用 Kamelets 和 Kafka 主题的数据流
以下是使用 Kamelets 和 Kamelet Bindings 将应用程序和服务连接到 Kafka 主题的基本步骤的概述:
设置 Kafka:
安装所需的 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。
- 创建 Kafka 实例。Kafka 实例作为消息代理运行。代理包含主题并编配存储和传递信息。
- 创建 Kafka 主题。主题提供数据存储的目的地。
- 获取 Kafka 身份验证凭据。
- 决定您要连接到 Kafka 主题的服务或应用程序。
- 查看 Kamelet Catalog,以查找您要添加到集成的源和目标组件的 Kamelets。另外,确定您要使用的每个 Kamelet 所需的配置参数。
创建 Kamelet Bindings :
-
创建一个 Kamelet Binding,它将数据源(生成数据的组件)连接到 Kafka 主题(通过使用
kafka-sink
Kamelet)。 -
创建一个 Kamelet Binding,它将 kafka 主题(使用
kafka-source
Kamelet)连接到数据接收器(消耗数据的组件)。
-
创建一个 Kamelet Binding,它将数据源(生成数据的组件)连接到 Kafka 主题(通过使用
- 另外,还可通过在 Kamelet Binding 中添加一个或多个操作 Kamelets 来操作 Kafka 主题和接收器之间传递的数据。
- (可选)定义如何处理 Kamelet Binding 中的错误。
将 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:
- 登录 OpenShift 集群的 Web 控制台。
- 创建或打开您要在其中创建集成的项目,如 my-camel-k-kafka。
- 安装 Camel K operator 和 Camel K CLI,如 安装 Camel K 所述。
安装 AMQ 流 Operator:
- 在任何项目中,选择 Operators > OperatorHub。
- 在 Filter by Keyword 字段中,键入 AMQ Streams。
点 Red Hat Integration - AMQ Streams 卡,然后点 Install。
此时会打开 Install Operator 页面。
- 接受默认值,然后点 Install。
- 选择 Operators > Installed Operators 来验证是否安装了 Camel K 和 AMQ Streams operator。
2.2.1.2. 使用 AMQ Streams 设置 Kafka 主题
Kafka 主题为 Kafka 实例中数据存储提供目的地。您必须将数据发送到 Kafka 主题,您必须先设置 Kafka 主题。
先决条件
- 您可以访问 OpenShift 集群。
- 已安装 Red Hat Integration - Camel K 和 Red Hat Integration - AMQ Streams operator,如 准备 OpenShift 集群 中所述。
-
已安装 OpenShift CLI (
oc
)和 Camel K CLI (kamel
)。
流程
使用 AMQ Streams 设置 Kafka 主题:
- 登录 OpenShift 集群的 Web 控制台。
- 选择 Projects,然后点击安装 Red Hat Integration - AMQ Streams operator 的项目。例如,单击 my-camel-k-kafka 项目。
- 选择 Operators > Installed Operators,然后点 Red Hat Integration - AMQ Streams。
创建 Kafka 集群:
- 在 Kafka 下,点 Create instance。
- 为集群输入一个名称,如 kafka-test。
接受其他默认值,然后单击 Create。
创建 Kafka 实例的过程可能需要几分钟时间才能完成。
当状态就绪时,请继续下一步。
创建 Kafka 主题:
- 选择 Operators > Installed Operators,然后点 Red Hat Integration - AMQ Streams。
- 在 Kafka Topic 下,点 Create Kafka Topic。
- 为主题输入名称,如 test-topic。
- 接受其他默认值,然后单击 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 集群交互。
流程
- 使用集群管理员帐户登录 OpenShift Web 控制台。
为您的 Camel K 或 Kamelets 应用程序创建 OpenShift 项目。
- 选择 Home > Projects。
- 点击 Create Project。
-
输入项目的名称,如
my-camel-k-kafka
,然后单击 Create。
- 下载并安装 RHOAS CLI,如 开始使用 rhoas CLI 所述。
- 安装 Camel K operator 和 Camel K CLI,如 安装 Camel K 所述。
- 要验证是否安装了 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 主题:
- 在命令行中登录到您的 OpenShift 集群。
打开项目,例如:
oc project my-camel-k-kafka
验证在您的项目中是否安装了 Camel K operator:
oc get csv
结果列出了 Red Hat Camel K operator,并表示它处于
Succeeded
阶段。准备 Kafka 实例并将其连接到 RHOAS:
使用以下命令登录到 RHOAS CLI:
rhoas login
创建一个 kafka 实例,如 kafka-test :
rhoAS kafka create kafka-test
创建 Kafka 实例的过程可能需要几分钟时间才能完成。
检查 Kafka 实例的状态:
RHOAS 状态
您还可以在 web 控制台中查看状态:
https://cloud.redhat.com/application-services/streams/kafkas/
当状态 就绪时,请继续下一步。
创建新的 Kafka 主题:
rhoas kafka topic create --name test-topic
将 Kafka 实例(集群)与 Openshift Application Services 实例连接:
RHOAS 集群连接
按照获取凭据令牌的脚本说明进行操作。
您应该看到类似如下的输出:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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.
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 主题。
流程
获取 Kafka Broker URL (Bootstrap URL):
RHOAS 状态
这个命令返回类似如下的输出:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow Kafka --------------------------------------------------------------- ID: 1ptdfZRHmLKwqW6A3YKM2MawgDh Name: my-kafka Status: ready Bootstrap URL: my-kafka--ptdfzrhmlkwqw-a-ykm-mawgdh.kafka.devshift.org:443
Kafka --------------------------------------------------------------- ID: 1ptdfZRHmLKwqW6A3YKM2MawgDh Name: my-kafka Status: ready Bootstrap URL: my-kafka--ptdfzrhmlkwqw-a-ykm-mawgdh.kafka.devshift.org:443
要获取用户名和密码,请使用以下语法创建服务帐户:
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 文件中。
要验证服务帐户凭证,请查看
credentials.json
文件:cat credentials.json
这个命令返回类似如下的输出:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow {"clientID":"srvc-acct-eb575691-b94a-41f1-ab97-50ade0cd1094", "password":"facf3df1-3c8d-4253-aa87-8c95ca5e1225"}
{"clientID":"srvc-acct-eb575691-b94a-41f1-ab97-50ade0cd1094", "password":"facf3df1-3c8d-4253-aa87-8c95ca5e1225"}
授予向 Kakfa 主题发送和接收消息的权限。使用以下命令,其中
clientID
是credentials.json
文件中提供的值(第 3 步)。Copy to Clipboard Copied! Toggle word wrap Toggle overflow rhoas kafka acl grant-access --producer --consumer --service-account $CLIENT_ID --topic test-topic --group all
rhoas kafka acl grant-access --producer --consumer --service-account $CLIENT_ID --topic test-topic --group all
例如:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow rhoas kafka acl grant-access --producer --consumer --service-account srvc-acct-eb575691-b94a-41f1-ab97-50ade0cd1094 --topic test-topic --group all
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 所示。
图 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:
在您选择的编辑器中,使用以下基本结构创建一个 YAML 文件:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:
为 Kamelet Binding 添加名称。在本例中,名称为
coffees-to-kafka
,因为绑定将coffee-source
Kamelet 连接到kafka-sink
Kamelet。Copy to Clipboard Copied! Toggle word wrap Toggle overflow apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: coffees-to-kafka spec: source: sink:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: coffees-to-kafka spec: source: sink:
对于 Kamelet Binding 的源,请指定数据源 Kamelet (例如,
coffee-source
Kamelet 会生成包含 coffee 的数据)的事件,并为 Kamelet 配置任何参数。Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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:
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:
对于 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 Copied! Toggle word wrap Toggle overflow 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"
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 Copied! Toggle word wrap Toggle overflow 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"
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"
-
对于
-
保存 YAML 文件(例如,
coffees-to-kafka.yaml
)。 - 登录您的 OpenShift 项目。
将 Kamelet Binding 作为资源添加到 OpenShift 命名空间中:
oc apply -f <kamelet binding filename>
例如:
oc apply -f coffees-to-kafka.yaml
Camel K operator 使用
KameletBinding
资源生成并运行 Camel K 集成。构建可能需要几分钟时间。查看
KameletBinding
资源的状态:oc get kameletbindings
查看其集成的状态:
oc get integrations
查看集成的日志:
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 所示。
图 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
"。
-
bootstrapServers -
-
log-sink
Kamelet - 使用log-sink
记录它从kafka-source
Kamelet 接收的数据。(可选)指定showStreams
参数来显示数据的消息正文。log-sink
Kamelet 有助于调试目的。
流程
要将 Kafka 主题连接到数据接收器,请创建一个 Kamelet Binding:
在您选择的编辑器中,使用以下基本结构创建一个 YAML 文件:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:
为 Kamelet Binding 添加名称。在本例中,名称为
kafka-to-log
,因为绑定将kafka-source
Kamelet 连接到log-sink
Kamelet。Copy to Clipboard Copied! Toggle word wrap Toggle overflow apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: kafka-to-log spec: source: sink:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: kafka-to-log spec: source: sink:
对于 Kamelet Binding 的源,指定
kafka-source
Kamelet 并配置其参数。例如,当 Kafka 集群在 OpenShift Streams 上时(您不需要设置
securityProtocol
参数):Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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:
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 Copied! Toggle word wrap Toggle overflow 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:
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:
对于 Kamelet Binding 的 sink,指定 data consumer Kamelet (如
log-sink
Kamelet)并为 Kamelet 配置任何参数,例如:Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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
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
-
保存 YAML 文件(如
kafka-to-log.yaml
)。 - 登录您的 OpenShift 项目。
将 Kamelet Binding 作为资源添加到 OpenShift 命名空间中:
oc apply -f <kamelet binding filename>
例如:
oc apply -f kafka-to-log.yaml
Camel K operator 使用
KameletBinding
资源生成并运行 Camel K 集成。构建可能需要几分钟时间。查看
KameletBinding
资源的状态:oc get kameletbindings
查看其集成的状态:
oc get integrations
查看集成的日志:
kamel logs <integration> -n <project>
例如:
kamel 日志 kafka-to-log -n my-camel-k-kafka
在输出中,您应该看到 coffee 事件,例如:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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"}
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"}
要停止正在运行的集成,请删除关联的 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,接收器是一个
kafka-sink
Kamelet,如 将数据源连接到 Kamelet Binding 中的 Kafka 主题 中所述。 - 您知道您要添加到 Kamelet Binding 中的哪些类型的转换。
流程
要转换目标主题,请在 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 主题的名称。
流程
编辑 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 Copied! Toggle word wrap Toggle overflow 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
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 Copied! Toggle word wrap Toggle overflow 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
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
- 保存 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 目的地的流程。

图 3.1:使用 Kamelets 和 Knative 频道的数据流
以下是使用 Kamelets 和 Kamelet Bindings 将应用程序和服务连接到 Knative 目的地的基本步骤的概述:
设置 Knative:
- 通过安装 Camel K 和 OpenShift Serverless operator 来准备 OpenShift 集群。
- 安装所需的 Knative Serving 和 Eventing 组件。
- 创建 Knative 频道或代理。
- 决定您要连接到 Knative 频道或代理的服务或应用程序。
- 查看 Kamelet Catalog,以查找您要添加到集成的源和目标组件的 Kamelets。另外,确定您要使用的每个 Kamelet 所需的配置参数。
创建 Kamelet Bindings :
- 创建一个 Kamelet Binding,将源 Kamelet 连接到 Knative 频道(或代理)。
- 创建一个 Kamelet Binding,将 Knative 频道(或代理)连接到接收器 Kamelet。
- 另外,还可通过将一个或多个操作 Kamelets 作为 Kamelet Binding 中的中间步骤,在 Knative 频道(或代理)和数据源或接收器之间传输的数据。
- (可选)定义如何处理 Kamelet Binding 中的错误。
- 将 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。
流程
- 在 OpenShift Container Platform Web 控制台中,使用具有集群管理员权限的账户登录。
- 在左侧导航菜单中,点 Operators > OperatorHub。
-
在 Filter by keyword 文本框中,输入
Serverless
来查找 OpenShift Serverless Operator。 - 阅读 Operator 的信息,然后点 Install 以显示 Operator 订阅页面。
选择默认订阅设置:
- 更新频道 > 选择与您的 OpenShift 版本匹配的频道,如 4.12
- Installation Mode > All namespaces on the cluster
Approval Strategy > Automatic
注意如果您的环境需要,也可以使用 Approval Strategy > Manual 设置。
- 点 Install,然后等待几分钟,直到 Operator 准备就绪。
按照 OpenShift 文档中的步骤安装所需的 Knative 组件:
(可选)下载并安装 OpenShift Serverless CLI 工具:
- 在 OpenShift Web 控制台顶部的 Help 菜单(?)中选择 Command line tools。
- 向下滚动到 kn - OpenShift Serverless - 命令行界面 部分。
- 单击链接,以下载本地操作系统的二进制文件(Linux、Mac、Windows)
- 在您的系统路径中解压并安装 CLI。
要验证您可以访问
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 中创建应用程序和其他工作负载。
流程
- 登录您的 OpenShift 集群。
打开您要在其中创建集成应用程序的项目。例如:
oc project camel-k-knative
使用 Knative (
kn
) CLI 命令创建频道kn channel create <channel_name> --type <channel_type>
例如,要创建一个名为
mychannel
的频道:kn channel create mychannel --type messaging.knative.dev:v1:InMemoryChannel
要确认频道现在存在,请输入以下命令列出所有现有频道:
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 中创建应用程序和其他工作负载。
流程
- 登录您的 OpenShift 集群。
打开您要在其中创建集成应用程序的项目。例如:
oc project camel-k-knative
使用此 Knative (
kn
) CLI 命令创建代理:kn broker create default
要确认代理现在存在,请输入以下命令列出所有现有代理:
kn broker list
您应该在列表中看到 default 代理。
3.3. 在 Kamelet Binding 中将数据源连接到 Knative 目的地
要将数据源连接到 Knative 目的地(通道或代理),您可以创建一个 Kamelet Binding,如图 3.2 所示。
图 3.2 将数据源连接到 Knative 目的地
Knative 目的地可以是 Knative 频道或 Knative 代理。
当您向频道发送数据时,频道只有一个事件类型。您不需要在 Kamelet Binding 中为频道指定任何属性值。
当您向代理发送数据时,因为代理可以处理多个事件类型,所以您必须在 Kamelet Binding 中引用代理时为 type 属性指定一个值。
先决条件
您知道您要将事件发送到的 Knative 频道或代理的名称和类型。
此流程中的示例使用名为
mychannel
的InMemoryChannel
频道或名为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:
在您选择的编辑器中,使用以下基本结构创建一个 YAML 文件:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:
为 Kamelet Binding 添加名称。在本例中,名称为
coffees-to-knative
,因为绑定将coffee-source
Kamelet 连接到 Knative 目的地。Copy to Clipboard Copied! Toggle word wrap Toggle overflow apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: coffees-to-knative spec: source: sink:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: coffees-to-knative spec: source: sink:
对于 Kamelet Binding 的源,请指定数据源 Kamelet (例如,
coffee-source
Kamelet 会生成包含 coffee 的数据)的事件,并为 Kamelet 配置任何参数。Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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:
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:
对于 Kamelet Binding 的 sink,请指定 Knative 频道或代理以及所需的参数。
这个示例将 Knative 频道指定为接收器:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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
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 Copied! Toggle word wrap Toggle overflow 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
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
-
保存 YAML 文件(例如,
coffees-to-knative.yaml
)。 - 登录您的 OpenShift 项目。
将 Kamelet Binding 作为资源添加到 OpenShift 命名空间中:
oc apply -f <kamelet binding filename>
例如:
oc apply -f coffees-to-knative.yaml
Camel K operator 使用
KameletBinding
资源生成并运行 Camel K 集成。构建可能需要几分钟时间。查看
KameletBinding
的状态:oc get kameletbindings
查看其集成的状态:
oc get integrations
查看集成的日志:
kamel logs <integration> -n <project>
例如:
kamel logs coffees-to-knative -n my-camel-knative
另请参阅
3.4. 将 Knative 目的地连接到 Kamelet Binding 中的数据接收器
要将 Knative 目的地连接到数据接收器,您可以创建一个 Kamelet Binding,如图 3.3 所示。
图 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:
在您选择的编辑器中,使用以下基本结构创建一个 YAML 文件:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: spec: source: sink:
为 Kamelet Binding 添加名称。在本例中,名称为
knative-to-log
,因为绑定将 Knative 目的地连接到log-sink
Kamelet。Copy to Clipboard Copied! Toggle word wrap Toggle overflow apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: knative-to-log spec: source: sink:
apiVersion: camel.apache.org/v1alpha1 kind: KameletBinding metadata: name: knative-to-log spec: source: sink:
对于 Kamelet Binding 的源,指定 Knative 频道或代理以及所需的参数。
本例指定一个 Knative 频道作为源:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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:
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 Copied! Toggle word wrap Toggle overflow 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:
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:
对于 Kamelet Binding 的 sink,指定 data consumer Kamelet (如
log-sink
Kamelet)并为 Kamelet 配置任何参数,例如:Copy to Clipboard Copied! Toggle word wrap Toggle overflow 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
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
-
保存 YAML 文件(如
knative-to-log.yaml
)。 - 登录您的 OpenShift 项目。
将 Kamelet Binding 作为资源添加到 OpenShift 命名空间:
oc apply -f <kamelet binding filename>
例如:
oc apply -f knative-to-log.yaml
Camel K operator 使用
KameletBinding
资源生成并运行 Camel K 集成。构建可能需要几分钟时间。查看
KameletBinding
的状态:oc get kameletbindings
查看集成的状态:
oc get integrations
查看集成的日志:
kamel logs <integration> -n <project>
例如:
kamel 日志 knative-to-log -n my-camel-knative
在输出中,您应该看到 coffee 事件,例如:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow [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"}
[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"}
要停止正在运行的集成,请删除关联的 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 类型(
源
、sink
或action
)。 - 包含一组参数的定义(JSON-schema 规格),可用于配置 Kamelet。
-
一个
可选
type 部分,其中包含 Kamelet 期望的输入和输出信息。 - YAML DSL 中的 Camel 模板,用于定义 Kamelet 的实施。
下图显示了 Kamelet 及其部分的示例。
Kamelet 结构示例
telegram-text-source.kamelet.yaml apiVersion: camel.apache.org/v1alpha1 kind: Kamelet metadata: name: telegram-source annotations: 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: camel.apache.org/kamelet.type: "source" spec: definition: 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: out: mediaType: application/json dependencies: - "camel:jackson" - "camel:kamelet" - "camel:telegram" template: 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"
telegram-text-source.kamelet.yaml
apiVersion: camel.apache.org/v1alpha1
kind: Kamelet
metadata:
name: telegram-source
annotations:
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:
camel.apache.org/kamelet.type: "source"
spec:
definition:
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:
out:
mediaType: application/json
dependencies:
- "camel:jackson"
- "camel:kamelet"
- "camel:telegram"
template:
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"
- Kamelet ID - 当您想引用 Kamelet 时,在 Camel K 集成中使用此 ID。
- 注解(如 icon)为 Kamelet 提供显示功能。
- 标签允许用户查询 Kamelets (例如: kind: "source"、"sink" 或 "action")
- JSON-schema 规格格式的 Kamelet 和参数描述。
- 输出的介质类型(可以包含 schema)。
- 定义 Kamelet 行为的路由模板。
4.2. 源 Kamelet 示例
以下是 coffee-source
Kamelet 示例的内容:
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"
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"