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

OpenShift 上的 Fuse 指南

Red Hat Fuse 7.5

在 OpenShift 中使用 Red Hat Fuse 安装和开发

Fuse Documentation Team

摘要

在 OpenShift 上使用 Fuse 指南

前言
复制链接

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

第 1 章 开始前
复制链接

发行注记

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

版本兼容性和支持

如需了解版本兼容性和支持的详细信息，请参阅 Red Hat JBoss Fuse 支持的配置页面。

支持 Windows O/S

Windows O/S 完全支持 OpenShift 上 Fuse 的开发人员工具(oc client and Container Development Kit)。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 会作为部署和扩展应用的一部分自动执行此操作。
  • Fabric 端点在 OpenShift 环境中不使用。必须使用 Kubernetes 服务。
  • 消息传递服务使用 A-MQ for OpenShift 镜像创建和管理，而不直接包含在 Karaf 容器中。OpenShift 上的 Fuse 提供了 camel-amq 组件的增强版本，它允许通过 Kubernetes 与 OpenShift 中的消息传递服务无缝连接。
  • 强烈建议不要使用 Karaf shell 运行 Karaf 实例的实时更新，因为如果应用容器重启或扩展，则不会保留更新。这是不可变架构的基本原则，在 OpenShift 中实现可扩展性和灵活性至关重要。
  • 红帽支持直接链接到红帽 Fuse 组件的 Maven 依赖项。不支持由用户引入的第三方 Maven 依赖项。
  • Apache Karaf 微容器中没有 SSH 代理，因此您无法使用 bin/client 控制台客户端连接到它。
  • OpenShift 应用的 Fuse 中的协议兼容性和 Camel 组件：基于非 HTTP 的通信必须使用 TLS 和 SNI，才能从 OpenShift 外部路由到 Fuse 服务(Camel 消费者端点)。

第 2 章 管理员入门
复制链接

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

  1. 配置 Red Hat Container Registry 身份验证。
  2. 在 OpenShift 镜像和模板上安装 Fuse。

2.1. 配置 Red Hat Container Registry 身份验证
复制链接

在导入并使用 OpenShift 镜像流和模板上的 Red Hat Fuse 前，您必须配置身份验证到 Red Hat 容器 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
    注意

    您需要在镜像流所在的每个命名空间以及使用 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 imagestreams Skipped Imagestreams 部分，并将 Fuse 和 Spring Boot 2 模板添加到 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-fuse75-eap-camel-amq
  - s2i-fuse75-eap-camel-cdi
  - s2i-fuse75-eap-camel-cxf-jaxrs
  - s2i-fuse75-eap-camel-cxf-jaxws
  - s2i-fuse75-eap-camel-jpa
  - s2i-fuse75-karaf-camel-amq
  - s2i-fuse75-karaf-camel-log
  - s2i-fuse75-karaf-camel-rest-sql
  - s2i-fuse75-karaf-cxf-rest
  - s2i-fuse75-spring-boot-camel
  - s2i-fuse75-spring-boot-camel-amq
  - s2i-fuse75-spring-boot-camel-config
  - s2i-fuse75-spring-boot-camel-drools
  - s2i-fuse75-spring-boot-camel-infinispan
  - s2i-fuse75-spring-boot-camel-rest-sql
  - s2i-fuse75-spring-boot-camel-rest-3scale
  - s2i-fuse75-spring-boot-camel-xa
  - s2i-fuse75-spring-boot-camel-xml
  - s2i-fuse75-spring-boot-cxf-jaxrs
  - s2i-fuse75-spring-boot-2-camel-amq
  - s2i-fuse75-spring-boot-2-camel-drools
  - s2i-fuse75-spring-boot-2-camel-infinispan
  - s2i-fuse75-spring-boot-2-camel-rest-3scale
  - s2i-fuse75-spring-boot-2-camel-rest-sql
  - s2i-fuse75-spring-boot-2-camel-teiid
  - s2i-fuse75-spring-boot-2-camel
  - s2i-fuse75-spring-boot-2-camel-xa
  - s2i-fuse75-spring-boot-2-camel-xml
  - s2i-fuse75-spring-boot-2-cxf-jaxrs
  - s2i-fuse75-spring-boot-2-cxf-jaxws
    Copy to Clipboard Toggle word wrap

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

    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-750056-redhat-00006

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

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

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

  8. 在 OpenShift 快速启动模板上安装 Fuse： 

    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-rest-3scale-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-750056-redhat-00006/quickstarts/${template}
 done
    Copy to Clipboard Toggle word wrap

  9. 安装 Spring Boot 2 Quickstart 模板： 

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

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

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

2.2.1. 在 OpenShift 4.x 中设置 Fuse 控制台
复制链接

在 OpenShift 4.x 上，设置 Fuse 控制台涉及保护、安装和部署它。

首先，您必须生成客户端证书，以便可以保护 Fuse 控制台，如 第 2.2.1.1 节 “生成证书来保护 OpenShift 4.x 上的 Fuse 控制台” 所述。

生成客户端证书后，您可以使用命令行和其中一个 Fuse 控制台来安装和部署 Fuse 控制台，以便它在 OpenShift 集群或特定命名空间中的多个命名空间中访问 Fuse 应用程序。

注意
  • Fuse 控制台的用户管理由 OpenShift 处理。
  • 基于角色的访问控制（在部署后访问 Fuse 控制台的用户）还不适用于 OpenShift 上的 Fuse。

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

重要

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

先决条件

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

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

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

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

      mkdir ../cluster2

      cd ../cluster2

流程

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

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

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

    • 检索证书： 

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

    • 检索私钥： 

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

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

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

    1. 生成私钥： 

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

    2. 编写 CSR 配置文件。 

      cat <<EOT >> csr.conf
  [ req ]
  default_bits = 2048
  prompt = no
  default_md = sha256
  distinguished_name = dn

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

  [ v3_ext ]
  authorityKeyIdentifier=keyid,issuer:always
  keyUsage=keyEncipherment,dataEncipherment,digitalSignature
  extendedKeyUsage=serverAuth,clientAuth
EOT
      Copy to Clipboard Toggle word wrap

    3. 生成 CSR： 

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

    4. 发布签名证书： 

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

后续步骤

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

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

  • 集群 - Fuse 控制台可以发现并连接到在 OpenShift 集群上的多个命名空间（项目）间部署的 Fuse 应用程序。要部署此模板，您必须具有 OpenShift 集群的管理员角色。
  • 命名空间 - Fuse 控制台可以访问特定的 OpenShift 项目（命名空间）。要部署此模板，您必须具有 OpenShift 项目的管理员角色。

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

oc process --parameters -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-750056-redhat-00006/fuse-console-namespace-os4.json
Copy to Clipboard Toggle word wrap

先决条件

流程

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

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

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

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

  3. 将以下 Fuse 控制台模板从原始格式 https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-750056-redhat-00006 下载到您选择的本地目录（例如，mytemp）。

    • 集群模板： fuse-console-cluster-os4.json
    • 命名空间模板： fuse-console-namespace-os4.json

  4. 对于命名空间模板，请跳至下一步。

    对于集群模板，在您选择的编辑器中编辑 fuse-console-cluster-os4.json 文件的本地副本，将 "grantMethod": "auto" 属性添加到 OAuthClient 部分： 

    {
      "kind": "OAuthClient",
      "apiVersion": "v1",
      "metadata": {
        "name": "${APP_NAME}-oauth-client"
      },
      "grantMethod": "auto",
      "redirectURIs": [
        "https://${ROUTE_HOSTNAME}"
      ]
}
    Copy to Clipboard Toggle word wrap

  5. 运行以下命令来获取 Fuse Console APP_NAME 值（其中 mytemp 是包含 Fuse Console 模板的本地目录的路径）：

    • 对于集群模板： 

      oc process --parameters -f mytemp/fuse-console-cluster-os4.json
      Copy to Clipboard Toggle word wrap

    • 对于命名空间模板： 

      oc process --parameters -f mytemp/fuse-console-namespace-os4.json
      Copy to Clipboard Toggle word wrap

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

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

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

    • 对于集群模板： 

      oc new-app -n myproject -f mytemp/fuse-console-cluster-os4.json -p ROUTE_HOSTNAME=myhost
      Copy to Clipboard Toggle word wrap

    • 对于命名空间模板： 

      oc new-app -n myproject -f mytemp/fuse-console-namespace-os4.json
      Copy to Clipboard Toggle word wrap

  8. 运行以下命令，获取 Fuse 控制台部署的状态和 URL： 

    oc status
    Copy to Clipboard Toggle word wrap
  9. 要从浏览器访问 Fuse 控制台，请使用在第 6 步中返回的 URL （例如 https://fuse-console.192.168.64.12.nip.io）。
2.2.1.3. 在 OpenShift 4.x 上升级 Fuse 控制台
复制链接

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

反过来，Operator 更新可触发应用程序升级。应用程序升级如何根据应用程序的配置方式的不同而有所不同。

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

前提条件

  • 有 OpenShift 集群管理员权限。

流程

升级 Fuse 控制台应用程序：

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

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

    例如： 

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

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

     oc get myproject
    Copy to Clipboard Toggle word wrap

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

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

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

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

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

    成功部署会显示这个响应： 

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

2.2.2. 在 OpenShift 4.x 上安装 API Designer
复制链接

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

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

先决条件

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

流程

  1. 启动 OpenShift 4.x 服务器。
  2. 在 Web 浏览器中，导航到浏览器中的 OpenShift 控制台。使用您的凭证登录到控制台。
  3. 点 Catalog，然后点 OperatorHub。

  4. 在搜索字段中，键入 API Designer。

    您可以在右侧面板中看到 API Designer 卡。

  5. 点 API Designer。此时会出现 API Designer operator 安装窗口。

  6. 点 Install。Create Operator Subscription 表单将打开。

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

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

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

后续步骤

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

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

注意

如需了解 OpenShift 开发人员要作为服务添加到 OpenShift 4.x 项目的步骤，请参阅 设计 API。

先决条件

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

流程

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

  3. 在 Provided APIs 下，点 Create Instance。

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

  4. 接受默认值或选择性地编辑以下值：

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

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

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

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

    1. 点 Operators，然后点 Installed Operators。

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

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

  7. 获取 API Designer 的 URL：

    1. 点 Networking > Routes。
    2. 确保选择了正确的项目。
    3. 在 apicurito-service 行中，在 Location 列中找到 API Designer Web 控制台的 URL。
2.2.2.2. 在 OpenShift 4.x 上升级 API Designer
复制链接

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

反过来，Operator 更新可触发应用程序升级。应用程序升级如何根据应用程序的配置方式的不同而有所不同。

对于 API Designer 应用程序，升级 API Designer 操作器时，OpenShift 会自动升级集群上的任何 API 设计程序应用程序。

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

流程

  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-750056-redhat-00006

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-rest-3scale-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-750056-redhat-00006/quickstarts/${template}
 done
    Copy to Clipboard Toggle word wrap

  6. 安装 Spring Boot 2 Quickstart 模板： 

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

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

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

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

  8. 安装 Apicurito 模板： 

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

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

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

2.3.1. 在 OpenShift 3.11 中设置 Fuse 控制台
复制链接

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

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

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

先决条件

  • 如 OpenShift 的 Fuse 指南中所述，在 OpenShift 镜像流和 Fuse 控制台安装 Fuse。

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

    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 默认目录提供。
  • Fuse 控制台模板默认配置端到端加密，以便您的 Fuse 控制台请求是从浏览器到集群服务的安全端到端。
  • Fuse 控制台的用户管理由 OpenShift 处理。
  • 基于角色的访问控制（在部署后访问 Fuse 控制台的用户）还不适用于 OpenShift 上的 Fuse。

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

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

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

2.3.1.1. 从 OpenShift 3.11 控制台部署 Fuse 控制台
复制链接

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

流程

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

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

    1. 选择 Add to Project → Browse Catalog。

      此时将打开 Select a item to the current project 页面。

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

      搜索结果中应该会显示 Red Hat Fuse 7.x Console 和 Red Hat Fuse 7.x Console (cluster) 项目。

注意

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

  1. 点 Red Hat Fuse Console 项之一：

    • Red Hat Fuse 7.x 控制台 - 此版本的 Fuse 控制台发现并连接到当前 OpenShift 项目中部署的 Fuse 应用程序。
    • Red Hat Fuse 7.x 控制台（集群） - 此版本的 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 控制台，请单击提供的 URL 链接，然后登录。

      浏览器中打开了 Authorize Access 页面，其中列出了所需权限。

    4. 点击 Allow selected permissions。

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

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

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

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

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

    Container Template View

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

    Fuse Console view

    注意

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

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

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

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

fis-console-cluster-template.json

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

fis-console-namespace-template.json

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

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

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

流程

从命令行部署 Fuse 控制台：

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

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

      oc new-app -n myproject -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-750056-redhat-00006/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-750056-redhat-00006/fis-console-namespace-template.json
      Copy to Clipboard Toggle word wrap
      注意

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

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

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

第 3 章 非管理员用户在 OpenShift 上安装 Fuse
复制链接

您可以通过创建应用程序并将其部署到 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 Server 上自动创建的标准帐户。如果您要访问远程服务器，请使用 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-750056-redhat-00006

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

    命令输出显示 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-rest-3scale-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. 使用您的凭据（例如，使用用户名 developer 和密码 developer）登录 OpenShift 控制台。

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

流程

在本地机器上安装 CDK：

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

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

    注意

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

  4. 在进行本章中的示例之前，您应该阅读并全面了解 Red Hat CDK 3.10 入门指南。

4.1.2. 远程访问现有 OpenShift 服务器
复制链接

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

  • 服务器机器必须运行受支持的 OpenShift Container Platform 版本（如 支持的配置页面 中所述）。本指南中的示例针对版本 3.11 进行了测试。
  • 要求 OpenShift 管理员在 OpenShift 容器基础镜像和 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 中的使用 OpenShift 客户端 Binary 3.10 入门指南。

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

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

    如需了解更多详细信息，请参阅 CDK 3.10 入门指南 中的重复使用 docker Daemon。

    重要

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

其它资源

（可选） Red Hat 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 中，使用以下 OpenShift Source-to-Image (S2I)应用程序开发工作流之一来开始使用 OpenShift 上的 Fuse：

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

在本小节中，您将使用 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-750020-redhat-00002/archetypes-catalog-2.2.0.fuse-750020-redhat-00002-archetype-catalog.xml \
  -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
  -DarchetypeArtifactId=spring-boot-camel-xml-archetype \
  -DarchetypeVersion=2.2.0.fuse-750020-redhat-00002
    Copy to Clipboard Toggle word wrap

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

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

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

  2. 如果上一命令以 BUILD SUCCESS 状态退出，则现在您应该在 fuse75-spring-boot 子目录下在 OpenShift 项目中有一个新的 Fuse。您可以检查 fuse75-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 Server 上自动创建的标准帐户。如果您要访问远程服务器，请使用 OpenShift 管理员提供的 URL 和凭据。

  4. 切换到 openshift 项目（如果尚未在 openshift 项目中），如下所示： 

    oc project openshift
    Copy to Clipboard Toggle word wrap

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

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

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

  6. 现在，您可以构建和部署 fuse75-spring-boot 项目。假设您仍然登录到 OpenShift，请更改到 fuse75-spring-boot 项目的 目录，然后构建和部署项目，如下所示： 

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

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

    ...
[INFO] OpenShift platform detected
[INFO] Using project: openshift
[INFO] Creating a Service from openshift.yml namespace openshift name fuse75-spring-boot
[INFO] Created Service: target/fabric8/applyJson/openshift/service-fuse75-spring-boot.json
[INFO] Using project: openshift
[INFO] Creating a DeploymentConfig from openshift.yml namespace openshift name fuse75-spring-boot
[INFO] Created DeploymentConfig: target/fabric8/applyJson/openshift/deploymentconfig-fuse75-spring-boot.json
[INFO] Creating Route openshift:fuse75-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-10-24T12:15:06+05:30
[INFO] Final Memory: 63M/688M
[INFO] ------------------------------------------------------------------------
    Copy to Clipboard Toggle word wrap
    注意

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

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

  9. 点 fuse75-spring-boot 查看 fuse75-spring-boot 应用程序的 Overview 信息页面。

    Overview

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

  12. 单击 pod Name （本例中为 fuse75-spring-boot-xxxxx）以查看正在运行的 pod 的详细信息。

    Pod Details

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

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

  14. 关闭正在运行的 pod，

    1. 在 openshift 项目的 Project Status 页面中，点 fuse75-spring-boot 应用程序。
    2. 点 Overview 选项卡查看应用程序的概述信息页面。
    3. 点 Desired Count 旁边的 edit pod count 图标。此时会显示 Edit Count 窗口。
    4. 使用向下箭头缩减至零以停止容器集。

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. 使用 S2I 源工作流创建和部署应用程序
复制链接

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

流程

  1. 按照如下所示，登录 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 Server 上自动创建的标准帐户。如果您要访问远程服务器，请使用 OpenShift 管理员提供的 URL 和凭据。

  2. 切换到 openshift 项目（如果尚未在 openshift 项目中），如下所示： 

    oc project openshift
    Copy to Clipboard Toggle word wrap

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

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

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

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

    oc new-app s2i-fuse75-spring-boot-camel-xml

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

  7. 点 s2i-fuse75-spring-boot-camel-xml 查看快速启动的 Overview 信息页面。

    Spring Boot Camel XML Overview

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

    Spring Boot Camel XML build logs

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

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

    Spring Boot Camel XML pod details

  11. 关闭正在运行的 pod，

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

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

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

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

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

  3. 如果上述命令以 BUILD SUCCESS 状态退出，则现在您应该在 fuse75-spring-boot 子目录下在 OpenShift 项目中有一个新的 Fuse。

  4. 现在，您可以构建和部署 fuse75-spring-boot 项目。假设您仍然登录到 OpenShift，请更改到 fuse75-spring-boot 项目的 目录，然后构建和部署项目，如下所示： 

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

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

5.2. 使用 Maven archetype 创建 Spring Boot 2 项目
复制链接

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

流程

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

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

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

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

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

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

  3. 如果上述命令以 BUILD SUCCESS 状态退出，则现在您应该在 fuse75-spring-boot 子目录下在 OpenShift 项目中有一个新的 Fuse。

  4. 现在，您可以构建和部署 fuse75-spring-boot 项目。假设您仍然登录到 OpenShift，请更改到 fuse75-spring-boot 项目的 目录，然后构建和部署项目，如下所示： 

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

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

5.3. 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-starter 或 camel-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.4. Spring Boot archetype 目录
复制链接

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

Expand
表 5.1. Spring Boot Maven Archetypes
Name描述

spring-boot-camel-archetype

演示了如何根据 fabric8 Java 基础镜像在 Spring Boot 中使用 Apache Camel。

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 服务器集成。

spring-boot-camel-infinispan-archetype

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

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

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

spring-boot-camel-rest-sql-archetype

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

spring-boot-camel-xa-archetype

Spring Boot、Camel 和 XA 事务.本例演示了如何在 Spring Boot 上运行 Camel 服务，它支持两个外部事务资源上的 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。Quickstart 使用 Spring Boot 配置包含启用了 Swagger 的 CXF JAXRS 端点的应用程序。

spring-boot-cxf-jaxws-archetype

演示了如何根据 fabric8 Java 基础镜像在 Spring Boot 中使用 Apache CXF。quickstart 使用 Spring Boot 配置包含 CXF JAXWS 端点的应用程序。

重要

还提供了一个技术预览快速入门。Spring Boot Camel XA Transactions 快速启动演示了如何使用 Spring Boot 运行支持 XA 事务的 Camel 服务。此快速入门显示了两个外部事务资源的使用：一个 JMS (AMQ)代理和一个数据库(PostgreSQL)。您可以在此处找到此快速入门 ：https://github.com/jboss-fuse/spring-boot-camel-xa。

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

5.5. Spring Boot 2 archetype 目录
复制链接

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

Expand
表 5.2. Spring Boot 2 Maven Archetypes
Name描述

spring-boot-camel-archetype

演示了如何根据 fabric8 Java 基础镜像在 Spring Boot 中使用 Apache Camel。

spring-boot-camel-amq-archetype

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

spring-boot-camel-drools-archetype

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

spring-boot-camel-infinispan-archetype

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

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

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

spring-boot-camel-rest-sql-archetype

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

spring-boot-camel-xml-archetype

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

spring-boot-cxf-jaxrs-archetype

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

spring-boot-cxf-jaxws-archetype

演示了如何根据 fabric8 Java 基础镜像在 Spring Boot 中使用 Apache CXF。quickstart 使用 Spring Boot 配置包含 CXF JAXWS 端点的应用程序。

注意

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

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

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

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

5.6. 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.6.1. 合并 BOM 文件
复制链接

要将 BOM 文件合并到 Maven 项目中，请在项目的 pom.xml 文件中指定 dependencies Management 元素（或者，可能在父 POM 文件中），如下面的 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.5.0.fuse-sb2-750029-redhat-00003</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.5.0.fuse-750029-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 后，可以在不指定工件版本 的情况下 向 POM 添加 Maven 依赖项。例如，要为 camel-hystrix 组件添加依赖项，您可以在 POM 中的 dependencies 元素中添加以下 XML 片段： 

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

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

5.7. 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.5.0.fuse-750029-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

Apache Camel Spring Boot 组件为 Spring Boot 自动配置 Camel 上下文。Camel 上下文的自动配置会自动检测到 Spring 上下文中提供的 Camel 路由，并将生成者模板、消费者模板以及类型转换器注册为 Bean。Apache Camel 组件包含一个 Spring Boot starter 模块，允许您使用 starters 开发 Spring Boot 应用程序。

6.1. Camel Spring Boot 组件简介
复制链接

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

示例

<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 模块简介
复制链接

Starters 是应该在 Spring Boot 应用程序中使用的 Apache Camel 模块。每个 Camel 组件都有一个 camel-xxx-starter 模块（在 第 6.3 节 “没有入门模块的 Camel 组件列表” 部分列出了几个例外）。

开始者满足以下要求：

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

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

注意

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

6.3. 没有入门模块的 Camel 组件列表
复制链接

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

  • camel-blueprint （只针对 OSGi 引入）
  • camel-cdi （仅限 CDI 引入）
  • camel-core-osgi （仅限 OSGi 修改）
  • camel-ejb （仅限 JUnit 修改）
  • camel-eventadmin （仅限 OSGi 引入）
  • camel-ibatis （包含camel-mybatis-starter ）
  • camel-jclouds
  • camel-mina （包含camel-mina2-starter ）
  • camel-paxlogging （仅限 OSGi 修改）
  • camel-quartz （包含camel-quartz2-starter ）
  • camel-spark-rest
  • camel-swagger （包含camel-swagger-java-starter ）

6.4. 使用 Camel Spring Boot starter
复制链接

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

流程

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

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

  2. 使用 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

  3. 可选的。要让主线程阻止，以便 Camel 保持工作，请执行以下操作之一：

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

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

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

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

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

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

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

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

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

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

6.5. 关于 Spring Boot 的 Camel 上下文自动配置
复制链接

Camel Spring Boot 自动配置提供 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

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

示例

将 @Component annotated 类添加到您的 classpath 中。 

@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.7. 为 Camel Spring Boot 自动配置配置 Camel 属性
复制链接

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

流程

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

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

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

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

  2. 按照如下所示，将配置的属性用作 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.8. 配置自定义 Camel 上下文
复制链接

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

流程

  • 在 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 上下文启动前，CamelContext Configuration 和 beforeApplicationStart ( CamelContext ) 方法被调用，因此传递给此回调的 CamelContext 实例会被完全自动配置。您可以将许多 CamelContextConfiguration 实例添加到 Spring 上下文中，并且所有实例都将被执行。

6.9. 在自动配置的 CamelContext 中禁用 JMX
复制链接

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

流程

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

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

Camel 自动配置提供预配置的 ConsumerTemplate 和 ProducerTemplate 实例。您可以将它们注入到 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

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.12. Spring 类型转换 API 网桥
复制链接

Spring 由强大的 类型转换 API 组成。Spring API 与 Camel 类型转换器 API 类似。由于两个 API Camel Spring Boot 之间的相似性会自动注册桥接转换器(SpringTypeConverter)，它委托给 Spring 转换 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.13. 禁用类型转换功能
复制链接

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

流程

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

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

6.14. 在类路径中添加 XML 路由以进行自动配置
复制链接

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

流程

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

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

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

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

6.15. 为自动配置添加 XML Rest-DSL 路由
复制链接

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

流程

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

    // 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 REST 元素，而不是 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.16. 使用 Camel Spring Boot 测试
复制链接

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

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

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

流程

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

    @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。

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

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

其它资源

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

7.1. StatefulSet 资源
复制链接

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

7.2. Spring Boot Narayana 恢复控制器
复制链接

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

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

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

7.3. 配置 Spring Boot Narayana 恢复控制器
复制链接

以下示例演示了如何配置 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 扩展 for Spring Boot Narayana Recovery Controller

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

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

流程

  1. 下载 Camel Spring Boot XA 项目。 

    git clone --branch spring-boot-camel-xa-1.0.0.fuse-750020-redhat-00005 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. 安装依赖项。

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

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

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

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

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

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

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

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

  8. 扩展至所需副本数。 

    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 （在剥离一些字符（如 - ）后。

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

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

7.5. 测试成功 XA 事务
复制链接

以下工作流演示了如何测试成功的 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. 新列表包含两个消息，即 hello 和 hello-ok。hello-ok 确认消息已发送到传出队列，然后记录。您可以添加多个信息并查看日志。

7.6. 测试失败的 XA 事务
复制链接

以下工作流演示了如何测试失败的 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 代理集成
复制链接

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

8.1. 构建和部署 Spring Boot Camel A-MQ 快速入门
复制链接

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

先决条件

流程

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

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

  2. 登录 openshift 项目。 

    oc project openshift
    Copy to Clipboard Toggle word wrap

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

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

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

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

  5. 导航到 quickstart 目录 fuse75-spring-boot-camel-amq。 

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

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

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

  7. 运行 mvn 命令，将 Quickstart 部署到 OpenShift 服务器。 

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

  8. 验证 Quickstart 是否已成功运行：

    1. 导航到浏览器中的 OpenShift Web 控制台(https://OPENSHIFT_IP_ADDR，将 OPENSHIFT_IP_ADDR 替换为集群的 IP 地址)，并使用您的凭证（例如，使用用户名 developer 和密码 developer）登录控制台。
    2. 在左侧面板中，展开 Home，然后单击 Status 以查看 openshift 项目的 Project Status 页面。
    3. 点 fuse75-spring-boot-camel-amq 查看 Quickstart 的 Overview 信息页面。
    4. 在左侧面板中，展开 Workloads。
    5. 单击 Pods，然后单击 fuse75-spring-boot-camel-amq-xxxxx。此时会显示 Quickstart 的 pod 详情。

    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
  9. 要查看 Web 界面上的路由，请点 Open Java Console 并检查 AMQ 队列中的信息。

第 9 章 将 Spring Boot 与 Kubernetes 集成
复制链接

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

9.1. Spring Boot 外部化配置
复制链接

在 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 机密 是一种向已部署的应用提供敏感数据（如密码、证书等）的机制。

9.1.3. Spring Cloud Kubernetes 插件
复制链接

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

9.1.4. 启用带有 Kubernetes 集成的 Spring Boot
复制链接

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

流程

  1. 通过在 Spring Boot Maven 项目的 pom.xml 文件中添加以下 Maven 依赖项来启用 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 属性源运行教程
复制链接

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

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

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

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

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

  2. 登录 OpenShift，并切换到要部署应用的 OpenShift 项目。例如，要以 developer 用户身份登录并部署到 openshift 项目，请输入以下命令： 

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

  3. 在命令行中，切换到新的 fuse75-configmap 项目目录，并为此应用创建 Secret 对象。 

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

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

  4. 构建和部署快速入门应用程序。在 fuse75-configmap 项目顶层，输入： 

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

  5. 查看应用日志，如下所示：

    1. 导航到浏览器中的 OpenShift Web 控制台(https://OPENSHIFT_IP_ADDR，将 OPENSHIFT_IP_ADDR 替换为集群的 IP 地址)，并使用您的凭证（例如，使用用户名 developer和密码 developer ）登录控制台。
    2. 在左侧面板中，展开 Home。单击 Status 以查看 Project Status 页面。此时会显示所选命名空间中的所有现有应用程序（如 openshift）。
    3. 单击 fuse75-configmap，以查看 Quickstart 的 Overview 信息页面。
    4. 在左侧面板中，展开 Workloads。
    5. 单击 Pods，然后单击 fuse75-configmap-xxxx。此时会显示应用程序的 Pod 详情。
    6. 点 Logs 选项卡查看应用程序日志。

  6. 默认接收者列表在 src/main/resources/application.properties 中配置，将生成的消息发送到两个 dummy 端点： direct:async-queue 和 direct: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 对象更新 fuse75-configmap 应用配置前，您必须提供 fuse75-configmap 应用程序权限来查看 OpenShift ApiServer 中的数据。输入以下命令为 fuse75-configmap 应用程序服务帐户授予 view 权限： 

    oc policy add-role-to-user view system:serviceaccount:openshift: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 路由的接收者列表，将其配置为将生成的消息发送到 三个 虚拟端点： direct:async-queue,direct: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 decorated。
Spring bean registry
使用 requisite 注解时，在 Spring bean registry 中注册了配置属性 bean。
与 Camel bean registry 集成
Camel bean registry 会自动与 Spring bean registry 集成，以便在 Camel 路由中引用注册的 Spring Bean。

QuickstartConfiguration 类

fuse75-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. 创建示例 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 外部化配置集成，Spring Cloud Kubernetes 插件必须配置有 secret 的挂载路径。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 的 recipients 属性中。

设置查看权限

如 Secret 的 deployment.yml 文件中所示，serviceAccountName 在项目的 deployment.yml 文件中设置为 qs-camel-config。因此，您需要输入以下命令来启用 Quickstart 应用的 查看 权限（假设它部署到 test 项目命名空间中）： 

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 将查找由应用程序命名的 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. 应用 application.yaml ConfigMap 属性
复制链接

对于大多数情况，单个属性可以正常工作，但有时我们找到 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. 应用 application.properties ConfigMap 属性
复制链接

您还可以在 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的服务帐户）。例如，将 view 权限添加到 default 服务帐户： 

    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 具有用于存储敏感数据的 机密 的概念，如密码、OAuth 令牌等。Spring cloud Kubernetes 插件提供与 Secret 集成，使 secret 可以被 Spring Boot 访问。

启用时的 Secrets 属性源将从以下源查找 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 Secrets
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
设置要查找的机密的名称。类型为 String，默认为 ${spring.application.name}。
spring.cloud.kubernetes.secrets.labels
设置用于查找 secret 的标签。此属性的行为 基于映射的绑定。type 是 java.util.Map，默认为 null。
spring.cloud.kubernetes.secrets.paths
设置挂载 secret 的路径。此属性的行为 基于集合的绑定。type 是 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 级别
复制链接

以下级别的 reload 支持属性 spring.cloud.kubernetes.reload.strategy ：

refresh

（默认） 仅重新加载标有 @ConfigurationProperties 或 @RefreshScope 的配置 Bean。此重新加载级别利用 Spring Cloud 上下文的刷新功能。

注意

当重新加载策略设置为 刷新 时，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 操作模式
复制链接

重新载入功能支持两种操作模式：

event
（默认） 监视使用 Kubernetes API (Web 套接字)的 ConfigMap 或 secret 中的更改。任何事件都将在配置上生成重新检查，并在发生更改时重新加载。需要服务帐户的 view 角色来侦听配置映射更改。更高级别角色（例如：secret 需要编辑）（默认不会监控secrets）。
polling
定期从配置映射和 secret 重新创建配置，以查看它是否已改变。可以使用属性 spring.cloud.kubernetes.reload.period 配置轮询周期，默认为 15 秒。它要求角色与被监控的属性源相同。例如，这意味着，对已挂载的 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、shutdown)。type 是 Enum，默认为 refresh。
spring.cloud.kubernetes.reload.mode
指定如何侦听属性源(事件、轮询)。type 是 Enum，默认为 事件。
spring.cloud.kubernetes.reload.period
使用 轮询 策略时验证更改的周期（毫秒）。类型为 Long，默认为 15000。

请注意以下几点：

  • spring.cloud.kubernetes.reload gem 属性不应在 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-750020-redhat-00002/archetypes-catalog-2.2.0.fuse-750020-redhat-00002-archetype-catalog.xml \
  -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
  -DarchetypeArtifactId=karaf-camel-log-archetype \
  -DarchetypeVersion=2.2.0.fuse-750020-redhat-00002
    Copy to Clipboard Toggle word wrap

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

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

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

  4. 如果上述命令以 BUILD SUCCESS 状态退出，则现在您应该在 fuse75-karaf-camel-log 子目录下在 OpenShift 项目中有一个新的 Fuse。

  5. 现在，您可以构建和部署 fuse75-karaf-camel-log 项目。假设您仍已登录到 OpenShift，请更改到 fuse75-karaf-camel-log 项目的 目录，然后构建并部署项目，如下所示： 

    cd fuse75-karaf-camel-log
mvn fabric8:deploy -Popenshift
    Copy to Clipboard Toggle word wrap
注意

有关可用 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

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

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 目录
复制链接

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 核心捆绑包功能
复制链接

bundle 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. 设置属性 Placeholder 服务选项
复制链接

bundle 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. 添加自定义属性占位符解析器
复制链接

您可以添加自定义占位符解析器来支持特定的需求，如自定义加密。您还可以使用 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. 您可以在配置管理中引用解析器，如下所示：

    属性

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

10.4.5. 解析策略列表
复制链接

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

  1. 解析策略列表
Expand

prefix

示例

描述

env

env:JAVA_HOME

从 OS 环境变量中查找属性。

'sys

sys:java.version

从 Java JVM 系统属性中查找属性。

'service

service:amq

使用服务命名约定，从 OS 环境变量中查找属性。

service.host

service.host:amq

使用服务命名规则从 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. Property 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 网桥添加，ConfigMap 必须使用 karaf.pid 标记。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 Config Admin 选项
复制链接

Fabric8 Karaf Config Admin 支持以下选项：

Expand
Namedefault描述

fabric8.config.plugin.enabled

false

enable 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 all ConfigMaps，值为 A 或 B，标签 database.name 等于 my.oracle.datasource"。

重要

ConfigurationPlugin 需要 Aries Blueprint CM 1.0.9 或更高版本。

10.6. 添加 Fabric8 Karaf 蓝图支持
复制链接

fabric8-karaf-blueprint 使用来自 fabric8-karaf-core 的 Aries PropertyEvaluator 和属性占位符来解析 Blueprint XML 文件中的占位符。

流程

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

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

示例

fabric8 evaluator 支持串联的 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-check 和 http://0.0.0.0:8181/health-check URL，供 Kubernetes 用于就绪度和存活度探测。

注意

这些 URL 只有在满足以下条件时，才会以 HTTP 200 状态代码响应：

  • OSGi 框架已启动。
  • 所有 OSGi 捆绑包都已启动。
  • 所有引导功能都已安装。
  • 所有部署的 BluePrint 捆绑包都处于创建的状态。
  • 所有部署的 SCR 捆绑包都处于 active、registered 或 factory 状态。
  • 所有 Web 捆绑包都部署到 Web 服务器。
  • 所有创建的 Camel 上下文都处于 started 状态。

流程

  1. 打开项目的 pom.xml，并在 startupFeatures 部分中添加 fabric8-karaf-checks 功能。

    pom.xml

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

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

10.8. 添加自定义健康检查
复制链接

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

流程

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

    pom.xml

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

    注意

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

示例

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

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

    oc login -u developer -p developer
oc policy add-role-to-user view -z default
    Copy to Clipboard Toggle word wrap

  2. 查看 OpenShift 模板上已安装的 Fuse。 

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

  3. 输入以下命令来创建 使用 EAP quickstart 运行 Red Hat Fuse 7.5 Camel CDI 所需的资源。它为快速入门创建部署配置和构建配置。终端会显示有关 Quickstart 和创建的资源的信息。 

    oc new-app s2i-fuse75-eap-camel-cdi

--> Creating resources ...
    service "s2i-fuse75-eap-camel-cdi" created
    service "s2i-fuse75-eap-camel-cdi-ping" created
    route.route.openshift.io "s2i-fuse75-eap-camel-cdi" created
    imagestream.image.openshift.io "s2i-fuse75-eap-camel-cdi" created
    buildconfig.build.openshift.io "s2i-fuse75-eap-camel-cdi" created
    deploymentconfig.apps.openshift.io "s2i-fuse75-eap-camel-cdi" created
--> Success
    Access your application via route 's2i-fuse75-eap-camel-cdi-OPENSHIFT_IP_ADDR'
    Build scheduled, use 'oc logs -f bc/s2i-fuse75-eap-camel-cdi' to track its progress.
    Run 'oc status' to view your app.
    Copy to Clipboard Toggle word wrap
  4. 导航到浏览器中的 OpenShift Web 控制台(https://OPENSHIFT_IP_ADDR，将 OPENSHIFT_IP_ADDR 替换为集群的 IP 地址)，并使用您的凭证（例如，使用用户名 developer和密码 developer ）登录控制台。
  5. 在左侧面板中，展开 Home。单击 Status 以查看 Project Status 页面。此时会显示所选命名空间中的所有现有应用程序（如 openshift）。

  6. 点 s2i-fuse75-eap-camel-cdi 查看快速启动的 Overview 信息页面。

    eap image s2i source 08

  7. 点 Resources 选项卡，然后点 Routes 部分显示的链接来访问应用程序。

    eap image s2i source 07

    链接的格式为 http://s2i-fuse75-eap-camel-cdi-OPENSHIFT_IP_ADDR。在浏览器中显示类似如下的消息： 

    Hello world from 172.17.0.3
    Copy to Clipboard Toggle word wrap

  8. 您还可以使用 URL 中的 name 参数指定名称。例如，如果您在浏览器中输入 URL http://s2i-fuse75-eap-camel-cdi-openshift.apps.cluster-name.openshift.com/?name=jdoe，您会看到响应： 

    Hello jdoe from 172.17.0.3
    Copy to Clipboard Toggle word wrap
  9. 点 View Logs 查看应用程序的日志。

  10. 关闭正在运行的 pod，

    1. 单击 Overview 选项卡，以返回到应用的概览信息页面。
    2. 点 Desired Count 旁边的 eap image s2i source 06 图标。此时会显示 Edit Count 窗口。
    3. 使用向下箭头缩减至零以停止容器集。

11.2. JBoss EAP 应用程序的结构
复制链接

您可以在以下位置找到 Red Hat Fuse 7.5 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

Camel on EAP 应用程序的目录结构如下： 

  ├── 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描述

JBoss Fuse 7.5 Camel A-MQ with EAP (eap-camel-amq-template)

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

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

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

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

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

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

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

Red Hat Fuse 7.5 Camel JPA + MySQL (Ephemeral) with EAP eap-camel-jpa-template

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

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

12.1. 关于卷和卷类型
复制链接

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

卷类型包括：

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

卷在 Pod 级别配置，只能使用 hostPath 直接访问外部存储。因此，更难以管理作为 hostPath 卷的多个 Pod 的共享资源的访问权限。

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 集群中命名实体公开。要从项目访问此存储，必须创建 PersistentVolumeClaims 来访问 PersistentVolume。使用特定访问模式的自定义存储声明为每个项目创建 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 使用卷挂载来定义文件系统挂载位置和卷，以定义参考 PersistentVolumeClaims。

流程

  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& gt; 替换为 Maven 项目名称，如 spring-boot-camel。

第 13 章 在 OpenShift 上修补 Fuse
复制链接

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

对 OpenShift 镜像上的 Fuse 进行补丁
更新 OpenShift 服务器上的 OpenShift 镜像上的 Fuse，以便新应用程序构建基于 Fuse 基础镜像的补丁版本。
使用 BOM 补丁应用程序依赖项
更新项目 POM 文件中的依赖项，以便应用程序使用 Maven 工件的补丁版本。
对 OpenShift 模板上的 Fuse 进行补丁
更新 OpenShift 服务器上的 Fuse on OpenShift 模板，以便在 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)文件，该文件定义了 OpenShift 上 Fuse 支持的所有 Maven 工件的版本。当您更新 BOM 文件版本时，会自动更新项目的 POM 中 OpenShift Maven 工件上所有 Fuse 的版本。

由 Fuse 在 OpenShift Maven archetype 或 OpenShift 模板上的 Fuse 生成的 POM 文件具有标准布局，它使用 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 项目中。 

    $ oc get is -n openshift
NAME                            DOCKER REPO                                              TAGS                           UPDATED
fuse7-console                   172.30.1.1:5000/openshift/fuse7-console                  1.0,1.1,1.2,1.3,1.4,1.5            About an hour ago
fuse7-eap-openshift             172.30.1.1:5000/openshift/fuse7-eap-openshift            1.0,1.1,1.2,,1.3,1.4,1.5           About an hour ago
fuse7-java-openshift            172.30.1.1:5000/openshift/fuse7-java-openshift           1.0,1.1,1.2,1.3,1.4,1.5            About an hour ago
fuse7-karaf-openshift           172.30.1.1:5000/openshift/fuse7-karaf-openshift          1.0,1.1,1.2,1.3,1.4,1.5            About an hour ago...
fuse-apicurito-generator        172.30.1.1:5000/openshift/fuse-apicurito-generator       1.2,1.3,1.4,1.5                    About an hour ago...
apicurito-ui                    172.30.1.1:5000/openshift/apicurito-ui                   1.2,1.3,1.4,1.5                    About an hour ago...
    Copy to Clipboard Toggle word wrap 

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

注意

13.3. 
复制链接

流程

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

  2. BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-750056-redhat-00006
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
    注意

13.4. 
复制链接

13.4.1. 
复制链接

<?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.5.0.fuse-750029-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

13.4.2. 
复制链接

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

    <fuse.version>7.5.0.fuse-750029-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

13.4.3. 
复制链接

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

    <fuse.version>7.5.0.fuse-750029-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

13.5. 
复制链接

Expand
表 13.1. 
  

Red Hat Fuse 7.0.0 GA

7.5.0.fuse-750029-redhat-00002

7.0.1.fuse-000008-redhat-4

附录 A. 
复制链接

A.1. 
复制链接

A.2. 
复制链接

注意

A.2.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.5.0.fuse-sb2-750029-redhat-00003</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.2.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.5.0.fuse-750029-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. 
复制链接

B.1. 
复制链接

B.2. 
复制链接

  • 示例

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

B.3. 
复制链接

B.3.1. 
复制链接

注意

示例

<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. 
复制链接

C.1. 
复制链接

重要

C.2. 
复制链接

Configuration

C.3. 
复制链接

流程

<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.4. 
复制链接

C.4.1. 
复制链接

Expand
表 C.1. 
目标描述

fabric8:build

fabric8:resource

fabric8:apply

fabric8:resource-apply

Expand
表 C.2. 
目标描述

fabric8:run

fabric8:deploy

fabric8:undeploy

fabric8:start

fabric8:stop

fabric8:log

fabric8:debug

fabric8:watch

C.4.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.4.3. 
复制链接

Expand
表 C.3. 
Configuration描述default

fabric8.skipResourceValidation

false

fabric8.failOnValidationError

false

fabric8.build.switchToDeployment

false

fabric8.openshift.trimImageInContainerSpec

false

C.5. 
复制链接

注意

C.5.1. 
复制链接

C.5.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.5.2.1. 
复制链接

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

C.5.2.2. 
复制链接

fuse7/fuse-eap-openshift:1.5
fuse7/fuse-java-openshift:1.5
fuse7/fuse-karaf-openshift:1.5
Copy to Clipboard Toggle word wrap
C.5.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.5.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.5.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.5.3. Spring Boot
复制链接

Expand
表 C.4. 
元素描述default

assemblyRef

 

targetDir

/deployments

jolokiaPort

8778

mainClass

 

webPort

8080

color

 

C.5.4. 
复制链接

Expand
表 C.5. 
元素描述default

baseDir

/deployments

jolokiaPort

8778

mainClass

 

user

jboss:jboss:jboss

webPort

8080

附录 D. 
复制链接

D.1. 
复制链接

D.2. 
复制链接

流程

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

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

示例

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

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

  3. [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. 选项
复制链接

Expand
表 D.1. 
参数默认值描述

downloadVersion

true

failOnError

false

logUnparseable

false

includeJava

true

includeXML

true

includeTest

false

includes

-

excludes

-

ignoreUnknownComponent

true

ignoreIncapable

true

ignoreLenientProperties

true

showAll

false

D.5. 
复制链接

流程

    $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. 
复制链接

`Karaf4: install karaf:assembly karaf:archive -DskipTests -e`
Copy to Clipboard Toggle word wrap

E.3. 
复制链接

  • 默认值为 false。

E.4. 
复制链接

E.5. 
复制链接

  • 默认值为 false。

  • 默认 CA 证书设置为 /var/run/secrets/kubernetes.io/serviceaccount/ca.crt。

附录 F. 
复制链接

F.1. 
复制链接

对于 OpenShift 镜像上的 Fuse，它可以：

  • 根据容器内核设置 CICompilerCount
  • 当容器内存限制低于 300MB 时禁用 C2 JIT 编译器
  • 以下 300MB 时，对默认堆大小使用容器内存限值的一体

F.2. Fuse on OpenShift 镜像的默认行为
复制链接

在 OpenShift 上的 Fuse 中，应用构建的基础镜像可以是 Java 镜像（用于 Spring Boot 应用程序）或 Karaf 镜像（用于 Karaf 应用程序）。在 OpenShift 镜像上的 Fuse 执行一个脚本，该脚本读取容器限制，并使用这些限制作为分配资源的基础。默认情况下，脚本将以下资源分配给 JVM：

  • 容器内存限值的 50%
  • 容器核心限制的 50%

这有一些例外。对于 Karaf 和 Java 镜像，当物理内存低于 300MB 阈值时，堆大小将恢复为默认堆大小的一次性，而不是一对一对一的。

F.3. 在 OpenShift 镜像上自定义 Fuse 调整
复制链接

该脚本设置 CONTAINER_MAX_MEMORY 和 CONTAINER_CORE_LIMIT 环境变量，由自定义应用读取以调优其内部资源。另外，您可以指定以下运行时环境变量，供您自定义运行应用程序的 JVM 上的设置：

  • JAVA_OPTIONS
  • JAVA_MAX_MEM_RATIO

要显式自定义限制，您可以在 Maven 项目中编辑 deployment.yml 文件来设置 JAVA_MAX_MEM_RATIO 环境变量。

示例

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.4. 调整第三方库
复制链接

红帽建议您为 Jetty 等任何第三方 Java 库自定义限制。如果您没有手动自定义限制，这些库将使用给定的默认限制。启动脚本会公开一些环境变量来描述应用程序可使用的容器限制：

CONTAINER_CORE_LIMIT
计算的内核限制
CONTAINER_MAX_MEMORY
提供给容器的内存限值

法律通告
复制链接

Copyright © 2023 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
返回顶部
Red Hat logoGithubredditYoutubeTwitter

学习

尝试、购买和销售

社区

关于红帽文档

通过我们的产品和服务，以及可以信赖的内容，帮助红帽用户创新并实现他们的目标。 了解我们当前的更新.

让开源更具包容性

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。欲了解更多详情，请参阅红帽博客.

關於紅帽

我们提供强化的解决方案，使企业能够更轻松地跨平台和环境（从核心数据中心到网络边缘）工作。

Theme

© 2025 Red Hat