使用 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 集成
- 有关管理集成的工具的详情,请参考红帽 为 Apache Camel K 的 VS Code 工具
1.2. 管理 Camel K 集成日志记录级别
Camel K 使用 Quarkus 日志机制作为集成的日志框架。您可以在运行时在命令行中配置各种日志记录器的日志记录级别,方法是将 quarkus.log.category 前缀指定为集成属性。例如:
示例
--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在终端中终止登录。
其他资源
- 有关日志记录框架的详情,请参考 配置日志格式
- 有关查看日志记录的开发工具详情,请参阅红帽的 Apache Camel K 的 VS Code 工具
1.3. 扩展 Camel K 集成
您可以使用 oc scale 命令扩展集成。
流程
要扩展 Camel K 集成,请运行以下命令:
oc scale it <integration_name> --replicas <number_of_replicas>
您还可以直接编辑 Integration 资源来扩展集成。
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-configConfigMap:$ oc -n openshift-monitoring create configmap cluster-monitoring-config
编辑
cluster-monitoring-configConfigMap:$ 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 特征配置对 Camel K 集成的监控。这会自动执行依赖项和集成 Pod 的配置,以公开一个指标端点,然后由 Prometheus 发现并显示。Camel Quarkus MicroProfile 指标扩展 自动以 OpenMetrics 格式收集和公开默认 Camel K 指标。
先决条件
- 您必须在 OpenShift 中已启用对您自己的服务的监控。请参阅 在 OpenShift 中启用用户工作负载监控。
流程
输入以下命令运行您的 Camel K 集成并启用了 Prometheus trait:
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 控制台中,在 Insert Metric at Cursor 下输入
application_camel_context_uptime_seconds,然后单击 Run Queries。 - 点 Add Query 查看其他指标。
2.3. 添加自定义 Camel K 集成指标
您可以使用 Camel MicroProfile 指标组件和 Java 代码注解将自定义指标添加到您的 Camel K 集成。然后,Prometheus 将自动发现和显示这些自定义指标。
本节演示了将 Camel MicroProfile 指标注释添加到 Camel K 集成和服务实施代码的示例。
先决条件
- 您必须在 OpenShift 中已启用对您自己的服务的监控。请参阅 在 OpenShift 中启用用户工作负载监控。
流程
使用 Camel MicroProfile 指标组件注释,在您的 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 集成调用
的服务,它会生成随机故障: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 模式line 来自动配置 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 监控端点公开以下指标:
表 3.1. Camel K operator 指标
| 名称 | 类型 | 描述 | 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 指标,您可以在 troubleshooting ServiceMonitor 更改 中查找更多信息,这也适用于
PodMonitor资源故障排除。
3.3. Camel K operator 警报
您可以创建 PrometheusRule 资源,以便 OpenShift 监控堆栈中的 AlertManager 实例可以根据 Camel K operator 公开的指标来触发警报。
示例
您可以根据公开的指标创建一个带有警报规则的 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 资源中定义的警报规则。
| 名称 | 重要性 | 描述 |
|---|---|---|
|
| warning | 协调请求超过 10% 的持续时间,超过 0.5 以上,至少有 1 分钟。 |
|
| warning | 超过 1% 的协调请求失败至少 10 分钟。 |
|
| warning | 超过 10% 的成功构建的时间已超过 2 分钟超过 1 分钟。 |
|
| critical | 成功构建的超过 1% 的时间已超过 5 分钟超过 1 分钟。 |
|
| critical | 构建超过 1% 的构建错误至少增加了 10 分钟。 |
|
| warning | 超过 1% 的构建队列已排队超过 1 分钟以上。 |
|
| critical | 超过 1% 的构建排队了超过 5 分钟以上时间超过 1 分钟。 |
您可以在 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 中快速配置数据源,如链接所示:将 Camel K 与数据库示例配置连接。
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 文件选项指定属性文件: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 机密中提供资源信息。
使用以下 kamel run 选项:
--property使用
--property选项直接在命令行中指定运行时属性,或通过引用 Java*.properties文件。Camel K operator 将属性文件的内容附加到运行的集成的user.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 operator 不会解析属性的资源,也不会将资源添加到类路径中。(如果要将资源添加到类路径,您可以使用集成中的 JVM 特征。
4.2.1. 提供运行时属性
您可以在命令行中直接指定运行时属性,或使用 kamel run 命令的 -- properties 选项引用 Java *.properties 文件。
当您运行与 --property 选项的集成时,Camel K operator 会将属性附加到正在运行的集成 user.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 file 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 机密中提供配置值。
运行集成时,Camel K 操作器会准备提供的文件,并将其添加到类路径中,以便您可以引用集成代码中的配置值,而无需提供准确的位置。
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"
流程
创建 Camel K 集成来引用 ConfigMap。
例如,以下集成(名为
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 来安全地包含配置信息。为提高 secret 使其可用于 Camel K 集成,您可以使用 --config secret 语法。
先决条件
- 设置 Camel K 开发环境
您已在 OpenShift 集群中存储了一个或多个 Secret。
例如,您可以使用以下命令创建 Secret:
oc create secret generic my-sec --from-literal=my-secret-key="very top secret"
流程
创建 Camel K 集成来引用 ConfigMap。
例如,以下集成(named
ConfigSecretRoute.java)引用my-secret属性,该属性位于名为my-sec的 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-multisecret 中某一源的 属性。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 operator 不会解析查找运行时属性的资源,它不会将资源添加到类路径中。(如果要将资源添加到类路径,您可以使用 JVM 特征。
4.2.3.1. 将文本或二进制文件指定为资源
如果您有一个包含配置值的文本或二进制文件,您可以使用 --resource file:/path/to/file 选项来整理该文件。默认情况下,Camel K 操作器会将资料化文件复制到 /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"
流程
创建一个 Camel K 集成,该集成引用存储在 OpenShift 集群中的 ConfigMap。
例如,以下集成(名为
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 operator 会使用 ConfigMap 的内容挂载一个卷(如
my-configmap-key)。
注: 如果您指定了集群中还没有可用的 ConfigMap,则集成会在 ConfigMap 可用时等待并启动。
4.2.3.3. 将 Secret 指定为资源
如果您有包含配置信息的 OpenShift Secret,且您需要将它作为一个或多个集成可用的资源进行整理,请使用 --resource <secret> 语法。
先决条件
- 设置 Camel K 开发环境
您有一个或多个存储在 OpenShift 集群上的 Secret 文件。例如,您可以使用以下命令创建 Secret:
oc create secret generic my-sec --from-literal=my-secret-key="very top secret"
流程
创建一个 Camel K 集成,该集成引用存储在 OpenShift 集群中的 Secret。
例如,以下集成(名为
ResourceSecretRoute.java)会引用my-secSecret: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 operator 会挂载一个带有 Secret 的内容的卷(如
my-sec)。
注: 如果您指定了集群中还没有可用的 Secret,则集成会在 Secret 可用时等待并启动。
4.2.3.4. 为资源指定目标路径
/etc/camel/resources/ 目录是挂载您通过 --resource 选项指定的资源的默认位置。如果您需要指定挂载资源的不同目录,请使用 --resource @path 语法。
先决条件
- 设置 Camel K 开发环境
- 您有一个文件、ConfigMap 或 Secret,其中包含一个或多个配置属性。
流程
创建引用包含配置属性的文件 ConfigMap 或 Secret 的 Camel K 集成。例如,以下集成(名为
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 时,您可以指定多个信息源。例如,以下命令从两个源创建一个 ConfigMap(名为 my-cm-multi):
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-multiConfigMap: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")
...
由于此集成具有以MAP: 前缀开头的 端点,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。
本例演示如何为 Apache Kafka 使用 Red Hat OpenShift Streams 设置 Kafka 主题,并在一个简单的 Producer/Consumer 模式集成中使用它。
5.1. 设置 Kafka
设置 Kafka 涉及安装所需的 OpenShift 操作器、创建 Kafka 实例并创建 Kafka 主题。
使用其中一个红帽产品设置 Kafka:
- Red Hat Advanced Message Queuing(AMQ)流 - 自我管理的 Apache Kafka 产品。AMQ Streams 基于开源 Strimzi,它包含在 Red Hat Integration 中。AMQ Streams 是一个基于 Apache Kafka 的分布式、可扩展的流平台,它包括发布/订阅消息传递代理。Kafka Connect 提供了一个框架,用于将基于 Kafka 的系统与外部系统集成。使用 Kafka Connect,您可以配置源和接收器连接器,将数据从外部系统流传输到 Kafka 代理。
- Red Hat OpenShift Streams for Apache Kafka - 一个受管云服务,简化了运行 Apache Kafka 的过程。它为构建、部署和扩展新的云原生应用程序或对现有系统进行现代化提供了简化的开发人员体验。
5.1.1. 使用 AMQ 流设置 Kafka
AMQ Streams 简化了在 OpenShift 集群中运行 Apache Kafka 的过程。
5.1.1.1. 为 AMQ Streams 准备 OpenShift 集群
要使用 Camel K 或 Kamelets 和红帽 AMQ Streams,您必须安装以下操作程序和工具:
- Red Hat Integration - AMQ Streams operator - 管理 Openshift Cluster 和 Apache Kafka 实例的 AMQ Streams 之间的通信。
- 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 Topic 下,点击 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 用于 Apache Kafka 管理的云服务,您必须安装以下操作程序和工具:
- OpenShift Application Services(RHOAS)CLI - 允许您从终端管理应用程序服务。
- Red Hat Integration - Camel K operator 安装并管理 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,如 Getting started with 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 Cloud 网站。
流程
使用 Red Hat OpenShift Streams for Apache Kafka 设置 Kafka 主题:
- 从命令行,登录您的 OpenShift 集群。
打开您的项目,例如:
oc project my-camel-k-kafka验证项目中是否安装了 Camel K Operator:
oc get csv结果列出了 Red Hat Camel K operator,并表示它处于
Succeeded阶段。准备并将 Kafka 实例连接到 RHOAS:
使用以下命令登录到 RHOAS CLI:
RHOAS 登录创建一个 kafka 实例,如 kafka-test :
RHOAS kafka 创建 kafka-test创建 Kafka 实例的过程可能需要几分钟时间。
检查 Kafka 实例的状态:
RHOAS 状态您还可以在 web 控制台中查看状态:
https://cloud.redhat.com/application-services/streams/kafkas/
状态 就绪时,请继续下一步。
创建新的 Kafka 主题:
RHOAS kafka 主题创建 --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
您可以使用您获取的凭证(Kafka bootstrap URL、服务帐户 ID 和服务帐户 secret)创建 secret。
流程
编辑
application.properties文件并添加 Kafka 凭证。application.properties file
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
您可以使用您获取的凭证(Kafka bootstrap URL、服务帐户 ID 和服务帐户 secret)创建 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 秒。
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!
运行消费者集成
创建消费者集成。
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 节 “dependencies Trait”
- 第 6.3.5 节 “deployer Trait”
- 第 6.3.6 节 “Deployment Trait”
- 第 6.3.7 节 “环境 Trait”
- 第 6.3.8 节 “error Handler Trait”
- 第 6.3.9 节 “JVM Trait”
- 第 6.3.10 节 “Kamelets Trait”
- 第 6.3.11 节 “OpenAPI Trait”- 技术预览
- 第 6.3.12 节 “所有者 Trait”
- 第 6.3.13 节 “platform Trait”
- 第 6.3.14 节 “Quarkus Trait”
6.1. Camel K trait 和配置集配置
本节介绍运行时用于配置高级 Camel K 功能的重要 Camel K 概念和配置文件。
Camel K traits
Camel K 特征是高级功能和核心功能,您可以在命令行中配置 以自定义 Camel K 集成。例如,这包括配置与 3scale API Management、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
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
| 可用于以 JSON 格式注入 Knative 完整配置。 |
|
|
| 用作集成路由源的频道列表。可以包含简单频道名称或完整的 Camel URI。 |
|
|
| 用作集成路由目的地的频道列表。可以包含简单频道名称或完整的 Camel URI。 |
|
|
| 用作集成路由源的频道列表。 |
|
|
| 用作集成路由目的地的端点列表。可以包含简单端点名称或完整的 Camel URI。 |
|
|
| 集成将订阅的事件类型列表。可以包含简单事件类型或完整的 Camel URI(使用与 "default" 不同的特定代理)。 |
|
|
| 集成生成的事件类型列表。可以包含简单事件类型或完整的 Camel URI(使用特定代理)。 |
|
|
| 根据标头 "ce-knativehistory" 启用对事件进行过滤。因为这个标头已在较新版本的 Knative 中删除,所以默认禁用过滤。 |
|
|
| 允许通过 Knative SinkBinding 资源将集成绑定到 sink。当集成目标一个 sink 时,可以使用它。当集成目标单个接收器(集成由 Knative 源所有时除外)时,它会被默认启用。 |
|
|
| 启用自动发现所有特征属性。 |
6.2.2. Knative Service Trait
Knative Service trait 可用于在作为 Knative 服务运行集成时配置选项,而不是标准 Kubernetes Deployment。
作为 Knative 服务运行集成会添加自动扩展(和缩减到零)功能,但只有路由使用 HTTP 端点消费者时,这些功能才有意义。
以下配置集中提供了这个特征: Knative。
6.2.2.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait knative-service.[key]=[value] --trait knative-service.[key2]=[value2] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
|
配置 Knative autoscaling 类属性(如设置 如需更多信息,请参阅 Knative 文档。 |
|
|
|
配置 Knative autoscaling 指标属性(例如,用于设置基于 如需更多信息,请参阅 Knative 文档。 |
|
|
| 为每个 Pod 设置允许的并发级别或 CPU 百分比(取决于自动扩展指标)。 如需更多信息,请参阅 Knative 文档。 |
|
|
| 在集成过程中,应随时运行的最低 Pod 数量。默认 为零,表示当不用于配置的时间时,集成会缩减为零。 如需更多信息,请参阅 Knative 文档。 |
|
|
| 为集成并行运行的 Pod 数量有一个上限。Knative 具有自己的 cap 值,它依赖于安装。 如需更多信息,请参阅 Knative 文档。 |
|
|
| 满足所有条件时,自动部署集成作为 Knative 服务:
|
6.2.3. Prometheus Trait
Prometheus 特征配置与 Prometheus 兼容的端点。它还会创建一个 PodMonitor 资源,以便在使用 Prometheus operator 时自动提取端点。
指标通过 MicroProfile 指标公开。
创建 PodMonitor 资源需要安装 Prometheus Operator 自定义资源定义。您可以将 pod-monitor 设置为 false,以便 Prometheus 特征在没有 Prometheus Operator 的情况下工作。
Prometheus 特征默认为禁用。
以下配置集提供了这个特征: Kubernetes、Knative、OpenShift。
6.2.3.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait prometheus.[key]=[value] --trait prometheus.[key2]=[value2] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
|
是否创建了 |
|
|
|
|
6.2.4. PDB Trait
PDB 特征允许为 Integration pod 配置 PodDisruptionBudget 资源。
以下配置集提供了这个特征: Kubernetes、Knative、OpenShift。
6.2.4.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait pdb.[key]=[value] --trait pdb.[key2]=[value2] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
|
驱除后必须仍然可用的集成 pod 数量。它可以是绝对数字或一个百分比。只能指定 |
|
|
|
驱除后可不可用的集成的 pod 数量。它可以是绝对数字或百分比(如果未设置 |
6.2.5. pull Secret Trait
Pull Secret trait 在 pod 上设置一个 pull secret,以允许 Kubernetes 从外部 registry 检索容器镜像。
pull secret 可以手动指定,或者当您为 IntegrationPlatform 上的外部容器 registry 配置身份验证时,会使用相同的 secret 来拉取镜像。
每当您为外部容器 registry 配置身份验证时,它会被默认启用,因此它会假定外部 registry 为私有。
如果您的 registry 不需要身份验证来拉取镜像,您可以禁用这个特征。
以下配置集提供了这个特征: Kubernetes、Knative、OpenShift。
6.2.5.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait pull-secret.[key]=[value] --trait pull-secret.[key2]=[value2] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
|
要在 Pod 上设置的 pull secret 名称。如果留空,则会自动从 |
|
|
|
在将全局 Operator 与共享平台搭配使用时,这启用了将 Operator 命名空间中的 |
|
|
|
如果平台 registry secret 是 |
6.2.6. route Trait
Route 特征可用于配置为集成创建 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、tls-destination-ca-certificate-secret,请参阅本页面末尾的示例部分,以查看设置选项。
以下配置集中提供了此特征: OpenShift。
6.2.6.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait route.[key]=[value] --trait route.[key2]=[value2] integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
| 配置由路由公开的主机。 |
|
|
|
TLS 终止类型,如 如需更多信息,请参阅 OpenShift 路由文档。 |
|
|
| TLS 证书内容。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
|
| 对 TLS 证书的 secret 名称和密钥引用。格式为 "secret-name[/key-name]",如果 secret 中只有一个键,则代表 secret 名称,否则您可以设置一个键名称以 "/" 分隔。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
|
| TLS 证书密钥内容。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
|
| 对 TLS 证书密钥的 secret 名称和密钥引用。格式为 "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 添加 passthrough 路由,TLS 在集成 pod 中是设置,在运行集成 pod 中应该可以看到密钥和证书,以便使用
--resourcekamel 参数在集成 pod 中挂载 secret,然后使用一些 camel quarkus 参数在运行的 pod 中引用这些证书文件,它们以-prkus.http.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 中应该可以看到密钥和证书,以便使用
--resourcekamel 参数在集成 pod 中挂载 secret,然后使用一些 camel quarkus 参数在运行的 pod 中引用这些证书文件,它们以-prkus.http.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=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
使用来自路由的 secret 的特定证书添加 重新加密路由,并为集成端点使用 Openshift service serving 证书。这样,Openshift 服务证书只在集成 pod 中设置。密钥和证书应该在运行的集成 pod 中可见,以便实现这一点,使用
--resourcekamel 参数在集成 pod 中挂载 secret,然后使用一些 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 特征公开与 Service 资源集成,以便同一命名空间中的其他应用程序(或集成)可以访问它。
如果集成依赖于可公开 HTTP 端点的 Camel 组件,它会被默认启用。
这种特征包括在以下配置集: Kubernetes、OpenShift。
6.2.7.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait service.[key]=[value] --trait service.[key2]=[value2] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
| 如果需要创建服务,可以从代码中自动检测。 |
|
|
|
启用服务以 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
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
| 在支持它的构建组件上启用详细日志记录(如 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
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
| |
|
|
| 需要的最小 CPU 量。 |
|
|
| 需要的最小内存量。 |
|
|
| 需要的最大 CPU 数量。 |
|
|
| 需要的最大内存量。 |
|
|
| 可用于通过 kubernetes 服务启用/禁用暴露。 |
|
|
|
配置容器公开的其他端口(默认 |
|
|
|
为容器公开的端口配置不同的端口名称(默认 |
|
|
|
若要配置在哪些服务端口下要公开的服务端口(默认为 |
|
|
|
要配置将容器端口的名称在哪个服务端口下来公开(默认 |
|
|
|
主容器名称。默认会命名 |
|
|
| 主容器镜像 |
|
|
|
容器上的探测启用/禁用探测(默认 |
|
|
| 在启动存活度探测前,容器启动后的秒数。 |
|
|
| 探测超时的秒数。适用于存活度探测。 |
|
|
| 执行探测的频率。适用于存活度探测。 |
|
|
| 在失败后,探测连续连续成功才会被认为成功。适用于存活度探测。 |
|
|
| 在成功成功后,探测的最小连续失败才会被视为失败。适用于存活度探测。 |
|
|
| 在启动就绪度探测前,容器启动后的秒数。 |
|
|
| 探测超时的秒数。适用于就绪度探测。 |
|
|
| 执行探测的频率。适用于就绪度探测。 |
|
|
| 在失败后,探测连续连续成功才会被认为成功。适用于就绪度探测。 |
|
|
| 在成功成功后,探测的最小连续失败才会被视为失败。适用于就绪度探测。 |
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
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
6.3.4. dependencies Trait
在内部使用 Dependencies 特征,用于根据用户希望运行的集成自动添加运行时依赖项。
以下配置集提供了这个特征: Kubernetes、Knative、OpenShift。
依赖项特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.4.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait dependencies.[key]=[value] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
6.3.5. deployer Trait
可以利用部署器特征来显式选择将要部署集成的高级别资源。
以下配置集提供了这个特征: Kubernetes、Knative、OpenShift。
部署器特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.5.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait deployer.[key]=[value] --trait deployer.[key2]=[value2] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
|
在创建运行集成的资源时,允许在部署、 |
6.3.6. Deployment Trait
Deployment 特征负责生成 Kubernetes 部署,确保集成会在集群中运行。
以下配置集提供了这个特征: Kubernetes、Knative、OpenShift。
部署特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.6.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait deployment.[key]=[value] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
6.3.7. 环境 Trait
在内部使用环境特征来注入集成容器中的标准环境变量,如 NAMESPACE、POD_NAME 等等。
以下配置集提供了这个特征: Kubernetes、Knative、OpenShift。
环境特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.7.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait environment.[key]=[value] --trait environment.[key2]=[value2] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
|
启用 |
6.3.8. error Handler Trait
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
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
| 在应用属性中提供或找到错误处理程序的 ref name |
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
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
| 激活远程调试,以便调试器可以使用端口转发连接到 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
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
| 自动注入所有引用的 Kamelets 及其默认配置(默认为启用) |
|
|
| 要加载到当前集成的以逗号分隔的 Kamelet 名称列表 |
6.3.11. OpenAPI Trait
OpenAPI DSL 特征用于允许从 OpenAPI specs 创建集成。
以下配置集提供了这个特征: Kubernetes、Knative、OpenShift。
openapi trait 是一个 平台特征 :禁用它可能会破坏平台功能。
6.3.11.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait openapi.[key]=[value] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
6.3.12. 所有者 Trait
Owner trait 确保所有创建的资源都属于正在创建并传输至这些所拥有的资源上的注解和标签。
以下配置集提供了这个特征: Kubernetes、Knative、OpenShift。
所有者特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.12.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait owner.[key]=[value] --trait owner.[key2]=[value2] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
| 要传输的注解集 |
|
|
| 要传输的标签集合 |
6.3.13. platform Trait
平台特征是一种基础特征,用于将集成平台分配给集成。
如果平台缺失,则这个特征可以创建默认平台。此功能在无需为平台提供自定义配置时(例如,在 OpenShift 默认设置工作中)时特别有用,因为有一个嵌入的容器镜像 registry。
以下配置集提供了这个特征: Kubernetes、Knative、OpenShift。
平台特征是 一个平台特征 :禁用它可能会破坏平台功能。
6.3.13.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait platform.[key]=[value] --trait platform.[key2]=[value2] Integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
| 缺少平台时,创建默认(空)平台。 |
|
|
| 指明在全局操作员中是否应该全局创建平台(默认为 true)。 |
|
|
| 如果可以创建默认平台(仅在 OpenShift 上创建),可以从环境自动探测到。 |
6.3.14. Quarkus Trait
Quarkus 特征激活 Quarkus 运行时。
它会被默认启用。
编译到原生可执行文件,即在使用 package-type=native 时,只有 kamelets 以及 YAML 集成才受支持。它还需要至少 4GiB 内存,因此运行原生构建的 Pod 或构建 Pod (取决于为平台配置的构建策略),必须有足够的内存。
以下配置集提供了这个特征: Kubernetes、Knative、OpenShift。
quarkus 的特征是 平台特征 :禁用它可能会破坏平台功能。
6.3.14.1. 配置
在运行任何与 CLI 集成时,可以指定特征属性:
$ kamel run --trait quarkus.[key]=[value] --trait quarkus.[key2]=[value2] integration.java
可用的配置选项如下:
| 属性 | 类型 | 描述 |
|---|---|---|
|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
|
Quarkus 软件包类型,可以是 |
6.3.14.2. 支持的 Camel 组件
Camel K 只支持 Camel Quarkus 扩展即用箱的 Camel 组件。
6.3.14.3. 例子
6.3.14.3.1. 自动推出到原生集成
虽然对原生可执行文件的编译会产生集成,它们在运行时会更快、消耗较少的内存,但构建过程需要大量资源,并且需要比传统 Java 应用程序打包的时间更长。
要组合两全其美,可以将 Quarkus 特征配置为在运行集成时并行运行传统和原生构建,例如:
$ kamel run -t quarkus.package-type=fast-jar -t quarkus.package-type=native ...
当 fast-jar 构建完成后,集成 Pod 将立即运行,并在 原生 构建完成后马上触发对 原生 镜像的推出部署,而不会中断服务。
第 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. 支持的命令
请注意以下密钥:
| 符号 | 描述 |
|---|---|
| ✔ | 支持 |
| ❌ | 不支持或不被支持 |
表 7.1. kamel 命令
| 名称 | 支持 | 描述 | 示例 |
|---|---|---|---|
|
| ✔ | 在集成流、到 Knative 频道、Kafka 主题或其他端点等绑定 Kubernetes 资源,如 Kamelets。 |
|
|
| ❌ | 生成完成脚本。 |
|
|
| ❌ | 使用本地调试器调试远程集成。 |
|
|
| ✔ | 删除 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 模式line 进入 Camel K 集成源文件中的配置选项,该文件在运行时执行,例如使用 kamel 运行 MyIntegration.java。如需了解更多详细信息,请参阅 使用模式 来运行 Camel K 集成。
所有可用于 kamel run 命令的选项,您可以指定 作为模式命令行选项。
下表描述了一些最常用的模式选项。
表 7.2. Camel K 模式命令行选项
| 选项 | 描述 |
|---|---|
|
| 添加 build-time 属性或 build-time 属性文件。
语法: |
|
| 从 Configmap、Secret 或文件添加运行时配置
语法:
-
- |
|
| 包括一个外部库(如 Maven 依赖项)
示例: |
|
|
在集成容器中设置环境变量。例如: |
|
|
为集成添加标签。例如, |
|
|
添加集成名称。例如, |
|
|
添加 OpenAPI v2 规格。例如, |
|
|
设置用于部署的 Camel K trait 配置集。例如: |
|
| 添加运行时属性或运行时属性文件。
语法: |
|
| 添加 ConfigMap、Secret 或文件中的运行时资源
语法:
-
- |
|
|
在特征中配置 Camel K 功能或核心功能。例如: |