Red Hat Summit 红帽全球峰会支持控制台（Console）开发人员开始试用联系人

OpenShift 上的 Fuse 指南

Red Hat Fuse 7.8

在 OpenShift 上安装并使用 Red Hat Fuse 进行开发

Red Hat Fuse Documentation Team

摘要

在 OpenShift 中使用 Fuse 指南

前言

Red Hat Fuse on OpenShift 允许您在 OpenShift Container Platform 上部署 Fuse 应用程序。

第 1 章 开始前

Release Notes

有关此版本的重要信息，请参阅发行注记。

版本兼容性和支持

有关版本兼容性和支持的详情，请查看 Red Hat JBoss Fuse 支持的配置页面。

支持 Windows O/S

Windows O/S 上完全支持 OpenShift 上的 Fuse 的开发人员工具(oc 客户端和容器开发套件)。Linux 命令行语法中显示的示例也可以在 Windows O/S 上工作，只要它们被适当地修改以模糊的 Windows 命令行语法。

1.1. 比较：OpenShift 中的 Fuse 独立和 Fuse

有几个主要功能的不同：

  • 在 OpenShift 上使用 Fuse 的应用部署由应用及所有必需运行时组件打包在 Docker 镜像内。应用程序不会像 Fuse Standalone 一样部署到运行时，应用程序镜像本身是一个通过 OpenShift 部署和管理的完整运行时环境。
  • OpenShift 环境中的补丁与 Fuse Standalone 不同，因为每个应用程序镜像都是完整的运行时环境。若要应用补丁，应用程序镜像将重新构建并重新部署到 OpenShift 中。核心 OpenShift 管理功能允许滚动升级和并行部署来在升级过程中保持应用程序的可用性。
  • Fuse 中 Fabric 提供的置备和集群功能已被 Kubernetes 和 OpenShift 中的等效功能替代。不需要创建或配置单独的子容器，因为 OpenShift 会自动为您部署和扩展应用。
  • OpenShift 环境中不使用光纤端点。必须使用 Kubernetes 服务。
  • 使用 A-MQ for OpenShift 镜像创建和管理消息传递服务，不直接 包含在 Karaf 容器中。OpenShift 上的 Fuse 提供了 camel-amq 组件的增强版本，允许无缝连接 OpenShift 到 Kubernetes 中的消息传递服务。
  • 强烈建议使用 Karaf shell 运行 Karaf 实例的实时更新，因为如果应用程序容器重新启动或扩展，则不会保留更新。这是不可变架构的基本原则，对于在 OpenShift 中实现可扩展性和灵活性至关重要。
  • 红帽支持直接链接到红帽 Fuse 组件的 Maven 依赖项。不支持用户引入的第三方 Maven 依赖项。
  • SSH 代理不包含在 Apache Karaf 微容器中，因此您无法使用 bin/client 控制台客户端连接到该容器。
  • 在 OpenShift 应用的 Fuse 中协议兼容性和 Camel 组件：非基于 HTTP 的通信必须使用 TLS 和 SNI，以便从外部 OpenShift 路由到 Fuse 服务(Camel consumer 端点)。

第 2 章 管理员入门

如果您是 OpenShift 管理员，您可以通过以下方法为 OpenShift 部署上的 Fuse 准备 OpenShift 集群：

  1. 配置红帽容器注册表身份验证.
  2. 在 OpenShift 镜像和模板上安装 Fuse。

2.1. 配置 Red Hat Container Registry 身份验证

在导入并使用 OpenShift 镜像流和模板上的 Red Hat Fuse 之前，您必须配置红帽容器 registry 身份验证。

流程

  1. 以管理员身份登录 OpenShift 服务器：

    Copy to Clipboard Toggle word wrap 
    oc login -u system:admin

  2. 登录到您要安装镜像流的 OpenShift 项目。我们建议您将 openshift 项目用于 OpenShift 镜像流上的 Fuse。

    Copy to Clipboard Toggle word wrap 
    oc project openshift

  3. 使用您的红帽客户门户网站帐户或 Red Hat Developer Program 帐户凭证创建 docker-registry secret。将 <pull_secret_name > 替换为您要创建的 secret 的名称。

    Copy to Clipboard Toggle word wrap 
    oc create secret docker-registry <pull_secret_name> \
  --docker-server=registry.redhat.io \
  --docker-username=CUSTOMER_PORTAL_USERNAME \
  --docker-password=CUSTOMER_PORTAL_PASSWORD \
  --docker-email=EMAIL_ADDRESS
    注意

    您需要在镜像流所在的每个新命名空间中创建 docker-registry secret，并在使用 registry.redhat.io 的每个命名空间中创建一个 docker-registry secret。

  4. 要使用 secret 为 pod 拉取镜像，请将 secret 添加到您的服务帐户。服务帐户的名称必须与服务帐户 pod 使用的名称匹配。以下示例使用 default，这是 default 服务帐户。

    Copy to Clipboard Toggle word wrap 
    oc secrets link default <pull_secret_name> --for=pull

  5. 要使用 secret 来推送和拉取构建镜像，该 secret 必须可在 pod 中挂载。要挂载 secret，请使用以下命令：

    Copy to Clipboard Toggle word wrap 
    oc secrets link builder <pull_secret_name>

如果您不想使用您的红帽帐户用户名和密码来创建 secret，您应该使用 registry 服务帐户 创建身份验证令牌。

如需更多信息，请参阅：

2.2. 在 OpenShift 4.x 服务器上安装 Fuse 镜像流和模板

OpenShift Container Platform 4.x 使用 Samples Operator，它在 OpenShift 命名空间中操作，用于安装和更新基于 Red Hat Enterprise Linux (RHEL)的 OpenShift Container Platform 镜像流和模板。在 OpenShift 镜像流和模板上安装 Fuse：

  • 重新配置 Samples Operator

  • 将 Fuse 镜像流和模板添加到 Skipped Imagestreams 和 Skipped Templates 字段中。

    • 跳过的 Imagestreams：位于 Samples Operator 清单中的 Imagestreams，但集群管理员希望 Operator 忽略或不管理。
    • 跳过的模板：在 Samples Operator 清单中，但集群管理员希望 Operator 忽略或不管理的模板。

先决条件

流程

  1. 启动 OpenShift 4 服务器。

  2. 以管理员身份登录 OpenShift 服务器。

    Copy to Clipboard Toggle word wrap 
    oc login -u system:admin

  3. 验证您是否使用创建了 docker-registry secret 的项目。

    Copy to Clipboard Toggle word wrap 
    oc project openshift

  4. 查看 Samples operator 的当前配置。

    Copy to Clipboard Toggle word wrap 
    oc get configs.samples.operator.openshift.io -n openshift-cluster-samples-operator -o yaml

  5. 配置 Samples operator 以忽略添加的 fuse 模板和镜像流。

    Copy to Clipboard Toggle word wrap 
    oc edit configs.samples.operator.openshift.io -n openshift-cluster-samples-operator

  6. 添加 Fuse imagestreams Skipped Imagestreams 部分，并将 Fuse 和 Spring Boot 2 模板添加到 Skipped Templates 部分。

    Copy to Clipboard Toggle word wrap 
    [...]
spec:
  architectures:
  - x86_64
  managementState: Managed
  skippedImagestreams:
  - fis-java-openshift
  - fis-karaf-openshift
  - fuse7-console
  - fuse7-eap-openshift
  - fuse7-java-openshift
  - fuse7-karaf-openshift
  - jboss-fuse70-console
  - jboss-fuse70-eap-openshift
  - jboss-fuse70-java-openshift
  - jboss-fuse70-karaf-openshift
  - fuse-apicurito-generator
  - apicurito-ui
  skippedTemplates:
  - s2i-fuse78-eap-camel-amq
  - s2i-fuse78-eap-camel-cdi
  - s2i-fuse78-eap-camel-cxf-jaxrs
  - s2i-fuse78-eap-camel-cxf-jaxws
  - s2i-fuse78-karaf-camel-amq
  - s2i-fuse78-karaf-camel-log
  - s2i-fuse78-karaf-camel-rest-sql
  - s2i-fuse78-karaf-cxf-rest
  - s2i-fuse78-spring-boot-2-camel-amq
  - s2i-fuse78-spring-boot-2-camel-config
  - s2i-fuse78-spring-boot-2-camel-drools
  - s2i-fuse78-spring-boot-2-camel-infinispan
  - s2i-fuse78-spring-boot-2-camel-rest-3scale
  - s2i-fuse78-spring-boot-2-camel-rest-sql
  - s2i-fuse78-spring-boot-2-camel
  - s2i-fuse78-spring-boot-2-camel-xa
  - s2i-fuse78-spring-boot-2-camel-xml
  - s2i-fuse78-spring-boot-2-cxf-jaxrs
  - s2i-fuse78-spring-boot-2-cxf-jaxws
  - s2i-fuse78-spring-boot-2-cxf-jaxrs-xml
  - s2i-fuse78-spring-boot-2-cxf-jaxws-xml

  7. 在 OpenShift 镜像流上安装 Fuse。

    Copy to Clipboard Toggle word wrap 
    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005

oc create -n openshift -f ${BASEURL}/fis-image-streams.json
    注意

    如果显示错误，显示消息 "Error from server (AlreadyExists): imagestreams.image.openshift.io <imagestreamname> already exists"，使用以下命令将现有镜像流替换为最新的镜像流。

    Copy to Clipboard Toggle word wrap 
    oc replace --force -n openshift -f ${BASEURL}/fis-image-streams.json

  8. 在 OpenShift quickstart 模板上安装 Fuse:

    Copy to Clipboard Toggle word wrap 
    for template in eap-camel-amq-template.json \
 eap-camel-cdi-template.json \
 eap-camel-cxf-jaxrs-template.json \
 eap-camel-cxf-jaxws-template.json \
 karaf-camel-amq-template.json \
 karaf-camel-log-template.json \
 karaf-camel-rest-sql-template.json \
 karaf-cxf-rest-template.json ;
 do
 oc create -n openshift -f \
 https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/quickstarts/${template}
 done

  9. 安装 Spring Boot 2 quickstart 模板：

    Copy to Clipboard Toggle word wrap 
    for template in spring-boot-2-camel-amq-template.json \
 spring-boot-2-camel-config-template.json \
 spring-boot-2-camel-drools-template.json \
 spring-boot-2-camel-infinispan-template.json \
 spring-boot-2-camel-rest-3scale-template.json \
 spring-boot-2-camel-rest-sql-template.json \
 spring-boot-2-camel-template.json \
 spring-boot-2-camel-xa-template.json \
 spring-boot-2-camel-xml-template.json \
 spring-boot-2-cxf-jaxrs-template.json \
 spring-boot-2-cxf-jaxws-template.json \
 spring-boot-2-cxf-jaxrs-xml-template.json \
 spring-boot-2-cxf-jaxws-xml-template.json ;
 do oc create -n openshift -f \
 https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/quickstarts/${template}
 done

  10. （可选） 查看 OpenShift 模板上安装的 Fuse:

    Copy to Clipboard Toggle word wrap 
    oc get template -n openshift

2.3. 在 OpenShift 4.x 上安装 API Designer

Red Hat Fuse on OpenShift 提供了 API Designer，它是一个基于 Web 的 API 设计器工具，可用于设计 REST API。API Designer operator 简化了 OpenShift Container Platform 4.x 上 API Designer 的安装和升级过程。

作为 OpenShift 管理员，您可以将 API Designer 操作器安装到 OpenShift 项目（命名空间）。安装 Operator 后，Operator 会在所选命名空间中运行。但是，若要使 API Designer 充当服务（您作为 OpenShift 管理员）或开发人员必须创建 API Designer 的实例。API Designer 服务提供用于访问 API Designer Web 控制台的 URL。

先决条件

  • 具有 OpenShift 集群的管理员访问权限。
  • 您已为 Red Hat Container Registry 配置身份验证。

流程

  1. 启动 OpenShift 4.x 服务器。
  2. 在 Web 浏览器中，导航到浏览器中的 OpenShift 控制台。使用您的凭证登录到控制台。
  3. 点 Operators，然后点 OperatorHub。
  4. 在搜索字段中，键入 API Designer。
  5. 点 API Designer 卡。API Designer operator install 页面将打开。

  6. 点 Install。此时会打开 Install Operator 页面。

    1. 对于 Installation mode，请从集群中的命名空间列表中选择一个命名空间（项目），

    2. 对于 Approval Strategy，选择 Automatic 或 Manual 来配置 OpenShift 如何处理对 API Designer Operator 的更新。

      • 如果选择 Automatic 更新，当 API Designer Operator 的新版本可用时，OpenShift Operator Lifecycle Manager (OLM)将自动升级 API Designer 的运行实例，而无需人为干预。
      • 如果选择手动 更新，则当有新版 Operator 可用时，OLM 会创建更新请求。作为集群管理员，您必须手动批准该更新请求，才能将 API Designer operator 更新至新版本。
  7. 点 Install 使 API Designer Operator 可供指定命名空间（项目）使用。
  8. 要验证项目中是否安装了 API Designer，请点 Operators，然后点 Installed Operators 查看列表中的 API Designer。

后续步骤

安装 API Designer 操作器后，必须通过创建 API Designer 实例，将 API Designer 添加为 OpenShift 项目。此任务可以通过两种方式来完成：

2.3.1. 将 API Designer 作为服务添加到 OpenShift 4.x 项目

在 OpenShift 4.x 项目中安装了 API Designer 操作器后，您（或 OpenShift 开发人员）可以将它作为服务添加到 OpenShift 项目中。API Designer 服务提供开发人员用于访问 API Designer Web 控制台的 URL。

注意

如需 OpenShift 开发人员遵循的步骤，请参阅 设计 API，将 API Designer 作为服务添加到 OpenShift 4.x 项目中。

先决条件

  • 具有 OpenShift 集群的管理员访问权限。
  • API Designer 操作器安装到当前的 OpenShift 项目中。

流程

  1. 在 OpenShift Web 控制台中，点 Operators，然后点 Installed Operators。
  2. 在 Name 列中，单击 API Designer。

  3. 在 Provided APIs 下，单击 Create Instance。

    此时会打开 API Designer 实例的最小起始模板的默认表单。

  4. 接受默认值或可选编辑以下值：

    • 大小 ：API Designer 实例的 pod 数量。

      默认为两个新资源类型的 pod，其中包含专门用于管理 API Designer 的逻辑。

    • Image: API Designer 镜像。如果您更改了此镜像，则会在集群中自动升级 API Designer Operator。
  5. 单击 Create 以创建新的 apicurito-service。OpenShift 为新的 API Designer 服务启动 pod、服务和其他组件。

  6. 验证 API Designer 服务是否可用：

    1. 点 Operators，然后点 Installed Operators。

    2. 在 Provided APIs 列中，点 Apicurito CRD。

      在 Operator Details 页面中，列出了 apicurito-service。

  7. 获取 API Designer 的 URL：

    1. 点 Networking > Routes。
    2. 确保已选中了正确的项目。
    3. 在 apicurito-service-ui 行中，在 Location 列中找到 API Designer Web 控制台的 URL。

2.3.2. 在 OpenShift 4.x 上升级 API Designer

Red Hat OpenShift 4.x 处理 operator 的更新，包括 Red Hat Fuse operator。如需更多信息，请参阅 Operators OpenShift 文档。

然后，Operator 更新可能会触发应用程序升级。应用程序升级是如何配置的，具体取决于应用程序的配置方式。

对于 API Designer 应用程序，当您升级 API Designer operator 时，OpenShift 会自动升级集群中的任何 API 设计器应用程序。

2.3.3. API Designer 的 metering 标签

您可以使用 OpenShift Metering operator 来分析已安装的 API Designer operator、UI 组件和代码生成器，以确定您是否符合红帽订阅。如需有关 Metering 的更多信息，请参阅 OpenShift 文档。

下表列出了 API Designer 的 metering 标签。

表 2.1. API Designer Metering 标签
标签可能的值

com.company

Red_Hat

rht.prod_name

Red_Hat_Integration

rht.prod_ver

7.8

rht.comp

fuse

rht.comp_ver

7.8

rht.subcomp

fuse-apicurito

apicurito-service-ui

apicurito-service-generator

rht.subcomp_t

infrastructure

例子

  • API Designer operator 示例：

    Copy to Clipboard Toggle word wrap 
    apicurito-operator
com.company: Red_Hat
rht.prod_name: Red_Hat_Integration
rht.prod_ver: 7.8
rht.comp: Fuse
rht.comp_ver: 7.8
rht.subcomp: fuse-apicurito
rht.subcomp_t: infrastructure

  • API Designer UI 组件示例：

    Copy to Clipboard Toggle word wrap 
    com.company: Red_Hat
rht.prod_name: Red_Hat_Integration
rht.prod_ver: 7.8
rht.comp: Fuse
rht.comp_ver: 7.8
rht.subcomp: apicurito-service-ui
rht.subcomp_t: infrastructure

  • API Designer Generator 组件示例：

    Copy to Clipboard Toggle word wrap 
    com.company: Red_Hat
rht.prod_name: Red_Hat_Integration
rht.prod_ver: 7.8
rht.comp: Fuse
rht.comp_ver: 7.8
rht.subcomp: apicurito-service-generator
rht.subcomp_t: infrastructure

2.3.4. 在受限环境中安装 API Designer 的注意事项

在受限环境中安装的 OpenShift 集群默认无法访问红帽提供的 OperatorHub 源，因为这些远程源需要足够的互联网连接。在这种情况下，要安装 API 设计器 Operator，您必须完成以下先决条件：

  • 禁用 Operator Lifecycle Manager (OLM)的默认远程 OperatorHub 源。
  • 使用有完全互联网访问的工作站来创建 OperatorHub 内容的本地镜像。
  • 将 OLM 配置为，从本地源而不是默认的远程源安装和管理 Operator。

如需更多信息，请参阅 OpenShift 文档中的 在受限网络中使用 Operator Lifecycle Manager 部分。创建 OperatorHub 的本地镜像后，您可以执行后续步骤。

2.4. 在 OpenShift 4.x 中设置 Fuse 控制台

在 OpenShift 4.x 中，设置 Fuse 控制台涉及保护、安装和部署它。您可以选择安装和部署 Fuse 控制台：

另外，您可以为 Fuse 控制台实施基于角色的访问控制(RBAC)，如 第 2.4.3 节 “OpenShift 4.x 上 Fuse 控制台的基于角色的访问控制” 所述。

2.4.1. 使用 OperatorHub 在 OpenShift 4.x 上安装和部署 Fuse 控制台

要在 OpenShift 4.x 上安装 Fuse 控制台，您可以使用 OpenShift OperatorHub 中提供的 Fuse Console Operator。要部署 Fuse 控制台，请创建一个已安装 Operator 实例。

前提条件

如果要为 Fuse 控制台自定义基于角色的访问控制(RBAC)，则必须在安装 Fuse Console Operator 的同一 OpenShift 命名空间中有一个 RBAC 配置映射文件。如果要使用默认的 RBAC 行为，如 OpenShift 4.x 上 Fuse Console 的基于角色的访问控制 中所述，则不需要提供配置映射文件。

流程

要安装和部署 Fuse 控制台：

  1. 以具有集群管理员访问权限的用户身份登录 Web 浏览器中的 OpenShift 控制台。
  2. 点 Operators，然后点 OperatorHub。
  3. 在搜索字段窗口中，键入 Fuse Console 来过滤操作器列表。
  4. 单击 Fuse Console Operator。

  5. 在 Fuse Console Operator 安装窗口中，单击 Install。

    Create Operator Subscription 表单将打开。

    • 对于 更新频道，请选择 fuse-console-7.8.x。

    • 对于 Installation Mode，接受 default （集群中的特定命名空间）。

      请注意，在安装 Operator 后，当部署 Fuse 控制台时，您可以选择监控集群中的所有命名空间中的应用程序，或者仅监控安装 Fuse Console operator 的命名空间中的应用程序。

    • 对于 Installed Namespace，选择要在其中安装 Fuse Console Operator 的命名空间。

    • 对于 批准策略，您可以选择 Automatic 或 Manual 来配置 OpenShift 如何处理对 Fuse Console Operator 的更新。

      • 如果选择 Automatic 更新，当 Fuse Console Operator 的新版本可用时，OpenShift Operator Lifecycle Manager (OLM)将自动升级 Fuse 控制台的运行实例，而无需人为干预。
      • 如果选择手动 更新，则当有新版 Operator 可用时，OLM 会创建更新请求。作为集群管理员，您必须手动批准该更新请求，才能将 Fuse Console Operator 更新至新版本。

  6. 点 Install。

    OpenShift 在当前命名空间中安装 Fuse Console Operator。

  7. 要验证安装，点 Operators，然后点 Installed Operators。您可以在 Operator 列表中看到 Fuse Console。

  8. 使用 OpenShift Web 控制台部署 Fuse 控制台：

    1. 在 Installed Operators 列表中，单击 Name 列下的 Fuse Console。

    2. 在 Provided APIs 下的 Operator Details 页面中，点 Create Instance。

      接受配置默认值或选择性地编辑它们。

      对于 Replicas，如果要提高 Fuse 控制台性能（例如在高可用性环境中），您可以增加分配给 Fuse 控制台的 pod 数量。

      对于 Rbac （基于角色的访问控制），如果要为 Fuse 控制台启用 RBAC，在 Form 视图中将 rbac > Enabled 选项设置为 true。另外，在 YAML 视图中，编辑该文件以在 spec 下包含以下条目：

      Copy to Clipboard Toggle word wrap 
      rbac:
    enabled: true

      如果要自定义默认的 RBAC 行为，且 ConfigMap 文件已在安装 Fuse Console Operator 的命名空间中存在时，才在 config Map 字段中指定一个值。如需有关 RBAC 的更多信息，请参阅 OpenShift 4.x 上 Fuse 控制台的基于角色的访问控制。

    3. 点 Create。

      Fuse Console Operator Details 页面将打开，并显示部署的状态。

  9. 打开 Fuse 控制台：

    1. 对于 命名空间 部署：在 OpenShift Web 控制台中，打开安装 Fuse Console operator 的项目，然后选择 Overview。在 Project Overview 页面中，向下滚动到 Launcher 部分，再单击 Fuse Console URL 将它打开。

      对于 集群部署，在 OpenShift Web 控制台的标题栏中，点网格图标( mf os grid icon )。在弹出菜单中，在红帽应用程序 下，单击 Fuse Console URL 链接。

    2. 登录 Fuse 控制台。

      在列出所需权限的浏览器中打开 Authorize Access 页面。

    3. 点击 Allow selected permissions。

      Fuse Console 在浏览器中打开，并显示您具有访问权限的 Fuse 应用容器集。

  10. 点您要查看的应用程序的 Connect。

    这时将打开一个新的浏览器窗口，显示 Fuse 控制台中的应用程序。

2.4.2. 使用命令行在 OpenShift 4.x 上安装和部署 Fuse 控制台

在 OpenShift 4.x 中，您可以选择其中一个部署选项来从命令行安装和部署 Fuse 控制台：

  • 集群 - Fuse Console 可以发现并连接到 OpenShift 集群上的多个命名空间（项目）部署的 Fuse 应用程序。若要部署此模板，您必须具有 OpenShift 集群的管理员角色。
  • 具有基于角色的访问控制的集群 - 具有可配置基于角色的访问控制(RBAC)的集群模板。如需更多信息，请参阅 OpenShift 4.x 上 Fuse 控制台的基于角色的访问控制。
  • namespace - Fuse 控制台有权访问特定的 OpenShift 项目（命名空间）。若要部署此模板，您必须具有 OpenShift 项目的管理员角色。
  • 具有基于角色的访问控制的命名空间 - 带有可配置 RBAC 的命名空间模板。如需更多信息，请参阅 OpenShift 4.x 上 Fuse 控制台的基于角色的访问控制。

要查看 Fuse Console 模板的参数列表，请运行以下命令：

Copy to Clipboard Toggle word wrap 
oc process --parameters -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/fuse-console-namespace-os4.json

先决条件

流程

  1. 使用以下命令检索所有模板的列表，验证是否安装了 Fuse Console 镜像流：

    Copy to Clipboard Toggle word wrap 
    oc get template -n openshift

  2. 另外，如果要使用新的发行版本标签更新已安装的镜像流，请使用以下命令将 Fuse Console 镜像导入到 openshift 命名空间：

    Copy to Clipboard Toggle word wrap 
    oc import-image fuse7/fuse7-console:1.8 --from=registry.redhat.io/fuse7/fuse-console:1.8 --confirm -n openshift

  3. 运行以下命令来获取 Fuse Console APP_NAME 值：

    Copy to Clipboard Toggle word wrap 
    oc process --parameters -f TEMPLATE-FILENAME

    其中 TEMPLATE-FILENAME 是以下模板之一：

  4. 从您在 OpenShift 4.x 上保护 Fuse 控制台 生成的证书，使用以下命令创建 secret 并将其挂载到 Fuse 控制台中（其中 APP_NAME 是 Fuse 控制台应用程序的名称）。

    Copy to Clipboard Toggle word wrap 
    oc create secret tls APP_NAME-tls-proxying --cert server.crt --key server.key

  5. 运行以下命令，根据 Fuse Console 模板的本地副本创建一个新应用程序（其中 myproject 是 OpenShift 项目的名称），mytemp 是包含 Fuse 控制台模板的本地目录的路径，myhost 是访问 Fuse 控制台的主机名：

    • 对于集群模板：

      Copy to Clipboard Toggle word wrap 
      oc new-app -n myproject -f {templates-base-url}/fuse-console-cluster-os4.json  -p ROUTE_HOSTNAME=myhost”

    • 对于使用 RBAC 模板的集群：

      Copy to Clipboard Toggle word wrap 
      oc new-app -n myproject -f {templates-base-url}/fuse-console-cluster-rbac.yml -p ROUTE_HOSTNAME=myhost”

    • 对于命名空间模板：

      Copy to Clipboard Toggle word wrap 
      {templates-base-url}/fuse-console-namespace-os4.json

    • 对于使用 RBAC 模板的命名空间：

      Copy to Clipboard Toggle word wrap 
      oc new-app -n myproject -f {templates-base-url}/fuse-console-namespace-rbac.yml

  6. 要配置 Fuse 控制台使其能够打开 OpenShift Web 控制台，请运行以下命令设置 OPENSHIFT_WEB_CONSOLE_URL 环境变量：

    Copy to Clipboard Toggle word wrap 
    oc set env dc/${APP_NAME} OPENSHIFT_WEB_CONSOLE_URL=`oc get -n openshift-config-managed cm console-public -o jsonpath={.data.consoleURL}`

  7. 运行以下命令，获取 Fuse Console 部署的状态和 URL：

    Copy to Clipboard Toggle word wrap 
    oc status
  8. 要从浏览器访问 Fuse 控制台，请使用步骤 7 返回的 URL （例如 https://fuse-console.192.168.64.12.nip.io）。
2.4.2.1. 生成证书来保护 OpenShift 4.x 上的 Fuse 控制台

在 OpenShift 4.x 中，若要在 Fuse Console 代理和 Jolokia 代理安全之间保持连接，必须在部署 Fuse 控制台前生成客户端证书。服务签名证书颁发机构私钥必须用于为客户端证书签名。

只有在 使用命令行安装和部署 Fuse 控制台时，您必须按照以下步骤操作。如果使用 Fuse Console Operator，它会为您处理此任务。

重要

您必须为每个 OpenShift 集群生成并签署单独的客户端证书。不要将同一证书用于多个集群。

先决条件

  • 具有 集群管理员 对 OpenShift 集群的访问权限。

  • 如果您要为多个 OpenShift 集群生成证书，并且之前在当前目录中为不同的集群生成证书，请执行以下操作之一，以确保为当前集群生成不同的证书：

    • 从当前目录中删除现有证书文件（如 ca.crt、ca.key、ca.key 和 ca.srl）。

    • 更改到其他工作目录。例如，如果您的当前工作目录命名为 cluster1，请创建一个新的 cluster2 目录，并将工作目录改为该目录：

      mkdir ../cluster2

      cd ../cluster2

流程

  1. 以具有集群管理员访问权限的用户身份登录 OpenShift：

    Copy to Clipboard Toggle word wrap 
    oc login -u <user_with_cluster_admin_role>

  2. 通过执行以下命令来检索服务签名证书颁发机构密钥：

    • 检索证书：

      Copy to Clipboard Toggle word wrap 
      oc get secrets/signing-key -n openshift-service-ca -o "jsonpath={.data['tls\.crt']}" | base64 --decode > ca.crt

    • 检索私钥：

      Copy to Clipboard Toggle word wrap 
      oc get secrets/signing-key -n openshift-service-ca -o "jsonpath={.data['tls\.key']}" | base64 --decode > ca.key

  3. 使用 easyrsa、openssl 或 cfssl 生成客户端证书，如 Kubernetes 证书管理 中所述。

    以下是使用 openssl 的示例命令：

    1. 生成私钥：

      Copy to Clipboard Toggle word wrap 
      openssl genrsa -out server.key 2048

    2. 编写 CSR 配置文件。

      Copy to Clipboard Toggle word wrap 
      cat <<EOT >> csr.conf
  [ req ]
  default_bits = 2048
  prompt = no
  default_md = sha256
  distinguished_name = dn

  [ dn ]
  CN = fuse-console.fuse.svc

  [ v3_ext ]
  authorityKeyIdentifier=keyid,issuer:always
  keyUsage=keyEncipherment,dataEncipherment,digitalSignature
  extendedKeyUsage=serverAuth,clientAuth
EOT

      在这里，CN 参数中的值指的是应用程序使用的应用程序名称和命名空间。

    3. 生成 CSR：

      Copy to Clipboard Toggle word wrap 
      openssl req -new -key server.key -out server.csr -config csr.conf

    4. 发布签名证书：

      Copy to Clipboard Toggle word wrap 
      openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 10000 -extensions v3_ext -extfile csr.conf

后续步骤

您需要此证书来为 Fuse 控制台创建 secret，如 使用命令行在 OpenShift 4.x 上安装和部署 Fuse 控制台 中所述。

2.4.3. OpenShift 4.x 上 Fuse 控制台的基于角色的访问控制

Fuse 控制台提供基于角色的访问控制(RBAC)，它根据 OpenShift 提供的用户授权来推断访问。在 Fuse 控制台中，RBAC 决定用户对 pod 执行 MBean 操作的能力。

如需有关 OpenShift 授权的信息，请参阅 OpenShift 文档中的使用 RBAC 定义和应用权限 部分。

当使用 Operator 在 OpenShift 上安装 Fuse 控制台时，默认禁用基于角色的访问控制。您可以选择在使用 Operator 期间或安装后启用 RBAC，如 使用 OperatorHub 在 OpenShift 4.x 上安装和部署 Fuse 控制台 中所述。

如果要为 Fuse 控制台实施基于角色的访问控制，则必须使用通过 RBAC 配置的模板之一(fuse-console-cluster-rbac.yml 或 fuse-console-namespace-rbac.yml)来安装 Fuse 控制台 ，如在 OpenShift 4.x 上安装 Fuse 控制台 中所述。

Fuse Console RBAC 利用 OpenShift 中 pod 资源的 操作动词 访问权限来确定用户对 Fuse 控制台中 pod 的 MBean 操作的访问权限。默认情况下，Fuse 控制台有两个用户角色：

  • admin

    如果用户可以在 OpenShift 中更新 pod，则用户会延迟 Fuse 控制台的 admin 角色。用户可以在 Fuse 控制台中为 pod 执行写入 MBean 操作。

  • viewer

    如果用户可以在 OpenShift 中获取 pod，则用户会延迟 Fuse 控制台的 viewer 角色。用户可以在 Fuse 控制台中为 pod 执行 只读 MBean 操作。

注意

如果您没有使用 Fuse Console Operator 配置启用 RBAC，或者您没有使用 RBAC 模板安装 Fuse 控制台，只有 pod 资源上赋予 update 动词的 OpenShift 用户才会被授权执行 Fuse Console MBeans 操作。授予 pod 资源的 get 动词的 用户可以查看 pod，但不能执行任何 Fuse 控制台操作。

其他资源

2.4.3.1. 确定 OpenShift 4.x 上 Fuse 控制台的访问角色

Fuse Console 基于角色的访问控制是从 Pod 的 OpenShift 权限中推断出来的。要确定授予特定用户的 Fuse 控制台访问角色，获取赋予 Pod 用户的 OpenShift 权限。

先决条件

  • 您知道用户名。
  • 您知道 pod 的名称。

流程

  • 要确定用户是否有 pod 的 Fuse Console admin 角色，请运行以下命令来查看用户是否可以更新 OpenShift 上的 pod：

    Copy to Clipboard Toggle word wrap 
    oc auth can-i update pods/<pod> --as <user>

    如果响应是 yes，则用户具有 Pod 的 Fuse Console admin 角色。用户可以在 Fuse 控制台中为 pod 执行写入 MBean 操作。

  • 要确定用户是否有 pod 的 Fuse Console viewer 角色，请运行以下命令来查看用户是否可以在 OpenShift 上获取 pod：

    Copy to Clipboard Toggle word wrap 
    oc auth can-i get pods/<pod> --as <user>

    如果响应是 yes，用户具有 Pod 的 Fuse Console viewer 角色。用户可以在 Fuse 控制台中为 pod 执行 只读 MBean 操作。根据上下文，Fuse 控制台可防止具有 viewer 角色的用户 执行写入 MBean 操作，方法是禁用一个选项，或者在用户尝试写 MBean 操作时显示 "operation not allowed for this user" 消息。

    如果响应不是，则用户没有绑定到任何 Fuse 控制台角色，用户无法在 Fuse 控制台中查看 pod。

其他资源

2.4.3.2. 在 OpenShift 4.x 上自定义对 Fuse 控制台进行基于角色的访问

如果您使用 OperatorHub 安装 Fuse 控制台，并且启用了 基于角色的访问控制(RBAC)，Fuse Console Operator 会提供默认的 RBAC 行为，如 OpenShift 4.x 上 Fuse Console 的基于角色的访问控制 中所述。如果要自定义 Fuse 控制台 RBAC 行为，在部署 Fuse 控制台前，您必须提供一个 ConfigMap 文件（定义自定义 RBAC 行为）。您必须将自定义 ConfigMap 文件放在安装 Fuse Console Operator 的同一命名空间中。

如果使用命令行模板安装 Fuse 控制台，则 deployment-cluster-rbac.yml 和 deployment-namespace-rbac.yml 模板会创建一个包含配置文件(ACL.yml)的 ConfigMap。配置文件定义 MBean 操作允许的角色。

前提条件

  • 您使用 OperatorHub 或使用其中一个 Fuse 控制台 RBAC 模板(deployment-cluster-rbac.yml 或 deployment-namespace-rbac.yml)安装 Fuse 控制台。

流程

自定义 Fuse 控制台 RBAC 角色：

  1. 如果使用命令行安装 Fuse 控制台，则安装模板包含一个默认的 ConfigMap 文件，以便您可以跳至下一步。

    如果使用 OperatorHub 安装 Fuse 控制台，在部署 Fuse 控制台前，要创建一个 RBAC ConfigMap：

    1. 确保当前的 OpenShift 项目是您要安装 Fuse 控制台的项目。例如，如果要在 fusetest 项目中安装 Fuse 控制台，请运行以下命令：

      Copy to Clipboard Toggle word wrap 
      oc project fusetest

    2. 要从模板创建 Fuse Console RBAC ConfigMap 文件，请运行以下命令：

      Copy to Clipboard Toggle word wrap 
      oc process -f https://raw.githubusercontent.com/jboss-fuse/application-templates/2.1.x.sb2.redhat-7-8-x/fuse-console-operator-rbac.yml -p APP_NAME=fuse-console | oc create -f -

  2. 运行以下命令，在编辑器中打开 ConfigMap：

    Copy to Clipboard Toggle word wrap 
    oc edit cm $APP_NAME-rbac

    例如：

    Copy to Clipboard Toggle word wrap 
    oc edit cm fuse-console-rbac
  3. 编辑该文件。
  4. 保存文件以使改变生效。OpenShift 会自动重启 Fuse Console pod。

其他资源

2.4.3.3. 在 OpenShift 4.x 上为 Fuse 控制台禁用基于角色的访问控制

Fuse Console 的 HAWTIO_ONLINE_RBAC_ACL 环境变量传递基于角色的访问控制(RBAC) ConfigMap 配置文件路径到 OpenShift 服务器。如果没有指定 HAWTIO_ONLINE_RBAC_ACL 环境变量，则只有为 pod 资源(OpenShift)授予 update 动词的用户才会被授权在 Fuse 控制台中对 pod 调用 MBeans 操作。

请注意，当使用 Operator 在 OpenShift 上安装 Fuse 控制台时，默认禁用基于角色的访问。

前提条件

已安装 Fuse 控制台：

  • 通过使用 OperatorHub，并在 Fuse 控制台配置中启用 RBAC
  • 使用命令行，并且您指定了其中一个 Fuse 控制台 RBAC 模板(deployment-cluster-rbac.yml 或 deployment-namespace-rbac.yml)。

流程

为 Fuse 控制台禁用基于角色的访问控制：

  1. 在 OpenShift 中 ，编辑 Fuse 控制台的部署配置资源。

  2. 删除整个 HAWTIO_ONLINE_RBAC_ACL 环境变量定义。

    （请注意，仅清除其值还不够）。

  3. 保存文件以使改变生效。OpenShift 会自动重启 Fuse Console pod。

其他资源

2.4.4. 在 OpenShift 4.x 上升级 Fuse 控制台

Red Hat OpenShift 4.x 处理 operator 的更新，包括 Red Hat Fuse operator。如需更多信息，请参阅 Operators OpenShift 文档。

然后，Operator 更新可以根据应用程序的配置方式触发应用程序升级。

对于 Fuse 控制台应用程序，您还可以通过编辑应用程序自定义资源定义的 .spec.version 字段来触发到应用程序的升级。

前提条件

  • 有 OpenShift 集群 admin 权限。

流程

升级 Fuse 控制台应用程序：

  1. 在终端窗口中，使用以下命令更改应用程序自定义资源定义的 .spec.version 字段：

    Copy to Clipboard Toggle word wrap 
    oc patch <project-name> <custom-resource-name> --type='merge' -p '{"spec":{"version":"1.7.1"}}'

    例如：

    Copy to Clipboard Toggle word wrap 
    oc patch myproject example-fuseconsole --type='merge' -p '{"spec":{"version":"1.7.1"}}'

  2. 检查应用程序的状态是否已更新：

    Copy to Clipboard Toggle word wrap 
     oc get myproject

    响应显示有关应用程序的信息，包括版本号：

    Copy to Clipboard Toggle word wrap 
    NAME                  AGE   URL                                        IMAGE
example-fuseconsole   1m    https://fuseconsole.192.168.64.38.nip.io   docker.io/fuseconsole/online:1.7.1

    当您更改 .spec.version 字段的值时，OpenShift 会自动重新部署应用。

  3. 检查版本更改触发的重新部署状态：

    Copy to Clipboard Toggle word wrap 
    oc rollout status deployment.v1.apps/example-fuseconsole

    成功部署显示这个响应：

    Copy to Clipboard Toggle word wrap 
    deployment "example-fuseconsole" successfully rolled out

2.5. 配置 Prometheus 以监控 OpenShift 上的 Fuse 应用程序

2.5.1. 关于 Prometheus

Prometheus 是一个开源系统和服务监控工具包，可用于监控 Red Hat OpenShift 环境中部署的服务。Prometheus 以给定间隔收集并存储已配置的服务的指标，评估规则表达式，显示结果，并在指定条件变为 true 时触发警报。

重要

红帽对 Prometheus 的支持仅限于红帽产品文档中提供的设置和配置建议。

要监控 OpenShift 服务，您必须配置每个服务来公开端点 Prometheus 格式。此端点是一个 HTTP 接口，提供指标列表和指标的当前值。Prometheus 定期提取每个目标定义的端点，并将收集的数据写入其数据库。Prometheus 在延长时间内收集数据，而不仅仅是针对当前运行的会话。Prometheus 存储数据，以便您可以以图形方式视觉化并在数据上运行查询。

2.5.1.1. Prometheus 查询

在 Prometheus Web 界面中，您可以使用 Prometheus Query Language (PromQL) 编写查询来选择和聚合收集的数据。

例如，您可以使用以下查询来选择 Prometheus 在最后五分钟内记录的所有值，以了解 http_requests_total 作为指标名称的所有时间序列数据：

Copy to Clipboard Toggle word wrap 
http_requests_total[5m]

要进一步定义或过滤查询的结果，请为指标指定一个标签（一个 key:value 对）。例如，您可以使用以下查询为集成选择 Prometheus 在最后五分钟内记录的所有值，以了解指标名称 http_requests_total 的所有时间序列数据，以及将作业标签设置为 integration ：

Copy to Clipboard Toggle word wrap 
http_requests_total{job="integration"}[5m]
2.5.1.2. 显示 Prometheus 数据的选项

您可以指定 Prometheus 如何处理查询的结果：

  • 在 Prometheus 的表达式浏览器中将 Prometheus 数据视为表格数据。
  • 通过 Prometheus HTTP API，由外部系统消耗 Prometheus 数据。

  • 显示图中的 Prometheus 数据。

    Prometheus 提供它收集的数据的默认图形视图。如果您希望使用更强大的图形仪表板来查看 Prometheus 数据，Grafana 是一个流行的选择。

    注意

    Grafana 是社区支持的功能。红帽生产服务级别协议(SLA)不支持部署 Grafana 来监控红帽产品。

您还可以使用 PromQL 语言在 Prometheus 的 Alertmanager 工具中配置警报。

2.5.2. 设置 Prometheus

要设置 Prometheus，请在集群中安装 Prometheus operator 自定义资源定义，然后将 Prometheus 添加到包含 Fuse 应用程序的 OpenShift 项目中。

先决条件

  • 具有 集群管理员 对 OpenShift 集群的访问权限。
  • 您已通过在 OpenShift 镜像和模板上安装 Fuse 来准备 OpenShift 集群，如 OpenShift 上的 Fuse 指南 中所述。
  • 您已在集群中创建了 OpenShift 项目，并将 Fuse 应用添加到其中。

流程

  1. 使用管理员权限登录到 OpenShift：

    Copy to Clipboard Toggle word wrap 
    oc login -u system:admin

  2. 安装运行 Prometheus Operator 所需的自定义资源定义：

    Copy to Clipboard Toggle word wrap 
    oc create -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/openshift3/fuse-prometheus-crd.yml

    Prometheus Operator 现在对集群中的任何命名空间都可用。

  3. 使用以下命令语法将 Prometheus Operator 安装到命名空间中：

    Copy to Clipboard Toggle word wrap 
    oc process -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/openshift3/fuse-prometheus-operator.yml -p NAMESPACE=<YOUR NAMESPACE> | oc create -f -

    例如，对名为 myproject 的项目（命名空间）使用此命令：

    Copy to Clipboard Toggle word wrap 
    oc process -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/openshift3/fuse-prometheus-operator.yml -p NAMESPACE=myproject | oc create -f -
    注意

    第一次将 Prometheus Operator 安装到命名空间中时，Prometheus 资源 Pod 可能需要几分钟才能启动。因此，如果您将其安装到集群中的其他命名空间，Prometheus 资源 pod 会更快地启动。

  4. 使用以下命令语法指示 Prometheus 操作器监控项目中的 Fuse 应用程序：

    Copy to Clipboard Toggle word wrap 
    oc process -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/openshift3/fuse-servicemonitor.yml -p NAMESPACE=<YOUR NAMESPACE> -p FUSE_SERVICE_NAME=<YOUR FUSE SERVICE> | oc apply -f -

    例如，将此命令用于名为 myproject 的 OpenShift 项目（命名空间），其中包含名为 myfuseapp 的 Fuse 应用程序：

    Copy to Clipboard Toggle word wrap 
    oc process -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/openshift3/fuse-servicemonitor.yml -p NAMESPACE=myproject -p FUSE_SERVICE_NAME=myfuseapp | oc apply -f -

  5. 打开 Prometheus 仪表板：

    1. 登录到 OpenShift 控制台。
    2. 打开您添加 Prometheus 的项目。

    3. 在左侧窗格中，选择 Applications -> Routes。

      prometheus route

    4. 点 Prometheus Hostname URL 在新浏览器标签页或窗口中打开 Prometheus 仪表板。

      prometheus dashboard

    5. 有关 Prometheus 入门的详情，请访问： https://prometheus.io/docs/prometheus/latest/getting_started/

2.5.3. OpenShift 环境变量

要配置应用程序的 Prometheus 实例，您可以设置 表 2.2 “Prometheus 环境变量” 中列出的 OpenShift 环境变量。

表 2.2. Prometheus 环境变量
环境变量描述default

AB_PROMETHEUS_HOST

要绑定的主机地址。

0.0.0.0

AB_PROMETHEUS_OFF

如果设置，则禁用 Prometheus 的激活（回显空值）。

Prometheus 被启用。

AB_PROMETHEUS_PORT

要使用的端口。

9779

AB_JMX_EXPORTER_CONFIG

使用文件（包括路径）作为 Prometheus 配置文件。

带有 Camel 指标的 /opt/prometheus/prometheus-config.yml 文件。

AB_JMX_EXPORTER_OPTS

附加到 JMX 导出器配置的附加选项。

不适用。

其他资源

有关为 pod 设置环境变量的详情，请参考 OpenShift 开发人员指南(https://access.redhat.com/documentation/zh-cn/openshift_container_platform/3.11/html/developer_guide/)。

2.5.4. 控制 Prometheus 监控并收集的指标

默认情况下，Prometheus 使用一个配置文件( https://raw.githubusercontent.com/jboss-fuse/application-templates/master/prometheus/prometheus-config.yml)，其中包含 Camel 公开的所有可能指标。

如果您在应用程序中有自定义指标，您希望 Prometheus 监控并收集（例如，应用程序进程的顺序），您可以使用自己的配置文件。请注意，您可以识别的指标仅限于 JMX 中提供的指标。

流程

要使用自定义配置文件公开默认 Prometheus 配置未涵盖的 JMX Bean，请按照以下步骤操作：

  1. 创建自定义 Prometheus 配置文件。您可以使用默认文件的内容(prometheus-config.yml https://raw.githubusercontent.com/jboss-fuse/application-templates/master/prometheus/prometheus-config.yml)作为格式指南。

    您可以将任何名称用于自定义配置文件，例如： my-prometheus-config.yml。

  2. 将 prometheus 配置文件（如 my-prometheus-config.yml）添加到应用程序的 src/main/fabric8-includes 目录中。

  3. 在应用程序中创建 src/main/fabric8/deployment.xml 文件，并为 AB_JMX_EXPORTER_CONFIG 环境变量添加一个条目，并将其值设为您的配置文件。例如：

    Copy to Clipboard Toggle word wrap 
    spec:
  template:
    spec:
      containers:
        -
          resources:
            requests:
              cpu: "0.2"
            limits:
              cpu: "1.0"
          env:
          - name: SPRING_APPLICATION_JSON
            value: '{"server":{"tomcat":{"max-threads":1}}}'
          - name: AB_JMX_EXPORTER_CONFIG
            value: "my-prometheus-config.yml"

    此环境变量适用于 Pod 级别的应用。

  4. 重建并部署应用程序。

2.6. 在 OpenShift 上为 Fuse 使用 Metering

您可以使用 OCP 4 上可用的 Metering 工具从不同的数据源生成 metering 报告。作为集群管理员，您可使用 Metering 来分析集群中的情况。您可以自行编写报告，也可以使用预定义的 SQL 查询来定义如何处理来自现有不同数据源的数据。使用 Prometheus 作为默认数据源，您可以生成 pod、命名空间和大多数其他 Kubernetes 资源的报告。您必须首先使用 Metering 工具在 OpenShift Container Platform 4.x 上安装和配置 Metering Operator。有关 Metering 的更多信息，请参阅 Metering。

2.6.1. Metering 资源

Metering 具有很多资源，可用于管理 Metering 的部署与安装以及 Metering 提供的报告功能。Metering 使用以下自定义资源定义 (CRD) 来管理；

表 2.3. Metering 资源
名称描述

MeteringConfig

为部署配置 metering 堆栈。包含用于控制 metering 堆栈各个组件的自定义和配置选项。

Reports

控制要使用的查询、查询运行时间、运行频率以及查询结果的存储位置。

ReportQueries

包含用于对 ReportDataSources 中所含数据进行分析的 SQL 查询。

ReportDataSources

控制 ReportQueries 和 Reports 可用数据。支持配置 metering 中使用的不同数据库的访问权限。

2.6.2. OpenShift 上 Fuse 的 metering 标签

表 2.4. Metering 标签
标签可能的值

com.company

Red_Hat

rht.prod_name

Red_Hat_Integration

rht.prod_ver

7.8

rht.comp

fuse

rht.comp_ver

7.8

rht.subcomp

fuse7-java-openshift

fuse7-eap-openshift

fuse7-karaf-openshift

rht.subcomp_t

infrastructure

2.7. 使用自定义 Grafana 仪表板在 OpenShift 上监控 Fuse

OpenShift Container Platform 4.6 提供了监控仪表板，可帮助您了解集群组件和用户定义的工作负载的状态。

先决条件

OpenShift 上 Fuse 的自定义仪表板

您可以使用两个自定义仪表板，用于 OpenShift 上的 Fuse。要使用这些仪表板，您必须在集群中安装并配置了 Grafana 和 Prometheus。在 OpenShift 上为 Fuse 提供两种示例仪表板：您可以从 Fuse Grafana 仪表板导入这些仪表板。

  • Fuse Pod/实例指标仪表板：

    此仪表板从单个 Fuse 应用程序 pod / 实例收集指标。您可以使用 fuse-grafana-dashboard.yml 导入仪表板。OpenShift 上 Fuse Pod 指标仪表板的面板表包括：

    表 2.5. Fuse Pod 指标仪表板
    标题图例查询描述

    进程开始时间

    -

    process_start_time_seconds{pod="$pod"}*1000

    进程启动时的时间

    当前内存 HEAP

    -

    sum (jvm_memory_bytes_used{pod="$pod", area="heap"})*100/sum (jvm_memory_bytes_max{pod="$pod", area="heap"})

    Fuse 当前使用的内存

    内存用量

    已提交

    sum(jvm_memory_bytes_committed{pod="$pod"})

    内存已提交

     

    使用的

    sum(jvm_memory_bytes_used{pod="$pod"})

    使用的内存

     

    max

    sum(jvm_memory_bytes_max{pod="$pod"})

    最大内存

    线程

    current

    jvm_threads_current{pod="$pod"}

    当前线程数

     

    daemon

    jvm_threads_daemon{pod="$pod"}

    守护进程线程数量

     

    峰值

    jvm_threads_peak{pod="$pod"}

    峰值线程数

    Camel Exchanges / 1m

    Exchange Completeds Completed / 1m

    sum(increase(org_apache_camel_ExchangesCompleted{pod="$pod"}[1m]))

    每分钟完成的 Camel 交换

     

    Exchanges Failed / 1m

    sum(increase(org_apache_camel_ExchangesFailed{pod="$pod"}[1m]))

    每分钟失败的 Camel 交换

     

    Exchanges Total / 1m

    sum(increase(org_apache_camel_ExchangesTotal{pod="$pod"}[1m]))

    每分钟的 Camel 交换总数

     

    Exchanges Inflight

    sum(org_apache_camel_ExchangesInflight{pod="$pod"})

    Camel 交换当前正在处理

    Camel 处理时间

    增量处理时间

    sum(org_apache_camel_DeltaProcessingTime{pod="$pod"})

    Camel 处理时间的 delta

     

    最后处理时间

    sum(org_apache_camel_LastProcessingTime{pod="$pod"})

    最后的 Camel 处理时间

     

    最大处理时间

    sum(org_apache_camel_MaxProcessingTime{pod="$pod"})

    最大 Camel 处理时间

     

    Min Processing Time

    sum(org_apache_camel_MinProcessingTime{pod="$pod"})

    最低 Camel 处理时间

     

    平均处理时间

    sum(org_apache_camel_MeanProcessingTime{pod="$pod"})

    平均 Camel 处理时间

    Camel Service Durations

    最大持续时间

    sum(org_apache_camel_MaxDuration{pod="$pod"})

    最大 Camel 服务持续时间

     

    最小持续时间

    sum(org_apache_camel_MinDuration{pod="$pod"})

    最低 Camel 服务持续时间

     

    mean Duration

    sum(org_apache_camel_MeanDuration{pod="$pod"})

    平均 Camel 服务持续时间

    Camel 失败和 Redeliveries

    redeliveries

    sum(org_apache_camel_Redeliveries{pod="$pod"})

    redeliveries 的数量

     

    最后处理时间

    sum(org_apache_camel_LastProcessingTime{pod="$pod"})

    最后的 Camel 处理时间

     

    外部 Redeliveries

    sum(org_apache_camel_ExternalRedeliveries{pod="$pod"})

    外部 redeliveries 数量

  • Fuse Camel Route Metrics Dashboard:

    此仪表板从 Fuse 应用程序中的单个 Camel 路由收集指标。您可以使用 fuse-grafana-dashboard-routes.yml 导入仪表板。OpenShift 上 Fuse Camel Route 指标仪表板的面板表包括：

    表 2.6. Fuse Camel Route 指标仪表板
    标题图例查询描述

    每秒交换数

    -

    rate(org_apache_camel_ExchangesTotal{route="\"$route\""}[5m])

    每秒 Camel 交换总数

    Exchanges inflights

    -

    max(org_apache_camel_ExchangesInflight{route="\"$route\""})

    当前正在处理的 Camel 交换数

    交换失败率

    -

    sum (org_apache_camel_ExchangesFailed{route="\"$route\""})/ sum (org_apache_camel_ExchangesTotal{route="\"$route\""})

    Camel Exchanges 失败的百分比

    平均处理时间

    -

    org_apache_camel_MeanProcessingTime{route="\"$route\""}

    平均 Camel 处理时间

    每秒交换数

    Failed

    rate(org_apache_camel_ExchangesFailed{route="\"$route\""}[5m])

    每秒失败交换

     

    完成

    rate(org_apache_camel_ExchangesCompleted{route="\"$route\""}[5m])

    每秒完成的交换

    Exchanges inflights

    Exchanges inflights

    org_apache_camel_ExchangesInflight{route="\"$route\""}

    Camel 交换当前正在处理

    处理时间

    Max

    org_apache_camel_MaxProcessingTime{route="\"$route\""}

    最大 Camel 处理时间

     

    mean

    org_apache_camel_MeanProcessingTime{route="\"$route\""}

    平均 Camel 处理时间

     

    Min

    org_apache_camel_MinProcessingTime{route="\"$route\""}

    最低 Camel 处理时间

    每秒外部 Redeliveries

    -

    rate(org_apache_camel_ExternalRedeliveries{route="\"$route\""}[5m])

    每秒外部 redeliveries

    每秒 redeliveries

    -

    rate(org_apache_camel_Redeliveries{route="\"$route\""}[5m])

    每秒 redeliveries

    每秒处理失败

    -

    rate(org_apache_camel_FailuresHandled{route="\"$route\""}[5m])

    每秒处理失败

2.8. 在 OpenShift 3.x 服务器上安装 Fuse 镜像流和模板

配置红帽容器 registry 身份验证后，导入并使用 OpenShift 镜像流和模板上的 Red Hat Fuse。

流程

  1. 启动 OpenShift 服务器。

  2. 以管理员身份登录 OpenShift 服务器。

    Copy to Clipboard Toggle word wrap 
    oc login -u system:admin

  3. 验证您是否使用创建了 docker-registry secret 的项目。

    Copy to Clipboard Toggle word wrap 
    oc project openshift

  4. 在 OpenShift 镜像流上安装 Fuse。

    Copy to Clipboard Toggle word wrap 
    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005

oc create -n openshift -f ${BASEURL}/fis-image-streams.json

  5. 安装 Quickstart 模板：

    Copy to Clipboard Toggle word wrap 
    for template in eap-camel-amq-template.json \
 eap-camel-cdi-template.json \
 eap-camel-cxf-jaxrs-template.json \
 eap-camel-cxf-jaxws-template.json \
 karaf-camel-amq-template.json \
 karaf-camel-log-template.json \
 karaf-camel-rest-sql-template.json \
 karaf-cxf-rest-template.json ;
 do
 oc create -n openshift -f \
 https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/quickstarts/${template}
 done

  6. 安装 Spring Boot 2 quickstart 模板：

    Copy to Clipboard Toggle word wrap 
    for template in spring-boot-2-camel-amq-template.json \
 spring-boot-2-camel-config-template.json \
 spring-boot-2-camel-drools-template.json \
 spring-boot-2-camel-infinispan-template.json \
 spring-boot-2-camel-rest-3scale-template.json \
 spring-boot-2-camel-rest-sql-template.json \
 spring-boot-2-camel-template.json \
 spring-boot-2-camel-xa-template.json \
 spring-boot-2-camel-xml-template.json \
 spring-boot-2-cxf-jaxrs-template.json \
 spring-boot-2-cxf-jaxws-template.json \
 spring-boot-2-cxf-jaxrs-xml-template.json \
 spring-boot-2-cxf-jaxws-xml-template.json ;
 do oc create -n openshift -f \
 https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/quickstarts/${template}
 done

  7. 安装 Fuse 控制台的模板。

    Copy to Clipboard Toggle word wrap 
    oc create -n openshift -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/fis-console-cluster-template.json
oc create -n openshift -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/fis-console-namespace-template.json
    注意

    有关部署 Fuse 控制台的详情，请参考在 OpenShift 中设置 Fuse 控制台。

  8. 安装 Apicurito 模板：

    Copy to Clipboard Toggle word wrap 
    oc create -n openshift -f ${BASEURL}/fuse-apicurito.yml

  9. （可选） 查看 OpenShift 镜像和模板中安装的 Fuse：

    Copy to Clipboard Toggle word wrap 
    oc get template -n openshift

2.8.1. 在 OpenShift 3.11 中设置 Fuse 控制台

在 OpenShift 3.11 中，您可以使用两种方式设置 Fuse 控制台：

  • 通过将 集中式 Fuse Console 目录项添加到项目中，以便您可以监控项目中的所有运行 Fuse 容器。
  • 从特定的 pod 中，以便您可以监控单个正在运行的 Fuse 容器。

您可以从 OpenShift 控制台或命令行部署 Fuse 控制台。

注意

要在基于 Minishift 或 CDK 的基础上安装 Fuse 控制台，请遵循以下 KCS 文章中所述的步骤。

  • 要在基于 Minishift 或 CDK 上安装 Fuse 控制台，请参阅 KCS 4998441。
  • 如果需要禁用 Jolokia 身份验证，请参阅 KCS 3988671 中描述的临时解决方案。

先决条件

  • 在 OpenShift 镜像流上安装 Fuse，以及 Fuse 控制台的模板，如 OpenShift 上的 Fuse 指南 中所述。

  • 对于 OpenShift 3.11 上的集群模式，您需要集群管理员角色和集群模式模板。运行以下命令:

    Copy to Clipboard Toggle word wrap 
    oc adm policy add-cluster-role-to-user cluster-admin system:serviceaccount:openshift-infra:template-instance-controller
注意
  • 默认情况下，集群模式模板仅在最新版本的 OpenShift Container Platform 上可用。它不是由 OpenShift Online 默认目录提供的。
  • Fuse 控制台模板默认配置端到端加密，以便 Fuse 控制台请求是安全的端到端，从浏览器到集群内服务。
  • Fuse 控制台的用户管理由 OpenShift 处理。
  • 基于角色的访问控制（用于部署 Fuse 控制台的用户）尚不可用于 OpenShift 上的 Fuse。

第 2.8.1.1 节 “从 OpenShift 3.11 控制台部署 Fuse 控制台”

第 2.8.1.2 节 “从 OpenShift 3.11 上的 Fuse 控制台监控单个 Fuse pod”

第 2.8.1.3 节 “从命令行部署 Fuse 控制台”

2.8.1.1. 从 OpenShift 3.11 控制台部署 Fuse 控制台

要从 OpenShift 3.11 控制台在 OpenShift 集群上部署 Fuse 控制台，请按照以下步骤操作。

流程

  1. 在 OpenShift 控制台中，打开现有项目或创建新项目。

  2. 将 Fuse 控制台添加到 OpenShift 项目中：

    1. 选择 Add to Project → Browse Catalog。

      此时会打开 Select an item to to the current project 页。

    2. 在 Search 字段中，键入 Fuse Console。

      Red Hat Fuse 7.x Console 和 Red Hat Fuse 7.x Console （集群） 项应该显示为搜索结果。

注意

如果 Red Hat Fuse Console 项没有作为搜索结果显示，或者显示的项目不是最新版本，您可以手动安装 Fuse Console 模板，如 OpenShift Guide 中的 Fuse "Prepare the OpenShift server" 部分所述。

  1. 点 Red Hat Fuse Console 项之一：

    • Red Hat Fuse 7.x Console - 此版本的 Fuse 控制台发现并连接到当前 OpenShift 项目中部署的 Fuse 应用程序。
    • Red Hat Fuse 7.x Console （集群） - 此版本的 Fuse 控制台可以发现并连接到 OpenShift 集群上多个项目中部署的 Fuse 应用程序。

  2. 在 Red Hat Fuse Console 向导中，单击 Next。此时会打开向导的 Configuration 页面。

    另外，您可以更改配置参数的默认值。

    1. 点 Create。

      向导的 Results 页面表示已创建了 Red Hat Fuse 控制台。

    2. 单击 Continue to the project overview 链接，以验证 Fuse Console 应用是否已添加到项目中。

    3. 要打开 Fuse Console，请单击提供的 URL 链接，然后登录。

      在列出所需权限的浏览器中打开 Authorize Access 页面。

    4. 点击 Allow selected permissions。

      Fuse Console 在浏览器中打开，并显示项目中运行的 Fuse pod。

    5. 点您要查看的应用程序的 Connect。

      这时将打开一个新的浏览器窗口，显示 Fuse 控制台中的应用程序。

2.8.1.2. 从 OpenShift 3.11 上的 Fuse 控制台监控单个 Fuse pod

您可以为在 OpenShift 3.11 上运行的 Fuse pod 打开 Fuse 控制台：

  1. 在 OpenShift 项目中的 Applications → Pods 视图中，点 pod 名称查看正在运行的 Fuse pod 的详情。在这个页面的右侧，您会看到容器模板的概述信息：

    Container Template View

  2. 从此视图中，单击 Open Java Console 链接以打开 Fuse 控制台。

    Fuse Console view

    注意

    要将 OpenShift 配置为在 pod 视图中显示到 Fuse Console 的链接，在 OpenShift 镜像上运行 Fuse 的 pod 必须声明设置为 jolokia 的 name 属性中的 TCP 端口：

    Copy to Clipboard Toggle word wrap 
    {
  "kind": "Pod",
  [...]
  "spec": {
    "containers": [
      {
        [...]
        "ports": [
          {
            "name": "jolokia",
            "containerPort": 8778,
            "protocol": "TCP"
          }
2.8.1.3. 从命令行部署 Fuse 控制台

表 2.7 “Fuse 控制台模板” 描述可用于从命令行部署 Fuse 控制台的 OpenShift 3.1 模板，具体取决于 Fuse 应用部署的类型。

表 2.7. Fuse 控制台模板
类型描述

fis-console-cluster-template.json

Fuse 控制台可以发现并连接到在多个命名空间或项目中部署的 Fuse 应用程序。若要部署此模板，您必须具有 OpenShift cluster-admin 角色。

fis-console-namespace-template.json

此模板限制 Fuse 控制台对当前 OpenShift 项目（命名空间）的访问，因此充当单个租户部署。若要部署此模板，您必须具有当前 OpenShift 项目的 admin 角色。

另外，您可以通过运行这个命令来查看所有模板的参数列表：

Copy to Clipboard Toggle word wrap 
oc process --parameters -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/fis-console-namespace-template.json

流程

从命令行部署 Fuse 控制台：

  1. 运行以下命令之一（其中 myproject 是项目的名称），基于 Fuse 控制台模板创建新应用：

    • 对于 Fuse Console 集群模板，其中 myhost 是访问 Fuse 控制台的主机名：

      Copy to Clipboard Toggle word wrap 
      oc new-app -n myproject -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/fis-console-cluster-template.json -p ROUTE_HOSTNAME=myhost

    • 对于 Fuse Console 命名空间 模板：

      Copy to Clipboard Toggle word wrap 
      oc new-app -n myproject -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/fis-console-namespace-template.json
      注意

      您可以省略 命名空间 模板的 route_hostname 参数，因为 OpenShift 会自动生成一个。

  2. 运行以下命令，获取 Fuse Console 部署的状态和 URL：

    Copy to Clipboard Toggle word wrap 
    oc status
  3. 要从浏览器访问 Fuse 控制台，请使用提供的 URL （例如 https://fuse-console.192.168.64.12.nip.io）。

第 3 章 在受限环境中的 Openshift 上安装 Fuse

要在 OpenShift 镜像流和模板上安装 Fuse，我们使用 registry.redhat.io 从 Red Hat Container registry 中拉取镜像。在没有或有限的互联网访问的生产环境中，无法使用 Red Hat Container Registry。本节介绍如何在受限环境中在 OpenShift 上安装 Fuse。

先决条件

  • 您已安装并配置了 OpenShift 服务器，使其可以在受限环境中运行。

3.1. 设置内部 Docker registry

本节介绍如何设置可用于推送或拉取镜像的内部 docker registry。您必须配置内部 docker registry，您可以在其中拉取或推送镜像。

流程

  1. 安装内部 ROOT CA。

    Copy to Clipboard Toggle word wrap 
    cd /etc/pki/ca-trust/source/anchors
sudo curl -O https://password.corp.redhat.com/RH-IT-Root-CA.crt
sudo update-ca-trust extract
sudo update-ca-trust update

    此证书允许系统向 registry 验证其自身。

  2. 登录到 Red Hat Container Registry。

    Copy to Clipboard Toggle word wrap 
    docker login -u USERNAME -p PASSWORD registry.redhat.io

  3. 从 registry.redhat.io 拉取 OpenShift 镜像上的 Fuse。

    Copy to Clipboard Toggle word wrap 
    docker pull registry.redhat.io/fuse7/fuse-java-openshift:1.8
docker pull registry.redhat.io/fuse7/fuse-karaf-openshift:1.8
docker pull registry.redhat.io/fuse7/fuse7-fuse-console:1.8
docker pull registry.redhat.io/fuse7/fuse7-fuse-apicurito:1.8
docker pull registry.redhat.io/fuse7/fuse7-fuse-apicurito-generator:1.8

  4. 标记拉取的镜像流。

    Copy to Clipboard Toggle word wrap 
    docker tag registry.redhat.io/fuse7/fuse-java-openshift:1.8 docker-registry.upshift.redhat.com/fuse7/fuse-java-openshift:1.8
docker tag registry.redhat.io/fuse7/fuse-karaf-openshift:1.8 docker-registry.upshift.redhat.com/fuse-karaf-openshift:1.8
docker tag registry.redhat.io/fuse7/fuse7-fuse-console:1.8 docker-registry.upshift.redhat.com/fuse7-fuse-console:1.8
docker tag registry.redhat.io/fuse7/fuse7-fuse-apicurito:1.8 docker-registry.upshift.redhat.com/fuse7-fuse-apicurito:1.8
docker tag registry.redhat.io/fuse7/fuse7-fuse-apicurito-generator:1.8 docker-registry.upshift.redhat.com/fuse7-fuse-apicurito-generator:1.8

  5. 将标记的镜像流推送到内部 Docker registry。

    Copy to Clipboard Toggle word wrap 
    docker push docker-registry.upshift.redhat.com/fuse7/fuse-java-openshift:1.8
docker push docker-registry.upshift.redhat.com/fuse-karaf-openshift:1.8
docker push docker-registry.upshift.redhat.com/fuse7-fuse-console:1.8
docker push docker-registry.upshift.redhat.com/fuse7-fuse-apicurito:1.8
docker push docker-registry.upshift.redhat.com/fuse7-fuse-apicurito-generator:1.8

3.2. 配置内部 registry secret

在设置受限 docker registry 并推送所有镜像后，需要配置受限的 OpenShift 服务器，以便它能够与内部注册表通信。

流程

  1. 以管理员身份登录 OpenShift 服务器。

    Copy to Clipboard Toggle word wrap 
    oc login -u system:admin

  2. 使用您的红帽客户门户网站帐户或 Red Hat Developer Program 帐户凭证创建 docker-registry secret。将 <pull_secret_name > 替换为您要创建的 secret 的名称。

    Copy to Clipboard Toggle word wrap 
    oc create secret docker-registry psi-internal-registry <pull_secret_name> \
--docker-server=docker-registry.upshift.redhat.com \
--docker-username=CUSTOMER_PORTAL_USERNAME \
--docker-password=CUSTOMER_PORTAL_PASSWORD \
--docker-email=EMAIL_ADDRESS

  3. 要使用 secret 为 pod 拉取镜像，请将 secret 添加到您的服务帐户。服务帐户的名称必须与服务帐户 pod 使用的名称匹配。

    Copy to Clipboard Toggle word wrap 
    oc secrets add serviceaccount/builder secrets/psi-internal-registry
oc secrets add serviceaccount/default secrets/psi-internal-registry --for=pull
oc secrets add serviceaccount/builder secrets/psi-internal-registry

  4. 要使用 secret 来推送和拉取构建镜像，该 secret 必须可在 pod 中挂载。要挂载该机密，请使用以下命令：

    Copy to Clipboard Toggle word wrap 
    oc secrets link default psi-internal-registry
oc secrets link default psi-internal-registry --for=pull
oc secrets link builder psi-internal-registry

3.3. 在受限环境中的 OpenShift 镜像上安装 Fuse

fis-image-streams.json 文件包含 OpenShift 上 Red Hat Fuse 的 imageStream 定义。但是，所有镜像流都引用 registry.redhat.io。您必须更改对 psi-internal-registry URL 的所有 registry.redhat.io 引用。

流程

  1. 从 OpenShift 镜像流 json 文件下载 Red Hat Fuse。

    Copy to Clipboard Toggle word wrap 
    curl -o fis-image-streams.json {BASEURL}

  2. 打开 fis-image-streams.json 文件，并找到对 registry.redhat.io 的所有引用。例如，

    Copy to Clipboard Toggle word wrap 
    {
"name": "1.8",
"annotations": {
"description": "Red Hat Fuse 7.8 Karaf S2I images.",
"openshift.io/display-name": "Red Hat Fuse 7.8 Karaf",
"iconClass": "icon-rh-integration",
"tags": "builder,jboss-fuse,java,karaf,xpaas,hidden",
"supports":"jboss-fuse:7.8.0,java:8,xpaas:1.2",
"version": "1.8"
},
"referencePolicy": {
"type": "Local"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/fuse7/fuse-karaf-openshift:1.8"
}
},

  3. 将文件中的所有 registry.redhat.io 引用替换为 psi-internal-registry 名称。例如，

    Copy to Clipboard Toggle word wrap 
    {
"name": "1.8",
"annotations": {
"description": "Red Hat Fuse 7.8 Karaf S2I images.",
"openshift.io/display-name": "Red Hat Fuse 7.8 Karaf",
"iconClass": "icon-rh-integration",
"tags": "builder,jboss-fuse,java,karaf,xpaas,hidden",
"supports":"jboss-fuse:7.8.0,java:8,xpaas:1.2",
"version": "1.8"
},
"referencePolicy": {
"type": "Local"
},
"from": {
"kind": "DockerImage",
"name": "docker-registry.upshift.redhat.com/fuse7/fuse-karaf-openshift:1.8"
}
},

  4. 替换所有引用后，运行以下命令在 OpenShift 镜像流上安装 Fuse：

    Copy to Clipboard Toggle word wrap 
    oc create -f fis-image-streams.json -n {namespace}

3.4. 使用内部 Maven 存储库

在受限环境中，您需要使用不同的 Maven 存储库。您可以使用名为 MAVEN_MIRROR_URL 的 template 参数指定。您可以使用此 MAVEN_MIRROR_URL 参数从命令行创建新应用程序。

3.4.1. 使用 MAVEN_MIRROR_URL 运行 Spring Boot 应用程序

本例解释了如何使用 MAVEN_MIRROR_URL 部署并运行 Spring Boot 应用程序。

流程

  1. 下载 Spring Boot Camel XML 快速启动。

    Copy to Clipboard Toggle word wrap 
    oc create -f {BASEURL}/quickstarts/spring-boot-2-camel-xml-template.json

  2. 输入以下命令使用 MAVEN_MIRROR_URL 参数创建运行 Spring Boot quickstart 模板所需的资源。这将为快速启动创建部署配置和构建配置。有关 Quickstart 的默认参数的信息，并在终端中显示创建的资源。

    Copy to Clipboard Toggle word wrap 
    oc new-app s2i-fuse78-spring-boot-2-camel-xml -n {namespace} -p IMAGE_STREAM_NAMESPACE={namespace} -p MAVEN_MIRROR_URL={Maven mirror URL}

3.4.2. 使用 Fabric8 Maven 插件运行 Spring Boot 应用程序

本例解释了如何使用内部 Maven 存储库使用 Fabric8 Maven 插件部署和运行 Spring Boot 应用。

流程

  1. 要使用 Fabric8 Maven 插件运行快速入门，请从本地存储库下载 Spring Boot 2 camel archetype，然后部署快速启动。将 {Maven Mirror URL} 替换为 Maven 镜像存储库 URL。

    Copy to Clipboard Toggle word wrap 
    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
  -DarchetypeCatalog={Maven Mirror URL}/archetypes/archetypes-catalog/2.2.0.fuse-sb2-780040-redhat-00002/archetypes-catalog-2.2.0.fuse-sb2-780040-redhat-00002-archetype-catalog.xml \
  -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
  -DarchetypeArtifactId=spring-boot-camel-xml-archetype
  -DarchetypeVersion=2.2.0.fuse-sb2-780040-redhat-00002

  2. archetype 插件切换到交互模式，以提示您输入剩余的字段。

    Copy to Clipboard Toggle word wrap 
    Define value for property 'groupId': : org.example.fis
Define value for property 'artifactId': : fuse78-spring-boot2
Define value for property 'version':  1.0-SNAPSHOT: :
Define value for property 'package':  org.example.fis: :
Confirm properties configuration:
groupId: org.example.fis
artifactId: fuse78-spring-boot
version: 1.0-SNAPSHOT
package: org.example.fis
 Y: : Y
  3. 如果上述命令以 BUILD SUCCESS 状态退出，则现在应在 fuse78-spring-boot2 子目录下具有 OpenShift 项目的 Fuse。

  4. 您现在已准备好构建和部署 fuse78-spring-boot2 项目。假设您仍然登录 OpenShift，请更改到 fuse78-spring-boot2 项目的目录，然后进行构建和部署项目，如下所示：

    Copy to Clipboard Toggle word wrap 
    cd fuse78-spring-boot2
mvn fabric8:deploy -Popenshift

第 4 章 以非管理员用户身份在 OpenShift 上安装 Fuse

您可以通过创建应用程序并将其部署到 OpenShift，在 OpenShift 上使用 Fuse。首先，您需要在 OpenShift 镜像和模板上安装 Fuse。

4.1. 以非管理员用户身份在 OpenShift 镜像和模板上安装 Fuse

先决条件

  • 您可以访问 OpenShift 服务器。它可以是 CDK 或远程 OpenShift 服务器的虚拟 OpenShift 服务器。
  • 您已为 Red Hat Container Registry 配置身份验证。

如需更多信息，请参阅：

流程

  1. 在准备在 OpenShift 项目中构建和部署 Fuse 时，请按如下所示登录 OpenShift 服务器：

    Copy to Clipboard Toggle word wrap 
    oc login -u developer -p developer https://OPENSHIFT_IP_ADDR:8443

    其中，OPENSHIFT_IP_ADDR 是 OpenShift 服务器的 IP 地址的占位符，因为此 IP 地址并不总是相同。

    注意

    developer 用户（具有开发人员密码）是 CDK 在虚拟 OpenShift 服务器上自动创建的标准帐户。如果您要访问远程服务器，请使用 OpenShift 管理员提供的 URL 和凭证。

  2. 创建名为 test 的新项目命名空间（假设它尚不存在）。

    Copy to Clipboard Toggle word wrap 
    oc new-project test

    如果 test 项目命名空间已存在，请切换到该命名空间。

    Copy to Clipboard Toggle word wrap 
    oc project test

  3. 在 OpenShift 镜像流上安装 Fuse：

    Copy to Clipboard Toggle word wrap 
    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005

oc create -n test -f ${BASEURL}/fis-image-streams.json

    命令输出显示 Fuse 在 OpenShift 项目的 Fuse 中。

  4. 安装 Quickstart 模板。

    Copy to Clipboard Toggle word wrap 
    for template in eap-camel-amq-template.json \
 eap-camel-cdi-template.json \
 eap-camel-cxf-jaxrs-template.json \
 eap-camel-cxf-jaxws-template.json \
 karaf-camel-amq-template.json \
 karaf-camel-log-template.json \
 karaf-camel-rest-sql-template.json \
 karaf-cxf-rest-template.json ;
 do
 oc create -n test -f \
 ${BASEURL}/quickstarts/${template}
 done

  5. 安装 Spring Boot 2 quickstart 模板：

    Copy to Clipboard Toggle word wrap 
    for template in spring-boot-2-camel-amq-template.json \
 spring-boot-2-camel-config-template.json \
 spring-boot-2-camel-drools-template.json \
 spring-boot-2-camel-infinispan-template.json \
 spring-boot-2-camel-rest-3scale-template.json \
 spring-boot-2-camel-rest-sql-template.json \
 spring-boot-2-camel-template.json \
 spring-boot-2-camel-xa-template.json \
 spring-boot-2-camel-xml-template.json \
 spring-boot-2-cxf-jaxrs-template.json \
 spring-boot-2-cxf-jaxws-template.json \
 spring-boot-2-cxf-jaxrs-xml-template.json \
 spring-boot-2-cxf-jaxws-xml-template.json ;
 do oc create -n openshift -f \
 https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005/quickstarts/${template}
 done

  6. 安装 Fuse 控制台的模板。

    Copy to Clipboard Toggle word wrap 
    oc create -n test -f ${BASEURL}/fis-console-cluster-template.json
oc create -n test -f ${BASEURL}/fis-console-namespace-template.json
    注意

    有关部署 Fuse 控制台的详情，请参考在 OpenShift 中设置 Fuse 控制台。

  7. （可选）查看 OpenShift 镜像和模板上安装的 Fuse。

    Copy to Clipboard Toggle word wrap 
    oc get template -n test

  8. 在您的浏览器中，进入 OpenShift 控制台：

    1. 使用 https://OPENSHIFT_IP_ADDR:8443，并将 OPENSHIFT_IP_ADDR 替换为您的 OpenShift 服务器的 IP 地址。
    2. 使用您的凭据登录 OpenShift 控制台（例如，使用用户名 developer 和密码 developer）。

第 5 章 开发人员入门

5.1. 准备开发环境

在 OpenShift 项目中开发和测试 Fuse 的基本要求是能够访问 OpenShift 服务器。您有以下基本替代方案：

5.1.1. 在本地机器上安装容器开发套件(CDK)

作为开发人员，如果您要快速启动，最实际的替代方法是在本地计算机上安装 Red Hat CDK。使用 CDK，您可以引导在 Red Hat Enterprise Linux (RHEL) 7 上运行 OpenShift 镜像的虚拟机(VM)实例。CDK 的安装由以下关键组件组成：

  • 虚拟机(libvirt、VirtualBox 或 Hyper-V)
  • Minishift 启动和管理容器开发环境
重要

Red Hat CDK 仅用于开发目的。它并不适用于其他目的，如生产环境，且可能无法解决已知的安全漏洞。为了获得对在使用 docker 格式的容器中运行的业务关键型应用程序的完全支持，您需要一个有效的 RHEL 7 或 RHEL Atomic 支持。如需了解更多详细信息，请参阅对 Red Hat Container Development Kit (CDK)的支持。

先决条件

  • Java 版本

    在开发人员机器上，确保您已安装了 Fuse 7.8 支持的 Java 版本。有关支持的 Java 版本的详情，请参阅 支持的配置。

流程

在本地机器上安装 CDK：

  1. 对于 OpenShift 上的 Fuse，我们建议您安装 CDK 版本 3.14。Red Hat CDK 3.14 入门指南 中提供了有关安装和使用 CDK 3.14 的详细信息。
  2. 按照 配置 Red Hat Container Registry 身份验证 中的说明，配置 OpenShift 凭证以访问红帽容器 registry。

  3. 如 第 2 章 管理员入门 所述，在 OpenShift 镜像和模板上安装 Fuse。

    注意

    您的 CDK 版本可能预装了 Fuse on OpenShift 镜像和模板。但是，在配置 OpenShift 凭证后，您必须在 OpenShift 镜像和模板上安装（或更新） Fuse。

  4. 在执行本章中的示例之前，您应该阅读并彻底了解 Red Hat CDK 3.14 入门指南 的内容。

5.1.2. 获取对现有 OpenShift 服务器的远程访问

您的 IT 部门可能已在某些服务器计算机上设置 OpenShift 集群。在这种情况下，在 OpenShift 中使用 Fuse 时必须满足以下要求：

  • 服务器机器必须运行受支持的 OpenShift Container Platform 版本（如 支持的配置页面 中所述）。本指南中的示例针对版本 3.11 测试。
  • 要求 OpenShift 管理员在 OpenShift 容器镜像上安装最新的 Fuse，并在 OpenShift 服务器上的 OpenShift 模板上安装 Fuse。
  • 要求 OpenShift 管理员为您创建用户帐户，具有常见的开发人员权限（使您能够创建、部署和运行 OpenShift 项目）。
  • 要求管理员获取 OpenShift 服务器的 URL （您可以使用它浏览到 OpenShift 控制台或使用 oc 命令行客户端连接到 OpenShift）以及您的帐户的登录凭据。

5.1.3. 安装客户端工具

我们建议您在开发人员机器上安装以下工具：

  • Apache Maven 3.6.x：OpenShift 项目本地构建需要。从 Apache Maven 下载页面下载 相应的软件包。确保至少安装了 3.6.x 版本（或更新版本），否则 Maven 在构建项目时可能会遇到解决依赖项的问题。
  • Git：OpenShift S2I 源工作流需要，通常推荐在 OpenShift 项目上的 Fuse 控制。从 Git Downloads 页面下载相应的软件包。

  • OpenShift 客户端：如果您使用 CDK，您可以使用 minishift oc -env 将 oc 二进制文件添加到 PATH 中，其中显示您需要键入的命令( oc-env 的输出会因 OS 和 shell 类型而异)：

    Copy to Clipboard Toggle word wrap 
    $ minishift oc-env
export PATH="/Users/john/.minishift/cache/oc/v1.5.0:$PATH"
# Run this command to configure your shell:
# eval $(minishift oc-env)

    如需了解更多详细信息，请参阅 CDK 3.14 入门指南中的使用 OpenShift 客户端 Binary。

    如果您不使用 CDK，请按照 CLI 参考中的 说明安装 oc 客户端工具。

  • （可选） Docker 客户端：高级用户可以方便地安装 Docker 客户端工具（与 OpenShift 服务器上运行的 docker 守护进程通信）。有关您的操作系统特定二进制安装的详情，请查看 Docker 安装 站点。

    如需了解更多详细信息，请参阅 CDK 3.14 Getting Started Guide 中的 Reusing the docker Daemon。

    重要

    确保安装 oc 工具版本和与 OpenShift 服务器上运行的 OpenShift 版本兼容的 docker 工具。

其它资源

（可选） 红帽 JBoss CodeReady Studio： 红帽 JBoss CodeReady Studio 是基于 Eclipse 的开发环境，包括对在 OpenShift 应用中开发 Fuse 的支持。有关如何安装此开发环境的详情，请参阅安装 Red Hat JBoss CodeReady Studio。

5.1.4. 配置 Maven 软件仓库

配置 Maven 存储库，其中包含您要在本地机器的 OpenShift 项目中构建 Fuse 的 archetypes 和工件。

流程

  1. 打开 Maven settings.xml 文件，该文件通常位于 ~/.m2/settings.xml （在 Linux 或 macOS 中）或 Documents and Settings\<USER_NAME>\.m2\settings.xml (on Windows)。

  2. 添加以下 Maven 存储库。

5.2. 在 OpenShift 的 Fuse 中创建和部署应用程序

您可以通过创建应用程序并将其部署到 OpenShift 来开始使用 Fuse，方法是使用以下 OpenShift Source-to-Image (S2I)应用程序开发工作流之一：

S2I 二进制工作流
带有来自 二进制源 的构建输入的 S2I。此工作流的特征是，构建部分在开发人员自己的计算机上执行。本地构建二进制软件包后，此工作流将二进制软件包传递给 OpenShift。如需了解更多详细信息，请参阅 构建 OpenShift Container Platform 指南中的 Binary Source。
S2I 源工作流
带有来自 Git 源 的构建输入的 S2I。此工作流的特征是，构建完全在 OpenShift 服务器上执行。如需了解更多详细信息，请参阅 构建 OpenShift Container Platform 指南中的 Git 源。

5.2.1. 使用 S2I 二进制工作流创建和部署应用程序

在本小节中，您将使用 OpenShift S2I 二进制工作流在 OpenShift 项目中创建、构建和部署 Fuse。

流程

  1. 使用 Maven archetype 在 OpenShift 项目中创建一个新的 Fuse。在本例中，我们使用 archetype 来创建 Spring Boot Camel 项目示例。打开一个新的 shell 提示符，并输入以下 Maven 命令：

    Copy to Clipboard Toggle word wrap 
    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
  -DarchetypeCatalog=https://maven.repository.redhat.com/ga/io/fabric8/archetypes/archetypes-catalog/2.2.0.fuse-sb2-780040-redhat-00002/archetypes-catalog-2.2.0.fuse-sb2-780040-redhat-00002-archetype-catalog.xml \
  -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
  -DarchetypeArtifactId=spring-boot-camel-xml-archetype \
  -DarchetypeVersion=2.2.0.fuse-sb2-780040-redhat-00002

    archetype 插件切换到交互模式，以提示您输入剩余的字段。

    Copy to Clipboard Toggle word wrap 
    Define value for property 'groupId': : org.example.fis
Define value for property 'artifactId': : fuse78-spring-boot
Define value for property 'version':  1.0-SNAPSHOT: :
Define value for property 'package':  org.example.fis: :
Confirm properties configuration:
groupId: org.example.fis
artifactId: fuse78-spring-boot
version: 1.0-SNAPSHOT
package: org.example.fis
 Y: : Y

    出现提示时，为 groupId 值输入 org.example.fis，为 artifactId 值输入 fuse78-spring-boot。接受剩余的字段的默认值。

  2. 如果上一命令以 BUILD SUCCESS 状态退出，则现在应在 fuse78-spring-boot 子目录下具有 OpenShift 项目的 Fuse。您可以检查 fuse78-spring-boot/src/main/resources/spring/camel-context.xml 文件中的 XML DSL 代码。演示代码定义了一个简单的 Camel 路由，可持续向日志发送包含随机数的消息。

  3. 在准备在 OpenShift 项目中构建和部署 Fuse 时，请按如下所示登录 OpenShift 服务器：

    Copy to Clipboard Toggle word wrap 
    oc login -u developer -p developer https://OPENSHIFT_IP_ADDR:8443

    其中，OPENSHIFT_IP_ADDR 是 OpenShift 服务器的 IP 地址的占位符，因为此 IP 地址并不总是相同。

    注意

    developer 用户（具有 开发人员 密码）是 CDK 在虚拟 OpenShift 服务器上自动创建的标准帐户。如果您要访问远程服务器，请使用 OpenShift 管理员提供的 URL 和凭证。

  4. 按照如下所示，切换到 openshift 项目（如果还没有在 openshift 项目中）。

    Copy to Clipboard Toggle word wrap 
    oc project openshift

  5. 运行以下命令，以确保 OpenShift 镜像和模板上的 Fuse 已安装，您可以访问它们。

    Copy to Clipboard Toggle word wrap 
    oc get template -n openshift

    如果没有预安装镜像和模板，或者提供的版本已过时，请在 OpenShift 镜像和模板上手动安装（或更新） Fuse。有关如何在 OpenShift 镜像上安装 Fuse 的更多信息，请参阅 第 2 章 管理员入门。

  6. 您现在已准备好构建和部署 fuse78-spring-boot 项目。假设您仍然登录 OpenShift，请更改到 fuse78-spring-boot 项目的目录，然后进行构建和部署项目，如下所示：

    Copy to Clipboard Toggle word wrap 
    cd fuse78-spring-boot
mvn fabric8:deploy -Popenshift

    在成功构建结束时，您应看到如下一些输出：

    Copy to Clipboard Toggle word wrap 
    ...
[INFO] OpenShift platform detected
[INFO] Using project: openshift
[INFO] Creating a Service from openshift.yml namespace openshift name fuse78-spring-boot
[INFO] Created Service: target/fabric8/applyJson/openshift/service-fuse78-spring-boot.json
[INFO] Using project: openshift
[INFO] Creating a DeploymentConfig from openshift.yml namespace openshift name fuse78-spring-boot
[INFO] Created DeploymentConfig: target/fabric8/applyJson/openshift/deploymentconfig-fuse78-spring-boot.json
[INFO] Creating Route openshift:fuse78-spring-boot host: null
[INFO] F8: HINT: Use the command `oc get pods -w` to watch your pods start up
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 05:38 min
[INFO] Finished at: 2020-12-04T12:15:06+05:30
[INFO] Final Memory: 63M/688M
[INFO] ------------------------------------------------------------------------
    注意

    第一次运行此命令时，Maven 必须下载大量依赖项，这需要几分钟时间。后续构建将更快。

  7. 在浏览器中打开 OpenShift 控制台，并使用您的凭据登录控制台（例如，使用用户名 developer 和密码 developer）。
  8. 在左侧面板中，展开 Home，然后单击 Status 以查看 openshift 项目的 Project Status 页面。

  9. 单击 fuse78-spring-boot，以查看 fuse78-spring-boot 应用程序的 Overview 信息页面。

    Overview

  10. 在左侧面板中，展开 Workloads。
  11. 单击 Pods。此时会显示 openshift 项目中运行的所有 Pod。

  12. 点 pod Name （本例中为 fuse78-spring-boot-xxxxx）以查看正在运行的 pod 的详情。

    Pod Details

  13. 单击 Logs 选项卡，以查看应用程序日志，再向下滚动以查找 Camel 应用程序生成的随机日志消息。

    Copy to Clipboard Toggle word wrap 
    ...
06:45:54.311 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 130
06:45:56.265 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 898
06:45:58.265 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 414
06:46:00.265 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 486
06:46:02.265 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 093
06:46:04.265 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 080

  14. 关闭正在运行的 pod，

    1. 在 openshift 项目的 Project Status 页面中，单击 fuse78-spring-boot 应用。
    2. 点 Overview 选项卡查看应用程序的概览信息页面。
    3. 点 Desired Count 旁边的 图标。此时会显示 Edit Count 窗口。
    4. 使用向下箭头向下扩展到零，以停止 pod。

5.2.2. 取消部署并重新部署项目

您可以取消部署或重新部署项目，如下所示：

流程

  • 要取消部署项目，请输入以下命令：

    Copy to Clipboard Toggle word wrap 
    mvn fabric8:undeploy

  • 要重新部署项目，请输入以下命令：

    Copy to Clipboard Toggle word wrap 
    mvn fabric8:undeploy
mvn fabric8:deploy -Popenshift

5.2.3. 使用 S2I 源工作流创建和部署应用程序

在本小节中，您将使用 OpenShift S2I 源工作流基于模板在 OpenShift 应用上构建和部署 Fuse。此演示的起点是存储在远程 Git 存储库中的快速入门项目。使用 OpenShift 控制台，您将在 OpenShift 服务器中下载、构建和部署此快速启动项目。

流程

  1. 按如下所示登录 OpenShift 服务器：

    Copy to Clipboard Toggle word wrap 
    oc login -u developer -p developer https://OPENSHIFT_IP_ADDR:8443

    其中，OPENSHIFT_IP_ADDR 是 OpenShift 服务器的 IP 地址的占位符，因为此 IP 地址并不总是相同。

    注意

    developer 用户（具有 开发人员 密码）是 CDK 在虚拟 OpenShift 服务器上自动创建的标准帐户。如果您要访问远程服务器，请使用 OpenShift 管理员提供的 URL 和凭证。

  2. 按照如下所示，切换到 openshift 项目（如果还没有在 openshift 项目中）。

    Copy to Clipboard Toggle word wrap 
    oc project openshift

  3. 运行以下命令，以确保 OpenShift 模板上的 Fuse 已安装，并可以访问它们。

    Copy to Clipboard Toggle word wrap 
    oc get template -n openshift

    如果没有预安装镜像和模板，或者提供的版本已过时，请在 OpenShift 镜像和模板上手动安装（或更新） Fuse。有关如何在 OpenShift 镜像上安装 Fuse 的更多信息，请参阅 第 2 章 管理员入门。

  4. 输入以下命令创建使用 Spring Boot quickstart 模板运行 Red Hat Fuse 7.8 Camel XML DSL 所需的资源。这将为快速启动创建部署配置和构建配置。有关 Quickstart 的默认参数的信息，并在终端中显示创建的资源。

    Copy to Clipboard Toggle word wrap 
    oc new-app s2i-fuse78-spring-boot-camel-xml

--> Deploying template "openshift/s2i-fuse78-spring-boot-camel-xml" to project openshift
...
--> Creating resources ...
    imagestream.image.openshift.io "s2i-fuse78-spring-boot-camel-xml" created
    buildconfig.build.openshift.io "s2i-fuse78-spring-boot-camel-xml" created
    deploymentconfig.apps.openshift.io "s2i-fuse78-spring-boot-camel-xml" created
--> Success
    Build scheduled, use 'oc logs -f bc/s2i-fuse78-spring-boot-camel-xml' to track its progress.
    Run 'oc status' to view your app.
  5. 在浏览器中打开 OpenShift Web 控制台(https://OPENSHIFT_IP_ADDR，将 OPENSHIFT_IP_ADDR 替换为集群的 IP 地址)，并使用您的凭证登录控制台（例如，使用用户名 developer 和密码 developer）。
  6. 在左侧面板中，展开 Home。点 Status 查看 Project Status 页面。此时会显示所选命名空间中的所有现有应用程序（如 openshift）。

  7. 单击 s2i-fuse78-spring-boot-camel-xml 以查看快速启动的 Overview 信息页面。

    Spring Boot Camel XML Overview

  8. 单击 Resources 选项卡，然后单击 View logs 以查看应用的构建日志。

    Spring Boot Camel XML build logs

  9. 在左侧面板中，展开 Workloads。

  10. 单击 Pods，然后单击 s2i-fuse78-spring-boot-camel-xml-xxxx。此时会显示应用程序的 Pod 详情。

    Spring Boot Camel XML pod details

  11. 关闭正在运行的 pod，

    1. 在 openshift 项目的 Project Status 页面中，单击 s2i-fuse78-spring-boot-camel-xml-xxxx 应用。
    2. 点 Overview 选项卡查看应用程序的概览信息页面。
    3. 点 Desired Count 旁边的 图标。此时会显示 Edit Count 窗口。
    4. 使用向下箭头向下扩展到零，以停止 pod。

第 6 章 为 Spring Boot 镜像开发应用程序

本章介绍了如何为 Spring Boot 镜像开发应用程序。

6.1. 使用 Maven archetype 创建 Spring Boot 2 项目

此快速入门演示了如何使用 Maven archetypes 创建 Spring Boot 2 项目。

流程

  1. 进入您系统上的相应目录。

  2. 在 shell 提示符中，输入以下 mvn 命令来创建一个 Spring Boot 2 项目。

    Copy to Clipboard Toggle word wrap 
    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
  -DarchetypeCatalog=https://maven.repository.redhat.com/ga/io/fabric8/archetypes/archetypes-catalog/2.2.0.fuse-sb2-780040-redhat-00002/archetypes-catalog-2.2.0.fuse-sb2-780040-redhat-00002-archetype-catalog.xml \
  -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
  -DarchetypeArtifactId=spring-boot-camel-xml-archetype \
  -DarchetypeVersion=2.2.0.fuse-sb2-780040-redhat-00002

    archetype 插件切换到交互模式，以提示您输入剩余的字段。

    Copy to Clipboard Toggle word wrap 
    Define value for property 'groupId': : org.example.fis
Define value for property 'artifactId': : fuse78-spring-boot
Define value for property 'version':  1.0-SNAPSHOT: :
Define value for property 'package':  org.example.fis: :
Confirm properties configuration:
groupId: org.example.fis
artifactId: fuse78-spring-boot
version: 1.0-SNAPSHOT
package: org.example.fis
 Y: : Y

    出现提示时，为 groupId 值输入 org.example.fis，为 artifactId 值输入 fuse78-spring-boot。接受剩余的字段的默认值。

  3. 如果上述命令以 BUILD SUCCESS 状态退出，则现在应在 fuse78-spring-boot 子目录下具有 OpenShift 项目的 Fuse。

  4. 您现在已准备好构建和部署 fuse78-spring-boot 项目。假设您仍然登录 OpenShift，请更改到 fuse78-spring-boot 项目的目录，然后进行构建和部署项目，如下所示：

    Copy to Clipboard Toggle word wrap 
    cd fuse78-spring-boot
mvn fabric8:deploy -Popenshift
注意

有关可用 Spring Boot 2 archetypes 的完整列表，请参阅 Spring Boot 2 Archetype Catalog。

6.2. Camel Spring Boot 应用程序的结构

Camel Spring Boot 应用程序的目录结构如下：

Copy to Clipboard Toggle word wrap 
  ├── LICENSE.md
  ├── pom.xml
  ├── README.md
  ├── configuration
  │   └── settings.xml
  └── src
      ├── main
      │   ├── fabric8
      │   │   └── deployment.yml
      │   ├── java
      │   │   └── org
      │   │       └── example
      │   │           └── fis
      │   │               ├── Application.java
      │   │               └── MyTransformer.java
      │   └── resources
      │       ├── application.properties
      │       ├── logback.xml
      │       └── spring
      │           └── camel-context.xml
      └── test
          └── java
              └── org
                  └── example
                      └── fis

以下文件对于开发应用程序非常重要：

pom.xml
包括其他依赖项。初学者版本提供了与 Spring Boot 兼容的 Camel 组件，如 camel-jdbc-starter 或 camel-infinispan-starter。启动者包含在 pom.xml 中后，它们会自动配置并在引导时使用 Camel 内容注册。用户可以使用 application.properties 文件配置组件的属性。
application.properties

允许您对配置进行外部化，并在不同环境中使用相同的应用程序代码。详情请参阅 外部配置

例如，在这个 Camel 应用程序中，您可以配置某些属性，如应用程序的名称或 IP 地址等。

application.properties

Copy to Clipboard Toggle word wrap 
#spring.main.sources=org.example.fos

logging.config=classpath:logback.xml

# the options from org.apache.camel.spring.boot.CamelConfigurationProperties can be configured here
camel.springboot.name=MyCamel

# lets listen on all ports to ensure we can be invoked from the pod IP
server.address=0.0.0.0
management.address=0.0.0.0

# lets use a different management port in case you need to listen to HTTP requests on 8080
management.server.port=8081

# disable all management endpoints except health
endpoints.enabled = false
endpoints.health.enabled = true

Application.java

运行您的应用程序是重要的文件。作为用户，您将在此处导入一个 camel-context.xml 文件，以使用 Spring DSL 配置路由。

Application.java 文件指定 @SpringBootApplication 注释，它相当于 @Configuration、@EnableAutoConfiguration 和 @ComponentScan，及其默认属性。

Application.java

Copy to Clipboard Toggle word wrap 
@SpringBootApplication
// load regular Spring XML file from the classpath that contains the Camel XML DSL
@ImportResource({"classpath:spring/camel-context.xml"})

它必须 有一个主要 方法来运行 Spring Boot 应用。

Application.java

Copy to Clipboard Toggle word wrap 
public class Application {
    /**
     * A main method to start this application.
     */
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

camel-context.xml

src/main/resources/spring/camel-context.xml 是用于开发应用程序的重要文件，因为它包含 Camel 路由。

注意
src/main/fabric8/deployment.yml

提供与 fabric8-maven-plugin 生成的默认 OpenShift 配置文件合并的额外配置。

注意

此文件没有 Spring Boot 应用程序的一部分，但在所有快速入门中使用该文件来限制 CPU 和内存用量等资源。

6.3. Spring Boot 2 archetype 目录

Spring Boot 2 Archetype 目录包括以下示例。

表 6.1. Spring Boot 2 Maven Archetypes
Name描述

spring-boot-camel-archetype

演示如何将 Apache Camel 与基于 fabric8 Java 基础镜像的 Spring Boot 搭配使用。

spring-boot-camel-amq-archetype

演示如何将 Spring Boot 应用程序连接到 ActiveMQ 代理，并使用 Kubernetes 或 OpenShift 在两个 Camel 路由之间使用 JMS 消息传递。

spring-boot-camel-drools-archetype

演示如何使用 Apache Camel 将 Kubernetes 或 OpenShift 上运行的 Spring Boot 应用程序与远程 Kie Server 集成。

spring-boot-camel-infinispan-archetype

演示如何使用 Hot Rod 协议将 Spring Boot 应用程序连接到 JBoss Data Grid 或 Infinispan 服务器。

spring-boot-camel-rest-3scale-archetype

演示如何使用 Camel 的 REST DSL 来公开 RESTful API 并将其公开给 3scale。

spring-boot-camel-rest-sql-archetype

演示如何通过 JDBC 和 Camel 的 REST DSL 使用 SQL 来公开 RESTful API。

spring-boot-camel-xml-archetype

演示如何通过 Spring XML 配置文件在 Spring Boot 中配置 Camel 路由。

spring-boot-cxf-jaxrs-archetype

演示如何在基于 fabric8 Java 基础镜像的 Spring Boot 中使用 Apache CXF。快速入门使用 Spring Boot 配置包含启用了 Swagger 的 CXF JAXRS 端点的应用程序。

spring-boot-cxf-jaxws-archetype

演示如何在基于 fabric8 Java 基础镜像的 Spring Boot 中使用 Apache CXF。快速入门使用 Spring Boot 来配置包含 CXF JAXWS 端点的应用程序。

spring-boot-cxf-jaxrs-xml-archetype

演示如何在 OpenShift 中使用 Apache CXF JAX-RS 和 Spring Boot 2。此快速入门使用 Spring Boot2 启动基于 Spring 的 CXF 应用，该应用程序包括启用了 Swagger 的 CXF JAXRS 端点。

spring-boot-cxf-jaxws-xml-archetype

演示如何在 OpenShift 中使用 Apache CXF JAX-WS 和 Spring Boot 2。快速入门使用 Spring Boot2 启动基于 CXF JAXWS 端点的基于 Spring 配置文件。

注意

以下 Spring Boot 2 Maven archetypes 无法构建和部署 OpenShift。如需更多信息，请参阅发行注记。

  • spring-boot-camel-archetype
  • spring-boot-camel-infinspan-archetype
  • spring-boot-cxf-jaxrs-archetype
  • spring-boot-cxf-jaxws-archetype

要临时解决这个问题，请在为其中一个快速入门生成 Maven 项目后，编辑项目的 Maven pom.xml 文件，添加以下依赖项：

Copy to Clipboard Toggle word wrap 
<dependency>
  <groupId>org.assertj</groupId>
  <artifactId>assertj-core</artifactId>
  <version>2.4.1</version>
  <scope>test</scope>
</dependency>

6.4. Spring Boot 的 BOM 文件

Maven Bill of Materials (BOM) 文件的目的是提供一组精心工作的 Maven 依赖关系版本，防止您必须为每个 Maven 工件单独定义版本。

重要

确保您根据您使用的 Spring Boot 版本使用正确的 Fuse BOM。

用于 Spring Boot 的 Fuse BOM 提供了以下优点：

  • 定义 Maven 依赖项的版本，以便在将依赖项添加到 POM 时不需要指定版本。
  • 定义一组策展的依赖关系，它们被完全测试并支持特定版本的 Fuse。
  • 简化 Fuse 的升级.
重要

红帽仅支持由 Fuse BOM 定义的依赖项集合。

6.5. 包含 BOM 文件

要将 BOM 文件合并到 Maven 项目中，请在项目的 pom.xml 文件中指定 dependencyManagement 元素（或可能在父 POM 文件中），如两个 Spring Boot 2 的示例所示：

Spring Boot 2 BOM

Copy to Clipboard Toggle word wrap 
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <!-- configure the versions you want to use here -->
    <fuse.version>7.8.0.fuse-sb2-780038-redhat-00001</fuse.version>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>fuse-springboot-bom</artifactId>
        <version>${fuse.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  ...
</project>

在使用依赖项管理机制指定 BOM 后，可以在 POM 中添加 Maven 依赖项，而不指定 工件版本。例如，要为 camel-hystrix 组件添加依赖项，您要将以下 XML 片段添加到 POM 中的 dependencies 元素中：

Copy to Clipboard Toggle word wrap 
<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-hystrix-starter</artifactId>
</dependency>

请注意，如何将 Camel 工件 ID 指定为：start -starter 后缀是 in，您可以将 Camel Hystrix 组件指定为 camel-hystrix-starter，而不是 camel-hystrix。Camel 初学者组件以针对 Spring Boot 环境优化的方式打包。

6.6. Spring Boot Maven 插件

Spring Boot Maven 插件由 Spring Boot 提供，它是一个用于构建和运行 Spring Boot 项目的开发人员实用程序：

  • 通过在项目目录中输入 mvn package 命令，为您的 Spring Boot 应用程序 构建 可执行文件 Jar 软件包。构建的输出放置在 Maven 项目的 target/ 子目录中。
  • 为方便起见，您可以运行 mvn spring-boot:start 命令来运行新构建的应用程序。

要将 Spring Boot Maven 插件合并到项目 POM 文件中，请将插件配置添加到 pom.xml 文件的 project/build/plugins 部分中，如下例所示。

Example

Copy to Clipboard Toggle word wrap 
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <!-- configure the versions you want to use here -->
    <fuse.version>7.8.0.fuse-sb2-780038-redhat-00001</fuse.version>

  </properties>
  ...
  <build>
    <plugins>
      <plugin>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <version>${fuse.version}</version>
        <executions>
          <execution>
            <goals>
              <goal>repackage</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  ...
</project>

第 7 章 在 Spring Boot 中运行 Apache Camel 应用程序

Apache Camel Spring Boot 组件会自动为 Spring Boot 配置 Camel 上下文。Camel 上下文的自动配置会自动检测 Spring 上下文中提供的 Camel 路由，并将密钥 Camel 工具（如生成者模板、消费者模板和类型转换器）注册为 Bean。Apache Camel 组件包含一个 Spring Boot 初学者模块，允许您使用启动者开发 Spring Boot 应用程序。

7.1. Camel Spring Boot 组件简介

每个 Camel Spring Boot 应用程序都必须使用项目的 pom.xml 中的 dependencyManagement 元素来指定依赖项的产品化版本。这些依赖项在红帽 Fuse BOM 中定义，并受特定版本的 Red Hat Fuse 支持。您可以省略额外启动者的版本号属性，以便不会覆盖 BOM 中的版本。如需更多信息，请参阅 快速入门 pom。

Example

Copy to Clipboard Toggle word wrap 
<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.jboss.redhat-fuse</groupId>
			<artifactId>fuse-springboot-bom</artifactId>
			<version>${fuse.version}</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>

注意

camel-spring-boot jar 包含 spring.factories 文件，该文件允许您将该依赖项添加到 classpath 中，以便 Spring Boot 自动配置 Camel 上下文。

7.2. Camel Spring Boot 初学者模块简介

Starters 是要在 Spring Boot 应用程序中使用的 Apache Camel 模块。每个 Camel 组件都有一个 camel-xxx-starter 模块（在 第 7.3 节 “没有初学者模块的 Camel 组件列表” 部分列出了一些例外）。

发起者满足以下要求：

  • 允许使用与 IDE 工具兼容的原生 Spring Boot 配置系统自动配置组件。
  • 允许自动配置数据格式和语言。
  • 管理传输日志记录依赖项，以便与 Spring Boot 日志记录系统集成。
  • 包括其他依赖项并协调传输依赖关系，以最大程度降低创建正常工作的 Spring Boot 应用程序的工作量。

每个初学者在 test /camel-itest-spring-boot 中都有自己的集成测试，用于验证与 Spring Boot 当前版本的兼容性。

注意

如需了解更多详细信息，请参阅链接： Apache Camel Spring-Boot 示例。

7.3. 没有初学者模块的 Camel 组件列表

由于兼容性问题，以下组件没有初学者模块：

  • camel-blueprint （仅用于 OSGi）
  • camel-cdi （仅适用于 CDI）
  • camel-core-osgi （仅用于 OSGi）
  • camel-ejb （仅适用于EET）
  • camel-eventadmin （仅适用于 OSGi）
  • camel-ibatis (camel-mybatis-starter is included)
  • camel-jclouds
  • camel-mina (camel-mina2-starter is included)
  • camel-paxlogging （仅用于 OSGi）
  • camel-quartz (camel-quartz2-starter is included)
  • camel-spark-rest
  • camel-openapi-java (camel-openapi-java-starter is included)

7.4. 使用 Camel Spring Boot 初学者

Apache Camel 提供了一个初学者模块，可让您快速开始开发 Spring Boot 应用程序。

流程

  1. 将以下依赖项添加到 Spring Boot pom.xml 文件中：

    Copy to Clipboard Toggle word wrap 
    <dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-spring-boot-starter</artifactId>
</dependency>

  2. 在您的 Camel 路由中添加类，如以下代码片段所示。当这些路由添加到类路径中后，路由会自动启动。

    Copy to Clipboard Toggle word wrap 
    package com.example;

import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;

@Component
public class MyRoute extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("timer:foo")
          .to("log:bar");
    }
}

  3. 可选。要保持主线程被阻止，以便 Camel 保持启动，请执行以下任一操作：

    1. 包括 spring-boot-starter-web 依赖项，

    2. 或者将 camel.springboot.main-run-controller=true 添加到 application.properties 或 application.yml 文件中。

      您可以使用 camel.springboot unset 属性在 application.properties 或 application.yml 文件中自定义 Camel 应用程序。

  4. 可选。要使用 bean 的 ID 名称来引用自定义 bean，请在 src/main/resources/application.properties （或 application.yml）文件中配置选项。以下示例显示了如何使用 bean ID 来引用自定义 bean。

    1. 请参阅 id myExtensionFactory 的自定义 bean。

      Copy to Clipboard Toggle word wrap 
      camel.component.xslt.saxon-extension-functions=myExtensionFactory

    2. 然后，使用 Spring Boot @Bean 注释创建自定义 bean。

      Copy to Clipboard Toggle word wrap 
      @Bean(name = "myExtensionFactory")
public ExtensionFunctionDefinition myExtensionFactory() {
    }

      或者，对于 Jackson ObjectMapper，在 camel-jackson data-format 中：

      Copy to Clipboard Toggle word wrap 
      camel.dataformat.json-jackson.object-mapper=myJacksonMapper

7.5. 关于 Spring Boot 的 Camel 上下文自动配置

Camel Spring Boot 自动配置提供了一个 CamelContext 实例，并创建 SpringCamelContext。它还会初始化并执行该上下文的关闭。此 Camel 上下文在 camelContext bean 名称下的 Spring 应用程序上下文中注册，您可以像其他 Spring bean 一样访问它。您可以访问 camelContext，如下所示。

Example

Copy to Clipboard Toggle word wrap 
@Configuration
public class MyAppConfig {

  @Autowired
  CamelContext camelContext;

  @Bean
  MyService myService() {
    return new DefaultMyService(camelContext);
  }

}

7.6. 在 Spring Boot 应用程序中自动检测 Camel 路由

Camel 自动配置从 Spring 上下文收集所有 RouteBuilder 实例，并自动将它们注入到 CamelContext 中。这简化了使用 Spring Boot 初学者创建新 Camel 路由的过程。您可以按照以下方式创建路由：

Example

将 @Component 注解的类添加到您的 classpath。

Copy to Clipboard Toggle word wrap 
@Component
public class MyRouter extends RouteBuilder {

  @Override
  public void configure() throws Exception {
    from("jms:invoices").to("file:/invoices");
  }

}

或在您的 @Configuration 类中创建新的路由 RouteBuilder bean。

Copy to Clipboard Toggle word wrap 
@Configuration
public class MyRouterConfiguration {

  @Bean
  RoutesBuilder myRouter() {
    return new RouteBuilder() {

      @Override
      public void configure() throws Exception {
        from("jms:invoices").to("file:/invoices");
      }

    };
  }
 
}

7.7. 为 Camel Spring Boot 自动配置配置 Camel 属性

Spring Boot 自动配置连接到 Spring Boot 外部配置，如属性占位符、操作系统环境变量或带有 Camel 属性支持的系统属性。

流程

  1. 在 application.properties 文件中定义属性： 

    Copy to Clipboard Toggle word wrap 
    route.from = jms:invoices

    或者将 Camel 正确设置为系统属性，例如：

    Copy to Clipboard Toggle word wrap 
    java -Droute.to=jms:processed.invoices -jar mySpringApp.jar

  2. 使用配置的属性作为 Camel 路由中的占位符，如下所示：

    Copy to Clipboard Toggle word wrap 
    @Component
public class MyRouter extends RouteBuilder {

  @Override
  public void configure() throws Exception {
    from("{{route.from}}").to("{{route.to}}");
  }

}

7.8. 配置自定义 Camel 上下文

要对 Camel Spring Boot 自动配置创建的 CamelContext bean 执行操作，请在 Spring 上下文中注册 CamelContextConfiguration 实例。

流程

  • 在 Spring 上下文中注册 CamelContextConfiguration 实例，如下所示。

    Copy to Clipboard Toggle word wrap 
    @Configuration
public class MyAppConfig {

  ...

  @Bean
  CamelContextConfiguration contextConfiguration() {
    return new CamelContextConfiguration() {
      @Override
      void beforeApplicationStart(CamelContext context) {
        // your custom configuration goes here
      }
    };
  }

}

在 Spring 上下文启动前调用 CamelContextConfiguration 和 beforeApplicationStart (CamelContext) 方法，因此传递给此回调的 CamelContext 实例完全自动配置。您可以将多个 CamelContextConfiguration 实例添加到 Spring 上下文中，并且执行它们。

7.9. 在自动配置的 CamelContext 中禁用 JMX

要在自动配置的 CamelContext 中禁用 JMX，您可以使用 camel.springboot.jmxEnabled 属性，因为 JMX 默认启用。

流程

  • 将以下属性添加到 application.properties 文件中，并将其设置为 false ：

    Copy to Clipboard Toggle word wrap 
    camel.springboot.jmxEnabled = false

7.10. 将自动配置的使用者和制作者模板注入到 Spring 管理的 Bean 中

Camel 自动配置提供预配置的 ConsumerTemplate 和 ProducerTemplate 实例。您可以将它们注入到 Spring 管理的 Bean 中。

Example

Copy to Clipboard Toggle word wrap 
@Component
public class InvoiceProcessor {

  @Autowired
  private ProducerTemplate producerTemplate;

  @Autowired
  private ConsumerTemplate consumerTemplate;
  public void processNextInvoice() {
    Invoice invoice = consumerTemplate.receiveBody("jms:invoices", Invoice.class);
    ...
    producerTemplate.sendBody("netty-http:http://invoicing.com/received/" + invoice.id());
  }

}

默认情况下，消费者模板和制作者模板将端点缓存大小设置为 1000。您可以通过将以下 Spring 属性设置为所需的缓存大小来更改这些值，例如：

Copy to Clipboard Toggle word wrap 
camel.springboot.consumerTemplateCacheSize = 100
camel.springboot.producerTemplateCacheSize = 200

7.11. 关于 Spring 上下文中的自动配置的类型Converter

Camel 自动配置注册 Spring 上下文中名为 typeConverter 的 TypeConverter 实例。

Example

Copy to Clipboard Toggle word wrap 
@Component
public class InvoiceProcessor {

  @Autowired
  private TypeConverter typeConverter;

  public long parseInvoiceValue(Invoice invoice) {
    String invoiceValue = invoice.grossValue();
    return typeConverter.convertTo(Long.class, invoiceValue);
  }

}

7.12. Spring 类型转换 API 网桥

Spring 由强大的 类型转换 API 组成。Spring API 与 Camel 类型转换器 API 类似。由于两个 API Camel Spring Boot 之间的相似性会自动注册一个桥接转换器(SpringTypeConverter)，它将委托给 Spring conversion API。这意味着，开箱即用的 Camel 将对待与 Camel 类似的 Spring Converters。

这可让您使用 Camel TypeConverter API 访问 Camel 和 Spring 转换器，如下所示：

Example

Copy to Clipboard Toggle word wrap 
@Component
public class InvoiceProcessor {

  @Autowired
  private TypeConverter typeConverter;

  public UUID parseInvoiceId(Invoice invoice) {
    // Using Spring's StringToUUIDConverter
    UUID id = invoice.typeConverter.convertTo(UUID.class, invoice.getId());
  }

}

在这里，Spring Boot 将转换委托给应用程序上下文中提供的 Spring 的 ConversionService 实例。如果没有 ConversionService 实例可用，Camel Spring Boot 自动配置会创建一个 ConversionService 实例。

7.13. 禁用类型转换功能

要禁用 Camel Spring Boot 类型转换功能，请将 camel.springboot.typeConversion 属性设置为 false。当此属性设置为 false 时，自动配置不会注册类型转换器实例，且不会启用将类型转换到 Spring Boot 类型转换 API。

流程

  • 要禁用 Camel Spring Boot 组件的类型转换功能，请将 camel.springboot.typeConversion 属性设置为 false，如下所示：

    Copy to Clipboard Toggle word wrap 
    camel.springboot.typeConversion = false

7.14. 在用于自动配置的 classpath 中添加 XML 路由

默认情况下，Camel Spring Boot 组件会自动探测，并包括位于 camel 目录中的 classpath 中的 Camel XML 路由。您可以使用配置选项配置目录名称或禁用此功能。

流程

  • 在 classpath 中配置 Camel Spring Boot XML 路由，如下所示：

    Copy to Clipboard Toggle word wrap 
    // turn off
camel.springboot.xmlRoutes = false
// scan in the com/foo/routes classpath
camel.springboot.xmlRoutes = classpath:com/foo/routes/*.xml
    注意

    XML 文件应该定义 Camel XML 路由元素，而不是 CamelContext 元素，例如：

    Copy to Clipboard Toggle word wrap 
       <routes xmlns="http://camel.apache.org/schema/spring">
        <route id="test">
            <from uri="timer://trigger"/>
            <transform>
                <simple>ref:myBean</simple>
            </transform>
            <to uri="log:out"/>
        </route>
    </routes>

使用 Spring XML 文件

要将 Spring XML 文件与 <camelContext> 搭配使用，您可以在 Spring XML 文件或 application.properties 文件中配置 Camel 上下文。要设置 Camel 上下文的名称并打开流缓存，请在 application.properties 文件中添加以下内容：

Copy to Clipboard Toggle word wrap 
camel.springboot.name = MyCamel
camel.springboot.stream-caching-enabled=true

7.15. 为自动配置添加 XML Rest-DSL 路由

Camel Spring Boot 组件会自动探测，并嵌入在 camel-rest 目录下的 classpath 中添加的 Camel Rest-DSL XML 路由。您可以使用配置选项配置目录名称或禁用此功能。

流程

  • 在 classpath 中配置 Camel Spring Boot Rest-DSL XML 路由，如下所示：

    Copy to Clipboard Toggle word wrap 
    // turn off
camel.springboot.xmlRests = false
// scan in the com/foo/routes classpath
camel.springboot.xmlRests = classpath:com/foo/rests/*.xml
    注意

    Rest-DSL XML 文件应该定义 Camel XML REST 元素，而不是 CamelContext 元素，例如：

    Copy to Clipboard Toggle word wrap 
       <rests xmlns="http://camel.apache.org/schema/spring">
      <rest>
         <post uri="/persons">
            <to uri="direct:postPersons"/>
         </post>
         <get uri="/persons">
            <to uri="direct:getPersons"/>
         </get>
         <get uri="/persons/{personId}">
             <to uri="direct:getPersionId"/>
         </get>
         <put uri="/persons/{personId}">
             <to uri="direct:putPersionId"/>
         </put>
         <delete uri="/persons/{personId}">
             <to uri="direct:deletePersionId"/>
         </delete>
      </rest>
    </rests>

7.16. 使用 Camel Spring Boot 测试

当 Camel 在 Spring Boot 上运行时，Spring Boot 会自动嵌入 Camel 及其所有路由，它们使用 @Component 标注。使用 Spring Boot 测试时使用 @SpringBootTest 而不是 @ContextConfiguration 来指定要使用的配置类。

当您在不同的 RouteBuilder 类中有多个 Camel 路由时，Camel Spring Boot 组件会在运行应用程序时自动嵌入所有这些路由。因此，当您只想从一个 RouteBuilder 类测试路由时，您可以使用以下模式来包括或排除要启用的 RouteBuilders：

  • java-routes-include-pattern：用于包括与模式匹配的 RouteBuilder 类。
  • java-routes-exclude-pattern：用于排除与模式匹配的 RouteBuilder 类。exclude 优先于 include。

流程

  1. 在单元测试类中指定 include 或 exclude 模式，作为 @SpringBootTest 注解的属性，如下所示：

    Copy to Clipboard Toggle word wrap 
    @RunWith(CamelSpringBootRunner.class)
@SpringBootTest(classes = {MyApplication.class);
   properties = {"camel.springboot.java-routes-include-pattern=**/Foo*"})
public class FooTest {

    在 FooTest 类中，include 模式为 **/Foo*，它代表 Ant 风格模式。此处的模式以双星号开头，与前导软件包名称匹配。/foo* 表示类名称必须以 Foo 开头，例如 FooRoute。

  2. 使用以下 maven 命令运行测试：

    Copy to Clipboard Toggle word wrap 
    mvn test -Dtest=FooTest

其它资源

第 8 章 在 OpenShift 上的 Fuse 上运行 SOAP 到 REST 网桥快速入门 2

本快速入门演示了如何使用 Camel 的 REST DSL 来公开后端 SOAP API。简单的 camel 路由可以桥接到传统 SOAP 服务的 REST 调用。安全性适用于 REST 端点和 SOAP 端点，两者均受 RH SSO 支持。通过 OAuth 和 OpenID Connect 保护的前端 REST API，客户端将使用 Resource Owner Password Credentials OAuth2 模式从 RH SSO 获取 JWT 访问令牌，并使用此令牌访问 REST 端点。

先决条件

流程

以下章节解释了如何在 OpenShift 的 Fuse 上将 SOAP 运行和管理 REST 网桥快速入门。

  1. 启动 OpenShift 服务器。由于我们需要安装 RH SSO 镜像(2 个 pod)和 3Scale 镜像(15 个 pod)作为此快速入门的先决条件，因此我们需要在强大的机器上启动 OpenShift 服务器，带有选项- 内存 8GB --cpus 4。我们还需要使用过期时间发布安全令牌，因此我们需要添加 timezone 选项。确保 Openshift 集群使用与本地机器相同的时区（默认情况下，它将使用 UTC 时区）。

  2. 将 cluster-admin 角色添加到用户 developer。

    Copy to Clipboard Toggle word wrap 
    $ oc login -u system:admin
$ oc adm policy add-cluster-role-to-user cluster-admin developer
$ oc login -u developer
$ oc project openshift

    此快速入门部署在 openshift 命名空间中（这是涉及的模板的默认配置）以及 RH SSO 镜像，因此我们需要向用户 开发人员 添加 cluster-admin 角色。

  3. 创建 secret 并将其链接到服务账户 。

    Copy to Clipboard Toggle word wrap 
    $ oc create secret docker-registry camel-bridge --docker-server=registry.redhat.io \
  --docker-username=USERNAME \
  --docker-password=PASSWORD \
  --docker-email=EMAIL_ADDRESS
$ oc secrets link default camel-bridge --for=pull
$ oc secrets link builder camel-bridge

  4. 添加 RH SSO 镜像流，并使用模板 sso74-x509-postgresql-persistent 安装 RH SSO。

    Copy to Clipboard Toggle word wrap 
    $ for resource in sso74-image-stream.json \
   sso74-https.json \
   sso74-postgresql.json \
   sso74-postgresql-persistent.json \
   sso74-x509-https.json \
   sso74-x509-postgresql-persistent.json
 do
   oc create -f \
   https://raw.githubusercontent.com/jboss-container-images/redhat-sso-7-openshift-image/sso74-dev/templates/${resource}
 done

$ oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default

$ oc new-app --template=sso74-x509-postgresql-persistent

    验证 RH SSO 镜像是否在 openshift 命名空间中可用，然后使用模板 sso74-x509-postgresql-persistent 安装 RH SSO。此模板可以永久保存 RH SSO 配置，因此在 Openshift 服务器重启后会保留配置。

  5. 在服务器上成功安装 RH SSO 镜像后，您可以按照如下所示在控制台上看到输出：

    Copy to Clipboard Toggle word wrap 
    A new persistent RH-SSO service (using PostgreSQL) has been created in your project. The admin username/password for accessing the master realm via the RH-SSO console is tprYtXP1/nEjf7fojv11FmhJ5eaqadoh0SI2gvlls. The username/password for accessing the PostgreSQL database "root" is userqxe/XNYRjL74CrJEWW7HiSYEdH5FMKVSDytx. The HTTPS keystore used for serving secure content, the JGroups keystore used for securing JGroups communications, and server truststore used for securing RH-SSO requests were automatically created via OpenShift's service serving x509 certificate secrets.

     * With parameters:
        * Application Name=sso
        * Custom RH-SSO Server Hostname=
        * JGroups Cluster Password=1whGRnsAWu162u0e4P6jNpLn5ysJLWjg # generated
        * Database JNDI Name=java:jboss/datasources/KeycloakDS
        * Database Name=root
        * Datasource Minimum Pool Size=
        * Datasource Maximum Pool Size=
        * Datasource Transaction Isolation=
        * PostgreSQL Maximum number of connections=
        * PostgreSQL Shared Buffers=
        * Database Username=userqxe # generated
        * Database Password=XNYRjL74CrJEWW7HiSYEdH5FMKVSDytx # generated
        * Database Volume Capacity=1Gi
        * ImageStream Namespace=openshift
        * RH-SSO Administrator Username=tprYtXP1 # generated
        * RH-SSO Administrator Password=nEjf7fojv11FmhJ5eaqadoh0SI2gvlls # generated
        * RH-SSO Realm=
        * RH-SSO Service Username=
        * RH-SSO Service Password=
        * PostgreSQL Image Stream Tag=10
        * Container Memory Limit=1Gi

  6. 注意 Username/Password，用于访问 RH SSO 管理控制台。例如，

    Copy to Clipboard Toggle word wrap 
     * RH-SSO Administrator Username=tprYtXP1 # generated
 * RH-SSO Administrator Password=nEjf7fojv11FmhJ5eaqadoh0SI2gvlls # generated

  7. 在 3scale 项目中安装 3scale 模板。

    Copy to Clipboard Toggle word wrap 
    $ oc new-project 3scale
$ oc create secret docker-registry threescale-registry-auth --docker-server=registry.redhat.io --docker-server=registry.redhat.io \
  --docker-username=USERNAME \
  --docker-password=PASSWORD \
  --docker-email=EMAIL_ADDRESS
$ oc secrets link default threescale-registry-auth --for=pull
$ oc secrets link builder threescale-registry-auth
$ oc new-app --param WILDCARD_DOMAIN="OPENSHIFT_IP_ADDR.nip.io" -f https://raw.githubusercontent.com/3scale/3scale-amp-openshift-templates/2.8.0.GA/amp/amp-eval-tech-preview.yml

    openshift 上的 3scale 安装将启动 15 个 pod，因此需要为 3scale 创建一个新的特定项目。您还需要一个新的 threescale-registry-auth （使用此名称来创建 secret，因为它用 3scale 编写）机密。您可以从 camel-bridge secret 中重复使用 USERNAME/PASSWORD。我们在这里有意使用 amp-eval-tech-preview.yml 模板，因为它没有明确指定硬件资源，因此可轻松在本地机器/laptop 上运行。

  8. 在 Openshift 上成功安装 3scale 模板后，您可以按照如下所示在控制台中看到输出：

    Copy to Clipboard Toggle word wrap 
    3scale API Management
     ---------
     3scale API Management main system (Evaluation)

     Login on https://3scale-admin.192.168.64.33.nip.io as admin/b6t784nt

     * With parameters:
        * AMP_RELEASE=2.8
        * APP_LABEL=3scale-api-management
        * TENANT_NAME=3scale
        * RWX_STORAGE_CLASS=null
        * AMP_BACKEND_IMAGE=registry.redhat.io/3scale-amp2/backend-rhel7:3scale2.8
        * AMP_ZYNC_IMAGE=registry.redhat.io/3scale-amp2/zync-rhel7:3scale2.8
        * AMP_APICAST_IMAGE=registry.redhat.io/3scale-amp2/apicast-gateway-rhel8:3scale2.8
        * AMP_SYSTEM_IMAGE=registry.redhat.io/3scale-amp2/system-rhel7:3scale2.8
        * ZYNC_DATABASE_IMAGE=registry.redhat.io/rhscl/postgresql-10-rhel7
        * MEMCACHED_IMAGE=registry.redhat.io/3scale-amp2/memcached-rhel7:3scale2.8
        * IMAGESTREAM_TAG_IMPORT_INSECURE=false
        * SYSTEM_DATABASE_IMAGE=registry.redhat.io/rhscl/mysql-57-rhel7:5.7
        * REDIS_IMAGE=registry.redhat.io/rhscl/redis-32-rhel7:3.2
        * System MySQL User=mysql
        * System MySQL Password=mrscfh4h # generated
        * System MySQL Database Name=system
        * System MySQL Root password.=xbi0ch3i # generated
        * WILDCARD_DOMAIN=192.168.64.33.nip.io
        * SYSTEM_BACKEND_USERNAME=3scale_api_user
        * SYSTEM_BACKEND_PASSWORD=kraji167 # generated
        * SYSTEM_BACKEND_SHARED_SECRET=8af5m6gb # generated
        * SYSTEM_APP_SECRET_KEY_BASE=726e63427173e58cbb68a63bdc60c7315565d6acd037caedeeb0050ecc0e6e41c3c7ec4aba01c17d8d8b7b7e3a28d6166d351a6238608bb84aa5d5b2dc02ae60 # generated
        * ADMIN_PASSWORD=b6t784nt # generated
        * ADMIN_USERNAME=admin
        * ADMIN_EMAIL=
        * ADMIN_ACCESS_TOKEN=k055jof4itblvwwn # generated
        * MASTER_NAME=master
        * MASTER_USER=master
        * MASTER_PASSWORD=buikudum # generated
        * MASTER_ACCESS_TOKEN=xa7wkt16 # generated
        * RECAPTCHA_PUBLIC_KEY=
        * RECAPTCHA_PRIVATE_KEY=
        * SYSTEM_REDIS_URL=redis://system-redis:6379/1
        * SYSTEM_MESSAGE_BUS_REDIS_URL=
        * SYSTEM_REDIS_NAMESPACE=
        * SYSTEM_MESSAGE_BUS_REDIS_NAMESPACE=
        * Zync Database PostgreSQL Connection Password=efyJdRccBbYcWtWl # generated
        * ZYNC_SECRET_KEY_BASE=dcmNGWtrjCReuJlQ # generated
        * ZYNC_AUTHENTICATION_TOKEN=3FKMAije3V3RWQQ8 # generated
        * APICAST_ACCESS_TOKEN=2ql8txu4 # generated
        * APICAST_MANAGEMENT_API=status
        * APICAST_OPENSSL_VERIFY=false
        * APICAST_RESPONSE_CODES=true
        * APICAST_REGISTRY_URL=http://apicast-staging:8090/policies

  9. 请注意，用户名/密码可以访问 3scale 管理控制台。

    Copy to Clipboard Toggle word wrap 
            * ADMIN_PASSWORD=b6t784nt # generated
        * ADMIN_USERNAME=admin

  10. 配置 RH SSO。

    1. 在 RH SSO 安装后，使用控制台中显示的用户名/密码从 https://sso-openshift.OPENSHIFT_IP_ADDR.nip.io/auth 登录 RH SSO 管理控制台。
    2. 单击页面左上角的 Add Realm 按钮。
    3. 在 Add Realm 页面上，选择 Import Select file 按钮。
    4. 从目录中选择 ./src/main/resources/keycloak-config/realm-export-new.json，它将为这个示例导入预定义的必要 realm/client/user/role。

  11. 配置 3Scale API 网关。

    1. 在 3Scale 安装后，使用控制台中显示的用户名/密码从 https://3scale-admin.OPENSHIFT_IP_ADDR.nip.io/p/admin/dashboard 登录 3Scale Admin 控制台。
    2. 在创建新产品时，选择 Define manually 并将 camel-security-bridge 用于 Name 和 System name。
    3. 在创建新后端时，将 camel-security-bridge 用于 Name 和 System name，private Base URL 应该为 http://spring-boot-camel-soap-rest-bridge-openshift.OPENSHIFT_IP_ADDR.nip.io/。
    4. 将新创建的后端添加到新创建的产品中。
    5. 添加映射规则 Verb:POST Pattern:/。
    6. 在创建应用计划时，请将 camel-security-bridge 用于 Name 和 System name。

    7. 在创建应用程序时，选择新创建的 camel-security-bridge 应用计划。创建应用程序后，记下 API 凭据。使用这些凭据访问 3scale 网关。eample，

      Copy to Clipboard Toggle word wrap 
          User Key 	bdfb53fe9b426fbf21428fd116035798
    8. 编辑新创建的 camel-security-bridge 项目，并在 Dashboard 中从 camel-security-bridge 发布它。
    9. 进入 Integration > Settings。选择 As HTTP Headers 作为 Credentials 位置。
    10. 从仪表板中的 camel-security-bridge，进入 Integration > Configuration，并提升 Staging APIcast 和 Production APIcast。

  12. 导航到包含提取的快速启动应用程序的目录（例如，my_openshift/spring-boot-camel-soap-rest-bridge）。

    Copy to Clipboard Toggle word wrap 
    $ cd my_openshift/spring-boot-camel-soap-rest-bridge

  13. 构建项目并部署到 OpenShift 集群。

    Copy to Clipboard Toggle word wrap 
    $ mvn clean fabric8:deploy -Popenshift -DJAVA_OPTIONS="-Dsso.server=https://sso-openshift.OPENSHIFT_IP_ADDR.nip.io -Dweather.service.host=${your local ip}"

    我们需要传递两个属性到 openshift 上的 camel-soap-rest-bridge 镜像。一个是 openshift 上的 RH SSO 服务器地址，这是 https://sso-openshift.OPENSHIFT_IP_ADDR.nip.io。另一个是后端 soap 服务器。在此快速入门中，我们在本地机器上运行后端 soap 服务器，因此请将机器的本地 ip 地址传递为 -Dweather.service.host。（这必须是 localhost 或 127.0.0.1 以外的 ip 地址。）

  14. 在您的浏览器中，导航到 OpenShift 控制台中的 openshift 项目。等待到您可以看到 spring-boot-camel-soap-rest-bridge 的 pod 已启动。
  15. 在项目的 Overview 页面中，导航到 spring-boot-camel-soap-rest-bridge 应用程序的详情页面部署 ：https://OPENSHIFT_IP_ADDR:8443/console/project/openshift/browse/pods/spring-boot-camel-soap-rest-bridge-NUMBER_OF_DEPLOYMENT?tab=details。
  16. 切换到 Logs 选项卡，以查看 Camel 的日志。
  17. Access OpenApi API.

这个示例使用 context-path camelcxf/openapi 提供使用 openapi 的服务的 API 文档。您可以从 Web 浏览器访问 API 文档，网址为 http://spring-boot-camel-soap-rest-bridge-openshift.OPENSHIFT_IP_ADDR.nip.io/camelcxf/openapi/openapi.jsonn。

第 9 章 使用 XA 事务在 Spring Boot 上运行 Camel 服务

Spring Boot Camel XA 事务快速入门演示了如何在 Spring-Boot 上运行 Camel Service，它在两个外部事务资源上支持 XA 事务、JMS 资源(A-MQ)和数据库(PostgreSQL)。这些外部资源由 OpenShift 提供，必须在运行此快速入门前启动。

9.1. StatefulSet 资源

此快速入门使用 OpenShift StatefulSet 资源来确保事务管理器的唯一性，并要求 PersistentVolume 存储事务日志。应用程序支持对 StatefulSet 资源进行扩展。每个实例都有 自己的进程 恢复管理器。特殊的控制器保证，当应用程序缩减时，终止的所有实例都会正确完成其所有工作，而不会留下待处理的事务。如果恢复管理器无法在终止前清除所有待处理的工作，则控制器会回滚 scale-down 操作。此快速入门使用 Spring Boot Narayana recovery controller。

9.2. Spring Boot Narayana recovery controller

Spring Boot Narayana 恢复控制器允许在终止前清理待处理的事务来安全地处理 StatefulSet 的缩减阶段。如果执行缩减操作，且 pod 在终止后没有清理，则会恢复之前副本数，从而有效地取消缩减操作。

StatefulSet 的所有 pod 需要访问共享卷，用于存储属于 StatefulSet 的每个 pod 的终止状态。StatefulSet 的 pod-0 会定期检查状态，并在出现不匹配时将 StatefulSet 扩展至正确的大小。

为了恢复控制器正常工作，需要编辑当前命名空间的权限（角色绑定包含在发布到 OpenShift 的资源集合中）。可以使用 CLUSTER_RECOVERY_ENABLED 环境变量禁用恢复控制器。在这种情况下，服务帐户不需要特殊权限，但任何缩减操作都可能会在已终止的 pod 上保留待处理的事务，而无需通知。

9.3. 配置 Spring Boot Narayana 恢复控制器

以下示例演示了如何配置 Narayana 以使用恢复控制器在 OpenShift 上工作。

流程

  1. 这是一个 application.properties 文件示例。替换 Kubernetes yaml 描述符中的以下选项。

    Copy to Clipboard Toggle word wrap 
    # Cluster
cluster.nodename=1
cluster.base-dir=./target/tx

# Transaction Data
spring.jta.transaction-manager-id=${cluster.nodename}
spring.jta.log-dir=${cluster.base-dir}/store/${cluster.nodename}

# Narayana recovery settings
snowdrop.narayana.openshift.recovery.enabled=true
snowdrop.narayana.openshift.recovery.current-pod-name=${cluster.nodename}
# You must enable resource filtering in order to inject the Maven artifactId
snowdrop.narayana.openshift.recovery.statefulset=${project.artifactId}
snowdrop.narayana.openshift.recovery.status-dir=${cluster.base-dir}/status

  2. 您需要一个共享卷来存储与终止相关的事务和信息。它可以挂载到 StatefulSet yaml 描述符中，如下所示。

    Copy to Clipboard Toggle word wrap 
    apiVersion: apps/v1beta1
kind: StatefulSet
#...
spec:
#...
  template:
#...
    spec:
      containers:
      - env:
        - name: CLUSTER_BASE_DIR
          value: /var/transaction/data
          # Override CLUSTER_NODENAME with Kubernetes Downward API (to use `pod-0`, `pod-1` etc. as tx manager id)
        - name: CLUSTER_NODENAME
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: metadata.name
#...
        volumeMounts:
        - mountPath: /var/transaction/data
          name: the-name-of-the-shared-volume
#...

Camel Extension for Spring Boot Narayana Recovery Controller

如果在 Spring Boot 应用程序上下文中找到 Camel，则在清除所有待处理的事务前会自动停止 Camel 上下文。

9.4. 在 OpenShift 上运行 Camel Spring Boot XA quickstart

此流程演示了如何在正在运行的单一节点 OpenShift 集群上运行 Quickstart。

流程

  1. 下载 Camel Spring Boot XA 项目。

    Copy to Clipboard Toggle word wrap 
    git clone --branch spring-boot-camel-xa-7.8.0.fuse-sb2-780031-redhat-00001 https://github.com/jboss-fuse/spring-boot-camel-xa

  2. 导航到 spring-boot-camel-xa 目录并运行以下命令：

    Copy to Clipboard Toggle word wrap 
    mvn clean install

  3. 登录 OpenShift 服务器。

    Copy to Clipboard Toggle word wrap 
    oc login -u developer -p developer

  4. 创建名为 test 的新项目命名空间（假设它尚不存在）。

    Copy to Clipboard Toggle word wrap 
    oc new-project test

    如果 test 项目命名空间已存在，请切换到该命名空间。

    Copy to Clipboard Toggle word wrap 
    oc project test

  5. 安装依赖项。

    • 使用用户名用户名 和密码 Thepassword1! 安装 postgresql。

      Copy to Clipboard Toggle word wrap 
      oc new-app --param=POSTGRESQL_USER=theuser --param=POSTGRESQL_PASSWORD='Thepassword1!' --env=POSTGRESQL_MAX_PREPARED_TRANSACTIONS=100 --template=postgresql-persistent

    • 使用用户名用户名 和密码 Thepassword1! 安装 A-MQ 代理。

      Copy to Clipboard Toggle word wrap 
      oc new-app --param=MQ_USERNAME=theuser --param=MQ_PASSWORD='Thepassword1!' --template=amq63-persistent

  6. 为事务日志创建一个持久性卷声明。

    Copy to Clipboard Toggle word wrap 
    oc create -f persistent-volume-claim.yml

  7. 构建和部署您的快速入门。

    Copy to Clipboard Toggle word wrap 
    mvn fabric8:deploy -P openshift

  8. 将它扩展至所需的副本数。

    Copy to Clipboard Toggle word wrap 
    oc scale statefulset spring-boot-camel-xa --replicas 3

    注： pod 名称用作事务管理器 ID (spring.jta.transaction-manager-id 属性)。当前的实现还限制了事务管理器 ID 的长度。请注意：

    • StatefulSet 的名称是事务系统的标识符，因此不得更改。
    • 您应该为 StatefulSet 命名，以便其所有 pod 名称长度都小于或等于 23 个字符。OpenShift 使用惯例创建 Pod 名称： <statefulset-name>-0, <statefulset-name>-1 等。Narayana 最好避免有多个具有相同 ID 的恢复管理器，因此当 pod 名称超过限制时，最后 23 字节将作为事务管理器 id （去掉一些字符（去除一些字符，如 -）。

  9. 快速启动运行后，使用以下命令获取基础服务 URL。

    Copy to Clipboard Toggle word wrap 
    NARAYANA_HOST=$(oc get route spring-boot-camel-xa -o jsonpath={.spec.host})

9.5. 测试成功 XA 事务

以下工作流演示了如何测试成功 XA 事务。

流程

  1. 获取 audit_log 表中的消息列表。

    Copy to Clipboard Toggle word wrap 
    curl -w "\n" http://$NARAYANA_HOST/api/

  2. 列表在开始时为空。现在，您可以放置第一个元素。

    Copy to Clipboard Toggle word wrap 
    curl -w "\n" -X POST http://$NARAYANA_HOST/api/?entry=hello

    等待一段时间后获取新列表。

    Copy to Clipboard Toggle word wrap 
    curl -w "\n" http://$NARAYANA_HOST/api/
  3. 新列表中含有两个消息，即 hello 和 hello-ok。hello-ok 确认消息已发送到传出队列，然后记录。您可以添加多个消息并查看日志。

9.6. 测试失败的 XA 事务

以下工作流演示了如何测试失败的 XA 事务。

流程

  1. 发送名为 fail 的消息。

    Copy to Clipboard Toggle word wrap 
    curl -w "\n" -X POST http://$NARAYANA_HOST/api/?entry=fail

  2. 等待一段时间后获取新列表。

    Copy to Clipboard Toggle word wrap 
    curl -w "\n" http://$NARAYANA_HOST/api/
  3. 此消息在路由的末尾生成一个例外，以便始终回滚事务。您不应该在 audit_log 表中找到任何消息的追踪。

第 10 章 将 Camel 应用程序与 A-MQ 代理集成

本教程介绍了如何使用 A-MQ 镜像部署快速入门。

10.1. 构建和部署 Spring Boot Camel A-MQ 快速启动

此快速入门演示了如何将 Spring Boot 应用程序连接到 AMQ Online，并使用 OpenShift 上的 Fuse 在两个 Camel 路由之间使用 JMS 消息传递。

先决条件

流程

  1. 以开发者身份登录 OpenShift 服务器。

    Copy to Clipboard Toggle word wrap 
    oc login -u developer -p developer

  2. 登录 openshift 项目。

    Copy to Clipboard Toggle word wrap 
    oc project openshift

  3. 使用 Maven 工作流创建 Quickstart 项目。

    Copy to Clipboard Toggle word wrap 
    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
-DarchetypeCatalog=https://maven.repository.redhat.com/ga/io/fabric8/archetypes/archetypes-catalog/2.2.0.fuse-sb2-780040-redhat-00002/archetypes-catalog-2.2.0.fuse-sb2-780040-redhat-00002-archetype-catalog.xml \
-DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
-DarchetypeArtifactId=spring-boot-camel-amq-archetype \
-DarchetypeVersion=2.2.0.fuse-sb2-780040-redhat-00002

  4. archetype 插件切换到交互模式，以提示您输入剩余的字段。

    Copy to Clipboard Toggle word wrap 
    Define value for property 'groupId': : org.example.fis
Define value for property 'artifactId': : fuse78-spring-boot-camel-amq
Define value for property 'version':  1.0-SNAPSHOT: :
Define value for property 'package':  org.example.fis: :
Confirm properties configuration:
groupId: org.example.fis
artifactId: fuse78-spring-boot-camel-amq
version: 1.0-SNAPSHOT
package: org.example.fis
Y: :Y

    出现提示时，为 groupId 值输入 org.example.fis，在 artifactId 值中输入 fuse78-spring-boot-camel-amq。接受剩余的字段的默认值。

  5. 导航到 Quickstart 目录 fuse78-spring-boot-camel-amq。

    Copy to Clipboard Toggle word wrap 
    cd fuse78-spring-boot-camel-amq

  6. 运行以下命令，将配置文件应用到 AMQ Online。这些配置文件创建 AMQ Online 用户和队列，两者均具有 admin 特权。

    Copy to Clipboard Toggle word wrap 
    oc login -u system:admin
oc apply -f src/main/resources/k8s

  7. 运行 mvn 命令将快速启动部署到 OpenShift 服务器。

    Copy to Clipboard Toggle word wrap 
    mvn fabric8:deploy -Popenshift

  8. 验证 Quickstart 是否已成功运行：

    1. 在浏览器中打开 OpenShift Web 控制台(https://OPENSHIFT_IP_ADDR，将 OPENSHIFT_IP_ADDR 替换为集群的 IP 地址)，并使用您的凭证（例如，使用用户名和密码 developer）登录到控制台。
    2. 在左侧面板中，展开 Home，然后单击 Status 以查看 openshift 项目的 Project Status 页面。
    3. 点 fuse78-spring-boot-camel-amq 查看快速启动的 Overview 信息页面。
    4. 在左侧面板中，展开 Workloads。
    5. 单击 Pods，然后单击 fuse78-spring-boot-camel-amq-xxxxx。此时会显示快速启动的 pod 详情。

    6. 点 Logs 查看应用程序的日志。

      输出显示消息成功发送。

      Copy to Clipboard Toggle word wrap 
      10:17:59.825 [Camel (camel) thread #10 - timer://order] INFO  generate-order-route - Generating order order1379.xml
10:17:59.829 [Camel (camel) thread #8 - JmsConsumer[incomingOrders]] INFO  jms-cbr-route - Sending order order1379.xml to the UK
10:17:59.829 [Camel (camel) thread #8 - JmsConsumer[incomingOrders]] INFO  jms-cbr-route - Done processing order1379.xml
10:18:02.825 [Camel (camel) thread #10 - timer://order] INFO  generate-order-route - Generating order order1380.xml
10:18:02.829 [Camel (camel) thread #7 - JmsConsumer[incomingOrders]] INFO  jms-cbr-route - Sending order order1380.xml to another country
10:18:02.829 [Camel (camel) thread #7 - JmsConsumer[incomingOrders]] INFO jms-cbr-route - Done processing order1380.xml
  9. 要查看 Web 界面中的路由，请点 Open Java Console 并检查 AMQ 队列中的消息。

第 11 章 将 Spring Boot 与 Kubernetes 集成

Spring Cloud Kubernetes 插件目前使您能够集成 Spring Boot 和 Kubernetes 的以下功能：

11.1. Spring Boot 外部化配置

在 Spring Boot 中，外部化 配置是可让您将来自外部源的配置值注入 Java 代码的机制。在您的 Java 代码中，使用 @Value 注释（注入单个字段）或 @ConfigurationProperties 注释（注入 Java bean 类的多个属性）通常启用注入。

配置数据可能来自各种不同的源（或 属性源）。特别是，通常在项目的 application.properties 文件中设置配置属性（或 application.yaml 文件）。

11.1.1. Kubernetes ConfigMap

Kubernetes ConfigMap 是向已部署的应用程序提供配置数据的机制。ConfigMap 对象通常在 YAML 文件中定义，然后上传到 Kubernetes 集群，使配置数据可用于部署的应用程序。

11.1.2. Kubernetes Secret

Kubernetes Secret 是为部署的应用程序提供敏感数据（如密码、证书等）的机制。

11.1.3. Spring Cloud Kubernetes 插件

Spring Cloud Kubernetes 插件实现 Kubernetes 和 Spring Boot 之间的集成。在原则上，您可以使用 Kubernetes API 从 ConfigMap 访问配置数据。但是，与 Spring Boot 外部配置机制直接集成 Kubernetes ConfigMap 更为方便，因此 Kubernetes ConfigMap 的行为是 Spring Boot 配置的替代属性源。这基本上是 Spring Cloud Kubernetes 插件提供的内容。

11.1.4. 启用带有 Kubernetes 的 Spring Boot

您可以通过将 Kubernetes 集成作为 Maven 依赖项添加到 pom.xml 文件来启用 Kubernetes 集成。

流程

  1. 通过将以下 Maven 依赖项添加到 Spring Boot Maven 项目的 pom.xml 文件中来启用 Kubernetes 集成。

    Copy to Clipboard Toggle word wrap 
    <project ...>
  ...
  <dependencies>
    ...
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-kubernetes-config</artifactId>
    </dependency>
    ...
  </dependencies>
  ...
</project>

  2. 要完成集成，

    • 在 Java 源代码中添加一些注解
    • 创建 Kubernetes ConfigMap 对象
    • 修改 OpenShift 服务帐户权限，以允许您的应用程序读取 ConfigMap 对象。

其他资源

11.2. 运行 ConfigMap 属性源的教程

以下教程允许您试验设置 Kubernetes Secret 和 ConfigMap。按照 Enabling Spring Boot with Kubernetes Integration 所述，启用 Spring Cloud Kubernetes 插件，以将 Kubernetes 配置对象与 Spring Boot Externalized Configuration 集成。

11.2.1. 运行 Spring Boot Camel Config quickstart

以下教程基于 spring-boot-camel-config-archetype Maven archetype，它可让您设置 Kubernetes Secret 和 ConfigMap。

流程

  1. 打开新的 shell 提示符，再输入以下 Maven 命令来创建简单的 Camel Spring Boot 项目。

    Copy to Clipboard Toggle word wrap 
    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
  -DarchetypeCatalog=https://maven.repository.redhat.com/ga/io/fabric8/archetypes/archetypes-catalog/2.2.0.fuse-sb2-780040-redhat-00002/archetypes-catalog-2.2.0.fuse-sb2-780040-redhat-00002-archetype-catalog.xml \
  -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
  -DarchetypeArtifactId=spring-boot-camel-config-archetype \
  -DarchetypeVersion=2.2.0.fuse-sb2-780040-redhat-00002

    archetype 插件切换到交互模式以提示您输入剩余的字段：

    Copy to Clipboard Toggle word wrap 
    Define value for property 'groupId': : org.example.fis
Define value for property 'artifactId': : fuse78-configmap
Define value for property 'version':  1.0-SNAPSHOT: :
Define value for property 'package':  org.example.fis: :
Confirm properties configuration:
groupId: org.example.fis
artifactId: fuse78-configmap
version: 1.0-SNAPSHOT
package: org.example.fis
Y: : Y

    出现提示时，为 groupId 值输入 org.example.fis，为 artifactId 值输入 fuse78-configmap。接受剩余的字段的默认值。

  2. 登录 OpenShift 并切换到您要部署应用的 OpenShift 项目。例如，若要以 developer 用户身份登录并部署到 openshift 项目，请输入以下命令：

    Copy to Clipboard Toggle word wrap 
    oc login -u developer -p developer
oc project openshift

  3. 在命令行中，更改到 new fuse78-configmap 项目的目录，再为此应用创建 Secret 对象。

    Copy to Clipboard Toggle word wrap 
    cd fuse78-configmap
oc create -f sample-secret.yml
    注意

    在部署应用程序前，需要创建 Secret 对象，否则部署的容器会进入等待状态，直到 Secret 变为可用。如果您随后创建 Secret，则容器将退出等待状态。有关如何设置 Secret 对象的更多信息，请参阅设置 Secret。

  4. 构建和部署快速入门应用程序。从 fuse78-configmap 项目的顶层，输入：

    Copy to Clipboard Toggle word wrap 
    mvn fabric8:deploy -Popenshift

  5. 按如下所示查看应用日志：

    1. 在浏览器中打开 OpenShift Web 控制台(https://OPENSHIFT_IP_ADDR，将 OPENSHIFT_IP_ADDR 替换为集群的 IP 地址)，并使用您的凭证登录控制台（例如，使用用户名 developer 和密码 developer）。
    2. 在左侧面板中，展开 Home。点 Status 查看 Project Status 页面。此时会显示所选命名空间中的所有现有应用程序（如 openshift）。
    3. 单击 fuse78-configmap，以查看快速启动的 Overview 信息页面。
    4. 在左侧面板中，展开 Workloads。
    5. 单击 Pods，然后单击 fuse78-configmap-xxxx。此时会显示应用程序的 Pod 详情。
    6. 点 Logs 选项卡查看应用程序日志。

  6. 默认接收者列表（在 src/main/resources/application.properties 中配置）将生成的消息发送到两个 dummy 端点： direct:async-queue 和 direct:file。这会导致类似以下内容的信息写入应用程序日志中：

    Copy to Clipboard Toggle word wrap 
    5:44:57.377 [Camel (camel) thread #0 - timer://order] INFO  generate-order-route - Generating message message-44, sending to the recipient list
15:44:57.378 [Camel (camel) thread #0 - timer://order] INFO  target-route-queue - ----> message-44 pushed to an async queue (simulation)
15:44:57.379 [Camel (camel) thread #0 - timer://order] INFO  target-route-queue - ----> Using username 'myuser' for the async queue
15:44:57.380 [Camel (camel) thread #0 - timer://order] INFO  target-route--file - ----> message-44 written to a file

  7. 在使用 ConfigMap 对象更新 fuse78-configmap 应用程序配置前，您必须提供 fuse78-configmap 应用程序权限来查看 OpenShift ApiServer 的数据。输入以下命令为 fuse78-configmap 应用程序的服务帐户授予 view 权限：

    Copy to Clipboard Toggle word wrap 
    oc policy add-role-to-user view system:serviceaccount:openshift:qs-camel-config
    注意

    服务帐户通过语法 system:serviceaccount:PROJECT_NAME:SERVICE_ACCOUNT_NAME 来指定。fis-config 部署描述符将 SERVICE_ACCOUNT_NAME 定义为 qs-camel-config。

  8. 要查看操作中的实时重新加载功能，请按如下所示创建一个 ConfigMap 对象：

    Copy to Clipboard Toggle word wrap 
    oc create -f sample-configmap.yml

    新的 ConfigMap 覆盖正在运行的应用程序中 Camel 路由的接收者列表，将其配置为将生成的消息发送到 三个 dummy 端点： direct:async-queue、direct:file，以及 direct:mail。如需有关 ConfigMap 对象的更多信息，请参阅设置 ConfigMap。这会导致类似以下内容的信息写入应用程序日志中：

    Copy to Clipboard Toggle word wrap 
    16:25:24.121 [Camel (camel) thread #0 - timer://order] INFO  generate-order-route - Generating message message-9, sending to the recipient list
16:25:24.124 [Camel (camel) thread #0 - timer://order] INFO  target-route-queue - ----> message-9 pushed to an async queue (simulation)
16:25:24.125 [Camel (camel) thread #0 - timer://order] INFO  target-route-queue - ----> Using username 'myuser' for the async queue
16:25:24.125 [Camel (camel) thread #0 - timer://order] INFO  target-route--file - ----> message-9 written to a file (simulation)
16:25:24.126 [Camel (camel) thread #0 - timer://order] INFO  target-route--mail - ----> message-9 sent via mail

11.2.2. 配置属性 bean

配置属性 bean 是可通过注入接收配置设置的常规 Java Bean。它提供了 Java 代码和外部配置机制之间的基本接口。

外部化配置和 Bean Registry

下图显示了 Spring Boot Externalized Configuration 如何在 spring-boot-camel-config quickstart 中工作。

kube spring boot 01

配置机制有以下主要部分：

属性源
提供注入配置的属性设置。默认属性源是应用程序的 application.properties 文件，这可以选择被 ConfigMap 对象或 Secret 对象覆盖。
配置属性 Bean
从属性源接收 configuraton 更新。配置属性 bean 是 @Configuration 和 @ConfigurationProperties 注释的 Java Bean。
Spring bean registry
使用 requisite 注解时，在 Spring bean registry 中注册了一个配置属性 Bean。
与 Camel bean registry 集成
Camel bean registry 会自动与 Spring bean registry 集成，以便在 Camel 路由中引用注册的 Spring Bean。

QuickstartConfiguration 类

fuse78-configmap 项目的配置属性 bean 定义为 QuickstartConfiguration Java 类（在 src/main/java/org/example/fis/ 目录下），如下所示：

Copy to Clipboard Toggle word wrap 
package org.example.fis;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
1 

@ConfigurationProperties(prefix = "quickstart")
2 

public class QuickstartConfiguration {

    /**
     * A comma-separated list of routes to use as recipients for messages.
     */
    private String recipients;
3 


    /**
     * The username to use when connecting to the async queue (simulation)
     */
    private String queueUsername;
4 


    /**
     * The password to use when connecting to the async queue (simulation)
     */
    private String queuePassword;
5 


    // Setters and Getters for Bean properties
    // NOT SHOWN
    ...
}
1
@Configuration 注释会导致 QuickstartConfiguration 类在 Spring 中实例化和注册，作为 ID 为 quickstartConfiguration 的 bean。这会自动使 bean 可从 Camel 访问。例如，target-route-queue 路由可以使用 Camel 语法 ${bean:quickstartConfiguration?method=getQueueUsername} 访问 queueUserName 属性。
2
@ConfigurationProperties 注释定义一个前缀 Quickstart，该前缀在属性源中定义属性值时必须使用。例如，属性文件将 recipients 属性引用为 quickstart.recipients。
3
recipient 属性可从属性源注入。
4
queueUsername 属性可从属性源注入。
5
queuePassword 属性可从属性源注入。

11.2.3. 设置 Secret

此快速入门中的 Kubernetes Secret 以标准方式设置，除了一个额外步骤外：Spring Cloud Kubernetes 插件必须使用 Secret 的挂载路径进行配置，以便在运行时读取 Secret。设置 Secret：

  1. 创建 Sample Secret 对象
  2. 为 Secret 配置卷挂载
  3. 将 spring-cloud-kubernetes 配置为读取 Secret 属性

Secret 对象示例

Quickstart 项目提供了一个示例 Secret sample-secret.yml，如下所示：Secret 对象中的属性值始终采用 base64 编码（使用 base64 命令行工具）。当 Secret 挂载到 pod 的文件系统中时，这些值会自动解码为纯文本。

sample-secret.yml 文件

Copy to Clipboard Toggle word wrap 
apiVersion: v1
kind: Secret
metadata:
1 

  name: camel-config
type: Opaque
data:
  # The username is 'myuser'
  quickstart.queue-username: bXl1c2VyCg==
2 

  quickstart.queue-password: MWYyZDFlMmU2N2Rm
3

1
metadata.name: 标识 Secret。OpenShift 系统的其他部分使用此标识符来引用 Secret。
2
quickstart.queue-username ：旨在注入 QuickstartConfiguration bean 的 queueUsername 属性。该值必须 采用 base64 编码。
3
quickstart.queue-password ：旨在注入到 quickstartConfiguration bean 的 queuePassword 属性中。该值必须 采用 base64 编码。
注意

Kubernetes 不允许在 CamelCase 中定义属性名称（需要属性名称才能都是小写）。要临时解决这个问题，请使用连字符格式 queue-username，Spring Boot 与 queueUsername 匹配。这利用 Spring Boot 的 relaxed 绑定规则 进行外部化配置。

为 Secret 配置卷挂载

应用程序必须配置为在运行时加载 Secret，方法是将 Secret 配置为卷挂载。应用程序启动后，Secret 属性就会在文件系统中指定的位置可用。应用的 deployment.yml 文件位于 src/main/fabric8/ 目录下，后者定义 Secret 的卷挂载。

deployment.yml 文件

Copy to Clipboard Toggle word wrap 
spec:
  template:
    spec:
      serviceAccountName: "qs-camel-config"
      volumes:
1 

        - name: "camel-config"
          secret:
            # The secret must be created before deploying this application
            secretName: "camel-config"
      containers:
        -
          volumeMounts:
2 

            - name: "camel-config"
              readOnly: true
              # Mount the secret where spring-cloud-kubernetes is configured to read it
              # see src/main/resources/bootstrap.yml
              mountPath: "/etc/secrets/camel-config"
          resources:
#            requests:
#              cpu: "0.2"
#              memory: 256Mi
#            limits:
#              cpu: "1.0"
#              memory: 256Mi
             env:
              - name: SPRING_APPLICATION_JSON
               value: '{"server":{"undertow":{"io-threads":1, "worker-threads":2 }}}'

1
在 volumes 部分中，部署会声明一个名为 camel-config 的新卷，它引用名为 camel-config 的 Secret。
2
在 volumeMounts 部分中，部署声明一个新的卷挂载，它引用了 camel-config 卷，并指定 Secret 卷应挂载到 pod 文件系统的路径 /etc/secrets/camel-config 中。

配置 spring-cloud-kubernetes 来读取 Secret 属性

要将 secret 与 Spring Boot 外部化配置集成，必须使用 secret 的挂载路径配置 Spring Cloud Kubernetes 插件。Spring Cloud Kubernetes 从指定的位置读取 secret，并使其可用于 Spring Boot 作为属性源。Spring Cloud Kubernetes 插件由 bootstrap.yml 文件中的设置进行配置，位于 Quickstart 项目中的 src/main/resources 下。

bootstrap.yml 文件

Copy to Clipboard Toggle word wrap 
# Startup configuration of Spring-cloud-kubernetes
spring:
  application:
    name: camel-config
  cloud:
    kubernetes:
      reload:
        # Enable live reload on ConfigMap change (disabled for Secrets by default)
        enabled: true
      secrets:
        paths: /etc/secrets/camel-config

spring.cloud.kubernetes.secrets.paths 属性指定 pod 中 secret 卷挂载的路径列表。

注意

bootstrap.properties 文件（或 bootstrap.yml 文件）的行为与 application.properties 文件类似，但它会在应用程序启动的早期阶段载入。在 bootstrap.properties 文件中设置与 Spring Cloud Kubernetes 插件相关的属性更可靠。

11.2.4. 设置 ConfigMap

除了创建 ConfigMap 对象并正确设置 view 权限外，与 Spring Cloud Kubernetes 集成还需要您将 ConfigMap 的 metadata.name 与项目的 bootstrap.yml 文件中配置的 spring.application.name 属性的值匹配。设置 ConfigMap：

  • 创建示例 ConfigMap 对象
  • 设置查看权限
  • 配置 Spring Cloud Kubernetes 插件

ConfigMap 对象示例

Quickstart 项目提供一个示例 ConfigMap sample-configmap.yml。

Copy to Clipboard Toggle word wrap 
kind: ConfigMap
apiVersion: v1
metadata:
1 

  # Must match the 'spring.application.name' property of the application
  name: camel-config
data:
  application.properties: |
2 

    # Override the configuration properties here
    quickstart.recipients=direct:async-queue,direct:file,direct:mail
3
1
metadata.name: 标识 ConfigMap。OpenShift 系统的其他部分使用此标识符来引用 ConfigMap。
2
data.application.properties ：本节列出了属性设置，可覆盖使用应用程序部署的原始 application.properties 文件中的设置。
3
quickstart.recipients ：旨在注入到 quickstartConfiguration bean 的 receivers 属性中。

设置查看权限

如 Secret 的 deployment.yml 文件所示，serviceAccountName 在项目的 deployment.yml 文件中被设置为 qs-camel-config。因此，您需要输入以下命令来启用快速启动应用程序的 查看 权限（假设它部署到 测试 项目命名空间中）：

Copy to Clipboard Toggle word wrap 
oc policy add-role-to-user view system:serviceaccount:test:qs-camel-config

配置 Spring Cloud Kubernetes 插件

Spring Cloud Kubernetes 插件由 bootstrap.yml 文件中的以下设置配置。

spring.application.name
这个值必须与 ConfigMap 对象的 metadata.name 匹配（例如，在 Quickstart 项目中的 sample-configmap.yml 中定义）。默认为 应用程序。
spring.cloud.kubernetes.reload.enabled
把它设置为 true 可启用 ConfigMap 对象的动态重新加载。

有关支持的属性的更多详细信息，请参阅 PropertySource Reload Configuration Properties。

11.3. 使用 ConfigMap PropertySource

Kubernetes 具有将配置传递给应用程序的 ConfigMap 的概念。Spring cloud Kubernetes 插件提供与 ConfigMap 集成，使配置映射可以被 Spring Boot 访问。

启用后 ConfigMap PropertySource 将查找 Kubernetes 查找应用程序命名的 ConfigMap （请参阅 spring.application.name）。如果找到了映射，它将读取其数据并执行以下操作：

11.3.1. 应用单个属性

假设我们有一个名为 demo 的 Spring Boot 应用程序，它使用属性来读取其线程池配置。

  • pool.size.core
  • pool.size.max

这可以以 YAML 格式外部化到配置映射：

Copy to Clipboard Toggle word wrap 
kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  pool.size.core: 1
  pool.size.max: 16

11.3.2. 应用 application.yaml ConfigMap 属性

对于大多数情况来说，单个属性可以正常工作，但有时我们找到 YAML 更为方便。在这种情况下，我们使用一个名为 application.yaml 的单个属性，并在其中嵌入 YAML：

Copy to Clipboard Toggle word wrap 
kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  application.yaml: |-
    pool:
      size:
        core: 1
        max:16

11.3.3. 应用 application.properties ConfigMap 属性

您还可以在 Spring Boot application.properties 文件的样式中定义 ConfigMap 属性。在这种情况下，我们使用名为 application.properties 的单个属性，并列出其中的属性设置：

Copy to Clipboard Toggle word wrap 
kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  application.properties: |-
    pool.size.core: 1
    pool.size.max: 16

11.3.4. 部署 ConfigMap

要部署 ConfigMap 并使其可以被 Spring Boot 应用程序访问，请执行以下步骤。

流程

  1. 在 Spring Boot 应用程序中，使用 外部化配置机制 来访问 ConfigMap 属性源。例如，通过注解带有 @Configuration 注释的 Java Bean，bean 的属性值可以被 ConfigMap 注入。
  2. 在项目的 bootstrap.properties 文件中（或 bootstrap.yaml 文件），将 spring.application.name 属性设置为与 ConfigMap 的名称匹配。

  3. 对与应用程序关联的服务帐户启用 查看 权限（默认情况下，这是名为 default的服务帐户）。例如，要在 default 服务帐户中添加 view 权限：

    Copy to Clipboard Toggle word wrap 
    oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default -n $(oc project -q)

11.4. 使用 Secrets PropertySource

Kubernetes 具有用于存储敏感数据的 secret 的概念，如密码、OAuth 令牌等。Spring cloud Kubernetes 插件提供与 Secret 集成，使 secret 可以被 Spring Boot 访问。

启用时的 Secrets 属性源将从以下源中查找 Kubernetes 的 Secret。如果找到 secret，则应用程序可使用其数据。

  1. 从 secret 挂载递归读取
  2. 在应用程序后命名（请参阅 spring.application.name）
  3. 匹配某些标签

请注意，默认情况下，通过 API （上面的点 2 和 3）消耗 Secret 不会被启用。

11.4.1. 设置 Secret 的示例

假设我们有一个名为 demo 的 Spring Boot 应用，它使用属性来读取其 ActiveMQ 和 PostreSQL 配置。

Copy to Clipboard Toggle word wrap 
amq.username
amq.password
pg.username
pg.password

这些 secret 可以外部化为 YAML 格式的 Secret ：

ActiveMQ 机密
Copy to Clipboard Toggle word wrap 
apiVersion: v1
kind: Secret
metadata:
  name: activemq-secrets
  labels:
    broker: activemq
type: Opaque
data:
  amq.username: bXl1c2VyCg==
  amq.password: MWYyZDFlMmU2N2Rm
PostreSQL Secret
Copy to Clipboard Toggle word wrap 
apiVersion: v1
kind: Secret
metadata:
  name: postgres-secrets
  labels:
    db: postgres
type: Opaque
data:
  pg.username: dXNlcgo=
  pg.password: cGdhZG1pbgo=

11.4.2. 消耗 secret

您可以以多种方式选择要使用的 Secret：

  • 通过列出 secret 映射的目录：

    Copy to Clipboard Toggle word wrap 
    -Dspring.cloud.kubernetes.secrets.paths=/etc/secrets/activemq,etc/secrets/postgres

    如果您有所有 secret 都映射到一个通用 root，您可以设置它们，如下所示：

    Copy to Clipboard Toggle word wrap 
    -Dspring.cloud.kubernetes.secrets.paths=/etc/secrets

  • 通过设置命名的 secret:

    Copy to Clipboard Toggle word wrap 
    -Dspring.cloud.kubernetes.secrets.name=postgres-secrets

  • 通过定义标签列表：

    Copy to Clipboard Toggle word wrap 
    -Dspring.cloud.kubernetes.secrets.labels.broker=activemq
-Dspring.cloud.kubernetes.secrets.labels.db=postgres

11.4.3. Secrets PropertySource 的配置属性

您可以使用以下属性配置 Secrets 属性源：

spring.cloud.kubernetes.secrets.enabled
启用 Secrets 属性源。type 是 布尔值，默认为 true。
spring.cloud.kubernetes.secrets.name
设置要查找的机密的名称。type 为 String，默认为 ${spring.application.name}。
spring.cloud.kubernetes.secrets.labels
设置用于查找 secret 的标签。此属性的行为由 基于映射的绑定 定义。类型为 java.util.Map，默认为 null。
spring.cloud.kubernetes.secrets.paths
设置挂载 secret 的路径。此属性的行为由 基于集合的绑定 定义。类型为 java.util.List，默认为 null。
spring.cloud.kubernetes.secrets.enableApi
通过 API 启用/禁用消耗 secret。type 是 布尔值，默认为 false。
注意

由于安全原因，可以通过 API 访问 secret，因为安全原因是，将 secret 挂载到 POD。

11.5. 使用 PropertySource Reload

有些应用程序可能需要检测外部属性源的更改，并更新其内部状态以反映新的配置。Spring Cloud Kubernetes 的 reload 功能可以在相关的 ConfigMap 或 Secret 更改时触发应用程序重新加载。

11.5.1. 启用 PropertySource Reload

Spring Cloud Kubernetes 的 PropertySource reload 功能被默认禁用。

流程

  1. 进入 Quickstart 项目的 src/main/resources 目录，再打开 bootstrap.yml 文件。
  2. 更改配置属性 spring.cloud.kubernetes.reload.enabled=true。

11.5.2. PropertySource Reload 的级别

属性 spring.cloud.kubernetes.reload.strategy 支持以下重新加载级别：

refresh

（默认） 仅重新加载使用 @ConfigurationProperties 或 @RefreshScope 注解的配置 Bean。此重新加载级别利用 Spring Cloud Context 的刷新功能。

注意

当 reload 策略被设置为 刷新 时，PropertySource reload 功能只能用于 简单 属性（即，而不是集合）。由集合支持的属性不能在运行时更改。

restart_context
整个 Spring ApplicationContext 已安全重启。Bean 使用新配置重新创建。
shutdown
Spring ApplicationContext 被关闭以激活容器重启。在使用此级别时，请确保所有非守护进程线程的生命周期都绑定到 ApplicationContext，并且复制控制器或副本集已配置为重启 pod。

11.5.3. PropertySource Reload 示例

以下示例解释了启用重新加载功能时会发生什么。

流程

  1. 假设使用默认设置(刷新 模式)启用了重新加载功能。配置映射更改时将刷新以下 bean：

    Copy to Clipboard Toggle word wrap 
    @Configuration
@ConfigurationProperties(prefix = "bean")
public class MyConfig {

    private String message = "a message that can be changed live";

    // getter and setters

}

  2. 要查看发生的更改，请创建另一个 bean，以定期打印消息，如下所示。

    Copy to Clipboard Toggle word wrap 
    @Component
public class MyBean {

    @Autowired
    private MyConfig config;

    @Scheduled(fixedDelay = 5000)
    public void hello() {
        System.out.println("The message is: " + config.getMessage());
    }
}

  3. 您可以使用 ConfigMap 更改应用程序打印的消息，如下所示。

    Copy to Clipboard Toggle word wrap 
    apiVersion: v1
kind: ConfigMap
metadata:
  name: reload-example
data:
  application.properties: |-
    bean.message=Hello World!

    对与 pod 关联的 Config Map 中名为 bean.message 的属性的任何更改都会反映在程序的输出中。

11.5.4. PropertySource Reload 操作模式

reload 功能支持两种操作模式：

event
（默认） 监视使用 Kubernetes API (Web 套接字)的 ConfigMap 或 secret 的更改。在更改时，任何事件都会对配置生成重新检查，并重新加载。要侦听配置映射更改，需要服务帐户的 view 角色。更高级别的角色（例如，secret 需要编辑）（默认情况下不监控secrets）。
轮询
从配置映射和 secret 定期重新创建配置，以查看它是否已更改。可以使用属性 spring.cloud.kubernetes.reload.period 配置轮询周期，默认为 15 秒。它需要与 monitored 属性源相同的角色。例如，在文件挂载的 secret 源上使用轮询不需要特定的特权。

11.5.5. PropertySource Reload 配置属性

以下属性可用于配置重新载入功能：

spring.cloud.kubernetes.reload.enabled
启用对属性源和配置重新加载的监控。type 是 布尔值，默认为 false。
spring.cloud.kubernetes.reload.monitoring-config-maps
允许配置映射中的监控更改。type 是 布尔值，默认为 true。
spring.cloud.kubernetes.reload.monitoring-secrets
允许监控 secret 中的更改。type 是 布尔值，默认为 false。
spring.cloud.kubernetes.reload.strategy
触发重新加载时使用的策略(刷新、restart_context、关闭)。type 为 Enum，默认为 refresh。
spring.cloud.kubernetes.reload.mode
指定如何侦听属性源中的更改(事件、轮询)。type 为 Enum，默认为 event。
spring.cloud.kubernetes.reload.period
使用 轮询 策略时验证更改的时间（以毫秒为单位）。type 为 Long，默认为 15000。

请注意以下几点：

  • spring.cloud.kubernetes.reload SetConfiguration 属性不应在 ConfigMap 或 Secret 中使用。在运行时更改这些属性可能会导致意外的结果；
  • 删除属性或整个配置映射在使用 刷新 级别时不会恢复 Bean 的原始状态。

第 12 章 为 Karaf 镜像开发应用程序

本教程介绍了如何为 Karaf 镜像创建和部署应用。

12.1. 使用 Maven archetype 创建 Karaf 项目

要使用 Maven archetype 创建 Karaf 项目，请按照以下步骤操作：

流程

  1. 进入您系统上的相应目录。

  2. 启动 Maven 命令以创建 Karaf 项目

    Copy to Clipboard Toggle word wrap 
    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
  -DarchetypeCatalog=https://maven.repository.redhat.com/ga/io/fabric8/archetypes/archetypes-catalog/2.2.0.fuse-sb2-780040-redhat-00002/archetypes-catalog-2.2.0.fuse-sb2-780040-redhat-00002-archetype-catalog.xml \
  -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
  -DarchetypeArtifactId=karaf-camel-log-archetype \
  -DarchetypeVersion=2.2.0.fuse-sb2-780040-redhat-00002

  3. archetype 插件切换到交互模式以提示您输入剩余的字段

    Copy to Clipboard Toggle word wrap 
    Define value for property 'groupId': : org.example.fis
Define value for property 'artifactId': : fuse78-karaf-camel-log
Define value for property 'version':  1.0-SNAPSHOT: :
Define value for property 'package':  org.example.fis: :
Confirm properties configuration:
groupId: org.example.fis
artifactId: fuse78-karaf-camel-log
version: 1.0-SNAPSHOT
package: org.example.fis
 Y: : Y

    出现提示时，为 groupId 值输入 org.example.fis，为 artifactId 值输入 fuse78-karaf-camel-log。接受剩余的字段的默认值。

  4. 如果上述命令以 BUILD SUCCESS 状态退出，则现在应在 fuse78-karaf-camel-log 子目录下具有 OpenShift 项目的 Fuse。

  5. 您现在已准备好构建和部署 fuse78-karaf-camel-log 项目。假设您仍然登录 OpenShift，请更改到 fuse78-karaf-camel-log 项目的目录，然后构建和部署项目，如下所示：

    Copy to Clipboard Toggle word wrap 
    cd fuse78-karaf-camel-log
mvn fabric8:deploy -Popenshift
注意

有关 available Karaf archetypes 的完整列表，请参阅 Karaf Archetype Catalog。

12.2. Camel Karaf 应用程序的结构

Camel Karaf 应用程序的目录结构如下：

Copy to Clipboard Toggle word wrap 
  ├── pom.xml
1 

  ├── README.md
  ├── configuration
  │   └── settings.xml
  └── src
      ├── main
      │   ├── fabric8
      │   │   └── deployment.yml
2 

      │   ├── java
      │   │   └── org
      │   │       └── example
      │   │           └── fis
      │   └── resources
      │       ├── assembly
      │       │   └── etc
      │       │       └── org.ops4j.pax.logging.cfg
3 

      │       └── OSGI-INF
      │           └── blueprint
      │               └── camel-log.xml
4 

      └── test
          └── java
              └── org
                  └── example
                      └── fis

以下文件对于开发 JSF 应用程序非常重要：

1
pom.xml ：包含其他依赖项。您可以在 pom.xml 文件中添加依赖项，例如，您可以使用 SLF4J 记录。
Copy to Clipboard Toggle word wrap 
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
    </dependency>
2
src/main/fabric8/deployment.yml ：提供与 fabric8-maven-plugin 生成的默认 OpenShift 配置文件合并的额外配置。
注意

此文件不用作 Karaf 应用的一部分，但所有快速入门中都用于限制 CPU 和内存使用情况等资源。

3
org.ops4j.pax.logging.cfg: Demonstrates 如何自定义日志级别，将日志记录级别设置为 DEBUG，而不是默认的 INFO。
4
camel-log.xml ：包含应用程序的源代码。

12.3. Karaf archetype 目录

Karaf archetype 目录包括以下示例。

表 12.1. Karaf Maven Archetypes
Name描述

karaf-camel-amq-archetype

演示如何使用 Camel amq 组件向 Apache ActiveMQ 消息代理发送和接收消息。

karaf-camel-log-archetype

演示一个简单的 Apache Camel 应用程序，每 5 秒将消息记录到服务器日志中。

karaf-camel-rest-sql-archetype

演示如何通过 JDBC 和 Camel 的 REST DSL 使用 SQL 来公开 RESTful API。

karaf-cxf-rest-archetype

演示如何使用 CXF 创建 RESTful (JAX-RS) Web 服务，并通过 OSGi HTTP 服务公开该服务。

12.4. 使用 Fabric8 Karaf 功能

Fabric8 提供对 Apache Karaf 的支持，使其更轻松地为 Kubernetes 开发 OSGi 应用。

Fabric8 的重要特性如下：

  • 在蓝图 XML 文件中解析占位符的不同策略。
  • 环境变量
  • 系统属性
  • 服务
  • Kubernetes ConfigMap
  • Kubernetes Secret
  • 使用 Kubernetes 配置映射动态更新 OSGi 配置管理。
  • 为 OSGi 服务提供 Kubernetes 热检查。

12.4.1. 添加 Fabric8 Karaf 功能

要使用功能，请将 fabric8-karaf-features 依赖项添加到项目 POM 文件中。

流程

  1. 打开项目的 pom.xml 文件，并添加 fabric8-karaf-features 依赖项。
Copy to Clipboard Toggle word wrap 
<dependency>
  <groupId>io.fabric8</groupId>
  <artifactId>fabric8-karaf-features</artifactId>
  <version>${fabric8.version}</version>
  <classifier>features</classifier>
  <type>xml</type>
</dependency>

fabric8 karaf 功能将安装到 Karaf 服务器中。

12.4.2. 添加 Fabric8 Karaf 核心捆绑包功能

捆绑包 fabric8-karaf-core 提供 Blueprint 和 ConfigAdmin 扩展所使用的功能。

流程

  1. 打开项目的 pom.xml，并将 fabric8-karaf-core 添加到 startupFeatures 部分。

    Copy to Clipboard Toggle word wrap 
    <startupFeatures>
  ...
  <feature>fabric8-karaf-core</feature>
  ...
</startupFeatures>

    这将在自定义 Karaf 分发中添加 fabric8-karaf-core 功能。

12.4.3. 设置 Property Placeholder 服务选项

捆绑包 fabric8-karaf-core 会使用以下接口导出服务 PlaceholderResolver ：

Copy to Clipboard Toggle word wrap 
public interface PlaceholderResolver {
    /**
     * Resolve a placeholder using the strategy indicated by the prefix
     *
     * @param value the placeholder to resolve
     * @return the resolved value or null if not resolved
     */
    String resolve(String value);

    /**
     * Replaces all the occurrences of variables with their matching values from the resolver using the given source string as a template.
     *
     * @param source the string to replace in
     * @return the result of the replace operation
     */
    String replace(String value);

    /**
     * Replaces all the occurrences of variables within the given source builder with their matching values from the resolver.
     *
     * @param value the builder to replace in
     * @rerurn true if altered
     */
    boolean replaceIn(StringBuilder value);

    /**
     * Replaces all the occurrences of variables within the given dictionary
     *
     * @param dictionary the dictionary to replace in
     * @rerurn true if altered
     */
    boolean replaceAll(Dictionary<String, Object> dictionary);

    /**
     * Replaces all the occurrences of variables within the given dictionary
     *
     * @param dictionary the dictionary to replace in
     * @rerurn true if altered
     */
    boolean replaceAll(Map<String, Object> dictionary);
}

PlaceholderResolver 服务充当不同属性占位符解析策略的收集器。默认情况下，它提供的解析策略列在表 解析策略 中。要设置属性占位符服务选项，您可以使用系统属性或环境变量或两者。

流程

  1. 要访问 OpenShift 上的 ConfigMap，服务帐户需要查看权限。为服务帐户添加查看权限。

    Copy to Clipboard Toggle word wrap 
    oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default -n $(oc project -q)
  2. 将 secret 挂载到 Pod，因为通过 API 访问 secret 可能会被限制。

  3. Pod 上作为卷挂载提供的 secret 映射到名为 secret 的目录，如下所示

    Copy to Clipboard Toggle word wrap 
    containers:
  -
   env:
   - name: FABRIC8_K8S_SECRETS_PATH
     value: /etc/secrets
     volumeMounts:
   - name: activemq-secret-volume
     mountPath: /etc/secrets/activemq
     readOnly: true
   - name: postgres-secret-volume
     mountPath: /etc/secrets/postgres
     readOnly: true

volumes:
  - name: activemq-secret-volume
  secret:
  secretName: activemq
  - name: postgres-secret-volume
   secret:
  secretName: postgres

12.4.4. 添加自定义属性占位符解析器

您可以添加自定义占位符解析器来支持特定的需求，如自定义加密。您还可以使用 PlaceholderResolver 服务使解析器可用于 Blueprint 和 ConfigAdmin。

流程

  1. 将以下 mvn 依赖项添加到项目 pom.xml 中。

    pom.xml

    Copy to Clipboard Toggle word wrap 
    ---
<dependency>
  <groupId>io.fabric8</groupId>
  <artifactId>fabric8-karaf-core</artifactId>
</dependency>
---

  2. 实施 PropertiesFunction 接口，并使用 SCR 将它注册为 OSGi 服务。

    Copy to Clipboard Toggle word wrap 
    import io.fabric8.karaf.core.properties.function.PropertiesFunction;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.ConfigurationPolicy;
import org.apache.felix.scr.annotations.Service;

@Component(
    immediate = true,
    policy = ConfigurationPolicy.IGNORE,
    createPid = false
)
@Service(PropertiesFunction.class)
public class MyPropertiesFunction implements PropertiesFunction {
    @Override
    public String getName() {
        return "myResolver";
    }

    @Override
    public String apply(String remainder) {
        // Parse and resolve remainder
        return remainder;
    }
}

  3. 您可以在 Configuration management 中引用解析器，如下所示：

    属性

    Copy to Clipboard Toggle word wrap 
    my.property = $[myResolver:value-to-resolve]

12.4.5. 解析策略列表

PlaceholderResolver 服务充当不同属性占位符解析策略的收集器。表中列出了它默认提供的解析策略。

  1. 解析策略列表

prefix

Example

描述

env

env:JAVA_HOME

从 OS 环境变量中查找属性。

'sys

sys:java.version

查找 Java JVM 系统属性中的 属性。

'service

service:amq

使用服务命名约定，从 OS 环境变量查找属性。

service.host

service.host:amq

使用服务命名约定仅返回 hostname 部分，从 OS 环境变量中查找属性。

service.port

service.port:amq

使用服务命名约定仅返回端口部分，从 OS 环境变量中查找属性。

k8s:map

k8s:map:myMap/myKey

从 Kubernetes ConfigMap （通过 API）中查找属性。

k8s:secret

k8s:secret:amq/password

从 Kubernetes Secret （通过 API 或卷挂载）中查找属性。

12.4.6. Property Placeholder 服务选项列表

属性占位符服务支持以下选项：

  1. 属性占位符服务选项列表
Namedefault描述

fabric8.placeholder.prefix

$[

占位符的前缀

fabric8.placeholder.suffix

]

占位符的后缀

fabric8.k8s.secrets.path

null

以逗号分隔的 secret 的路径列表

fabric8.k8s.secrets.api.enabled

false

通过 API 启用/禁用消耗 secret

12.5. 添加 Fabric8 Karaf 配置管理员支持

12.5.1. 添加 Fabric8 Karaf 配置管理员支持

您可以将 Fabric8 Karaf 配置管理员支持添加到自定义 Karaf 分发中。

流程

  • 打开项目的 pom.xml，并将 fabric8-karaf-cm 添加到 startupFeatures 部分。

    pom.xml

    Copy to Clipboard Toggle word wrap 
    <startupFeatures>
  ...
  <feature>fabric8-karaf-cm</feature>
  ...
</startupFeatures>

12.5.2. 添加 ConfigMap 注入

fabric8-karaf-cm 提供了一个 ConfigAdmin 网桥，该网桥在 Karaf 的 ConfigAdmin 中注入 ConfigMap 值。

流程

  1. 要由 ConfigAdmin 网桥添加，必须使用 karaf.pid 标记 ConfigMap。karaf.pid 值对应于组件的 pid。例如，

    Copy to Clipboard Toggle word wrap 
    kind: ConfigMap
apiVersion: v1
metadata:
  name: myconfig
  labels:
    karaf.pid: com.mycompany.bundle
data:
  example.property.1: my property one
  example.property.2: my property two

  2. 要定义配置，您可以使用单个属性名称。单个属性适用于大多数情况。它与 karaf/etc 中的 pid 文件相同。例如，

    Copy to Clipboard Toggle word wrap 
    kind: ConfigMap
apiVersion: v1
metadata:
  name: myconfig
  labels:
    karaf.pid: com.mycompany.bundle
data:
  com.mycompany.bundle.cfg: |
    example.property.1: my property one
    example.property.2: my property two

12.5.3. 配置插件

fabric8-karaf-cm 提供了一个 ConfigurationPlugin，用于解析配置属性占位符。

要使用 fabric8-karaf-cm 插件启用属性替换，您必须将 Java 属性 fabric8.config.plugin.enabled 设置为 true。例如，您可以使用 Karaf 镜像中的 JAVA_OPTIONS 环境变量设置此属性，如下所示：

Copy to Clipboard Toggle word wrap 
JAVA_OPTIONS=-Dfabric8.config.plugin.enabled=true

12.5.4. config Property Placeholders

配置属性占位符示例如下所示：

my.service.cfg

Copy to Clipboard Toggle word wrap 
    amq.usr = $[k8s:secret:$[env:ACTIVEMQ_SERVICE_NAME]/username]
    amq.pwd = $[k8s:secret:$[env:ACTIVEMQ_SERVICE_NAME]/password]
    amq.url = tcp://$[env+service:ACTIVEMQ_SERVICE_NAME]

my-service.xml

Copy to Clipboard Toggle word wrap 
    <?xml version="1.0" encoding="UTF-8"?>

    <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.1.0"
               xsi:schemaLocation="
                 http://www.osgi.org/xmlns/blueprint/v1.0.0
                 https://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd
                 http://camel.apache.org/schema/blueprint
                 http://camel.apache.org/schema/blueprint/camel-blueprint.xsd">

      <cm:property-placeholder persistent-id="my.service" id="my.service" update-strategy="reload"/>

      <bean id="activemq" class="org.apache.activemq.camel.component.ActiveMQComponent">
         <property name="userName"  value="${amq.usr}"/>
         <property name="password"  value="${amq.pwd}"/>
         <property name="brokerURL" value="${amq.url}"/>
      </bean>
    </blueprint>

12.5.5. Fabric8 Karaf 配置管理员选项

Fabric8 Karaf Config Admin 支持以下选项：

Namedefault描述

fabric8.config.plugin.enabled

false

启用 ConfigurationPlugin

fabric8.cm.bridge.enabled

true

启用 ConfigAdmin 网桥

fabric8.config.watch

true

启用监视 ConfigMap 更改

fabric8.config.merge

false

在 ConfigAdmin 中启用合并 ConfigMap 值

fabric8.config.meta

true

在 ConfigAdmin 网桥中启用注入 ConfigMap meta

fabric8.pid.label

karaf.pid

定义 ConfigAdmin 网桥查找的标签（即，需要选择的 ConfigMap 必须具有该标签；该值决定了它所关联的 PID）

fabric8.pid.filters

empty

为 ConfigAdmin 网桥定义额外的条件，以选择 ConfigMap。支持的语法为：

  • 不同标签上的条件由 "," 分隔，旨在相互分隔。
  • 在标签内，分号(;)被视为 OR，并可用作标签值中条件的分隔符。

例如，一个类似 -Dfabric8.pid.filters=appName=A;B,database.name=my.oracle.datasource 的过滤器转换为 "give me the label appName，值为 A 或 B，标签 database.name 等于 my.oracle.datasource"。

重要

ConfigurationPlugin 需要 Aries Blueprint CM 1.0.9 或更高版本。

12.6. 添加 Fabric8 Karaf 蓝图支持

fabric8-karaf-blueprint 使用来自 fabric8-karaf-core 的 Aries PropertyEvaluator 和属性占位符解析器来解析蓝图 XML 文件中的占位符。

流程

  • 要在自定义 Karaf 分发中包含蓝图支持的功能，请将 fabric8-karaf-blueprint 添加到项目 pom.xml 中的 startupFeatures 部分。

    Copy to Clipboard Toggle word wrap 
    <startupFeatures>
  ...
  <feature>fabric8-karaf-blueprint</feature>
  ...
</startupFeatures>

Example

fabric8 evaluators 支持串联的 evaluators，如 ${env+service:MY_ENV_VAR}。您需要针对环境变量解析 MY_ENV_VAR 变量。然后，使用服务功能解决结果。例如，

Copy to Clipboard Toggle word wrap 
<?xml version="1.0" encoding="UTF-8"?>

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:ext="http://aries.apache.org/blueprint/xmlns/blueprint-ext/v1.2.0"
           xsi:schemaLocation="
             http://www.osgi.org/xmlns/blueprint/v1.0.0
             https://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd
             http://camel.apache.org/schema/blueprint
             http://camel.apache.org/schema/blueprint/camel-blueprint.xsd
             http://aries.apache.org/blueprint/xmlns/blueprint-ext/v1.3.0
             http://aries.apache.org/schemas/blueprint-ext/blueprint-ext-1.3.xsd">

  <ext:property-placeholder evaluator="fabric8" placeholder-prefix="$[" placeholder-suffix="]"/>

  <bean id="activemq" class="org.apache.activemq.camel.component.ActiveMQComponent">
     <property name="userName"  value="$[k8s:secret:$[env:ACTIVEMQ_SERVICE_NAME]/username]"/>
     <property name="password"  value="$[k8s:secret:$[env:ACTIVEMQ_SERVICE_NAME]/password]"/>
     <property name="brokerURL" value="tcp://$[env+service:ACTIVEMQ_SERVICE_NAME]"/>
  </bean>
</blueprint>
重要

嵌套属性占位符替换需要 Aries Blueprint Core 1.7.0 或更高版本。

12.7. 启用 Fabric8 Karaf 健康检查

建议将 fabric8-karaf-checks 安装为启动功能。启用后，您的 Karaf 服务器就可以公开 http://0.0.0.0:8181/readiness-check 和 http://0.0.0.0:8181/health-check URL，它们可供 Kubernetes 用于就绪度和存活度探测。

注意

只有满足以下条件时，这些 URL 才会响应 HTTP 200 状态代码：

  • OSGi 框架已经启动。
  • 所有 OSGi 捆绑包都已启动。
  • 所有引导功能都已安装。
  • 所有部署的 BluePrint 捆绑包都处于创建的状态。
  • 所有部署的 SCR 捆绑包都处于 active、registered 或 factory 状态。
  • 所有 Web 捆绑包都部署到 web 服务器。
  • 所有创建的 Camel 上下文都处于 started 状态。

流程

  1. 打开项目的 pom.xml，并在 startupFeatures 部分中添加 fabric8-karaf-checks 功能。

    pom.xml

    Copy to Clipboard Toggle word wrap 
    <startupFeatures>
  ...
  <feature>fabric8-karaf-checks</feature>
  ...
</startupFeatures>

    fabric8-maven-plugin:resources 目标将检测您使用 fabric8-karaf-checks 功能，并将 Kubernetes 就绪度和存活度探测自动添加到您的容器的配置中。

12.7.1. 配置健康检查

默认情况下，fabric8-karaf-checks 端点注册到在端口 8181 上运行的内置 HTTP 服务器引擎(Undertow)中。为避免健康检查请求被容器中其他长时间运行的 HTTP 进程阻止，端点可以注册到单独的 Undertow 容器中。

这些检查可通过设置以下属性在 etc/io.fabric8.checks.cfg 文件中配置：

  • httpPort ：如果指定此属性，并且是有效的端口号，则 readiness-check 和 health-check 端点将被注册到 Undertow 服务器的独立实例中
  • readinessCheckPath 和 healthCheckPath 属性允许您配置可用于就绪度和健康检查的实际 URI。默认情况下，它们与前面的值相同。
注意

这些属性可以在启动 Fuse-Karaf 后更改，但也可以在 etc/io.fabric8.checks.cfg 文件中指定，该文件是想要让 fabric8-karaf-checks 功能在开箱即用状态的客户使用。

以下示例演示了 etc/io.fabric8.checks.cfg 文件中的健康和就绪属性的配置：

Example

Copy to Clipboard Toggle word wrap 
httpPort = 8182
readinessCheckPath = /readiness-check
healthCheckPath = /health-check

12.8. 添加自定义健康检查

您可以提供额外的自定义 heath 检查，以防止 Karaf 服务器在用户准备好处理请求前接收用户流量。要启用自定义健康检查，您需要实施 io.fabric8.karaf.checks.HealthChecker 或 io.fabric8.karaf.checks.ReadinessChecker 接口，并在 OSGi 注册表中注册这些对象。

流程

  • 将以下 mvn 依赖项添加到项目 pom.xml 文件中。

    pom.xml

    Copy to Clipboard Toggle word wrap 
    <dependency>
  <groupId>io.fabric8</groupId>
  <artifactId>fabric8-karaf-checks</artifactId>
</dependency>

    注意

    在 OSGi 注册表中创建和注册对象的最简单方法是使用 SCR。

Example

一个执行健康检查的示例，以确保您有一些可用磁盘空间，如下所示：

Copy to Clipboard Toggle word wrap 
import io.fabric8.karaf.checks.*;
import org.apache.felix.scr.annotations.*;
import org.apache.commons.io.FileSystemUtils;
import java.util.Collections;
import java.util.List;

@Component(
    name = "example.DiskChecker",
    immediate = true,
    enabled = true,
    policy = ConfigurationPolicy.IGNORE,
    createPid = false
)
@Service({HealthChecker.class, ReadinessChecker.class})
public class DiskChecker implements HealthChecker, ReadinessChecker {

    public List<Check> getFailingReadinessChecks() {
        // lets just use the same checks for both readiness and health
        return getFailingHeathChecks();
    }

    public List<Check> getFailingHealthChecks() {
        long free = FileSystemUtils.freeSpaceKb("/");
        if (free < 1024 * 500) {
            return Collections.singletonList(new Check("disk-space-low", "Only " + free + "kb of disk space left."));
        }
        return Collections.emptyList();
    }
}

第 13 章 为 JBoss EAP 镜像开发应用程序

要在 JBoss EAP 上开发 Fuse 应用程序，替代方案是使用 S2I 源工作流为带有 EAP 的 Red Hat Camel CDI 创建 OpenShift 项目。

先决条件

13.1. 使用 S2I 源工作流创建 JBoss EAP 项目

要在 JBoss EAP 上开发 Fuse 应用程序，替代方案是使用 S2I 源工作流为带有 EAP 的 Red Hat Camel CDI 创建 OpenShift 项目。

流程

  1. 将 view 角色添加到 default 服务帐户以启用集群。这会授予用户对 default 服务帐户的 view 访问权限。每个项目都需要服务帐户来运行构建、部署和其他容器集。在 shell 提示符中输入以下 oc 客户端命令：

    Copy to Clipboard Toggle word wrap 
    oc login -u developer -p developer
oc policy add-role-to-user view -z default

  2. 查看 OpenShift 模板上安装的 Fuse。

    Copy to Clipboard Toggle word wrap 
    oc get template -n openshift

  3. 输入以下命令创建使用 EAP quickstart 运行 Red Hat Fuse 7.8 Camel CDI 所需的资源。它为快速启动创建部署配置和构建配置。有关快速启动和创建的资源的信息显示在终端上。

    Copy to Clipboard Toggle word wrap 
    oc new-app s2i-fuse78-eap-camel-cdi

--> Creating resources ...
    service "s2i-fuse78-eap-camel-cdi" created
    service "s2i-fuse78-eap-camel-cdi-ping" created
    route.route.openshift.io "s2i-fuse78-eap-camel-cdi" created
    imagestream.image.openshift.io "s2i-fuse78-eap-camel-cdi" created
    buildconfig.build.openshift.io "s2i-fuse78-eap-camel-cdi" created
    deploymentconfig.apps.openshift.io "s2i-fuse78-eap-camel-cdi" created
--> Success
    Access your application via route 's2i-fuse78-eap-camel-cdi-OPENSHIFT_IP_ADDR'
    Build scheduled, use 'oc logs -f bc/s2i-fuse78-eap-camel-cdi' to track its progress.
    Run 'oc status' to view your app.
  4. 在浏览器中打开 OpenShift Web 控制台(https://OPENSHIFT_IP_ADDR，将 OPENSHIFT_IP_ADDR 替换为集群的 IP 地址)，并使用您的凭证登录控制台（例如，使用用户名 developer 和密码 developer）。
  5. 在左侧面板中，展开 Home。点 Status 查看 Project Status 页面。此时会显示所选命名空间中的所有现有应用程序（如 openshift）。

  6. 单击 s2i-fuse78-eap-camel-cdi 以查看快速启动的 Overview 信息页面。

    eap image s2i source 08

  7. 单击 Resources 选项卡，然后单击 Routes 部分中显示的链接来访问应用程序。

    eap image s2i source 07

    该链接的格式是 http://s2i-fuse78-eap-camel-cdi-OPENSHIFT_IP_ADDR。在您的浏览器中显示类似如下的信息：

    Copy to Clipboard Toggle word wrap 
    Hello world from 172.17.0.3

  8. 您还可以使用 URL 中的 name 参数指定一个名称。例如，如果您在浏览器中输入 URL http://s2i-fuse78-eap-camel-cdi-openshift.apps.cluster-name.openshift.com/?name=jdoe，您会看到响应：

    Copy to Clipboard Toggle word wrap 
    Hello jdoe from 172.17.0.3
  9. 单击 View Logs 以查看应用的日志。

  10. 关闭正在运行的 pod，

    1. 单击 Overview 选项卡，以返回到应用的概览信息页面。
    2. 点 Desired Count 旁边的 图标。此时会显示 Edit Count 窗口。
    3. 使用向下箭头向下扩展到零，以停止 pod。

13.2. JBoss EAP 应用程序的结构

您可以使用 EAP 示例找到 Red Hat Fuse 7.8 Camel CDI 的源代码，位于以下位置：

Copy to Clipboard Toggle word wrap 
https://github.com/wildfly-extras/wildfly-camel-examples/tree/wildfly-camel-examples-5.2.0.fuse-720021/camel-cdi

EAP 应用程序上 Camel 的目录结构如下：

Copy to Clipboard Toggle word wrap 
  ├── pom.xml
  ├── README.md
  ├── configuration
  │   └── settings.xml
  └── src
      └── main
          ├── java
          │   └── org
          │       └── wildfly
          │           └── camel
          │               └── examples
          │                   └── cdi
          │                       └── camel
          │                           ├── MyRouteBuilder.java
          │                           ├── SimpleServlet.java
          │                           └── SomeBean.java
          └── webapp
              └── WEB-INF
                  └── beans.xml

以下文件对于开发 JBoss EAP 应用程序非常重要：

pom.xml
包括其他依赖项。

13.3. JBoss EAP 快速入门模板

以下 S2I 模板为 JBoss EAP 上的 Fuse 提供：

表 13.1. JBoss EAP S2I 模板
Name描述

带有 EAP 的 JBoss Fuse 7.8 Camel A-MQ (eap-camel-amq-template)

演示使用 camel-activemq 组件连接到 OpenShift 中运行 AMQ 消息代理。假设代理已经部署。

Red Hat Fuse 7.8 Camel CDI with EAP (eap-camel-cdi-template)

演示使用 camel-cdi 组件将 CDI Bean 与 Camel 路由集成。

Red Hat Fuse 7.8 CXF JAX-RS with EAP (eap-camel-cxf-jaxrs-template)

演示使用 camel-cxf 组件生成和使用 JAX-RS REST 服务。

Red Hat Fuse 7.8 CXF JAX-WS with EAP (eap-camel-cxf-jaxws-template)

演示使用 camel-cxf 组件生成和使用 JAX-WS Web 服务。

第 14 章 在 OpenShift 上的 Fuse 中使用持久性存储

OpenShift 应用的 Fuse 基于 OpenShift 容器，没有持久文件系统。每次启动应用程序时，会在带有不可变 Docker 格式镜像的新容器中启动它。因此，文件系统中的任何持久数据都会在容器停止时丢失。但是，应用程序需要将一些状态存储为持久性存储中的数据，有时应用程序共享对通用数据存储的访问。OpenShift 平台支持将外部存储置备为持久性存储。

14.1. 关于卷和卷类型

OpenShift 允许 Pod 和容器作为由多个本地或网络附加存储端点支持的文件系统来 挂载卷。

卷类型包括：

  • emptyDir （空目录）：这是默认卷类型。它是在本地主机上创建 pod 时分配的目录。它不会在服务器间复制，并在删除 pod 时删除该目录。
  • ConfigMap：它是一个目录，其中包含从命名 configmap 中填充了键值对的目录。
  • hostpath （主机目录）：它是具有任何主机上特定路径的目录，它需要升级的特权。
  • Secret （挂载 secret）： Secret 卷将命名 secret 挂载到提供的目录中。
  • PersistentVolumeClaim 或 pvc （持久性卷声明）：这会将容器中的卷目录链接到您按名称分配的持久性卷声明。持久性卷声明是分配存储的请求。请注意，如果您的声明没有绑定，您的 pod 不会启动。

卷在 Pod 级别上配置，只能使用 hostPath 直接访问外部存储。因此，难以将多个 Pod 共享资源作为 hostPath 卷进行管理。

14.2. 关于 PersistentVolume

通过 PersistentVolume，集群管理员可以调配由各种类型的网络存储（如 NFS、Ceph RBD、AWS Elastic Block Store (EBS)）支持的集群范围的存储。PersistentVolume 还指定容量、访问模式和循环策略。这允许来自多个项目的 pod 访问持久性存储，而无需担心底层资源的性质。

14.3. 

流程

  1. Copy to Clipboard Toggle word wrap 
    apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv0001
spec:
  accessModes:
    - ReadWriteOnce
  capacity:
    storage: 2Mi
  hostPath:
    path: /data/pv0001/

  2. Copy to Clipboard Toggle word wrap 
    oc create -f pv.yaml

  3. Copy to Clipboard Toggle word wrap 
    oc get pv

14.4. 

流程

  • Copy to Clipboard Toggle word wrap 
    apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc0001
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Mi

14.5. 

流程

  1. Copy to Clipboard Toggle word wrap 
    spec:
  template:
    spec:
      containers:
        - volumeMounts:
          - name: vol0001
            mountPath: /usr/share/data
      volumes:
        - name: vol0001
          persistentVolumeClaim:
            claimName: pvc0001

  2. Copy to Clipboard Toggle word wrap 
    mvn fabric8:resource-apply

  3. Copy to Clipboard Toggle word wrap 
    oc describe deploymentconfig <application-dc-name>

第 15 章 

15.1. 

15.2. 

  • fuse7-java-openshift
  • fuse7-karaf-openshift
  • fuse7-eap-openshift
  • fuse7-console
  • apicurito-ui
  • fuse-apicurito-generator

流程

  1. Copy to Clipboard Toggle word wrap 
    $ oc get is -n openshift
NAME                           DOCKER REPO                                          TAGS                                    UPDATED
fuse7-console                  172.30.1.1:5000/openshift/fuse7-console              1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8     About an hour ago
fuse7-eap-openshift            172.30.1.1:5000/openshift/fuse7-eap-openshift        1.0,1.1,1.2,,1.3,1.4,1.5,1.6,1.7,1.8    About an hour ago
fuse7-java-openshift           172.30.1.1:5000/openshift/fuse7-java-openshift       1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8     About an hour ago
fuse7-karaf-openshift          172.30.1.1:5000/openshift/fuse7-karaf-openshift      1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8     About an hour ago
fuse-apicurito-generator       172.30.1.1:5000/openshift/fuse-apicurito-generator   1.2,1.3,1.4,1.5,1.6,1.7,1.8             About an hour ago
apicurito-ui                   172.30.1.1:5000/openshift/apicurito-ui               1.2,1.3,1.4,1.5,1.6,1.7,1.8             About an hour ago

  2. Copy to Clipboard Toggle word wrap 
    oc import-image -n openshift fuse7-java-openshift:1.8
oc import-image -n openshift fuse7-karaf-openshift:1.8
oc import-image -n openshift fuse7-eap-openshift:1.8
oc import-image -n openshift fuse7-console:1.8
oc import-image -n openshift apicurito-ui:1.8
oc import-image -n openshift fuse-apicurito-generator:1.8
注意

注意

15.3. 

流程

  1. Copy to Clipboard Toggle word wrap 
    oc login URL -u ADMIN_USER -p ADMIN_PASS

  2. Copy to Clipboard Toggle word wrap 
    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-780019-redhat-00005
oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-amq-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-cdi-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-cxf-jaxrs-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-cxf-jaxws-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-camel-amq-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-camel-log-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-camel-rest-sql-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-cxf-rest-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-amq-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-config-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-drools-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-infinispan-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-xml-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-cxf-jaxrs-template.json
oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-cxf-jaxws-template.json
    注意

15.4. 

15.4.1. 

Copy to Clipboard Toggle word wrap 
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

    <fuse.version>7.8.0.fuse-sb2-780038-redhat-00001</fuse.version>
    ...
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>fuse-springboot-bom</artifactId>
        <version>${fuse.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  ...
  <build>
    ...
    <plugins>
      <!-- Core plugins -->
      ...
      <plugin>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        ...
        <version>${fuse.version}</version>
      </plugin>
    </plugins>
  </build>

  <profiles>
    <profile>
      <id>openshift</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.jboss.redhat-fuse</groupId>
            <artifactId>fabric8-maven-plugin</artifactId>
            ...
            <version>${fuse.version}</version>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
</project>

15.4.2. 

Copy to Clipboard Toggle word wrap 
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <fuse.version>7.8.0.fuse-sb2-780038-redhat-00001</fuse.version>
    ...
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>fuse-karaf-bom</artifactId>
        <version>${fuse.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  ...
  <build>
    ...
    <plugins>
      ...
      <plugin>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>karaf-maven-plugin</artifactId>
        <version>${fuse.version}</version>
        ...
      </plugin>
      ...
      <plugin>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>fabric8-maven-plugin</artifactId>
        <version>${fuse.version}</version>
        ...
      </plugin>
    </plugins>
  </build>

</project>

15.4.3. 

Copy to Clipboard Toggle word wrap 
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <fuse.version>7.8.0.fuse-sb2-780038-redhat-00001</fuse.version>
    ...
  </properties>

  <!-- Dependency Management -->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>fuse-eap-bom</artifactId>
        <version>${fuse.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  ...
</project>

15.5. 

表 15.1. 
  

Red Hat Fuse 7.8 GA

7.8.0.fuse-sb2-780038-redhat-00001

7.0.1.fuse-000008-redhat-4

附录 A. 

A.1. 

A.2. 

A.2.1. 

Example

Copy to Clipboard Toggle word wrap 
<project>
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.redhat.fuse</groupId>
  <artifactId>spring-boot-camel</artifactId>
  <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <!-- configure the Fuse version you want to use here -->
        <fuse.bom.version>7.8.0.fuse-sb2-780038-redhat-00001</fuse.bom.version>

        <!-- maven plugin versions -->
        <maven-compiler-plugin.version>3.7.0</maven-compiler-plugin.version>
        <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>
    </properties>


    <build>
        <defaultGoal>spring-boot:run</defaultGoal>

        <plugins>
            <plugin>
                <groupId>org.jboss.redhat-fuse</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${fuse.bom.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>redhat-ga-repository</id>
            <url>https://maven.repository.redhat.com/ga</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>redhat-ea-repository</id>
            <url>https://maven.repository.redhat.com/earlyaccess/all</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>redhat-ga-repository</id>
            <url>https://maven.repository.redhat.com/ga</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>redhat-ea-repository</id>
            <url>https://maven.repository.redhat.com/earlyaccess/all</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>

附录 B. 

B.1. 

B.2. 

  • Example

    Copy to Clipboard Toggle word wrap 
    <libraries>
    <library>mvn:org.postgresql/postgresql/9.3-1102-jdbc41;type:=endorsed</library>
</libraries>

B.3. 

B.3.1. 

注意

Example

Copy to Clipboard Toggle word wrap 
<plugin>
  <groupId>org.jboss.redhat-fuse</groupId>
  <artifactId>karaf-maven-plugin</artifactId>
  <version>${fuse.version}</version>
  <extensions>true</extensions>
  <executions>
    <execution>
      <id>karaf-assembly</id>
      <goals>
        <goal>assembly</goal>
      </goals>
      <phase>install</phase>
    </execution>
  </executions>
  <configuration>

    <karafVersion>{karafMavenPluginVersion}</karafVersion>
    <useReferenceUrls>true</useReferenceUrls>
    <archiveTarGz>false</archiveTarGz>
    <includeBuildOutputDirectory>false</includeBuildOutputDirectory>
    <startupFeatures>
      <feature>karaf-framework</feature>
            </startupFeatures>
            <bootFeatures>
      <feature>shell</feature>
      <feature>jaas</feature>
      <feature>aries-blueprint</feature>
      <feature>camel-blueprint</feature>
      <feature>fabric8-karaf-blueprint</feature>
      <feature>fabric8-karaf-checks</feature>
    </bootFeatures>
    <bootBundles>
      <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
    </bootBundles>
  </configuration>
</plugin>

附录 C. 

C.1. 

重要

C.2. 

配置

C.3. 

流程

Copy to Clipboard Toggle word wrap 
<plugin>
  <groupId>org.jboss.redhat-fuse</groupId>
  <artifactId>fabric8-maven-plugin</artifactId>
  <version>${fuse.version}</version>

  <configuration>
     ....
     <images>
        <!-- A single's image configuration -->
        <image>
          ...
          <build>
           ....
          </build>
        </image>
        ....
     </images>
  </configuration>

  <!-- Connect fabric8:resource and fabric8:build to lifecycle phases -->
  <executions>
    <execution>
       <id>fabric8</id>
       <goals>
         <goal>resource</goal>
         <goal>build</goal>
       </goals>
    </execution>
  </executions>
</plugin>

C.4. 

C.4.1. 

表 C.1. 
目标描述

fabric8:build

fabric8:resource

fabric8:apply

表 C.2. 
目标描述

fabric8:deploy

fabric8:undeploy

fabric8:start

fabric8:stop

fabric8:log

fabric8:debug

fabric8:watch

C.4.2. 

例如，

Example

Copy to Clipboard Toggle word wrap 
<configuration>
  <resources>
    <env>
        <JAVA_OPTIONS>-Dmy.custom=option</JAVA_OPTIONS>
        <MY_VAR>value</MY_VAR>
    </env>
  </resources>
</configuration>

C.4.3. 

表 C.3. 
配置描述default

fabric8.skipResourceValidation

false

fabric8.failOnValidationError

false

fabric8.build.switchToDeployment

false

fabric8.openshift.trimImageInContainerSpec

false

C.5. 

注意

C.5.1. 

C.5.2. 

istag

Copy to Clipboard Toggle word wrap 
<namespace>/<image-stream-name>:<tag>

docker

Copy to Clipboard Toggle word wrap 
[<registry-location-url>/]<image-namespace>/<image-name>:<tag>

注意

C.5.2.1. 

Copy to Clipboard Toggle word wrap 
fuse7/fuse-eap-openshift:1.8
fuse7/fuse-java-openshift:1.8
fuse7/fuse-karaf-openshift:1.8
注意

C.5.2.2. 

Copy to Clipboard Toggle word wrap 
fuse7/fuse-eap-openshift:1.8
fuse7/fuse-java-openshift:1.8
fuse7/fuse-karaf-openshift:1.8
C.5.2.3. 

Example

Copy to Clipboard Toggle word wrap 
<configuration>
  <generator>
    <config>
      <spring-boot>
        <fromMode>{istag|docker}</fromMode>
        <from>{image locations}</from>
      </spring-boot>
    </config>
  </generator>
</configuration>

C.5.2.4. 

Example

Copy to Clipboard Toggle word wrap 
<configuration>
  <generator>
    <config>
      <karaf>
        <fromMode>{istag|docker}</fromMode>
        <from>{image locations}</from>
      </karaf>
    </config>
  </generator>
</configuration>

C.5.2.5. 

Example

Copy to Clipboard Toggle word wrap 
//build from Docker-formatted image directly, registry location, image name or tag are subject to change if desirable
-Dfabric8.generator.fromMode=docker
-Dfabric8.generator.from=<custom-registry-location-url>/<image-namespace>/<image-name>:<tag>

//to use ImageStream from different namespace
-Dfabric8.generator.fromMode=istag //istag is default
-Dfabric8.generator.from=<namespace>/<image-stream-name>:<tag>

C.5.3. Spring Boot

表 C.4. 
元素描述default

assemblyRef

 

targetDir

jolokiaPort

8778

mainClass

 

webPort

8080

color

 

C.5.4. 

表 C.5. 
元素描述default

baseDir

jolokiaPort

8778

mainClass

 

user

jboss:jboss:jboss

webPort

8080

附录 D. 

D.1. 

D.2. 

流程

  1. Copy to Clipboard Toggle word wrap 
    <plugin>
  <groupId>io.fabric8.forge</groupId>
  <artifactId>fabric8-camel-maven-plugin</artifactId>
  <version>2.3.90</version>
</plugin>

  2. Copy to Clipboard Toggle word wrap 
    mvn fabric8-camel:validate

Example

Copy to Clipboard Toggle word wrap 
<plugin>
  <groupId>io.fabric8.forge</groupId>
  <artifactId>fabric8-camel-maven-plugin</artifactId>
  <version>2.3.80</version>
  <executions>
    <execution>
      <phase>process-classes</phase>
    <goals>
      <goal>validate</goal>
    </goals>
    </execution>
  </executions>
</plugin>

Example

Copy to Clipboard Toggle word wrap 
<plugin>
  <groupId>io.fabric8.forge</groupId>
  <artifactId>fabric8-camel-maven-plugin</artifactId>
  <version>2.3.80</version>
  <executions>
    <execution>
      <configuration>
        <includeTest>true</includeTest>
      </configuration>
      <phase>process-test-classes</phase>
      <goals>
        <goal>validate</goal>
      </goals>
    </execution>
  </executions>
</plugin>

D.3. 

流程

  • Copy to Clipboard Toggle word wrap 
        $cd camel-example-cdi
    $mvn io.fabric8.forge:fabric8-camel-maven-plugin:2.3.80:validate

    Copy to Clipboard Toggle word wrap 
    [INFO] ------------------------------------------------------------------------
[INFO] Building Camel :: Example :: CDI 2.16.2
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- fabric8-camel-maven-plugin:2.3.80:validate (default-cli) @ camel-example-cdi ---
[INFO] Endpoint validation success: (4 = passed, 0 = invalid, 0 = incapable, 0 = unknown components)
[INFO] Simple validation success: (0 = passed, 0 = invalid)
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

Example

  1. Copy to Clipboard Toggle word wrap 
      @Uri("timer:foo?period=5000")

  2. Copy to Clipboard Toggle word wrap 
      @Uri("timer:foo?perid=5000")

  3. Copy to Clipboard Toggle word wrap 
    [INFO] ------------------------------------------------------------------------
[INFO] Building Camel :: Example :: CDI 2.16.2
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- fabric8-camel-maven-plugin:2.3.80:validate (default-cli) @ camel-example-cdi ---
[WARNING] Endpoint validation error at: org.apache.camel.example.cdi.MyRoutes(MyRoutes.java:32)

	timer:foo?perid=5000

	                   perid    Unknown option. Did you mean: [period]


[WARNING] Endpoint validation error: (3 = passed, 1 = invalid, 0 = incapable, 0 = unknown components)
[INFO] Simple validation success: (0 = passed, 0 = invalid)
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

D.4. 选项

表 D.1. 
参数默认值描述

downloadVersion

true

failOnError

false

logUnparseable

false

includeJava

true

includeXML

true

includeTest

false

includes

-

excludes

-

ignoreUnknownComponent

true

ignoreIncapable

true

ignoreLenientProperties

true

showAll

false

D.5. 

流程

Copy to Clipboard Toggle word wrap 
    $cd myproject
    $mvn io.fabric8.forge:fabric8-camel-maven-plugin:2.3.80:validate -DincludeTest=true

附录 E. 

E.1. 

E.2. 

流程

Copy to Clipboard Toggle word wrap 
s2i build <git repo url> registry.redhat.io/fuse7/fuse-karaf-openshift:1.6 <target image name>
docker run <target image name>

E.2.1. 

E.2.2. 

Copy to Clipboard Toggle word wrap 
`Karaf4: install karaf:assembly karaf:archive -DskipTests -e`

E.3. 

  • 默认值为 false。

E.4. 

  • 如果设置为 0，则无法根据内核数执行基础 JVM 调优。
  • JAVA_DIAGNOSTICS ：将其设置为获取一些诊断信息，以便在发生时进行标准。
  • JAVA_MAIN_CLASS ：用作 java 的参数的主类。当您使用此环境变量时，$JAVA_APP_DIR 目录中的所有 jar 文件都会添加到 classpath 和 $JAVA_LIB_DIR 目录中。
  • JAVA_APP_JAR ：具有适当清单的 jar 文件，以便您可以以 java -jar 开始。但是，如果没有提供它，则设置 $JAVA_MAIN_CLASS。在所有情况下，此 jar 文件都添加到 classpath 中。
  • JAVA_APP_NAME: 用于进程的名称。
  • JAVA_CLASSPATH ：要使用的类路径。如果没有指定，启动脚本会检查文件 ${JAVA_APP_DIR}/classpath，并将其内容用作 classpath。如果这个文件不存在，则应用程序目录中的所有 jar 都添加到 (classes:${JAVA_APP_DIR}/*) 下。
  • JAVA_DEBUG ：如果设置了，则会打开远程调试。
  • JAVA_DEBUG_PORT ：用于远程调试的端口。默认值为 5005。

E.5. Jolokia 配置

您可以在 Jolokia 中使用以下环境变量：

  • AB_JOLOKIA_OFF ：如果设置，则禁用 Jolokia 的激活(echos 为空值)。默认情况下启用 Jolokia。
  • AB_JOLOKIA_CONFIG ：如果设置了，则使用文件（包括路径）作为 Jolokia JVM 代理属性。但是，如果没有设置，则使用设置创建 /opt/jolokia/etc/jolokia.properties。
  • AB_JOLOKIA_HOST: 要绑定的主机地址（默认值为 0.0.0.0）
  • AB_JOLOKIA_PORT: 要使用的端口（默认值为 8778）
  • AB_JOLOKIA_USER ：用于基本身份验证的用户。默认情况下，它是 jolokia。
  • AB_JOLOKIA_PASSWORD ：用于基本身份验证的密码。默认情况下关闭身份验证。
  • AB_JOLOKIA_PASSWORD_RANDOM: 生成值，并写在 /opt/jolokia/etc/jolokia.pw 文件中。
  • AB_JOLOKIA_HTTPS ：切换与 HTTPS 的安全通信。默认情况下，如果没有在 AB_JOLOKIA_OPTS 中提供 serverCert 配置，则会生成自签名证书。
  • AB_JOLOKIA_ID: 代理 ID 要使用
  • AB_JOLOKIA_DISCOVERY_ENABLED ：启用 Jolokia 发现。默认值为 false。
  • AB_JOLOKIA_OPTS ：附加到代理配置中的附加选项。以 key=value 格式提供选项。

以下是与各种环境集成的选项：

  • AB_JOLOKIA_AUTH_OPENSHIFT ：切换 OpenShift TSL 通信的客户端身份验证。确保客户端证书中必须存在此参数的值。如果启用此参数，它将自动将 Jolokia 切换到 HTTPS 通信模式。默认 CA 证书设置为 /var/run/secrets/kubernetes.io/serviceaccount/ca.crt。

通过将变量 JAVA_ARGS 设置为对应的值，可以提供应用程序参数。

附录 F. 调整 JVM 在 Linux 容器中运行

当您允许 JVM ergonomics 为垃圾收集器、堆大小和运行时编译器设置默认值时，在 Linux 容器中运行的 Java 进程的行为不如预期。当您执行不带任何调优参数的 Java 应用程序时，例如： java -jar mypplication-fat.jar wagon-busyboxthe JVM 会自动根据主机限制设置多个参数，而不是 容器限制。

本节提供有关在 Linux 容器中打包 Java 应用程序的信息，以便考虑计算默认值时容器的限制。

F.1. 调整 JVM

当前的 Java JVM 代不是容器感知型，因此它们根据物理主机的大小来分配资源，而不是容器的大小。例如，JVM 通常将主机上物理内存的 最大堆大小 设置为 1/4。在大型主机上，这个值可以轻松地超过为容器定义的内存限值，如果在运行时超过容器限制，OpenShift 将终止该应用。

要解决这个问题，您可以使用 OpenShift 基础镜像上的 Fuse，该镜像可以了解 Java JVM 在受限容器中运行的，并在未手动完成时自动调整最大堆大小。它提供了为运行应用的 JVM 设置最大内存限值和核心限制的解决方案。对于 OpenShift 镜像上的 Fuse，它可以：

  • 根据容器内核设置 CICompilerCount
  • 当容器内存限制低于 300MB 时，禁用 C2 JIT 编译器
  • 低于 300MB 时，对默认堆大小使用一倍的容器内存限值

F.2. Fuse On OpenShift 镜像的默认行为

在 OpenShift 上的 Fuse 中，应用构建的基础镜像可以是 Java 镜像（适用于 Spring Boot 应用）或 Karaf 镜像（用于 Karaf 应用）。OpenShift 镜像上的 Fuse 执行可读取容器限值的脚本，并将这些限制用作分配资源的基础。默认情况下，脚本会将以下资源分配给 JVM：

  • 容器内存限值的 50%，
  • 容器内核限制 50%。

这有一些例外情况。对于 Karaf 和 Java 镜像，当物理内存低于 300MB 阈值时，堆大小将恢复到默认堆大小的一流，而不是一半。

F.3. 在 OpenShift 镜像上对 Fuse 进行定制调整

该脚本设置 CONTAINER_MAX_MEMORY 和 CONTAINER_CORE_LIMIT 环境变量，这些变量由自定义应用读取，以调优其内部资源。另外，您可以指定以下运行时环境变量，它们可让您自定义运行应用程序的 JVM 上的设置：

  • JAVA_OPTIONS
  • JAVA_MAX_MEM_RATIO

要显式自定义限制，您可以通过编辑 Maven 项目中的 deployment.yml 文件来设置 JAVA_MAX_MEM_RATIO 环境变量。

Example

Copy to Clipboard Toggle word wrap 
spec:
  template:
    spec:
      containers:
        -
          resources:
            requests:
              cpu: "0.2"
               memory: 256Mi
            limits:
              cpu: "1.0"
               memory: 256Mi
          env:
          - name: JAVA_MAX_MEM_RATIO
            value: 60

F.4. 调整第三方库

红帽建议您自定义任何第三方 Java 库的限制，如 Jetty。如果您无法手动自定义限制，这些库将使用给定的默认限值。启动脚本会公开一些环境变量描述容器限制，供应用程序使用：

CONTAINER_CORE_LIMIT
计算的内核限制
CONTAINER_MAX_MEMORY
容器提供的内存限值

法律通告

Copyright © 2024 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
返回顶部
Red Hat logoGithubredditYoutubeTwitter

学习

尝试、购买和销售

社区

关于红帽文档

通过我们的产品和服务，以及可以信赖的内容，帮助红帽用户创新并实现他们的目标。 了解我们当前的更新.

让开源更具包容性

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。欲了解更多详情，请参阅红帽博客.

關於紅帽

我们提供强化的解决方案，使企业能够更轻松地跨平台和环境（从核心数据中心到网络边缘）工作。

Theme

© 2025 Red Hat, Inc.