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 集成
您可以使用 Camel K 命令行或使用开发工具来管理红帽集成 - Camel K 集成。本章介绍了如何在命令行中管理 Camel K 集成,并提供有关如何使用 VS Code 开发工具的其他资源链接。
1.1. 管理 Camel K 集成
Camel K 提供了在命令行中管理 OpenShift 集群上的 Camel K 集成的不同选项。本节演示了使用以下命令的简单示例:
-
kamel get
-
kamel describe
-
kamel 日志
-
kamel delete
前提条件
- 设置 Camel K 开发环境
- 您必须具有用 Java 或 YAML DSL 编写的 Camel 集成
流程
确保 Camel K Operator 在您的 OpenShift 集群上运行,例如:
oc get pod
NAME READY STATUS RESTARTS AGE camel-k-operator-86b8d94b4-pk7d6 1/1 Running 0 6m28s
输入
kamel run
命令,在 OpenShift 上的云中运行您的集成。例如:kamel run hello.camelk.yaml
integration "hello" created
输入
kamel get
命令检查集成状态:kamel get
NAME PHASE KIT hello Building Kit kit-bqatqib5t4kse5vukt40
输入
kamel describe
命令来打印有关集成的详细信息:kamel describe integration hello
Name: hello Namespace: myproject Creation Timestamp: Fri, 13 Aug 2021 16:23:21 +0200 Phase: Building Kit Runtime Version: 1.7.1.fuse-800025-redhat-00001 Kit: myproject/kit-c4ci6mbe9hl5ph5c9sjg Image: Version: 1.6.6 Dependencies: camel:core camel:log camel:timer mvn:org.apache.camel.k:camel-k-runtime mvn:org.apache.camel.quarkus:camel-quarkus-yaml-dsl Sources: Name Language Compression Ref Ref Key camel-k-embedded-flow.yaml yaml false Conditions: Type Status Reason Message IntegrationPlatformAvailable True IntegrationPlatformAvailable myproject/camel-k IntegrationKitAvailable True IntegrationKitAvailable kit-c4ci6mbe9hl5ph5c9sjg CronJobAvailable False CronJobNotAvailableReason different controller strategy used (deployment) DeploymentAvailable True DeploymentAvailable deployment name is hello KnativeServiceAvailable False KnativeServiceNotAvailable different controller strategy used (deployment) Ready True ReplicaSetReady
输入
kamel log
命令,将日志输出到stdout
:kamel log hello
... [1] 2021-08-13 14:37:15,860 INFO [info] (Camel (camel-1) thread #0 - timer://yaml) Exchange[ExchangePattern: InOnly, BodyType: String, Body: Hello Camel K from yaml] ...
-
按
Ctrl-C
在终端中终止登录。 输入
kamel delete
以删除 OpenShift 中部署的集成:kamel delete hello
Integration hello deleted
其他资源
- 有关日志记录的详情,请参阅管理 Camel K 集成日志记录级别
- 有关更快速的部署周转时间,请参阅 在开发模式下运行 Camel K 集成
- 有关管理集成的开发工具的详情,请参阅 Red Hat Apache Camel K 的 VS Code 工具
1.2. 管理 Camel K 集成日志级别
Camel K 使用 Quarkus 日志记录机制作为集成的日志框架。您可以在运行时在命令行中配置不同日志记录器的日志记录级别,方法是将 quarkus.log.category
前缀指定为集成属性。例如:
Example
--property 'quarkus.log.category."org".level'=DEBUG
务必要用单引号转义 属性。
前提条件
流程
输入
kamel run
命令并使用--property
选项指定日志级别。例如:kamel run --dev --property 'quarkus.log.category."org.apache.camel.support".level'=DEBUG Basic.java ... integration "basic" created Progress: integration "basic" in phase Initialization Progress: integration "basic" in phase Building Kit Progress: integration "basic" in phase Deploying Condition "IntegrationPlatformAvailable" is "True" for Integration basic: myproject/camel-k Integration basic in phase "Initialization" Integration basic in phase "Building Kit" Integration basic in phase "Deploying" Condition "IntegrationKitAvailable" is "True" for Integration basic: kit-c4dn5l62v9g3aopkocag Condition "DeploymentAvailable" is "True" for Integration basic: deployment name is basic Condition "CronJobAvailable" is "False" for Integration basic: different controller strategy used (deployment) Progress: integration "basic" in phase Running Condition "KnativeServiceAvailable" is "False" for Integration basic: different controller strategy used (deployment) Integration basic in phase "Running" Condition "Ready" is "False" for Integration basic Condition "Ready" is "True" for Integration basic [1] Monitoring pod basic-575b97f64b-7l5rl [1] 2021-08-17 08:35:22,906 DEBUG [org.apa.cam.sup.LRUCacheFactory] (main) Creating DefaultLRUCacheFactory [1] 2021-08-17 08:35:23,132 INFO [org.apa.cam.k.Runtime] (main) Apache Camel K Runtime 1.7.1.fuse-800025-redhat-00001 [1] 2021-08-17 08:35:23,134 INFO [org.apa.cam.qua.cor.CamelBootstrapRecorder] (main) bootstrap runtime: org.apache.camel.quarkus.main.CamelMainRuntime [1] 2021-08-17 08:35:23,224 INFO [org.apa.cam.k.lis.SourcesConfigurer] (main) Loading routes from: SourceDefinition{name='Basic', language='java', location='file:/etc/camel/sources/Basic.java', } [1] 2021-08-17 08:35:23,232 DEBUG [org.apa.cam.sup.ResolverHelper] (main) Found RoutesBuilderLoader: org.apache.camel.dsl.java.joor.JavaRoutesBuilderLoader via: META-INF/services/org/apache/camel/java [1] 2021-08-17 08:35:23,232 DEBUG [org.apa.cam.sup.ResolverHelper] (main) Detected and using RoutesBuilderLoader: org.apache.camel.dsl.java.joor.JavaRoutesBuilderLoader@68dc098b [1] 2021-08-17 08:35:23,236 DEBUG [org.apa.cam.sup.ResolverHelper] (main) Found ResourceResolver: org.apache.camel.impl.engine.DefaultResourceResolvers$FileResolver via: META-INF/services/org/apache/camel/file [1] 2021-08-17 08:35:23,237 DEBUG [org.apa.cam.sup.ResolverHelper] (main) Detected and using ResourceResolver: org.apache.camel.impl.engine.DefaultResourceResolvers$FileResolver@5b67bb7e [1] 2021-08-17 08:35:24,320 DEBUG [org.apa.cam.sup.ResolverHelper] (main) Lookup Language with name simple in registry. Found: org.apache.camel.language.simple.SimpleLanguage@74d7184a [1] 2021-08-17 08:35:24,328 DEBUG [org.apa.cam.sup.EventHelper] (main) Ignoring notifying event Initializing CamelContext: camel-1. The EventNotifier has not been started yet: org.apache.camel.quarkus.core.CamelManagementEventBridge@3301500b [1] 2021-08-17 08:35:24,336 DEBUG [org.apa.cam.sup.ResolverHelper] (main) Lookup Component with name timer in registry. Found: org.apache.camel.component.timer.TimerComponent@3ef41c66 [1] 2021-08-17 08:35:24,342 DEBUG [org.apa.cam.sup.DefaultComponent] (main) Creating endpoint uri=[timer://java?period=1000], path=[java] [1] 2021-08-17 08:35:24,350 DEBUG [org.apa.cam.sup.ResolverHelper] (main) Found ProcessorFactory: org.apache.camel.processor.DefaultProcessorFactory via: META-INF/services/org/apache/camel/processor-factory [1] 2021-08-17 08:35:24,351 DEBUG [org.apa.cam.sup.ResolverHelper] (main) Detected and using ProcessorFactory: org.apache.camel.processor.DefaultProcessorFactory@704b2127 [1] 2021-08-17 08:35:24,369 DEBUG [org.apa.cam.sup.ResolverHelper] (main) Found InternalProcessorFactory: org.apache.camel.processor.DefaultInternalProcessorFactory via: META-INF/services/org/apache/camel/internal-processor-factory [1] 2021-08-17 08:35:24,369 DEBUG [org.apa.cam.sup.ResolverHelper] (main) Detected and using InternalProcessorFactory: org.apache.camel.processor.DefaultInternalProcessorFactory@4f8caaf3 [1] 2021-08-17 08:35:24,442 DEBUG [org.apa.cam.sup.ResolverHelper] (main) Lookup Component with name log in registry. Found: org.apache.camel.component.log.LogComponent@46b695ec [1] 2021-08-17 08:35:24,444 DEBUG [org.apa.cam.sup.DefaultComponent] (main) Creating endpoint uri=[log://info], path=[info] [1] 2021-08-17 08:35:24,461 DEBUG [org.apa.cam.sup.EventHelper] (main) Ignoring notifying event Initialized CamelContext: camel-1. The EventNotifier has not been started yet: org.apache.camel.quarkus.core.CamelManagementEventBridge@3301500b [1] 2021-08-17 08:35:24,467 DEBUG [org.apa.cam.sup.DefaultProducer] (main) Starting producer: Producer[log://info] [1] 2021-08-17 08:35:24,469 DEBUG [org.apa.cam.sup.DefaultConsumer] (main) Build consumer: Consumer[timer://java?period=1000] [1] 2021-08-17 08:35:24,475 DEBUG [org.apa.cam.sup.DefaultConsumer] (main) Starting consumer: Consumer[timer://java?period=1000] [1] 2021-08-17 08:35:24,481 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Routes startup summary (total:1 started:1) [1] 2021-08-17 08:35:24,481 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Started java (timer://java) [1] 2021-08-17 08:35:24,482 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Apache Camel 3.10.0.fuse-800010-redhat-00001 (camel-1) started in 170ms (build:0ms init:150ms start:20ms) [1] 2021-08-17 08:35:24,487 INFO [io.quarkus] (main) camel-k-integration 1.6.6 on JVM (powered by Quarkus 1.11.7.Final-redhat-00009) started in 2.192s. [1] 2021-08-17 08:35:24,488 INFO [io.quarkus] (main) Profile prod activated. [1] 2021-08-17 08:35:24,488 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-17 08:35:25,493 INFO [info] (Camel (camel-1) thread #0 - timer://java) Exchange[ExchangePattern: InOnly, BodyType: String, Body: Hello Camel K from java] [1] 2021-08-17 08:35:26,479 INFO [info] (Camel (camel-1) thread #0 - timer://java) Exchange[ExchangePattern: InOnly, BodyType: String, Body: Hello Camel K from java] ...
-
按
Ctrl-C
在终端中终止登录。
其他资源
- 有关日志记录框架的详情,请参阅配置日志记录格式
- 有关查看日志的开发工具详情,请参阅 Red Hat Apache Camel K 的 VS Code 工具
1.3. 扩展 Camel K 集成
您可以使用 oc scale
命令扩展您的集成。
流程
若要扩展 Camel K 集成,请运行以下命令:
oc scale it <integration_name> --replicas <number_of_replicas>
您还可以直接编辑集成资源来扩展集成。
oc patch it <integration_name> --type merge -p '{"spec":{"replicas":<number_of_replicas>}}'
要查看集成的副本数,请使用以下命令:
oc get it <integration_name> -o jsonpath='{.status.replicas}'
第 2 章 监控 Camel K 集成
Red Hat Integration - Camel K 监控基于 OpenShift 监控系统。本章论述了如何使用可用选项来监控 Red Hat Integration - Camel K 在运行时集成。您可以使用作为 OpenShift Monitoring 的一部分部署的 Prometheus Operator 来监控您自己的应用程序。
2.1. 在 OpenShift 中启用用户工作负载监控
OpenShift 4.3 或更高版本包括已作为 OpenShift Monitoring 的一部分部署的嵌入式 Prometheus Operator。本节介绍如何在 OpenShift Monitoring 中启用对您自己的应用程序服务的监控。这个选项避免了安装和管理独立 Prometheus 实例的额外开销。
前提条件
- 您必须具有安装 Camel K Operator 的 OpenShift 集群的集群管理员访问权限。请参阅安装 Camel K。
流程
输入以下命令检查
openshift-monitoring 项目中是否存在
ConfigMap 对象:cluster-monitoring-
config$ oc -n openshift-monitoring get configmap cluster-monitoring-config
如果尚不存在,请创建
cluster-monitoring-config
ConfigMap:$ oc -n openshift-monitoring create configmap cluster-monitoring-config
编辑
cluster-monitoring-config
ConfigMap:$ oc -n openshift-monitoring edit configmap cluster-monitoring-config
在
data:config.yaml
下,将enableUserWorkload
设置为true
:apiVersion: v1 kind: ConfigMap metadata: name: cluster-monitoring-config namespace: openshift-monitoring data: config.yaml: | enableUserWorkload: true
其他资源
2.2. 配置 Camel K 集成指标
您可以在运行时使用 Camel K Prometheus trait 配置 Camel K 集成监控。这会自动配置依赖项和集成 Pod,以公开指标端点,该端点由 Prometheus 发现并显示。Camel Quarkus MicroProfile 指标扩展 自动收集并公开 OpenMetrics 格式的默认 Camel K 指标。
前提条件
- 您必须在 OpenShift 中启用对您自己的服务的监控。请参阅 在 OpenShift 中启用用户工作负载监控。
流程
输入以下命令运行与启用 Prometheus 特征的 Camel K 集成:
kamel run myIntegration.java -t prometheus.enabled=true
另外,您可以通过更新集成平台进行全局启用 Prometheus 特征,如下所示:
$ oc patch ip camel-k --type=merge -p '{"spec":{"traits":{"prometheus":{"configuration":{"enabled":true}}}}}'
- 查看 Prometheus 中的 Camel K 集成指标监控。例如,对于嵌入式 Prometheus,在 OpenShift 管理员或开发者 Web 控制台中选择 Monitoring > Metrics。
-
输入您要查看的 Camel K 指标。例如,在 Administrator 控制台中,在 Cursor 的 Insert Metric at Cursor 下输入
application_camel_context_uptime_seconds
,然后单击 Run Queries。 - 点 Add Query 查看其他指标。
2.3. 添加自定义 Camel K 集成指标
您可以使用 Camel MicroProfile Metrics 组件和 Java 代码中的注解将自定义指标添加到 Camel K 集成中。然后 Prometheus 将自动发现和显示这些自定义指标。
本节演示了将 Camel MicroProfile 指标注释添加到 Camel K 集成和服务实施代码的示例。
前提条件
- 您必须在 OpenShift 中启用对您自己的服务的监控。请参阅 在 OpenShift 中启用用户工作负载监控。
流程
使用 Camel MicroProfile Metrics 组件注释,在您的 Camel 集成代码中注册自定义指标。以下示例显示了
Metrics.java
集成:// camel-k: language=java trait=prometheus.enabled=true dependency=mvn:org.my/app:1.0 1 import org.apache.camel.Exchange; import org.apache.camel.LoggingLevel; import org.apache.camel.builder.RouteBuilder; import org.apache.camel.component.microprofile.metrics.MicroProfileMetricsConstants; import javax.enterprise.context.ApplicationScoped; @ApplicationScoped public class Metrics extends RouteBuilder { @Override public void configure() { onException() .handled(true) .maximumRedeliveries(2) .logStackTrace(false) .logExhausted(false) .log(LoggingLevel.ERROR, "Failed processing ${body}") // Register the 'redelivery' meter .to("microprofile-metrics:meter:redelivery?mark=2") // Register the 'error' meter .to("microprofile-metrics:meter:error"); 2 from("timer:stream?period=1000") .routeId("unreliable-service") .setBody(header(Exchange.TIMER_COUNTER).prepend("event #")) .log("Processing ${body}...") // Register the 'generated' meter .to("microprofile-metrics:meter:generated") 3 // Register the 'attempt' meter via @Metered in Service.java .bean("service") 4 .filter(header(Exchange.REDELIVERED)) .log(LoggingLevel.WARN, "Processed ${body} after ${header.CamelRedeliveryCounter} retries") .setHeader(MicroProfileMetricsConstants.HEADER_METER_MARK, header(Exchange.REDELIVERY_COUNTER)) // Register the 'redelivery' meter .to("microprofile-metrics:meter:redelivery") 5 .end() .log("Successfully processed ${body}") // Register the 'success' meter .to("microprofile-metrics:meter:success"); 6 } }
根据需要将 Camel MicroProfile 指标注释添加到任何实施文件中。以下示例显示了 Camel K 集成调用
的服务
bean,这会产生随机失败:package com.redhat.integration; import java.util.Random; import org.apache.camel.Exchange; import org.apache.camel.RuntimeExchangeException; import org.eclipse.microprofile.metrics.Meter; import org.eclipse.microprofile.metrics.annotation.Metered; import org.eclipse.microprofile.metrics.annotation.Metric; import javax.inject.Named; import javax.enterprise.context.ApplicationScoped; @Named("service") @ApplicationScoped @io.quarkus.arc.Unremovable public class Service { //Register the attempt meter @Metered(absolute = true) public void attempt(Exchange exchange) { 1 Random rand = new Random(); if (rand.nextDouble() < 0.5) { throw new RuntimeExchangeException("Random failure", exchange); 2 } } }
按照以下步骤配置 Camel K 集成指标,以运行集成并在 Prometheus 中查看自定义 Camel K 指标。
在本例中,示例已经使用
Metrics.java
中的 Camel K modeline 自动配置 Prometheus 和Service.java
所需的 Maven 依赖项。
第 3 章 监控 Camel K operator
Red Hat Integration - Camel K 监控基于 OpenShift 监控系统。本章论述了如何在运行时使用可用选项监控 Red Hat Integration - Camel K operator。您可以使用作为 OpenShift Monitoring 的一部分部署的 Prometheus Operator 来监控您自己的应用程序。
3.1. Camel K Operator 指标
Camel K operator 监控端点公开以下指标:
名称 | 类型 | Description | Buckets | 标签 |
---|---|---|---|---|
|
| 协调请求持续时间 | 0.25S、0.5s、1s、5s |
|
|
| 构建持续时间 | 30s, 1m, 1.5m, 2m, 5m, 10m |
|
|
| 构建恢复尝试 | 0, 1, 2, 3, 4, 5 |
|
|
| 构建队列持续时间 | 5s, 15s, 30s, 1m, 5m, | N/A |
|
| 第一次集成就绪 | 5s, 10s, 30s, 1m, 2m | N/A |
3.2. 启用 Camel K Operator 监控
OpenShift 4.3 或更高版本包括已作为 OpenShift Monitoring 的一部分部署的嵌入式 Prometheus Operator。本节介绍如何在 OpenShift Monitoring 中启用对您自己的应用程序服务的监控。
前提条件
- 您必须具有安装 Camel K Operator 的 OpenShift 集群的集群管理员访问权限。请参阅安装 Camel K。
- 您必须在 OpenShift 中启用对您自己的服务的监控。请参阅 在 OpenShift 中启用用户工作负载监控。
流程
创建一个以 operator 指标端点为目标的
PodMonitor
资源,以便 Prometheus 服务器可以提取 Operator 公开的指标。operator-pod-monitor.yaml
apiVersion: monitoring.coreos.com/v1 kind: PodMonitor metadata: name: camel-k-operator labels: app: "camel-k" camel.apache.org/component: operator spec: selector: matchLabels: app: "camel-k" camel.apache.org/component: operator podMetricsEndpoints: - port: metrics
创建
PodMonitor
资源。oc apply -f operator-pod-monitor.yaml
其它资源
- 有关发现机制和 Operator 资源之间的关系的更多信息,请参阅 Prometheus Operator 入门指南。
-
如果没有发现 Operator 指标,您可以在 故障排除 ServiceMonitor 中的内容中找到更多信息,这也适用于
PodMonitor
资源故障排除。
3.3. Camel K operator 警报
您可以创建一个 PrometheusRule
资源,以便来自 OpenShift 监控堆栈的 AlertManager 实例可以根据 Camel K operator 公开的指标来触发警报。
Example
您可以根据公开的指标,使用警报规则创建 PrometheusRule
资源,如下所示。
apiVersion: monitoring.coreos.com/v1 kind: PrometheusRule metadata: name: camel-k-operator spec: groups: - name: camel-k-operator rules: - alert: CamelKReconciliationDuration expr: | ( 1 - sum(rate(camel_k_reconciliation_duration_seconds_bucket{le="0.5"}[5m])) by (job) / sum(rate(camel_k_reconciliation_duration_seconds_count[5m])) by (job) ) * 100 > 10 for: 1m labels: severity: warning annotations: message: | {{ printf "%0.0f" $value }}% of the reconciliation requests for {{ $labels.job }} have their duration above 0.5s. - alert: CamelKReconciliationFailure expr: | sum(rate(camel_k_reconciliation_duration_seconds_count{result="Errored"}[5m])) by (job) / sum(rate(camel_k_reconciliation_duration_seconds_count[5m])) by (job) * 100 > 1 for: 10m labels: severity: warning annotations: message: | {{ printf "%0.0f" $value }}% of the reconciliation requests for {{ $labels.job }} have failed. - alert: CamelKSuccessBuildDuration2m expr: | ( 1 - sum(rate(camel_k_build_duration_seconds_bucket{le="120",result="Succeeded"}[5m])) by (job) / sum(rate(camel_k_build_duration_seconds_count{result="Succeeded"}[5m])) by (job) ) * 100 > 10 for: 1m labels: severity: warning annotations: message: | {{ printf "%0.0f" $value }}% of the successful builds for {{ $labels.job }} have their duration above 2m. - alert: CamelKSuccessBuildDuration5m expr: | ( 1 - sum(rate(camel_k_build_duration_seconds_bucket{le="300",result="Succeeded"}[5m])) by (job) / sum(rate(camel_k_build_duration_seconds_count{result="Succeeded"}[5m])) by (job) ) * 100 > 1 for: 1m labels: severity: critical annotations: message: | {{ printf "%0.0f" $value }}% of the successful builds for {{ $labels.job }} have their duration above 5m. - alert: CamelKBuildFailure expr: | sum(rate(camel_k_build_duration_seconds_count{result="Failed"}[5m])) by (job) / sum(rate(camel_k_build_duration_seconds_count[5m])) by (job) * 100 > 1 for: 10m labels: severity: warning annotations: message: | {{ printf "%0.0f" $value }}% of the builds for {{ $labels.job }} have failed. - alert: CamelKBuildError expr: | sum(rate(camel_k_build_duration_seconds_count{result="Error"}[5m])) by (job) / sum(rate(camel_k_build_duration_seconds_count[5m])) by (job) * 100 > 1 for: 10m labels: severity: critical annotations: message: | {{ printf "%0.0f" $value }}% of the builds for {{ $labels.job }} have errored. - alert: CamelKBuildQueueDuration1m expr: | ( 1 - sum(rate(camel_k_build_queue_duration_seconds_bucket{le="60"}[5m])) by (job) / sum(rate(camel_k_build_queue_duration_seconds_count[5m])) by (job) ) * 100 > 1 for: 1m labels: severity: warning annotations: message: | {{ printf "%0.0f" $value }}% of the builds for {{ $labels.job }} have been queued for more than 1m. - alert: CamelKBuildQueueDuration5m expr: | ( 1 - sum(rate(camel_k_build_queue_duration_seconds_bucket{le="300"}[5m])) by (job) / sum(rate(camel_k_build_queue_duration_seconds_count[5m])) by (job) ) * 100 > 1 for: 1m labels: severity: critical annotations: message: | {{ printf "%0.0f" $value }}% of the builds for {{ $labels.job }} have been queued for more than 5m.
Camel K operator 警报
下表显示了在 PrometheusRule
资源中定义的警报规则。
名称 | 重要性 | Description |
---|---|---|
| warning | 超过 10% 的协调请求使其在 0.5 之前的时长至少超过 1 分钟。 |
| warning | 超过 1% 的协调请求在至少 10 分钟内失败。 |
| warning | 在至少 1 分钟内,成功构建构建的时间超过 2 分钟。 |
| critical | 超过 1% 的构建构建周期已超过 5 分钟的时间,超过 1 分钟。 |
| critical | 超过 1% 的构建的构建错误至少超过 10 分钟。 |
| warning | 超过 1% 的构建的构建已被排队,至少超过 1 分钟。 |
| critical | 超过 1% 的构建的构建已被排队,至少超过 5 分钟。 |
您可以在 OpenShift 文档中的 创建警报规则 中找到有关警报的更多信息。
第 4 章 配置 Camel K 集成
Camel K 集成生命周期有两个配置阶段:
- 构建时间 - 当 Camel Quarkus 构建 Camel K 集成时,它会消耗构建属性。
- Runtime - 当 Camel K 集成运行时,集成使用运行时属性或来自本地文件、OpenShift ConfigMap 或 Secret 的配置信息。
您使用以下选项以及 kamel run
命令提供配置信息:
-
对于构建时间配置,请使用
--build-property
选项,如 Specifying build-time 配置属性中所述 -
对于运行时配置,请使用
--property
、--config
或--resource
选项,如 指定运行时配置选项所述
例如,您可以使用构建时和运行时选项在 Camel K 中快速配置数据源,如链接中所示: Connect Camel K with database sample configuration。
4.1. 指定构建时配置属性
您可能需要向 Camel Quarkus 运行时提供属性值,以便它能够构建 Camel K 集成。有关构建期间工作的 Quarkus 配置的更多信息,请参阅 Quarkus 构建配置文档。您可以直接在命令行中指定构建属性,也可以通过引用属性文件直接指定。如果在这两个位置都定义了属性,则直接在命令行中指定的值优先于属性文件中的值。
前提条件
- 您必须有权访问安装 Camel K Operator 和 OpenShift Serverless Operator 的 OpenShift 集群:
- 安装 Camel K
- 从 OperatorHub 安装 OpenShift Serverless
- 您知道您要应用到 Camel K 集成的 Camel Quarkus 配置选项。
流程
使用 Camel K
kamel run
命令指定--build-property
选项:kamel run --build-property <quarkus-property>=<property-value> <camel-k-integration>
例如,以下 Camel K 集成(名为
my-simple-timer.yaml
)使用quarkus.application.name
配置选项:- from: uri: "timer:tick" steps: - set-body: constant: "{{quarkus.application.name}}" - to: "log:info"
要覆盖默认应用程序名称,请在运行集成时为
quarkus.application.name
属性的值。例如,要将名称从
my-simple-timer
更改为my-favorite-app
:kamel run --build-property quarkus.application.name=my-favorite-app my-simple-timer.yaml
要提供多个构建时属性,请在
kamel run
命令中添加额外的--build-property
选项:kamel run --build-property <quarkus-property1>=<property-value1> -build-property=<quarkus-property2>=<property-value12> <camel-k-integration>
另外,如果您需要指定多个属性,可以使用
--build-property file
选项指定属性文件:kamel run --build-property file:<property-filename> <camel-k-integration>
例如,以下属性文件(名为
quarkus.properties
)定义了两个 Quarkus 属性:quarkus.application.name = my-favorite-app quarkus.banner.enabled = true
quarkus.banner.enabled
属性指定在集成启动时显示 Quarkus 横幅。使用 Camel K kamel run 命令指定
quarkus.properties
文件:kamel run --build-property file:quarkus.properties my-simple-timer.yaml
Quarkus 解析 属性文件,并使用属性值配置 Camel K 集成。
其他资源
有关 Camel K 集成运行时的 Camel Quarkus 的详情,请参考 Quarkus Trait。
4.2. 指定运行时配置选项
您可以在 Camel K 运行时指定以下运行时配置信息:
- 您在命令行或 .properties 文件中提供的运行时属性。
- 在集成启动时,您希望 Camel K 操作器处理并解析为运行时属性的配置值。您可以在本地文本文件、OpenShift ConfigMap 或 OpenShift secret 中提供配置值。
- 集成启动时不会解析为属性文件的资源信息。您可以在本地文本文件、二进制文件、OpenShift ConfigMap 或 OpenShift secret 中提供资源信息。
使用以下 kamel run
选项:
--property
使用
--property
选项直接在命令行中指定运行时属性,或者引用 Java*.properties
文件。Camel K 运算符将属性文件的内容附加到正在运行的集成的用户.properties
文件中。--config
在集成启动时,使用
--config
选项提供您希望 Camel K 运算符处理并解析为运行时属性的配置值。您可以提供一个本地文本文件(1 MiB 最大文件大小)、ConfigMap (3MB)或 Secret (3MB)。该文件必须是 UTF-8 资源。材料化文件(在从您提供的文件中生成的)在类路径级别上提供,以便您可以在集成代码中引用它,而无需提供确切的位置。
注: 如果您需要提供非 UTF-8 资源(例如,一个二进制文件),请使用
--resource
选项。--resource
使用
--resource
选项为集成提供资源,以便在资源运行时访问。您可以提供本地文本或二进制文件(1 MiB 最大文件大小)、ConfigMap (最大 3MB)或 Secret (最大 3MB)。另外,您还可以指定资源材料的文件的目的地。例如,如果要设置 HTTPS 连接,请使用--resource
选项提供在指定位置预期 SSL 证书(二进制文件)。Camel K 运算符不会解析属性的资源,且不会将资源添加到 classpath 中。(如果要将资源添加到类路径,您可以使用集成中的 JVM 特征。
4.2.1. 提供运行时属性
您可以直接在命令行中指定运行时属性,或者使用 kamel run
命令的 --property
选项引用 Java *.properties
文件。
当您运行与 --property
选项的集成时,Camel K operator 会将属性附加到正在运行的集成 的用户.properties
文件中。
4.2.1.1. 在命令行中提供运行时属性
您可以在运行时在命令行中配置 Camel K 集成的属性。当您使用属性占位符(如 {{my.message}}
)在集成中定义属性时,您可以在命令行中指定属性值,如 --property my.message=Hello
。您可以在一个命令中指定多个属性。
前提条件
流程
开发使用属性的 Camel 集成。以下简单示例包含
{{my.message}}
属性占位符:... - from: uri: "timer:tick" steps: - set-body: constant: "{{my.message}}" - to: "log:info" ...
使用下列语法运行集成,在运行时设置属性值:
kamel run --property <property>=<value> <integration>
另外,您可以使用
--p
简写表示法(使用--property
代替 ):kamel run --property <property>=<value> <integration>
例如:
kamel run --property my.message="Hola Mundo" HelloCamelK.java --dev
或者
kamel run --p my.message="Hola Mundo" HelloCamelK.java --dev
以下是示例结果:
... [1] 2020-04-13 15:39:59.213 INFO [main] ApplicationRuntime - Listener org.apache.camel.k.listener.RoutesDumper@6e0dec4a executed in phase Started [1] 2020-04-13 15:40:00.237 INFO [Camel (camel-k) thread #1 - timer://java] info - Exchange[ExchangePattern: InOnly, BodyType: String, Body: Hola Mundo from java] ...
另请参阅
4.2.1.2. 在属性文件中提供运行时属性
您可以在运行时在命令行中指定属性文件(*.properties
)来为 Camel K 集成配置多个属性。当您使用属性占位符(如 {{my.items}}
)在集成中定义属性时,您可以使用属性文件(如 --p 文件 my-integration.properties
)来指定命令行上的属性值。
前提条件
流程
创建集成属性文件。以下示例来自名为
my.properties
的文件:my.key.1=hello my.key.2=world
开发使用属性文件的 Camel 集成。以下示例
Routing.java
集成使用{{my.key.1}}
和{{my.key.2=world}}
属性占位符:import org.apache.camel.builder.RouteBuilder; public class Routing extends RouteBuilder { @Override public void configure() throws Exception { from("timer:property-file") .routeId("property-file") .log("property file content is: {{my.key.1}} {{my.key.2}}"); } }
通过以下语法运行集成来引用属性文件:
kamel run --property file:<my-file.properties> <integration>
另外,您可以使用
--p
简写表示法(使用--property
代替 ):kamel run --p file:<my-file.properties> <integration>
例如:
kamel run Routing.java --property:file=my.properties --dev
4.2.2. 提供配置值
您可以使用 kamel run
命令的 --config
选项,提供希望 Camel K 运算符处理并解析为运行时属性的配置值。您可以在本地文本(UTF-8)文件中、OpenShift ConfigMap 或 OpenShift secret 中提供配置值。
当您运行集成时,Camel K operator 会复制提供的文件并将其添加到类路径中,以便您可以引用集成代码中的配置值,而无需提供确切的位置。
4.2.2.1. 指定文本文件
如果您的 UTF-8 文本文件包含配置值,您可以使用 --config file:/path/to/file
选项使该文件在运行集成的类路径上可用(具有相同文件名)。
前提条件
- 设置 Camel K 开发环境
您有一个或多个(非二进制)文本文件,其中包含配置值。
例如,创建一个名为
resources-data.txt
的文件,该文件含有以下行文本:the file body
流程
创建一个 Camel K 集成来引用包含配置值的文本文件。
例如,以下集成(
ConfigFileRoute.java
)预期resources-data.txt
文件在运行时在 classpath 上可用:import org.apache.camel.builder.RouteBuilder; public class ConfigFileRoute extends RouteBuilder { @Override public void configure() throws Exception { from("timer:config-file") .setBody() .simple("resource:classpath:resources-data.txt") .log("resource file content is: ${body}"); } }
运行集成并使用
--config
选项指定文本文件,使其可用于正在运行的集成。例如:kamel run --config file:resources-data.txt ConfigFileRoute.java --dev
另外,您可以通过重复添加
--config
选项来提供多个文件,例如:kamel run --config file:resources-data1.txt --config file:resources-data2.txt ConfigFileRoute.java --dev
4.2.2.2. 指定 ConfigMap
如果您有一个包含配置值的 OpenShift ConfigMap,且您需要对 ConfigMap 进行材料,使其可用于您的 Camel K 集成,请使用 --config configmap:<configmap-name> 语法。
前提条件
- 设置 Camel K 开发环境
在 OpenShift 集群中存储了一个或多个 ConfigMap 文件。
例如,您可以使用以下命令创建 ConfigMap:
oc create configmap my-cm --from-literal=my-configmap-key="configmap content"
流程
创建引用 ConfigMap 的 Camel K 集成。
例如,以下集成(名为
ConfigConfigmapRoute.java
)在名为my-cm
的 ConfigMap 中引用名为my-configmap-key
的配置值。import org.apache.camel.builder.RouteBuilder; public class ConfigConfigmapRoute extends RouteBuilder { @Override public void configure() throws Exception { from("timer:configmap") .setBody() .simple("resource:classpath:my-configmap-key") .log("configmap content is: ${body}"); } }
运行集成并使用
--config
选项对 ConfigMap 文件进行整理,使其可用于运行的集成。例如:kamel run --config configmap:my-cm ConfigConfigmapRoute.java --dev
当集成启动时,Camel K operator 会使用 ConfigMap 的内容挂载 OpenShift 卷。
注: 如果您指定集群中还没有可用的 ConfigMap,则集成会等待并在 ConfigMap 可用时启动。
4.2.2.3. 指定 Secret
您可以使用 OpenShift Secret 安全地包含配置信息。要对机密进行碎片化,以便可以供您使用 Camel K 集成,您可以使用 --config secret
语法。
前提条件
- 设置 Camel K 开发环境
在 OpenShift 集群中存储了一个或多个 Secret。
例如,您可以使用以下命令创建 Secret:
oc create secret generic my-sec --from-literal=my-secret-key="very top secret"
流程
创建引用 ConfigMap 的 Camel K 集成。
例如,以下集成(名为
ConfigSecretRoute.java
)引用名为my-sec
的 Secret 中的my-secret
属性:import org.apache.camel.builder.RouteBuilder; public class ConfigSecretRoute extends RouteBuilder { @Override public void configure() throws Exception { from("timer:secret") .setBody() .simple("resource:classpath:my-secret") .log("secret content is: ${body}"); } }
运行集成并使用
--config
选项对 Secret 进行分析,使其可用于运行的集成。例如:kamel run --config secret:my-sec ConfigSecretRoute.java --dev
当集成启动时,Camel K operator 会使用 Secret 的内容挂载 OpenShift 卷。
4.2.2.4. 引用 ConfigMap 或 Secret 中包含的属性
当您运行集成和使用 --config
选项指定 ConfigMap 或 Secret 时,Camel K operator 会将 ConfigMap 或 Secret 解析为运行时属性文件。在集成中,您可以引用属性,就像引用任何其他运行时属性一样。
前提条件
流程
创建包含属性的文本文件。
例如,创建一个名为
my.properties
的文件,其包含以下属性:my.key.1=hello my.key.2=world
根据属性文件创建 ConfigMap 或 Secret。
例如,使用以下命令从 my.properties 文件中创建 secret:
oc create secret generic my-sec --from-file my.properties
在集成中,引用 Secret 中定义的属性。
例如,以下集成(名为
ConfigSecretPropertyRoute.java
)引用my.key.1
和my.key.2
属性:import org.apache.camel.builder.RouteBuilder; public class ConfigSecretPropertyRoute extends RouteBuilder { @Override public void configure() throws Exception { from("timer:secret") .routeId("secret") .log("{{my.key.1}} {{my.key.2}}"); } }
运行集成并使用
--config
选项指定包含 my.key.1 和
属性的 Secret。my.key
.2例如:
kamel run --config secret:my-sec ConfigSecretPropertyRoute.java --dev
4.2.2.5. 过滤从 ConfigMap 或 Secret 获取的配置值
ConfigMap 和 Secret 可以容纳多个源。例如,以下命令从两个源创建一个 secret (my-sec-multi
):
oc create secret generic my-sec-multi --from-literal=my-secret-key="very top secret" --from-literal=my-secret-key-2="even more secret"
您可以使用 --config configmap
或 --config secret
选项后,使用 /key
表示法限制集成检索的信息数量。
前提条件
- 设置 Camel K 开发环境
- 您有一个包含多个源的 ConfigMap 或 Secret。
流程
创建使用 ConfigMap 或 Secret 中其中一个源的配置值的集成。
例如,以下集成(
ConfigSecretKeyRoute.java
)使用来自my-sec-multi
机密中的一个源的 属性。import org.apache.camel.builder.RouteBuilder; public class ConfigSecretKeyRoute extends RouteBuilder { @Override public void configure() throws Exception { from("timer:secret") .setBody() .simple("resource:classpath:my-secret-key-2") .log("secret content is: ${body}"); } }
使用
--config secret
选项和/key
表示法运行集成。例如:
kamel run --config secret:my-sec-multi/my-secret-key-2 ConfigSecretKeyRoute.java --dev
检查集成 pod,以验证是否只挂载指定源(如
my-secret-key-2)。
例如,运行以下命令来列出 pod 的所有卷:
oc set volume pod/<pod-name> --all
4.2.3. 为正在运行的集成提供资源
您可以通过指定 kamel run 命令的 --resource
选项,为它运行时提供集成使用的资源。您可以指定本地文本文件(1 MiB 最大文件大小)、ConfigMap (3MB)或 Secret (3MB)。您可以选择指定资源材料的文件的目的地。例如,如果要设置 HTTPS 连接,请使用 --resource 选项,因为您必须提供一个 SSL 证书,这是已知位置中预期的二进制文件。
当您使用 --resource
选项时,Camel K 运算符不会解析资源查找运行时属性,且不会将资源添加到 classpath 中。(如果要将资源添加到类路径,您可以使用 JVM 特征。
4.2.3.1. 将文本或二进制文件指定为资源
如果您的文本或二进制文件包含配置值,您可以使用 --resource file:/path/to/file
选项来对文件进行碎片整理。默认情况下,Camel K operator 将资料化文件复制到 /etc/camel/resources/
目录中。另外,您可以指定不同的目标目录,如 指定资源 的目标路径 所述。
前提条件
- 设置 Camel K 开发环境
- 您有一个或多个包含配置属性的文本或二进制文件。
流程
创建一个 Camel K 集成,以读取您提供的文件内容。
例如,以下集成(
ResourceFileBinaryRoute.java
) unzips 并读取resources-data.zip
文件:import org.apache.camel.builder.RouteBuilder; public class ResourceFileBinaryRoute extends RouteBuilder { @Override public void configure() throws Exception { from("file:/etc/camel/resources/?fileName=resources-data.zip&noop=true&idempotent=false") .unmarshal().zipFile() .log("resource file unzipped content is: ${body}"); } }
运行集成并使用
--resource
选项将文件复制到默认目标目录(/etc/camel/resources/
)。例如:kamel run --resource file:resources-data.zip ResourceFileBinaryRoute.java -d camel-zipfile --dev
注: 如果您指定了二进制文件,则会在集成中透明地创建并解码文件内容的二进制表示。
另外,您可以通过重复添加
--resource
选项来提供多个资源,例如:kamel run --resource file:resources-data1.txt --resource file:resources-data2.txt ResourceFileBinaryRoute.java -d camel-zipfile --dev
4.2.3.2. 将 ConfigMap 指定为资源
如果您有一个包含配置值的 OpenShift ConfigMap,且需要将 ConfigMap 作为集成资源进行材料,请使用 --resource <configmap-file>
选项。
前提条件
- 设置 Camel K 开发环境
在 OpenShift 集群中存储了一个或多个 ConfigMap 文件。例如,您可以使用以下命令创建 ConfigMap:
oc create configmap my-cm --from-literal=my-configmap-key="configmap content"
流程
创建引用 OpenShift 集群中存储的 ConfigMap 的 Camel K 集成。
例如,以下集成(名为
ResourceConfigmapRoute.java
)引用名为my-cm
的 ConfigMap,其中包含my-configmap-key
。import org.apache.camel.builder.RouteBuilder; public class ResourceConfigmapRoute extends RouteBuilder { @Override public void configure() throws Exception { from("file:/etc/camel/resources/my-cm/?fileName=my-configmap-key&noop=true&idempotent=false") .log("resource file content is: ${body}"); } }
运行集成并使用
--resource
选项将 ConfigMap 文件放在默认的/etc/camel/resources/
目录中,使其可用于运行的集成。例如:
kamel run --resource configmap:my-cm ResourceConfigmapRoute.java --dev
当集成启动时,Camel K 操作器会挂载 ConfigMap 的内容的卷(如
my-configmap-key
)。
注: 如果您指定集群中还没有可用的 ConfigMap,则集成会等待并在 ConfigMap 可用时启动。
4.2.3.3. 将 Secret 指定为资源
如果您有一个包含配置信息的 OpenShift Secret,且您需要将其作为可提供给一个或多个集成的资源进行材料,请使用 --resource <secret>
; 语法。
前提条件
- 设置 Camel K 开发环境
您有一个或多个存储在 OpenShift 集群上的机密文件。例如,您可以使用以下命令创建 Secret:
oc create secret generic my-sec --from-literal=my-secret-key="very top secret"
流程
创建引用 OpenShift 集群中存储的 Secret 的 Camel K 集成。
例如,以下集成(名为
ResourceSecretRoute.java
)引用my-sec
Secret:import org.apache.camel.builder.RouteBuilder; public class ResourceSecretRoute extends RouteBuilder { @Override public void configure() throws Exception { from("file:/etc/camel/resources/my-sec/?fileName=my-secret-key&noop=true&idempotent=false") .log("resource file content is: ${body}"); } }
运行集成并使用
--resource
选项将 Secret 整理到默认的/etc/camel/resources/
目录中,以便供正在运行的集成使用。例如:
kamel run --resource secret:my-sec ResourceSecretRoute.java --dev
当集成启动时,Camel K 运算符使用 Secret 的内容挂载卷(如
my-sec
)。
注: 如果您指定集群中还没有可用的 Secret,则集成会等待并在 Secret 可用时启动。
4.2.3.4. 为资源指定目标路径
/etc/camel/resources/
目录是挂载使用 --resource
选项指定的资源的默认位置。如果您需要指定要在其上挂载资源的不同目录,请使用 --resource @path
语法。
前提条件
- 设置 Camel K 开发环境
- 您有一个包含一个或多个配置属性的文件、ConfigMap 或 Secret。
流程
创建一个 Camel K 集成来引用包含配置属性的文件、ConfigMap 或 Secret。例如,以下集成(名为
ResourceFileLocationRoute.java
)引用myprops
文件:import org.apache.camel.builder.RouteBuilder; public class ResourceFileLocationRoute extends RouteBuilder { @Override public void configure() throws Exception { from("file:/tmp/?fileName=input.txt&noop=true&idempotent=false") .log("resource file content is: ${body}"); } }
运行集成并使用
--resource
选项及@path
语法,并指定挂载资源内容(文件、ConfigMap 或 Secret)的位置:例如,以下命令指定使用
/tmp
目录挂载input.txt
文件:kamel run --resource file:resources-data.txt@/tmp/input.txt ResourceFileLocationRoute.java --dev
检查集成的 pod,以验证文件(例如
input.txt
)已挂载到正确的位置(例如,在tmp
目录中)。例如,运行以下命令:oc exec <pod-name> -- cat /tmp/input.txt
4.2.3.5. 过滤 ConfigMap 或 Secret 数据
创建 ConfigMap 或 Secret 时,您可以指定多个信息源。例如,以下命令从两个源中创建一个名为 my-cm-multi
的 ConfigMap:
oc create configmap my-cm-multi --from-literal=my-configmap-key="configmap content" --from-literal=my-configmap-key-2="another content"
当您运行与 --resource
选项的集成时,默认情况下,使用多个源创建的 ConfigMap 或 Secret 都会进行碎片处理。
如果要限制从 ConfigMap 或 Secret 恢复的信息数量,您可以在 ConfigMap 或 Secret 名称后指定 --resource
选项的 /key 表示法。例如,-- resource configmap:my-cm/my-key
或 --resource secret:my-secret/my-key
。
在带有 --resource configmap
或 --resource secret
选项后,您可以使用 /key 表示法限制集成检索的信息数量。
前提条件
- 设置 Camel K 开发环境
- 您有一个 ConfigMap 或 Secret,其中包含来自多个源的值。
流程
创建使用 ConfigMap 或 Secret 中的一个资源的配置值的集成。例如,以下集成(名为
ResourceConfigmapKeyLocationRoute.java
)引用my-cm-multi
ConfigMap:import org.apache.camel.builder.RouteBuilder; public class ResourceConfigmapKeyLocationRoute extends RouteBuilder { @Override public void configure() throws Exception { from("file:/tmp/app/data/?fileName=my-configmap-key-2&noop=true&idempotent=false") .log("resource file content is: ${body} consumed from ${header.CamelFileName}"); } }
运行集成并使用
--resource
选项及@path
语法,并指定挂载源内容(文件、ConfigMap 或 Secret)的位置:例如,以下命令只指定 ConfigMap 中包含的源之一(
my-configmap-key-2@
),并使用/tmp/app/data
目录挂载它:kamel run --resource configmap:my-cm-multi/my-configmap-key-2@/tmp/app/data ResourceConfigmapKeyLocationRoute.java --dev
检查集成的 pod,以验证只有一个文件(例如
my-configmap-key-2)
已挂载到正确的位置(例如,在/tmp/app/data
目录中)。例如,运行以下命令:oc exec <pod-name> -- cat /tmp/app/data/my-configmap-key-2
4.3. 配置 Camel 集成组件
您可以以编程方式在集成代码中配置 Camel 组件,或者使用在运行时在命令行中配置配置属性。您可以使用以下语法配置 Camel 组件:
camel.component.${scheme}.${property}=${value}
例如,要为暂存事件驱动的架构更改 Camel seda
组件的队列大小,您可以在命令行中配置以下属性:
camel.component.seda.queueSize=10
前提条件
流程
输入
kamel run
命令并使用--property
选项指定 Camel 组件配置。例如:kamel run --property camel.component.seda.queueSize=10 examples/Integration.java
4.4. 配置 Camel K 集成依赖项
Camel K 自动解决运行集成代码所需的各种依赖项。但是,您可以使用 kamel run --dependency
选项在运行时明确添加对命令行的依赖项。
以下示例集成使用 Camel K 自动依赖项解析:
... from("imap://admin@myserver.com") .to("seda:output") ...
由于此集成有以 imap:
前缀开头的端点,因此 Camel K 可以自动将 camel-mail
组件添加到所需依赖项列表中。seda:
端点属于 camel-core
,它会被自动添加到所有集成中,因此 Camel K 不会为此组件添加其他依赖项。
Camel K 自动依赖项解析对用户在运行时透明。这在开发模式中非常有用,因为您可以快速添加不需要的所有组件,而无需退出开发循环。
您可以使用 kamel run --dependency
或 -d
选项显式添加依赖项。您可能需要使用它来指定 Camel 目录中未包含的依赖项。您可以在命令行中指定多个依赖项。
前提条件
流程
输入
kamel run
命令并使用-d
选项指定依赖项。例如:kamel run -d mvn:com.google.guava:guava:26.0-jre -d camel-mina2 Integration.java
您可以通过禁用 dependencies trait: -trait dependencies.enabled=false
来禁用自动依赖关系解析。但是,在大多数情况下不建议这样做。
第 5 章 对 Kafka 的 Camel K 进行身份验证
您可以针对 Apache Kafka 验证 Camel K。
本例演示了如何使用 Red Hat OpenShift Streams for Apache Kafka 设置 Kafka 主题,并在简单的 Producer/Consumer 模式集成中使用它。
5.1. 设置 Kafka
设置 Kafka 涉及安装所需的 OpenShift operator、创建 Kafka 实例并创建 Kafka 主题。
使用这些红帽产品之一设置 Kafka:
- Red Hat Advanced Message Queue (AMQ)流 - 自我管理的 Apache Kafka 产品。AMQ Streams 基于开源 Strimzi,并包含在 Red Hat Integration 中。AMQ Streams 是一个基于 Apache Kafka 的分布式可扩展流平台,其中包括一个发布/订阅消息传递代理。Kafka Connect 提供了一个框架,可将基于 Kafka 的系统与外部系统集成。使用 Kafka Connect,您可以配置 source 和 sink 连接器,将外部系统中的数据流传输到 Kafka 代理中。
- Red Hat OpenShift Streams for Apache Kafka - 一个托管的云服务简化了运行 Apache Kafka 的过程。它为构建、部署和扩展新的云原生应用程序或现代化现有系统提供了简化的开发人员体验。
5.1.1. 使用 AMQ 流设置 Kafka
AMQ Streams 简化了在 OpenShift 集群中运行 Apache Kafka 的过程。
5.1.1.1. 为 AMQ Streams 准备 OpenShift 集群
要使用 Camel K 或 Kamelets 和 Red Hat AMQ Streams,您必须安装以下 operator 和工具:
- Red Hat Integration - AMQ Streams operator - 管理 Openshift Cluster and AMQ Streams for Apache Kafka 实例之间的通信。
- Red Hat Integration - Camel K operator - 安装和管理 Camel K - 一个轻量级集成框架,可在 OpenShift 中云端运行。
- Camel K CLI 工具 - 允许您访问所有 Camel K 功能。
前提条件
- 熟悉 Apache Kafka 概念。
- 您可以使用正确的访问级别访问 OpenShift 4.6 (或更新版本)集群、创建项目和安装操作器,以及在本地系统上安装 OpenShift 和 Camel K CLI 的功能。
-
已安装 OpenShift CLI 工具(
oc
),以便您可以在命令行中与 OpenShift 集群交互。
流程
使用 AMQ Streams 设置 Kafka:
- 登录您的 OpenShift 集群的 Web 控制台。
- 创建或打开您要在其中创建集成的项目,如 my-camel-k-kafka。
- 安装 Camel K 运算符和 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。
5.1.1.2. 使用 AMQ Streams 设置 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 主题 下,点 Create Kafka Topic。
- 输入主题的名称,如 test-topic。
- 接受其他默认值,然后单击 Create。
5.1.2. 使用 OpenShift 流设置 Kafka
Red Hat OpenShift Streams for Apache Kafka 是一个受管云服务,简化了运行 Apache Kafka 的过程。
要将 OpenShift Streams 用于 Apache Kafka,您必须登录到您的红帽帐户。
5.1.2.1. 为 OpenShift Streams 准备 OpenShift 集群
要使用 Red Hat OpenShift Streams for Apache Kafka 管理的云服务,您必须安装以下 operator 和工具:
- OpenShift Application Services (RHOAS) CLI - 允许您从终端管理应用程序服务。
- Red Hat Integration - Camel K operator Installs 并管理 Camel K - 一个轻量级集成框架,可在 OpenShift 中云端运行。
- Camel K CLI 工具 - 允许您访问所有 Camel K 功能。
前提条件
- 熟悉 Apache Kafka 概念。
- 您可以使用正确的访问级别访问 OpenShift 4.6 (或更新版本)集群、创建项目和安装操作器,以及在本地系统上安装 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 运算符和 Camel K CLI,如 安装 Camel K 所述。
- 要验证是否已安装 Red Hat Integration - Camel K operator,点 Operators > Installed Operators。
后续步骤
5.1.2.2. 使用 RHOAS 设置 Kafka 主题
Kafka 围绕 主题 组织信息。每个主题都有一个名称。应用向主题发送消息并从主题检索信息。Kafka 主题提供在 Kafka 实例中存储数据的目的地。在将数据发送到之前,您必须设置 Kafka 主题。
前提条件
- 您可以使用正确的访问级别访问 OpenShift 集群,创建项目和安装操作器,以及在本地系统上安装 OpenShift 和 Camel K CLI 的功能。
-
已安装 OpenShift CLI (
oc
)、Camel CLI (kamel
)和 RHOAS CLI (rhoas
)工具,如 准备 OpenShift 集群 中所述。 - 您安装了 Red Hat Integration - Camel K operator,如 准备 OpenShift 集群 中所述。
- 登录到 红帽云站点。
流程
使用 Red Hat OpenShift Streams for Apache Kafka 设置 Kafka 主题:
- 在命令行中登录您的 OpenShift 集群。
打开您的项目,例如:
oc project my-camel-k-kafka
验证项目中的 Camel K 操作器是否安装了:
oc get csv
结果列出了 Red Hat Camel K operator,并指示它处于
Succeeded
阶段。准备 Kafka 实例并将其连接到 RHOAS:
使用以下命令登录到 RHOAS CLI:
RHOAS 登录
创建 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 集群连接
按照获取凭证令牌的脚本说明。
您应该看到类似如下的输出:
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.
后续步骤
5.1.2.3. 获取 Kafka 凭证
要将应用程序或服务连接到 Kafka 实例,您必须首先获取以下 Kafka 凭证:
- 获取 bootstrap URL。
- 使用凭证(用户名和密码)创建服务帐户。
对于 OpenShift Streams,身份验证协议是 SASL_SSL。
前提条件
- 您已创建了 Kafka 实例,它有一个 ready 状态。
- 您已创建了 Kafka 主题。
流程
获取 Kafka Broker URL (Bootstrap URL):
RHOAS 状态
这个命令返回类似如下的输出:
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
这个命令返回类似如下的输出:
{"clientID":"srvc-acct-eb575691-b94a-41f1-ab97-50ade0cd1094", "password":"facf3df1-3c8d-4253-aa87-8c95ca5e1225"}
授予从 Kakfa 主题发送和接收消息的权限。使用以下命令,clientID 是
credentials.json
文件(第 3 步中)中提供的值。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 srvc-acct-eb575691-b94a-41f1-ab97-50ade0cd1094 --topic test-topic --group all
5.1.2.4. 使用 SASL/Plain 身份验证方法创建 secret
您可以使用您获取的凭证创建 secret (Kafka bootstrap URL、服务帐户 ID 和服务帐户 secret)。
流程
编辑
application.properties
文件并添加 Kafka 凭证。application.properties 文件
camel.component.kafka.brokers = <YOUR-KAFKA-BOOTSTRAP-URL-HERE> camel.component.kafka.security-protocol = SASL_SSL camel.component.kafka.sasl-mechanism = PLAIN camel.component.kafka.sasl-jaas-config=org.apache.kafka.common.security.plain.PlainLoginModule required username='<YOUR-SERVICE-ACCOUNT-ID-HERE>' password='<YOUR-SERVICE-ACCOUNT-SECRET-HERE>'; consumer.topic=<TOPIC-NAME> producer.topic=<TOPIC-NAME>
运行以下命令,在
application.properties
文件中创建一个包含敏感属性的 secret:oc create secret generic kafka-props --from-file application.properties
在运行 Camel K 集成时,您可以使用此 secret。
另请参阅
5.1.2.5. 使用 SASL/OAUTHBearer 验证方法创建 secret
您可以使用您获取的凭证创建 secret (Kafka bootstrap URL、服务帐户 ID 和服务帐户 secret)。
流程
编辑
application-oauth.properties
文件并添加 Kafka 凭证。application-oauth.properties file
camel.component.kafka.brokers = <YOUR-KAFKA-BOOTSTRAP-URL-HERE> camel.component.kafka.security-protocol = SASL_SSL camel.component.kafka.sasl-mechanism = OAUTHBEARER camel.component.kafka.sasl-jaas-config = org.apache.kafka.common.security.oauthbearer.OAuthBearerLoginModule required \ oauth.client.id='<YOUR-SERVICE-ACCOUNT-ID-HERE>' \ oauth.client.secret='<YOUR-SERVICE-ACCOUNT-SECRET-HERE>' \ oauth.token.endpoint.uri="https://identity.api.openshift.com/auth/realms/rhoas/protocol/openid-connect/token" ; camel.component.kafka.additional-properties[sasl.login.callback.handler.class]=io.strimzi.kafka.oauth.client.JaasClientOauthLoginCallbackHandler consumer.topic=<TOPIC-NAME> producer.topic=<TOPIC-NAME>
运行以下命令,在
application.properties
文件中创建一个包含敏感属性的 secret:oc create secret generic kafka-props --from-file application-oauth.properties
在运行 Camel K 集成时,您可以使用此 secret。
另请参阅
5.2. 运行 Kafka 集成
运行制作者集成
创建示例制作者集成。这会用每 10 秒填充一条消息。
Sample SaslSSLKafkaProducer.java
// kamel run --secret kafka-props SaslSSLKafkaProducer.java --dev // camel-k: language=java dependency=mvn:org.apache.camel.quarkus:camel-quarkus-kafka dependency=mvn:io.strimzi:kafka-oauth-client:0.7.1.redhat-00003 import org.apache.camel.builder.RouteBuilder; import org.apache.camel.component.kafka.KafkaConstants; public class SaslSSLKafkaProducer extends RouteBuilder { @Override public void configure() throws Exception { log.info("About to start route: Timer -> Kafka "); from("timer:foo") .routeId("FromTimer2Kafka") .setBody() .simple("Message #${exchangeProperty.CamelTimerCounter}") .to("kafka:{{producer.topic}}") .log("Message correctly sent to the topic!"); } }
然后运行流程集成。
kamel run --secret kafka-props SaslSSLKafkaProducer.java --dev
该制作者将创建一个新消息并推送至主题并记录一些信息。
[2] 2021-05-06 08:48:11,854 INFO [FromTimer2Kafka] (Camel (camel-1) thread #1 - KafkaProducer[test]) Message correctly sent to the topic! [2] 2021-05-06 08:48:11,854 INFO [FromTimer2Kafka] (Camel (camel-1) thread #3 - KafkaProducer[test]) Message correctly sent to the topic! [2] 2021-05-06 08:48:11,973 INFO [FromTimer2Kafka] (Camel (camel-1) thread #5 - KafkaProducer[test]) Message correctly sent to the topic! [2] 2021-05-06 08:48:12,970 INFO [FromTimer2Kafka] (Camel (camel-1) thread #7 - KafkaProducer[test]) Message correctly sent to the topic! [2] 2021-05-06 08:48:13,970 INFO [FromTimer2Kafka] (Camel (camel-1) thread #9 - KafkaProducer[test]) Message correctly sent to the topic!
运行消费者集成
创建消费者集成。
Sample SaslSSLKafkaProducer.java
// kamel run --secret kafka-props SaslSSLKafkaConsumer.java --dev // camel-k: language=java dependency=mvn:org.apache.camel.quarkus:camel-quarkus-kafka dependency=mvn:io.strimzi:kafka-oauth-client:0.7.1.redhat-00003 import org.apache.camel.builder.RouteBuilder; public class SaslSSLKafkaConsumer extends RouteBuilder { @Override public void configure() throws Exception { log.info("About to start route: Kafka -> Log "); from("kafka:{{consumer.topic}}") .routeId("FromKafka2Log") .log("${body}"); } }
打开另一个 shell,并使用命令运行使用者集成:
kamel run --secret kafka-props SaslSSLKafkaConsumer.java --dev
消费者将开始记录主题中找到的事件:
[1] 2021-05-06 08:51:08,991 INFO [FromKafka2Log] (Camel (camel-1) thread #0 - KafkaConsumer[test]) Message #8 [1] 2021-05-06 08:51:10,065 INFO [FromKafka2Log] (Camel (camel-1) thread #0 - KafkaConsumer[test]) Message #9 [1] 2021-05-06 08:51:10,991 INFO [FromKafka2Log] (Camel (camel-1) thread #0 - KafkaConsumer[test]) Message #10 [1] 2021-05-06 08:51:11,991 INFO [FromKafka2Log] (Camel (camel-1) thread #0 - KafkaConsumer[test]) Message #11
第 6 章 Camel K trait 配置参考
本章提供了在使用 特征 时可以在命令行中配置的高级功能和核心功能的参考信息。Camel K 提供 功能特征 来配置特定的功能和技术。Camel K 提供 平台特征 来配置内部 Camel K 核心功能。
Red Hat Integration - Camel K 1.6 包括 OpenShift
和 Knative
配置集。Kubernetes
配置集具有仅限社区的支持。它还包括 Java,以及用于集成的 YAML DSL 支持。XML、Groovy、JavaScript 和 Kotlin 等其它语言具有仅限社区的支持。
本章包括以下部分:
Camel K 功能特征
Camel K 核心平台特征
- 第 6.3.1 节 “builder Trait”
- 第 6.3.3 节 “Camel Trait”
- 第 6.3.2 节 “容器 Trait”
- 第 6.3.4 节 “依赖项 Trait”
- 第 6.3.5 节 “deployer Trait”
- 第 6.3.6 节 “Deployment Trait”
- 第 6.3.7 节 “环境跟踪”
- 第 6.3.8 节 “处理程序错误”
- 第 6.3.9 节 “JVM Trait”
- 第 6.3.10 节 “Kamelets Trait”
- 第 6.3.11 节 “OpenAPI Trait”- 技术预览
- 第 6.3.12 节 “所有者 Trait”
- 第 6.3.13 节 “平台 Trait”
- 第 6.3.14 节 “Quarkus Trait”
6.1. Camel K trait 和配置集配置
本节介绍 特征 和配置文件 的重要 Camel K 概念,这些概念用于在运行时配置高级 Camel K 功能。
Camel K traits
Camel K 特征是高级功能和核心功能,您可以在命令行中配置这些功能来自定义 Camel K 集成。例如,其中包括配置与 3scale API 管理、Quarkus、Knative 和 Prometheus 等技术交互 的功能特征。Camel K 还提供内部 平台特征 来配置重要的核心平台功能,如 Camel 支持、容器、依赖项解析和 JVM 支持。
Camel K 配置集
Camel K 配置集定义 Camel K 集成运行的目标云平台。支持的配置集是 OpenShift
和 Knative
配置集。
当您在 OpenShift 上运行集成时,当集群中安装 OpenShift Serverless 时,Camel K 会使用 Knative
配置集。如果没有安装 OpenShift
Serverless,Camel K 使用 OpenShift 配置集。
您还可以使用 kamel run --profile
选项在运行时指定配置集。
Camel K 为所有特征提供有用的默认值,考虑集成在其上运行的目标配置集。但是,高级用户可以为自定义行为配置 Camel K 特征。某些特征只适用于特定的配置集,如 OpenShift
或 Knative
。如需了解更多详细信息,请参阅每个特征描述中的可用配置集。
Camel K trait 配置
每个 Camel 特征都有一个唯一 ID,可用于在命令行中配置特征。例如,以下命令禁用为集成创建 OpenShift 服务:
kamel run --trait service.enabled=false my-integration.yaml
您还可以使用 -t
选项指定特征。
Camel K trait 属性
您可以使用 enabled
属性启用或禁用每个特征。所有特征都有自己的内部逻辑,用来决定在用户没有显式激活时是否需要启用它们。
禁用平台特征可能会破坏平台功能。
有些特征有一个 auto
属性,可用于根据环境启用或禁用特征的自动配置。例如,其中包括 3scale、Cron 和 Knative 的特征。如果没有显式设置,这个自动配置可以在 enabled
属性未明确设置时启用或禁用特征,并可以更改特征配置。
大多数特征都具有额外的属性,您可以在命令行中配置这些属性。如需了解更多详细信息,请参阅后面的部分中每个特征的描述。
6.2. Camel K 功能特征
6.2.1. Knative Trait
Knative 特征自动发现 Knative 资源的地址并将其注入正在运行的集成。
完整的 Knative 配置以 JSON 格式在 CAMEL_KNATIVE_CONFIGURATION 中注入。然后,Camel Knative 组件将使用完整配置来配置路由。
当 Knative 配置集处于活跃状态时,会默认启用特征。
此特征在以下配置集中提供: Knative。
6.2.1.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait knative.[key]=[value] --trait knative.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
| 可用于以 JSON 格式注入 Knative 完整的配置。 |
|
| 用作集成路由来源的频道列表。可以包含简单的频道名称或完整的 Camel URI。 |
|
| 用作集成路由目的地的频道列表。可以包含简单的频道名称或完整的 Camel URI。 |
|
| 用作集成路由来源的频道列表。 |
|
| 用作集成路由目的地的端点列表。可以包含简单的端点名称或完整的 Camel URI。 |
|
| 集成要订阅的事件类型列表。可以包含简单的事件类型或完整 Camel URI (使用与"默认")不同的特定代理。 |
|
| 集成将生成的事件类型列表。可以包含简单的事件类型或完整 Camel URI (使用特定的代理)。 |
|
| 启用对基于标头 "ce-knativehistory" 的事件进行过滤。因为这个标头在较新的 Knative 版本中删除,所以默认禁用过滤。 |
|
| 允许通过 Knative SinkBinding 资源将集成绑定到 sink。当集成以单个接收器(sink)为目标时使用。当集成以单一接收器(集成归 Knative 源所有)时,默认启用它。 |
|
| 启用所有特征属性的自动发现。 |
6.2.2. Knative Service Trait
Knative Service 特征允许在将集成作为 Knative 服务而非标准 Kubernetes Deployment 时配置选项。
以 Knative Services 运行集成会增加自动扩展(和缩减到零)功能,但只有在路由使用 HTTP 端点消费者时这些功能才有意义。
此特征在以下配置集中提供: Knative。
6.2.2.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait knative-service.[key]=[value] --trait knative-service.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
|
配置 Knative 自动扩展类属性(例如,设置 如需更多信息,请参阅 Knative 文档。 |
|
|
配置 Knative autoscaling 指标属性(例如,设置基于 如需更多信息,请参阅 Knative 文档。 |
|
| 为每个 Pod 设置允许的并发级别或 CPU 百分比(取决于自动扩展指标)。 如需更多信息,请参阅 Knative 文档。 |
|
| 对于集成,任何时候应运行最少的 Pod 数量。默认情况下是 零个,这意味着当没有配置的时间时,集成会缩减为零。 如需更多信息,请参阅 Knative 文档。 |
|
| 可以并行运行用于集成的 Pod 数量的上限。Knative 都有自己的大写值,它依赖于安装。 如需更多信息,请参阅 Knative 文档。 |
|
| 当所有条件都存在时,自动将集成部署为 Knative 服务:
|
6.2.3. Prometheus Trait
Prometheus trait 配置了一个与 Prometheus 兼容的端点。它还会创建一个 PodMonitor
资源,以便在使用 Prometheus operator 时自动提取端点。
这些指标通过 MicroProfile Metrics 公开。
创建 PodMonitor
资源需要安装 Prometheus Operator 自定义资源定义。您可以将 pod-monitor
设置为 false
,以便 Prometheus 特征在没有 Prometheus Operator 的情况下工作。
Prometheus trait 被默认禁用。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
6.2.3.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait prometheus.[key]=[value] --trait prometheus.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
|
是否创建 |
|
|
|
6.2.4. PDB Trait
PDB 特征可为集成 pod 配置 PodDisruptionBudget 资源。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
6.2.4.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait pdb.[key]=[value] --trait pdb.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
|
驱除后必须仍然可用集成的 pod 数量。它可以是绝对数字,也可以是一个百分比。只能指定 |
|
|
驱除后可无法使用的集成的 pod 数量。它可以是绝对数字或百分比(如果未设置 |
6.2.5. pull Secret Trait
Pull Secret 特征在 pod 上设置 pull secret,以允许 Kubernetes 从外部 registry 检索容器镜像。
可以手动指定 pull secret,或者当您为 IntegrationPlatform
上的外部容器 registry 配置身份验证时,可以使用相同的 secret 来拉取镜像。
每当您为外部容器注册表配置身份验证时,它会默认启用,因此它会假定外部 registry 是私有的。
如果您的 registry 不需要身份验证来拉取镜像,您可以禁用这个特征。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
6.2.5.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait pull-secret.[key]=[value] --trait pull-secret.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
|
Pod 上设置的 pull secret 名称。如果留空,则会自动从 |
|
|
在将全局操作员与共享平台搭配使用时,这会将 operator 命名空间中的 |
|
|
如果 pod 类型为 |
6.2.6. Route Trait
路由特征可用于配置用于集成的 OpenShift 路由。
证书和密钥内容可以从本地文件系统或 Openshift secret
对象中提供。用户可以使用以 -secret
结尾的参数(例如: tls-certificate-secret
)来引用存储在 secret
中的证书。以 -secret
结尾的参数具有更高的优先级,如果设置了相同的路由参数,例如: tls-key-secret
和 tls-key
,然后使用 tls-key-secret
。设置密钥和证书的建议方法是使用 secret
来存储其内容,并使用以下参数来引用它们: tls-certificate-secret
,tls-key-secret
,tls-ca-certificate-secret
,tls-destination-ca-certificate-secret
see this page 末尾的 example 部分来查看设置选项。
此特征在以下配置集中提供: OpenShift。
6.2.6.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait route.[key]=[value] --trait route.[key2]=[value2] integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
| 配置路由公开的主机。 |
|
|
TLS 终止类型,如 如需更多信息,请参阅 OpenShift 路由文档。 |
|
| TLS 证书内容。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
| secret 名称和密钥引用 TLS 证书。格式为 "secret-name[/key-name]",其值代表 secret 名称,如果 secret 中只有一个密钥,否则您可以设置使用 "/" 分隔的键名称。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
| TLS 证书密钥内容。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
| secret 名称和密钥引用 TLS 证书密钥。格式为 "secret-name[/key-name]",其值代表 secret 名称,如果 secret 中只有一个密钥,否则您可以设置使用 "/" 分隔的键名称。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
| TLS CA 证书内容。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
| 对 TLS CA 证书的 secret 名称和密钥引用。格式为 "secret-name[/key-name]",其值代表 secret 名称,如果 secret 中只有一个密钥,否则您可以设置使用 "/" 分隔的键名称。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
| 目标 CA 证书提供最终目的地的 ca 证书的内容。使用重新加密终止时,应提供此文件,以便让路由器将它用于安全连接上的健康检查。如果没有指定此字段,路由器可能会提供自己的目标 CA,并使用短服务名称(service.namespace.svc)执行主机名验证,它允许基础架构生成的证书自动验证。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
| 对目标 CA 证书的 secret 名称和密钥引用。格式为 "secret-name[/key-name]",其值代表 secret 名称,如果 secret 中只有一个密钥,否则您可以设置使用 "/" 分隔的键名称。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
|
要配置如何处理不安全的流量,例如, 如需更多信息,请参阅 OpenShift 路由文档。 |
6.2.6.2. 例子
这些示例使用 secret 存储集成中要引用的证书和密钥。有关路由的详细信息,请阅读 Openshift 路由文档。platform HttpServer.java 是集成示例。
作为运行这些示例的要求,您应该有一个带有密钥和证书的 secret
。
6.2.6.2.1. 生成自签名证书并创建 secret
openssl genrsa -out tls.key openssl req -new -key tls.key -out csr.csr -subj "/CN=my-server.com" openssl x509 -req -in csr.csr -signkey tls.key -out tls.crt oc create secret tls my-combined-certs --key=tls.key --cert=tls.crt
6.2.6.2.2. 向路由发出 HTTP 请求
对于所有示例,您可以使用以下 curl 命令发出 HTTP 请求。它使用内联脚本来检索 openshift 命名空间和集群基域,如果您使用不支持这些内联脚本的 shell,您应该将内联脚本替换为实际命名空间和基域的值。
curl -k https://platform-http-server-`oc config view --minify -o 'jsonpath={..namespace}'`.`oc get dnses/cluster -ojsonpath='{.spec.baseDomain}'`/hello?name=Camel-K
要使用 secret 添加 边缘路由,请使用以
-secret
结尾的参数设置包含证书的 secret 名称。此路由特征引用名为my-combined-certs
的 secret,其包含名为tls.key
和tls.crt
的两个密钥。kamel run --dev PlatformHttpServer.java -t route.tls-termination=edge -t route.tls-certificate-secret=my-combined-certs/tls.crt -t route.tls-key-secret=my-combined-certs/tls.key
要使用 secret 添加 透传 路由,TLS 在集成 pod 中被设置,在运行的集成 pod 中应该可以看到这些密钥和证书,以便实现此目的,我们在集成 pod 中挂载 secret,然后我们使用 some camel quarkus 参数在运行的 pod 中引用这些证书文件,它们以
-prkus.http.ssl.ssl.ssl.certificate
开头。此路由特征引用名为
my-combined-certs
的 secret,其包含名为tls.key
和tls.crt
的两个密钥。kamel run --dev PlatformHttpServer.java --resource secret:my-combined-certs@/etc/ssl/my-combined-certs -p quarkus.http.ssl.certificate.file=/etc/ssl/my-combined-certs/tls.crt -p quarkus.http.ssl.certificate.key-file=/etc/ssl/my-combined-certs/tls.key -t route.tls-termination=passthrough -t container.port=8443
要使用 secret 添加 重新加密路由,TLS 在集成 pod 中被设置,在运行的集成 pod 中应看到密钥和证书,以
--resource
kamel 参数在集成 pod 中挂载 secret,然后我们使用 some camel quarkus 参数在运行的 pod 中引用这些证书文件,它们以-p quarkus.http.ssl.ssl.certificate.ssl.certificate
.此路由特征引用名为my-combined-certs
的 secret,其包含名为tls.key
和tls.crt
的两个密钥。kamel run --dev PlatformHttpServer.java --resource secret:my-combined-certs@/etc/ssl/my-combined-certs -p quarkus.http.ssl.certificate.file=/etc/ssl/my-combined-certs/tls.crt -p quarkus.http.ssl.certificate.key-file=/etc/ssl/my-combined-certs/tls.key -t route.tls-termination=reencrypt -t route.tls-destination-ca-certificate-secret=my-combined-certs/tls.crt -t route.tls-certificate-secret=my-combined-certs/tls.crt -t route.tls-key-secret=my-combined-certs/tls.key -t container.port=8443
使用来自路由和 Openshift 服务证书 的特定证书为集成端点添加 重新加密路由,请执行以下操作:这样,Openshift 服务证书只在集成 pod 中设置。在运行中的集成 pod 中应该可以看到密钥和证书,以达到此目的,我们使用
--resource
kamel 参数将 secret 挂载到集成 pod 中,然后我们使用 some camel quarkus 参数来引用正在运行的 pod 中的这些证书文件,它们以-p quarkus.http.ssl.certificate
开头。此路由特征引用名为my-combined-certs
的 secret,其包含名为tls.key
和tls.crt
的两个密钥。kamel run --dev PlatformHttpServer.java --resource secret:cert-from-openshift@/etc/ssl/cert-from-openshift -p quarkus.http.ssl.certificate.file=/etc/ssl/cert-from-openshift/tls.crt -p quarkus.http.ssl.certificate.key-file=/etc/ssl/cert-from-openshift/tls.key -t route.tls-termination=reencrypt -t route.tls-certificate-secret=my-combined-certs/tls.crt -t route.tls-key-secret=my-combined-certs/tls.key -t container.port=8443
然后,您应注解集成服务以注入 Openshift 服务证书
oc annotate service platform-http-server service.beta.openshift.io/serving-cert-secret-name=cert-from-openshift
使用您本地文件系统提供的证书和私钥添加 边缘路由。本例使用内联脚本读取证书和私钥文件内容,然后删除所有新行字符(这是把证书设置为参数值),因此这些值位于一行中。
kamel run PlatformHttpServer.java --dev -t route.tls-termination=edge -t route.tls-certificate="$(cat tls.crt|awk 'NF {sub(/\r/, ""); printf "%s\\n",$0;}')" -t route.tls-key="$(cat tls.key|awk 'NF {sub(/\r/, ""); printf "%s\\n",$0;}')"
6.2.7. Service Trait
Service trait 会公开与 Service 资源的集成,以便在同一命名空间中的其他应用程序(或集成)可以访问它。
如果集成依赖于可公开 HTTP 端点的 Camel 组件,它默认启用。
此特征在以下配置集中提供: Kubernetes、OpenShift。
6.2.7.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait service.[key]=[value] --trait service.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
| 如果需要创建服务,从代码中自动检测。 |
|
| 启用 Service 以作为 NodePort 公开 |
6.3. Camel K 平台特征
6.3.1. builder Trait
构建器特征在内部用来决定用于构建和配置 IntegrationKits 的最佳策略。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
构建器特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.1.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait builder.[key]=[value] --trait builder.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
| 在支持它的构建组件(如 OpenShift 构建 pod)上启用详细记录。不支持 Kaniko 和 Buildah。 |
|
| 要提供给构建任务的属性列表 |
6.3.2. 容器 Trait
容器特征可用于配置运行集成的容器的属性。
它还为与容器关联的服务提供配置。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
容器特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.2.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait container.[key]=[value] --trait container.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
| |
|
| 需要的最小 CPU 量。 |
|
| 需要的最小内存量。 |
|
| 需要的最大 CPU 量。 |
|
| 需要的最大内存量。 |
|
| 可用于通过 kubernetes 服务启用/禁用暴露。 |
|
|
要配置容器公开的不同端口(默认值 |
|
|
要为容器公开的端口配置不同的端口名称(默认为 |
|
|
要配置要公开容器端口的服务端口(默认为 |
|
|
要在哪个服务端口名称下配置要公开容器端口(默认为 |
|
|
主容器名称。默认会命名的 |
|
| 主容器镜像 |
|
|
ProbesEnabled enable/disable probes on the container (default |
|
| 在启动存活度探测前容器启动后的秒数。 |
|
| 探测超时的秒数。应用到存活度探测。 |
|
| 执行探测的频率。应用到存活度探测。 |
|
| 在失败后,探测的最小连续成功才被视为成功。应用到存活度探测。 |
|
| 在成功后,探测的最小连续故障会被视为失败。应用到存活度探测。 |
|
| 容器启动后的秒数,然后启动就绪度探测。 |
|
| 探测超时的秒数。适用于就绪度探测。 |
|
| 执行探测的频率。适用于就绪度探测。 |
|
| 在失败后,探测的最小连续成功才被视为成功。适用于就绪度探测。 |
|
| 在成功后,探测的最小连续故障会被视为失败。适用于就绪度探测。 |
6.3.3. Camel Trait
Camel 特征可用于配置 Apache Camel K 运行时和相关库的版本,它无法禁用。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
camel trait 是一个 平台特征 :禁用它可能会破坏平台功能。
6.3.3.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait camel.[key]=[value] --trait camel.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
6.3.4. 依赖项 Trait
依赖项特征内部用于根据用户要运行的集成自动添加运行时依赖项。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
依赖项特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.4.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait dependencies.[key]=[value] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
6.3.5. deployer Trait
deployer 特征可用于明确选择部署集成的高级别资源类型。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
部署器特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.5.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait deployer.[key]=[value] --trait deployer.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
|
允许在创建用于运行集成的资源时, |
6.3.6. Deployment Trait
Deployment 特征负责生成 Kubernetes 部署,以确保集成在集群中运行。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
部署特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.6.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait deployment.[key]=[value] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
6.3.7. 环境跟踪
环境特征用于在集成容器中注入标准环境变量,如 NAMESPACE
、POD_NAME
等等。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
环境特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.7.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait environment.[key]=[value] --trait environment.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
|
启用 |
6.3.8. 处理程序错误
error-handler 是一个平台特征,用于将 Error Handler 源注入集成运行时。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
error-handler 特征是 平台特征 :禁用它可能会破坏平台功能。
6.3.8.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait error-handler.[key]=[value] --trait error-handler.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
| 在应用程序属性中提供或找到错误处理器 ref 名称 |
6.3.9. JVM Trait
JVM 特征用于配置运行集成的 JVM。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
jvm 特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.9.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait jvm.[key]=[value] --trait jvm.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
| 激活远程调试,以便可以使用端口转发将调试器连接到 JVM (如 ) |
|
| 在载入主类前立即挂起目标 JVM |
|
|
在容器日志中打印用于启动 JVM 的命令(默认值 |
|
|
侦听新启动的 JVM 的传输地址(默认为 |
|
| JVM 选项列表 |
|
|
其他 JVM 类路径(使用 |
6.3.9.2. 例子
包括一个到
Integration
的额外类路径:$ kamel run -t jvm.classpath=/path/to/my-dependency.jar:/path/to/another-dependency.jar ...
6.3.10. Kamelets Trait
kamelets 特征是将 Kamelets 注入集成运行时的平台特征。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
kamelets 特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.10.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait kamelets.[key]=[value] --trait kamelets.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
| 自动注入所有引用的 Kamelets 及其默认配置(默认启用) |
|
| 要加载到当前集成的 Kamelet 名称的逗号分隔列表 |
6.3.11. OpenAPI Trait
OpenAPI DSL 特征在内部用来从 OpenAPI specs 创建集成。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
openapi 特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.11.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait openapi.[key]=[value] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
6.3.12. 所有者 Trait
Owner 特征可确保所有创建的资源都属于正在创建的集成,并将资源上的注解和标签传输到这些拥有的资源。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
所有者特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.12.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait owner.[key]=[value] --trait owner.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
| 要传输的注解集合 |
|
| 要传输的标签集合 |
6.3.13. 平台 Trait
平台特征是一个基础特征,用于为集成分配集成平台。
如果缺少平台,则允许创建默认平台。此功能在不需要为平台提供自定义配置的情况下特别有用(例如,在 OpenShift 的默认设置中,因为存在内嵌的容器镜像 registry)。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
平台特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.13.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait platform.[key]=[value] --trait platform.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
|
| 当平台缺失时,要创建默认(空)平台。 |
|
| 表示在全局操作员(默认为 true)时是否应全局创建该平台。 |
|
| 如果要自动创建默认平台(仅在 OpenShift 中创建)来自动检测环境。 |
6.3.14. Quarkus Trait
Quarkus 遍历激活 Quarkus 运行时。
它被默认启用。
此特征在以下配置集中提供: Kubernetes、Knative、OpenShift。
限定特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.14.1. 配置
运行任何与 CLI 的集成时,可以指定特征属性:
$ kamel run --trait quarkus.[key]=[value] --trait quarkus.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | Description |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享此通用属性。 |
6.3.14.2. 支持的 Camel 组件
在启用了 Quarkus 的情况下运行时,Camel K 只支持这些 Camel 组件作为 Camel Quarkus 扩展可用。您可以看到 Camel Quarkus 文档中的扩展列表。
第 7 章 Camel K 命令参考
本章详细介绍了 Camel K 命令行界面(CLI),并提供使用 kamel
命令的示例。本章还提供了您可以在运行时执行的 Camel K 集成源文件的 Camel K 模式选项的参考详情。
本章包括以下部分:
7.1. Camel K 命令行
Camel K CLI 提供 kamel
命令,作为在 OpenShift 上运行 Camel K 集成的主要入口点。
7.1.1. 支持的命令
请注意以下密钥:
符号 | Description |
---|---|
✔ | 支持 |
❌ | 不支持或者还没有支持 |
名称 | 支持 | Description | Example |
---|---|---|---|
| ✔ | 在集成流中绑定 Kubernetes 资源,如 Kamelets,到 Knative 频道、Kafka 主题或任何其他端点。 |
|
| ❌ | 生成完成脚本。 |
|
| ❌ | 使用本地调试器调试远程集成。 |
|
| ✔ | 删除部署在 OpenShift 上的集成。 |
|
| ✔ |
获取 Camel K 资源的详细信息。这包括 |
|
| ✔ | 获取在 OpenShift 中部署的集成状态。 |
|
| ✔ |
获取可用命令的完整列表。您可以输入 |
|
| ✔ | 初始化在 Java 或 YAML 中实施的空 Camel K 文件。 |
|
| ❌ | 在 OpenShift 集群上安装 Camel K。 注: 建议您使用 OpenShift Camel K Operator 来安装和卸载 Camel K。 |
|
| ❌ | 配置集成套件。 |
|
| ❌ | 本地执行集成操作,给定了一组输入集成文件。 |
|
| ✔ | 显示正在运行的集成的日志。 |
|
| ✔ | 清除一个或多个集成的状态,从而导致重建。 |
|
| ❌ | 重置当前的 Camel K 安装。 |
|
| ✔ | 在 OpenShift 上运行集成。 |
|
| ❌ | 从 OpenShift 集群卸载 Camel K。 注: 建议您使用 OpenShift Camel K Operator 来安装和卸载 Camel K。 |
|
| ✔ | 显示 Camel-K 客户端版本。 |
|
其他资源
7.2. Camel K 模式选项
您可以使用 Camel K modeline 在 Camel K 集成源文件中输入配置选项,例如,在运行时使用 kamel 运行 MyIntegration.java
。如需了解更多详细信息,请参阅 使用模式 来运行 Camel K 集成。
所有适用于 kamel run
命令的选项,您可以指定为模式选项。
下表描述了一些最常用的模式选项。
Option | Description |
---|---|
| 添加构建属性或构建属性文件。
Syntax: |
| 从 Configmap、Secret 或文件添加运行时配置
Syntax:
-
- |
| 包含外部库(例如,Maven 依赖项)
示例: |
|
在集成容器中设置环境变量。例如: |
|
为集成添加标签。例如, |
|
添加集成名称。例如: |
|
添加 OpenAPI v2 规格。例如, |
|
设置用于部署的 Camel K 特征配置文件。例如: |
| 添加运行时属性或运行时属性文件。
Syntax: |
| 从 ConfigMap、Secret 或文件添加运行时资源
Syntax:
-
- |
|
在特征中配置 Camel K 功能或核心功能。例如, |