使用 Camel K 开发和管理集成
前言
使开源包含更多
红帽承诺替换我们的代码、文档和网页属性中存在问题的语言。我们从这四个术语开始: master、slave、blacklist 和 whitelist。这些更改将在即将发行的几个发行本中逐渐实施。有关更多详情,请参阅我们的首席技术官 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 log
-
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 Tooling for Apache Camel K by Red Hat
1.2. 管理 Camel K 集成日志记录级别
Camel K 使用 Quarkus Logging 机制作为集成的日志记录框架。您可以通过在运行时在命令行中配置各种日志记录器的日志级别,方法是将 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 Tooling for Apache Camel K by Red Hat
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 monitoring 基于 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 项目
中是否存在cluster-monitoring-config
ConfigMap 对象:$ 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 Metrics 扩展 以 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 控制台中,在 Insert Metric at Cursor 下,输入
application_camel_context_uptime_seconds
,然后单击 Run Queries。 - 点 Add Query 查看其他指标。
2.3. 添加自定义 Camel K 集成指标
您可以使用 Java 代码中的 Camel MicroProfile Metrics 组件和注解在 Camel K 集成中添加自定义指标。然后,Prometheus 会自动发现并显示这些自定义指标。
本节演示了在 Camel K 集成和服务实施代码中添加 Camel MicroProfile Metrics 注解的示例。
先决条件
- 您必须在 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 Metrics 注解添加到任何实施文件中。以下示例显示了 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 模式行来自动配置 Prometheus 和Service.java
所需的 Maven 依赖项。
第 3 章 监控 Camel K operator
Red Hat Integration - Camel K monitoring 基于 OpenShift 监控系统。本章解释了如何在运行时使用可用选项来监控 Red Hat Integration - Camel K operator。您可以使用已部署为 OpenShift Monitoring 一部分的 Prometheus Operator 来监控您自己的应用程序。
3.1. Camel K Operator 指标
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.5s 超过至少 1 分钟。 |
| warning | 超过 1% 的协调请求失败超过 10 分钟。 |
| warning | 成功构建超过 10% 的持续时间超过至少 1 分钟。 |
| critical | 成功构建中有超过 1% 的持续时间长于 5 分钟超过最少 1 分钟。 |
| critical | 超过 1% 的构建错误超过 10 分钟。 |
| warning | 超过 1% 的构建已排队超过 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-time 配置,请使用
--build-property
选项,如 指定 build-time 配置属性中所述 -
对于运行时配置,请使用
--property
、--config
或--resource
选项,如 指定运行时配置选项中所述
例如,您可以使用 build-time 和 runtime 选项在 Camel K 中快速配置数据源,如 link: Connect Camel K with database sample configuration 所示。
4.1. 指定 build-time 配置属性
您可能需要为 Camel Quarkus 运行时提供属性值,以便它可以构建 Camel K 集成。有关构建期间有效的 Quarkus 配置的更多信息,请参阅 Quarkus 构建时间配置文档。您可以在命令行中直接指定 build-time 属性,或引用属性文件。如果两个位置都定义了属性,则直接在命令行中指定的值优先于属性文件中的值。
先决条件
- 您必须有权访问安装 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
要提供多个 build-time 属性,请在
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 Quarkus 作为 Camel K 集成的运行时的详情,请参考 Quarkus Trait。
4.2. 指定运行时配置选项
您可以为 Camel K 集成指定在运行时配置信息,以便在其运行时配置信息:
- 您在命令行或 .properties 文件中提供的运行时属性。
- 集成启动时,您希望 Camel K 操作器处理并解析为运行时属性的配置值。您可以在本地文本文件、OpenShift ConfigMap 或 OpenShift secret 中提供配置值。
- 集成启动时没有解析为属性文件的资源信息。您可以在本地文本文件、二进制文件、OpenShift ConfigMap 或 OpenShift secret 中提供资源信息。
使用以下 kamel 运行
选项:
--property
使用
--property
选项可直接在命令行中指定运行时属性,或者引用 Java Swarmproperties
文件。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 不会解析属性的资源,且不会将资源添加到 classpath 中。(如果您想要将资源添加到 classpath 中,您可以在集成中使用 JVM 特征)。
4.2.1. 提供运行时属性
您可以直接在命令行中指定运行时属性,或使用 kamel run
命令的 --property
选项引用 Java Swarm 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 文件 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
选项使该文件可用(具有相同文件名)在运行的集成的 classpath 上。
先决条件
- 设置 Camel K 开发环境
您有一个或多个包含配置值的文本文件。
例如,创建一个名为
resources-data.txt
的文件,其中包含以下行:the file body
流程
创建一个 Camel K 集成来引用包含配置值的文本文件。
例如,以下集成(
ConfigFileRoute.java
)预期在 classpath 在运行时提供resources-data.txt
文件: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 安全地包含配置信息。要对 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
和my.key.2
属性的 Secret。例如:
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
secret 中的一个源的属性。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 不会解析查找运行时属性的资源,它不会将资源添加到 classpath 中。(如果要将资源添加到 classpath 中,您可以使用 JVM 特征。
4.2.3.1. 将文本或二进制文件指定为资源
如果您有包含配置值的文本或二进制文件,您可以使用 --resource file:/path/to/file
选项来对文件进行序列化。默认情况下,Camel K operator 将材料化文件复制到 /etc/camel/resources/
目录中。另外,您可以指定不同的目标目录,如 为资源指定目标路径 中所述。
先决条件
- 设置 Camel K 开发环境
- 您有一个或多个包含配置属性的文本文件。
流程
创建一个 Camel K 集成,它会读取您提供的文件内容。
例如,以下集成(
ResourceFileBinaryRoute.java
)解压缩并读取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&
gt; 选项。
先决条件
- 设置 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
选项以对默认/etc/camel/resources/
目录中的 ConfigMap 文件进行解析,使其可用于正在运行的集成。例如:
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-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
选项,在默认/etc/camel/resources/
目录中对 Secret 进行材料化,使其可用于正在运行的集成。例如:
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。
流程
创建一个 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}"); } }
运行集成并使用带
@path
语法的--resource
选项,并指定挂载资源内容的位置(文件、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-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}"); } }
运行集成并使用带
@path
语法的--resource
选项,并指定挂载源内容的位置(文件、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
来禁用自动依赖项解析。但是,多数情况下不建议这样做。
依赖项的类型
kamel run
命令的 -d
标志非常灵活,并支持多种依赖项。
可以使用 -d
标志直接添加 Camel 依赖项,如下所示:
kamel run -d camel:http Integration.java
在这种情况下,依赖项将使用正确的版本添加。请注意,指定 Camel 依赖项的标准表示法为 camel:xxx
,而 kamel
也接受 camel-xxx
以实现可用性。
您可以使用 -d
标志、mvn
前缀和 maven 协调来添加 外部依赖项 :
kamel run -d mvn:com.google.guava:guava:26.0-jre Integration.java
请注意,如果您的依赖项属于私有存储库,则必须定义此存储库。请参阅 配置 maven。
您可以使用 -d
标志和 file://
前缀来添加 本地依赖项。
kamel run -d file://path/to/integration-dep.jar Integration.java
然后,在集成中可以访问 integration-dep.jar
的内容供您使用。
您还可以指定要挂载到正在运行的容器中的数据文件:
kamel run -d file://path/to/data.csv:path/in/container/data.csv Integration.java
指定目录将递归工作。
请注意,这个功能依赖于 Image Registry 被准确设置。
Jitpack 依赖项
如果您的依赖项没有发布到 maven
存储库中,您将找到 Jitpack 作为向运行时集成环境提供任何自定义依赖项的方法。在某些 occasion 中,您将发现它只包含您的路由定义,也有一些帮助程序类或在定义集成行为时必须使用的其他类。使用 Jitpack 时,您将能够编译托管在远程存储库中的 java 项目,并使用生成的软件包作为集成的依赖项。
用法与为任何 maven 依赖项定义的用法相同。可以使用 -d
标志来添加它,但此时,您需要为您要使用的项目存储库(即 github
)定义前缀。它必须以 repository-kind:user/repo/version 的形式提供。
例如,您可以执行以下操作来提供 Apache Commons CSV 依赖项:
kamel run -d github:apache/commons-csv/1.1 Integration.java
我们支持最重要的公共代码存储库:
github:user/repo/version gitlab:user/repo/version bitbucket:user/repo/version gitee:user/repo/version azure:user/repo/version
当使用 main
分支时,可以省略 version
。否则,它将代表项目仓库中使用的分支或标签。
动态 URI
Camel K 并不总是发现所有依赖项。当您动态创建 URI 时,您必须指示 Camel K 哪个组件要加载(使用 -d
参数)。以下代码片段演示了这一点。
DynamicURI.java
String myTopic = "purchases" from("kafka:" + myTopic + "? ... ") .to(...) ...
此处的 from
URI 由一些在运行时解析的变量动态创建。在这种情况下,您必须指定组件和相关依赖项来加载到 集成中。
第 5 章 针对 Kafka 验证 Camel K
您可以针对 Apache Kafka 验证 Camel K。
本例演示了如何使用 Red Hat OpenShift Streams for Apache Kafka 设置 Kafka 主题,并在一个简单的 Producer/Consumer pattern 集成中使用它。
5.1. 设置 Kafka
设置 Kafka 涉及安装所需的 OpenShift operator、创建 Kafka 实例并创建 Kafka 主题。
使用以下红帽产品之一设置 Kafka:
- Red Hat Advanced Message Queuing (AMQ)流 - 一个自我管理的 Apache Kafka 产品。AMQ Streams 基于开源 Strimzi,它包含在 Red Hat Integration 中。AMQ Streams 是一个基于 Apache Kafka 的分布式且可扩展的流平台,其中包括发布/订阅消息传递代理。Kafka Connect 提供了一个框架,用于将基于 Kafka 的系统与外部系统集成。使用 Kafka Connect,您可以配置源和接收器连接器,将来自外部系统的数据流传输到 Kafka 代理。
- Red Hat OpenShift Streams for Apache Kafka - 受管云服务,简化了运行 Apache Kafka 的过程。它为构建、部署和扩展新的云原生应用程序或现代化现有系统提供了简化的开发人员体验。
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 和 AMQ Streams for Apache Kafka 实例之间的通信。
- Red Hat Integration - Camel K operator - 安装和管理 Camel K - 一个轻量级集成框架,它在 OpenShift 的云中原生运行。
- Camel K CLI 工具 - 允许您访问所有 Camel K 功能。
先决条件
- 熟悉 Apache Kafka 概念。
- 您可以使用正确的访问级别访问 OpenShift 4.6 (或更新版本)集群,创建项目并安装 Operator,以及在本地系统上安装 OpenShift 和 Camel K CLI 的功能。
-
已安装 OpenShift CLI 工具(
oc
),以便您可以在命令行中与 OpenShift 集群交互。
流程
使用 AMQ Streams 设置 Kafka:
- 登录 OpenShift 集群的 Web 控制台。
- 创建或打开您要在其中创建集成的项目,如 my-camel-k-kafka。
- 安装 Camel K operator 和 Camel K CLI,如 安装 Camel K 所述。
安装 AMQ 流 Operator:
- 在任何项目中,选择 Operators > OperatorHub。
- 在 Filter by Keyword 字段中,键入 AMQ Streams。
点 Red Hat Integration - AMQ Streams 卡,然后点 Install。
此时会打开 Install Operator 页面。
- 接受默认值,然后点 Install。
- 选择 Operators > Installed Operators 来验证是否安装了 Camel K 和 AMQ Streams operator。
5.1.1.2. 使用 AMQ Streams 设置 Kafka 主题
Kafka 主题为 Kafka 实例中数据存储提供目的地。您必须将数据发送到 Kafka 主题,您必须先设置 Kafka 主题。
先决条件
- 您可以访问 OpenShift 集群。
- 已安装 Red Hat Integration - Camel K 和 Red Hat Integration - AMQ Streams operator,如 准备 OpenShift 集群 中所述。
-
已安装 OpenShift CLI (
oc
)和 Camel K CLI (kamel
)。
流程
使用 AMQ Streams 设置 Kafka 主题:
- 登录 OpenShift 集群的 Web 控制台。
- 选择 Projects,然后点击安装 Red Hat Integration - AMQ Streams operator 的项目。例如,单击 my-camel-k-kafka 项目。
- 选择 Operators > Installed Operators,然后点 Red Hat Integration - AMQ Streams。
创建 Kafka 集群:
- 在 Kafka 下,点 Create instance。
- 为集群输入一个名称,如 kafka-test。
接受其他默认值,然后单击 Create。
创建 Kafka 实例的过程可能需要几分钟时间才能完成。
当状态就绪时,请继续下一步。
创建 Kafka 主题:
- 选择 Operators > Installed Operators,然后点 Red Hat Integration - AMQ Streams。
- 在 Kafka Topic 下,点 Create Kafka Topic。
- 为主题输入名称,如 test-topic。
- 接受其他默认值,然后单击 Create。
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 安装和管理 Camel K,它是一个轻量级集成框架,它在 OpenShift 的云中原生运行。
- Camel K CLI 工具 - 允许您访问所有 Camel K 功能。
先决条件
- 熟悉 Apache Kafka 概念。
- 您可以使用正确的访问级别访问 OpenShift 4.6 (或更新版本)集群,创建项目并安装 Operator,以及在本地系统上安装 OpenShift 和 Apache Camel K CLI 的功能。
-
已安装 OpenShift CLI 工具(
oc
),以便您可以在命令行中与 OpenShift 集群交互。
流程
- 使用集群管理员帐户登录 OpenShift Web 控制台。
为您的 Camel K 或 Kamelets 应用程序创建 OpenShift 项目。
- 选择 Home > Projects。
- 点击 Create Project。
-
输入项目的名称,如
my-camel-k-kafka
,然后单击 Create。
- 下载并安装 RHOAS CLI,如 开始使用 rhoas CLI 所述。
- 安装 Camel K operator 和 Camel K CLI,如 安装 Camel K 所述。
- 要验证是否安装了 Red Hat Integration - Camel K operator,请点击 Operators > Installed Operators。
后续步骤
5.1.2.2. 使用 RHOAS 设置 Kafka 主题
Kafka 针对 主题 组织消息。每个主题都有一个名称。应用发送消息到主题并从主题检索消息。Kafka 主题为 Kafka 实例中数据存储提供目的地。您必须将数据发送到 Kafka 主题,您必须先设置 Kafka 主题。
先决条件
- 您可以使用正确的访问级别访问 OpenShift 集群,创建项目并安装操作器,以及在本地系统上安装 OpenShift 和 Camel K CLI 的功能。
-
已安装 OpenShift CLI (
oc
)、Camel K CLI (kamel
)和 RHOAS CLI (rhoas
)工具,如 准备 OpenShift 集群 中所述。 - 已安装 Red Hat Integration - Camel K operator,如 准备 OpenShift 集群 中所述。
- 已登陆到 Red Hat Cloud 站点。
流程
使用 Red Hat OpenShift Streams for Apache Kafka 设置 Kafka 主题:
- 在命令行中登录到您的 OpenShift 集群。
打开项目,例如:
oc project my-camel-k-kafka
验证在您的项目中是否安装了 Camel K operator:
oc get csv
结果列出了 Red Hat Camel K operator,并表示它处于
Succeeded
阶段。准备 Kafka 实例并将其连接到 RHOAS:
使用以下命令登录到 RHOAS CLI:
rhoas login
创建一个 kafka 实例,如 kafka-test :
rhoAS kafka create kafka-test
创建 Kafka 实例的过程可能需要几分钟时间才能完成。
检查 Kafka 实例的状态:
RHOAS 状态
您还可以在 web 控制台中查看状态:
https://cloud.redhat.com/application-services/streams/kafkas/
当状态 就绪时,请继续下一步。
创建新的 Kafka 主题:
rhoas kafka topic create --name test-topic
将 Kafka 实例(集群)与 Openshift Application Services 实例连接:
RHOAS 集群连接
按照获取凭据令牌的脚本说明进行操作。
您应该看到类似如下的输出:
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 节 “构建器 Trait”
- 第 6.3.3 节 “Camel Trait”
- 第 6.3.2 节 “容器垃圾”
- 第 6.3.4 节 “依赖项垃圾”
- 第 6.3.5 节 “deployer Trait”
- 第 6.3.6 节 “部署垃圾”
- 第 6.3.7 节 “环境垃圾”
- 第 6.3.8 节 “错误处理程序垃圾”
- 第 6.3.9 节 “JVM Trait”
- 第 6.3.10 节 “kamelets Trait”
- 第 6.3.11 节 “OpenAPI Trait”- 技术预览
- 第 6.3.12 节 “所有者垃圾箱”
- 第 6.3.13 节 “平台垃圾”
- 第 6.3.14 节 “Quarkus Trait”
6.1. Camel K trait 和配置集配置
本节介绍 特征 和配置文件 的重要 Camel K 概念,这些概念用于在运行时配置高级 Camel K 功能。
Camel K traits
Camel K traits 是高级功能和核心功能,您可以在命令行中配置来自定义 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 traits 以进行自定义行为。有些特征只适用于特定的配置集,如 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 trait 会自动发现 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 (使用不同于"默认"的特定代理)。 |
|
| 集成将生成的事件类型列表。可以包含简单的事件类型或完整的 Camel URI (使用特定代理)。 |
|
| 启用根据标头 "ce-knativehistory" 对事件进行过滤。由于此标头在较新版本的 Knative 中被删除,所以默认禁用过滤。 |
|
| 允许通过 Knative SinkBinding 资源将集成绑定到 sink。当集成以单个 sink 为目标时,可以使用它。当集成以单个 sink 为目标时,它会被默认启用(集成归 Knative 源所有时除外)。 |
|
| 启用自动发现所有特征属性。 |
6.2.2. Knative Service Trait
在将集成作为 Knative 服务而不是标准的 Kubernetes Deployment 运行时,Knative Service trait 允许配置选项。
作为 Knative 服务运行集成会添加自动扩展(和缩减到零)功能,但这些功能仅在路由使用 HTTP 端点消费者时才有意义。
这个特征包括在以下配置集:Knative。
6.2.2.1. 配置
可在运行任何 CLI 集成时指定特征属性:
$ kamel run --trait knative-service.[key]=[value] --trait knative-service.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | 描述 |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
配置 Knative 自动扩展类属性(例如,设置 如需更多信息,请参阅 Knative 文档。 |
|
|
配置 Knative 自动扩展指标属性(例如,设置基于 如需更多信息,请参阅 Knative 文档。 |
|
| 为每个 Pod 设置允许的并发级别或 CPU 百分比(取决于自动扩展指标)。 如需更多信息,请参阅 Knative 文档。 |
|
| 应该随时运行集成的最小 Pod 数量。默认情况下,它 为零,这意味着在没有用于配置的时间时,集成会缩减为零。 如需更多信息,请参阅 Knative 文档。 |
|
| 可并行运行用于集成的 Pod 数的上限。Knative 都有自己的上限值,具体取决于安装。 如需更多信息,请参阅 Knative 文档。 |
|
| 在所有条件都满足时自动将集成部署为 Knative 服务:
|
6.2.3. Prometheus Trait
Prometheus trait 配置与 Prometheus 兼容的端点。它还会创建一个 PodMonitor
资源,以便在使用 Prometheus operator 时自动提取端点。
指标通过 MicroProfile 指标来公开。
创建 PodMonitor
资源需要安装 Prometheus Operator 自定义资源定义。您可以将 Prometheus 特征的 pod-monitor
设置为 false
,以便在没有 Prometheus Operator 的情况下工作。
Prometheus trait 默认禁用。
此特征包括在以下配置集中: 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 特征允许为集成 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 特征在 pod 上设置 pull secret,以允许 Kubernetes 从外部 registry 检索容器镜像。
可以手动指定 pull secret,或者您已为 集成
平台上的外部容器 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 命名空间中的 |
|
|
如果是 |
6.2.6. 路由垃圾
Route trait 可用于为集成配置 OpenShift 路由。
证书和密钥内容可以从本地文件系统或 Openshift secret
对象中提供。用户可以使用以 -
结尾的参数(例如: secret
tls-certificate-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
查看此页面末尾的示例部分,以查看设置选项。
此特征包括在以下配置集中: 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 路由文档。 |
|
| secret 名称和密钥引用 TLS CA 证书。格式为 "secret-name[/key-name]",如果 secret 中只有一个键,则该值代表 secret 名称,否则您可以设置以"/"分隔的键名称。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
| 目标 CA 证书提供最终目的地的 ca 证书的内容。使用重新加密终止时,应提供此文件,以便让路由器将它用于安全连接上的健康检查。如果没有指定此字段,路由器可能会提供自己的目标 CA,并使用短服务名称(service.namespace.svc)执行主机名验证,它允许基础架构生成的证书自动验证。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
| secret 名称和密钥引用目标 CA 证书。格式为 "secret-name[/key-name]",如果 secret 中只有一个键,则该值代表 secret 名称,否则您可以设置以"/"分隔的键名称。 如需更多信息,请参阅 OpenShift 路由文档。 |
|
|
要配置如何处理不安全的流量,例如 如需更多信息,请参阅 OpenShift 路由文档。 |
6.2.6.2. 例子
这些示例使用 secret 来存储集成中引用的证书和密钥。有关路由的详细信息,请参阅 Openshift 路由文档。PlatformHttpServer.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 请求。如果使用不支持这些内联脚本的 shell,它会使用内联脚本来检索 openshift 命名空间和集群基域,您应该将内联脚本替换为实际命名空间和基域的值。
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 中看到,以达到此目的,使用
--resource
kamel 参数在集成 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: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,然后使用一些 camel quarkus 参数在运行的 pod 中引用这些证书文件,它们以-p quarkus.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=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 服务证书的 secret 的特定证书 来添加 重新加密路由。这样,Openshift 服务证书仅在集成 pod 中设置。密钥和证书应该在正在运行的集成 pod 中可见,为了达到此目的,我们使用
--resource
kamel 参数在集成 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. 服务 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
可用的配置选项如下:
属性 | 类型 | 描述 |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
| 如果需要创建服务,可以从代码中自动检测。 |
|
|
启用 Service 作为 NodePort 公开(默认为 |
6.3. Camel K 平台特征
6.3.1. 构建器 Trait
builder 特征用于决定构建和配置 IntegrationKits 的最佳策略。
此特征包括在以下配置集中: Kubernetes、Knative、OpenShift。
builder 特征是一个 平台特征 :禁用它可能会破坏平台功能。
6.3.1.1. 配置
可在运行任何 CLI 集成时指定特征属性:
$ kamel run --trait builder.[key]=[value] --trait builder.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | 描述 |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
| 对支持它的构建组件(如 OpenShift 构建 pod)启用详细日志记录。不支持 Kaniko 和 Buildah。 |
|
| 要提供给构建任务的属性列表 |
6.3.2. 容器垃圾
容器特征可用于配置运行集成的容器的属性。
它还为与容器关联的服务提供配置。
此特征包括在以下配置集中: Kubernetes、Knative、OpenShift。
容器特征是一个 平台特征 :禁用它可能会破坏平台功能。
6.3.2.1. 配置
可在运行任何 CLI 集成时指定特征属性:
$ kamel run --trait container.[key]=[value] --trait container.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | 描述 |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
| |
|
| 需要的最小 CPU 量。 |
|
| 需要的最小内存量。 |
|
| 需要的最大 CPU 量。 |
|
| 需要的最大内存量。 |
|
| 可以用来通过 kubernetes Service 启用/禁用暴露。 |
|
|
配置容器公开的不同端口(默认 |
|
|
要为容器公开的端口配置不同的端口名称(默认值 |
|
|
要配置在哪些服务端口上公开容器端口(默认值 |
|
|
要配置要公开的容器端口名称下的服务端口名称(默认值 |
|
|
主容器名称。默认情况下,它被命名为 |
|
| 主容器镜像 |
|
|
ProbesEnabled 在容器中启用/禁用探测(默认值为 |
|
| 在启动存活度探测前容器启动后的秒数。 |
|
| 探测超时的秒数。适用于存活度探测。 |
|
| 执行探测的频率。适用于存活度探测。 |
|
| 在失败后,探测的连续成功才被视为成功。适用于存活度探测。 |
|
| 成功后探测被视为失败的最小连续失败。适用于存活度探测。 |
|
| 在启动就绪度探测前容器启动后的秒数。 |
|
| 探测超时的秒数。适用于就绪度探测。 |
|
| 执行探测的频率。适用于就绪度探测。 |
|
| 在失败后,探测的连续成功才被视为成功。适用于就绪度探测。 |
|
| 成功后探测被视为失败的最小连续失败。适用于就绪度探测。 |
6.3.3. Camel Trait
Camel trait 可用于配置 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 内部用于根据用户想要运行的集成自动添加运行时依赖项。
此特征包括在以下配置集中: Kubernetes、Knative、OpenShift。
依赖项特征是一个 平台特征 :禁用它可能会破坏平台功能。
6.3.4.1. 配置
可在运行任何 CLI 集成时指定特征属性:
$ kamel run --trait dependencies.[key]=[value] Integration.java
可用的配置选项如下:
属性 | 类型 | 描述 |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
6.3.5. deployer Trait
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 负责生成 Kubernetes 部署,以确保集成将在集群中运行。
此特征包括在以下配置集中: Kubernetes、Knative、OpenShift。
部署特征是一个 平台特征 :禁用它可能会破坏平台功能。
6.3.6.1. 配置
可在运行任何 CLI 集成时指定特征属性:
$ kamel run --trait deployment.[key]=[value] Integration.java
可用的配置选项如下:
属性 | 类型 | 描述 |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
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
可用的配置选项如下:
属性 | 类型 | 描述 |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
|
启用 |
6.3.8. 错误处理程序垃圾
error-handler 是一个 平台特征,用于将 Error Handler 源注入集成运行时。
此特征包括在以下配置集中: Kubernetes、Knative、OpenShift。
error-handler trait 是一个 平台特征 :禁用它可能会破坏平台功能。
6.3.8.1. 配置
可在运行任何 CLI 集成时指定特征属性:
$ kamel run --trait error-handler.[key]=[value] --trait error-handler.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | 描述 |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
| 错误处理程序 ref 名称在应用程序属性中提供或找到 |
6.3.9. JVM Trait
JVM 特征用于配置运行集成的 JVM。
此特征包括在以下配置集中: Kubernetes、Knative、OpenShift。
jvm trait 是一个 平台特征 :禁用它可能会破坏平台功能。
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. 例子
包括一个到
集成
的额外类路径:$ kamel run -t jvm.classpath=/path/to/my-dependency.jar:/path/to/another-dependency.jar ...
6.3.10. kamelets Trait
kamelets trait 是一个 平台特征,用于将 Kamelets 注入集成运行时。
此特征包括在以下配置集中: Kubernetes、Knative、OpenShift。
kamelets trait 是一个 平台特征 :禁用它可能会破坏平台功能。
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. 所有者垃圾箱
Owner trait 确保所有创建的资源都属于正在创建并传输集成上的注解和标签到这些拥有的资源。
此特征包括在以下配置集中: Kubernetes、Knative、OpenShift。
owner trait 是一个 平台特征 :禁用它可能会破坏平台功能。
6.3.12.1. 配置
可在运行任何 CLI 集成时指定特征属性:
$ kamel run --trait owner.[key]=[value] --trait owner.[key2]=[value2] Integration.java
可用的配置选项如下:
属性 | 类型 | 描述 |
---|---|---|
|
| 可用于启用或禁用特征。所有特征共享这个通用属性。 |
|
| 要传输的注解集合 |
|
| 要传输的标签集合 |
6.3.13. 平台垃圾
平台特征是一个基本特征,用于为集成分配集成平台。
如果缺少平台,则允许特征创建默认平台。此功能在不需要为平台提供自定义配置的情况下特别有用(例如,在 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 (即 operator Pod)或构建 Pod (取决于为平台配置的构建策略)必须有足够的内存。
此特征包括在以下配置集中: Kubernetes、Knative、OpenShift。
quarkus trait 是一个 平台特征 :禁用它可能会破坏平台功能。
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 ...
集成 Pod 将在 fast-jar
构建完成后立即运行,并在 原生
构建完成后触发对 原生
镜像的推出部署,而不会中断服务。
第 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. 支持的命令
请注意以下键:
符号 | 描述 |
---|---|
✔ | 支持 |
❌ | 不支持或尚不受支持 |
名称 | 支持 | 描述 | 示例 |
---|---|---|---|
| ✔ | 在集成流中将 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 客户端版本。 |
|
其他资源
- 请参阅 安装 Camel K
7.2. Camel K 模式命令行选项
您可以使用 Camel K 模式在 Camel K 集成源文件中输入配置选项,这些文件在运行时执行,例如使用 kamel run MyIntegration.java
。如需了解更多详细信息,请参阅使用模式行运行 Camel K 集成。
所有可用于 kamel run
命令的选项,您可以指定为 mode 命令行选项。
下表描述了一些最常用的模式命令行选项。
选项 | 描述 |
---|---|
| 添加 build-time 属性或 build-time 属性文件。
语法: |
| 从 Configmap、Secret 或文件添加运行时配置
语法:
-
- |
| 包括一个外部库(例如,Maven 依赖项)
示例: |
|
在集成容器中设置环境变量。例如, |
|
为集成添加标签。例如, |
|
添加集成名称。例如, |
|
添加 OpenAPI v2 规格。例如, |
|
设置用于部署的 Camel K trait 配置集。例如: |
| 添加运行时属性或运行时属性文件。
语法: |
| 从 ConfigMap、Secret 或文件添加运行时资源
语法:
-
- |
|
在特征中配置 Camel K 功能或核心功能。例如, |