红帽全球峰会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.Camel K 入门
开发并运行第一个 Camel K 应用程序
摘要
前言
使开源包含更多
红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。我们从这四个术语开始：master、slave、黑名单和白名单。由于此项工作十分艰巨，这些更改将在即将推出的几个发行版本中逐步实施。有关更多详情，请参阅我们的首席技术官 Chris Wright 提供的消息。
第 1 章 Camel K 简介
本章介绍了 Red Hat Integration - Camel K 提供的概念、功能和云原生架构：
1.1. Camel K 概述
Red Hat Integration - Camel K 是一个从 Apache Camel K 构建的轻量级集成框架，可在 OpenShift 上的云中原生运行。Camel K 是专为无服务器和微服务架构设计的。您可以使用 Camel K 立即运行在 OpenShift 上以 Camel 域特定语言(DSL)编写的集成代码。Camel K 是 Apache Camel 开源社区的子项目 ：https://github.com/apache/camel-k。
Camel K 使用 Go 编程语言实现，并使用 Kubernetes Operator SDK 在云中自动部署集成。例如，这包括在 OpenShift 上自动创建服务和路由。这在部署和重新部署集成时提供了更快的周转时间，如几秒或更短的分钟。
Camel K 运行时提供了显著的性能优化。默认启用 Quarkus 云原生 Java 框架，以便更快地启动时间，并降低内存和 CPU 占用量。在开发人员模式下运行 Camel K 时，您可以对集成 DSL 进行实时更新，并在 OpenShift 上的云中立即查看结果，而无需等待集成重新部署。
在 OpenShift Serverless 和 Knative Serving 中使用 Camel K，容器仅根据需要创建，并在负载或缩减到零下自动扩展。这降低了服务器置备和维护开销，并可让您专注于应用程序开发。
在 OpenShift Serverless 和 Knative Eventing 中使用 Camel K，您可以管理系统中的组件如何在用于无服务器应用程序的事件驱动的架构中进行通信。这通过使用发布订阅或事件流模式在事件制作者和消费者之间的分离关系，实现灵活性并提高效率。
1.2. Camel K 功能
Camel K 包括以下主要平台和功能：
1.2.1. 平台和组件版本
- OpenShift Container Platform 4.13, 4.14
- OpenShift Serverless 1.31.1
- Red Hat Build of Quarkus 2.13.8.Final-redhat-00006
- Red Hat Camel Extensions for Quarkus 2.13.3.redhat-00008
- Apache Camel K0.5.redhat-00002
- Apache Camel 3.18.6.redhat-00007
- OpenJDK 11
1.2.2. Camel K 功能
- 用于自动扩展和缩减至零的 Knative Serving
- 用于事件驱动的架构的 Knative Eventing
- 默认使用 Quarkus 运行时进行性能优化
- 使用 Java 或 YAML DSL 编写的 Camel 集成
- 使用 Visual Studio Code 的开发工具
- 使用 OpenShift 中的 Prometheus 监控集成
- Quickstart 教程
- kamelet 连接器目录到外部系统，如 AWS、JIRA 和 Salesforce
下图显示了 Camel K 云原生架构的简化视图：
其他资源
1.2.3. kamelets
kamelet 隐藏了在简单接口后连接到外部系统的复杂性，其中包含实例化它们所需的所有信息，即使用户不熟悉 Camel。
kamelets 作为自定义资源实施，您可以在 OpenShift 集群上安装并在 Camel K 集成中使用。kamelets 是使用 Camel 组件的路由模板，它们设计为连接到外部系统，而无需深入了解组件。Kamelets 对连接到外部系统的详细信息进行了抽象。您还可以组合 Kamelets 来创建复杂的 Camel 集成，就像使用标准 Camel 组件一样。
其他资源
1.3. Camel K 开发工具
Camel K 为 Visual Studio (VS) Code、Red Hat CodeReady WorkSpaces 和 Eclipse Che 提供开发工具扩展。基于 Camel 的工具扩展包括自动完成 Camel DSL 代码、Camel K 模式线配置和 Camel K traits 的功能。
可用的 VS Code 开发工具扩展如下：
红帽 Apache Camel 的 VS Code Extension Pack
- Apache Camel K 扩展的工具
- Apache Camel 扩展的语言支持
- Apache Camel K 的调试适配器
- OpenShift、Java 等的其他扩展
有关如何为 Camel K 设置这些 VS Code 扩展的详细信息，请参阅设置 Camel K 开发环境。
-
以下插件 VS Code Language support for Camel（Camel extension pack 的一部分）提供了在编辑 Camel 路由和
application.properties时提供内容协助。 - 要安装受支持的 Camel K 工具扩展，以便在 OpenShift 中创建、运行和操作 Camel K 集成，请参阅 红帽扩展为 Apache Camel K 的 VS Code 工具工具
- 要安装 VS 代码支持的 Camel 调试工具扩展，以调试以 Java、YAML 或 XML 在本地编写的 Camel 集成，请参阅 红帽 Apache Camel 的 Debug Adapter
- 有关将开发人员工具与特定产品版本搭配使用的详情，请参阅 Camel K 支持的配置 和 Camel K 组件详情
注： Camel K VS Code 扩展是社区功能。
Eclipse Che 还使用 vscode-camelk 插件提供这些功能。
1.4. Camel K 发行版
| 分发 | 描述 | 位置 |
|---|---|---|
| Operator 镜像 |
Red Hat Integration - Camel K Operator 的容器镜像： |
|
| Maven 存储库 | Red Hat Integration 的 Maven 工件 - Camel K 红帽提供了 Maven 存储库来托管我们随产品一起提供的内容。这些软件仓库可从软件下载页面下载。 对于 Red Hat Integration - Camel K 需要以下软件仓库：
不支持在断开连接的环境中安装 Red Hat Integration - Camel K （离线模式）。 | |
| 源代码 | Red Hat Integration 的源代码 - Camel K | |
| Quickstarts | 快速入门指南：
|
您必须有红帽构建的 Apache Camel K 订阅，并登录到红帽客户门户网站以访问 Red Hat Integration - Camel K 发行版。
第 2 章 准备 OpenShift 集群
本章介绍了如何在 OpenShift 上安装 Red Hat Integration - Camel K 和 OpenShift Serverless，以及如何在开发环境中安装所需的 Camel K 和 OpenShift Serverless 命令行客户端工具。
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 工具的功能。
注意You do not need to create a pull secret when installing Camel K from the OpenShift OperatorHub. The Camel K Operator automatically reuses the OpenShift cluster-level authentication to pull the Camel K image from `registry.redhat.io`.
-
已安装 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 卡。 - 阅读有关操作器的信息，然后单击 Install。Operator 安装页面将打开。
选择以下订阅设置：
- Update Channel > latest
在以下两个选项中选择：
- Installation Mode > A specific namespace on the cluster > my-camel-k-project
- Installation Mode > All namespaces on the cluster (default) > Openshift operator
注意If you do not choose among the above two options, the system by default chooses a global namespace on the cluster then leading to openshift operator.
Approval Strategy > Automatic
注意如果您的环境需要，还可以使用 Installation mode > All namespaces on the cluster and Approval Strategy > Manual 设置。
- 点 Install，等待片刻，直到 Camel K Operator 准备就绪。
下载并安装 Camel K CLI 工具：
- 从 OpenShift Web 控制台顶部的 帮助菜单(?)，选择 Command line tools。
- 向下滚动到 kamel - Red Hat Integration - Camel K - 命令行界面 部分。
- 点链接为您的本地操作系统(Linux、Mac、Windows)下载二进制文件。
- 在您的系统路径中解压并安装 CLI。
要验证您可以访问 Kamel K CLI，请打开一个命令窗口，然后键入以下内容：
kamel --help此命令显示有关 Camel K CLI 命令的信息。
如果您使用 OLM 从 OperatorHub 卸载 Camel K Operator，则不会删除 CRD。要切回到以前的 Camel K operator，您必须使用以下命令手动删除 CRD。
oc get crd -l app=camel-k -o name | xargs oc delete
后续步骤
（可选） 指定 Camel K 资源限值
2.1.1. 一致的集成平台设置
您可以创建命名空间本地集成 Platform 资源来覆盖 Operator 中使用的设置。
这些命名空间本地平台设置必须从 Operator 默认使用的 Integration Platform 中派生出来。也就是说，只有明确指定的设置会覆盖 Operator 中使用的平台默认值。
因此，您必须使用一致的平台设置层次结构，其中全局 operator 平台设置始终代表用户指定平台设置的基础。
- 对于全局 Camel K operator，如果 IntegrationPlatform 指定非默认 spec.build.buildStrategy，这个值也会传播到命名空间 Camel-K operator。
buildStrategy 的默认值为 routine。
$ oc get itp camel-k -o yaml -n openshift-operators apiVersion: camel.apache.org/v1 kind: IntegrationPlatform metadata: labels: app: camel-k name: camel-k namespace: openshift-operators spec: build: buildStrategy: pod全局 Operator 集成平台的参数 buildStrategy 可以通过以下任一方式编辑：
从仪表板中
- Administrator 视图： Operators → Installed operators → in namespace openshift-operators （即全局安装的 operator），选择 Red Hat Integration - Camel K → Integration Platform → YAML
- 现在添加或编辑（如果已存在）spec.build.buildStrategy: pod
- 点 Save
使用以下命令：之后安装的任何命名空间 Camel K operator 都会继承全局集成平台中的设置。
oc patch itp/camel-k -p '{"spec":{"build":{"buildStrategy": "pod"}}}' --type merge -n openshift-operators
2.1.2. 指定 Camel K 资源限值
安装 Camel K 时，Camel K 的 OpenShift pod 不会为 CPU 和内存(RAM)资源设置任何限制。如果要为 Camel K 定义资源限值，您必须编辑在安装过程中创建的 Camel K 订阅资源。
前提条件
- 具有安装 Camel K Operator 的 OpenShift 项目的集群管理员访问权限，如 安装 Camel K 所述。
您知道要应用到 Camel K 订阅的资源限值。有关资源限值的更多信息，请参阅以下文档：
流程
- 登录 OpenShift Web 控制台。
- 选择 Operators > Installed Operators > Operator Details > Subscription。
选择 Actions > Edit Subscription。
订阅的文件在 YAML 编辑器中打开。
在
spec部分，添加一个config.resources部分，并为 memory 和 cpu 提供值，如下例所示：spec: channel: default config: resources: limits: memory: 512Mi cpu: 500m requests: cpu: 200m memory: 128Mi- 保存您的更改。
OpenShift 更新订阅并应用您指定的资源限值。
我们建议您只通过 全局 安装安装 Camel K Operator。
2.2. 安装 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.16
- Installation Mode > All namespaces on the cluster
Approval Strategy > Automatic
注意如果您的环境需要，还可以使用 Approval Strategy > Manual 设置。
- 点 Install，然后等待 Operator 准备就绪。
使用 OpenShift 文档中的步骤安装所需的 Knative 组件：
（可选）下载并安装 OpenShift Serverless CLI 工具：
- 从 OpenShift Web 控制台顶部的帮助菜单(?)，选择 Command line tools。
- 向下滚动到 kn - OpenShift Serverless - Command Line Interface 部分。
- 点链接下载本地操作系统(Linux、Mac、Windows)的二进制代码。
- 在您的系统路径中解压并安装 CLI。
要验证您可以访问
knCLI，请打开一个命令窗口，然后键入以下内容：kn --help此命令显示有关 OpenShift Serverless CLI 命令的信息。
如需了解更多详细信息，请参阅 OpenShift Serverless CLI 文档。
2.3. 为 Camel K 配置 Maven 存储库
对于 Camel K operator，您可以在 ConfigMap 或 secret 中提供 Maven 设置。
流程
要从文件创建
ConfigMap，请运行以下命令：oc create configmap maven-settings --from-file=settings.xml
然后，可在
IntegrationPlatform资源中从spec.build.maven.settings字段中引用创建的ConfigMap。示例
apiVersion: camel.apache.org/v1 kind: IntegrationPlatform metadata: name: camel-k spec: build: maven: settings: configMapKeyRef: key: settings.xml name: maven-settings或者，您可以直接编辑
IntegrationPlatform资源来引用包含 Maven 设置的 ConfigMap：oc edit itp camel-k
为远程 Maven 存储库配置 CA 证书
您可以在 Secret 中提供 CA 证书，供 Maven 命令用于连接远程 Maven 存储库。
流程
使用以下命令，从文件创建 Secret：
oc create secret generic maven-ca-certs --from-file=ca.crt
从
spec.build.maven.caSecret字段中引用IntegrationPlatform资源中创建的 Secret，如下所示。apiVersion: camel.apache.org/v1 kind: IntegrationPlatform metadata: name: camel-k spec: build: maven: caSecret: key: tls.crt name: tls-secret
2.4. Camel K offline
Camel K 是自然而开发的，以适合"开放世界"集群模型。这意味着默认安装假设它可以从互联网拉取和推送资源。但是，在某些域或用例中可能会存在限制。以下是如何在离线（或断开连接）集群环境中设置 Camel K 的详情。
要求
- 在 OLM 模式中断开连接的 openshift 4.14+ 集群上安装 Camel K 1.10.7。
- 使用 maven 存储库管理器在同一集群中运行集成，为 maven 工件提供服务。
超出范围
- 支持安装和管理 maven 存储库管理器。
- 使用 maven 工件挂载卷
-
使用-
-offlinemaven 参数。 - 如何在断开连接的环境中安装或配置 OCP。
假设
- 在断开连接的环境中 配置了现有 OCP 4.14+ 集群。
- 现有容器镜像 registry。
- 现有的 maven 存储库管理器。
- 在 linux 机器中执行命令步骤。
先决条件
- 熟悉 Camel K 网络架构。
让我们在此处查看图表。
我们可识别那些需要访问互联网的组件，并单独对待它们：镜像 registry 和 maven 构建。
2.4.1. 容器镜像 registry
容器 registry 是负责托管从操作器构建的容器的组件，供集群用来运行 Camel 应用程序。此组件可以由集群开箱即用提供，或者应由您执行（请参阅有关 如何运行您自己的注册表的指南）。
正如我们在断开连接的环境中一样，我们假定此组件可以被集群访问（通过 IP 或 URL）。但是，集群必须使用 Camel K 容器镜像 才能安装。您必须确保集群 registry 已预加载 Camel K 容器镜像，该镜像应该类似于 registry.redhat.io/integration/camel-k-rhel8-operator-bundle:1.10.7
在 生态系统目录中 定义红帽容器镜像，请参阅 Get this image 选项卡，然后在 Manifest List Digest 字段中看到容器镜像摘要地址：
OpenShift 提供了用于镜像容器镜像的文档。在镜像容器镜像时，您必须确保在其操作过程中包括 Camel K 所需的以下容器镜像，请注意，在断开连接的集群中，我们必须使用摘要 URL 而不是标签。对于红帽提供的容器镜像，请访问红帽生态系统目录，查找容器镜像并复制容器镜像的摘要 URL。https://catalog.redhat.com/search?searchType=containers
-
registry.redhat.io/integration/camel-k-rhel8-operator:1.10.7 -
registry.redhat.io/integration/camel-k-rhel8-operator-bundle:1.10.7 -
registry.redhat.io/quarkus/mandrel-23-rhel8:23.0 -
registry.access.redhat.com/ubi8/openjdk-11:1.20
Camel K 1.10.7: registry.redhat.io/integration/camel-k-rhel8-operator-bundle@sha256:a043af04c9b816f0dfd5db64ba69bae192d73dd726df83aaf2002559a111a786的摘要 URL 示例
如果设置了以上所有内容，那么您还必须准备好从 Camel K 中的容器 registry 中拉取和推送。
2.4.1.1. 创建自己的 CatalogSource
安装 Camel K Operator 的唯一方法是来自 OperatorHub。由于我们使用断开连接的环境，所以无法下载 redhat-operators CatalogSource 中的容器镜像。因此，我们必须创建自己的 CatalogSource 来从 OperatorHub 安装 Camel K operator。
Operator Catalog 有镜像(mirror)，用于镜像 CatalogSource。
但是，这种方法可以仅使用 Camel K Bundle Metadata 容器镜像来设置一个自定义 CatalogSource。
先决条件
- 所需工具
- 镜像可在 registry 中访问
- Camel K Operator 和 Camel K Operator Bundle 带有 sha256 标签。
2.4.1.1.1. 创建自己的索引镜像捆绑包(IIB)
首先，我们需要使用内部的一个运算符创建自己的 IIB 镜像。
没有 operator 升级。
设置
- 仅使用一个捆绑包在本地创建 IIB （使用 sha tag）：
opm index add --bundles {CAMEL_K_OPERATOR_BUNDLE_WITH_SHA_TAG} --tag {YOUR_CONTAINER_STORAGE}/{USERNAME}/{IMAGE_NAME}:{TAG} --mode=semver例如：
opm index add --bundles registry.redhat.io/integration/camel-k-rhel8-operator-bundle@sha256:a043af04c9b816f0dfd5db64ba69bae192d73dd726df83aaf2002559a111a786 --tag my-custom-registry/mygroup/ck-iib:1.10.7 --mode=semver
- 检查镜像是否已创建。
podman images
- 推送到 registry。
podman push {YOUR_CONTAINER_STORAGE}/{USERNAME}/{IMAGE_NAME}:{TAG}例如：
podman push my-custom-registry/mygroup/ck-iib:1.10.7
2.4.1.1.2. 创建自己的目录源
创建 yaml 文件，即 myCatalogSource.yaml，其中包含以下内容：
apiVersion: operators.coreos.com/v1alpha1
kind: CatalogSource
metadata:
name: {CATALOG_SOURCE_NAME}
namespace: openshift-marketplace
spec:
displayName: {NAME_WHICH_WILL_BE_DISPLAYED_IN_OCP}
publisher: grpc
sourceType: grpc
image: {YOUR_CONTAINER_STORAGE}/{USERNAME}/{IMAGE_NAME}:{SHA_TAG}}例如：
apiVersion: operators.coreos.com/v1alpha1 kind: CatalogSource metadata: name: camel-k-source-1.10 namespace: openshift-marketplace spec: displayName: Camel K Offline publisher: grpc sourceType: grpc image: ec2-1-111-111-111.us-east-1.compute.amazonaws.com:5000/myrepository/ckiib@sha256:f67fc953b10729e49bf012329fbfb6352b91bbc7d4b1bcdf5779f6d31c397c5c
使用 oc 工具登录到 Openshift:
Oc login -u {USER} -p {PASS} https://api.{YOUR_CLUSTER_API_URL}:6443将 CatalogSource 部署到 openshift-marketplace 命名空间：
oc apply -f myCatalogSource.yaml -n openshift-marketplace
打开 Openshift Web 控制台，进入到 OperatorHub，选择 Camel K Offline Source，然后在右侧选择 "Red Hat Integration - Camel K" 并安装它。
2.4.2. Maven 构建配置
本指南是帮助最终用户创建 maven 离线捆绑包并能够在离线模式下运行 Camel K 的最佳开发过程。但是，由于安装拓扑高度的灵活性，我们无法提供任何级别的支持，因此只有对可能配置的指导。另外，考虑到在流程中下载的第三方依赖关系的数量，我们无法确保任何影响这些第三方库的 CVE 的保护。最好使用。
该流程包含一个脚本，用于解析、下载并打包 Maven 所需的所有 Camel K Runtime 及其传输依赖项集合，以构建和运行 camel 集成。
它需要运行脚本（如机器）的 Maven 版本与 Camel K operator 中使用的相同，即 Maven 3.6.3，这将确保具有正确的依赖项版本。
Operator 期望依赖项归 1001 用户所有。因此，请确保此类用户执行该脚本以避免因为特权错误而出现 maven 构建失败。
脚本的输出是一个 tar.gz 文件，其中包含 Maven 期望的所有依赖项树，允许目标构建系统（即 Camel K operator）。
它可能无法在 Quarkus 原生模式下工作，因为原生构建可能需要捆绑包中没有的额外依赖项。
2.4.2.1. Offliner 脚本
该脚本位于 Camel K github 存储库中。
您可以按照以下方式运行：
./offline_dependencies.sh usage: ./script/offline_dependencies.sh -v <Camel K Runtime version> [optional parameters] -v <Camel K Runtime version> - Camel K Runtime Version -m </usr/share/bin/mvn> - Path to mvn command -r <http://my-repo.com> - URL address of the maven repository manager -d </var/tmp/offline-1.2> - Local directory to add the offline dependencies -s - Skip Certificate validation
示例运行示例：
./offline_dependencies.sh -v 1.15.6.redhat-00029 -r https://maven.repository.redhat.com/ga -d camel-k-offline -s
如何知道正确的 Camel K Runtime 版本？您应该查看 Openshift 集群中的 IntegrationPlatform/camel-k 自定义资源对象，查找 runtimeVersion 字段，例如：
oc get integrationplatform/camel-k -oyaml|grep runtimeVersion
如果有 maven 代理，可能需要大约 30 分钟才能解决。所有打包的依赖关系都位于 tar.gz 文件中。这是一个大型文件，因为它包含 camel-k-catalog 中配置的所有 Camel 组件 所需的所有传输依赖关系。
2.4.2.2. 将依赖项上传到 Maven 代理服务器
我们建议的最佳实践是始终使用 Maven 代理。这也是离线安装的情况。在这种情况下，您可以检查 Maven Repository Manager 文档，并验证如何使用上面章节中创建的文件上传依赖项。
构建集成路由时，构建应使用 maven 代理，因此需要自定义 maven settings.xml 配置为镜像所有 maven 存储库才能通过 maven 代理。
获取 maven 代理的 URL，并在 url 字段中设置，如下例所示：
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 https://maven.apache.org/xsd/settings-1.0.0.xsd"> <mirrors> <mirror> <id>local-central-mirror</id> <name>local-central-mirror</name> <mirrorOf>*</mirrorOf> <url>http://my-maven-proxy:8080/releases</url> </mirror> </mirrors> </settings>
从这个 maven settings.xml 创建 ConfigMap。
kubectl create configmap local-maven-settings-offline --from-file=settings.xml=maven-settings-offline.xml
现在，您必须在构建集成时通知 Camel K 来使用这个 settings.xml。
如果您已经安装了 Camel K，您可以修补 IntegrationPlatform/camel-k，验证您用于自定义名称和命名空间的环境：
kubectl patch itp/camel-k --type=merge -p '{"spec": {"build": {"maven": {"settings": {"configMapKeyRef": {"key": "settings.xml", "name": "local-maven-settings-offline"}}}}}}'
然后，您应该能够运行与 kamel run my-integration.java 的集成，并遵循 camel-k-operator 日志。
kubectl logs -f `kubectl get pod -l app=camel-k -oname`
2.4.2.3. 故障排除
2.4.2.3.1. 下载依赖项时出错
检查 maven 存储库管理器是否可从 camel-k-operator 日志访问。
进入 camel-k-operator 日志
kubectl -n openshift-operators exec -i -t `kubectl -n openshift-operators get pod -l app=camel-k -oname` -- bash
并使用 curl 下载 maven 工件
curl http://my-maven-proxy:8080/my-artifact.jar -o file
2.4.2.3.2. 未找到依赖项
可能会发生在 maven 代理管理器中找到特定的 maven 工件，因为离线脚本无法解析和下载依赖项，因此您必须下载该依赖项并上传到 maven 代理管理器。
第 3 章 开发并运行 Camel K 集成
本章介绍了如何设置开发环境以及如何开发和部署使用 Java 和 YAML 编写的简单 Camel K 集成。它还演示了如何使用 kamel 命令行在运行时管理 Camel K 集成。例如，这包括运行、描述、日志记录和删除集成。
3.1. 设置 Camel K 开发环境
您必须先使用推荐的开发工具设置您的环境，然后才能自动部署 Camel K 快速启动指南。本节介绍如何安装推荐的 Visual Studio (VS) Code IDE 及其为 Camel K 提供的扩展。
- Camel K VS Code 扩展是社区功能。
- 建议 VS Code 易于使用，以及 Camel K 的最佳开发人员体验。这包括自动完成 Camel DSL 代码和 Camel K traits。但是，您可以使用您选择的 IDE 而不是 VS Code 手动输入您的代码和教程命令。
先决条件
您必须有权访问安装 Camel K Operator 和 OpenShift Serverless Operator 的 OpenShift 集群：
流程
在您的开发平台上安装 VS Code。例如，在 Red Hat Enterprise Linux 中：
安装所需的密钥和存储库：
$ sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc $ sudo sh -c 'echo -e "[code]\nname=Visual Studio Code\nbaseurl=https://packages.microsoft.com/yumrepos/vscode\nenabled=1\ngpgcheck=1\ngpgkey=https://packages.microsoft.com/keys/microsoft.asc" > /etc/yum.repos.d/vscode.repo'
更新缓存并安装 VS Code 软件包：
$ yum check-update $ sudo yum install code
有关在其他平台上安装的详情，请查看 VS Code 安装文档。
-
输入
code命令启动 VS Code 编辑器。如需了解更多详细信息，请参阅 VS Code 命令行文档。 安装 VS Code Camel Extension Pack，其中包含 Camel K 所需的扩展。例如，在 VS Code 中：
- 在左侧导航栏中，单击 Extensions。
- 在搜索框中，输入 Apache Camel。
选择 Extension Pack for Apache Camel by Red Hat，然后单击 Install。
详情请查看 红帽为 Apache Camel 扩展包的说明。
其他资源
- VS Code 入门文档
- 红帽扩展为 Apache Camel K 的 VS Code 工具
- 红帽扩展为 Apache Camel 的 VS Code 语言支持
- Apache Camel K 和 VS Code 工具示例
- 要将 Camel 应用程序从 Camel 3.x 升级到 3.y，请参阅 Camel 3.x 升级指南。
3.2. 在 Java 中开发 Camel K 集成
本节介绍如何在 Java DSL 中开发简单的 Camel K 集成。使用 Camel K 编写 Java 集成与在 Camel 中定义路由规则相同。但是，在使用 Camel K 时，您不需要构建并打包集成为 JAR。
您可以在集成路由中直接使用任何 Camel 组件。Camel K 会自动处理依赖项管理，并使用代码检查从 Camel 目录中导入所有必要的库。
先决条件
流程
输入
camel init命令来生成简单的 Java 集成文件。例如：$ camel init HelloCamelK.java
在 IDE 中打开生成的集成文件，并根据需要编辑。例如，
HelloCamelK.java集成自动包含 Camel计时器和日志组件，以帮助您开始：// camel-k: language=java import org.apache.camel.builder.RouteBuilder; public class HelloCamelK extends RouteBuilder { @Override public void configure() throws Exception { // Write your routes here, for example: from("timer:java?period=1s") .routeId("java") .setBody() .simple("Hello Camel K from ${routeId}") .to("log:info"); } }
后续步骤
3.3. 在 YAML 中开发 Camel K 集成
本节介绍如何在 YAML DSL 中开发一个简单的 Camel K 集成。在 YAML 中编写集成以使用 Camel K 部署，与在 Camel 中定义路由规则相同。
您可以在集成路由中直接使用任何 Camel 组件。Camel K 会自动处理依赖项管理，并使用代码检查从 Camel 目录中导入所有必要的库。
先决条件
流程
输入
camel init命令来生成简单的 YAML 集成文件。例如：$ camel init hello.camelk.yaml
在 IDE 中打开生成的集成文件，并根据需要编辑。例如，
hello.camelk.yaml集成自动包含 Camel计时器和日志组件，以帮助您开始：# Write your routes here, for example: - from: uri: "timer:yaml" parameters: period: "1s" steps: - set-body: constant: "Hello Camel K from yaml" - to: "log:info"
3.4. 运行 Camel K 集成
您可以使用 kamel run 命令在 OpenShift 集群的云中运行 Camel K 集成。
先决条件
- 设置 Camel K 开发环境.
- 您必须已经有一个使用 Java 或 YAML DSL 编写的 Camel 集成。
流程
使用
oc客户端工具登录到 OpenShift 集群，例如：$ oc login --token=my-token --server=https://my-cluster.example.com:6443
确保 Camel K Operator 正在运行，例如：
$ oc get pod NAME READY STATUS RESTARTS AGE camel-k-operator-86b8d94b4-pk7d6 1/1 Running 0 6m28s
输入
kamel run命令，以在 OpenShift 上的云中运行您的集成。例如：Java 示例
$ kamel run HelloCamelK.java integration "hello-camel-k" created
YAML 示例
$ kamel run hello.camelk.yaml integration "hello" created
输入
kamel get命令检查集成的状态：$ kamel get NAME PHASE KIT hello Building Kit myproject/kit-bq666mjej725sk8sn12g
当集成首次运行时，Camel K 为容器镜像构建集成工具包，它会下载所有所需的 Camel 模块，并将它们添加到镜像类路径中。
再次输入
kamel get来验证集成是否正在运行：$ kamel get NAME PHASE KIT hello Running myproject/kit-bq666mjej725sk8sn12g
输入
kamel log命令，将日志输出到stdout：$ kamel log hello [1] 2021-08-11 17:58:40,573 INFO [org.apa.cam.k.Runtime] (main) Apache Camel K Runtime 1.7.1.fuse-800025-redhat-00001 [1] 2021-08-11 17:58:40,653 INFO [org.apa.cam.qua.cor.CamelBootstrapRecorder] (main) bootstrap runtime: org.apache.camel.quarkus.main.CamelMainRuntime [1] 2021-08-11 17:58:40,844 INFO [org.apa.cam.k.lis.SourcesConfigurer] (main) Loading routes from: SourceDefinition{name='camel-k-embedded-flow', language='yaml', location='file:/etc/camel/sources/camel-k-embedded-flow.yaml', } [1] 2021-08-11 17:58:41,216 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Routes startup summary (total:1 started:1) [1] 2021-08-11 17:58:41,217 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Started route1 (timer://yaml) [1] 2021-08-11 17:58:41,217 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Apache Camel 3.10.0.fuse-800010-redhat-00001 (camel-1) started in 136ms (build:0ms init:100ms start:36ms) [1] 2021-08-11 17:58:41,268 INFO [io.quarkus] (main) camel-k-integration 1.6.6 on JVM (powered by Quarkus 1.11.7.Final-redhat-00009) started in 2.064s. [1] 2021-08-11 17:58:41,269 INFO [io.quarkus] (main) Profile prod activated. [1] 2021-08-11 17:58:41,269 INFO [io.quarkus] (main) Installed features: [camel-bean, camel-core, camel-k-core, camel-k-runtime, camel-log, camel-support-common, camel-timer, camel-yaml-dsl, cdi] [1] 2021-08-11 17:58:42,423 INFO [info] (Camel (camel-1) thread #0 - timer://yaml) Exchange[ExchangePattern: InOnly, BodyType: String, Body: Hello Camel K from yaml] ...-
按
Ctrl-C终止终端中的日志记录。
其他资源
-
有关
kamel run命令的详情，请输入kamel run --help - 有关更快的部署周转时间，请参阅 在开发模式下运行 Camel K 集成
- 有关运行集成的开发工具的详情，请参阅 红帽为 Apache Camel K 的 VS Code 工具
- 另请参阅 管理 Camel K 集成
运行没有 CLI 的集成
您可以在没有 CLI （命令行接口）的情况下运行集成，并使用配置创建 集成自定义资源 来运行应用程序。
例如，执行以下示例路由。
kamel run Sample.java -o yaml
它返回预期的集成自定义资源。
apiVersion: camel.apache.org/v1
kind: Integration
metadata:
creationTimestamp: null
name: my-integration
namespace: default
spec:
sources:
- content: "
import org.apache.camel.builder.RouteBuilder;
public class Sample extends RouteBuilder {
@Override
public void configure()
throws Exception {
from(\"timer:tick\")
.log(\"Hello Integration!\");
}
}"
name: Sample.java
status: {}
将此自定义资源保存在 yaml 文件中 my-integration.yaml 中。现在，使用 oc 命令行、UI 或 API 调用 OpenShift 集群运行包含 Integration 自定义资源的集成。在以下示例中，oc CLI 从命令行使用。
oc apply -f my-integration.yaml ... integration.camel.apache.org/my-integration created
Operator 运行 Integration。
- Kubernetes 支持 CustomResourceDefinitions 的 Structural Schemas。
- 有关 Camel K traits 的详情，请参阅 Camel K trait 配置参考。
自定义资源的 schema 更改
强烈输入的 Trait API 对以下 CustomResourceDefinitions 施加更改： integrations、integrationkits' 和 'integrationplatforms。
现在，spec.traits.<traits.<trait-id>.configuration 下的 trait 属性直接在 spec.traits.<trait-id> 下定义。
traits:
container:
configuration:
enabled: true
name: my-integration↓↓↓
traits:
container:
enabled: true
name: my-integration
在这种实现中，可以向后兼容。为实现向后兼容，为每个特征类型提供 Configuration 字段和 RawMessage 类型，以便从现有集成和资源从 Apache Camel K 版本的新构建中读取。
读取旧集成和资源时，每个特征（若有）中的传统配置都会迁移到新的 Trait API 字段中。如果在新的 API 字段中预定义了值，它们会在旧的 API 字段前面。
type Trait struct {
// Can be used to enable or disable a trait. All traits share this common property.
Enabled *bool `property:"enabled" json:"enabled,omitempty"`
// Legacy trait configuration parameters.
// Deprecated: for backward compatibility.
Configuration *Configuration `json:"configuration,omitempty"`
}
// Deprecated: for backward compatibility.
type Configuration struct {
RawMessage `json:",inline"`
}3.5. 在开发模式下运行 Camel K 集成
您可以从命令行在 OpenShift 集群中以开发模式运行 Camel K 集成。使用开发模式，您可以快速迭代开发集成并快速获得对代码的反馈。
当您使用-- dev 选项指定 kamel run 命令时，这将立即在云中部署集成，并在终端中显示集成日志。然后，您可以更改代码，并查看立即应用到 OpenShift 上的远程集成 Pod 的更改。终端会自动显示云中远程集成的所有重新部署。
在开发模式中由 Camel K 生成的工件与您在生产环境中运行的工件相同。开发模式的目的是加快开发速度。
先决条件
- 设置 Camel K 开发环境.
- 您必须已经有一个使用 Java 或 YAML DSL 编写的 Camel 集成。
流程
使用
oc客户端工具登录到 OpenShift 集群，例如：$ oc login --token=my-token --server=https://my-cluster.example.com:6443
确保 Camel K Operator 正在运行，例如：
$ oc get pod NAME READY STATUS RESTARTS AGE camel-k-operator-86b8d94b4-pk7d6 1/1 Running 0 6m28s
输入
kamel run命令 with-dev，以在云中在 OpenShift 上的开发模式下运行集成。下面显示了一个一个简单的 Java 示例：$ kamel run HelloCamelK.java --dev Condition "IntegrationPlatformAvailable" is "True" for Integration hello-camel-k: test/camel-k Integration hello-camel-k in phase "Initialization" Integration hello-camel-k in phase "Building Kit" Condition "IntegrationKitAvailable" is "True" for Integration hello-camel-k: kit-c49sqn4apkb4qgn55ak0 Integration hello-camel-k in phase "Deploying" Progress: integration "hello-camel-k" in phase Initialization Progress: integration "hello-camel-k" in phase Building Kit Progress: integration "hello-camel-k" in phase Deploying Integration hello-camel-k in phase "Running" Condition "DeploymentAvailable" is "True" for Integration hello-camel-k: deployment name is hello-camel-k Progress: integration "hello-camel-k" in phase Running Condition "CronJobAvailable" is "False" for Integration hello-camel-k: different controller strategy used (deployment) Condition "KnativeServiceAvailable" is "False" for Integration hello-camel-k: different controller strategy used (deployment) Condition "Ready" is "False" for Integration hello-camel-k Condition "Ready" is "True" for Integration hello-camel-k [1] Monitoring pod hello-camel-k-7f85df47b8-js7cb ... ... [1] 2021-08-11 18:34:44,069 INFO [org.apa.cam.k.Runtime] (main) Apache Camel K Runtime 1.7.1.fuse-800025-redhat-00001 [1] 2021-08-11 18:34:44,167 INFO [org.apa.cam.qua.cor.CamelBootstrapRecorder] (main) bootstrap runtime: org.apache.camel.quarkus.main.CamelMainRuntime [1] 2021-08-11 18:34:44,362 INFO [org.apa.cam.k.lis.SourcesConfigurer] (main) Loading routes from: SourceDefinition{name='HelloCamelK', language='java', location='file:/etc/camel/sources/HelloCamelK.java', } [1] 2021-08-11 18:34:46,180 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Routes startup summary (total:1 started:1) [1] 2021-08-11 18:34:46,180 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Started java (timer://java) [1] 2021-08-11 18:34:46,180 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Apache Camel 3.10.0.fuse-800010-redhat-00001 (camel-1) started in 243ms (build:0ms init:213ms start:30ms) [1] 2021-08-11 18:34:46,190 INFO [io.quarkus] (main) camel-k-integration 1.6.6 on JVM (powered by Quarkus 1.11.7.Final-redhat-00009) started in 3.457s. [1] 2021-08-11 18:34:46,190 INFO [io.quarkus] (main) Profile prod activated. [1] 2021-08-11 18:34:46,191 INFO [io.quarkus] (main) Installed features: [camel-bean, camel-core, camel-java-joor-dsl, camel-k-core, camel-k-runtime, camel-log, camel-support-common, camel-timer, cdi] [1] 2021-08-11 18:34:47,200 INFO [info] (Camel (camel-1) thread #0 - timer://java) Exchange[ExchangePattern: InOnly, BodyType: String, Body: Hello Camel K from java] [1] 2021-08-11 18:34:48,180 INFO [info] (Camel (camel-1) thread #0 - timer://java) Exchange[ExchangePattern: InOnly, BodyType: String, Body: Hello Camel K from java] [1] 2021-08-11 18:34:49,180 INFO [info] (Camel (camel-1) thread #0 - timer://java) Exchange[ExchangePattern: InOnly, BodyType: String, Body: Hello Camel K from java] ...编辑集成 DSL 文件的内容，保存您的更改，并查看终端中显示的更改。例如：
... integration "hello-camel-k" updated ... [2] 2021-08-11 18:40:54,173 INFO [org.apa.cam.k.Runtime] (main) Apache Camel K Runtime 1.7.1.fuse-800025-redhat-00001 [2] 2021-08-11 18:40:54,209 INFO [org.apa.cam.qua.cor.CamelBootstrapRecorder] (main) bootstrap runtime: org.apache.camel.quarkus.main.CamelMainRuntime [2] 2021-08-11 18:40:54,301 INFO [org.apa.cam.k.lis.SourcesConfigurer] (main) Loading routes from: SourceDefinition{name='HelloCamelK', language='java', location='file:/etc/camel/sources/HelloCamelK.java', } [2] 2021-08-11 18:40:55,796 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Routes startup summary (total:1 started:1) [2] 2021-08-11 18:40:55,796 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Started java (timer://java) [2] 2021-08-11 18:40:55,797 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Apache Camel 3.10.0.fuse-800010-redhat-00001 (camel-1) started in 174ms (build:0ms init:147ms start:27ms) [2] 2021-08-11 18:40:55,803 INFO [io.quarkus] (main) camel-k-integration 1.6.6 on JVM (powered by Quarkus 1.11.7.Final-redhat-00009) started in 3.025s. [2] 2021-08-11 18:40:55,808 INFO [io.quarkus] (main) Profile prod activated. [2] 2021-08-11 18:40:55,809 INFO [io.quarkus] (main) Installed features: [camel-bean, camel-core, camel-java-joor-dsl, camel-k-core, camel-k-runtime, camel-log, camel-support-common, camel-timer, cdi] [2] 2021-08-11 18:40:56,810 INFO [info] (Camel (camel-1) thread #0 - timer://java) Exchange[ExchangePattern: InOnly, BodyType: String, Body: Hello Camel K from java] [2] 2021-08-11 18:40:57,793 INFO [info] (Camel (camel-1) thread #0 - timer://java) Exchange[ExchangePattern: InOnly, BodyType: String, Body: Hello Camel K from java] ...-
按
Ctrl-C终止终端中的日志记录。
其他资源
-
有关
kamel run命令的详情，请输入kamel run --help - 有关运行集成的开发工具的详情，请参阅 红帽为 Apache Camel K 的 VS Code 工具
- 管理 Camel K 集成
- 配置 Camel K 集成依赖项
3.6. 使用模式行运行 Camel K 集成
您可以使用 Camel K modeline 在 Camel K 集成源文件中指定多个配置选项，该文件在运行时执行。这通过保存重新输入多个命令行选项的时间来提高效率，并有助于防止输入错误。
以下示例显示了 Java 集成文件中的 modeline 条目，它启用了 3scale 并限制集成容器内存。
先决条件
- 设置 Camel K 开发环境
- 您必须已经有一个使用 Java 或 YAML DSL 编写的 Camel 集成。
流程
在您的集成文件中添加 Camel K modeline 条目。例如：
ThreeScaleRest.java
// camel-k: trait=3scale.enabled=true trait=container.limit-memory=256Mi 1 import org.apache.camel.builder.RouteBuilder; public class ThreeScaleRest extends RouteBuilder { @Override public void configure() throws Exception { rest().get("/") .to("direct:x"); from("direct:x") .setBody().constant("Hello"); } }启用容器和 3scale 特征，以通过 3scale 公开路由并限制容器内存。
运行集成，例如：
kamel run ThreeScaleRest.java
kamel run命令输出集成中指定的任何模式命令行选项，例如：Modeline options have been loaded from source files Full command: kamel run ThreeScaleRest.java --trait=3scale.enabled=true --trait=container.limit-memory=256Mi
其他资源
- Camel K modeline 选项
- 有关运行模式线集成的开发工具的详情，请参阅 对 Apache Camel K Modeline 的 IDE 支持。
3.7. Camel Runtimes (aka "sourceless" Integrations)
Camel K 可以运行 Apache Camel 中可用的任何运行时。但是，只有在之前构建了 Camel 应用程序并打包到容器镜像中时，才能执行此操作。另外，如果您通过此选项运行，Operator 提供的一些功能可能不可用。例如，您无法发现 Camel 功能，因为源不适用于 Operator，但嵌入在容器镜像中。
如果您要在外部构建应用程序（即通过 CICD 技术），并且您希望仅委派操作器"运行"部分，请小心操作自己的构建和发布部分。
您可以松散更多功能，如增量镜像和容器工具包可重复利用。
3.7.1. 在外部构建，通过 Operator 运行
让我们来看看以下示例。
您可以拥有自己的 Camel 应用程序，或者只是通过 Camel JBang 创建基础(camel init test.yaml)。一旦开发结束，您可以通过 camel run test.yaml 在本地测试，并通过 camel export test.yaml --runtime … 在您选择的运行时导出。
上面的步骤是在任何可用的运行时中创建基本 Camel 应用程序的一种快速方法。假设我们为 Camel Main 进行了这一操作，或者我们已将 Camel 应用程序作为 Maven 项目。当我们希望处理构建部分时，我们创建一个管道来构建、容器化并将容器推送到注册表（请参阅作为参考 Camel K Tekton 示例）。
在这个阶段，我们使用 Camel 应用程序有一个容器镜像。我们可以使用 kamel CLI 通过 kamel run --image docker.io/my-org/my-app:1.0.0 调优来运行 Camel 应用程序（如果这是这种情况），其中包含所需的任何特征或配置。请记住，当您使用此选项运行集成时，Operator 会创建一个 复合 集成Kit。
在外部运行应用时，某些特征（即 builder 特征）不可用。
在几秒钟（没有涉及构建）中，您必须启动并运行应用程序，您可以像通常一样监控和操作 Camel K。
3.7.2. 遍历和依赖项
某些 Camel K 操作方面可能由特征驱动。当您在 Operator 外部构建应用程序时，不会执行其中的一些特征，因为它们在运行 无源 集成时跳过的构建阶段执行。
3.8. 导入现有 Camel 应用程序
您已在集群中运行了 Camel 应用程序，并且您已通过手动部署、CICD 或已有的任何其他部署机制创建它。由于 Camel K 操作器旨在在其中操作任何 Camel 应用程序，因此您可以使用类似的 Camel K 受管集成 方式导入它并监控。
此功能默认为禁用。要启用它，您必须使用环境变量 CAMEL_K_SYNTHETIC_INTEGRATIONS 运行 Operator 部署，设置为 true。
您只能监控 synthetic Integrations。Camel K 不会更改非受管集成（即，重建原始应用程序）的生命周期。
Operator 不会更改原始应用程序的任何字段，以避免破坏任何已存在的部署流程。由于它不能对应用程序的构建和部署方式做出任何假设，因此只能监控它所发生的任何更改。
3.8.1. 在外部部署，通过 Camel K Operator 监控
导入的集成称为 synthetic Integration。您可以导入部署为 Deployment、CronJob 或 Knative Service 的任何 Camel 应用程序。我们通过一个标签(camel.apache.org/integration)来控制用户必须应用到 Camel 应用程序（手动或引入部署过程中，即通过 CICD）。
以下示例使用 CronJob 和 Knative Service 的类似方法工作。
例如，我们演示了如何导入使用 Deployment kind 部署的 Camel 应用程序。让我们假定这名为 my-deploy。
$ oc label deploy my-camel-sb-svc camel.apache.org/integration=my-it
Operator 会立即创建一个合成集成。
$ oc get it NAMESPACE NAME PHASE RUNTIME PROVIDER RUNTIME VERSION KIT REPLICAS test-79c385c3-d58e-4c28-826d-b14b6245f908 my-it Running
您可以看到，它处于 Running 状态。但是，在检查条件后，您现在可以看到集成还没有完全监控。这是正常的，因为 Camel K operator 监控 Pod 的方式。它要求生成的 Pod 继承应用到 Deployment 的相同标签。因此，除了标记 Deployment 外，我们还必须在 Deployment 模板中添加一个标签。
$ oc patch deployment my-camel-sb-svc --patch '{"spec": {"template": {"metadata": {"labels": {"camel.apache.org/integration": "my-it"}}}}}'此操作也可以在部署过程中手动执行或自动执行。现在，我们可以看到操作器能够监控 Pod 的状态。
$ oc get it NAMESPACE NAME PHASE RUNTIME PROVIDER RUNTIME VERSION KIT REPLICAS test-79c385c3-d58e-4c28-826d-b14b6245f908 my-it Running 1
现在，您可以在与受管集成相关的类似方法中监控 synthetic Integration 的状态。例如，如果您的 Deployment 扩展或缩减，您会看到此信息会相应反映。
$ oc scale deployment my-camel-sb-svc --replicas 2 $ oc get it NAMESPACE NAME PHASE RUNTIME PROVIDER RUNTIME VERSION KIT REPLICAS test-79c385c3-d58e-4c28-826d-b14b6245f908 my-it Running 2
3.9. Build
构建 资源描述了整合容器镜像的过程，该镜像与 集成 或集成Kit 的要求一致。
构建的结果是 IntegrationKit，必须为多个集成 重复使用。
type Build struct {
Spec BuildSpec 1
Status BuildStatus 2
}
type BuildSpec struct {
Tasks []Task 3
}完整的 go 定义 可在此处找到。
3.9.1. 构建策略
您可以从不同的构建策略中选择。构建策略定义如何执行构建，并如下为可用的策略：
- buildStrategy: pod （每个构建都在一个单独的 pod 中运行，Operator 会监控 pod 状态）
- buildStrategy: routine （每个构建都作为 Operator pod 中的 go routine 运行）
例行 程序是默认策略。
以下描述允许您决定何时使用哪些策略。
例行 ：提供稍快的构建，因为没有额外的 pod，并在构建之间缓存载入的构建依赖项（如 Maven 依赖项）。适用于要执行的正常构建，且只能并行运行几个构建。
Pod ：防止 Operator 上的内存压力，因为构建不会消耗 Operator 的 CPU 和内存。适合被执行的许多构建以及许多并行构建。
3.9.2. 构建队列
对于多个集成，必须重复使用 IntegrationKits 及其基础镜像，以完成有效的资源管理，并为 Camel K 集成优化构建和启动时间。
要重复使用镜像，Operator 将按顺序排序到队列构建。这样，Operator 能够将高效的镜像分层用于集成。
默认情况下，构建会根据其布局（如原生、fast-jar）和构建命名空间按顺序排队。
但是，构建可能不会按顺序运行，但会根据特定条件相互并行运行。
- 例如，原生构建始终与其他构建并行运行。
- 另外，当构建需要使用自定义集成平台运行时，它可以与使用默认操作器集成平台运行的其他构建并行运行。
- 通常，当无法重复使用构建的镜像层时，构建会期望与其他构建并行运行。
因此，为了避免并行运行许多构建，Operator 使用最大数量的运行构建设置来限制正在运行的构建量。
您可以在 IntegrationPlatform 设置中设置这个限制。
此限制的默认值基于构建策略。
- buildStrategy: pod (MaxRunningBuilds=10)
- buildStrategy: routine (MaxRunningBuilds=3)
3.10. 跨环境提升
当一个集成在集群中运行后，您可以将该集成移到更高的环境中。也就是说，您可以 在开发环境中 测试集成，并在获得结果后进行测试，您可以将其移到 生产环境中。
Camel K 使用 kamel promote 命令实现此目标。通过此命令，您可以将集成从一个命名空间移到另一个命名空间。
先决条件
- 设置 Camel K 开发环境
- 您必须已经有一个使用 Java 或 YAML DSL 编写的 Camel 集成。
-
确保源 Operator 和目标 Operator 使用相同的容器 registry，默认 registry （如果通过 OperatorHub 安装 Camel K operator）是
registry.redhat.io - 另外，确保目标命名空间提供集成所需的 Configmaps、Secret 或 Kamelets。
要使用相同的容器 registry，您可以在安装过程中使用-- registry 选项或更改 IntegrationPlatform 以反应它们。
代码示例
以下是一个简单的集成，它使用 Configmap 在 HTTP 端点上公开一些消息。您可以在名为
development的命名空间中创建这样的集成测试和测试。kubectl create configmap my-cm --from-literal=greeting="hello, I am development!" -n development
PromoteServer.java
import org.apache.camel.builder.RouteBuilder; public class PromoteServer extends RouteBuilder { @Override public void configure() throws Exception { from("platform-http:/hello?httpMethodRestrict=GET").setBody(simple("resource:classpath:greeting")); } }现在运行它。
kamel run --dev -n development PromoteServer.java --config configmap:my-cm [-t service.node-port=true]
您必须调整服务特征，具体取决于 Kubernetes 平台和您要提供的暴露级别。之后，您可以对其进行测试。
curl http://192.168.49.2:32116/hello hello, I am development!
测试集成后，您可以将其移到生产环境中。您必须具有目标环境(Open Openshift 命名空间)与操作器（共享相同的 operator 源容器 registry）和任何配置（如此处使用的 configmap）就绪。对于该范围，请在目标命名空间中创建一个。
kubectl create configmap my-cm --from-literal=greeting="hello, I am production!" -n production
注意为了安全起见，需要检查来确保目的地上存在预期的资源，如 Configmaps、Secret 和 Kamelets。如果缺少这些资源，则集成不会移动。
现在，您可以推广您的集成。
kamel promote promote-server -n development --to production kamel logs promote-server -n production
测试升级的集成。
curl http://192.168.49.2:30764/hello hello, I am production!
由于集成正在重复使用同一容器镜像，因此新的应用会立即执行。另外，集成的不可变性也保证，因为所使用的容器与开发中测试的容器完全相同（更改只是配置）。
注意测试中运行的集成不会以任何方式更改，并在停止之前继续运行。
第 4 章 升级 Camel K
您可以自动升级安装的 Camel K operator，但它不会自动升级 Camel K 集成。您必须手动触发 Camel K 集成升级。本章介绍了如何升级 Camel K operator 和 Camel K 集成。
4.1. 升级 Camel K operator
安装的 Camel K operator 的订阅指定一个更新频道，如 1.10.x 频道，用于跟踪和接收 Operator 的更新。要升级 Operator 以开始跟踪并从更新频道接收更新，您可以更改订阅中的更新频道。如需有关更改 已安装 Operator 的更新频道的更多信息，请参阅升级已安装的 Operator。
- 安装的 Operator 无法变为比当前频道旧的频道。
如果订阅中的批准策略被设置为 Automatic，则升级过程会在所选频道中提供新的 Operator 版本时立即启动。如果批准策略设为 Manual，则必须手动批准待处理的升级。
先决条件
- Camel K operator 使用 Operator Lifecycle Manager (OLM)安装。
流程
- 在 OpenShift Container Platform web 控制台的 Administrator 视角中，进入 Operators → Installed Operators。
- 点 Camel K Operator。
- 点 Subscription 标签页。
- 点 Channel 中的更新频道的名称。
-
点击您要更改的更新频道。例如，
latest。点击 Save。这将开始升级到最新的 Camel K 版本。
对于带有 自动批准策略 的订阅，升级会自动开始。返回到 Operators → Installed Operators 页面，以监控升级的进度。完成后，状态将变为 Succeeded 和 Up to date。
对于采用手动批准策略的订阅，您可以从 Subscription 选项卡中手动批准升级。
4.2. 升级 Camel K 集成
当您为 Camel K operator 触发升级时，Operator 会准备要升级的集成，但不会逐一触发升级，以避免服务中断。当升级 Operator 时，集成自定义资源不会自动升级到较新的版本，例如，Operator 可能处于 1.10.3 版本，而集成会报告自定义资源的 status.version 字段为以前的版本 1.8.2。
先决条件
使用 Operator Lifecycle Manager (OLM)安装和升级 Camel K operator。
流程
- 打开终端并运行以下命令来升级 Camel K intergations。
kamel rebuild myintegration
这将清除集成资源的状态，Operator 将利用来自升级版本的工件（如 1.10.3 ）开始部署集成。
4.3. 降级 Camel K
您可以通过安装之前版本的 Operator 来降级到旧版本的 Camel K operator。这需要使用 OC CLI 手动触发。有关使用 CLI 安装特定版本的 Operator 的更多信息，请参阅安装 Operator 的特定版本。
您必须删除现有 Camel K operator，然后安装 Operator 的 specifc 版本，因为 OLM 不支持降级。
安装旧版本的 operator 后，使用 kamel rebuild 命令将集成降级到 Operator 版本。例如，
kamel rebuild myintegration
第 5 章 Camel K quick start developer tutorials
Red Hat Integration - Camel K 根据 https://github.com/openshift-integration 提供的集成用例提供快速启动开发人员指南。本章详细介绍了如何设置和部署以下教程：
5.1. 部署基本 Camel K Java 集成
本教程介绍了如何在 OpenShift 上的云中运行简单的 Java 集成，将配置和路由应用到集成，并运行作为 Kubernetes CronJob 的集成。
先决条件
- 请参阅 GitHub 中的教程 readme。
-
您必须已安装了 Camel K operator 和
kamelCLI。请参阅安装 Camel K。 - Visual Studio (VS) Code 是可选的，但建议获得最佳开发人员体验。请参阅 设置 Camel K 开发环境。
流程
克隆教程 Git 存储库。
$ git clone git@github.com:openshift-integration/camel-k-example-basic.git
- 在 VS Code 中，选择 File → Open Folder → camel-k-example-basic。
-
在 VS Code 导航树中，单击
readme.md文件。这会在 VS Code 中打开一个新标签页，以显示教程说明。 按照教程说明操作。
或者，如果您没有安装 VS Code，您可以手动输入 部署基本 Camel K Java 集成的命令。
5.2. 部署 Camel K Serverless 与 Knative 集成
本教程介绍了如何在事件驱动的架构中部署 Camel K 与 OpenShift Serverless 集成。本教程使用 Knative Eventing 代理在 Bitcoin 交易演示中使用事件发布订阅模式进行通信。
本教程还介绍了如何使用 Camel K 集成连接到使用多个外部系统的 Knative 事件网格。Camel K 集成还根据需要使用 Knative Serving 来自动扩展和缩减到零。
先决条件
- 请参阅 GitHub 中的教程 readme。
您必须具有 OpenShift 集群的集群管理员访问权限才能安装 Camel K 和 OpenShift Serverless：
- Visual Studio (VS) Code 是可选的，但建议获得最佳开发人员体验。请参阅 设置 Camel K 开发环境。
流程
克隆教程 Git 存储库：
$ git clone git@github.com:openshift-integration/camel-k-example-knative.git
- 在 VS Code 中，选择 File → Open Folder → camel-k-example-knative。
-
在 VS Code 导航树中，单击
readme.md文件。这会在 VS Code 中打开一个新标签页，以显示教程说明。 按照教程说明操作。
如果您没有安装 VS Code，您可以手动输入 部署 Camel K Knative 集成的命令。
5.3. 部署 Camel K 转换集成
本教程演示了如何在 OpenShift 上运行 Camel K Java 集成，它将 XML 等数据转换为 JSON，并将其存储在 PostgreSQL 等数据库中。
教程示例使用 CSV 文件查询 XML API，并使用收集的数据来构建有效的 GeoJSON 文件，该文件存储在 PostgreSQL 数据库中。
先决条件
- 请参阅 GitHub 中的教程 readme。
- 您必须具有 OpenShift 集群的集群管理员访问权限才能安装 Camel K。请参阅 安装 Camel K。
- 您必须按照教程 readme 中的说明来安装 Crunchy Postgres for Kubernetes，这在 OpenShift 集群中是必需的。
- Visual Studio (VS) Code 是可选的，但建议获得最佳开发人员体验。请参阅 设置 Camel K 开发环境。
流程
克隆教程 Git 存储库：
$ git clone git@github.com:openshift-integration/camel-k-example-transformations.git
- 在 VS Code 中，选择 File → Open Folder → camel-k-example-transformations。
-
在 VS Code 导航树中，单击
readme.md文件。这会在 VS Code 中打开一个新标签页，以显示教程说明。 按照教程说明操作。
如果您没有安装 VS Code，您可以手动输入 部署 Camel K 转换集成的命令。
5.4. 部署 Camel K Serverless 事件流集成
本教程演示了在 Knative Eventing 中使用 Camel K 和 OpenShift Serverless 进行事件驱动的架构。
教程介绍了如何在带有 AMQ Broker 集群的 AMQ Streams 集群中安装 Camel K 和 Serverless，以及如何部署 event streaming 项目来运行全局 hazard 警报演示应用程序。
先决条件
- 请参阅 GitHub 中的教程 readme。
您必须具有 OpenShift 集群的集群管理员访问权限才能安装 Camel K 和 OpenShift Serverless：
您必须遵循教程 readme 中的说明，才能在 OpenShift 集群上安装额外的所需 Operator：
- AMQ Streams Operator
- AMQ Broker Operator
- Visual Studio (VS) Code 是可选的，但建议获得最佳开发人员体验。请参阅 设置 Camel K 开发环境。
流程
克隆教程 Git 存储库。
$ git clone git@github.com:openshift-integration/camel-k-example-event-streaming.git
- 在 VS Code 中，选择 File → Open Folder → camel-k-example-event-streaming。
-
在 VS Code 导航树中，单击
readme.md文件。这会在 VS Code 中打开一个新标签页，以显示教程说明。 按照教程说明操作。
或者，如果您没有安装 VS Code，您可以手动输入 部署 Camel K 事件流集成的命令。
5.5. 部署基于 Camel K Serverless API 的集成
本教程演示了使用带有 Knative Serving 的 Camel K 和 OpenShift Serverless 进行基于 API 的集成，以及管理 OpenShift 中使用 3scale API Management 的 API。
教程介绍了如何配置基于 Amazon S3 的存储，设计 OpenAPI 定义，并运行调用演示 API 端点的集成。
先决条件
- 请参阅 GitHub 中的教程 readme。
您必须具有 OpenShift 集群的集群管理员访问权限才能安装 Camel K 和 OpenShift Serverless：
- 您还可以在 OpenShift 系统上安装可选的 Red Hat Integration - 3scale Operator 来管理 API。请参阅使用 Operator 部署 3scale。
- Visual Studio (VS) Code 是可选的，但建议获得最佳开发人员体验。请参阅 设置 Camel K 开发环境。
流程
克隆教程 Git 存储库。
$ git clone git@github.com:openshift-integration/camel-k-example-api.git
- 在 VS Code 中，选择 File → Open Folder → camel-k-example-api。
-
在 VS Code 导航树中，单击
readme.md文件。这会在 VS Code 中打开一个新标签页，以显示教程说明。 按照教程说明操作。
或者，如果您没有安装 VS Code，您可以手动输入 部署 Camel K API 集成的命令。
5.6. 部署 Camel K SaaS 集成
本教程介绍了如何在 OpenShift 上运行 Camel K Java 集成，该集成连接两个广泛使用的软件作为服务(SaaS)供应商。
教程示例演示了如何使用基于 REST 的 Camel 组件集成 Salesforce 和 ServiceNow SaaS 供应商。在这个简单示例中，每个新的 Salesforce 问题单被复制到包含 Salesforce 问题单号的相应 ServiceNow 事件中。
先决条件
- 请参阅 GitHub 中的教程 readme。
- 您必须具有 OpenShift 集群的集群管理员访问权限才能安装 Camel K。请参阅 安装 Camel K。
- 您必须有 Salesforce 登录凭证和 ServiceNow 登录凭证。
- Visual Studio (VS) Code 是可选的，但建议获得最佳开发人员体验。请参阅 设置 Camel K 开发环境。
流程
克隆教程 Git 存储库：
$ git clone git@github.com:openshift-integration/camel-k-example-saas.git
- 在 VS Code 中，选择 File → Open Folder → camel-k-example-saas。
-
在 VS Code 导航树中，单击
readme.md文件。这会在 VS Code 中打开一个新标签页，以显示教程说明。 按照教程说明。
如果您没有安装 VS Code，您可以手动输入 部署 Camel K SaaS 集成的命令。
5.7. 部署 Camel K JDBC 集成
本教程介绍了如何通过 JDBC 驱动程序开始使用 Camel K 和 SQL 数据库。本教程介绍了如何将生成数据整合到 Postgres 数据库中（您可以使用您选择的任何关系数据库）以及如何从同一数据库读取数据。
先决条件
- 请参阅 GitHub 中的教程 readme。
您必须具有 OpenShift 集群的集群管理员访问权限才能安装 Camel K。
- 您必须按照教程 readme 中的说明来安装 Crunchy Postgres for Kubernetes，这在 OpenShift 集群中是必需的。
- Visual Studio (VS) Code 是可选的，但建议获得最佳开发人员体验。请参阅 设置 Camel K 开发环境。
流程
克隆教程 Git 存储库。
$ git clone git@github.com:openshift-integration/camel-k-example-jdbc.git
- 在 VS Code 中，选择 File → Open Folder → camel-k-example-jdbc。
-
在 VS Code 导航树中，单击
readme.md文件。这会在 VS Code 中打开一个新标签页，以显示教程说明。 按照教程说明操作。
或者，如果您没有安装 VS Code，您可以手动输入 部署 Camel K JDBC 集成的命令。
5.8. 部署 Camel K JMS 集成
本教程介绍了如何使用 JMS 连接到消息代理，以便使用和生成消息。有两个示例：
- JMS Sink：本教程介绍了如何向 JMS 代理生成消息。
- JMS Source：本教程演示了如何使用 JMS 代理的消息。
先决条件
- 请参阅 GitHub 中的教程 readme。
您必须具有 OpenShift 集群的集群管理员访问权限才能安装 Camel K。
- Visual Studio (VS) Code 是可选的，但建议获得最佳开发人员体验。请参阅 设置 Camel K 开发环境。
流程
克隆教程 Git 存储库：
$ git clone git@github.com:openshift-integration/camel-k-example-jms.git
- 在 VS Code 中，选择 File → Open Folder → camel-k-example-jms。
-
在 VS Code 导航树中，单击
readme.md文件。这会在 VS Code 中打开一个新标签页，以显示教程说明。 按照教程说明操作。
如果您没有安装 VS Code，您可以手动输入 部署 Camel K JMS 集成的命令。
其他资源
5.9. 部署 Camel K Kafka 集成
本教程演示了如何在 Apache Kafka 中使用 Camel K。本教程介绍了如何通过 Red Hat OpenShift Streams for Apache Kafka 设置 Kafka 主题，并与 Camel K 一起使用。
先决条件
- 请参阅 GitHub 中的教程 readme。
您必须具有 OpenShift 集群的集群管理员访问权限才能安装 Camel K。
- Visual Studio (VS) Code 是可选的，但建议获得最佳开发人员体验。请参阅 设置 Camel K 开发环境。
流程
克隆教程 Git 存储库：
$ git clone git@github.com:openshift-integration/camel-k-example-kafka.git
- 在 VS Code 中，选择 File → Open Folder → camel-k-example-kafka。
-
在 VS Code 导航树中，单击
readme.md文件。这会在 VS Code 中打开一个新标签页，以显示教程说明。 按照教程说明操作。
如果您没有安装 VS Code，您可以手动输入 部署 Camel K Kafka 集成的命令。
