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 集群:
- 配置 Red Hat Container Registry 身份验证。
- 在 OpenShift 镜像和模板上安装 Fuse。
2.1. 配置 Red Hat Container Registry 身份验证
在导入并使用 OpenShift 镜像流和模板上的 Red Hat Fuse 前,您必须配置身份验证到 Red Hat 容器 registry。
流程
以管理员身份登录 OpenShift 服务器:
oc login -u system:admin
登录到您要安装镜像流的 OpenShift 项目。我们建议您将
openshift
项目用于 OpenShift 镜像流上的 Fuse。oc project openshift
使用您的红帽客户门户网站帐户或 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
注意您需要在镜像流所在的每个命名空间以及使用 registry.redhat.io 的每个命名空间中创建一个 docker-registry secret。
要使用 secret 为 pod 拉取镜像,请将 secret 添加到您的服务帐户中。服务帐户的名称必须与服务帐户 pod 使用的名称匹配。以下示例使用
default
,这是 default 服务帐户。oc secrets link default <pull_secret_name> --for=pull
要使用 secret 推送和拉取构建镜像,该 secret 必须在 pod 内挂载。要挂载 secret,请使用以下命令:
oc secrets link builder <pull_secret_name>
如果您不想使用红帽帐户用户名和密码来创建 secret,您应该使用 registry 服务帐户 创建身份验证令牌。
如需更多信息,请参阅:
2.2. 在 OpenShift 4.x 服务器上安装 Fuse 镜像流和模板
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 忽略或不予管理。
先决条件
- 您可以访问 OpenShift 服务器。
- 您已为 Red Hat Container Registry 配置了身份验证。
- 另外,如果您要在安装 OpenShift 仪表板后在 OpenShift 仪表板中看到 Fuse 模板,您必须首先安装服务目录和模板服务代理,如 OpenShift 文档https://docs.openshift.com/container-platform/4.1/applications/service_brokers/installing-service-catalog.html所述。
流程
- 启动 OpenShift 4 服务器。
以管理员身份登录 OpenShift 服务器。
oc login -u system:admin
验证您是否使用您为其创建 docker-registry secret 的项目。
oc project openshift
查看 Samples operator 的当前配置。
oc get configs.samples.operator.openshift.io -n openshift-cluster-samples-operator -o yaml
配置 Samples operator 以忽略添加的 fuse 模板和镜像流。
oc edit configs.samples.operator.openshift.io -n openshift-cluster-samples-operator
添加 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-fuse76-eap-camel-amq - s2i-fuse76-eap-camel-cdi - s2i-fuse76-eap-camel-cxf-jaxrs - s2i-fuse76-eap-camel-cxf-jaxws - s2i-fuse76-eap-camel-jpa - s2i-fuse76-karaf-camel-amq - s2i-fuse76-karaf-camel-log - s2i-fuse76-karaf-camel-rest-sql - s2i-fuse76-karaf-cxf-rest - s2i-fuse76-spring-boot-camel - s2i-fuse76-spring-boot-camel-amq - s2i-fuse76-spring-boot-camel-config - s2i-fuse76-spring-boot-camel-drools - s2i-fuse76-spring-boot-camel-infinispan - s2i-fuse76-spring-boot-camel-rest-sql - s2i-fuse76-spring-boot-camel-rest-3scale - s2i-fuse76-spring-boot-camel-xa - s2i-fuse76-spring-boot-camel-xml - s2i-fuse76-spring-boot-cxf-jaxrs - s2i-fuse76-spring-boot-2-camel-amq - s2i-fuse76-spring-boot-2-camel-config - s2i-fuse76-spring-boot-2-camel-drools - s2i-fuse76-spring-boot-2-camel-infinispan - s2i-fuse76-spring-boot-2-camel-rest-3scale - s2i-fuse76-spring-boot-2-camel-rest-sql - s2i-fuse76-spring-boot-2-camel - s2i-fuse76-spring-boot-2-camel-xa - s2i-fuse76-spring-boot-2-camel-xml - s2i-fuse76-spring-boot-2-cxf-jaxrs - s2i-fuse76-spring-boot-2-cxf-jaxws - s2i-fuse76-spring-boot-2-cxf-jaxrs-xml - s2i-fuse76-spring-boot-2-cxf-jaxws-xml
在 OpenShift 镜像流上安装 Fuse。
BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003 oc create -n openshift -f ${BASEURL}/fis-image-streams.json
注意如果显示错误,并显示信息
Error from server (AlreadyExists): imagestreams.image.openshift.io <imagestreamname> already exists
,使用以下命令将现有镜像流替换为最新的镜像流。oc replace --force -n openshift -f ${BASEURL}/fis-image-streams.json
在 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.0.fuse-760043-redhat-00003/quickstarts/${template} done
安装 Spring Boot 2 Quickstart 模板:
for template in spring-boot-2-camel-amq-template.json \ spring-boot-2-camel-config-template.json \ spring-boot-2-camel-drools-template.json \ spring-boot-2-camel-infinispan-template.json \ spring-boot-2-camel-rest-3scale-template.json \ spring-boot-2-camel-rest-sql-template.json \ spring-boot-2-camel-template.json \ spring-boot-2-camel-xa-template.json \ spring-boot-2-camel-xml-template.json \ spring-boot-2-cxf-jaxrs-template.json \ spring-boot-2-cxf-jaxws-template.json \ spring-boot-2-cxf-jaxrs-xml-template.json \ spring-boot-2-cxf-jaxws-xml-template.json ; do oc create -n openshift -f \ https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-760039-redhat-00001/quickstarts/${template} done
(可选) 查看 OpenShift 模板上安装的 Fuse:
oc get template -n openshift
2.2.1. 在 OpenShift 4.x 中设置 Fuse 控制台
在 OpenShift 4.x 上,设置 Fuse 控制台涉及保护、安装和部署它。
首先,您必须生成客户端证书,以便可以保护 Fuse 控制台,如 第 2.2.1.1 节 “生成证书来保护 OpenShift 4.x 上的 Fuse 控制台” 所述。
生成客户端证书后,您可以选择安装和部署 Fuse 控制台:
第 2.2.1.2 节 “使用 OperatorHub 在 OpenShift 4.x 上安装和部署 Fuse 控制台”
您可以使用 Fuse Console Operator 安装和部署 Fuse 控制台,以便它能够访问特定命名空间中的 Fuse 应用程序。
第 2.2.1.3 节 “使用命令行在 OpenShift 4.x 上安装和部署 Fuse 控制台”
您可以使用命令行和其中一个 Fuse 控制台模板来安装和部署 Fuse 控制台,以便它可以访问 OpenShift 集群或特定命名空间中的多个命名空间中的 Fuse 应用程序。
- Fuse 控制台的用户管理由 OpenShift 处理。
- 基于角色的访问控制(在部署后访问 Fuse 控制台的用户)还不适用于 OpenShift 上的 Fuse。
2.2.1.1. 生成证书来保护 OpenShift 4.x 上的 Fuse 控制台
在 OpenShift 4.x 上,若要在 Fuse 控制台代理和 Jolokia 代理之间保持连接,您必须在部署 Fuse 控制台前生成客户端证书。您必须使用服务签名证书颁发机构私钥来为客户端证书签名。
您必须为每个 OpenShift 集群生成并签署单独的客户端证书。对于多个集群,不要使用相同的证书。
先决条件
-
有
集群管理员
对 OpenShift 集群的访问权限。 如果您要为多个 OpenShift 集群生成证书,并且之前在当前目录中为不同的集群生成证书,请执行以下操作之一以确保为当前集群生成不同的证书:
-
从当前目录中删除现有证书文件(如
ca.crt
、ca.key
和ca.srl
)。 更改到其他工作目录。例如,如果您的当前工作目录命名为
cluster1
,请创建一个新的cluster2
目录,并将工作目录改为其中:mkdir ../cluster2
cd ../cluster2
-
从当前目录中删除现有证书文件(如
流程
以具有集群管理员访问权限的用户身份登录 OpenShift:
oc login -u <user_with_cluster_admin_role>
执行以下命令来检索服务签名证书颁发机构密钥:
检索证书:
oc get secrets/signing-key -n openshift-service-ca -o "jsonpath={.data['tls\.crt']}" | base64 --decode > ca.crt
检索私钥:
oc get secrets/signing-key -n openshift-service-ca -o "jsonpath={.data['tls\.key']}" | base64 --decode > ca.key
生成客户端证书,如 Kubernetes 证书管理 中所述,使用
easyrsa
、openssl
或cfssl
。以下是使用 openssl 的示例命令:
生成私钥:
openssl genrsa -out server.key 2048
编写 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
生成 CSR:
openssl req -new -key server.key -out server.csr -config csr.conf
发布签名证书:
openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 10000 -extensions v3_ext -extfile csr.conf
后续步骤
您需要此证书来为 Fuse 控制台创建 secret,如以下部分所述,具体取决于您要安装 Fuse 控制台的方式:
2.2.1.2. 使用 OperatorHub 在 OpenShift 4.x 上安装和部署 Fuse 控制台
要在 OpenShift 4.x 上安装 Fuse 控制台,您可以使用 OpenShift OperatorHub 提供的 Fuse Console Operator。要部署 Fuse 控制台,请创建一个已安装的 Operator 实例。
前提条件
-
有
集群管理员
对 OpenShift 集群的访问权限。 - 您已为 Fuse 控制台生成客户端证书,如生成证书 以保护 OpenShift 4.x 上的 Fuse 控制台 中所述。
流程
安装和部署 Fuse 控制台:
-
以具有集群管理员访问权限的用户身份登录 Web 浏览器中的 OpenShift 控制台。
- 选择 Home > Projects,然后选择您要添加 Fuse 控制台的项目。
- 点 Operators,然后点 OperatorHub。
- 在搜索字段窗口中,键入 Fuse Console 来过滤操作器列表。
- 点 Fuse Console Operator。
在 Fuse Console Operator 安装窗口中,点 Install。
Create Operator Subscription 表单将打开。
对于 安装模式,您可以将 Fuse Console Operator 安装到特定命名空间(当前 OpenShift 项目)。
请注意,在安装操作器后,您可以选择部署 Fuse 控制台以监控集群中的所有命名空间中的应用程序,或者仅监控安装了 Fuse Console operator 的命名空间中的应用程序。
对于 Approval Strategy,您可以选择 Automatic 或 Manual 来配置 OpenShift 如何处理 Fuse Console Operator 的更新。
- 如果选择 Automatic 更新,当有新版本的 Fuse Console Operator 可用时,OpenShift Operator Lifecycle Manager (OLM)将自动升级 Fuse 控制台的运行实例,而无需人为干预。
- 如果选择手动 更新,则当有新版 Operator 可用时,OLM 会创建更新请求。作为集群管理员,您必须手动批准该更新请求,才可将 Fuse Console Operator 更新至新版本。
点 Subscribe.
OpenShift 在当前命名空间中安装 Fuse Console Operator。
- 要验证安装,点 Operators,然后点 Installed Operators。您可以在操作器列表中看到 Fuse 控制台。
在终端窗口中,使用以下命令,使用您在 OpenShift 4.x 上保护 Fuse 控制台 生成的证书来创建 secret 并在 Fuse 控制台中挂载它,其中 APP_NAME 是 Fuse Console Deployment 的名称(如
fuse-console
)。oc create secret tls APP_NAME-tls-proxying --cert server.crt --key server.key
例如,如果 Fuse Console 应用程序的名称是 fuse-console,请输入以下命令:
oc create secret tls fuse-console-tls-proxying --cert server.crt --key server.key
如果成功,这个命令会返回一个响应来确认创建了 secret,例如:
secret/fuse-console-operator-tls-proxying created
使用 OpenShift Web 控制台部署 Fuse 控制台:
- 在 Installed Operators 列表中,单击 Name 列下的 Fuse Console。
在 Provided APIs 下的 Overview 页面中,点 Create Instance。此时会打开一个新的自定义资源定义(CRD)文件。
默认情况下,Fuse Console 部署到当前命名空间中。
如果要部署 Fuse 控制台来发现和管理当前命名空间中的应用程序,请跳至下一步。
另外,如果要部署 Fuse 控制台,以在集群中的所有命名空间中发现和管理应用程序(以及您是一个经过身份验证的用户),请通过将
spec.type
字段的值从namespace
改为cluster
来编辑 CRD 文件。点 Create。
Fuse Console CRD 页面将打开显示新的 Fuse 控制台服务。
打开 Fuse 控制台:
获取 Fuse 控制台 URL:
- 在 OpenShift Web 控制台中,选择 Networking > Routes。
-
在命令行中键入
oc get routes
命令。
在 Web 浏览器中,打开 Fuse 控制台 URL,然后登录。
浏览器中打开了 Authorize Access 页面,其中列出了所需权限。
点击 Allow selected permissions。
Fuse 控制台在浏览器中打开,并显示您有权访问的 Fuse 应用程序 pod。
对于您要查看的应用程序,点 Connect。
此时将打开一个新浏览器窗口,显示 Fuse 控制台中的应用程序。
2.2.1.3. 使用命令行在 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.0.fuse-760043-redhat-00003/fuse-console-namespace-os4.json
先决条件
- 在安装和部署 Fuse 控制台前,您必须生成一个使用服务签名证书颁发机构签名的客户端证书,如生成证书以保护 OpenShift 4.x 上的 Fuse 控制台安全 中所述。
-
有 OpenShift
集群的集群管理员角色
。 - 已安装 Fuse Console 镜像流(以及其他 Fuse 镜像流),如 在 OpenShift 4.x 服务器上安装 Fuse 镜像流和模板 中所述。
流程
使用以下命令验证是否安装了 Fuse Console 镜像流,以检索所有模板的列表:
oc get template -n openshift
另外,如果要使用新发行标签更新已安装的镜像流,请使用以下命令将 Fuse Console 镜像导入到 openshift 命名空间:
oc import-image fuse7/fuse7-console:1.6 --from=registry.redhat.io/fuse7/fuse-console:1.6 --confirm -n openshift
运行以下命令来获取 Fuse Console APP_NAME 值:
对于集群模板:
oc process --parameters -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fuse-console-cluster-os4.json
对于命名空间模板:
oc process --parameters -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fuse-console-namespace-os4.json
从您在 OpenShift 4.x 上保护 Fuse 控制台 生成的证书,使用以下命令创建 secret 并将其挂载到 Fuse 控制台中(其中 APP_NAME 是 Fuse Console 应用程序的名称)。
oc create secret tls APP_NAME-tls-proxying --cert server.crt --key server.key
运行以下命令创建新应用(其中 $project 是 OpenShift 项目的名称,$APP_NAME 是以上步骤中获取的应用程序的名称,$DOMAIN_NAME 是用于访问 Fuse 控制台的主机名:
对于集群模板:
oc new-app -n $project -f {templates-base-url}/fuse-console-cluster-os4.json -p ROUTE_HOSTNAME=$APP_NAME.$DOMAIN_NAME -p APP_NAME=$APP_NAME
对于命名空间模板:
oc new-app -n myproject -f {templates-base-url}/fuse-console-namespace-os4.json
运行以下命令,获取 Fuse 控制台部署的状态和 URL:
oc status
- 要从浏览器访问 Fuse 控制台,请使用在第 6 步中返回的 URL (例如 https://fuse-console.192.168.64.12.nip.io)。
2.2.1.4. 在 OpenShift 4.x 上升级 Fuse 控制台
Red Hat OpenShift 4.x 处理对 Operator 的更新,包括 Red Hat Fuse operator。如需更多信息,请参阅 Operator OpenShift 文档。
另外,Operator 更新可以根据应用程序的配置方式触发应用程序升级。
对于 Fuse 控制台应用程序,您还可以通过编辑应用程序自定义资源定义的 .spec.version
字段来触发对应用程序的升级。
前提条件
- 有 OpenShift 集群管理员权限。
流程
升级 Fuse 控制台应用程序:
在终端窗口中,使用以下命令更改应用程序自定义资源定义的
.spec.version
字段:oc patch <project-name> <custom-resource-name> --type='merge' -p '{"spec":{"version":"1.7.1"}}'
例如:
oc patch myproject example-fuseconsole --type='merge' -p '{"spec":{"version":"1.7.1"}}'
检查应用程序的状态是否已更新:
oc get myproject
响应显示有关应用程序的信息,包括版本号:
NAME AGE URL IMAGE example-fuseconsole 1m https://fuseconsole.192.168.64.38.nip.io docker.io/fuseconsole/online:1.7.1
当您更改
.spec.version
字段的值时,OpenShift 会自动重新部署应用。检查版本更改触发的重新部署状态:
oc rollout status deployment.v1.apps/example-fuseconsole
成功部署会显示这个响应:
deployment "example-fuseconsole" successfully rolled out
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 配置了身份验证。
流程
- 启动 OpenShift 4.x 服务器。
- 在 Web 浏览器中,导航到浏览器中的 OpenShift 控制台。使用您的凭证登录到控制台。
- 点 Catalog,然后点 OperatorHub。
在搜索字段中,键入 API Designer。
您可以在右侧面板中看到 API Designer 卡。
- 点 API Designer。此时会出现 API Designer operator 安装窗口。
点 Install。Create Operator Subscription 表单将打开。
- 对于 Installation 模式,请从集群中的命名空间列表中选择命名空间(项目),
对于 Approval Strategy,选择 Automatic 或 Manual 来配置 OpenShift 如何处理 API Designer Operator 的更新。
- 如果选择 Automatic 更新,当 API Designer 操作器有新版本可用时,OpenShift Operator Lifecycle Manager (OLM)会自动升级 API Designer 的运行实例,而无需人为干预。
- 如果选择手动 更新,则当有新版 Operator 可用时,OLM 会创建更新请求。作为集群管理员,您必须手动批准该更新请求,才能将 API Designer Operator 更新至新版本。
- 点 Subscribe 使 API Designer Operator 可供指定命名空间(项目)使用。
- 要验证 API Designer 是否已安装到项目中,点 Operators,然后点 Installed Operators 以查看列表中的 API Designer。
后续步骤
安装 API Designer 操作器后,API Designer 必须通过创建 API Designer 的实例将 API Designer 添加为 OpenShift 项目。此任务可以通过两种方式完成:
- OpenShift 管理员可以按照 第 2.2.2.1 节 “将 API Designer 作为一个服务添加到 OpenShift 4.x 项目中” 中的步骤操作。
OpenShift 开发人员可按照设计 API 中所述的步骤操作。
API Designer 服务提供用于访问 API Designer Web 控制台的 URL。
2.2.2.1. 将 API Designer 作为一个服务添加到 OpenShift 4.x 项目中
在 OpenShift 4.x 项目中安装了 API Designer 操作器后,您可以(或一个 OpenShift 开发人员)将它添加为 OpenShift 项目的服务。API Designer 服务提供开发人员用来访问 API Designer Web 控制台的 URL。
如需了解 OpenShift 开发人员要作为服务添加到 OpenShift 4.x 项目的步骤,请参阅 设计 API。
先决条件
- 具有 OpenShift 集群的管理员访问权限。
- API Designer 操作器安装到当前的 OpenShift 项目中。
流程
- 在 OpenShift Web 控制台中,点 Operators,然后点 Installed Operators。
- 在 Name 列中,单击 API Designer。
在 Provided APIs 下,点 Create Instance。
此时会打开 API Designer 实例的最小起始模板的默认表单。
接受默认值或选择性地编辑以下值:
大小 : API Designer 实例的 pod 数量。
默认为三个用于新资源类型的 pod,其中包含特定于管理 API Designer 的逻辑。
- 镜像 :API 设计器镜像。如果您更改了此镜像,API Designer Operator 会自动在集群中升级。
- 单击 Create 以创建一个新的 apicurito-service。OpenShift 启动用于新 API Designer 服务的 pod、服务和其他组件。
验证 API Designer 服务是否可用:
- 点 Operators,然后点 Installed Operators。
在 Provided APIs 列中,点 Apicurito CRD。
在 Operator Details 页面中,会列出 apicurito-service。
获取 API Designer 的 URL:
- 点 Networking > Routes。
- 确保选择了正确的项目。
- 在 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 设计程序应用程序。
2.3. 在 OpenShift 3.x 服务器上安装 Fuse 镜像流和模板
在为红帽容器 registry 配置身份验证后,导入并使用 Red Hat Fuse on OpenShift 镜像流和模板。
流程
- 启动 OpenShift 服务器。
以管理员身份登录 OpenShift 服务器。
oc login -u system:admin
验证您是否使用您为其创建 docker-registry secret 的项目。
oc project openshift
在 OpenShift 镜像流上安装 Fuse。
BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003 oc create -n openshift -f ${BASEURL}/fis-image-streams.json
安装 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.0.fuse-760043-redhat-00003/quickstarts/${template} done
安装 Spring Boot 2 Quickstart 模板:
for template in spring-boot-2-camel-amq-template.json \ spring-boot-2-camel-config-template.json \ spring-boot-2-camel-drools-template.json \ spring-boot-2-camel-infinispan-template.json \ spring-boot-2-camel-rest-3scale-template.json \ spring-boot-2-camel-rest-sql-template.json \ spring-boot-2-camel-template.json \ spring-boot-2-camel-xa-template.json \ spring-boot-2-camel-xml-template.json \ spring-boot-2-cxf-jaxrs-template.json \ spring-boot-2-cxf-jaxws-template.json \ spring-boot-2-cxf-jaxrs-xml-template.json \ spring-boot-2-cxf-jaxws-xml-template.json ; do oc create -n openshift -f \ https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-760039-redhat-00001/quickstarts/${template} done
安装 Fuse 控制台的模板。
oc create -n openshift -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fis-console-cluster-template.json oc create -n openshift -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fis-console-namespace-template.json
注意有关部署 Fuse 控制台的详情,请参阅在 OpenShift 中设置 Fuse 控制台。
安装 Apicurito 模板:
oc create -n openshift -f ${BASEURL}/fuse-apicurito.yml
(可选) 查看 OpenShift 镜像和模板上安装的 Fuse:
oc get template -n openshift
2.3.1. 在 OpenShift 3.11 中设置 Fuse 控制台
在 OpenShift 3.11 中,您可以使用两种方式设置 Fuse 控制台:
- 通过将 集中式 Fuse 控制台目录项添加到项目中,以便您可以监控项目中所有正在运行的 Fuse 容器。
- 以便可以监控单个正在运行的 Fuse 容器。
您可以从 OpenShift 控制台或命令行部署 Fuse 控制台。
要在 Minishift 或 CDK based enviroments 上安装 Fuse 控制台,请按照以下 KCS 文章中所述的步骤操作。
- 要在 Minishift 或 CDK based enviroments 上安装 Fuse 控制台,请参阅 KCS 4998441。
- 如果需要禁用 Jolokia 身份验证,请参阅 KCS 3988671 中描述的临时解决方案。
先决条件
- 如 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
- 默认情况下,集群模式模板仅在 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.1. 从 OpenShift 3.11 控制台部署 Fuse 控制台
要从 OpenShift 3.11 控制台在 OpenShift 集群上部署 Fuse 控制台,请按照以下步骤操作。
流程
- 在 OpenShift 控制台中,打开现有项目或创建新项目。
将 Fuse 控制台添加到 OpenShift 项目中:
选择 Add to Project → Browse Catalog。
此时将打开 Select a item to the current project 页面。
在 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" 部分所述。
点 Red Hat Fuse Console 项之一:
- Red Hat Fuse 7.x 控制台 - 此版本的 Fuse 控制台发现并连接到当前 OpenShift 项目中部署的 Fuse 应用程序。
- Red Hat Fuse 7.x 控制台(集群) - 此版本的 Fuse 控制台可以发现和连接到在 OpenShift 集群上的多个项目间部署的 Fuse 应用程序。
在 Red Hat Fuse Console 向导中,单击 Next。向导的 Configuration 页面将打开。
另外,您可以更改配置参数的默认值。
点 Create。
向导的 Results 页面表示已创建了 Red Hat Fuse 控制台。
- 单击 Continue to the project overview 链接,以验证 Fuse Console 应用程序是否已添加到项目中。
要打开 Fuse 控制台,请单击提供的 URL 链接,然后登录。
浏览器中打开了 Authorize Access 页面,其中列出了所需权限。
点击 Allow selected permissions。
Fuse 控制台在浏览器中打开,并显示项目中运行的 Fuse pod。
对于您要查看的应用程序,点 Connect。
此时将打开一个新浏览器窗口,显示 Fuse 控制台中的应用程序。
2.3.1.2. 从 OpenShift 3.11 上的 Fuse 控制台监控单个 Fuse pod
您可以为在 OpenShift 3.11 上运行的 Fuse pod 打开 Fuse 控制台:
在 OpenShift 项目中的 Applications → Pods 视图中,点 pod 名称查看正在运行的 Fuse pod 的详情。在此页面的右侧,您会看到容器模板的摘要:
从此视图中,单击 Open Java Console 链接以打开 Fuse 控制台。
注意要将 OpenShift 配置为在 pod 视图中显示到 Fuse Console 的链接,在 OpenShift 镜像上运行 Fuse 的 pod 必须在 name 属性中声明 TCP 端口,设置为
jolokia
:{ "kind": "Pod", [...] "spec": { "containers": [ { [...] "ports": [ { "name": "jolokia", "containerPort": 8778, "protocol": "TCP" }
2.3.1.3. 从命令行部署 Fuse 控制台
表 2.1 “Fuse 控制台模板” 描述可用于从命令行部署 Fuse 控制台的 OpenShift 3.1 模板,具体取决于 Fuse 应用程序部署的类型。
类型 | 描述 |
---|---|
| Fuse 控制台可以发现并连接到在多个命名空间或项目中部署的 Fuse 应用程序。要部署此模板,您必须具有 OpenShift cluster-admin 角色。 |
| 此模板限制 Fuse 控制台访问当前 OpenShift 项目(命名空间),因此充当单个租户部署。若要部署此模板,您必须拥有当前 OpenShift 项目的 admin 角色。 |
另外,您可以通过运行以下命令来查看所有模板的参数列表:
oc process --parameters -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fis-console-namespace-template.json
流程
从命令行部署 Fuse 控制台:
运行以下命令,基于 Fuse 控制台模板创建一个新应用程序(其中 myproject 是项目的名称):
对于 Fuse Console 集群模板,其中
myhost
是用于访问 Fuse 控制台的主机名:oc new-app -n myproject -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fis-console-cluster-template.json -p ROUTE_HOSTNAME=myhost
对于 Fuse Console 命名空间 模板:
oc new-app -n myproject -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fis-console-namespace-template.json
注意您可以省略 命名空间 模板的 route_hostname 参数,因为 OpenShift 会自动生成一个。
运行以下命令,获取 Fuse 控制台部署的状态和 URL:
oc status
- 要从浏览器访问 Fuse 控制台,请使用提供的 URL (例如 https://fuse-console.192.168.64.12.nip.io)。
第 3 章 非管理员用户在 OpenShift 上安装 Fuse
您可以通过创建应用程序并将其部署到 OpenShift,开始在 OpenShift 上使用 Fuse。首先,您需要在 OpenShift 镜像和模板上安装 Fuse。
3.1. 以非 admin 用户身份在 OpenShift 镜像和模板上安装 Fuse
先决条件
- 您可以访问 OpenShift 服务器。它可以是 CDK 或远程 OpenShift 服务器的虚拟 OpenShift 服务器。
- 您已为 Red Hat Container Registry 配置了身份验证。
如需更多信息,请参阅:
流程
在准备在 OpenShift 项目中构建和部署 Fuse,请登录 OpenShift 服务器,如下所示:
oc login -u developer -p developer https://OPENSHIFT_IP_ADDR:8443
其中,
OPENSHIFT_IP_ADDR
是 OpenShift 服务器的 IP 地址的占位符,因为此 IP 地址并非始终相同。注意developer 用户(使用开发人员密码)是 CDK 在虚拟 OpenShift Server 上自动创建的标准帐户。如果您要访问远程服务器,请使用 OpenShift 管理员提供的 URL 和凭据。
创建名为 test 的新项目命名空间(假设它尚不存在)。
oc new-project test
如果 test 项目命名空间已存在,请切换到它。
oc project test
在 OpenShift 镜像流上安装 Fuse:
BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003 oc create -n test -f ${BASEURL}/fis-image-streams.json
命令输出显示 OpenShift 项目的 Fuse 镜像流。
安装 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
安装 Spring Boot 2 Quickstart 模板:
for template in spring-boot-2-camel-amq-template.json \ spring-boot-2-camel-config-template.json \ spring-boot-2-camel-drools-template.json \ spring-boot-2-camel-infinispan-template.json \ spring-boot-2-camel-rest-3scale-template.json \ spring-boot-2-camel-template.json \ spring-boot-2-camel-xa-template.json \ spring-boot-2-camel-xml-template.json \ spring-boot-2-cxf-jaxrs-template.json \ spring-boot-2-cxf-jaxws-template.json \ spring-boot-2-cxf-jaxrs-xml-template.json \ spring-boot-2-cxf-jaxws-xml-template.json ; do oc create -n openshift -f \ https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-760039-redhat-00001/quickstarts/${template} done
安装 Fuse 控制台的模板。
oc create -n test -f ${BASEURL}/fis-console-cluster-template.json oc create -n test -f ${BASEURL}/fis-console-namespace-template.json
注意有关部署 Fuse 控制台的详情,请参阅在 OpenShift 中设置 Fuse 控制台。
(可选)查看 OpenShift 镜像和模板上安装的 Fuse。
oc get template -n test
在浏览器中,进入 OpenShift 控制台:
-
使用 https://OPENSHIFT_IP_ADDR:8443,并将
OPENSHIFT_IP_ADDR
替换为您的 OpenShift 服务器的 IP 地址。 - 使用您的凭据(例如,使用用户名 developer 和密码 developer)登录 OpenShift 控制台。
-
使用 https://OPENSHIFT_IP_ADDR:8443,并将
第 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.6 支持的 Java 版本。有关支持的 Java 版本的详情,请参阅 支持的配置。
流程
在本地机器上安装 CDK:
- 对于 OpenShift 上的 Fuse,建议您安装 CDK 的版本 3.11。有关安装和使用 CDK 3.11 的详细信息,请参阅 Red Hat CDK 3.11 入门指南。
- 按照 配置 Red Hat Container Registry 身份验证 中的说明,将 OpenShift 凭证配置为可以访问红帽容器 registry。
在 OpenShift 镜像和模板上安装了 Fuse,如 第 2 章 管理员入门 所述。
注意您的 CDK 版本可能预安装了 Fuse on OpenShift 镜像和模板。但是,在配置 OpenShift 凭据后,您必须在 OpenShift 镜像和模板上安装(或更新 Fuse)。
- 在进行本章中的示例之前,您应该阅读并全面了解 Red Hat CDK 3.11 入门指南。
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 二进制文件添加到 PATH 中,这显示您需要键入的命令(oc
-envoc-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)
如需了解更多详细信息,请参阅 CDK 3.11 入门指南中的使用 OpenShift Client Binary。
如果您不使用 CDK,请按照 CLI 参考中的 说明安装
oc
客户端工具。(可选) Docker 客户端:高级用户可能会发现安装 Docker 客户端工具(与 OpenShift 服务器上运行的 docker 守护进程通信)会很方便。有关您的操作系统的特定二进制安装的详情,请查看 Docker 安装 站点。
如需了解更多详细信息,请参阅 CDK 3.11 入门指南 中的重复使用 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 和工件。
流程
-
打开您的 Maven
settings.xml
文件,该文件通常位于~/.m2/settings.xml
(在 Linux 或 macOS 上)或Documents and Settings\<USER_NAME>\.m2\settings.xml
(on Windows)。 添加以下 Maven 存储库。
-
Maven central:
https://repo1.maven.org/maven2
-
Red Hat GA 软件仓库
:https://maven.repository.redhat.com/ga
红帽 EA 软件仓库
:https://maven.repository.redhat.com/earlyaccess/all
您必须将前面的软件仓库同时添加到依赖项软件仓库部分,以及
settings.xml
文件的插件软件仓库部分。
-
Maven central:
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 源。
4.2.1. 使用 S2I 二进制工作流创建和部署应用程序
在本小节中,您将使用 OpenShift S2I 二进制工作流在 OpenShift 项目上创建、构建和部署 Fuse。
流程
使用 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-760024-redhat-00001/archetypes-catalog-2.2.0.fuse-760024-redhat-00001-archetype-catalog.xml \ -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \ -DarchetypeArtifactId=spring-boot-camel-xml-archetype \ -DarchetypeVersion=2.2.0.fuse-760024-redhat-00001
archetype 插件切换到交互模式,以提示您输入剩余的字段。
Define value for property 'groupId': : org.example.fis Define value for property 'artifactId': : fuse76-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: fuse76-spring-boot version: 1.0-SNAPSHOT package: org.example.fis Y: : Y
出现提示时,为
groupId
值输入org.example.fis
,为artifactId
值输入fuse76-spring-boot
。接受剩余字段的默认值。-
如果上一命令以
BUILD SUCCESS
状态退出,则现在您应该在fuse76-spring-boot
子目录下在 OpenShift 项目中有一个新的 Fuse。您可以检查fuse76-spring-boot/src/main/resources/spring/camel-context.xml
文件中的 XML DSL 代码。演示代码定义了一个简单的 Camel 路由,它会持续向日志发送包含随机数字的消息。 在准备在 OpenShift 项目中构建和部署 Fuse,请登录 OpenShift 服务器,如下所示:
oc login -u developer -p developer https://OPENSHIFT_IP_ADDR:8443
其中,
OPENSHIFT_IP_ADDR
是 OpenShift 服务器的 IP 地址的占位符,因为此 IP 地址并非始终相同。注意developer
用户(使用开发人员
密码)是 CDK 在虚拟 OpenShift Server 上自动创建的标准帐户。如果您要访问远程服务器,请使用 OpenShift 管理员提供的 URL 和凭据。切换到
openshift
项目(如果尚未在openshift
项目中),如下所示:oc project openshift
运行以下命令,以确保 OpenShift 镜像和模板上的 Fuse 已安装,并可以访问它们。
oc get template -n openshift
如果没有预安装镜像和模板,或者提供的版本已过时,请在 OpenShift 镜像和模板上手动安装(或更新)F。有关如何在 OpenShift 镜像上安装 Fuse 的更多信息,请参阅 第 2 章 管理员入门。
现在,您可以构建和部署
fuse76-spring-boot
项目。假设您仍已登录到 OpenShift,请更改到fuse76-spring-boot
项目的 目录,然后构建和部署项目,如下所示:cd fuse76-spring-boot mvn fabric8:deploy -Popenshift
在构建成功后,您应看到如下一些输出:
... [INFO] OpenShift platform detected [INFO] Using project: openshift [INFO] Creating a Service from openshift.yml namespace openshift name fuse76-spring-boot [INFO] Created Service: target/fabric8/applyJson/openshift/service-fuse76-spring-boot.json [INFO] Using project: openshift [INFO] Creating a DeploymentConfig from openshift.yml namespace openshift name fuse76-spring-boot [INFO] Created DeploymentConfig: target/fabric8/applyJson/openshift/deploymentconfig-fuse76-spring-boot.json [INFO] Creating Route openshift:fuse76-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] ------------------------------------------------------------------------
注意第一次运行此命令时,Maven 必须下载许多依赖项,这需要几分钟。后续构建将更快。
-
在浏览器中导航到 OpenShift 控制台,并使用您的凭据登录控制台(例如,使用用户名
developer
和密码developer
)。 -
在左侧面板中,展开 Home。单击 Projects,然后选择
openshift
project 以查看项目控制面板。 点
fuse76-spring-boot
查看fuse76-spring-boot
应用程序的 Overview 信息页面。- 在左侧面板中,展开 Workloads。
- 单击 Pods。此时会显示 openshift 项目中所有正在运行的 pod。
单击 pod Name (本例中为
fuse76-spring-boot-xxxxx
)以查看正在运行的 pod 的详细信息。点 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
关闭正在运行的 pod,
-
在
openshift
项目的 Project Status 页面中,单击 Workloads 选项卡,然后单击 fuse76-spring-boot 应用程序。 - 点 Overview 选项卡查看应用程序的概述信息页面。
- 点 pod 图标旁边的向下箭头 来缩减至零以停止 pod。
-
在
4.2.2. 取消部署并重新部署项目
您可以取消部署或重新部署项目,如下所示:
流程
要取消部署项目,请输入以下命令:
mvn fabric8:undeploy
要重新部署项目,请输入命令:
mvn fabric8:undeploy mvn fabric8:deploy -Popenshift
4.2.3. 使用 S2I 源工作流创建和部署应用程序
在本小节中,您将使用 OpenShift S2I 源工作流根据模板在 OpenShift 应用上构建和部署 Fuse。此演示的起点是存储在远程 Git 存储库中的快速入门项目。使用 OpenShift 控制台,您将在 OpenShift 服务器中下载、构建和部署此快速入门项目。
流程
按照如下所示,登录 OpenShift 服务器:
oc login -u developer -p developer https://OPENSHIFT_IP_ADDR:8443
其中,
OPENSHIFT_IP_ADDR
是 OpenShift 服务器的 IP 地址的占位符,因为此 IP 地址并非始终相同。注意developer
用户(使用开发人员
密码)是 CDK 在虚拟 OpenShift Server 上自动创建的标准帐户。如果您要访问远程服务器,请使用 OpenShift 管理员提供的 URL 和凭据。切换到
openshift
项目(如果尚未在openshift
项目中),如下所示:oc project openshift
运行以下命令,以确保已安装 OpenShift 模板上的 Fuse,并可以访问它们。
oc get template -n openshift
如果没有预安装镜像和模板,或者提供的版本已过时,请在 OpenShift 镜像和模板上手动安装(或更新)F。有关如何在 OpenShift 镜像上安装 Fuse 的更多信息,请参阅 第 2 章 管理员入门。
输入以下命令来创建 使用 Spring Boot quickstart 模板运行 Red Hat Fuse 7.6 Camel XML DSL 所需的资源。这将为 Quickstart 创建部署配置和构建配置。有关 Quickstart 和创建的资源的默认参数的信息显示在终端上。
oc new-app s2i-fuse76-spring-boot-camel-xml --> Deploying template "openshift/s2i-fuse76-spring-boot-camel-xml" to project openshift ... --> Creating resources ... imagestream.image.openshift.io "s2i-fuse76-spring-boot-camel-xml" created buildconfig.build.openshift.io "s2i-fuse76-spring-boot-camel-xml" created deploymentconfig.apps.openshift.io "s2i-fuse76-spring-boot-camel-xml" created --> Success Build scheduled, use 'oc logs -f bc/s2i-fuse76-spring-boot-camel-xml' to track its progress. Run 'oc status' to view your app.
- 导航到浏览器中的 OpenShift Web 控制台(https://OPENSHIFT_IP_ADDR,将 OPENSHIFT_IP_ADDR 替换为集群的 IP 地址),并使用您的凭证(例如,使用用户名 developer和密码 developer )登录控制台。
-
在左侧面板中,展开 Home。单击 Projects,然后选择
openshift
project 以查看项目控制面板。 - 点 Workloads 标签页。此时会显示所选命名空间中的所有现有应用程序(如 openshift)。
点
s2i-fuse76-spring-boot-camel-xml
查看快速启动的 Overview 信息页面。单击 Resources 选项卡,然后单击 View logs 以查看应用的构建日志。
- 在左侧面板中,展开 Workloads。
单击 Pods,然后单击
s2i-fuse76-spring-boot-camel-xml-xxxx
。此时会显示应用程序的 Pod 详情。关闭正在运行的 pod,
-
在
openshift
项目的 Project Details 页面中,单击 Workloads 选项卡,然后单击 s2i-fuse76-spring-boot-camel-xml-xxxx 应用程序。 - 点 Overview 选项卡查看应用程序的概述信息页面。
- 点 pod 图标旁边的向下箭头 来缩减至零以停止 pod。
- 使用向下箭头缩减至零以停止容器集。
-
在
第 5 章 为 Spring Boot 镜像开发应用程序
本章介绍了如何为 Spring Boot 镜像开发应用程序。
5.1. 使用 Maven archetype 创建 Spring Boot 项目
要使用 Maven archetypes 创建 Spring Boot 项目,请按照以下步骤操作:
流程
- 进入系统中的相应目录。
在 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-760024-redhat-00001/archetypes-catalog-2.2.0.fuse-760024-redhat-00001-archetype-catalog.xml \ -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \ -DarchetypeArtifactId=spring-boot-camel-xml-archetype \ -DarchetypeVersion=2.2.0.fuse-760024-redhat-00001
archetype 插件切换到交互模式,以提示您输入剩余的字段。
Define value for property 'groupId': : org.example.fis Define value for property 'artifactId': : fuse76-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: fuse76-spring-boot version: 1.0-SNAPSHOT package: org.example.fis Y: : Y
出现提示时,为
groupId
值输入org.example.fis
,为artifactId
值输入fuse76-spring-boot
。接受剩余字段的默认值。-
如果上述命令以 BUILD SUCCESS 状态退出,则现在您应该在
fuse76-spring-boot
子目录下在 OpenShift 项目中有一个新的 Fuse。 现在,您可以构建和部署
fuse76-spring-boot
项目。假设您仍已登录到 OpenShift,请更改到fuse76-spring-boot
项目的 目录,然后构建和部署项目,如下所示:cd fuse76-spring-boot mvn fabric8:deploy -Popenshift
有关可用 Spring Boot archetypes 的完整列表,请参阅 Spring Boot Archetype Catalog。
5.2. 使用 Maven archetype 创建 Spring Boot 2 项目
此快速入门演示了如何使用 Maven archetypes 创建 Spring Boot 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-760038-redhat-00001/archetypes-catalog-2.2.0.fuse-sb2-760038-redhat-00001-archetype-catalog.xml \ -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \ -DarchetypeArtifactId=spring-boot-camel-xml-archetype \ -DarchetypeVersion=2.2.0.fuse-sb2-760038-redhat-00001
archetype 插件切换到交互模式,以提示您输入剩余的字段。
Define value for property 'groupId': : org.example.fis Define value for property 'artifactId': : fuse76-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: fuse76-spring-boot version: 1.0-SNAPSHOT package: org.example.fis Y: : Y
出现提示时,为
groupId
值输入org.example.fis
,为artifactId
值输入fuse76-spring-boot
。接受剩余字段的默认值。-
如果上述命令以 BUILD SUCCESS 状态退出,则现在您应该在
fuse76-spring-boot
子目录下在 OpenShift 项目中有一个新的 Fuse。 现在,您可以构建和部署
fuse76-spring-boot
项目。假设您仍已登录到 OpenShift,请更改到fuse76-spring-boot
项目的 目录,然后构建和部署项目,如下所示:cd fuse76-spring-boot mvn fabric8:deploy -Popenshift
有关可用 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
以下文件对于开发应用程序非常重要:
- 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
- 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"})
它必须具有运行 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); } }
- camel-context.xml
src/main/resources/spring/camel-context.xml
是开发应用程序的重要文件,因为它包含 Camel 路由。注意您可以在开发 第一个 Spring Boot 应用程序中找到有关开发 Spring-Boot 应用程序的更多信息
- src/main/fabric8/deployment.yml
提供与 fabric8-maven-plugin 生成的默认 OpenShift 配置文件合并的额外配置。
注意此文件不是 Spring Boot 应用程序的一部分,但它用于限制 CPU 和内存用量等资源。
5.4. Spring Boot archetype 目录
Spring Boot Archetype 目录包括以下示例。
Name | 描述 |
---|---|
| 演示了如何根据 fabric8 Java 基础镜像在 Spring Boot 中使用 Apache Camel。 |
| 演示了如何将 Spring Boot 应用连接到 ActiveMQ 代理,并使用 Kubernetes 或 OpenShift 的两个 Camel 路由之间使用 JMS 消息传递。 |
| 演示如何使用 Kubernetes ConfigMap 和 Secret 配置 Spring Boot 应用程序。 |
| 演示如何使用 Apache Camel 将 Kubernetes 或 OpenShift 上运行的 Spring Boot 应用程序与远程 Kie 服务器集成。 |
| 演示如何使用 Hot Rod 协议将 Spring Boot 应用程序连接到 JBoss Data Grid 或 Infinispan 服务器。 |
| 演示如何使用 Camel 的 REST DSL 来公开 RESTful API 并将其公开给 3scale。 |
| 演示如何通过 JDBC 和 Camel 的 REST DSL 使用 SQL 来公开 RESTful API。 |
| Spring Boot、Camel 和 XA 事务.本例演示了如何在 Spring Boot 上运行 Camel 服务,它支持两个外部事务资源上的 XA 事务:一个 JMS 资源(A-MQ)和数据库(PostgreSQL)。此快速入门需要 PostgreSQL 数据库和 A-MQ 代理已部署并运行,一个简单的方法是使用 Openshift 服务目录中提供的模板 |
| 演示如何通过蓝图配置文件在 Spring Boot 中配置 Camel 路由。 |
| 演示了如何根据 fabric8 Java 基础镜像在 Spring Boot 中使用 Apache CXF。quickstart 使用 Spring Boot 配置包含启用了 OpenAPI 的 CXF JAXRS 端点的应用程序。 |
| 演示了如何根据 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 目录包括以下示例。
Name | 描述 |
---|---|
| 演示了如何根据 fabric8 Java 基础镜像在 Spring Boot 中使用 Apache Camel。 |
| 演示了如何将 Spring Boot 应用连接到 ActiveMQ 代理,并使用 Kubernetes 或 OpenShift 的两个 Camel 路由之间使用 JMS 消息传递。 |
| 演示如何使用 Apache Camel 将 Kubernetes 或 OpenShift 上运行的 Spring Boot 应用程序与远程 Kie 服务器集成。 |
| 演示如何使用 Hot Rod 协议将 Spring Boot 应用程序连接到 JBoss Data Grid 或 Infinispan 服务器。 |
| 演示如何使用 Camel 的 REST DSL 来公开 RESTful API 并将其公开给 3scale。 |
| 演示如何通过 JDBC 和 Camel 的 REST DSL 使用 SQL 来公开 RESTful API。 |
| 演示如何通过蓝图配置文件在 Spring Boot 中配置 Camel 路由。 |
| 演示了如何根据 fabric8 Java 基础镜像在 Spring Boot 中使用 Apache CXF。Quickstart 使用 Spring Boot 配置包含启用了 Swagger 的 CXF JAXRS 端点的应用程序。 |
| 演示了如何根据 fabric8 Java 基础镜像在 Spring Boot 中使用 Apache CXF。quickstart 使用 Spring Boot 配置包含 CXF JAXWS 端点的应用程序。 |
| 演示如何在 OpenShift 上使用 Apache CXF JAX-RS 和 Spring Boot 2。此快速入门使用 Spring Boot2 启动基于 Spring 配置文件的 CXF 应用,其中包括启用了 Swagger 的 CXF JAXRS 端点。 |
| 演示如何在 OpenShift 上的 Spring Boot 2 中使用 Apache CXF JAX-WS。快速入门使用 Spring Boot2 启动基于 CXF JAXWS 端点的 Spring 配置文件。 |
以下 Spring Boot 2 Maven archetypes 无法构建和部署到 OpenShift。如需更多信息,请参阅发行注记。
-
spring-boot-camel-archetype
-
spring-boot-camel-infinspan-archetype
-
spring-boot-cxf-jaxrs-archetype
-
spring-boot-cxf-jaxws-archetype
要临时解决这个问题,在为其中一个快速入门生成 Maven 项目后,编辑项目的 Maven pom.xml
文件以添加以下依赖项:
<dependency> <groupId>org.assertj</groupId> <artifactId>assertj-core</artifactId> <version>2.4.1</version> <scope>test</scope> </dependency>
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.6.0.fuse-sb2-760028-redhat-00001</fuse.version> </properties> <dependencyManagement> <dependencies> <dependency> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>fuse-springboot-bom</artifactId> <version>${fuse.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> ... </project>
<?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.6.0.fuse-760027-redhat-00001</fuse.version> </properties> <dependencyManagement> <dependencies> <dependency> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>fuse-springboot-bom</artifactId> <version>${fuse.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> ... </project>
使用依赖项管理机制指定 BOM 后,可以在不指定工件版本 的情况下 向 POM 添加 Maven 依赖项。例如,要为 camel-hystrix
组件添加依赖项,您可以在 POM 中的 dependencies
元素中添加以下 XML 片段:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-hystrix-starter</artifactId> </dependency>
请注意,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.6.0.fuse-760027-redhat-00001</fuse.version> </properties> ... <build> <plugins> <plugin> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>${fuse.version}</version> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> </plugins> </build> ... </project>
第 6 章 在 Spring Boot 中运行 Apache Camel 应用程序
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>
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-openapi-java (
camel-openapi-java-starter
)
6.4. 使用 Camel Spring Boot starter
Apache Camel 提供了一个初学者模块,可让您快速开始开发 Spring Boot 应用程序。
流程
将以下依赖项添加到 Spring Boot pom.xml 文件中:
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-spring-boot-starter</artifactId> </dependency>
使用 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"); } }
可选的。要让主线程阻止,以便 Camel 保持工作,请执行以下操作之一:
-
包含
spring-boot-starter-web
依赖项, 或将
camel.springboot.main-run-controller=true
添加到application.properties
或application.yml
文件中。您可以使用
camel.springboot mdadm 属性自定义
文件中的 Camel 应用程序。application.properties
或application.
yml
-
包含
可选的。要使用 bean 的 ID 名称引用自定义 bean,请在
src/main/resources/application.properties
(或application.yml
)文件中配置选项。以下示例显示了 xslt 组件如何使用 bean ID 来引用自定义 bean。请参阅 id
myExtensionFactory
的自定义 bean。camel.component.xslt.saxon-extension-functions=myExtensionFactory
然后,使用 Spring Boot @Bean 注释创建自定义 bean。
@Bean(name = "myExtensionFactory") public ExtensionFunctionDefinition myExtensionFactory() { }
或者,对于 Jackson ObjectMapper,在
camel-jackson
data-format 中:camel.dataformat.json-jackson.object-mapper=myJacksonMapper
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); } }
6.6. Spring Boot Applications 中的自动探测 Camel 路由
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"); } }
或者在您的 @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"); } }; } }
6.7. 为 Camel Spring Boot 自动配置配置 Camel 属性
Spring Boot 自动配置连接到 Spring Boot 外部配置,如属性占位符、OS 环境变量或带有 Camel 属性的系统属性。
流程
在
application.properties
文件中定义属性:route.from = jms:invoices
或者,将 Camel 正确设置为系统属性,例如:
java -Droute.to=jms:processed.invoices -jar mySpringApp.jar
按照如下所示,将配置的属性用作 Camel 路由中的占位符:
@Component public class MyRouter extends RouteBuilder { @Override public void configure() throws Exception { from("{{route.from}}").to("{{route.to}}"); } }
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 } }; } }
在 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
6.10. 将自动配置的消费者和制作者模板注入 Spring 管理的 Bean
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()); } }
默认情况下,消费者模板和制作者模板随端点缓存大小设置为 1000。您可以通过将以下 Spring 属性设置为所需缓存大小来更改这些值,例如:
camel.springboot.consumerTemplateCacheSize = 100 camel.springboot.producerTemplateCacheSize = 200
6.11. 关于 Spring 上下文中自动配置的 TypeConverter
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); } }
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()); } }
这里,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
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
注意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>
使用 Spring XML 文件
要将 Spring XML 文件与 <camelContext> 搭配使用,您可以在 Spring XML 文件或 application.properties
文件中配置 Camel 上下文。要设置 Camel 上下文的名称并打开流缓存,请在 application.properties
文件中添加以下内容:
camel.springboot.name = MyCamel camel.springboot.stream-caching-enabled=true
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
注意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>
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。
流程
将单元测试类中的
include
或exclude
模式指定为@SpringBootTest
注释的属性,如下所示:@RunWith(CamelSpringBootRunner.class) @SpringBootTest(classes = {MyApplication.class); properties = {"camel.springboot.java-routes-include-pattern=**/Foo*"}) public class FooTest {
在
FooTest
类中,include 模式是**/Foo*
,它代表 Ant 样式模式。在这里,模式以双星号开头,该星号与任何前导软件包名称匹配。/foo*
表示类名称必须以 Foo 开头,例如 FooRoute。使用以下 maven 命令运行测试:
mvn test -Dtest=FooTest
第 7 章 在带有 XA 事务的 Spring Boot 上运行 Camel 服务
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 上工作。
流程
这是一个
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
您需要一个共享卷来存储与终止相关的事务和信息。它可以挂载到 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 #...
Camel 扩展 for Spring Boot Narayana Recovery Controller
如果在 Spring Boot 应用程序上下文中找到 Camel,则 Camel 上下文会在清除所有待处理的事务前自动停止。
7.4. 在 OpenShift 上运行 Camel Spring Boot XA quickstart
此流程演示了如何在运行的单一节点 OpenShift 集群上运行 Quickstart。
流程
下载 Camel Spring Boot XA 项目。
git clone --branch spring-boot-camel-xa-1.0.0.fuse-760022-redhat-00001 https://github.com/jboss-fuse/spring-boot-camel-xa
导航到
spring-boot-camel-xa
目录,再运行以下命令:mvn clean install
登录 OpenShift 服务器。
oc login -u developer -p developer
创建名为
test
的新项目命名空间(假设它尚不存在)。oc new-project test
如果
test
项目命名空间已存在,请切换到它。oc project test
安装依赖项。
使用用户名 username 和密码
Thepassword1!
安装postgresql
。oc new-app --param=POSTGRESQL_USER=theuser --param=POSTGRESQL_PASSWORD='Thepassword1!' --env=POSTGRESQL_MAX_PREPARED_TRANSACTIONS=100 --template=postgresql-persistent
使用用户名用户名 和密码
Thepassword1!
安装A-MQ
代理。oc new-app --param=MQ_USERNAME=theuser --param=MQ_PASSWORD='Thepassword1!' --template=amq63-persistent
为事务日志创建持久性卷声明。
oc create -f persistent-volume-claim.yml
构建和部署快速入门。
mvn fabric8:deploy -P openshift
扩展至所需副本数。
oc scale statefulset spring-boot-camel-xa --replicas 3
注: pod 名称用作事务管理器 ID (spring.jta.transaction-manager-id 属性)。当前实施还限制事务管理器 ID 的长度。请注意:
- StatefulSet 的名称是事务系统的标识符,因此不得更改它。
- 您应该为 StatefulSet 命名,以便所有 pod 名称的长度都小于或等于 23 个字符。OpenShift 使用惯例创建 Pod 名称: <statefulset-name>-0, <statefulset-name>-1 等。Narayana 最好避免有多个具有相同 id 的恢复管理器,因此当 pod 名称超过限制时,最后 23 字节被用作事务管理器 id (在剥离一些字符(如 - )后。
快速启动运行后,使用以下命令获取基础服务 URL。
NARAYANA_HOST=$(oc get route spring-boot-camel-xa -o jsonpath={.spec.host})
7.5. 测试成功 XA 事务
以下工作流演示了如何测试成功的 XA 事务。
流程
获取 audit_log 表中的消息列表。
curl -w "\n" http://$NARAYANA_HOST/api/
列表在启动时为空。现在,您可以放置第一个元素。
curl -w "\n" -X POST http://$NARAYANA_HOST/api/?entry=hello
等待一段时间后会得到新列表。
curl -w "\n" http://$NARAYANA_HOST/api/
-
新列表包含两个消息,即
hello
和hello-ok
。hello-ok
确认消息已发送到传出队列,然后记录。您可以添加多个信息并查看日志。
7.6. 测试失败的 XA 事务
以下工作流演示了如何测试失败的 XA 事务。
流程
发送名为
fail
的消息。curl -w "\n" -X POST http://$NARAYANA_HOST/api/?entry=fail
等待一段时间后会得到新列表。
curl -w "\n" http://$NARAYANA_HOST/api/
- 此消息会在路由末尾生成一个异常,以便始终回滚事务。您应该不会在 audit_log 表中找到消息的任何追踪。
第 8 章 将 Camel 应用程序与 A-MQ 代理集成
本教程介绍了如何使用 A-MQ 镜像部署快速入门。
8.1. 构建和部署 Spring Boot Camel A-MQ 快速入门
此快速入门演示了如何将 Spring Boot 应用程序连接到 AMQ Online,并在使用 OpenShift 上的 Fuse 的两个 Camel 路由之间使用 JMS 消息传递。
先决条件
- 确保 AMQ Online 已部署和运行。要在 OpenShift 上安装 AMQ Online,请参阅在 OpenShift 中 安装和配置 AMQ Online。
- 确保 OpenShift 正确运行,并且 OpenShift 中已安装了 Fuse 镜像流。请参阅管理员入门。
- 确保为 fuse 配置 Maven 存储库,请参阅配置 Maven 存储库。
流程
以开发者身份登录 OpenShift 服务器。
oc login -u developer -p developer
登录
openshift
项目。oc project openshift
使用 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-760024-redhat-00001/archetypes-catalog-2.2.0.fuse-760024-redhat-00001-archetype-catalog.xml \ -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \ -DarchetypeArtifactId=spring-boot-camel-amq-archetype \ -DarchetypeVersion=2.2.0.fuse-760024-redhat-00001
archetype 插件切换到交互模式,以提示您输入剩余的字段。
Define value for property 'groupId': : org.example.fis Define value for property 'artifactId': : fuse76-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: fuse76-spring-boot-camel-amq version: 1.0-SNAPSHOT package: org.example.fis Y: :Y
出现提示时,为
groupId
值输入org.example.fis
,为artifactId
值输入fuse76-spring-boot-camel-amq
。接受剩余字段的默认值。导航到 quickstart 目录
fuse76-spring-boot-camel-amq
。cd fuse76-spring-boot-camel-amq
运行以下命令,将配置文件应用到 AMQ Online。这些配置文件创建 AMQ Online 用户和队列,两者都具有 admin 特权。
oc login -u system:admin oc apply -f src/main/resources/k8s
运行
mvn
命令,将 Quickstart 部署到 OpenShift 服务器。mvn fabric8:deploy -Popenshift
验证 Quickstart 是否已成功运行:
- 导航到浏览器中的 OpenShift Web 控制台(https://OPENSHIFT_IP_ADDR,将 OPENSHIFT_IP_ADDR 替换为集群的 IP 地址),并使用您的凭证(例如,使用用户名 developer 和密码 developer)登录控制台。
-
在左侧面板中,展开
Home
,然后单击Status
以查看openshift
项目的 Project Status 页面。 -
点
fuse76-spring-boot-camel-amq
查看 Quickstart 的 Overview 信息页面。 -
在左侧面板中,展开
Workloads
。 -
单击
Pods
,然后单击fuse76-spring-boot-camel-amq-xxxxx
。此时会显示 Quickstart 的 pod 详情。 点
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
- 要查看 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 集成。
流程
通过在 Spring Boot Maven 项目的 pom.xml 文件中添加以下 Maven 依赖项来启用 Kubernetes 集成。
<project ...> ... <dependencies> ... <dependency> <groupId>io.fabric8</groupId> <artifactId>spring-cloud-kubernetes-core</artifactId> </dependency> ... </dependencies> ... </project>
以完成集成,
- 在您的 Java 源代码中添加一些注解
- 创建 Kubernetes ConfigMap 对象
- 修改 OpenShift 服务帐户权限,以允许应用程序读取 ConfigMap 对象。
其他资源
- 如需了解更多详细信息,请参阅为 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。
流程
打开一个新的 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-760024-redhat-00001/archetypes-catalog-2.2.0.fuse-760024-redhat-00001-archetype-catalog.xml \ -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \ -DarchetypeArtifactId=spring-boot-camel-config-archetype \ -DarchetypeVersion=2.2.0.fuse-760024-redhat-00001
archetype 插件切换到互动模式,提示您输入剩余的字段:
Define value for property 'groupId': : org.example.fis Define value for property 'artifactId': : fuse76-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: fuse76-configmap version: 1.0-SNAPSHOT package: org.example.fis Y: : Y
出现提示时,为
groupId
值输入org.example.fis
,为artifactId
值输入fuse76-configmap
。接受剩余字段的默认值。登录 OpenShift,并切换到要部署应用的 OpenShift 项目。例如,要以
developer
用户身份登录并部署到openshift
项目,请输入以下命令:oc login -u developer -p developer oc project openshift
在命令行中,切换到新的
fuse76-configmap
项目目录,并为此应用创建 Secret 对象。cd fuse76-configmap oc create -f sample-secret.yml
注意在部署应用程序前,需要创建 Secret 对象,否则部署的容器进入 wait 状态,直到 Secret 可用为止。如果随后创建 Secret,容器将退出等待状态。有关如何设置 Secret 对象的更多信息,请参阅设置 Secret。
构建和部署快速入门应用程序。在
fuse76-configmap
项目的顶部级别输入:mvn fabric8:deploy -Popenshift
查看应用日志,如下所示:
- 导航到浏览器中的 OpenShift Web 控制台(https://OPENSHIFT_IP_ADDR,将 OPENSHIFT_IP_ADDR 替换为集群的 IP 地址),并使用您的凭证(例如,使用用户名 developer和密码 developer )登录控制台。
- 在左侧面板中,展开 Home。单击 Status 以查看 Project Status 页面。此时会显示所选命名空间中的所有现有应用程序(如 openshift)。
-
单击
fuse76-configmap
,以查看 Quickstart 的 Overview 信息页面。 - 在左侧面板中,展开 Workloads。
-
单击 Pods,然后单击
fuse76-configmap-xxxx
。此时会显示应用程序的 Pod 详情。 - 点 Logs 选项卡查看应用程序日志。
默认接收者列表在
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
在使用 ConfigMap 对象更新
fuse76-configmap
应用配置前,您必须提供fuse76-configmap
应用程序权限来查看 OpenShift ApiServer 中的数据。输入以下命令为fuse76-configmap
应用程序的服务帐户授予view
权限:oc policy add-role-to-user view system:serviceaccount:openshift:qs-camel-config
注意服务帐户通过
system:serviceaccount:PROJECT_NAME:SERVICE_ACCOUNT_NAME
指定。fis-config
部署描述符定义SERVICE_ACCOUNT_NAME
为qs-camel-config
。要查看操作中的实时重新加载功能,请按如下所示创建 ConfigMap 对象:
oc create -f sample-configmap.yml
新 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
9.2.2. 配置属性 bean
配置属性 bean 是一个常规 Java Bean,可通过注入接收配置设置。它提供了 Java 代码与外部配置机制之间的基本接口。
外部化配置和 Bean Registry
下图显示了 Spring Boot Externalized Configuration 在 spring-boot-camel-config
quickstart 中的工作方式。
配置机制有以下主要部分:
- 属性源
-
提供注入到配置中的属性设置。默认属性源是应用程序的
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 类
fuse76-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 ... }
- 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:
- 创建示例 Secret 对象
- 为 Secret 配置卷挂载
- 配置 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
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 }}}'
配置 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
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
设置查看权限
如 Secret 的 deployment.yml 文件中所示,serviceAccountName
在项目的 deployment.yml
文件中设置为 qs-camel-config
。因此,您需要输入以下命令来启用 Quickstart 应用的 查看
权限(假设它部署到 test
项目命名空间中):
oc policy add-role-to-user view system:serviceaccount:test:qs-camel-config
配置 Spring Cloud Kubernetes 插件
Spring Cloud Kubernetes 插件由 bootstrap.yml
文件中的以下设置进行配置。
- spring.application.name
-
这个值必须与 ConfigMap 对象的
metadata.name
匹配(例如,在 Quickstart 项目中的sample-configmap.yml
中定义)。默认为应用程序
。 - spring.cloud.kubernetes.reload.enabled
-
把它设置为
true
可动态重新加载 ConfigMap 对象。
有关支持的属性的详情,请参阅 PropertySource Reload Configuration Properties。
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
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
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
9.3.4. 部署 ConfigMap
要部署 ConfigMap 并使它可以被 Spring Boot 应用程序访问,请执行以下步骤。
流程
-
在 Spring Boot 应用程序中,使用外部配置机制 来访问 ConfigMap 属性源。例如,通过为带有
@Configuration
注释的 Java bean 标注,bean 的属性值可能会由 ConfigMap 注入。 -
在项目的
bootstrap.properties
文件(或bootstrap.yaml
文件)中,设置spring.application.name
属性以匹配 ConfigMap 的名称。 对与应用程序关联的服务帐户启用
查看
权限(默认情况下,这是名为default
的服务帐户)。例如,将view
权限添加到default
服务帐户:oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default -n $(oc project -q)
9.4. 使用 Secrets PropertySource
Kubernetes 具有用于存储敏感数据的 机密 的概念,如密码、OAuth 令牌等。Spring cloud Kubernetes 插件提供与 Secret
集成,使 secret 可以被 Spring Boot 访问。
启用时的 Secrets
属性源将从以下源查找 Secret
:如果找到 secret,则会将其数据提供给应用程序。
- 从 secret 挂载中递归读取
-
在应用程序后命名(请参阅
spring.application.name
) - 匹配一些标签
请注意,默认情况下,不启用 通过 API (点 2 和 3)消耗 Secret。
9.4.1. 设置 Secret 的示例
假设我们有一个名为 demo
的 Spring Boot 应用程序,它使用属性来读取其 ActiveMQ 和 PostreSQL 配置。
amq.username amq.password pg.username pg.password
这些 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
- PostreSQL Secret
apiVersion: v1 kind: Secret metadata: name: postgres-secrets labels: db: postgres type: Opaque data: pg.username: dXNlcgo= pg.password: cGdhZG1pbgo=
9.4.2. 使用 secret
您可以以多种方式选择要使用的 Secret:
通过列出映射 secret 的目录:
-Dspring.cloud.kubernetes.secrets.paths=/etc/secrets/activemq,etc/secrets/postgres
如果您的所有 secret 都映射到一个通用 root,您可以设置它们,如下所示:
-Dspring.cloud.kubernetes.secrets.paths=/etc/secrets
通过设置命名 secret:
-Dspring.cloud.kubernetes.secrets.name=postgres-secrets
通过定义标签列表:
-Dspring.cloud.kubernetes.secrets.labels.broker=activemq -Dspring.cloud.kubernetes.secrets.labels.db=postgres
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
功能默认为禁用。
流程
-
导航到 Quickstart 项目的
src/main/resources
目录,再打开bootstrap.yml
文件。 -
更改配置属性
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 示例
以下示例说明了在启用重新加载功能时会发生什么。
流程
假定使用默认设置(刷新 模式)启用了重新加载功能。配置映射更改时将刷新以下 bean:
@Configuration @ConfigurationProperties(prefix = "bean") public class MyConfig { private String message = "a message that can be changed live"; // getter and setters }
要查看发生的更改,请创建另一个 bean 以定期打印消息,如下所示。
@Component public class MyBean { @Autowired private MyConfig config; @Scheduled(fixedDelay = 5000) public void hello() { System.out.println("The message is: " + config.getMessage()); } }
您可以使用 ConfigMap 更改应用程序打印的消息,如下所示。
apiVersion: v1 kind: ConfigMap metadata: name: reload-example data: application.properties: |- bean.message=Hello World!
与 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 项目,请按照以下步骤操作:
流程
- 进入系统中的相应目录。
启动 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-760024-redhat-00001/archetypes-catalog-2.2.0.fuse-760024-redhat-00001-archetype-catalog.xml \ -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \ -DarchetypeArtifactId=karaf-camel-log-archetype \ -DarchetypeVersion=2.2.0.fuse-760024-redhat-00001
archetype 插件切换到交互模式来提示您输入剩余的字段
Define value for property 'groupId': : org.example.fis Define value for property 'artifactId': : fuse76-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: fuse76-karaf-camel-log version: 1.0-SNAPSHOT package: org.example.fis Y: : Y
出现提示时,为
groupId
值输入org.example.fis
,为artifactId
值输入fuse76-karaf-camel-log
。接受剩余字段的默认值。-
如果上述命令以 BUILD SUCCESS 状态退出,则现在您应该在
fuse76-karaf-camel-log
子目录下在 OpenShift 项目中有一个新的 Fuse。 现在,您可以构建和部署
fuse76-karaf-camel-log
项目。假设您仍已登录到 OpenShift,请更改到fuse76-karaf-camel-log
项目的目录,然后构建并部署项目,如下所示:cd fuse76-karaf-camel-log mvn fabric8:deploy -Popenshift
有关可用 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
以下文件对于开发 Karaf 应用程序非常重要:
- 1
- pom.xml :包含额外的依赖项。您可以在
pom.xml
文件中添加依赖项,例如日志记录可以使用 SLF4J。<dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> </dependency>
- 2
- src/main/fabric8/deployment.yml :提供与 fabric8-maven-plugin 生成的默认 OpenShift 配置文件合并的额外配置。注意
此文件不作为 Karaf 应用的一部分使用,但在所有快速入门中都用来限制 CPU 和内存用量等资源。
- 3
- org.ops4j.pax.logging.cfg: Demonstrates 如何自定义日志级别,将日志级别设置为 DEBUG,而不是默认的 INFO。
- 4
- camel-log.xml:包含应用程序的源代码。
10.3. Karaf archetype 目录
Karaf archetype 目录包含以下示例。
Name | 描述 |
---|---|
| 演示了如何使用 Camel amq 组件向 Apache ActiveMQ 消息代理发送和接收消息。 |
| 演示一个简单的 Apache Camel 应用程序,该应用程序将消息记录到服务器每 5 秒记录一次。 |
| 演示如何通过 JDBC 和 Camel 的 REST DSL 使用 SQL 来公开 RESTful API。 |
| 演示如何使用 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 文件。
流程
-
打开项目的
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>
fabric8 karaf 功能将安装到 Karaf 服务器中。
10.4.2. 添加 Fabric8 Karaf 核心捆绑包功能
bundle fabric8-karaf-core
提供 Blueprint 和 ConfigAdmin 扩展使用的功能。
流程
打开项目的
pom.xml
,并将fabric8-karaf-core
添加到startupFeatures
部分。<startupFeatures> ... <feature>fabric8-karaf-core</feature> ... </startupFeatures>
这将在自定义 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); }
PlaceholderResolver
服务充当不同属性占位符解析策略的收集器。默认情况下提供的解析策略列在表 解析策略 中。要设置属性占位符服务选项,您可以使用系统属性或环境变量或两者。
流程
要访问 OpenShift 上的 ConfigMap,服务帐户需要查看权限。为服务帐户添加查看权限。
oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default -n $(oc project -q)
- 将 secret 挂载到 Pod,以便通过 API 访问 secret。
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
10.4.4. 添加自定义属性占位符解析器
您可以添加自定义占位符解析器来支持特定的需求,如自定义加密。您还可以使用 PlaceholderResolver
服务将解析器提供给 Blueprint 和 ConfigAdmin。
流程
将以下 mvn 依赖项添加到项目
pom.xml
中。pom.xml
--- <dependency> <groupId>io.fabric8</groupId> <artifactId>fabric8-karaf-core</artifactId> </dependency> ---
实施 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; } }
您可以在配置管理中引用解析器,如下所示:
属性
my.property = $[myResolver:value-to-resolve]
10.4.5. 解析策略列表
PlaceholderResolver
服务充当不同属性占位符解析策略的收集器。默认情况下提供的解析策略列在表中。
- 解析策略列表
prefix | 示例 | 描述 |
|
| 从 OS 环境变量中查找属性。 |
'sys |
| 从 Java JVM 系统属性中查找属性。 |
'service |
| 使用服务命名约定,从 OS 环境变量中查找属性。 |
|
| 使用服务命名规则从 OS 环境变量中查找属性,仅返回主机名部分。 |
|
| 使用服务命名约定,从 OS 环境变量中查找属性,仅返回端口部分。 |
|
| 从 Kubernetes ConfigMap (通过 API)中查找属性 |
|
| 从 Kubernetes Secret (通过 API 或卷挂载)中查找属性 |
10.4.6. Property Placeholder 服务选项列表
属性占位符服务支持以下选项:
- 属性占位符服务选项列表
Name | default | 描述 |
---|---|---|
| $[ | 占位符前缀 |
| ] | 占位符后缀 |
| null | 以逗号分隔的路径列表,其中 secret 被映射 |
| 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>
10.5.2. 添加 ConfigMap 注入
fabric8-karaf-cm
提供了一个 ConfigAdmin
网桥,可在 Karaf 的 ConfigAdmin
中注入 ConfigMap
值。
流程
要通过 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
要定义配置,您可以使用单个属性名称。个别属性适用于大多数情况。它与
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
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
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]
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>
10.5.5. Fabric8 Karaf Config Admin 选项
Fabric8 Karaf Config Admin 支持以下选项:
Name | default | 描述 |
---|---|---|
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。支持的语法是:
例如,一个过滤器(如 -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>
示例
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>
嵌套属性占位符替换需要 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 状态。
流程
打开项目的
pom.xml
,并在startupFeatures
部分中添加fabric8-karaf-checks
功能。pom.xml
<startupFeatures> ... <feature>fabric8-karaf-checks</feature> ... </startupFeatures>
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>
注意在 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(); } }
第 11 章 为 JBoss EAP 镜像开发应用程序
要在 JBoss EAP 上开发 Fuse 应用程序,替代方案是使用 S2I 源工作流为使用 EAP 的 Red Hat Camel CDI 创建 OpenShift 项目。
先决条件
- 确保 OpenShift 正确运行,并且 OpenShift 中已安装了 Fuse 镜像流。请参阅管理员入门。
- 确保为 fuse 配置 Maven 存储库,请参阅配置 Maven 存储库。
11.1. 使用 S2I 源工作流创建 JBoss EAP 项目
要在 JBoss EAP 上开发 Fuse 应用程序,替代方案是使用 S2I 源工作流为使用 EAP 的 Red Hat Camel CDI 创建 OpenShift 项目。
流程
将
view
角色添加到 default 服务帐户,以启用集群。这会授予用户对default
服务帐户的view
访问权限。每个项目都需要服务帐户来运行构建、部署和其他容器集。在 shell 提示符中输入以下oc
client 命令:oc login -u developer -p developer oc policy add-role-to-user view -z default
查看 OpenShift 模板上已安装的 Fuse。
oc get template -n openshift
输入以下命令来创建 使用 EAP quickstart 运行 Red Hat Fuse 7.6 Camel CDI 所需的资源。它为快速入门创建部署配置和构建配置。终端会显示有关 Quickstart 和创建的资源的信息。
oc new-app s2i-fuse76-eap-camel-cdi --> Creating resources ... service "s2i-fuse76-eap-camel-cdi" created service "s2i-fuse76-eap-camel-cdi-ping" created route.route.openshift.io "s2i-fuse76-eap-camel-cdi" created imagestream.image.openshift.io "s2i-fuse76-eap-camel-cdi" created buildconfig.build.openshift.io "s2i-fuse76-eap-camel-cdi" created deploymentconfig.apps.openshift.io "s2i-fuse76-eap-camel-cdi" created --> Success Access your application via route 's2i-fuse76-eap-camel-cdi-OPENSHIFT_IP_ADDR' Build scheduled, use 'oc logs -f bc/s2i-fuse76-eap-camel-cdi' to track its progress. Run 'oc status' to view your app.
-
导航到浏览器中的 OpenShift Web 控制台(https://OPENSHIFT_IP_ADDR,将
OPENSHIFT_IP_ADDR
替换为集群的 IP 地址),并使用您的凭证(例如,使用用户名developer
和密码developer
)登录控制台。 -
在左侧面板中,展开 Home。单击 Projects,然后选择
openshift
project 以查看项目控制面板。 - 点 Workloads 标签页。此时会显示所选命名空间中的所有现有应用程序(如 openshift)。
点
s2i-fuse76-eap-camel-cdi
查看快速启动的Overview
信息页面。点 Resources 选项卡,然后点 Routes 部分显示的链接来访问应用程序。
链接的格式为 http://s2i-fuse76-eap-camel-cdi-OPENSHIFT_IP_ADDR。在浏览器中显示类似如下的消息:
Hello world from 172.17.0.3
您还可以使用 URL 中的 name 参数指定名称。例如,如果您在浏览器中输入 URL http://s2i-fuse76-eap-camel-cdi-openshift.apps.cluster-name.openshift.com/?name=jdoe,您会看到响应:
Hello jdoe from 172.17.0.3
- 点 View Logs 查看应用程序的日志。
关闭正在运行的 pod,
- 单击 Overview 选项卡,以返回到应用的概览信息页面。
- 点 pod 图标旁边的向下箭头 来缩减至零以停止 pod。
11.2. JBoss EAP 应用程序的结构
您可以在以下位置找到带有 EAP 示例的 Red Hat Fuse 7.6 Camel CDI 的源代码:
https://github.com/wildfly-extras/wildfly-camel-examples/tree/wildfly-camel-examples-5.2.0.fuse-720021/camel-cdi
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
以下文件对于开发 JBoss EAP 应用程序非常重要:
- pom.xml
- 包括其他依赖项。
11.3. JBoss EAP Quickstart 模板
以下 S2I 模板为 JBoss EAP 上的 Fuse 提供:
Name | 描述 |
---|---|
JBoss Fuse 7.6 Camel A-MQ with EAP ( | 演示使用 camel-activemq 组件连接到 OpenShift 中运行的 AMQ 消息代理。假设代理已部署。 |
Red Hat Fuse 7.6 Camel CDI with EAP ( | 演示使用 camel-cdi 组件将 CDI Bean 与 Camel 路由集成。 |
Red Hat Fuse 7.6 CXF JAX-RS with EAP ( | 演示使用 camel-cxf 组件来生成和使用 JAX-RS REST 服务。 |
Red Hat Fuse 7.6 CXF JAX-WS with EAP ( | 演示使用 camel-cxf 组件来生成和使用 JAX-WS Web 服务。 |
Red Hat Fuse 7.6 Camel JPA + MySQL (Ephemeral) with EAP | 演示如何将 Camel 应用程序与 EAP 上的红帽 Fuse 连接到 MySQL 数据库并公开 REST API。这个示例创建两个容器,一个容器作为 MySQL 服务器运行,另一个容器运行作为数据库的客户端。 |
第 12 章 在 OpenShift 上的 Fuse 中使用持久性存储
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.
流程
apiVersion: v1 kind: PersistentVolume metadata: name: pv0001 spec: accessModes: - ReadWriteOnce capacity: storage: 2Mi hostPath: path: /data/pv0001/
oc create -f pv.yaml
oc get pv
12.4.
流程
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: pvc0001 spec: accessModes: - ReadWriteOnce resources: requests: storage: 1Mi
12.5.
流程
spec: template: spec: containers: - volumeMounts: - name: vol0001 mountPath: /usr/share/data volumes: - name: vol0001 persistentVolumeClaim: claimName: pvc0001
mvn fabric8:resource-apply
oc describe deploymentconfig <application-dc-name>
第 13 章
13.1.
13.2.
-
fuse7-java-openshift
-
fuse7-karaf-openshift
-
fuse7-eap-openshift
-
fuse7-console
-
apicurito-ui
-
fuse-apicurito-generator
流程
$ oc get is -n openshift NAME DOCKER REPO TAGS UPDATED fuse7-console 172.30.1.1:5000/openshift/fuse7-console 1.0,1.1,1.2,1.3,1.4,1.5,1.6 About an hour ago fuse7-eap-openshift 172.30.1.1:5000/openshift/fuse7-eap-openshift 1.0,1.1,1.2,,1.3,1.4,1.5,1.6 About an hour ago fuse7-java-openshift 172.30.1.1:5000/openshift/fuse7-java-openshift 1.0,1.1,1.2,1.3,1.4,1.5,1.6 About an hour ago fuse7-karaf-openshift 172.30.1.1:5000/openshift/fuse7-karaf-openshift 1.0,1.1,1.2,1.3,1.4,1.5,1.6 About an hour ago... fuse-apicurito-generator 172.30.1.1:5000/openshift/fuse-apicurito-generator 1.2,1.3,1.4,1.5,1.6 About an hour ago... apicurito-ui 172.30.1.1:5000/openshift/apicurito-ui 1.2,1.3,1.4,1.5,1.6 About an hour ago...
oc import-image -n openshift fuse7-java-openshift:1.6 oc import-image -n openshift fuse7-karaf-openshift:1.6 oc import-image -n openshift fuse7-eap-openshift:1.6 oc import-image -n openshift fuse7-console:1.6 oc import-image -n openshift apicurito-ui:1.6 oc import-image -n openshift fuse-apicurito-generator:1.6
13.3.
流程
oc login URL -u ADMIN_USER -p ADMIN_PASS
BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003 oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-amq-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-cdi-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-cxf-jaxrs-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-cxf-jaxws-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-jpa-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-camel-amq-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-camel-log-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-camel-rest-sql-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-cxf-rest-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-amq-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-config-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-drools-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-infinispan-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-xml-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-cxf-jaxrs-template.json oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-cxf-jaxws-template.json
注意
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.6.0.fuse-760027-redhat-00001</fuse.version> ... </properties> <dependencyManagement> <dependencies> <dependency> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>fuse-springboot-bom</artifactId> <version>${fuse.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> ... <build> ... <plugins> <!-- Core plugins --> ... <plugin> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>spring-boot-maven-plugin</artifactId> ... <version>${fuse.version}</version> </plugin> </plugins> </build> <profiles> <profile> <id>openshift</id> <build> <plugins> <plugin> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>fabric8-maven-plugin</artifactId> ... <version>${fuse.version}</version> </plugin> </plugins> </build> </profile> </profiles> </project>
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.6.0.fuse-760027-redhat-00001</fuse.version> ... </properties> <dependencyManagement> <dependencies> <dependency> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>fuse-karaf-bom</artifactId> <version>${fuse.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> ... <build> ... <plugins> ... <plugin> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>karaf-maven-plugin</artifactId> <version>${fuse.version}</version> ... </plugin> ... <plugin> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>fabric8-maven-plugin</artifactId> <version>${fuse.version}</version> ... </plugin> </plugins> </build> </project>
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.6.0.fuse-760027-redhat-00001</fuse.version> ... </properties> <!-- Dependency Management --> <dependencyManagement> <dependencies> <dependency> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>fuse-eap-bom</artifactId> <version>${fuse.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> ... </project>
fuse.version
13.5.
Red Hat Fuse 7.0.0 GA | 7.6.0.fuse-760027-redhat-00001 |
| 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.6.0.fuse-sb2-760028-redhat-00001</fuse.bom.version> <!-- maven plugin versions --> <maven-compiler-plugin.version>3.7.0</maven-compiler-plugin.version> <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version> </properties> <build> <defaultGoal>spring-boot:run</defaultGoal> <plugins> <plugin> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>${fuse.bom.version}</version> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> </plugins> </build> <repositories> <repository> <id>redhat-ga-repository</id> <url>https://maven.repository.redhat.com/ga</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>false</enabled> </snapshots> </repository> <repository> <id>redhat-ea-repository</id> <url>https://maven.repository.redhat.com/earlyaccess/all</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>false</enabled> </snapshots> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>redhat-ga-repository</id> <url>https://maven.repository.redhat.com/ga</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>false</enabled> </snapshots> </pluginRepository> <pluginRepository> <id>redhat-ea-repository</id> <url>https://maven.repository.redhat.com/earlyaccess/all</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>false</enabled> </snapshots> </pluginRepository> </pluginRepositories> </project>
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.6.0.fuse-760027-redhat-00001</fuse.bom.version> <!-- maven plugin versions --> <maven-compiler-plugin.version>3.7.0</maven-compiler-plugin.version> <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version> </properties> <build> <defaultGoal>spring-boot:run</defaultGoal> <plugins> <plugin> <groupId>org.jboss.redhat-fuse</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>${fuse.bom.version}</version> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> </plugins> </build> <repositories> <repository> <id>redhat-ga-repository</id> <url>https://maven.repository.redhat.com/ga</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>false</enabled> </snapshots> </repository> <repository> <id>redhat-ea-repository</id> <url>https://maven.repository.redhat.com/earlyaccess/all</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>false</enabled> </snapshots> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>redhat-ga-repository</id> <url>https://maven.repository.redhat.com/ga</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>false</enabled> </snapshots> </pluginRepository> <pluginRepository> <id>redhat-ea-repository</id> <url>https://maven.repository.redhat.com/earlyaccess/all</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>false</enabled> </snapshots> </pluginRepository> </pluginRepositories> </project>
附录 B.
B.1.
B.2.
示例
<libraries> <library>mvn:org.postgresql/postgresql/9.3-1102-jdbc41;type:=endorsed</library> </libraries>
B.3.
for features.xml
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>
附录 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>
C.4.
C.4.1.
目标 | 描述 |
---|---|
fabric8:build |
|
fabric8:resource |
|
fabric8:apply |
|
fabric8:resource-apply |
|
目标 | 描述 |
---|---|
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>
C.4.3.
Configuration | 描述 | default |
---|---|---|
|
| false |
|
| false |
|
| false |
|
| false |
C.5.
C.5.1.
C.5.2.
istag
<namespace>/<image-stream-name>:<tag>
docker
[<registry-location-url>/]<image-namespace>/<image-name>:<tag>
C.5.2.1.
fuse7/fuse-eap-openshift:1.6 fuse7/fuse-java-openshift:1.6 fuse7/fuse-karaf-openshift:1.6
C.5.2.2.
fuse7/fuse-eap-openshift:1.6 fuse7/fuse-java-openshift:1.6 fuse7/fuse-karaf-openshift:1.6
C.5.2.3.
示例
<configuration> <generator> <config> <spring-boot> <fromMode>{istag|docker}</fromMode> <from>{image locations}</from> </spring-boot> </config> </generator> </configuration>
C.5.2.4.
示例
<configuration> <generator> <config> <karaf> <fromMode>{istag|docker}</fromMode> <from>{image locations}</from> </karaf> </config> </generator> </configuration>
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>
C.5.3. Spring Boot
元素 | 描述 | default |
---|---|---|
assemblyRef |
| |
targetDir |
|
|
jolokiaPort |
| 8778 |
mainClass |
| |
webPort |
| 8080 |
color |
|
C.5.4. Karaf
元素 | 描述 | default |
---|---|---|
baseDir |
|
|
jolokiaPort |
| 8778 |
mainClass |
| |
user |
|
|
webPort |
| 8080 |
附录 D.
D.1.
D.2.
流程
<plugin> <groupId>io.fabric8.forge</groupId> <artifactId>fabric8-camel-maven-plugin</artifactId> <version>2.3.90</version> </plugin>
mvn fabric8-camel:validate
示例
<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>
示例
<plugin> <groupId>io.fabric8.forge</groupId> <artifactId>fabric8-camel-maven-plugin</artifactId> <version>2.3.80</version> <executions> <execution> <configuration> <includeTest>true</includeTest> </configuration> <phase>process-test-classes</phase> <goals> <goal>validate</goal> </goals> </execution> </executions> </plugin>
D.3.
流程
$cd camel-example-cdi $mvn io.fabric8.forge:fabric8-camel-maven-plugin:2.3.80:validate
[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] ------------------------------------------------------------------------
示例
@Uri("timer:foo?period=5000")
@Uri("timer:foo?perid=5000")
[INFO] ------------------------------------------------------------------------ [INFO] Building Camel :: Example :: CDI 2.16.2 [INFO] ------------------------------------------------------------------------ [INFO] [INFO] --- fabric8-camel-maven-plugin:2.3.80:validate (default-cli) @ camel-example-cdi --- [WARNING] Endpoint validation error at: org.apache.camel.example.cdi.MyRoutes(MyRoutes.java:32) timer:foo?perid=5000 perid Unknown option. Did you mean: [period] [WARNING] Endpoint validation error: (3 = passed, 1 = invalid, 0 = incapable, 0 = unknown components) [INFO] Simple validation success: (0 = passed, 0 = invalid) [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------
D.4. 选项
参数 | 默认值 | 描述 |
---|---|---|
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
附录 E.
E.1.
E.2.
流程
s2i build <git repo url> registry.redhat.io/fuse7/fuse-karaf-openshift:1.6 <target image name> docker run <target image name>
E.2.1.
E.2.2.
`Karaf4: install karaf:assembly karaf:archive -DskipTests -e`
E.3.
- 默认值为 false。
E.4.
-
JAVA_OPTIONS
:在调用 java 时添加的选项。 -
JAVA_MAX_MEM_RATIO
:当 JAVA_OPTIONS 中不提供-Xmx
选项时,会使用它。这用于根据容器限制计算默认的 maximal heap Memory。如果在没有容器任何内存约束的 Docker 容器中使用,则此选项不会起作用。 -
JAVA_MAX_CORE
:它手动限制可用的内核数,用于计算特定默认值,如垃圾收集器线程的数量。如果设置为 0,则无法根据内核数执行基本 JVM 调优。 -
JAVA_DIAGNOSTICS
:将其设置为在出现问题时获取一些诊断信息。 -
JAVA_MAIN_CLASS
:用作 java 的参数的主要类。当您使用此环境变量时,$JAVA_APP_DIR
目录中的所有 jar 文件都添加到 classpath 中,在$JAVA_LIB_DIR
目录中。 -
JAVA_APP_JAR
:包含适当清单的 jar 文件,以便您可以使用java -jar
开始。但是,如果没有提供,则会设置$JAVA_MAIN_CLASS
。在所有情况下,此 jar 文件都添加到 classpath 中。 -
JAVA_APP_NAME
:用于进程的名称。 -
JAVA_CLASSPATH
:要使用的类路径。如果没有提供,启动脚本会检查文件${JAVA_APP_DIR}/classpath
,并将其内容用作 classpath。如果此文件不存在,则应用程序目录中的所有 jar 都添加到(classes:${JAVA_APP_DIR}/*)
下。 -
JAVA_DEBUG
:如果设置,则将开启远程调试。 -
JAVA_DEBUG_PORT
:用于远程调试的端口。默认值为 5005。
E.5. Jolokia 配置
您可以使用 Jolokia 中的以下环境变量:
-
AB_JOLOKIA_OFF
:如果设置,则禁用 Jolokia 激活(echos 空值)。默认情况下启用 Jolokia。 -
AB_JOLOKIA_CONFIG
:如果设置,请使用文件(包括路径)作为 Jolokia JVM 代理属性。但是,如果没有设置,将使用设置创建/opt/jolokia/etc/jolokia.properties
。 -
AB_JOLOKIA_HOST
: Host address to bind (默认值为 0.0.0.0) -
AB_JOLOKIA_PORT
: 使用的端口(默认值为 8778) -
AB_JOLOKIA_USER
: 用于基本身份验证的用户。默认情况下,它是jolokia
。 -
AB_JOLOKIA_PASSWORD
: 用于基本身份验证的密码。默认情况下关闭身份验证。 -
AB_JOLOKIA_PASSWORD_RANDOM
:生成值,并使用/opt/jolokia/etc/jolokia.pw
文件中写入。 -
AB_JOLOKIA_HTTPS
:与HTTPS
进行安全通信切换。默认情况下,如果在AB_JOLOKIA_OPTS
中未提供 serverCert 配置,则会生成自签名服务器证书。 -
AB_JOLOKIA_ID
:要使用的代理 ID -
AB_JOLOKIA_DISCOVERY_ENABLED
:启用 Jolokia 发现。默认值为 false。 -
AB_JOLOKIA_OPTS
: 附加到代理配置中的附加选项。选项以key=value
格式提供。
以下是与各种环境集成的一个选项:
-
AB_JOLOKIA_AUTH_OPENSHIFT
:切换 OpenShift TSL 通信的客户端身份验证。确保此参数的值必须存在于客户端证书中。如果启用此参数,它将自动将 Jolokia 切换到HTTPS
通信模式。默认 CA 证书设置为/var/run/secrets/kubernetes.io/serviceaccount/ca.crt
。
可以通过将变量 JAVA_ARGS
设置为对应的值来提供应用程序参数。
附录 F. 调整 JVM 以在 Linux 容器中运行
当您允许 JVM ergonomics 为垃圾收集器、堆大小和运行时编译器设置默认值时,Linux 容器中运行的 Java 进程的行为与预期一样。当您在不执行任何调优参数的 Java 应用程序时,java -jar mypplication-fat.jar
urllib-osgithe JVM 会自动根据主机限制设置几个参数,而不是 容器限制。
本节提供有关在 Linux 容器中打包 Java 应用程序的信息,以便考虑计算默认值时容器的限制。
F.1. 调整 JVM
当前的 Java JVM 的生成不是容器感知型,因此它们根据物理主机的大小而非容器的大小来分配资源。例如,JVM 通常将主机上的物理内存的 最大堆大小 设置为 1/4。在大型主机上,此值可以轻松地超过为容器定义的内存限值,如果容器限制在运行时超过容器,OpenShift 将终止应用。
要解决这个问题,您可以在 OpenShift 基础镜像上使用 Fuse,它们能够了解在受限容器中运行的 Java JVM,并在未手动完成的情况下自动调整最大堆大小。它提供了为运行应用程序的 JVM 设置最大内存限值和核心限制的解决方案。对于 OpenShift 镜像上的 Fuse,它可以:
- 根据容器内核设置 CICompilerCount
- 当容器内存限制低于 300MB 时禁用 C2 JIT 编译器
- 以下 300MB 时,对默认堆大小使用容器内存限值的一体
F.2. Fuse on OpenShift 镜像的默认行为
在 OpenShift 上的 Fuse 中,应用构建的基础镜像可以是 Java 镜像(用于 Spring Boot 应用程序)或 Karaf 镜像(用于 Karaf 应用程序)。在 OpenShift 镜像上的 Fuse 执行一个脚本,该脚本读取容器限制,并使用这些限制作为分配资源的基础。默认情况下,脚本将以下资源分配给 JVM:
- 容器内存限值的 50%
- 容器核心限制的 50%
这有一些例外。对于 Karaf 和 Java 镜像,当物理内存低于 300MB 阈值时,堆大小将恢复为默认堆大小的一次性,而不是一对一对一的。
F.3. 在 OpenShift 镜像上自定义 Fuse 调整
该脚本设置 CONTAINER_MAX_MEMORY
和 CONTAINER_CORE_LIMIT
环境变量,由自定义应用读取以调优其内部资源。另外,您可以指定以下运行时环境变量,供您自定义运行应用程序的 JVM 上的设置:
-
JAVA_OPTIONS
-
JAVA_MAX_MEM_RATIO
要显式自定义限制,您可以在 Maven 项目中编辑 deployment.yml
文件来设置 JAVA_MAX_MEM_RATIO
环境变量。
示例
spec: template: spec: containers: - resources: requests: cpu: "0.2" memory: 256Mi limits: cpu: "1.0" memory: 256Mi env: - name: JAVA_MAX_MEM_RATIO value: 60
F.4. 调整第三方库
红帽建议您为 Jetty 等任何第三方 Java 库自定义限制。如果您没有手动自定义限制,这些库将使用给定的默认限制。启动脚本会公开一些环境变量来描述应用程序可使用的容器限制:
CONTAINER_CORE_LIMIT
- 计算的内核限制
CONTAINER_MAX_MEMORY
- 提供给容器的内存限值