OpenShift 上的 Fuse 指南


Red Hat Fuse 7.4

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

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 服务器:

    oc login -u system:admin
    Copy to Clipboard Toggle word wrap
  2. 登录到您要安装镜像流的 OpenShift 项目。我们建议您将 openshift 项目用于 OpenShift 镜像流上的 Fuse。

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

    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
    Copy to Clipboard Toggle word wrap
    注意

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

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

    oc secrets link default <pull_secret_name> --for=pull
    Copy to Clipboard Toggle word wrap
  5. 要使用 secret 来推送和拉取构建镜像,该 secret 必须可在 pod 中挂载。要挂载 secret,请使用以下命令:

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

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

如需更多信息,请参阅:

OpenShift Container Platform 4.1 使用 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 服务器。

    oc login -u system:admin
    Copy to Clipboard Toggle word wrap
  3. 验证您是否使用创建了 docker-registry secret 的项目。

    oc project openshift
    Copy to Clipboard Toggle word wrap
  4. 查看 Samples operator 的当前配置。

    oc get configs.samples.operator.openshift.io -n openshift-cluster-samples-operator -o yaml
    Copy to Clipboard Toggle word wrap
  5. 配置 Samples operator 以忽略添加的 fuse 模板和镜像流。

    oc edit configs.samples.operator.openshift.io -n openshift-cluster-samples-operator
    Copy to Clipboard Toggle word wrap
  6. 将 Fuse 镜像流和模板分别添加到 Skipped Imagestreams 和 Skipped Templates 部分。

    [...]
    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-fuse74-eap-camel-amq
      - s2i-fuse74-eap-camel-cdi
      - s2i-fuse74-eap-camel-cxf-jaxrs
      - s2i-fuse74-eap-camel-cxf-jaxws
      - s2i-fuse74-eap-camel-jpa
      - s2i-fuse74-karaf-camel-amq
      - s2i-fuse74-karaf-camel-log
      - s2i-fuse74-karaf-camel-rest-sql
      - s2i-fuse74-karaf-cxf-rest
      - s2i-fuse74-spring-boot-camel
      - s2i-fuse74-spring-boot-camel-amq
      - s2i-fuse74-spring-boot-camel-config
      - s2i-fuse74-spring-boot-camel-drools
      - s2i-fuse74-spring-boot-camel-infinispan
      - s2i-fuse74-spring-boot-camel-rest-sql
      - s2i-fuse74-spring-boot-camel-xa
      - s2i-fuse74-spring-boot-camel-xml
      - s2i-fuse74-spring-boot-cxf-jaxrs
    Copy to Clipboard Toggle word wrap
  7. 在 OpenShift 镜像流上安装 Fuse。

    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-740025-redhat-00003
    
    oc create -n openshift -f ${BASEURL}/fis-image-streams.json
    Copy to Clipboard Toggle word wrap
  8. 安装 Quickstart 模板:

    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 \
     eap-camel-jpa-template.json \
     karaf-camel-amq-template.json \
     karaf-camel-log-template.json \
     karaf-camel-rest-sql-template.json \
     karaf-cxf-rest-template.json \
     spring-boot-camel-amq-template.json \
     spring-boot-camel-config-template.json \
     spring-boot-camel-drools-template.json \
     spring-boot-camel-infinispan-template.json \
     spring-boot-camel-rest-sql-template.json \
     spring-boot-camel-template.json \
     spring-boot-camel-xa-template.json \
     spring-boot-camel-xml-template.json \
     spring-boot-cxf-jaxrs-template.json \
     spring-boot-cxf-jaxws-template.json ;
     do
     oc create -n openshift -f \
     https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-740025-redhat-00003/quickstarts/${template}
     done
    Copy to Clipboard Toggle word wrap
  9. 安装 Fuse 控制台的模板。

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

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

  10. (可选) 查看 OpenShift 镜像和模板中安装的 Fuse:

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

Red Hat Fuse on OpenShift 提供了基于 Web 的 API 设计器 Apicurito,可用于设计 REST API。新的 Apicurito Operator 简化了 OpenShift Container Platform 4.1 的安装和升级过程。对于 Fuse 7.4,OperatorHub 中提供 Apicurito Operator。按照以下步骤安装 Operator。

先决条件

  • 您可以访问 OpenShift 服务器。
  • 您已为 Red Hat Container Registry 配置身份验证。

流程

  1. 启动 OpenShift 4.x 服务器。
  2. 在浏览器中打开 OpenShift 控制台。使用您的凭证登录到控制台。
  3. Catalog,然后点 OperatorHub
  4. 在搜索字段中输入 Apicurito,然后按 Enter 键。您可以在右侧面面板中看到 Apicurito Operator。
  5. Apicurito Operator。此时会显示 Apicurito Operator 安装窗口。
  6. Install。此时会显示 Create Operator Subscription 表单。表单有如下选项:

    • 安装模式
    • 更新频道
    • 批准策略.

      根据偏好选择,也可以保留默认值。

  7. Subscribe.Apicurito Operator 现在安装在所选命名空间中。
  8. 要验证,请单击 Catalog,然后单击 Installed Operator。您可以在列表中看到 Apicurito Operator。
  9. 点 Name 列中的 Apicurito Operator。单击 Provided APIs 下的 Create New。使用默认值创建新的自定义资源定义(CRD)。作为 CR 的一部分支持以下字段:

    • 大小:您 apicurito operator 将有多少个 pod。
    • 镜像:picurito 镜像。在现有安装中更改此镜像将触发 Operator 的升级。
  10. Create。这将创建一个新的 apicurito-service

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

流程

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

    oc login -u system:admin
    Copy to Clipboard Toggle word wrap
  3. 验证您是否使用创建了 docker-registry secret 的项目。

    oc project openshift
    Copy to Clipboard Toggle word wrap
  4. 在 OpenShift 镜像流上安装 Fuse。

    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-740025-redhat-00003
    
    oc create -n openshift -f ${BASEURL}/fis-image-streams.json
    Copy to Clipboard Toggle word wrap
  5. 安装 Quickstart 模板:

    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 \
     eap-camel-jpa-template.json \
     karaf-camel-amq-template.json \
     karaf-camel-log-template.json \
     karaf-camel-rest-sql-template.json \
     karaf-cxf-rest-template.json \
     spring-boot-camel-amq-template.json \
     spring-boot-camel-config-template.json \
     spring-boot-camel-drools-template.json \
     spring-boot-camel-infinispan-template.json \
     spring-boot-camel-rest-sql-template.json \
     spring-boot-camel-template.json \
     spring-boot-camel-xa-template.json \
     spring-boot-camel-xml-template.json \
     spring-boot-cxf-jaxrs-template.json \
     spring-boot-cxf-jaxws-template.json ;
     do
     oc create -n openshift -f \
     https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-740025-redhat-00003/quickstarts/${template}
     done
    Copy to Clipboard Toggle word wrap
  6. 安装 Fuse 控制台的模板。

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

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

  7. 安装 Apicurito 模板:

    oc create -n openshift -f ${BASEURL}/fuse-apicurito.yml
    Copy to Clipboard Toggle word wrap
  8. (可选) 查看 OpenShift 镜像和模板中安装的 Fuse:

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

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

先决条件

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

如需更多信息,请参阅:

流程

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

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

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

    注意

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

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

    oc new-project test
    Copy to Clipboard Toggle word wrap

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

    oc project test
    Copy to Clipboard Toggle word wrap
  3. 在 OpenShift 镜像流上安装 Fuse:

    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-740025-redhat-00003
    
    oc create -n test -f ${BASEURL}/fis-image-streams.json
    Copy to Clipboard Toggle word wrap

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

  4. 安装 Quickstart 模板。

    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 \
     eap-camel-jpa-template.json \
     karaf-camel-amq-template.json \
     karaf-camel-log-template.json \
     karaf-camel-rest-sql-template.json \
     karaf-cxf-rest-template.json \
     spring-boot-camel-amq-template.json \
     spring-boot-camel-config-template.json \
     spring-boot-camel-drools-template.json \
     spring-boot-camel-infinispan-template.json \
     spring-boot-camel-rest-sql-template.json \
     spring-boot-camel-template.json \
     spring-boot-camel-xa-template.json \
     spring-boot-camel-xml-template.json \
     spring-boot-cxf-jaxrs-template.json \
     spring-boot-cxf-jaxws-template.json ;
     do
     oc create -n test -f \
     ${BASEURL}/quickstarts/${template}
     done
    Copy to Clipboard Toggle word wrap
  5. 安装 Fuse 控制台的模板。

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

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

  6. (可选)查看 OpenShift 镜像和模板上安装的 Fuse。

    oc get template -n test
    Copy to Clipboard Toggle word wrap
  7. 在您的浏览器中,进入 OpenShift 控制台:

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

第 4 章 开发人员入门

4.1. 准备开发环境

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

4.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.4 支持的 Java 版本。有关支持的 Java 版本的详情,请参阅 支持的配置

流程

在本地机器上安装 CDK:

  1. 对于 OpenShift 上的 Fuse,我们建议您安装 CDK 的版本 3.9。Red Hat CDK 3.9 入门指南 中提供了安装和使用 CDK 3.9 的详细信息。
  2. 按照 配置 Red Hat Container Registry 身份验证 中的说明,配置 OpenShift 凭证以访问红帽容器 registry。
  3. 第 2 章 管理员入门 所述,在 OpenShift 镜像和模板上安装 Fuse。

    注意

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

  4. 在继续本章中的示例之前,您应该阅读并彻底理解 Red Hat CDK 3.9 入门指南 的内容。

4.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)以及您的帐户的登录凭据。

4.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 类型而异):

    $ 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)
    Copy to Clipboard Toggle word wrap

    如需了解更多详细信息,请参阅 CDK 3.9 入门指南中的使用 OpenShift 客户端二进制

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

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

    如需了解更多详细信息,请参阅 CDK 3.9 入门指南 中的 Reusing the docker Daemon

    重要

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

其它资源

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

4.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 存储库。

4.2. 在 OpenShift 的 Fuse 上创建和部署应用程序

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

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

4.2.1. 使用 S2I Binary 工作流创建和部署项目

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

流程

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

    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-740017-redhat-00003/archetypes-catalog-2.2.0.fuse-740017-redhat-00003-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=spring-boot-camel-xml-archetype \
      -DarchetypeVersion=2.2.0.fuse-740017-redhat-00003
    Copy to Clipboard Toggle word wrap

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

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse74-spring-boot
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    [INFO] Using property: spring-boot-version = 1.5.17.RELEASE
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse74-spring-boot
    version: 1.0-SNAPSHOT
    package: org.example.fis
    spring-boot-version: 1.5.17.RELEASE
     Y: :
    Copy to Clipboard Toggle word wrap

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

  2. 如果上一命令以 BUILD SUCCESS 状态退出,则现在应在 fuse74-spring-boot 子目录下具有 OpenShift 项目的 Fuse。您可以检查 fuse74-spring-boot/src/main/resources/spring/camel-context.xml 文件中的 XML DSL 代码。演示代码定义了一个简单的 Camel 路由,可持续向日志发送包含随机数的消息。
  3. 在准备在 OpenShift 项目中构建和部署 Fuse 时,请按如下所示登录 OpenShift 服务器:

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

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

    注意

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

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

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

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

  5. 创建名为 test 的新项目命名空间(假设它尚不存在),如下所示:

    oc new-project test
    Copy to Clipboard Toggle word wrap

    如果 test 项目命名空间已存在,您可以使用以下命令切换到该命名空间。

    oc project test
    Copy to Clipboard Toggle word wrap
  6. 您现在已准备好构建和部署 fuse74-spring-boot 项目。假设您仍然登录 OpenShift,请更改到 fuse74-spring-boot 项目的目录,然后进行构建和部署项目,如下所示:

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

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

    ...
    [INFO] OpenShift platform detected
    [INFO] Using project: test
    [INFO] Creating a Service from openshift.yml namespace test name fuse74-spring-boot
    [INFO] Created Service: target/fabric8/applyJson/test/service-fuse74-spring-boot.json
    [INFO] Using project: test
    [INFO] Creating a DeploymentConfig from openshift.yml namespace test name fuse74-spring-boot
    [INFO] Created DeploymentConfig: target/fabric8/applyJson/test/deploymentconfig-fuse74-spring-boot.json
    [INFO] Creating Route test:fuse74-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: 2019-02-22T12:08:11+01:00
    [INFO] Final Memory: 63M/272M
    [INFO] ------------------------------------------------------------------------
    Copy to Clipboard Toggle word wrap
    注意

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

  7. 在浏览器中打开 OpenShift 控制台,并使用您的凭据登录控制台(例如,使用用户名 developer 和密码 developer)。
  8. 在 OpenShift 控制台中,向下滚动以查找 test 项目命名空间。单击 test 项目,以打开 test 项目命名空间。此时会打开 test 项目的 Overview 选项卡,显示 fuse74-spring-boot 应用程序。
  9. 单击 fuse74-spring-boot 部署左侧的箭头,以展开并查看此部署的详细信息,如下所示。

    OpenShift console test namespace overview showing fuse74-spring-boot application and associated pods

  10. 单击容器集图标(blue circle)的数据中心,以查看 fuse74-spring-boot 的 pod 列表。

    List of pods associated with the fuse74-spring-boot service

  11. 单击 pod Name (本例中为 fuse74-spring-boot-1-kxdjm)以查看正在运行的 Pod 的详情。

    Detail view of the running pod for fuse74-spring-boot

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

    ...
    07:30:32.406 [Camel (camel) thread #0 - timer://foo] INFO  simple-route - >>> 985
    07:30:34.405 [Camel (camel) thread #0 - timer://foo] INFO  simple-route - >>> 741
    07:30:36.409 [Camel (camel) thread #0 - timer://foo] INFO  simple-route - >>> 796
    07:30:38.409 [Camel (camel) thread #0 - timer://foo] INFO  simple-route - >>> 211
    07:30:40.411 [Camel (camel) thread #0 - timer://foo] INFO  simple-route - >>> 511
    07:30:42.411 [Camel (camel) thread #0 - timer://foo] INFO simple-route - >>> 942
    Copy to Clipboard Toggle word wrap
  13. 单击左侧导航栏上的 Overview,以返回到 测试 命名空间中的应用程序概述。要关闭正在运行的 pod,点 pod 图标旁的向下箭头 get started s2i binary 05 。当对话框提示您输入问题 Scale down deployment fuse74-spring-boot-1? 时,单击 Scale Down
  14. (可选) 如果您使用 CDK,您可以通过返回到 shell 提示符并输入以下命令来完全关闭虚拟 OpenShift 服务器:

    minishift stop
    Copy to Clipboard Toggle word wrap

4.2.2. 取消部署和重新部署项目

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

流程

  • 要取消部署项目,请输入以下命令:

    mvn fabric8:undeploy
    Copy to Clipboard Toggle word wrap
  • 要重新部署项目,请输入以下命令:

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

4.2.3. 在 OpenShift 中设置 Fuse 控制台

在 OpenShift 中,您可以通过两种方式访问 Fuse 控制台:

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

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

注意
  • 在 OpenShift 4 上,如果要使用 Fuse 控制台管理 Fuse 7.4 服务,您必须安装社区版本(Hawtio),如 Fuse 7.4 发行注记 中所述。
  • Fuse 控制台的安全性和用户管理由 OpenShift 处理。
  • Fuse 控制台模板默认配置端到端加密,以便 Fuse 控制台请求是安全的端到端,从浏览器到集群内服务。
  • 基于角色的访问控制(用于部署 Fuse 控制台的用户)尚不可用于 OpenShift 上的 Fuse。

先决条件

  • 在 OpenShift 镜像流上安装 Fuse,以及 Fuse 控制台的模板,如 OpenShift 上的 Fuse 指南 中所述。
  • 如果要在 OpenShift Container Platform 环境中以集群模式部署 Fuse 控制台,则需要集群管理员角色和集群模式模板。运行以下命令:
oc adm policy add-cluster-role-to-user cluster-admin system:serviceaccount:openshift-infra:template-instance-controller
Copy to Clipboard Toggle word wrap
注意

默认情况下,集群模式模板仅在最新版本的 OpenShift Container Platform 上可用。它不是由 OpenShift Online 默认目录提供的。

4.2.3.1. 从 Fuse 控制台监控单个 Fuse pod

您可以为在 OpenShift 上运行的 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 端口:

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

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

流程

  1. 在 OpenShift 控制台中,打开现有项目或创建新项目。
  2. 将 Fuse 控制台添加到 OpenShift 项目中:

    1. 选择 Add to ProjectBrowse Catalog

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

    2. Search 字段中,键入 Fuse Console

      Red Hat Fuse 7.x ConsoleRed 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 控制台中的应用程序。

4.2.3.3. 从命令行部署 Fuse 控制台

表 4.1 “Fuse 控制台模板” 描述可用于从命令行访问 Fuse 控制台的两个 OpenShift 模板,具体取决于 Fuse 应用部署的类型。

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

cluster

使用需要创建 cluster-admin 角色的 OAuth 客户端。Fuse 控制台可以发现并连接到在多个命名空间或项目中部署的 Fuse 应用程序。

namespace

使用服务帐户作为 OAuth 客户端,它只需要在项目中创建 admin 角色。这会限制 Fuse 控制台访问此单一项目,例如充当单个租户部署。

另外,您可以运行以下命令来查看模板参数列表:

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

流程

从命令行部署 Fuse 控制台:

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

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

      oc new-app -n myproject -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-740025-redhat-00003/fis-console-cluster-template.json -p ROUTE_HOSTNAME=myhost
      Copy to Clipboard Toggle word wrap
    • 对于 Fuse Console 命名空间 模板:

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

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

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

    oc status
    Copy to Clipboard Toggle word wrap
  3. 要从浏览器访问 Fuse 控制台,请使用提供的 URL (例如 https://fuse-console.192.168.64.12.nip.io)。
4.2.3.4. 确保数据在 Fuse 控制台中正确显示

如果在 Fuse 控制台中显示队列和连接缺少队列、缺少连接或显示不一致图标,请调整 Jolokia 集合大小参数,以指定 Jolokia marshals 中的最大元素数。

流程

  1. 在 Fuse 控制台右上角,单击用户图标,然后单击 Preferences

    mf preferences

  2. 增加 Maximum collection size 选项的值(默认为 50,000)。
  3. 单击 Close

4.2.4. 使用 S2I 源工作流创建和部署项目

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

流程

  1. 在浏览器中打开 OpenShift 控制台(https://OPENSHIFT_IP_ADDR:8443,将 OPENSHIFT_IP_ADDR 替换为 CDK 中显示的 IP 地址),并使用您的凭据(例如,使用用户名 developer和密码 developer )登录控制台。
  2. 在 Catalog 搜索字段中,输入 Red Hat Fuse 7.4 Camel XML 作为搜索字符串,并使用 Spring Boot 模板选择 Red Hat Fuse 7.4 Camel XML DSL

    get started s2i source 01

  3. 模板向导的 Information 步骤将打开。点击 Next
  4. 模板向导的 Configuration 步骤将打开,如下所示。从 Add to Project 下拉菜单,选择 My Project

    注意

    或者,如果您想为本例创建一个新项目,请从 Add to Project 下拉菜单中选择 Create Project。然后会显示一个 Project Name 字段来填写新项目的名称。

  5. 您可以接受 Configuration 步骤中其余设置的默认值。点 Create

    get started s2i source 02

    注意

    如果要修改应用程序代码(而不是像运行 Quickstart 一样),则需要分叉原始 Quickstart Git 存储库,并填写 Git Repository URLGit Reference 字段中的适当值。

  6. 模板向导的 Results 步骤将打开。单击 Close
  7. 在右侧 My Projects 窗格中,单击 My ProjectMy Project 项目的 Overview 选项卡将打开,显示 s2i-fuse74-spring-boot-camel-xml 应用。
  8. 单击 s2i-fuse74-spring-boot-camel-xml 部署左侧的箭头,以展开并查看此部署的详细信息,如下所示。

    get started s2i source 03

  9. 在此视图中,您可以看到构建日志。如果构建因任何原因而失败,构建日志可帮助您诊断问题。

    注意

    构建可能需要几分钟才能完成,因为必须从远程 Maven 存储库下载大量依赖项。为加快构建时间,我们建议您在本地网络上部署 Nexus 服务器。

  10. 如果构建成功完成,pod 图标会显示为运行 1 Pod 的蓝色圆圈。单击 pod 图标(blue circle)的中心,以查看 s2i-fuse74-spring-boot-camel-xml 的 pod 列表。

    注意

    如果多个 pod 正在运行,您会看到在这个时间点上运行的 pod 列表。否则(如果只有一个 pod),您直接浏览正在运行的 Pod 的详情视图。

  11. pod 详情视图将打开。单击 Logs 选项卡,以查看应用程序日志,再向下滚动以查找由 Camel 应用程序生成的日志消息。

    Details view of the running pod

  12. 单击左侧导航栏上的 Overview,以返回到 My Project 命名空间中的应用程序概述。要关闭正在运行的 pod,点 pod 图标旁的向下箭头 get started s2i binary 05 。当对话框提示您输入问题 Scale down deployment s2i-fuse74-spring-boot-camel-xml-1? 时,单击 Scale Down
  13. (可选) 如果您使用 CDK,您可以通过返回到 shell 提示符并输入以下命令来完全关闭虚拟 OpenShift 服务器:

    minishift stop
    Copy to Clipboard Toggle word wrap

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

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

5.1. 使用 Maven Archetype 创建 Spring Boot 项目

要使用 Maven archetypes 创建 Spring Boot 项目,请按照以下步骤操作:

流程

  1. 进入您系统上的相应目录。
  2. 在 shell 提示符中,输入以下 mvn 命令来创建一个 Spring Boot 项目。

    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-740017-redhat-00003/archetypes-catalog-2.2.0.fuse-740017-redhat-00003-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=spring-boot-camel-xml-archetype \
      -DarchetypeVersion=2.2.0.fuse-740017-redhat-00003
    Copy to Clipboard Toggle word wrap

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

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse74-spring-boot
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    [INFO] Using property: spring-boot-version = 1.5.17.RELEASE
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse74-spring-boot
    version: 1.0-SNAPSHOT
    package: org.example.fis
    spring-boot-version: 1.5.17.RELEASE
     Y: :
    Copy to Clipboard Toggle word wrap

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

  3. 按照快速启动中的说明,了解如何构建和部署示例。
注意

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

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

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

  ├── 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
Copy to Clipboard Toggle word wrap

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

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

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

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

application.properties

#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.port=8081

# disable all management endpoints except health
endpoints.enabled = false
endpoints.health.enabled = true
Copy to Clipboard Toggle word wrap

Application.java

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

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

Application.java

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

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

Application.java

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

camel-context.xml

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

注意
src/main/fabric8/deployment.yml

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

注意

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

5.3. Spring Boot Archetype Catalog

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

Expand
表 5.1. Spring Boot 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-config-archetype

演示如何使用 Kubernetes ConfigMap 和 Secret 配置 Spring Boot 应用程序。

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-sql-archetype

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

spring-boot-camel-xa-archetype

Spring Boot、Camel 和 XA Transactions.本例演示了如何在 Spring Boot 上运行 Camel Service,它支持 XA 事务在两个外部事务资源上运行:JMS 资源(A-MQ)和数据库(PostgreSQL)。此快速入门需要 PostgreSQL 数据库和 A-MQ 代理,首先部署并运行它们,一种简单的方法是使用 Openshift 服务目录中提供的模板。

spring-boot-camel-xml-archetype

演示如何通过蓝图配置文件在 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 Camel XA Transactions quickstart 演示了如何使用 Spring Boot 运行支持 XA 事务的 Camel 服务。此快速入门显示两个外部事务资源的使用:JMS (AMQ)代理和数据库(PostgreSQL)。您可以在此处找到此快速入门 :https://github.com/jboss-fuse/spring-boot-camel-xa。

红帽产品服务等级协议(SLA)不支持技术预览功能,其功能可能并不完善,因此红帽不建议在生产环境中使用它们。这些技术预览功能可以使用户提早试用新的功能,并有机会在开发阶段提供反馈意见。如需更多信息,请参阅红帽技术预览功能支持范围

5.4. Spring Boot 的 BOM 文件

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

重要

确保您根据您使用的 Spring Boot 版本(Spring Boot 1 或 Spring Boot 2)使用正确的 Fuse BOM。

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

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

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

5.4.1. 包含 BOM 文件

要将 BOM 文件合并到 Maven 项目中,请在项目的 pom.xml 文件中指定 dependencyManagement 元素(或者在父 POM 文件中指定一个 dependencyManagement 项),如以下 Spring Boot 2 和 Spring Boot 1 的示例所示:

<?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.4.0.fuse-sb2-740019-redhat-00005</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>
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.4.0.fuse-740036-redhat-00002</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>
Copy to Clipboard Toggle word wrap

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

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

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

5.5. 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 部分中,如下例所示:

<?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.4.0.fuse-740036-redhat-00002</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>
Copy to Clipboard Toggle word wrap

第 6 章 Spring Boot 中的 Apache Camel

6.1. Camel Spring Boot 简介

Camel Spring Boot 组件为 Apache Camel 提供自动配置。Camel 上下文自动配置会自动探测到 Spring 上下文中提供的 Camel 路由,并注册密钥 Camel 工具,如生成者模板、消费者模板,以及类型转换器作为 Bean。

每个 Camel Spring Boot 应用程序都应该使用带有产品化版本的 dependencyManagement,请参阅 快速入门 pom。之后标记的版本可以被省略,以不能覆盖 BOM 中的版本。

<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>
Copy to Clipboard Toggle word wrap
注意

camel-spring-boot jar 附带 spring.factories 文件,该文件允许您将该依赖项添加到 classpath 中,因此 Spring Boot 将自动配置 Camel。

6.2. Camel Spring Boot Starter 简介

Apache Camel 包含一个 Spring Boot 初学者模块,允许您使用 starters 开发 Spring Boot 应用程序。

注意

如需了解更多详细信息,请参阅源代码中的 示例应用程序 。

要使用初学者,请在 Spring Boot pom.xml 文件中添加以下代码片段:

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

初学者允许您使用 Camel 路由添加类,如下面的代码片段中所示。当这些路由添加到类路径中后,路由会自动启动。

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");
    }
}
Copy to Clipboard Toggle word wrap

您可以在 application.properties 或 application.yml 文件中自定义 Camel 应用程序。 

现在,当您配置任何 Camel 初学者组件时,Camel Spring Boot 现在支持根据配置文件(application.properties 或 yaml 文件)引用 bean。在 src/main/resources/application.properties (或 yaml)文件中,您现在可以通过引用 beans ID 名称在 Camel 上轻松配置引用其他 Bean 的选项。例如,xslt 组件可以使用 bean ID 来引用自定义 bean,如下所示:

请参考 id myExtensionFactory 的自定义 bean,如下所示:

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

然后,您可以使用 Spring Boot @Bean 注解创建,如下所示:

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

或者,在 camel-jackson data-format 中的 Jackson ObjectMapper 中:

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

6.3. 自动配置的 Camel 上下文

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

例如,您可以访问 camelContext,如下所示:

@Configuration
public class MyAppConfig {

  @Autowired
  CamelContext camelContext;

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

}
Copy to Clipboard Toggle word wrap

6.4. 自动探测 Camel 路由

Camel 自动配置从 Spring 上下文收集所有 RouteBuilder 实例,并自动将它们注入到 CamelContext 中。它简化了使用 Spring Boot 初学者创建新 Camel 路由的过程。您可以通过在 classpath 中添加 @Component 注解的类来创建路由。

@Component
public class MyRouter extends RouteBuilder {

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

}
Copy to Clipboard Toggle word wrap

要在 @Configuration 类中创建新路由 RouteBuilder bean,请参阅以下:

@Configuration
public class MyRouterConfiguration {

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

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

    };
  }
 
}
Copy to Clipboard Toggle word wrap

6.5. Camel 属性

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

这些属性在 application.properties 文件中定义: 

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

使用 作为系统属性

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

使用 作为 Camel 路由中的占位符:

@Component
public class MyRouter extends RouteBuilder {

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

}
Copy to Clipboard Toggle word wrap

6.6. 自定义 Camel 上下文配置

要对 Camel 自动配置创建的 CamelContext bean 执行操作,您需要在 Spring 上下文中注册 CamelContextConfiguration 实例,如下所示:

@Configuration
public class MyAppConfig {

  ...

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

}
Copy to Clipboard Toggle word wrap
注意

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

6.7. 禁用 JMX

要禁用自动配置的 CamelContext 的 JMX,请使用 camel.springboot.jmxEnabled 属性,因为默认启用 JMX。

例如,您可以在 application.properties 文件中添加以下属性:

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

6.8. 自动配置的消费者和制作者模板

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

@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());
  }

}
Copy to Clipboard Toggle word wrap

默认情况下,消费者模板和制作者模板将端点缓存大小设置为 1000。您可以使用以下 Spring 属性更改这些值:

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

6.9. 自动配置的类型Converter

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

@Component
public class InvoiceProcessor {

  @Autowired
  private TypeConverter typeConverter;

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

}
Copy to Clipboard Toggle word wrap

6.10. 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 转换器,如下所示:

@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());
  }

}
Copy to Clipboard Toggle word wrap

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

6.11. 禁用类型转换功能

要禁用 Camel Spring Boot 的注册类型转换功能,如 TypeConverter 实例或 Spring 网桥,请将 camel.springboot.typeConversion 属性设置为 false,如下所示:

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

6.12. 添加 XML 路由

默认情况下,您可以将 Camel XML 路由放在目录 camel 下的 classpath 中,camel-spring-boot 将自动检测并包括:从 Camel 版本 2.17 开始,您可以使用配置选项配置目录名称或禁用此功能,如下所示:

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

XML 文件应该是 Camel XML 路由而不是 CamelContext,例如:

   <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>
Copy to Clipboard Toggle word wrap

当将 Spring XML 文件与 <camelContext> 搭配使用时,您可以在 Spring XML 文件和 application.properties 文件中配置 Camel。例如,要在 Camel 上设置名称并打开流缓存,请添加:

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

6.13. 添加 XML Rest-DSL

默认情况下,您可以将 Camel Rest-DSL XML 路由放在目录 camel-rest 下的 classpath 中,camel-spring-boot 将自动检测并包括:您可以使用配置选项配置目录名称或禁用此功能,如下所示:

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

Rest-DSL XML 文件应该是 Camel XML rests 而不是 CamelContext,例如:

   <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>
Copy to Clipboard Toggle word wrap

6.14. 使用 Camel Spring Boot 测试

如果在 Spring Boot 上运行的 Camel 上,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。

您可以在单元测试类中指定这些模式作为 @SpringBootTest 注释的属性,如下所示:

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

FooTest 类中,include 模式为 **/Foo*,它代表 Ant 风格模式。此处的模式以双星号开头,与前导软件包名称匹配。/foo* 表示类名称必须以 Foo 开头,例如 FooRoute。您可以使用以下 maven 命令运行测试:

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

6.15. 另请参阅

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

7.1. StatefulSet 资源

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

7.2. Spring Boot Narayana Recovery Controller

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

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

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

7.3. 配置 Spring Boot Narayana Recovery Controller

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

流程

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

    # 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
    Copy to Clipboard Toggle word wrap
  2. 您需要一个共享卷来存储与终止相关的事务和信息。它可以挂载到 StatefulSet yaml 描述符中,如下所示。

    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
    #...
    Copy to Clipboard Toggle word wrap

Camel Extension for Spring Boot Narayana Recovery Controller

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

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

流程

  1. 下载 Camel Spring Boot XA 项目。

    git clone https://github.com/jboss-fuse/spring-boot-camel-xa
    Copy to Clipboard Toggle word wrap
  2. 导航到 spring-boot-camel-xa 目录并运行以下命令:

    mvn clean install
    Copy to Clipboard Toggle word wrap
  3. 登录 OpenShift 服务器。

    oc login -u developer -p developer
    Copy to Clipboard Toggle word wrap
  4. 创建名为 test 的新项目命名空间(假设它尚不存在)。

    oc new-project test
    Copy to Clipboard Toggle word wrap

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

    oc project test
    Copy to Clipboard Toggle word wrap
  5. 安装依赖项。

    • 从 OpenShift 目录,使用用户名用户名 和密码 Thepassword1! 安装 postgresql
    • 在 OpenShift 目录中,使用用户名 user 和密码 Thepassword1! 安装 A-MQ 代理。
  6. 更改 Postgresql 数据库以接受准备的语句。

    oc env dc/postgresql POSTGRESQL_MAX_PREPARED_TRANSACTIONS=100
    Copy to Clipboard Toggle word wrap
  7. 为事务日志创建一个持久性卷声明。

    oc create -f persistent-volume-claim.yml
    Copy to Clipboard Toggle word wrap
  8. 构建和部署您的快速入门。

    mvn fabric8:deploy -P openshift
    Copy to Clipboard Toggle word wrap
  9. 将它扩展至所需的副本数。

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

    注: 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 (去掉一些字符(去除一些字符,如 -)。
  10. 快速启动运行后,使用以下命令获取基础服务 URL。

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

7.5. 测试成功 XA Transactions

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

流程

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

    curl -w "\n" http://$NARAYANA_HOST/api/
    Copy to Clipboard Toggle word wrap
  2. 列表在开始时为空。现在,您可以放置第一个元素。

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

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

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

7.6. 测试失败的 XA Transactions

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

流程

  1. 发送名为 fail 的消息。

    curl -w "\n" -X POST http://$NARAYANA_HOST/api/?entry=fail
    Copy to Clipboard Toggle word wrap
  2. 等待一段时间后获取新列表。

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

第 8 章 将 Camel 应用程序与 A-MQ Broker 集成

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

8.1. 构建和部署 Spring Boot Camel A-MQ Quickstart

这个示例需要 JBoss A-MQ 6 镜像和部署模板。如果您使用 CDK 3.1.1+,默认情况下,JBoss A-MQ 6 镜像和模板应已安装在 openshift 命名空间中。

先决条件

流程

  1. 准备好构建和部署快速入门:

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

      oc login -u developer -p developer
      Copy to Clipboard Toggle word wrap
    2. 创建一个新项目 amq-quickstart

      oc new-project amq-quickstart
      Copy to Clipboard Toggle word wrap
    3. 确定安装的 A-MQ 6 镜像和模板的版本。

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

      您应能够查找名为 amqXX-basic 的模板,其中 XX 是 Openshift 中安装的 A-MQ 版本。

  2. amq-quickstart 命名空间中部署 A-MQ 6 镜像(将 XX 替换为上一步中找到的 A-MQ 的实际版本)。

    $ oc process openshift//amqXX-basic -p APPLICATION_NAME=broker -p MQ_USERNAME=admin -p MQ_PASSWORD=admin -p MQ_QUEUES=test -p MQ_PROTOCOL=amqp -n amq-quickstart | oc create -f -
    Copy to Clipboard Toggle word wrap
    注意

    如果使用旧版本的 oc,这个 oc 命令可能会失败。此语法可用于 oc 版本 3.5.x (基于 Kubernetes 1.5.x)。

  3. 添加发现网格端点(通过 Kubernetes REST API 代理)所需的用户角色。

    $ oc policy add-role-to-user view system:serviceaccount:amq-quickstart:default
    Copy to Clipboard Toggle word wrap
  4. 使用 Maven 工作流创建 Quickstart 项目。

    $ 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-740017-redhat-00003/archetypes-catalog-2.2.0.fuse-740017-redhat-00003-archetype-catalog.xml \
    -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
    -DarchetypeArtifactId=spring-boot-camel-amq-archetype \
    -DarchetypeVersion=2.2.0.fuse-740017-redhat-00003
    Copy to Clipboard Toggle word wrap
  5. archetype 插件切换到交互模式,以提示您输入剩余的字段。

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse74-spring-boot-camel-amq
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    [INFO] Using property: spring-boot-version = 1.5.17.RELEASE
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse74-spring-boot-camel-amq
    version: 1.0-SNAPSHOT
    package: org.example.fis
    spring-boot-version: 1.5.17.RELEASE
     Y: :
    Copy to Clipboard Toggle word wrap

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

  6. 导航到 Quickstart 目录 fuse74-spring-boot-camel-amq

    $ cd fuse74-spring-boot-camel-amq
    Copy to Clipboard Toggle word wrap
  7. 通过设置 ACTIVEMQ_BROKER_USERNAMEACTIVEMQ_BROKER_PASSWORD 环境变量,自定义用于登录代理的客户端凭据。在 fuse74-spring-boot-camel-amq 项目中,编辑 src/main/fabric8/deployment.yml 文件,如下所示:

    spec:
      template:
        spec:
          containers:
            -
              resources:
                requests:
                  cpu: "0.2"
    #              memory: 256Mi
                limits:
                  cpu: "1.0"
    #              memory: 256Mi
              env:
              - name: AMQP_HOST
                value: broker-amq-amqp
              - name: SPRING_APPLICATION_JSON
                value: '{"server":{"undertow":{"io-threads":1, "worker-threads":2 }}}'
              - name: AMQP_USERNAME
                value: admin
              - name: AMQP_PASSWORD
                value: admin
    Copy to Clipboard Toggle word wrap
  8. 运行 mvn 命令将 Quickstart 部署到 OpenShift 服务器。

    mvn fabric8:deploy -Popenshift
    Copy to Clipboard Toggle word wrap
  9. 验证 Quickstart 是否已成功运行:

    1. 导航到 OpenShift 控制台。
    2. 选择项目 amq-quickstart
    3. 单击 Applications
    4. 选择 Pod
    5. 单击 fis-spring-boot-camel-am-1-xxxxx
    6. Logs

      输出显示消息成功发送。

      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
      Copy to Clipboard Toggle word wrap
  10. 要查看 Web 界面中的路由,请单击 Open Java Console 并检查 A-MQ 队列中的消息。

第 9 章 将 Spring Boot 与 Kubernetes 集成

Spring Cloud Kubernetes 插件目前使您能够集成 Spring Boot 和 Kubernetes 的以下功能:

9.1. Spring Boot Externalized 配置

在 Spring Boot 中,外部化 配置是可让您将来自外部源的配置值注入 Java 代码的机制。在您的 Java 代码中,使用 @Value 注释(注入单个字段)或 @ConfigurationProperties 注释(注入 Java bean 类的多个属性)通常启用注入。

配置数据可能来自各种不同的源(或 属性源)。特别是,通常在项目的 application.properties 文件中设置配置属性(或 application.yaml 文件)。

9.1.1. Kubernetes ConfigMap

Kubernetes ConfigMap 是向已部署的应用程序提供配置数据的机制。ConfigMap 对象通常在 YAML 文件中定义,然后上传到 Kubernetes 集群,使配置数据可用于部署的应用程序。

9.1.2. Kubernetes Secret

Kubernetes Secret 是为部署的应用程序提供敏感数据(如密码、证书等)的机制。

9.1.3. Spring Cloud Kubernetes Plug-In

Spring Cloud Kubernetes 插件实现 Kubernetes 和 Spring Boot 之间的集成。在原则上,您可以使用 Kubernetes API 从 ConfigMap 访问配置数据。但是,与 Spring Boot 外部配置机制直接集成 Kubernetes ConfigMap 更为方便,因此 Kubernetes ConfigMap 的行为是 Spring Boot 配置的替代属性源。这基本上是 Spring Cloud Kubernetes 插件提供的内容。

9.1.4. 启用带有 Kubernetes 集成的 Spring Boot

您可以通过将 Kubernetes 集成作为 Maven 依赖项添加到 pom.xml 文件来启用 Kubernetes 集成。

流程

  1. 通过将以下 Maven 依赖项添加到 Spring Boot Maven 项目的 pom.xml 文件中来启用 Kubernetes 集成。

    <project ...>
      ...
      <dependencies>
        ...
        <dependency>
          <groupId>io.fabric8</groupId>
          <artifactId>spring-cloud-kubernetes-core</artifactId>
        </dependency>
        ...
      </dependencies>
      ...
    </project>
    Copy to Clipboard Toggle word wrap
  2. 要完成集成,

    • 在 Java 源代码中添加一些注解
    • 创建 Kubernetes ConfigMap 对象
    • 修改 OpenShift 服务帐户权限,以允许您的应用程序读取 ConfigMap 对象。

其他资源

9.2. 为 ConfigMap 属性源运行 Tutorial

以下教程允许您试验设置 Kubernetes Secret 和 ConfigMap。按照 Enabling Spring Boot with Kubernetes Integration 所述,启用 Spring Cloud Kubernetes 插件,以将 Kubernetes 配置对象与 Spring Boot Externalized Configuration 集成。

9.2.1. 运行 Spring Boot Camel Config Quickstart

以下教程基于 spring-boot-camel-config-archetype Maven archetype,它可让您设置 Kubernetes Secret 和 ConfigMap。

流程

  1. 打开新的 shell 提示符,再输入以下 Maven 命令来创建简单的 Camel Spring Boot 项目。

    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-740017-redhat-00003/archetypes-catalog-2.2.0.fuse-740017-redhat-00003-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=spring-boot-camel-config-archetype \
      -DarchetypeVersion=2.2.0.fuse-740017-redhat-00003
    Copy to Clipboard Toggle word wrap

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

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse74-configmap
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    [INFO] Using property: spring-boot-version = 1.5.17.RELEASE
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse74-configmap
    version: 1.0-SNAPSHOT
    package: org.example.fis
    spring-boot-version: 1.5.17.RELEASE
     Y: :
    Copy to Clipboard Toggle word wrap

    出现提示时,为 groupId 值输入 org.example.fis,为 artifactId 值输入 fuse74-configmap。接受剩余的字段的默认值。

  2. 登录 OpenShift 并切换到您要部署应用的 OpenShift 项目。例如,若要以 developer 用户身份登录并部署到 test 项目,请输入以下命令:

    oc login -u developer -p developer
    oc project test
    Copy to Clipboard Toggle word wrap
  3. 在命令行中,更改到 new fuse74-configmap 项目的目录,再为此应用创建 Secret 对象。

    oc create -f sample-secret.yml
    Copy to Clipboard Toggle word wrap
    注意

    在部署应用程序前,需要创建 Secret 对象,否则部署的容器会进入等待状态,直到 Secret 变为可用。如果您随后创建 Secret,则容器将退出等待状态。有关如何设置 Secret 对象的更多信息,请参阅设置 Secret

  4. 构建和部署快速入门应用程序。从 fuse74-configmap 项目的顶层,输入:

    mvn fabric8:deploy -Popenshift
    Copy to Clipboard Toggle word wrap
  5. 按如下所示查看应用日志:

    1. 在浏览器中打开 OpenShift 控制台,再选择相关的项目命名空间(如 test)。
    2. 单击 fuse74-configmap 服务的 circular pod 图标的中心。
    3. Pod 视图中,点 pod Name 查看正在运行的 Pod 的详细信息(如果只有一个 pod 正在运行),您将直接转至详细信息页面。
    4. 单击 Logs 标签,以查看应用程序日志并向下滚动,以查找由 Camel 应用程序生成的日志消息。
  6. 默认接收者列表(在 src/main/resources/application.properties 中配置)将生成的消息发送到两个 dummy 端点: direct:async-queuedirect:file。这会导致类似以下内容的信息写入应用程序日志中:

    5:44:57.376 [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
    Copy to Clipboard Toggle word wrap
  7. 在使用 ConfigMap 对象更新 fuse74-configmap 应用程序配置前,您必须提供 fuse74-configmap 应用程序权限来查看 OpenShift ApiServer 的数据。输入以下命令为 fuse74-configmap 应用程序的服务帐户授予 view 权限:

    oc policy add-role-to-user view system:serviceaccount:test:qs-camel-config
    Copy to Clipboard Toggle word wrap
    注意

    服务帐户通过语法 system:serviceaccount:PROJECT_NAME:SERVICE_ACCOUNT_NAME 来指定。fis-config 部署描述符将 SERVICE_ACCOUNT_NAME 定义为 qs-camel-config

  8. 要查看操作中的实时重新加载功能,请按如下所示创建一个 ConfigMap 对象:

    oc create -f sample-configmap.yml
    Copy to Clipboard Toggle word wrap

    新的 ConfigMap 覆盖正在运行的应用程序中 Camel 路由的接收者列表,将其配置为将生成的消息发送到 三个 dummy 端点: direct:async-queuedirect:file,以及 direct:mail。如需有关 ConfigMap 对象的更多信息,请参阅设置 ConfigMap。这会导致类似以下内容的信息写入应用程序日志中:

    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
    Copy to Clipboard Toggle word wrap

9.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 类

fuse74-configmap 项目的配置属性 bean 定义为 QuickstartConfiguration Java 类(在 src/main/java/org/example/fis/ 目录下),如下所示:

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
    ...
}
Copy to Clipboard Toggle word wrap
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 属性可从属性源注入。

9.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 文件

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
Copy to Clipboard Toggle word wrap

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

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 }}}'
Copy to Clipboard Toggle word wrap

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

# 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
Copy to Clipboard Toggle word wrap

spring.cloud.kubernetes.secrets.paths 属性指定 pod 中 secret 卷挂载的路径列表。

注意

bootstrap.properties 文件(或 bootstrap.yml 文件)的行为与 application.properties 文件类似,但它会在应用程序启动的早期阶段载入。在 bootstrap.properties 文件中设置与 Spring Cloud Kubernetes 插件相关的属性更可靠。

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

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
Copy to Clipboard Toggle word wrap
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。因此,您需要输入以下命令来启用快速启动应用程序的 查看 权限(假设它部署到 测试 项目命名空间中):

oc policy add-role-to-user view system:serviceaccount:test:qs-camel-config
Copy to Clipboard Toggle word wrap

配置 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

9.3. 使用 ConfigMap PropertySource

Kubernetes 具有将配置传递给应用程序的 ConfigMap 的概念。Spring cloud Kubernetes 插件提供与 ConfigMap 集成,使配置映射可以被 Spring Boot 访问。

启用后 ConfigMap PropertySource 将查找 Kubernetes 查找应用程序命名的 ConfigMap (请参阅 spring.application.name)。如果找到了映射,它将读取其数据并执行以下操作:

9.3.1. 应用单个属性

假设我们有一个名为 demo 的 Spring Boot 应用程序,它使用属性来读取其线程池配置。

  • pool.size.core
  • pool.size.max

这可以以 YAML 格式外部化到配置映射:

kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  pool.size.core: 1
  pool.size.max: 16
Copy to Clipboard Toggle word wrap

9.3.2. 应用 Property Named application.yaml

对于大多数情况来说,单个属性可以正常工作,但有时我们找到 YAML 更为方便。在这种情况下,我们使用一个名为 application.yaml 的单个属性,并在其中嵌入 YAML:

kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  application.yaml: |-
    pool:
      size:
        core: 1
        max:16
Copy to Clipboard Toggle word wrap

9.3.3. 应用 Property Named application.properties

您还可以在 Spring Boot application.properties 文件的样式中定义 ConfigMap 属性。在这种情况下,我们使用名为 application.properties 的单个属性,并列出其中的属性设置:

kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  application.properties: |-
    pool.size.core: 1
    pool.size.max: 16
Copy to Clipboard Toggle word wrap

9.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 权限:

    oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default -n $(oc project -q)
    Copy to Clipboard Toggle word wrap

9.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 不会被启用

9.4.1. 设置 Secret 的示例

假设我们有一个名为 demo 的 Spring Boot 应用,它使用属性来读取其 ActiveMQ 和 PostreSQL 配置。

amq.username
amq.password
pg.username
pg.password
Copy to Clipboard Toggle word wrap

这些 secret 可以外部化为 YAML 格式的 Secret

ActiveMQ 机密
apiVersion: v1
kind: Secret
metadata:
  name: activemq-secrets
  labels:
    broker: activemq
type: Opaque
data:
  amq.username: bXl1c2VyCg==
  amq.password: MWYyZDFlMmU2N2Rm
Copy to Clipboard Toggle word wrap
PostreSQL Secret
apiVersion: v1
kind: Secret
metadata:
  name: postgres-secrets
  labels:
    db: postgres
type: Opaque
data:
  pg.username: dXNlcgo=
  pg.password: cGdhZG1pbgo=
Copy to Clipboard Toggle word wrap

9.4.2. 消耗 secret

您可以以多种方式选择要使用的 Secret:

  • 通过列出 secret 映射的目录:

    -Dspring.cloud.kubernetes.secrets.paths=/etc/secrets/activemq,etc/secrets/postgres
    Copy to Clipboard Toggle word wrap

    如果您有所有 secret 都映射到一个通用 root,您可以设置它们,如下所示:

    -Dspring.cloud.kubernetes.secrets.paths=/etc/secrets
    Copy to Clipboard Toggle word wrap
  • 通过设置命名的 secret:

    -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
    Copy to Clipboard Toggle word wrap

9.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。

9.5. 使用 PropertySource Reload

有些应用程序可能需要检测外部属性源的更改,并更新其内部状态以反映新的配置。Spring Cloud Kubernetes 的 reload 功能可以在相关的 ConfigMap 或 Secret 更改时触发应用程序重新加载。

9.5.1. 启用 PropertySource Reload

Spring Cloud Kubernetes 的 PropertySource reload 功能被默认禁用。

流程

  1. 进入 Quickstart 项目的 src/main/resources 目录,再打开 bootstrap.yml 文件。
  2. 更改配置属性 spring.cloud.kubernetes.reload.enabled=true

9.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。

9.5.3. PropertySource Reload 示例

以下示例解释了启用重新加载功能时会发生什么。

流程

  1. 假设使用默认设置(刷新 模式)启用了重新加载功能。配置映射更改时将刷新以下 bean:

    @Configuration
    @ConfigurationProperties(prefix = "bean")
    public class MyConfig {
    
        private String message = "a message that can be changed live";
    
        // getter and setters
    
    }
    Copy to Clipboard Toggle word wrap
  2. 要查看发生的更改,请创建另一个 bean,以定期打印消息,如下所示。

    @Component
    public class MyBean {
    
        @Autowired
        private MyConfig config;
    
        @Scheduled(fixedDelay = 5000)
        public void hello() {
            System.out.println("The message is: " + config.getMessage());
        }
    }
    Copy to Clipboard Toggle word wrap
  3. 您可以使用 ConfigMap 更改应用程序打印的消息,如下所示。

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: reload-example
    data:
      application.properties: |-
        bean.message=Hello World!
    Copy to Clipboard Toggle word wrap

    对与 pod 关联的 Config Map 中名为 bean.message 的属性的任何更改都会反映在程序的输出中。

9.5.4. PropertySource Reload Operating Modes

reload 功能支持两种操作模式:

event
(默认) 监视使用 Kubernetes API (Web 套接字)的 ConfigMap 或 secret 的更改。在更改时,任何事件都会对配置生成重新检查,并重新加载。要侦听配置映射更改,需要服务帐户的 view 角色。更高级别的角色(例如,secret 需要编辑)(默认情况下不监控secrets)。
轮询
从配置映射和 secret 定期重新创建配置,以查看它是否已更改。可以使用属性 spring.cloud.kubernetes.reload.period 配置轮询周期,默认为 15 秒。它需要与 monitored 属性源相同的角色。例如,在文件挂载的 secret 源上使用轮询不需要特定的特权。

9.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 的原始状态。

第 10 章 为 Karaf 镜像开发应用

本教程介绍了如何为 Karaf 镜像创建和部署应用。

10.1. 使用 Maven Archetype 创建 Karaf 项目

要使用 Maven archetype 创建 Karaf 项目,请按照以下步骤操作:

流程

  1. 进入您系统上的相应目录。
  2. 启动 Maven 命令以创建 Karaf 项目

    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-740017-redhat-00003/archetypes-catalog-2.2.0.fuse-740017-redhat-00003-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=karaf-camel-log-archetype \
      -DarchetypeVersion=2.2.0.fuse-740017-redhat-00003
    Copy to Clipboard Toggle word wrap
  3. archetype 插件切换到交互模式以提示您输入剩余的字段

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse74-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: fuse74-karaf-camel-log
    version: 1.0-SNAPSHOT
    package: org.example.fis
     Y: :
    Copy to Clipboard Toggle word wrap

    出现提示时,为 groupId 值输入 org.example.fis,为 artifactId 值输入 fuse74-karaf-camel-log。接受剩余的字段的默认值。

  4. 按照快速启动中的说明,了解如何构建和部署示例。
注意

有关 available Karaf archetypes 的完整列表,请参阅 Karaf Archetype Catalog

10.2. Camel Karaf 应用程序的结构

Camel Karaf 应用程序的目录结构如下:

  ├── 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
Copy to Clipboard Toggle word wrap

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

1
pom.xml :包含其他依赖项。您可以在 pom.xml 文件中添加依赖项,例如,您可以使用 SLF4J 记录。
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
    </dependency>
Copy to Clipboard Toggle word wrap
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 :包含应用程序的源代码。

10.3. Karaf Archetype Catalog

Karaf archetype 目录包括以下示例。

Expand
表 10.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 服务公开该服务。

10.4. 使用 Fabric8 Karaf 功能

Fabric8 提供对 Apache Karaf 的支持,使其更轻松地为 Kubernetes 开发 OSGi 应用。

Fabric8 的重要特性如下:

  • 在蓝图 XML 文件中解析占位符的不同策略。
  • 环境变量
  • 系统属性
  • 服务
  • Kubernetes ConfigMap
  • Kubernetes Secret
  • 使用 Kubernetes 配置映射动态更新 OSGi 配置管理。
  • 为 OSGi 服务提供 Kubernetes 热检查。

10.4.1. 添加 Fabric8 Karaf 功能

要使用功能,请将 fabric8-karaf-features 依赖项添加到项目 pom 文件中。

流程

  1. 打开项目的 pom.xml 文件,并添加 fabric8-karaf-features 依赖项。
<dependency>
  <groupId>io.fabric8</groupId>
  <artifactId>fabric8-karaf-features</artifactId>
  <version>${fabric8.version}</version>
  <classifier>features</classifier>
  <type>xml</type>
</dependency>
Copy to Clipboard Toggle word wrap

fabric8 karaf 功能将安装到 Karaf 服务器中。

10.4.2. 添加 Fabric8 Karaf 核心捆绑包功能

捆绑包 fabric8-karaf-core 提供 Blueprint 和 ConfigAdmin 扩展所使用的功能。

流程

  1. 打开项目的 pom.xml,并将 fabric8-karaf-core 添加到 startupFeatures 部分。

    <startupFeatures>
      ...
      <feature>fabric8-karaf-core</feature>
      ...
    </startupFeatures>
    Copy to Clipboard Toggle word wrap

    这将在自定义 Karaf 分发中添加 fabric8-karaf-core 功能。

10.4.3. 设置 Property Placeholder 服务选项

捆绑包 fabric8-karaf-core 会使用以下接口导出服务 PlaceholderResolver

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);
}
Copy to Clipboard Toggle word wrap

PlaceholderResolver 服务充当不同属性占位符解析策略的收集器。默认情况下,它提供的解析策略列在表 解析策略 中。要设置属性占位符服务选项,您可以使用系统属性或环境变量或两者。

流程

  1. 要访问 OpenShift 上的 ConfigMap,服务帐户需要查看权限。为服务帐户添加查看权限。

    oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default -n $(oc project -q)
    Copy to Clipboard Toggle word wrap
  2. 将 secret 挂载到 Pod,因为通过 API 访问 secret 可能会被限制。
  3. Pod 上作为卷挂载提供的 secret 映射到名为 secret 的目录,如下所示

    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
    Copy to Clipboard Toggle word wrap

10.4.4. 添加自定义属性 Placeholder Resolver

您可以添加自定义占位符解析器来支持特定的需求,如自定义加密。您还可以使用 PlaceholderResolver 服务使解析器可用于 Blueprint 和 ConfigAdmin。

流程

  1. 将以下 mvn 依赖项添加到项目 pom.xml 中。

    pom.xml

    ---
    <dependency>
      <groupId>io.fabric8</groupId>
      <artifactId>fabric8-karaf-core</artifactId>
    </dependency>
    ---
    Copy to Clipboard Toggle word wrap

  2. 实施 PropertiesFunction 接口,并使用 SCR 将它注册为 OSGi 服务。

    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;
        }
    }
    Copy to Clipboard Toggle word wrap
  3. 您可以在 Configuration management 中引用解析器,如下所示:

    属性

    my.property = $[myResolver:value-to-resolve]
    Copy to Clipboard Toggle word wrap

10.4.5. 解析策略列表

PlaceholderResolver 服务充当不同属性占位符解析策略的收集器。表中列出了它默认提供的解析策略。

  1. 解析策略列表
Expand

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 或卷挂载)中查找属性。

10.4.6. 属性 Placeholder 服务选项列表

属性占位符服务支持以下选项:

  1. 属性占位符服务选项列表
Expand
Namedefault描述

fabric8.placeholder.prefix

$[

占位符的前缀

fabric8.placeholder.suffix

]

占位符的后缀

fabric8.k8s.secrets.path

null

以逗号分隔的 secret 的路径列表

fabric8.k8s.secrets.api.enabled

false

通过 API 启用/禁用消耗 secret

10.5. 添加 Fabric8 Karaf 配置管理员支持

10.5.1. 添加 Fabric8 Karaf 配置管理员支持

您可以将 Fabric8 Karaf 配置管理员支持添加到自定义 Karaf 分发中。

流程

  • 打开项目的 pom.xml,并将 fabric8-karaf-cm 添加到 startupFeatures 部分。

    pom.xml

    <startupFeatures>
      ...
      <feature>fabric8-karaf-cm</feature>
      ...
    </startupFeatures>
    Copy to Clipboard Toggle word wrap

10.5.2. 添加 ConfigMap 注入

fabric8-karaf-cm 提供了一个 ConfigAdmin 网桥,该网桥在 Karaf 的 ConfigAdmin 中注入 ConfigMap 值。

流程

  1. 要由 ConfigAdmin 网桥添加,必须使用 karaf.pid 标记 ConfigMap。karaf.pid 值对应于组件的 pid。例如,

    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
    Copy to Clipboard Toggle word wrap
  2. 要定义配置,您可以使用单个属性名称。单个属性适用于大多数情况。它与 karaf/etc 中的 pid 文件相同。例如,

    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
    Copy to Clipboard Toggle word wrap

10.5.3. 配置插件

fabric8-karaf-cm 提供了一个 ConfigurationPlugin,用于解析配置属性占位符。

要使用 fabric8-karaf-cm 插件启用属性替换,您必须将 Java 属性 fabric8.config.plugin.enabled 设置为 true。例如,您可以使用 Karaf 镜像中的 JAVA_OPTIONS 环境变量设置此属性,如下所示:

JAVA_OPTIONS=-Dfabric8.config.plugin.enabled=true
Copy to Clipboard Toggle word wrap

10.5.4. config Property Placeholders

配置属性占位符示例如下所示:

my.service.cfg

    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]
Copy to Clipboard Toggle word wrap

my-service.xml

    <?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>
Copy to Clipboard Toggle word wrap

10.5.5. Fabric8 Karaf 配置管理员选项

Fabric8 Karaf Config Admin 支持以下选项:

Expand
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 或更高版本。

10.6. 添加 Fabric8 Karaf 蓝图支持

fabric8-karaf-blueprint 使用来自 fabric8-karaf-coreAries PropertyEvaluator 和属性占位符解析器来解析蓝图 XML 文件中的占位符。

流程

  • 要在自定义 Karaf 分发中包含蓝图支持的功能,请将 fabric8-karaf-blueprint 添加到项目 pom.xml 中的 startupFeatures 部分。

    <startupFeatures>
      ...
      <feature>fabric8-karaf-blueprint</feature>
      ...
    </startupFeatures>
    Copy to Clipboard Toggle word wrap

Example

fabric8 evaluators 支持串联的 evaluators,如 ${env+service:MY_ENV_VAR}。您需要针对环境变量解析 MY_ENV_VAR 变量。然后,使用服务功能解决结果。例如,

<?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>
Copy to Clipboard Toggle word wrap
重要

嵌套属性占位符替换需要 Aries Blueprint Core 1.7.0 或更高版本。

10.7. 启用 Fabric8 Karaf 健康检查

建议将 fabric8-karaf-checks 安装为启动功能。启用后,您的 Karaf 服务器就可以公开 http://0.0.0.0:8181/readiness-checkhttp://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

    <startupFeatures>
      ...
      <feature>fabric8-karaf-checks</feature>
      ...
    </startupFeatures>
    Copy to Clipboard Toggle word wrap

    fabric8-maven-plugin:resources 目标将检测您使用 fabric8-karaf-checks 功能,并将 Kubernetes 就绪度和存活度探测自动添加到您的容器的配置中。

10.8. 添加自定义健康检查

您可以提供额外的自定义 heath 检查,以防止 Karaf 服务器在用户准备好处理请求前接收用户流量。要启用自定义健康检查,您需要实施 io.fabric8.karaf.checks.HealthCheckerio.fabric8.karaf.checks.ReadinessChecker 接口,并在 OSGi 注册表中注册这些对象。

流程

  • 将以下 mvn 依赖项添加到项目 pom.xml 文件中。

    pom.xml

    <dependency>
      <groupId>io.fabric8</groupId>
      <artifactId>fabric8-karaf-checks</artifactId>
    </dependency>
    Copy to Clipboard Toggle word wrap

    注意

    在 OSGi 注册表中创建和注册对象的最简单方法是使用 SCR。

Example

一个执行健康检查的示例,以确保您有一些可用磁盘空间,如下所示:

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();
    }
}
Copy to Clipboard Toggle word wrap

第 11 章 为 JBoss EAP 镜像开发应用程序

要在 JBoss EAP 上开发 Fuse 应用程序,替代方案是使用 S2I 源工作流为带有 EAP 的 Red Hat Camel CDI 创建 OpenShift 项目。

先决条件

11.1. 使用 S2I 源工作流创建 JBoss EAP 项目

要在 JBoss EAP 上开发 Fuse 应用程序,替代方案是使用 S2I 源工作流为带有 EAP 的 Red Hat Camel CDI 创建 OpenShift 项目。

流程

  1. view 角色添加到 default 服务帐户以启用集群。这会授予用户对 default 服务帐户的 view 访问权限。每个项目都需要服务帐户来运行构建、部署和其他容器集。在 shell 提示符中输入以下 oc 客户端命令:

    oc login -u developer -p developer
    oc policy add-role-to-user view -z default
    Copy to Clipboard Toggle word wrap
  2. 在浏览器中打开 OpenShift 控制台(https://OPENSHIFT_IP_ADDR:8443,将 OPENSHIFT_IP_ADDR 替换为 CDK 中显示的 IP 地址),并使用您的凭据(例如,使用用户名 developer和密码 developer )登录控制台。
  3. 在 Catalog 搜索字段中,输入 Red Hat Fuse 7.4 Camel CDI,使用 EAP 作为搜索字符串,再选择 带有 EAP 模板的 Red Hat Fuse 7.4 Camel CDI

  4. 模板向导的 Information 步骤将打开。点击 Next
  5. 模板向导的 Configuration 步骤将打开。从 Add to Project 下拉菜单,选择 My Project

    注意

    或者,如果您想为本例创建一个新项目,请从 Add to Project 下拉菜单中选择 Create Project。然后会显示一个 Project Name 字段来填写新项目的名称。

  6. 您可以接受 Configuration 步骤中其余设置的默认值。点 Create

    注意

    如果要修改应用程序代码(而不是像运行 Quickstart 一样),则需要分叉原始 Quickstart Git 存储库,并填写 Git Repository URLGit Reference 字段中的适当值。

  7. 模板向导的 Results 步骤将打开。单击 Close
  8. 在右侧 My Projects 窗格中,单击 My ProjectMy Project 项目的 Overview 选项卡将打开,显示 s2i-fuse74-eap-camel-cdi 应用。
  9. 单击 s2i-fuse74-eap-camel-cdi 部署左侧的箭头,以展开并查看此部署的详细信息,如下所示。

    eap image s2i source 02

  10. 在此视图中,您可以看到构建日志。如果构建因任何原因而失败,构建日志可帮助您诊断问题。

    eap image s2i source 03

    注意

    构建可能需要几分钟才能完成,因为必须从远程 Maven 存储库下载大量依赖项。为加快构建时间,我们建议您在本地网络上部署 Nexus 服务器。

  11. 如果构建成功完成,pod 图标会显示为运行 1 Pod 的蓝色圆圈。

    Link to the running application

  12. 要打开应用程序,请点击应用程序详情上方显示的链接,其格式为 http://s2i-fuse74-eap-camel-cdi-myproject.IP_ADDRESS.nip.io/。在您的浏览器中显示类似如下的信息:

    Hello world from 172.17.0.3
    Copy to Clipboard Toggle word wrap

    您还可以使用 URL 中的 name 参数指定一个名称。例如,如果您在浏览器中输入 URL http://s2i-fuse74-eap-camel-cdi-myproject.IP_ADDRESS.nip.io/?name=jdoe,您会看到响应:

    Hello jdoe from 172.17.0.3
    Copy to Clipboard Toggle word wrap
  13. 单击左侧导航栏上的 Overview,以返回到 My Project 命名空间中的应用程序概述。要关闭正在运行的 pod,点 pod 图标旁的向下箭头 get started s2i binary 05 。当对话框提示您输入问题 Scale down deployment s2i-fuse74-eap-camel-cdi-1? 时,单击 Scale Down
  14. (可选) 如果您使用 CDK,您可以通过返回到 shell 提示符并输入以下命令来完全关闭虚拟 OpenShift 服务器:

    minishift stop
    Copy to Clipboard Toggle word wrap

11.2. JBoss EAP 应用的结构

您可以使用 EAP 示例在以下位置找到 Red Hat Fuse 7.4 Camel CDI 的源代码:

https://github.com/wildfly-extras/wildfly-camel-examples/tree/wildfly-camel-examples-5.2.0.fuse-720021/camel-cdi
Copy to Clipboard Toggle word wrap

EAP 应用程序上 Camel 的目录结构如下:

  ├── 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
Copy to Clipboard Toggle word wrap

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

pom.xml
包括其他依赖项。

11.3. JBoss EAP Quickstart 模板

以下 S2I 模板为 JBoss EAP 上的 Fuse 提供:

Expand
表 11.1. JBoss EAP S2I 模板
Name描述

带有 EAP 的 JBoss Fuse 7.4 Camel A-MQ (eap-camel-amq-template)

演示使用 camel-activemq 组件连接到 OpenShift 中运行 AMQ 消息代理。假设代理已经部署。

Red Hat Fuse 7.4 Camel CDI with EAP (eap-camel-cdi-template)

演示使用 camel-cdi 组件将 CDI Bean 与 Camel 路由集成。

Red Hat Fuse 7.4 CXF JAX-RS with EAP (eap-camel-cxf-jaxrs-template)

演示使用 camel-cxf 组件生成和使用 JAX-RS REST 服务。

Red Hat Fuse 7.4 CXF JAX-WS with EAP (eap-camel-cxf-jaxws-template)

演示使用 camel-cxf 组件生成和使用 JAX-WS Web 服务。

带有 EAP eap-camel-jpa-template的 Red Hat Fuse 7.4 Camel JPA + MySQL (Ephemeral)

演示如何将 Camel 应用程序与 EAP 上的红帽 Fuse 连接到 MySQL 数据库并公开 REST API。这个示例创建两个容器,一个容器作为 MySQL 服务器运行,另一个运行 Camel 应用程序充当数据库的客户端。

OpenShift 应用的 Fuse 基于 OpenShift 容器,没有持久文件系统。每次启动应用程序时,会在带有不可变 Docker 格式镜像的新容器中启动它。因此,文件系统中的任何持久数据都会在容器停止时丢失。但是,应用程序需要将一些状态存储为持久性存储中的数据,有时应用程序共享对通用数据存储的访问。OpenShift 平台支持将外部存储置备为持久性存储。

12.1. 关于卷和卷类型

OpenShift 允许容器集和容器作为由多个主机本地或网络附加存储端点支持的文件系统来 挂载卷

卷类型包括:

  • emptyDir (空目录):这是默认卷类型。它是在本地主机上创建 pod 时分配的目录。它不会在服务器间复制,并在删除 pod 时删除该目录。
  • ConfigMap:它是一个目录,其中包含从命名 configmap 中填充了键值对的目录。
  • hostpath (主机目录):它是具有任何主机上特定路径的目录,它需要升级的特权。
  • Secret (挂载 secret): Secret 卷将命名 secret 挂载到提供的目录中。
  • PersistentVolumeClaim 或 pvc (持久性卷声明):这会将容器中的卷目录链接到您按名称分配的持久性卷声明。持久性卷声明是分配存储的请求。请注意,如果您的声明没有绑定,您的 pod 不会启动。

卷在 Pod 级别上配置,只能使用 hostPath 直接访问外部存储。因此,难以将多个 Pod 共享资源作为 hostPath 卷进行管理。

12.2. 关于 PersistentVolume

通过 PersistentVolume,集群管理员可以调配由各种类型的网络存储(如 NFS、Ceph RBD、AWS Elastic Block Store (EBS))支持的集群范围的存储。PersistentVolume 还指定容量、访问模式和循环策略。这允许来自多个项目的 pod 访问持久性存储,而无需担心底层资源的性质。

请参阅 配置持久性存储 以创建各种 PersistentVolume 类型。

12.3. 配置持久性卷

您可以通过创建配置文件来置备持久性卷。然后,可通过创建 PersistentVolume 声明来访问此存储。

流程

  1. 使用以下示例配置,创建名为 pv.yaml 的配置文件。这会在主机机器上置备一个路径,作为名为 pv001 的 PersistentVolume。

    apiVersion: v1
    kind: PersistentVolume
    metadata:
      name: pv0001
    spec:
      accessModes:
        - ReadWriteOnce
      capacity:
        storage: 2Mi
      hostPath:
        path: /data/pv0001/
    Copy to Clipboard Toggle word wrap

    此处主机路径为 /data/pv0001,存储容量限制为 2MB。例如,在使用 OpenShift CDK 时,它将从托管 OpenShift 集群的虚拟机中调配目录 /data/pv0001

  2. 创建 PersistentVolume

    oc create -f pv.yaml
    Copy to Clipboard Toggle word wrap
  3. 验证 PersistentVolume 的创建。这将列出 OpenShift 集群中配置的所有 PersistentVolume

    oc get pv
    Copy to Clipboard Toggle word wrap

12.4. 创建 PersistentVolumeClaims

PersistentVolume 将存储端点作为 OpenShift 集群中的命名实体公开。要从项目访问此存储,必须创建可以访问 PersistentVolumePersistent VolumeClaim。为每个项目创建 PersistentVolumeClaim,其中包含具有特定访问模式的特定存储量的自定义声明。

流程

  • 以下示例配置为 1MB 存储创建一个名为 pvc0001 的声明,对名为 pv0001 的 PersistentVolume 具有读写权限访问。

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: pvc0001
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 1Mi
    Copy to Clipboard Toggle word wrap

12.5. 在 Pod 中使用持久性卷

Pod 使用卷挂载定义文件系统挂载位置和卷来定义引用 PersistentVolumeClaim

流程

  1. 创建如下所示的示例容器配置,在其文件系统中将 PersistentVolumeClaim pvc0001 挂载于 /usr/share/data

    spec:
      template:
        spec:
          containers:
            - volumeMounts:
              - name: vol0001
                mountPath: /usr/share/data
          volumes:
            - name: vol0001
              persistentVolumeClaim:
                claimName: pvc0001
    Copy to Clipboard Toggle word wrap

    现在,应用程序写入目录 /usr/share/data 的任何数据都会在容器重启后保留。

  2. 将此配置添加到 OpenShift 应用的 Fuse 中的 src/main/fabric8/deployment.yml 文件中,并使用以下命令创建 OpenShift 资源:

    mvn fabric8:resource-apply
    Copy to Clipboard Toggle word wrap
  3. 验证创建的 DeploymentConfiguration 是否具有卷挂载和卷。

    oc describe deploymentconfig <application-dc-name>
    Copy to Clipboard Toggle word wrap

    对于 OpenShift 快速入门中的 Fuse,将 & lt;application-dc-name > 替换为 Maven 项目名称,如 spring-boot-camel

第 13 章 在 OpenShift 中修补 Fuse

您可能需要执行一个或多个任务,将 Fuse on OpenShift 产品设置为最新的补丁级别:

对 OpenShift 镜像上的 Fuse 进行补丁
更新 OpenShift 服务器上的 Fuse,以便新应用构建基于 Fuse 基础镜像的补丁版本。
使用 BOM 修补应用依赖项
更新项目 POM 文件中的依赖项,以便您的应用程序使用 Maven 工件的补丁版本。
对 OpenShift 模板上的 Fuse 进行补丁
更新 OpenShift 服务器上的 OpenShift 模板上的 Fuse,以便使用 OpenShift 模板上的 Fuse 创建的新项目使用 Maven 工件的补丁版本。

13.1. 有关 BOM 和 Maven 依赖项的重要注意事项

在 OpenShift 上的 Fuse 中,应用程序完全使用从 Red Hat Maven 存储库下载的 Maven 工件来构建。因此,要修补应用程序代码,您只需要编辑项目的 POM 文件,更改 Maven 依赖项,以在 OpenShift 补丁版本上使用适当的 Fuse。

务必要将 OpenShift 上 Fuse 的所有 Maven 依赖项升级在一起,以便您的项目使用来自同一补丁版本的依赖项。OpenShift 项目的 Fuse 包括一组精心策展的 Maven 工件,这些工件会被构建和测试。如果您尝试混合和匹配来自 OpenShift 补丁级别 的不同 Fuse 的 Maven 工件,则最终可以使用由红帽未经测试且不支持的配置。避免这种情况的最简单方法是在 Maven 中使用 Bill of Materials (BOM)文件,该文件定义 Fuse 在 OpenShift 上支持的所有 Maven 工件版本。当您更新 BOM 文件的版本时,您会自动更新项目的 POM 中 OpenShift Maven 工件上所有 Fuse 的版本。

POM 文件由 OpenShift Maven archetype 上的 Fuse 或 OpenShift 模板上的 Fuse 生成,具有使用 BOM 文件的标准布局,并定义某些所需插件的版本。建议您在自己的应用程序中继续使用这个标准布局,因为这样可以更轻松地修补和升级应用程序的依赖关系。

13.2. 在 OpenShift 镜像中修补 Fuse

OpenShift 镜像上的 Fuse 独立于主要的 Fuse 产品单独更新。如果 OpenShift 镜像上的 Fuse 需要任何补丁,则更新的镜像将在 OpenShift 镜像流上的标准 Fuse 上提供,并且更新的镜像可从红帽镜像 registry ( registry.redhat.io )下载。OpenShift 上的 Fuse 提供以下镜像流(通过 OpenShift 镜像流名称标识):

  • fuse7-java-openshift
  • fuse7-karaf-openshift
  • fuse7-eap-openshift
  • fuse7-console
  • apicurito-ui
  • fuse-apicurito-generator

流程

  1. OpenShift 镜像流上的 Fuse 通常安装在 OpenShift 服务器上的 openshift 项目中。要检查 OpenShift 上 OpenShift 镜像上的 Fuse 状态,请以管理员身份登录到 OpenShift,请输入以下命令:

    $ 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            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           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            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            About an hour ago...
    fuse-apicurito-generator         172.30.1.1:5000/openshift/fuse-apicurito-generator       1.2,1.3,1.4                    About an hour ago...
    apicurito-ui                     172.30.1.1:5000/openshift/apicurito-ui                   1.2,1.3,1.4                    About an hour ago...
    Copy to Clipboard Toggle word wrap
  2. 现在,您可以一次更新每个镜像流:

    oc import-image -n openshift fuse7-java-openshift:1.4
    oc import-image -n openshift fuse7-karaf-openshift:1.4
    oc import-image -n openshift fuse7-eap-openshift:1.4
    oc import-image -n openshift fuse7-console:1.4
    oc import-image -n openshift apicurito-ui:1.4
    oc import-image -n openshift fuse-apicurito-generator:1.4
    Copy to Clipboard Toggle word wrap
注意

镜像流中的版本标签的格式是 1.4-<BUILDNUMBER>。当您将标签指定为 1.4 时,您将在 1.4 流中获取最新的构建。

注意

您还可以配置 Fuse 应用程序,以便在 OpenShift 镜像上的新 Fuse 可用时自动触发重建。详情请参阅 OpenShift Container Platform 3.11 开发人员指南中的 设置部署触发器 一节。

13.3. 在 OpenShift 模板上修补 Fuse

您必须将 OpenShift 模板上的 Fuse 更新至最新的补丁级别,以确保使用正确的补丁依赖项构建新的基于模板的项目。

流程

  1. 您需要管理员特权来更新 OpenShift 模板上的 Fuse。以管理员身份登录 OpenShift 服务器,如下所示:

    oc login URL -u ADMIN_USER -p ADMIN_PASS
    Copy to Clipboard Toggle word wrap

    其中 URL 是 OpenShift 服务器的 URL 和 ADMIN_USERADMIN_PASS 是 OpenShift 服务器上管理员帐户的凭据。

  2. 在 OpenShift 模板上安装补丁的 Fuse。在命令提示符后输入以下命令:

    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-740025-redhat-00003
    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/eap-camel-jpa-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
    Copy to Clipboard Toggle word wrap
    注意

    Git 存储库的 GA 分支上的 BASEURL 指向存储快速启动模板,并且始终具有 HEAD 的最新模板。因此,每当您运行上述命令时,都将获得最新版本的模板。

13.4. 使用 BOM 修补应用依赖项

如果您的应用程序 pom.xml 文件被配置为使用 new-style BOM,请按照本节中的说明升级 Maven 依赖项。

13.4.1. 更新 Spring Boot 应用程序中的依赖项

以下代码片段显示了 OpenShift 上 Fuse 中 Spring Boot 应用程序的 POM 文件的标准布局,突出显示了一些重要属性设置:

<?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.4.0.fuse-740036-redhat-00002</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>
Copy to Clipboard Toggle word wrap

当涉及到修补或升级应用程序时,以下版本设置非常重要:

fuse.version
定义 new-style fuse-springboot-bom BOM 的版本,以及 fabric8-maven-plugin 插件的版本和 spring-boot-maven-plugin 插件。

13.4.2. 更新 Karaf 应用中的依赖项

以下代码片段显示了 Fuse 上 Fuse 中的 POM 应用程序的标准布局,突出显示了一些重要属性设置:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <fuse.version>7.4.0.fuse-740036-redhat-00002</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>
Copy to Clipboard Toggle word wrap

当涉及到修补或升级应用程序时,以下版本设置非常重要:

fuse.version
定义 new-style fuse-karaf-bom BOM 的版本,以及 fabric8-maven-plugin 插件的版本,以及 karaf-maven-plugin 插件。

13.4.3. 更新 JBoss EAP 应用程序中的依赖项

以下代码片段显示了 OpenShift 上 Fuse 中 JBoss EAP 应用程序的 POM 文件标准布局,突出显示了一些重要属性设置:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <fuse.version>7.4.0.fuse-740036-redhat-00002</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>
Copy to Clipboard Toggle word wrap

当涉及到修补或升级应用程序时,以下版本设置非常重要:

fuse.version
定义 fuse-eap-bom BOM 文件的版本(它替换了旧的 样式的 wildfly-camel-bom BOM 文件)。通过将 BOM 版本更新至特定的补丁版本,您也会有效地更新 JBoss EAP Maven 依赖项上的所有 Fuse。

13.5. 可用的 BOM 版本

下表显示了与不同补丁版本对应的新样式 BOM 版本。

Expand
表 13.1. Red Hat Fuse 发行版本和协调 New-Style BOM 版本
Red Hat Fuse 发行版本org.jboss.redhat-fuse BOM 版本

Red Hat Fuse 7.0.0 GA

7.4.0.fuse-740036-redhat-00002

Red Hat Fuse 7.0.1 补丁

7.0.1.fuse-000008-redhat-4

要将应用程序 POM 升级到特定的 Red Hat Fuse 补丁发行版本,请将 fuse.version 属性设置为对应的 BOM 版本。

附录 A. Spring Boot Maven Plug-In

A.1. Spring Boot Maven 插件概述

本附录描述了 Spring Boot Maven 插件。它在 Maven 中提供 Spring Boot 支持,并允许您打包可执行文件 jar 或 war 归档,并运行应用程序 原位

A.2. 目标

Spring Boot 插件包括以下目标:

  1. spring-boot:run 运行 Spring Boot 应用程序。
  2. spring-boot:repackage 重新打包您的 .jar.war 文件成为可执行文件。
  3. spring-boot:startspring-boot:stop 均用于管理 Spring Boot 应用程序的生命周期。
  4. spring-boot:build-info 生成构建信息,供 Actuator 使用。

A.3. 使用方法

您可以在以下位置找到有关如何使用 Spring Boot 插件的一般说明 :http://docs.spring.io/spring-boot/docs/current/maven-plugin/usage.html。以下示例演示了在 Spring Boot 中使用 spring-boot-maven-plugin

注意

有关 Spring Boot Maven 插件的详情,请参考 http://docs.spring.io/spring-boot/docs/current/maven-plugin 链接。

A.3.1. Spring Boot Maven 插件 2

<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.4.0.fuse-sb2-740019-redhat-00005</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>
Copy to Clipboard Toggle word wrap

A.3.2. Spring Boot Maven 插件 1

<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.4.0.fuse-740036-redhat-00002</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>
Copy to Clipboard Toggle word wrap

附录 B. 使用 Karaf Maven 插件

karaf-maven-plugin 可让您创建一个 Karaf 服务器装配,这是 Karaf 容器的微服务风格打包。完成的装配包含 Karaf 安装的所有重要组件(包括 etc/、data/、lib 和系统目录的内容),但剥离运行应用程序所需的裸机最低要求。

B.1. Maven 依赖项

karaf-assembly 项目中的 Maven 依赖项是功能存储库(类分类 功能)或 kar 归档。

  • 功能存储库安装在 maven 结构化系统/内部存储库中。
  • Kar 归档在服务器之上解包其内容,并安装了包含的功能存储库。

B.1.1. Maven 依赖项范围

依赖项的 Maven 范围决定其功能存储库是否列在功能服务配置文件 etc/org.apache.karaf.features.cfg 中(在 featuresRepositories 属性下)。这些范围是:

  • 编译(默认):存储库中的所有功能(或 kar 存储库)都将安装到 startup.properties 中。功能存储库不在 features 服务配置文件中列出。
  • Runtime:作为 karaf-maven-plugin 中的引导阶段。
  • provided: 作为 karaf-maven-plugin 中的 install stage。

B.2. Karaf Maven 插件配置

karaf-maven-plugin 定义与 Maven 范围相关的三个阶段。插件配置通过引用安装的功能,来控制如何使用这些元素安装功能:

  • 启动阶段: etc/startup.properties

    在这个阶段,启动功能、启动配置集和启动捆绑包用于准备要在 etc/startup.properties 中包含的捆绑包列表。这将导致在适当的开始级别的 etc/startup.properties 中列出功能捆绑包,并将捆绑包复制到 系统 内部存储库中。您可以使用 feature_namefeature_name/feature_version 格式,例如 < startupFeature>foo</startupFeature& gt;。

  • 引导阶段: etc/org.apache.karaf.features.cfg

    此阶段管理 featuresBoot 属性和 featuresRepositories 属性中提供的功能。这会导致在功能服务配置文件中添加到 boot-features 的功能名称,以及复制到 系统 内部存储库的功能中的所有捆绑包。您可以使用 feature_namefeature_name/feature_version 格式,例如 < bootFeature>bar</bootFeature& gt;。

  • 安装阶段:

    此阶段将工件安装在 ${karaf.home}/${karaf.default.repository} 中。这将导致 在系统 内部存储库中安装该功能中的所有捆绑包。因此在运行时,可以在不访问外部存储库的情况下安装该功能。您可以使用 feature_namefeature_name/feature_version 格式,例如 < installedFeature>baz</installedFeature& gt;。

  • 该插件接受 library 元素,它可以具有指定库 URL 的一个或多个库子元素。

    Example

    <libraries>
        <library>mvn:org.postgresql/postgresql/9.3-1102-jdbc41;type:=endorsed</library>
    </libraries>
    Copy to Clipboard Toggle word wrap

B.3. 自定义 Karaf assembly

创建 Karaf 服务器装配的建议方法是使用 karaf- maven-plugin 提供的 karaf:assembly 目标。这会从项目的 pom.xml 文件中的 Maven 依赖项编译服务器。在 karaf-maven-plugin 配置中指定的捆绑包(或功能)和 pom.xml 中的 &lt ;dependencies > 部分指定的依赖项都可以进入自定义的 karaf assembly 中。

  • 对于 kar

    具有 kar 类型的依赖项将作为 startup (scope=compile), boot (scope=runtime)或 installed (scope=provided) kars in karaf-maven-plugin 添加。kars 被解压缩到工作目录(target/assembly),并且搜索功能 XML,并用作额外功能存储库(与给定 kar 的阶段相同)。

  • 对于 features.xml

    具有分类器 的依赖项 将用作启动(scope=compile)、引导(scope=runtime)或安装(scope=provided)存储库(在 karaf-maven-plugin 中)。不需要显式添加 kar 中的功能存储库。

  • 对于 jar 和捆绑包

    bundlejar 类型的依赖项将用作启动(scope=compile), boot (scope=runtime)或 installed (scope=provided)捆绑包(在 karaf-maven-plugin 中)。

B.3.1. Karaf:assembly 目标

您可以使用 karaf-maven-plugin 提供的 karaf:assembly 目标来创建 Karaf 服务器装配。此目标从项目 POM 中的 Maven 依赖项装有微服务风格服务器装配。在 OpenShift 项目的 Fuse 中,建议您将 karaf:assembly 目标绑定到 Maven 安装阶段。该项目使用捆绑包打包,项目本身将安装到 Karaf 容器中,方法是在 bootBundles 元素中列出它。

注意

在启动阶段仅包含 karaf 框架功能所需的元素,因为它将进入 etc/startup.properties,并在此阶段 karaf 功能服务没有完全启动。延迟其他元素来引导阶段。

Example

以下示例显示了 Quickstart 中的典型 Maven 配置:

<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>
Copy to Clipboard Toggle word wrap

附录 C. Fabric8 Maven 插件

C.1. 概述

借助 fabric8-maven-plugin 帮助,您可以将 Java 应用部署到 OpenShift。它提供与 Maven 的紧密集成,以及来自已提供的构建配置的好处。此插件侧重于以下任务:

  • 构建 Docker 格式的镜像以及.
  • 创建 OpenShift 资源描述符

它可以配置非常灵活地,并支持多个配置模型来创建:

  • Zero-Config 设置,允许使用一些建议的默认值进行快速通道。或满足更高级的要求,
  • XML 配置,它提供额外的配置选项,可添加到 pom.xml 文件中。

C.1.1. 构建镜像

fabric8:build 目标用于创建包含应用的 Docker 格式镜像。在这些镜像中很容易包括构建工件及其依赖项。此插件使用 maven-assembly-plugin 中的 assembly 描述符格式来指定将添加到镜像中的内容。

重要

OpenShift 上的 Fuse 仅支持 OpenShift s2i 构建策略,不支持 docker 构建策略。

C.1.2. Kubernetes 和 OpenShift 资源

可以使用 fabric8:resource 创建 Kubernetes 和 OpenShift 资源描述符。这些文件打包在 Maven 工件中,并可通过 fabric8:apply 部署到正在运行的编配平台。

C.1.3. 配置

配置有四个级别:

  • 零配置模式有助于根据 pom.xml 文件中的内容、要使用的基础镜像或要公开的端口进行一些非常有用的决策。它用于启动事情,并用于保持快速启动应用程序小且方便。
  • XML 插件配置模式与 docker-maven-plugin 提供的模式类似。它允许使用 IDE 支持类型安全配置,但只有提供可能的资源描述符功能的子集。
  • Kubernetes 和 OpenShift 资源片段是用户提供的 YAML 文件,可通过插件增强。这允许专家用户使用普通配置文件及其功能,还可以添加特定于项目的构建信息并避免样板代码。*Docker Compose 用于在 OpenShift 集群上启动 docker compose 部署。这至少需要了解 OpenShift 部署过程。有关配置的详情,请参考 https://maven.fabric8.io/#configuration

C.2. 安装插件

Fabric8 Maven 插件位于 Maven 中央存储库下,可以连接到预集成阶段,如下所示:

<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>
Copy to Clipboard Toggle word wrap

C.3. 了解目标

Fabric8 Maven 插件支持丰富的目标集合,以提供平稳的 Java 开发人员体验。您可以按如下方式对这些目标进行分类:

C.3.1. 了解构建和开发目标:

以下是 Red Hat Fabric Integration Services 产品中 Fabric8 Maven 插件支持的目标:

Expand
表 C.1. 构建目标
目标描述

fabric8:build

构建镜像。请注意,OpenShift 上的 Fuse 仅支持 OpenShift s2i 构建策略,而不是 docker 构建策略。

fabric8:resource

创建 Kubernetes 或 OpenShift 资源描述符

fabric8:apply

将资源应用到正在运行的集群

fabric8:resource-apply

运行 fabric8:resourcefabric8:apply

Expand
表 C.2. 开发目标
目标描述

fabric8:run

在前台运行完整的开发工作流周期 fabric8:resourcefabric8:buildfabric8:apply

fabric8:deploy

在创建并构建应用程序后,为集群部署资源描述符。与 fabric8:run 相同,但它在后台运行。

fabric8:undeploy

从集群中删除资源描述符。

fabric8:start

启动之前部署的应用程序

fabric8:stop

停止之前部署的应用程序

fabric8:log

显示正在运行的应用程序的日志

fabric8:debug

启用远程调试

fabric8:watch

监控项目工作区的更改,并自动触发应用的重新部署。

C.3.2. 

例如,

<configuration>
  <resources>
    <env>
        <JAVA_OPTIONS>-Dmy.custom=option</JAVA_OPTIONS>
        <MY_VAR>value</MY_VAR>
    </env>
  </resources>
</configuration>
Copy to Clipboard Toggle word wrap

C.3.3. 

Expand
表 C.3. 
配置描述default

fabric8.skipResourceValidation

false

fabric8.failOnValidationError

false

fabric8.build.switchToDeployment

false

fabric8.openshift.trimImageInContainerSpec

false

C.4. 

注意

C.4.1. 

C.4.2. 

istag

<namespace>/<image-stream-name>:<tag>
Copy to Clipboard Toggle word wrap

docker

[<registry-location-url>/]<image-namespace>/<image-name>:<tag>
Copy to Clipboard Toggle word wrap

注意

C.4.2.1. 

fuse7/fuse-eap-openshift:1.3
fuse7/fuse-java-openshift:1.3
fuse7/fuse-karaf-openshift:1.3
Copy to Clipboard Toggle word wrap
注意

C.4.2.2. 

fuse7/fuse-eap-openshift:1.3
fuse7/fuse-java-openshift:1.3
fuse7/fuse-karaf-openshift:1.3
Copy to Clipboard Toggle word wrap
C.4.2.3. 

<configuration>
  <generator>
    <config>
      <spring-boot>
        <fromMode>{istag|docker}</fromMode>
        <from>{image locations}</from>
      </spring-boot>
    </config>
  </generator>
</configuration>
Copy to Clipboard Toggle word wrap
C.4.2.4. 

<configuration>
  <generator>
    <config>
      <karaf>
        <fromMode>{istag|docker}</fromMode>
        <from>{image locations}</from>
      </karaf>
    </config>
  </generator>
</configuration>
Copy to Clipboard Toggle word wrap
C.4.2.5. 

//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>
Copy to Clipboard Toggle word wrap

C.4.3. Spring Boot

Expand
表 C.4. 
元素描述default

assemblyRef

 

targetDir

jolokiaPort

8778

mainClass

 

webPort

8080

color

 

C.4.4. 

Expand
表 C.5. 
元素描述default

baseDir

jolokiaPort

8778

mainClass

 

user

jboss:jboss:jboss

webPort

8080

附录 D. 

D.1. 目标

D.2. 

<plugin>
  <groupId>io.fabric8.forge</groupId>
  <artifactId>fabric8-camel-maven-plugin</artifactId>
  <version>2.3.90</version>
</plugin>
Copy to Clipboard Toggle word wrap

mvn fabric8-camel:validate
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>
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>
Copy to Clipboard Toggle word wrap

D.3. 

    $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] ------------------------------------------------------------------------
Copy to Clipboard Toggle word wrap

  @Uri("timer:foo?period=5000")
Copy to Clipboard Toggle word wrap

  @Uri("timer:foo?perid=5000")
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] ------------------------------------------------------------------------
Copy to Clipboard Toggle word wrap

D.4. 选项

D.4.1. 表

Expand
参数默认值描述

downloadVersion

true

failOnError

false

logUnparseable

false

includeJava

true

includeXML

true

includeTest

false

includes

-

excludes

-

ignoreUnknownComponent

true

ignoreIncapable

true

ignoreLenientProperties

true

showAll

false

D.5. 

    $cd myproject
    $mvn io.fabric8.forge:fabric8-camel-maven-plugin:2.3.80:validate -DincludeTest=true
Copy to Clipboard Toggle word wrap

附录 E. 

E.1. 

E.2. 

s2i build <git repo url> registry.redhat.io/fuse7/fuse-karaf-openshift:1.3 <target image name>
docker run <target image name>
Copy to Clipboard Toggle word wrap

E.2.1. 

E.2.2. 

E.3. 环境变量

E.3.1. 

  • 默认值为 false。

E.3.2. 

E.3.3. 

  • 默认值为 false。

附录 F. 

F.1. 概述

F.2. 

F.3. 

F.4. 

  • JAVA_OPTIONS
  • JAVA_MAX_MEM_RATIO

例如:

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
Copy to Clipboard Toggle word wrap

F.5. 

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

© 2026 Red Hat