使用 Camel K 部署和管理集成

Red Hat Integration 2022.Q3

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

先决条件

流程

  1. 确保 Camel K Operator 在 OpenShift 集群上运行,例如:

    oc get pod
    NAME                               READY   STATUS    RESTARTS   AGE
    camel-k-operator-86b8d94b4-pk7d6   1/1     Running   0          6m28s
  2. 输入 kamel run 命令,在 OpenShift 上的云中运行您的集成。例如:

    kamel run hello.camelk.yaml
    integration "hello" created
  3. 输入 kamel get 命令检查集成状态:

    kamel get
    NAME   PHASE        KIT
    hello  Building Kit kit-bqatqib5t4kse5vukt40
  4. 输入 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
  5. 输入 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]
    ...
  6. Ctrl-C 在终端中终止登录。
  7. 输入 kamel delete 以删除 OpenShift 中部署的集成:

    kamel delete hello
    Integration hello deleted

其他资源

1.2. 管理 Camel K 集成日志记录级别

Camel K 使用 Quarkus 日志机制作为集成的日志框架。您可以在运行时在命令行中配置各种日志记录器的日志记录级别,方法是将 quarkus.log.category 前缀指定为集成属性。例如:

示例

--property 'quarkus.log.category."org".level'=DEBUG

注意

使用单引号转义属性非常重要。

流程

  1. 输入 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]
    ...
  2. Ctrl-C 在终端中终止登录。

其他资源

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

流程

  1. 输入以下命令检查 openshift-monitoring 项目中是否存在 cluster-monitoring- config ConfigMap 对象:

    $ oc -n openshift-monitoring get configmap cluster-monitoring-config
  2. 如果不存在,创建 cluster-monitoring-config ConfigMap:

    $ oc -n openshift-monitoring create configmap cluster-monitoring-config
  3. 编辑 cluster-monitoring-config ConfigMap:

    $ oc -n openshift-monitoring edit configmap cluster-monitoring-config
  4. 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 指标。

先决条件

流程

  1. 输入以下命令运行您的 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}}}}}'
  2. 在 Prometheus 中查看 Camel K 集成指标的监控。例如,对于嵌入式 Prometheus,请在 OpenShift 管理员或开发人员 Web 控制台中选择 Monitoring > Metrics
  3. 输入您要查看的 Camel K 指标。例如,在 Administrator 控制台中,在 Insert Metric at Cursor 下输入 application_camel_context_uptime_seconds,然后单击 Run Queries
  4. Add Query 查看其他指标。

2.3. 添加自定义 Camel K 集成指标

您可以使用 Camel MicroProfile 指标组件和 Java 代码注解将自定义指标添加到您的 Camel K 集成。然后,Prometheus 将自动发现和显示这些自定义指标。

本节演示了将 Camel MicroProfile 指标注释添加到 Camel K 集成和服务实施代码的示例。

先决条件

流程

  1. 使用 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
        }
    }
    1
    使用 Camel K 模式行自动配置 Prometheus 特征和 Maven 依赖项
    2
    错误 :指标与未处理的事件数对应的错误数
    3
    generated: 指标要处理的事件数量
    4
    尝试: 指标数据对服务 bean 发出的调用数来处理传入的事件
    5
    重新传送 :指标用于处理事件的重试次数
    6
    成功 :指标事件数量
  2. 根据需要,将 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
          }
       }
     }
    1
    @Metered MicroProfile Metrics 注释声明计量,并且名称根据指标方法名称自动生成,在这种情况下,尝试
    2
    这个示例失败,以帮助生成指标的错误。
  3. 按照以下步骤配置 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标签

camel_k_reconciliation_duration_seconds

HistogramVec

协调请求持续时间

0.25S、0.5s、1s、5s

命名空间,group,version,kind,result:Reconciled|Errored|Requeued,tag:""|PlatformError|UserError

camel_k_build_duration_seconds

HistogramVec

构建持续时间

30s, 1m, 1.5m, 2m, 5m, 10m

结果Succeeded|Error

camel_k_build_recovery_attempts

Histogram

构建恢复尝试

0, 1, 2, 3, 4, 5

结果Succeeded|Error

camel_k_build_queue_duration_seconds

Histogram

构建队列持续时间

5s、15s、30s、1m、5m、

N/A

camel_k_integration_first_readiness_seconds

Histogram

第一次集成就绪的时间

5s, 10s, 30s, 1m, 2m

N/A

3.2. 启用 Camel K Operator 监控

OpenShift 4.3 或更高版本包含已作为 OpenShift Monitoring 的一部分部署的嵌入式 Prometheus Operator。本节介绍如何在 OpenShift Monitoring 中启用对您自己的应用程序服务的监控。

先决条件

流程

  1. 以 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

  2. 创建 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 资源中定义的警报规则。

名称重要性描述

CamelKReconciliationDuration

warning

协调请求超过 10% 的持续时间,超过 0.5 以上,至少有 1 分钟。

CamelKReconciliationFailure

warning

超过 1% 的协调请求失败至少 10 分钟。

CamelKSuccessBuildDuration2m

warning

超过 10% 的成功构建的时间已超过 2 分钟超过 1 分钟。

CamelKSuccessBuildDuration5m

critical

成功构建的超过 1% 的时间已超过 5 分钟超过 1 分钟。

CamelKBuildError

critical

构建超过 1% 的构建错误至少增加了 10 分钟。

CamelKBuildQueueDuration1m

warning

超过 1% 的构建队列已排队超过 1 分钟以上。

CamelKBuildQueueDuration5m

critical

超过 1% 的构建排队了超过 5 分钟以上时间超过 1 分钟。

您可以在 OpenShift 文档 创建警报规则 中找到有关警报的更多信息。

第 4 章 配置 Camel K 集成

Camel K 集成生命周期有两个配置阶段:

  • 构建时间 - 当 Camel Quarkus 构建 Camel K 集成时,它会消耗构建时间属性。
  • Runtime - 当 Camel K 集成运行时,该集成将使用来自本地文件、OpenShift ConfigMap 或 Secret 的运行时属性或配置信息。

您可以在 kamel run 命令中使用以下选项提供配置信息:

例如,您可以使用构建和运行时选项在 Camel K 中快速配置数据源,如链接所示:将 Camel K 与数据库示例配置连接

4.1. 指定构建配置属性

您可能需要为 Camel Quarkus 运行时提供属性值,以便它可以构建 Camel K 集成。有关构建期间生效的 Quarkus 配置的更多信息,请参阅 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。您可以在单个命令中指定多个属性。

流程

  1. 开发使用属性的 Camel 集成。以下简单示例包括 {{my.message}} 属性占位符:

    ...
    - from:
       uri: "timer:tick"
       steps:
         - set-body:
             constant: "{{my.message}}"
         - to: "log:info"
    ...
  2. 通过使用以下语法在运行时设置属性值来运行集成。

    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 )在命令行中指定属性值。

流程

  1. 创建集成属性文件。以下示例来自名为 my.properties 的文件:

    my.key.1=hello
    my.key.2=world
  2. 开发使用属性 文件中定义的属性的 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}}");
    
      }
    }
  3. 使用以下语法运行集成来引用属性文件:

    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

流程

  1. 创建一个 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}");
    
      }
    }
  2. 运行集成并使用 --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"

流程

  1. 创建 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}");
    
      }
    }
  2. 运行集成并使用 --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"

流程

  1. 创建 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}");
    
      }
    }
  2. 运行集成并使用 --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 解析为运行时属性文件。在集成中,您可以在引用任何其他运行时属性时引用属性。

流程

  1. 创建一个文本文件,其中包含属性。

    例如,创建一个名为 my.properties 的文件,其中包含以下属性:

    my.key.1=hello
    my.key.2=world
  2. 基于属性文件创建 ConfigMap 或 Secret。

    例如,使用以下命令从 my.properties 文件中创建一个 secret:

    oc create secret generic my-sec --from-file my.properties
  3. 在集成中,引用 Secret 中定义的属性。

    例如,以下集成(名为 ConfigSecretPropertyRoute.java)引用 my.key.1my.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}}");
    
      }
    }
  4. 运行集成并使用 --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 表示法来限制您的集成只检索的信息数量。

先决条件

流程

  1. 创建仅来自 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}");
      }
    }
  2. 使用 --config secret 选项和 /key 表示法运行集成。

    例如:

    kamel run --config secret:my-sec-multi/my-secret-key-2 ConfigSecretKeyRoute.java --dev
  3. 检查集成 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/ 目录。另外,您可以指定不同的目标目录,如 指定资源 的目标路径 所述。

先决条件

流程

  1. 创建一个 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}");
    
      }
    }
  2. 运行集成并使用 --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"

流程

  1. 创建一个 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}");
    
      }
    }
  2. 运行集成并使用 --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&gt; 语法。

先决条件

  • 设置 Camel K 开发环境
  • 您有一个或多个存储在 OpenShift 集群上的 Secret 文件。例如,您可以使用以下命令创建 Secret:

    oc create secret generic my-sec --from-literal=my-secret-key="very top secret"

流程

  1. 创建一个 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}");
    
      }
    }
  2. 运行集成并使用 --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 语法。

先决条件

流程

  1. 创建引用包含配置属性的文件 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}");
    
      }
    }
  2. 运行集成并使用 --resource 选项与 @path 语法,并指定挂载资源内容的位置(文件、ConfigMap 或 Secret):

    例如,以下命令指定使用 /tmp 目录挂载 input.txt 文件:

    kamel run --resource file:resources-data.txt@/tmp/input.txt ResourceFileLocationRoute.java --dev
  3. 检查集成的 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 表示法来限制您的集成只检索的信息数量。

先决条件

流程

  1. 创建仅来自 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}");
    
      }
    }
  2. 运行集成并使用 --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
  3. 检查集成的 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:

  1. 登录您的 OpenShift 集群的 Web 控制台。
  2. 创建或打开您计划在其中创建集成的项目,如 my-camel-k-kafka
  3. 安装 Camel K 运算符和 Camel K CLI,如 安装 Camel K 所述。
  4. 安装 AMQ 流 Operator:

    1. 从任何项目中,选择 Operators > OperatorHub
    2. Filter by Keyword 字段中,键入 AMQ Streams
    3. Red Hat Integration - AMQ Streams 卡,然后点 Install

      此时会打开 Install Operator 页面。

    4. 接受默认值,然后点 Install
  5. 选择 Operators > Installed Operators 来验证是否安装了 Camel K 和 AMQ Streams operator。

5.1.1.2. 使用 AMQ Streams 设置 Kafka 主题

Kafka 主题为 Kafka 实例中数据存储提供目的地。您必须设置 Kafka 主题,然后才能将数据发送到它。

先决条件

  • 您可以访问 OpenShift 集群。
  • 已安装 Red Hat Integration - Camel KRed Hat Integration - AMQ Streams operator,如 准备 OpenShift 集群 所述。
  • 已安装 OpenShift CLI(oc)和 Camel K CLI(kamel)。

流程

使用 AMQ Streams 设置 Kafka 主题:

  1. 登录您的 OpenShift 集群的 Web 控制台。
  2. 选择 Projects,然后点安装 Red Hat Integration - AMQ Streams operator 的项目。例如,点击 my-camel-k-kafka 项目。
  3. 选择 Operators > Installed Operators,然后点 Red Hat Integration - AMQ Streams
  4. 创建 Kafka 集群:

    1. Kafka 下,点 Create instance
    2. 为集群输入一个名称,如 kafka-test
    3. 接受其他默认值,然后点 Create

      创建 Kafka 实例的过程可能需要几分钟时间。

      状态就绪时,继续下一步。

  5. 创建一个 Kafka 主题:

    1. 选择 Operators > Installed Operators,然后点 Red Hat Integration - AMQ Streams
    2. Kafka Topic 下,点击 Create Kafka Topic
    3. 为主题输入一个名称,如 test-topic
    4. 接受其他默认值,然后点 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 集群交互。

流程

  1. 使用集群管理员帐户登录到 OpenShift Web 控制台。
  2. 为您的 Camel K 或 Kamelets 应用程序创建 OpenShift 项目。

    1. 选择 Home > Projects
    2. 点击 Create Project
    3. 键入项目名称,如 my-camel-k-kafka,然后点 Create
  3. 下载并安装 RHOAS CLI,如 Getting started with rhoas CLI 所述。
  4. 安装 Camel K 运算符和 Camel K CLI,如 安装 Camel K 所述。
  5. 要验证 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 主题:

  1. 从命令行,登录您的 OpenShift 集群。
  2. 打开您的项目,例如:

    oc project my-camel-k-kafka

  3. 验证项目中是否安装了 Camel K Operator:

    oc get csv

    结果列出了 Red Hat Camel K operator,并表示它处于 Succeeded 阶段。

  4. 准备并将 Kafka 实例连接到 RHOAS:

    1. 使用以下命令登录到 RHOAS CLI:

      RHOAS 登录

    2. 创建一个 kafka 实例,如 kafka-test

      RHOAS kafka 创建 kafka-test

      创建 Kafka 实例的过程可能需要几分钟时间。

  5. 检查 Kafka 实例的状态:

    RHOAS 状态

    您还可以在 web 控制台中查看状态:

    https://cloud.redhat.com/application-services/streams/kafkas/

    状态 就绪时,请继续下一步。

  6. 创建新的 Kafka 主题:

    RHOAS kafka 主题创建 --name test-topic

  7. 将 Kafka 实例(集群)与 Openshift Application Services 实例连接:

    RHOAS 集群连接

  8. 按照获取凭据令牌的脚本说明。

    您应该看到类似如下的输出:

    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 主题。

流程

  1. 获取 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
  2. 要获得用户名和密码,请使用以下语法创建服务帐户:

    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 文件中。

  3. 要验证服务帐户凭证,请查看 credentials.json 文件:

    cat credentials.json

    这个命令返回类似如下的输出:

    {"clientID":"srvc-acct-eb575691-b94a-41f1-ab97-50ade0cd1094", "password":"facf3df1-3c8d-4253-aa87-8c95ca5e1225"}
  4. 授予向 Kakfa 主题发送和接收信息的权限。使用以下命令,其中 clientIDcredentials.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。

流程

  1. 编辑 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>

  2. 运行以下命令,在 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。

流程

  1. 编辑 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>

  2. 运行以下命令,在 application.properties 文件中创建一个包含敏感属性的 secret:

    oc create secret generic kafka-props --from-file application-oauth.properties

    运行 Camel K 集成时使用此 secret。

5.2. 运行 Kafka 集成

运行制作者集成

  1. 创建示例制作者集成。这会填充一个消息,每 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!");
      }
    }

  2. 然后运行流程集成。

    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!

运行消费者集成

  1. 创建消费者集成。

    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}");
      }
    }

  2. 打开另一个 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 包含 OpenShiftKnative 配置集。Kubernetes 配置集只有社区支持。它还包括 Java 和 YAML DSL 集成支持。其他语言,如 XML、Groovy、JavaScript 和 Kotlin 具有仅社区支持。

本章包括以下部分:

Camel K 功能特征

Camel K 核心平台特征

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 集成的目标云平台。支持的配置集有 OpenShiftKnative 配置集。

注意

当您在 OpenShift 上运行集成时,当集群中安装 OpenShift Serverless 时,Camel K 将使用 Knative 配置集。在没有安装 OpenShift Serverless 时,Camel K 使用 OpenShift 配置集。

您也可以使用 kamel run --profile 选项在运行时指定配置集。

Camel K 为所有特征提供了有用的默认值,考虑集成运行的目标配置文件。但是,高级用户可以为自定义行为配置 Camel K 特征。有些特征只适用于特定的配置集,如 OpenShiftKnative。如需了解更多详细信息,请参阅每个特征描述中的可用配置集。

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

可用的配置选项如下:

属性类型描述

knative.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

knative.configuration

字符串

可用于以 JSON 格式注入 Knative 完整配置。

knative.channel-sources

[]string

用作集成路由源的频道列表。可以包含简单频道名称或完整的 Camel URI。

knative.channel-sinks

[]string

用作集成路由目的地的频道列表。可以包含简单频道名称或完整的 Camel URI。

knative.endpoint-sources

[]string

用作集成路由源的频道列表。

knative.endpoint-sinks

[]string

用作集成路由目的地的端点列表。可以包含简单端点名称或完整的 Camel URI。

knative.event-sources

[]string

集成将订阅的事件类型列表。可以包含简单事件类型或完整的 Camel URI(使用与 "default" 不同的特定代理)。

knative.event-sinks

[]string

集成生成的事件类型列表。可以包含简单事件类型或完整的 Camel URI(使用特定代理)。

knative.filter-source-channels

bool

根据标头 "ce-knativehistory" 启用对事件进行过滤。因为这个标头已在较新版本的 Knative 中删除,所以默认禁用过滤。

knative.sink-binding

bool

允许通过 Knative SinkBinding 资源将集成绑定到 sink。当集成目标一个 sink 时,可以使用它。当集成目标单个接收器(集成由 Knative 源所有时除外)时,它会被默认启用。

knative.auto

bool

启用自动发现所有特征属性。

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-service.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

knative-service.autoscaling-class

字符串

配置 Knative autoscaling 类属性(如设置 hpa.autoscaling.knative.devkpa.autoscaling.knative.dev autoscaling)。

如需更多信息,请参阅 Knative 文档。

knative-service.autoscaling-metric

字符串

配置 Knative autoscaling 指标属性(例如,用于设置基于 并发cpu 的自动扩展)。

如需更多信息,请参阅 Knative 文档。

knative-service.autoscaling-target

int

为每个 Pod 设置允许的并发级别或 CPU 百分比(取决于自动扩展指标)。

如需更多信息,请参阅 Knative 文档。

knative-service.min-scale

int

在集成过程中,应随时运行的最低 Pod 数量。默认 为零,表示当不用于配置的时间时,集成会缩减为零。

如需更多信息,请参阅 Knative 文档。

knative-service.max-scale

int

为集成并行运行的 Pod 数量有一个上限。Knative 具有自己的 cap 值,它依赖于安装。

如需更多信息,请参阅 Knative 文档。

knative-service.auto

bool

满足所有条件时,自动部署集成作为 Knative 服务:

  • 集成使用 Knative 配置集
  • 所有路由均可从基于 HTTP 的使用者或被动消费者(例如,直接 消费者)开始。

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

可用的配置选项如下:

属性类型描述

prometheus.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

prometheus.pod-monitor

bool

是否创建了 PodMonitor 资源(默认为 true)。

prometheus.pod-monitor-labels

[]string

PodMonitor 资源标签,适用于 pod-monitortrue

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

可用的配置选项如下:

属性类型描述

pdb.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

pdb.min-available

字符串

驱除后必须仍然可用的集成 pod 数量。它可以是绝对数字或一个百分比。只能指定 min-availablemax-unavailable

pdb.max-unavailable

字符串

驱除后可不可用的集成的 pod 数量。它可以是绝对数字或百分比(如果未设置 min-available,则默认为 1)。只能指定 max-unavailablemin-available

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

可用的配置选项如下:

属性类型描述

pull-secret.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

pull-secret.secret-name

字符串

要在 Pod 上设置的 pull secret 名称。如果留空,则会自动从 IntegrationPlatform registry 配置中提取。

pull-secret.image-puller-delegation

bool

在将全局 Operator 与共享平台搭配使用时,这启用了将 Operator 命名空间中的 system:image-puller 集群角色委派到集成服务帐户。

pull-secret.auto

bool

如果平台 registry secret 是 kubernetes.io/dockerconfigjson 类型,则在 pod 上自动配置平台 registry secret。

6.2.6. route Trait

Route 特征可用于配置为集成创建 OpenShift 路由。

证书和密钥内容可以从本地文件系统或 Openshift secret 对象的源。用户可以使用以 -secret 结尾的参数(例如: tls-certificate-secret)来引用存储在 secret 中的证书。以 -secret 结尾的参数具有较高的优先级,如果设置了相同的路由参数,例如: tls-key-secrettls-key,然后使用 tls-key-secret。设置密钥和证书的推荐方法是,使用 secret 来存储其内容,并使用以下参数来引用它们: tls-certificate-secrettls-key-secrettls-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

可用的配置选项如下:

属性类型描述

route.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

route.host

字符串

配置由路由公开的主机。

route.tls-termination

字符串

TLS 终止类型,如 edgepassthroughreencrypt

如需更多信息,请参阅 OpenShift 路由文档。

route.tls-certificate

字符串

TLS 证书内容。

如需更多信息,请参阅 OpenShift 路由文档。

route.tls-certificate-secret

字符串

对 TLS 证书的 secret 名称和密钥引用。格式为 "secret-name[/key-name]",如果 secret 中只有一个键,则代表 secret 名称,否则您可以设置一个键名称以 "/" 分隔。

如需更多信息,请参阅 OpenShift 路由文档。

route.tls-key

字符串

TLS 证书密钥内容。

如需更多信息,请参阅 OpenShift 路由文档。

route.tls-key-secret

字符串

对 TLS 证书密钥的 secret 名称和密钥引用。格式为 "secret-name[/key-name]",如果 secret 中只有一个键,则代表 secret 名称,否则您可以设置一个键名称以 "/" 分隔。

如需更多信息,请参阅 OpenShift 路由文档。

route.tls-ca-certificate

字符串

TLS CA 证书内容。

如需更多信息,请参阅 OpenShift 路由文档。

route.tls-ca-certificate-secret

字符串

对 TLS CA 证书的 secret 名称和密钥引用。格式为 "secret-name[/key-name]",如果 secret 中只有一个键,则代表 secret 名称,否则您可以设置一个键名称以 "/" 分隔。

如需更多信息,请参阅 OpenShift 路由文档。

route.tls-destination-ca-certificate

字符串

目标 CA 证书提供最终目的地的 ca 证书的内容。使用重新加密终止时,应该提供此文件,以便让路由器使用它来在安全连接上进行健康检查。如果没有指定此字段,路由器可以提供自己的目标 CA,并使用短服务名称(service.namespace.svc)执行主机名验证,这允许基础架构生成的证书自动验证。

如需更多信息,请参阅 OpenShift 路由文档。

route.tls-destination-ca-certificate-secret

字符串

到目标 CA 证书的 secret 名称和密钥引用。格式为 "secret-name[/key-name]",如果 secret 中只有一个键,则代表 secret 名称,否则您可以设置一个键名称以 "/" 分隔。

如需更多信息,请参阅 OpenShift 路由文档。

route.tls-insecure-edge-termination-policy

字符串

要配置如何处理不安全的流量,如 允许禁用 或重定向流量。

如需更多信息,请参阅 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.keytls.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 中引用这些证书文件,它们以 -prkus.http.ssl.certificate 开头。此路由特征引用了名为 my-combined-certs 的 secret,它包含两个名为 tls.keytls.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 中引用这些证书文件,它们以 -prkus.http.ssl.ssl.certificate.此路由特征引用了名为 my-combined-certs 的 secret,它包含两个名为 tls.keytls.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 中可见,以便实现这一点,使用 --resource kamel 参数在集成 pod 中挂载 secret,然后使用一些 camel quarkus 参数在运行的 pod 中引用这些证书文件,它们以 -p quarkus.http.ssl.certificate 开头。此路由特征引用了名为 my-combined-certs 的 secret,它包含两个名为 tls.keytls.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

可用的配置选项如下:

属性类型描述

service.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

service.auto

bool

如果需要创建服务,可以从代码中自动检测。

service.node-port

bool

启用服务以 NodePort 公开(默认为 false)。

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

可用的配置选项如下:

属性类型描述

builder.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

builder.verbose

bool

在支持它的构建组件上启用详细日志记录(如 OpenShift 构建 Pod)。不支持 Kaniko 和 Buildah。

builder.properties

[]string

要提供给构建任务的属性列表

6.3.2. 容器 Trait

容器特征可用于配置运行集成的容器的属性。

它还提供与容器关联的服务配置。

以下配置集提供了这个特征: Kubernetes、Knative、OpenShift

警告

容器特征是 一个平台特征 :禁用它可能会破坏平台功能。

6.3.2.1. 配置

在运行任何与 CLI 集成时,可以指定特征属性:

$ kamel run --trait container.[key]=[value] --trait container.[key2]=[value2] Integration.java

可用的配置选项如下:

属性类型描述

container.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

container.auto

bool

 

container.request-cpu

字符串

需要的最小 CPU 量。

container.request-memory

字符串

需要的最小内存量。

container.limit-cpu

字符串

需要的最大 CPU 数量。

container.limit-memory

字符串

需要的最大内存量。

container.expose

bool

可用于通过 kubernetes 服务启用/禁用暴露。

container.port

int

配置容器公开的其他端口(默认 8080)。

container.port-name

字符串

为容器公开的端口配置不同的端口名称(默认 http)。

container.service-port

int

若要配置在哪些服务端口下要公开的服务端口(默认为 80)。

container.service-port-name

字符串

要配置将容器端口的名称在哪个服务端口下来公开(默认 http)。

container.name

字符串

主容器名称。默认会命名 集成

container.image

字符串

主容器镜像

container.probes-enabled

bool

容器上的探测启用/禁用探测(默认 错误

container.liveness-initial-delay

int32

在启动存活度探测前,容器启动后的秒数。

container.liveness-timeout

int32

探测超时的秒数。适用于存活度探测。

container.liveness-period

int32

执行探测的频率。适用于存活度探测。

container.liveness-success-threshold

int32

在失败后,探测连续连续成功才会被认为成功。适用于存活度探测。

container.liveness-failure-threshold

int32

在成功成功后,探测的最小连续失败才会被视为失败。适用于存活度探测。

container.readiness-initial-delay

int32

在启动就绪度探测前,容器启动后的秒数。

container.readiness-timeout

int32

探测超时的秒数。适用于就绪度探测。

container.readiness-period

int32

执行探测的频率。适用于就绪度探测。

container.readiness-success-threshold

int32

在失败后,探测连续连续成功才会被认为成功。适用于就绪度探测。

container.readiness-failure-threshold

int32

在成功成功后,探测的最小连续失败才会被视为失败。适用于就绪度探测。

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

可用的配置选项如下:

属性类型描述

camel.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

6.3.4. dependencies Trait

在内部使用 Dependencies 特征,用于根据用户希望运行的集成自动添加运行时依赖项。

以下配置集提供了这个特征: Kubernetes、Knative、OpenShift

警告

依赖项特征是 一个平台特征 :禁用它可能会破坏平台功能。

6.3.4.1. 配置

在运行任何与 CLI 集成时,可以指定特征属性:

$ kamel run --trait dependencies.[key]=[value] Integration.java

可用的配置选项如下:

属性类型描述

dependencies.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

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

可用的配置选项如下:

属性类型描述

deployer.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

deployer.kind

字符串

在创建运行集成的资源时,允许在部署、cron-jobknative-service 之间显式选择所需的 部署 类型。

6.3.6. Deployment Trait

Deployment 特征负责生成 Kubernetes 部署,确保集成会在集群中运行。

以下配置集提供了这个特征: Kubernetes、Knative、OpenShift

警告

部署特征是 一个平台特征 :禁用它可能会破坏平台功能。

6.3.6.1. 配置

在运行任何与 CLI 集成时,可以指定特征属性:

$ kamel run --trait deployment.[key]=[value] Integration.java

可用的配置选项如下:

属性类型描述

deployment.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

6.3.7. 环境 Trait

在内部使用环境特征来注入集成容器中的标准环境变量,如 NAMESPACEPOD_NAME 等等。

以下配置集提供了这个特征: Kubernetes、Knative、OpenShift

警告

环境特征是 一个平台特征 :禁用它可能会破坏平台功能。

6.3.7.1. 配置

在运行任何与 CLI 集成时,可以指定特征属性:

$ kamel run --trait environment.[key]=[value] --trait environment.[key2]=[value2] Integration.java

可用的配置选项如下:

属性类型描述

environment.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

environment.container-meta

bool

启用 NAMESPACEPOD_NAME 环境变量注入(默认为 true

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

可用的配置选项如下:

属性类型描述

error-handler.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

error-handler.ref

字符串

在应用属性中提供或找到错误处理程序的 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.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

jvm.debug

bool

激活远程调试,以便调试器可以使用端口转发连接到 JVM,例如:

jvm.debug-suspend

bool

在加载主类前立即挂起目标 JVM

jvm.print-command

bool

在容器日志中打印命令使用启动 JVM(默认为 true

jvm.debug-address

字符串

要侦听新启动的 JVM 的传输地址(默认为 *:5005)

jvm.options

[]string

JVM 选项列表

jvm.classpath

字符串

其他 JVM 类路径(使用 Linux 类路径分隔符)

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.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

kamelets.auto

bool

自动注入所有引用的 Kamelets 及其默认配置(默认为启用)

kamelets.list

字符串

要加载到当前集成的以逗号分隔的 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

可用的配置选项如下:

属性类型描述

openapi.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

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

可用的配置选项如下:

属性类型描述

owner.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

owner.target-annotations

[]string

要传输的注解集

owner.target-labels

[]string

要传输的标签集合

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

可用的配置选项如下:

属性类型描述

platform.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

platform.create-default

bool

缺少平台时,创建默认(空)平台。

platform.global

bool

指明在全局操作员中是否应该全局创建平台(默认为 true)。

platform.auto

bool

如果可以创建默认平台(仅在 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.enabled

bool

可用于启用或禁用特征。所有特征共享这个通用属性。

quarkus.package-type

[]github.com/apache/camel-k/pkg/trait.quarkusPackageType

Quarkus 软件包类型,可以是 fast-jarnative (默认的 fast-jar)。如果同时指定了 fast-jarnative,则创建两个 IntegrationKit 资源,并且 原生 kit 优先于 fast-jar 一次。该订单将影响当前集成工具包的解析。如果不存在与集成匹配的现有工具包,则与第一个软件包类型对应的 kit 将分配给集成。

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 命令

名称支持描述示例

bind

在集成流、到 Knative 频道、Kafka 主题或其他端点等绑定 Kubernetes 资源,如 Kamelets。

kamel bind telegram-source -p "source.authorizationToken=The Token" channel:mychannel

completion

生成完成脚本。

kamel completion bash

debug

使用本地调试器调试远程集成。

kamel debug my-integration

delete

删除 OpenShift 中部署的集成。

kamel delete my-integration

describe

获取有关 Camel K 资源的详细信息。这包括 集成工具包 或平台

kamel describe 集成我的集成

get

获取 OpenShift 中部署的集成状态。

kamel get

帮助

获取可用命令的完整列表。如需更多详细信息,您可以输入 --help 作为每个命令的参数。

  • kamel help
  • kamel run --help

init

初始化以 Java 或 YAML 实施的空 Camel K 文件。

kamel init MyIntegration.java

install

在 OpenShift 集群上安装 Camel K。

注: 建议您使用 OpenShift Camel K Operator 安装并卸载 Camel K。

kamel install

Kit

配置集成套件。

kamel kit create my-integration --secret

local

在本地执行集成操作,赋予一组输入集成文件。

kamel local run

log

打印正在运行的集成的日志。

kamel 日志 my-integration

重建

清除一个或多个集成的状态,从而导致重建。

kamel 重建 my-integration

reset

重置当前的 Camel K 安装。

kamel reset

run

在 OpenShift 上运行集成。

kamel 运行 MyIntegration.java

uninstall

从 OpenShift 集群中卸载 Camel K。

注: 建议您使用 OpenShift Camel K Operator 安装并卸载 Camel K。

kamel uninstall

version

显示 Camel-K 客户端版本。

kamel 版本

7.2. Camel K 模式命令行选项

您可以使用 Camel K 模式line 进入 Camel K 集成源文件中的配置选项,该文件在运行时执行,例如使用 kamel 运行 MyIntegration.java。如需了解更多详细信息,请参阅 使用模式 来运行 Camel K 集成

所有可用于 kamel run 命令的选项,您可以指定 作为模式命令行选项。

下表描述了一些最常用的模式选项。

表 7.2. Camel K 模式命令行选项

选项描述

build-property

添加 build-time 属性或 build-time 属性文件。

语法: [my-key=my-value|file:/path/to/my-conf.properties]

config

从 Configmap、Secret 或文件添加运行时配置

语法: [configmap|secret|file]:name[/key]

- name 代表本地文件路径或 ConfigMap/Secret 名称。

- (可选)代表要过滤的 ConfigMap/Secret 键。

依赖项

包括一个外部库(如 Maven 依赖项)

示例: dependency=mvn:org.my:app:1.0

env

在集成容器中设置环境变量。例如: env=MY_ENV_VAR=my-value

label

为集成添加标签。例如,label=my.company=hello

name

添加集成名称。例如,name=my-integration.

open-api

添加 OpenAPI v2 规格。例如,open-api=path/to/my-hello-api.json

配置集

设置用于部署的 Camel K trait 配置集。例如: openshift

属性

添加运行时属性或运行时属性文件。

语法: [my-key=my-value|file:/path/to/my-conf.properties])

resource

添加 ConfigMap、Secret 或文件中的运行时资源

语法: [configmap|secret|file]:name[/key][@path]

- name 代表本地文件路径或 ConfigMap/Secret 名称

- key (可选)代表要过滤的 ConfigMap 或 Secret 键(可选)代表目标路径

特征

在特征中配置 Camel K 功能或核心功能。例如: trait=service.enabled=false