红帽全球峰会Red Hat Camel K is deprecated
Red Hat Camel K is deprecated and the End of Life date for this product is June 30, 2025. For help migrating to the current go-to solution, Red Hat build of Apache Camel, see the Migration Guide.第 2 章 在本地和云基础架构中测试 Camel K
本章论述了测试与 YAKS 的 Camel K 集成的步骤，包括本地和云基础架构(Kubernetes 平台)。
2.1. 使用 YAKS 测试 Camel K
2.1.1. 什么是 YAKS？
YAKS 是一个开源测试自动化平台，它利用行为驱动开发概念在本地和云基础架构上运行测试（例如： Kubernetes 或 OpenShift）。这意味着测试工具能够将您的测试作为本地测试运行，并在 Kubernetes 上原生运行。该框架专为验证 Serverless 和 microservice 应用程序而设计，旨在集成测试下测试并在类似于生产环境的环境中运行的应用程序。典型的 YAKS 测试使用与不同消息传递传输过程中的应用相同的基础架构（例如：Http REST、Knative 事件、Kafka、JMS 等）。
因为 YAKS 本身以 Java 编写，运行时将使用 Java 虚拟机以及 Maven 等构建工具，并与 JUnit、Cucumber 和 Citrus 等已知 Java 测试框架集成来运行测试。
2.1.2. 了解 Camel K 示例
以下是我们想要测试的 Camel K 集成示例：该集成会向用户公开 Http 服务。该服务接受添加 fruit 模型对象的客户端 Http POST 请求。Camel K 路由应用基于内容的路由，将有问题的路由存储在不同的 AWS S3 存储桶中。
在测试场景中，YAKS 将调用 Camel K 服务，并验证消息内容是否已发送到正确的 AWS S3 存储桶。
以下是可能存储在 AWS S3 中的模糊模型对象示例：
{
"id": 1000,
"name": "Pineapple",
"category":{
"id": "1",
"name":"tropical"
},
"nutrition":{
"calories": 50,
"sugar": 9
},
"status": "AVAILABLE",
"price": 1.59,
"tags": ["sweet"]
}{
"id": 1000,
"name": "Pineapple",
"category":{
"id": "1",
"name":"tropical"
},
"nutrition":{
"calories": 50,
"sugar": 9
},
"status": "AVAILABLE",
"price": 1.59,
"tags": ["sweet"]
}以下是 Camel K 集成路由：
from('platform-http:/fruits')
.log('received fruit ${body}')
.unmarshal().json()
.removeHeaders("*")
.setHeader("CamelAwsS3Key", constant("fruit.json"))
.choice()
.when().simple('${body[nutrition][sugar]} <= 5')
.setHeader("CamelAwsS3BucketName", constant("low-sugar"))
.when().simple('${body[nutrition][sugar]} > 5 && ${body[nutrition][sugar]} <= 10')
.setHeader("CamelAwsS3BucketName", constant("medium-sugar"))
.otherwise()
.setHeader("CamelAwsS3BucketName", constant("high-sugar"))
.end()
.marshal().json()
.log('sending ${body}')
.to("aws2-s3://noop?$parameters")from('platform-http:/fruits')
.log('received fruit ${body}')
.unmarshal().json()
.removeHeaders("*")
.setHeader("CamelAwsS3Key", constant("fruit.json"))
.choice()
.when().simple('${body[nutrition][sugar]} <= 5')
.setHeader("CamelAwsS3BucketName", constant("low-sugar"))
.when().simple('${body[nutrition][sugar]} > 5 && ${body[nutrition][sugar]} <= 10')
.setHeader("CamelAwsS3BucketName", constant("medium-sugar"))
.otherwise()
.setHeader("CamelAwsS3BucketName", constant("high-sugar"))
.end()
.marshal().json()
.log('sending ${body}')
.to("aws2-s3://noop?$parameters")路由使用基于内容的路由 EAP，基于给定模糊的 nutrition sugar 评级，将模糊应用到不同的 AWS S3 存储桶(low-sugar, medium-sugar, high-sugar)。
在进行此集成的测试案例中，需要使用不同的模糊调用公开的服务并验证其在 AWS S3 上的结果。
2.1.3. 如何使用 YAKS 本地测试
开始时，让我们只编写测试并在本地运行它。现在，我们不关心如何在云基础架构中进行测试，因为所有内容在使用 JBang 的计算机上运行。
JBang 是仅开始编码和运行 Java 代码以及 Camel K 集成（也看到此前文中关于 JBang 与 Camel K 集成）的好方法。
YAKS 作为框架提供了一组现成的域特定语言(XML、YAML、Groovy、BDD Cucumber 步骤)，用于编写测试以验证部署的服务。
此后，通过 Cucumber 使用行为驱动开发集成。因此，YAKS 测试是使用 BDD Gherkin 语法的单一功能文件，如下所示：
Feature: Camel K Fruit Store
Background:
Given URL: http://localhost:8080
Scenario: Create infrastructure
# Start AWS S3 container
Given Enable service S3
Given start LocalStack container
# Create Camel K integration
Given Camel K integration property file aws-s3-credentials.properties
When load Camel K integration fruit-service.groovy
Then Camel K integration fruit-service should print Started route1 (platform-http:///fruits)
Scenario: Verify fruit service
# Invoke Camel K service
Given HTTP request body: yaks:readFile('pineapple.json')
And HTTP request header Content-Type="application/json"
When send POST /fruits
Then receive HTTP 200 OK
# Verify uploaded S3 file
Given New global Camel context
Given load to Camel registry amazonS3Client.groovy
Given Camel exchange message header CamelAwsS3Key="fruit.json"
Given receive Camel exchange from("aws2-s3://medium-sugar?amazonS3Client=#amazonS3Client&deleteAfterRead=true") with body: yaks:readFile('pineapple.json')Feature: Camel K Fruit Store
Background:
Given URL: http://localhost:8080
Scenario: Create infrastructure
# Start AWS S3 container
Given Enable service S3
Given start LocalStack container
# Create Camel K integration
Given Camel K integration property file aws-s3-credentials.properties
When load Camel K integration fruit-service.groovy
Then Camel K integration fruit-service should print Started route1 (platform-http:///fruits)
Scenario: Verify fruit service
# Invoke Camel K service
Given HTTP request body: yaks:readFile('pineapple.json')
And HTTP request header Content-Type="application/json"
When send POST /fruits
Then receive HTTP 200 OK
# Verify uploaded S3 file
Given New global Camel context
Given load to Camel registry amazonS3Client.groovy
Given Camel exchange message header CamelAwsS3Key="fruit.json"
Given receive Camel exchange from("aws2-s3://medium-sugar?amazonS3Client=#amazonS3Client&deleteAfterRead=true") with body: yaks:readFile('pineapple.json')逐步浏览测试步骤。首先，功能文件使用常见的 Given-When-Then BDD 语法来给出上下文，描述操作并验证结果。每个步骤都调用框架开箱即用的特定 YAKS 操作。用户可以从 大量的步骤 中选择，它们会自动执行诸如发送/接收 Http 请求/响应、启动 Testcontainers、运行 Camel 路由、连接到数据库、在 Kafka 或 Knative 代理上的事件等操作。
在第一个场景中，测试会自动准备一些所需的基础架构。YAKS 测试启动 Localstack Testcontainer 来运行 AWS S3 测试实例(Given start LocalStack 容器)。然后，测试会加载并启动 Camel K integration in test (当加载 Camel K integration fruit-service.groovy)，并等待它正确启动。本地测试中，此步骤使用 JBang 启动 Camel K 集成。之后，后期还会在 Kubernetes 环境中运行测试。
现在，基础架构已启动并运行，测试能够加载 fruit 模型对象作为 Http 请求正文(Given HTTP request body: yaks:readFile ('pineapple.json'))，并调用 Camel K 服务(发送 POST /fruits)。该测试会等待 Http 响应，并验证其 200 OK 状态。
在最后一步中，测试会验证 fruit 对象是否已添加到正确的 AWS S3 存储桶(medium-sugar)。因为 YAKS 本身无法连接到 AWS S3，因此测试将 Apache Camel 用于这一步。该测试会创建一个 Camel 上下文，加载 AWS 客户端，并使用临时 Camel 路由连接到 AWS S3 (Given 接收 Camel 交换来自("aws2-s3://medium-sugar?amazonS3Client=45amazonS3Client&deleteAfterRead=true"))。使用这个 Apache Camel 集成 YAKS，可以使用完整的 300+ Camel 组件来发送和接收信息到各种消息传递传输。Camel Exchange body 必须是与初始 Http 请求中发布的相同模糊模型对象（yaks:readFile ('pineapple.json')。
YAKS 使用 Citrus 提供的强大的消息有效负载验证功能进行此消息内容验证。验证能够比较类型为 XML、Json、纯文本等消息内容。
该操作将完成测试案例。现在，您可以使用 Cucumber 和 JUnit 实例运行此测试。直接使用 YAKS 运行测试的最简单方法是使用 YAKS 命令行客户端。您不需要使用 Maven 依赖项设置整个项目，等等。只需编写测试文件并使用以下方法运行：
yaks run fruit-service.feature --local
$ yaks run fruit-service.feature --local您应该看到一些日志输出，如下所示：
INFO |
INFO | ------------------------------------------------------------------------
INFO | .__ __
INFO | ____ |__|/ |________ __ __ ______
INFO | _/ ___\| \ __\_ __ \ | \/ ___/
INFO | \ \___| || | | | \/ | /\___ \
INFO | \___ >__||__| |__| |____//____ >
INFO | \/ \/
INFO |
INFO | C I T R U S T E S T S 3.4.0
INFO |
INFO | ------------------------------------------------------------------------
INFO |
Scenario: Create infrastructure # fruit-service.feature:6
Given URL: http://localhost:8080
Given Enable service S3
[...]
Scenario: Verify fruit service # fruit-service.feature:20
Given URL: http://localhost:8080
Given HTTP request body: yaks:readFile('pineapple.json')
[...]
Scenario: Remove infrastructure # fruit-service.feature:31
Given URL: http://localhost:8080
Given delete Camel K integration fruit-service
Given stop LocalStack container
3 Scenarios (3 passed)
18 Steps (18 passed)
0m18,051s
INFO | ------------------------------------------------------------------------
INFO |
INFO | CITRUS TEST RESULTS
INFO |
INFO | Create infrastructure .......................................... SUCCESS
INFO | Verify fruit service ........................................... SUCCESS
INFO | Remove infrastructure .......................................... SUCCESS
INFO |
INFO | TOTAL: 3
INFO | FAILED: 0 (0.0%)
INFO | SUCCESS: 3 (100.0%)
INFO |
INFO | ------------------------------------------------------------------------
3 Scenarios (3 passed)
18 Steps (18 passed)
0m18,051s
Test results: Total: 0, Passed: 1, Failed: 0, Errors: 0, Skipped: 0
fruit-service (fruit-service.feature): PassedINFO |
INFO | ------------------------------------------------------------------------
INFO | .__ __
INFO | ____ |__|/ |________ __ __ ______
INFO | _/ ___\| \ __\_ __ \ | \/ ___/
INFO | \ \___| || | | | \/ | /\___ \
INFO | \___ >__||__| |__| |____//____ >
INFO | \/ \/
INFO |
INFO | C I T R U S T E S T S 3.4.0
INFO |
INFO | ------------------------------------------------------------------------
INFO |
Scenario: Create infrastructure # fruit-service.feature:6
Given URL: http://localhost:8080
Given Enable service S3
[...]
Scenario: Verify fruit service # fruit-service.feature:20
Given URL: http://localhost:8080
Given HTTP request body: yaks:readFile('pineapple.json')
[...]
Scenario: Remove infrastructure # fruit-service.feature:31
Given URL: http://localhost:8080
Given delete Camel K integration fruit-service
Given stop LocalStack container
3 Scenarios (3 passed)
18 Steps (18 passed)
0m18,051s
INFO | ------------------------------------------------------------------------
INFO |
INFO | CITRUS TEST RESULTS
INFO |
INFO | Create infrastructure .......................................... SUCCESS
INFO | Verify fruit service ........................................... SUCCESS
INFO | Remove infrastructure .......................................... SUCCESS
INFO |
INFO | TOTAL: 3
INFO | FAILED: 0 (0.0%)
INFO | SUCCESS: 3 (100.0%)
INFO |
INFO | ------------------------------------------------------------------------
3 Scenarios (3 passed)
18 Steps (18 passed)
0m18,051s
Test results: Total: 0, Passed: 1, Failed: 0, Errors: 0, Skipped: 0
fruit-service (fruit-service.feature): Passed2.1.4. 在云中运行 YAKS
YAKS 能够在本地和 Kubernetes 集群一部分运行测试。在 Cloud infrastructure YAKS 上运行测试时，利用 Operator SDK 并提供一个特定的 operator 来管理集群中的测试问题单资源。每次以 自定义资源 的形式声明测试时，YAKS 操作器会自动处理准备正确的运行时，以便将测试作为 Kubernetes Pod 执行。
为什么您要在 Kubernetes 平台上作为云原生资源运行测试？
Kubernetes 已成为 Serverless 和 microservices 架构的标准目标平台。
使用 Camel K 为实例编写 Serverless 或 microservices 应用程序非常声明性。作为您刚刚编写 Camel 路由的开发者，并通过 Camel K operator 直接在集群中运行它。Serverless 应用程序的声明方法以及 Serverless 应用程序的性质使得我们依赖于给定的运行时基础架构，对于验证该基础架构上的应用程序也至关重要。因此，只有将验证测试移到这种非常相同的云基础架构中才会自然。这就是为什么 YAKS 也将测试引入云基础架构，以进行集成和端到端测试。
下面是它的运作方式。您可以运行与 Kubernetes 中本地运行的相同 YAKS 测试。
YAKS 提供 Kubernetes operator 和一组需要安装到的 CRD （自定义资源）。安装 YAKS 的最佳方法是使用 OperatorHub 或 yaks CLI 工具，您可以从 YAKS GitHub 发行页 下载。
使用 yaks-client 二进制文件只运行这个 install 命令：
yaks install
$ yaks install此命令会准备您的 Kubernetes 集群，以使用 YAKS 运行测试。它将负责安装 YAKS 自定义资源定义，设置角色权限并在全局 operator 命名空间中创建 YAKS Operator。
您需要是一个集群管理员来安装自定义资源定义。此操作只需要为整个集群执行一次。
现在，YAKS 操作器已经启动并在运行，您可以在云基础架构上从本地测试运行相同的测试。需要完成的唯一操作是将 Camel K 集成的 Http 端点 URL 从 http://localhost:8080 调整为 http://fruit-service.${YAKS_NAMESPACE}
yaks run fruit-service.feature
$ yaks run fruit-service.feature
我们刚刚跳过了 本地的 CLI 选项。
YAKS CLI 连接到 Kubernetes 集群，而不是使用本地 JBang 工具在本地运行测试，以作为自定义资源创建测试。从 中，YAKS 操作器负责准备测试运行时并将测试作为 Pod 运行。
测试已准备一些基础架构，特别是 Camel K 集成和 AWS S3 Localstack Testcontainer 实例。这如何在 Kubernetes 内工作？YAKS 完全负责它。Camel K 集成与在同一 Kubernetes 集群上运行的 Camel K operator 运行。然后 Testcontainer AWS S3 实例会在 Kubernetes 中自动作为 Pod 运行。即使连接设置也会自动处理。它只是工作！
远程运行测试时，您将看到一些类似的测试日志输出，测试将执行其操作及其验证与本地的完全相同。
您还可以使用以下方法查看测试 Pod 结果：
yaks ls
$ yaks ls这是一个输出示例，您应该获得：
NAME PHASE TOTAL PASSED FAILED SKIPPED ERRORS fruit-service Passed 3 3 0 0 0
NAME PHASE TOTAL PASSED FAILED SKIPPED ERRORS
fruit-service Passed 3 3 0 0 02.1.5. Demostration
此 GitHub 存储库 上提供了整个演示代码。它还介绍了如何在 GitHub CI 操作工作流中集成测试，以便您可以使用每个代码更改自动运行测试。
2.1.6. Apache Camel K 步骤
Apache Camel K 是由 Apache Camel 构建的轻量级集成框架，可在 Kubernetes 上原生运行，专为无服务器和微服务架构而设计。
Camel K 用户可以在首选云(Kubernetes 或 OpenShift)上立即运行使用 Camel DSL 编写的集成代码。
如果测试中的主题是 Camel K 集成，您可以利用 YAKS Camel K 绑定来提供 Camel K 集成的有效步骤。
使用 Camel K 集成
Given create Camel K integration helloworld.groovy
"""
from('timer:tick?period=1000')
.setBody().constant('Hello world from Camel K!')
.to('log:info')
"""
Given Camel K integration helloworld is running
Then Camel K integration helloworld should print Hello world from Camel K!Given create Camel K integration helloworld.groovy
"""
from('timer:tick?period=1000')
.setBody().constant('Hello world from Camel K!')
.to('log:info')
"""
Given Camel K integration helloworld is running
Then Camel K integration helloworld should print Hello world from Camel K!YAKS 框架默认提供 Camel K 扩展库。您可以创建新的 Camel K 集成并检查集成的状态（例如，运行）。
以下小节详细介绍了可用的 Camel K 步骤。
2.1.6.1. API 版本
用于创建和管理资源的默认 Camel K API 版本是 v1。您可以使用 YAKS 配置中设置的环境变量覆盖这个版本。
覆盖 Camel K API 版本
YAKS_CAMELK_API_VERSION=v1alpha1
YAKS_CAMELK_API_VERSION=v1alpha1这会为所有操作设置 Camel K API 版本。
2.1.6.2. 创建 Camel K 集成
@given ("^(?:create|new) Camel K integration {name}.{type}$")
Given create Camel K integration {name}.groovy
"""
<<Camel DSL>>
"""Given create Camel K integration {name}.groovy
"""
<<Camel DSL>>
"""
创建新的 Camel K 与指定路由 DSL 集成。集成会自动启动，并可在其他步骤中通过其 {name} 引用。
@given ("^(?:create|new) Camel K integration {name}.{type} with configuration:$")
Given create Camel K integration {name}.groovy with configuration:
| dependencies | mvn:org.foo:foo:1.0,mvn:org.bar:bar:0.9 |
| traits | quarkus.native=true,quarkus.enabled=true,route.enabled=true |
| properties | foo.key=value,bar.key=value |
| source | <<Camel DSL>> |Given create Camel K integration {name}.groovy with configuration:
| dependencies | mvn:org.foo:foo:1.0,mvn:org.bar:bar:0.9 |
| traits | quarkus.native=true,quarkus.enabled=true,route.enabled=true |
| properties | foo.key=value,bar.key=value |
| source | <<Camel DSL>> |您可以在 Camel K 集成中添加可选配置，如依赖项、特征和属性。
源
路由 DSL，作为 Camel K 集成的源。
依赖项
Maven 协调列表，它将作为库添加到集成运行时中。
遍历
将添加到集成规格中的特征配置列表。每个特征配置值都必须采用 traitname.key=value 格式。
属性
添加到集成中的属性绑定列表。每个值都必须采用 key=value 格式。
2.1.6.3. 加载 Camel K 集成
@given ("^load Camel K integration {name}.{type}$")
Given load Camel K integration {name}.groovyGiven load Camel K integration {name}.groovy
将文件 {name}.groovy 载入为 Camel K 集成。
2.1.6.4. 删除 Camel K 集成
@given ("^delete Camel K integration {name}$")
Given delete Camel K integration {name}Given delete Camel K integration {name}
删除与给定 {name} 的 Camel K 集成。
2.1.6.5. 验证集成状态
Camel K 集成在普通的 Kubernetes pod 中运行。pod 的状态为，处于一个阶段（如 running, stopped）。您可以使用预期验证状态。
@given ("^Camel K integration {name} is running/stopped$")
Given Camel K integration {name} is runningGiven Camel K integration {name} is running
检查 Camel K 与给定 {name} 集成是否处于运行状态，并且副本数为 > 0。步骤轮询给定次数的集成状态，并在尝试之间具有给定延迟的尝试。您可以使用以下方法调整轮询设置：
@given Camel K 资源轮询配置
Given Camel K resource polling configuration
| maxAttempts | 10 |
| delayBetweenAttempts | 1000 |Given Camel K resource polling configuration
| maxAttempts | 10 |
| delayBetweenAttempts | 1000 |2.1.6.6. 观察 Camel K 集成日志
@given ("^Camel K integration {name} should print (.)$")*
Given Camel K integration {name} should print {log-message}Given Camel K integration {name} should print {log-message}
监视 Camel K 集成的日志输出并等待日志中存在给定的 {log-message}。步骤轮询指定时间的日志。您可以使用以下方法调整轮询配置：
@given Camel K 资源轮询配置
Given Camel K resource polling configuration
| maxAttempts | 10 |
| delayBetweenAttempts | 1000 |Given Camel K resource polling configuration
| maxAttempts | 10 |
| delayBetweenAttempts | 1000 |您还可以等待输出中不存在日志消息。只使用这个步骤：
@given ("^Camel K integration {name} should not print (.)$")*
Given Camel K integration {name} should not print {log-message}Given Camel K integration {name} should not print {log-message}您可以启用 YAKS 在测试运行时将日志打印到测试日志输出中。可以使用环境变量设置 'YAKS_CAMELK_PRINT_POD_LOGS=true/false 来启用/禁用日志
要在测试控制台日志记录中看到日志输出，您必须将日志级别设置为 INFO （例如： yaks-config.yaml）。
config: runtime: settings: loggers: - name: INTEGRATION_STATUS level: INFO - name: INTEGRATION_LOGS level: INFO
2.1.6.7. 管理 Camel K 资源
Camel K 步骤可以创建集成等资源。默认情况下，这些资源会在测试场景后自动删除。
可以按照以下步骤关闭自动删除 Camel K 资源。
@given ("^Disable auto removal of Camel K resources$")
Given Disable auto removal of Camel K resources
Given Disable auto removal of Camel K resources
通常，此步骤 是 功能文件中所有场景的背景步骤。这样，多个场景可以在非常相同的 Camel K 资源上工作并共享集成。
还有一个单独的步骤来显式启用自动移除。
@given ("^Enable auto removal of Camel K resources$")
Given Enable auto removal of Camel K resources
Given Enable auto removal of Camel K resources默认情况下，所有 Camel K 资源都会在每次场景后自动删除。
2.1.6.7.1. 使用环境变量启用和禁用自动删除
您可以通过环境变量设置启用/禁用自动移除。
环境变量称为 YAKS_CAMELK_AUTO_REMOVE_RESOURCES=true/false，必须在 test 套件中为所有测试设置。
另外，有一个名为 yaks.camelk.auto.remove.resources=true/false 的系统属性，您必须在 yaks.properties 文件中设置。
2.1.7. kamelet 步骤
kamelets 是 Camel K 中实施的预定义 Camel 路由模板的形式。通常是一个 Kamelet 封装某个功能（例如，发送消息到端点）。Additionaly Kamelets 定义一组用户在使用 Kamelet 时提供的属性。
YAKS 提供管理 Kamelets 的步骤。
2.1.7.1. API 版本
用于创建和管理资源的默认 Kamelet API 版本为 v1。（例如，您可以使用上述环境变量将版本调整为 v1alpha1。）您可以使用 YAKS 配置中设置的环境变量覆盖这个版本。
覆盖 Kamelet API 版本
YAKS_KAMELET_API_VERSION=v1
YAKS_KAMELET_API_VERSION=v1这会为所有操作设置 Kamelet API 版本。
2.1.7.2. create Kamelets
Kamelets 定义了一组属性和规格，您可以使用功能中的独立步骤设置它们。以下步骤在 Kamelet 中设置特定的属性。使用 Kamelet 规格完成后，您可以在当前命名空间中创建 Kamelet。
首先，您可以在 Kamelet 中指定可用插槽(in、out 和 error)的介质类型。
@given ("^Kamelet dataType (in|out|error) (?:=| is)\"{mediaType}\"$")
Given Kamelet dataType in="{mediaType}"Given Kamelet dataType in="{mediaType}"Kamelet 可以使用您在以下步骤中设置的标题。
@given ("^Kamelet title \"{title}\"$")
Given Kamelet title "{title}"Given Kamelet title "{title}"每个模板都使用端点 uri，并定义了一组在 Kamelet 处理发生时调用的步骤。以下步骤在当前 Kamelet 上定义了一个模板。
@given ("^Kamelet template$")
Given Kamelet template
"""
from:
uri: timer:tick
parameters:
period: "#property:period"
steps:
- set-body:
constant: "{{message}}"
- to: "kamelet:sink"
"""Given Kamelet template
"""
from:
uri: timer:tick
parameters:
period: "#property:period"
steps:
- set-body:
constant: "{{message}}"
- to: "kamelet:sink"
"""
该模板使用两个属性 {{message}} 和 {{period}}。这些占位符需要由 Kamelet 用户提供。下一步详细定义了 属性信息 ：
@given ("^Kamelet 属性定义 {name}$")
Given Kamelet property definition message | type | string | | required | true | | example | "hello world" | | default | "hello" |
Given Kamelet property definition message
| type | string |
| required | true |
| example | "hello world" |
| default | "hello" |
属性接收规格，如 type、required 和 example。除了示例外，您还可以为属性设置默认值。
除了在 Kamelet 上使用模板外，您还可以将多个源添加到 Kamelet 中。
@given ("^Kamelet source {name}.{language}$")
Given Kamelet source timer.yaml """ <<YAML>> """
Given Kamelet source timer.yaml
"""
<<YAML>>
"""前面的步骤定义了所有属性和 Kamelet 规格，现在您已准备好在当前命名空间中创建 Kamelet。
@Given("^(?:create|new) Kamelet {name}$")
Given create Kamelet {name}Given create Kamelet {name}
Kamelet 需要 唯一名称。创建一个 Kamelet 意味着会创建一个类型为 Kamelet 的新自定义资源。作为变体，您也可以在创建 Kamelet 时设置模板。
@given ("^(?:create|new) Kamelet {name} with template")
Given create Kamelet {name} with template
"""
<<YAML>>
"""Given create Kamelet {name} with template
"""
<<YAML>>
"""这会在当前命名空间中创建 Kamelet。
2.1.7.3. Load Kamelets
您可以通过在外部 YAML 文件中提供完整的规格来创建新的 Kamelets。此步骤加载文件内容，并在当前命名空间中创建 Kamelet。
@given ("^load Kamelet {name}.kamelet.yaml$")
Given load Kamelet {name}.kamelet.yamlGiven load Kamelet {name}.kamelet.yaml
将文件 {name}.kamelet.yaml 载入为 Kamelet。目前只支持 kamelet.yaml 源文件扩展。
2.1.7.4. delete Kamelets
@Given("^delete Kamelet {name}$")
Given delete Kamelet {name}Given delete Kamelet {name}
从当前命名空间中删除给定 {name} 的 Kamelet。
2.1.7.5. 验证 Kamelet 可用
@given ("^Kamelet {name} is available$$")
Given Kamelet {name} is available$Given Kamelet {name} is available$验证 Kamelet 自定义资源是否在当前命名空间中可用。
2.1.8. 管道步骤
您可以将 Kamelet 绑定到 sink。这个概念在管道中进行了描述。YAKS 作为框架能够与 Kamelets 结合使用创建和验证 Pipes。
管道自 Camel K 中的 API 版本 v1 开始提供。YAKS 还支持 KameletBinding 资源，它们代表与 Pipes 等效的 v1alpha1。因此，如果您需要使用 KameletBindings，您需要明确将 Kamelet API 版本明确设置为 v1alpha1 （例如，通过环境变量设置 YAKS_KAMELET_API_VERSION）。
2.1.8.1. 创建管道
YAKS 提供将 Kamelet 源绑定到 sink 的多个步骤。管道(pipeline)会将源处理的所有信息转发到 sink。
2.1.8.1.1. 绑定到 Http URI
@given ("^bind Kamelet {kamelet} to uri {uri}$")
Given bind Kamelet {name} to uri {uri}Given bind Kamelet {name} to uri {uri}这将带有给定 Kamelet 名称的 Pipe 定义为给定 Http URI 作为接收器的源。
2.1.8.1.2. 绑定到 Kafka 主题
您可以将 Kamelet 源绑定到 Kafka 主题接收器。所有消息都将转发到主题。
@given ("^bind Kamelet {kamelet} to Kafka topic {topic}$")
Given bind Kamelet {kamelet} to Kafka topic {topic}Given bind Kamelet {kamelet} to Kafka topic {topic}2.1.8.1.3. 绑定到 Knative 频道
频道是 Knative 中事件的一部分。与 Kafka 中的主题类似，频道会保存订阅者信息。
@given ("^bind Kamelet {kamelet} to Knative channel {channel}$")
Given bind Kamelet {kamelet} to Knative channel {channel}Given bind Kamelet {kamelet} to Knative channel {channel}可使用不同的实现支持频道。您可以明确设置要在管道中使用的频道类型。
@given ("^bind Kamelet {kamelet} to Knative channel {channel} of kind {kind}$")
Given bind Kamelet {kamelet} to Knative channel {channel} of kind {kind}Given bind Kamelet {kamelet} to Knative channel {channel} of kind {kind}2.1.8.1.4. 指定 source/sink 属性
Pipe 可能需要为源和接收器指定属性。这些属性在 instance 的 Kamelet 源规格中定义。
您可以使用以下步骤中的值设置属性：
@given ("^Pipe source properties$")
Given Pipe source properties
| {property} | {value} |Given Pipe source properties
| {property} | {value} |
上述示例中使用的 Kamelet 源定义了属性 消息。您可以按照如下所示，在管道上设置属性：
Given Pipe source properties | message | "Hello world" |
Given Pipe source properties
| message | "Hello world" |相同的方法适用于 sink 属性。
@given ("^Pipe sink properties$")
Given Pipe sink properties
| {property} | {value} |Given Pipe sink properties
| {property} | {value} |2.1.8.1.5. 创建管道
前面的步骤定义了 Pipe 规格的 source 和 sink。现在，您已准备好在当前命名空间中创建 Pipe。
@Given("^(?:create|new) Pipe {name}$")
Given create Pipe {name}Given create Pipe {name}
Pipe 接收 唯一名称，并使用之前指定的源和接收器。创建 Pipe 表示在当前命名空间中创建类型为 Pipe 的新自定义资源。
2.1.8.2. 加载管道
您可以通过在外部 YAML 文件中提供完整的规格来创建新的 Pipes。步骤加载文件内容，并在当前命名空间中创建 Pipe。
@given ("^load Pipe {name}.yaml$")
Given load Pipe {name}.yamlGiven load Pipe {name}.yaml
将文件 {name}.yaml 载入为 Pipe。目前，YAKS 只支持 .yaml 源文件。
2.1.8.3. 删除管道
@given ("^delete Pipe {name}$")
Given delete Pipe {name}Given delete Pipe {name}
从当前命名空间中删除给定 {name} 的 Pipe。
2.1.8.4. 验证 Pipe 是否可用
@given ("^Pipe {name} 可用$$")
Given Pipe {name} is available$Given Pipe {name} is available$验证 Pipe 自定义资源是否在当前命名空间中可用。
2.1.8.5. 管理 Kamelet 和 Pipe 资源
描述的步骤可以在当前 Kubernetes 命名空间中创建 Kamelet 资源。默认情况下，这些资源会在测试场景后自动删除。
可以按照以下步骤关闭 Auto removal of Kamelet 资源。
@given ("^Disable auto removal of Kamelet resources$")
Given Disable auto removal of Kamelet resources
Given Disable auto removal of Kamelet resources
通常，此步骤 是 功能文件中所有场景的背景步骤。这样，多个场景可以在非常相同的 Kamelet 资源上工作，并共享集成。
还有一个单独的步骤来显式启用自动移除。
@given ("^Enable auto removal of Kamelet resources$")
Given Enable auto removal of Kamelet resources
Given Enable auto removal of Kamelet resources默认情况下，所有 Kamelet 资源都会在每次场景后自动删除。
2.1.8.5.1. 使用环境变量启用和禁用自动删除
您可以通过环境变量设置启用/禁用自动移除。
环境变量称为 YAKS_CAMELK_AUTO_REMOVE_RESOURCES=true/false，必须在 test 套件中为所有测试设置。
另外，有一个名为 yaks.camelk.auto.remove.resources=true/false 的系统属性，您必须在 yaks.properties 文件中设置。
'%20d='M201.5%20305.5c-13.8%200-24.9-11.1-24.9-24.6%200-13.8%2011.1-24.9%2024.9-24.9%2013.6%200%2024.6%2011.1%2024.6%2024.9%200%2013.6-11.1%2024.6-24.6%2024.6zM504%20256c0%20137-111%20248-248%20248S8%20393%208%20256%20119%208%20256%208s248%20111%20248%20248zm-132.3-41.2c-9.4%200-17.7%203.9-23.8%2010-22.4-15.5-52.6-25.5-86.1-26.6l17.4-78.3%2055.4%2012.5c0%2013.6%2011.1%2024.6%2024.6%2024.6%2013.8%200%2024.9-11.3%2024.9-24.9s-11.1-24.9-24.9-24.9c-9.7%200-18%205.8-22.1%2013.8l-61.2-13.6c-3-.8-6.1%201.4-6.9%204.4l-19.1%2086.4c-33.2%201.4-63.1%2011.3-85.5%2026.8-6.1-6.4-14.7-10.2-24.1-10.2-34.9%200-46.3%2046.9-14.4%2062.8-1.1%205-1.7%2010.2-1.7%2015.5%200%2052.6%2059.2%2095.2%20132%2095.2%2073.1%200%20132.3-42.6%20132.3-95.2%200-5.3-.6-10.8-1.9-15.8%2031.3-16%2019.8-62.5-14.9-62.5zM302.8%20331c-18.2%2018.2-76.1%2017.9-93.6%200-2.2-2.2-6.1-2.2-8.3%200-2.5%202.5-2.5%206.4%200%208.6%2022.8%2022.8%2087.3%2022.8%20110.2%200%202.5-2.2%202.5-6.1%200-8.6-2.2-2.2-6.1-2.2-8.3%200zm7.7-75c-13.6%200-24.6%2011.1-24.6%2024.9%200%2013.6%2011.1%2024.6%2024.6%2024.6%2013.8%200%2024.9-11.1%2024.9-24.6%200-13.8-11-24.9-24.9-24.9z'/%3e%3c/svg%3e){kind=small}