管理 Red Hat Process Automation Manager 和 KIE 服务器设置
摘要
前言
作为开发者或系统管理员,您可以修改 Red Hat Process Automation Manager 和 KIE 服务器设置和属性,以满足您的业务需求。您可以修改 Red Hat Process Automation Manager 运行时、Business Central 接口或 KIE 服务器的行为。
使开源包含更多
红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。我们从这四个术语开始:master、slave、黑名单和白名单。由于此项工作十分艰巨,这些更改将在即将推出的几个发行版本中逐步实施。详情请查看 CTO Chris Wright 信息。
部分 I. 管理和监控 KIE 服务器
作为系统管理员,您可以为生产环境安装、配置和升级 Red Hat Process Automation Manager,快速轻松地对系统故障进行故障排除,并确保系统最佳运行。
先决条件
- 安装了 Red Hat JBoss Enterprise Application Platform 7.3。如需更多信息,请参阅 Red Hat JBoss Enterprise Application Platform 7.3 安装指南。
- 安装了 Red Hat Process Automation Manager。如需更多信息,请参阅 规划 Red Hat Process Automation Manager 安装。
-
Red Hat Process Automation Manager 正在运行,您可以使用
admin
角色登录到 Business Central。如需更多信息,请参阅 规划 Red Hat Process Automation Manager 安装。
第 1 章 Red Hat Process Automation Manager 组件
Red Hat Process Automation Manager 由 Business Central 和 KIE Server 组成。
Business Central 是创建和管理新规则的图形用户界面。您可以在 Red Hat JBoss EAP 实例或 Red Hat OpenShift Container Platform (OpenShift)上安装 Business Central。
Business Central 也作为独立 JAR 文件提供。您可以使用 Business Central 独立 JAR 文件来运行 Business Central,而无需将其部署到应用服务器。
KIE 服务器是执行规则和其他工件的服务器。它用于实例化和执行规则并解决规划问题。您可以在 Red Hat JBoss EAP 实例中、Red Hat JBoss EAP 集群、OpenShift、在 Oracle WebLogic 服务器实例、IBM WebSphere Application Server 实例或 Spring Boot 应用程序的一部分安装 KIE 服务器。
您可以将 KIE 服务器配置为以受管或非受管模式运行。如果 KIE Server 是非受管服务器,您必须手动创建和维护 KIE 容器(部署单元)。KIE 容器是项目的特定版本。如果管理 KIE 服务器,则 Process Automation Manager 控制器管理 KIE 服务器配置,并与 Process Automation Manager 控制器交互,以创建和维护 KIE 容器。
第 2 章 系统与 Maven 集成
Red Hat Process Automation Manager 旨在与 Red Hat JBoss Middleware Maven Repository 和 Maven Central 存储库一起使用,作为依赖项源。确保这两个依赖项都可用于项目构建。
确保您的项目依赖于工件的特定版本。LATEST
或 RELEASE
通常用于指定和管理应用程序中的依赖项版本。
-
LATEST
指的是工件的最新部署(快照)版本。 -
RELEASE
指的是存储库中的最后一个非快照版本。
通过使用 LATEST
或 RELEASE
,当发布新版本的第三方库时,您不必更新版本号,但丢失对构建的控制会受到软件版本的影响。
2.1. 本地项目的抢占身份验证
如果您的环境无法访问互联网,请设置内部 Nexus 并使用它,而不是 Maven Central 或其他公共存储库。要从 Red Hat Process Automation Manager 服务器的远程 Maven 存储库导入 JAR,请为存储库服务器打开预先验证。您可以通过在 pom.xml
文件中为 guvnor-m2-repo
配置身份验证,如下所示:
<server> <id>guvnor-m2-repo</id> <username>admin</username> <password>admin</password> <configuration> <wagonProvider>httpclient</wagonProvider> <httpConfiguration> <all> <usePreemptive>true</usePreemptive> </all> </httpConfiguration> </configuration> </server>
另外,您可以使用 Base64 编码凭证设置 Authorization HTTP 标头:
<server> <id>guvnor-m2-repo</id> <configuration> <httpHeaders> <property> <name>Authorization</name> <!-- Base64-encoded "admin:admin" --> <value>Basic YWRtaW46YWRtaW4=</value> </property> </httpHeaders> </configuration> </server>
2.2. Business Central 中重复的 GAV 检测
在 Business Central 中,所有 Maven 存储库都会检查项目中任何重复的 GroupId
、ArtifactId
和 Version
(GAV)值。如果存在 GAV 重复,则会取消执行的操作。
开发模式 中的项目禁用重复的 GAV 检测。要在 Business Central 中启用重复的 GAV 检测,请转至 Project Settings → General Settings → Version,并将 Development Mode 选项切换为 OFF (如果适用)。
每次执行以下操作时都会执行重复的 GAV 检测:
- 保存项目的项目定义。
-
保存
pom.xml
文件。 - 安装、构建或部署项目。
检查以下 Maven 存储库是否有重复的 GAV:
-
在
pom.xml
文件的<repositories
> 和 <distributionManagement
> 元素中指定的软件仓库。 -
Maven
settings.xml
配置文件中指定的存储库。
2.3. 在 Business Central 中管理重复的 GAV 检测设置
具有 admin
角色的用户,可以修改检查项目的重复 GroupId
、ArtifactId
和 Version
(GAV)值的存储库列表。
开发模式 中的项目禁用重复的 GAV 检测。要在 Business Central 中启用重复的 GAV 检测,请转至 Project Settings → General Settings → Version,并将 Development Mode 选项切换为 OFF (如果适用)。
流程
- 在 Business Central 中,进入 Menu → Design → Projects,然后点击项目名称。
- 单击 Project Settings 选项卡,然后单击 Validation 以打开存储库列表。
选择或清除任何列出的仓库选项,以启用或禁用重复的 GAV 检测。
未来,只有您启用了验证的存储库才会报告重复的 GAV。
注意要禁用此功能,请在系统启动时将 Business Central 的
org.guvnor.project.gav.check.disabled
系统属性设置为true
:$ ~/EAP_HOME/bin/standalone.sh -c standalone-full.xml -Dorg.guvnor.project.gav.check.disabled=true
第 3 章 将补丁更新和次版本升级到 Red Hat Process Automation Manager
自动更新工具通常随补丁更新和 Red Hat Process Automation Manager 的新次要版本一起提供,以便于更新 Red Hat Process Automation Manager 的某些组件,如 Business Central、KIE Server 和无头进程自动化管理器控制器。其他 Red Hat Process Automation Manager 工件(如决策引擎和独立 Business Central)作为每个次发行版本的新工件发布,您必须重新安装它们以应用更新。
您可以使用相同的自动更新工具,将补丁更新和次版本升级到 Red Hat Process Automation Manager 7.11。Red Hat Process Automation Manager 的补丁更新(如从 7.11 升级到 7.11.1)包括最新的安全更新和程序错误修复。Red Hat Process Automation Manager 的次发行版本(如从版本 7.10.x 升级到 7.11),包括功能增强、安全更新和程序错误修复。
Red Hat Process Automation Manager 更新工具中仅包含对 Red Hat Process Automation Manager 的更新。Red Hat JBoss EAP 的更新必须使用 Red Hat JBoss EAP 补丁分发来应用。有关红帽 JBoss EAP 补丁的更多信息,请参阅 Red Hat JBoss EAP 补丁和升级指南。
先决条件
- 您的 Red Hat Process Automation Manager 和 KIE 服务器实例没有运行。在运行 Red Hat Process Automation Manager 或 KIE Server 实例时,不要应用更新。
流程
导航到红帽客户门户网站中的 Software Downloads 页面(需要登录),然后从下拉菜单中选择产品和版本。
如果您要升级到 Red Hat Process Automation Manager 的新次要版本,如从版本 7.10.x 升级到 7.11,首先将最新的补丁更新应用到您当前的 Red Hat Process Automation Manager 版本,然后按照此流程升级到新的次版本。
单击 Patches,下载 Red Hat Process Automation Manager [VERSION] Update Tool,并将下载的
rhpam-$VERSION-update.zip
文件提取到临时目录中。这个版本工具会自动更新 Red Hat Process Automation Manager 的某些组件,如 Business Central、KIE Server 和无头进程自动化管理器控制器。首先使用此次更新工具来应用更新,然后安装与 Red Hat Process Automation Manager 发行版本相关的任何其他更新或新发行工件。
如果要保留更新工具更新的任何文件,进入提取的
rhpam-$VERSION-update
文件夹,打开blacklist.txt
文件,并将相对路径添加到您不想更新的文件中。当文件列在
blacklist.txt
文件中时,更新脚本不会将文件替换为新版本,而是将文件保留原位,而在同一位置将添加新版本并带有.new
后缀。如果您阻止不再分发的文件,则更新工具会创建一个带有.removed
后缀的空标记文件。然后,您可以选择手动保留、合并或删除这些新文件。在
blacklist.txt
文件中要排除的文件示例:WEB-INF/web.xml // Custom file styles/base.css // Obsolete custom file kept for record
更新后阻止的文件目录的内容:
$ ls WEB-INF web.xml web.xml.new
$ ls styles base.css base.css.removed
在命令终端中,导航到提取
rhpam-$VERSION-update.zip
文件的临时目录,并以以下格式运行apply-updates
脚本:重要在应用更新前,请确保您的 Red Hat Process Automation Manager 和 KIE 服务器实例没有运行。在运行 Red Hat Process Automation Manager 或 KIE Server 实例时,不要应用更新。
在 Linux 或基于 Unix 的系统上:
$ ./apply-updates.sh $DISTRO_PATH $DISTRO_TYPE
对于 Windows:
$ .\apply-updates.bat $DISTRO_PATH $DISTRO_TYPE
$DISTRO_PATH
部分是相关分发目录的路径,$DISTRO_TYPE
部分是您使用这个更新更新的发行版类型。Red Hat Process Automation Manager 更新工具支持以下发行版类型:
-
rhpam-business-central-eap7-deployable
: Updates Business Central (business-central.war
) rhpam-kie-server-ee8
: Updates KIE Server (kie-server.war
)注意更新工具将更新 Red Hat JBoss EAP EE7 到 Red Hat JBoss EAP EE8。Red Hat JBoss EAP EE7 用于 WebLogic 和 WebSphere,而版本 EE8 则用于 Red Hat JBoss EAP。确保 WebLogic 和 WebSphere 上的 KIE Server 不是由更新工具更新。
-
rhpam-kie-server-jws
: Updates KIE Server on Red Hat JBoss Web Server (kie-server.war
) -
rhpam-controller-ee7
:更新无头流程自动化管理器控制器(controller.war
) rhpam-controller-jws
:在 Red Hat JBoss Web Server (controller.war
)上更新无头流程自动化管理器控制器在 Red Hat JBoss EAP 上为完整的 Red Hat Process Automation Manager 发行版更新到 Business Central 和 KIE 服务器示例:
./apply-updates.sh ~EAP_HOME/standalone/deployments/business-central.war rhpam-business-central-eap7-deployable ./apply-updates.sh ~EAP_HOME/standalone/deployments/kie-server.war rhpam-kie-server-ee8
使用无头进程自动化管理器控制器的示例:
./apply-updates.sh ~EAP_HOME/standalone/deployments/controller.war rhpam-controller-ee7
更新脚本会在提取的
rhpam-$VERSION-update
文件夹中创建一个备份
文件夹,其中包含指定发行版的副本,然后继续进行更新。
-
更新工具完成后,返回到红帽客户门户网站的 Software Downloads 页面,在其中下载更新工具并安装与您的 Red Hat Process Automation Manager 发行版本相关的任何其他更新或新发行工件。
对于 Red Hat Process Automation Manager 发行版本中已存在的文件,如决策引擎或其他附加组件的
.jar
文件,请将文件的现有版本替换为红帽客户门户网站中的新版本。如果您使用独立的 Red Hat Process Automation Manager 7.11.0 Maven Repository 工件(
rhpam-7.11.0-maven-repository.zip
),如在 air-gap 环境中,下载 Red Hat Process Automation Manager 7.11.x Maven Repository,并将下载的rhpam-7.11.x-maven-repository.zip
文件提取到现有的~/maven-repository
目录中,以更新相关的内容。Maven 存储库更新示例:
$ unzip -o rhpam-7.11.x-maven-repository.zip 'rhba-7.11.1.GA-maven-repository/maven-repository/*' -d /tmp/rhbaMavenRepoUpdate $ mv /tmp/rhbaMavenRepoUpdate/rhba-7.11.0.GA-maven-repository/maven-repository/ $REPO_PATH/
注意在完成更新后,您可以删除
/tmp/rhbaMavenRepoUpdate
文件夹。- 完成应用所有相关更新后,启动 Red Hat Process Automation Manager 和 KIE Server 并登录到 Business Central。
验证在 Business Central 中存在和准确的所有项目数据,并在 Business Central 窗口右上角点击您的配置集名称,然后点击 About 以验证更新的产品版本号。
如果您遇到错误或注意到 Business Central 中缺少的数据,您可以恢复
rhpam-$VERSION-update
文件夹中备份
文件夹中的内容,以恢复更新工具更改。您还可以在红帽客户门户网站中重新安装以前版本的 Red Hat Process Automation Manager 中的相关发行工件。恢复之前发行版本后,您可以重试来运行更新。
第 4 章 配置并启动 KIE 服务器
您可以通过在启动 KIE 服务器时定义必要的配置来配置 KIE 服务器位置、用户名、密码和其他相关属性。
流程
导航到 Red Hat Process Automation Manager 7.11 bin
目录,并使用以下属性启动新的 KIE 服务器:根据您的环境调整特定属性。
$ ~/EAP_HOME/bin/standalone.sh --server-config=standalone-full.xml 1 -Dorg.kie.server.id=myserver 2 -Dorg.kie.server.user=kie_server_username 3 -Dorg.kie.server.pwd=kie_server_password 4 -Dorg.kie.server.controller=http://localhost:8080/business-central/rest/controller 5 -Dorg.kie.server.controller.user=controller_username 6 -Dorg.kie.server.controller.pwd=controller_password 7 -Dorg.kie.server.location=http://localhost:8080/kie-server/services/rest/server 8 -Dorg.kie.server.persistence.dialect=org.hibernate.dialect.PostgreSQLDialect 9 -Dorg.kie.server.persistence.ds=java:jboss/datasources/psjbpmDS 10
- 1
- 使用
standalone-full.xml
服务器配置文件启动命令 - 2
- 必须与 Business Central 中定义的服务器配置名称匹配的服务器 ID
- 3
- 要从 Process Automation Manager 控制器与 KIE 服务器连接的用户名
- 4
- 从 Process Automation Manager 控制器与 KIE 服务器连接的密码
- 5
- 进程自动化管理器控制器位置,使用
/rest/controller
后缀的 Business Central URL - 6
- 连接到 Process Automation Manager 控制器 REST API 的用户名
- 7
- 连接到 Process Automation Manager 控制器 REST API 的密码
- 8
- KIE 服务器位置(在这个示例中与 Business Central 相同的实例)
- 9
- 要使用 Hibernate dialect
- 10
- 用于之前 Red Hat JBoss BPM Suite 数据库的数据源的 JNDI 名称
如果在单独的应用服务器实例(Red Hat JBoss EAP 或其他)上安装了 Business Central 和 KIE 服务器,请为 KIE 服务器位置使用单独的端口以避免与 Business Central 的端口冲突。如果尚未配置单独的 KIE 服务器端口,您可以添加端口偏移,并在 KIE Server 属性中相应地调整 KIE 服务器端口值。
例如:
-Djboss.socket.binding.port-offset=150 -Dorg.kie.server.location=http://localhost:8230/kie-server/services/rest/server
如果 Business Central 端口为 8080,如本例中,则 KIE 服务器端口(其定义偏移为 150)为 8230。
KIE 服务器连接到新的 Business Central,并收集要部署的部署单元(KIE 容器)列表。
当您使用依赖项 JAR 文件中的类从 KIE 服务器客户端访问 KIE 服务器时,您可以在 Business Central 中获取 ConversionException
和 ForbiddenClassException
。为了避免在 Business Central 中生成这些例外,请执行以下操作之一:
- 如果在客户端上生成例外,请在 kie-server 客户端中添加以下系统属性:
System.setProperty("org.kie.server.xstream.enabled.packages", "org.example.**");
-
如果在服务器端生成例外,请从 Red Hat Process Automation Manager 安装目录中打开
standalone-full.xml
,在 <system-properties> 标签下设置以下属性:
<property name="org.kie.server.xstream.enabled.packages" value="org.example.**"/>
- 设置以下 JVM 属性:
-Dorg.kie.server.xstream.enabled.packages=org.example.**
您希望不要使用这些系统属性配置 KJAR 中存在的类。确保系统属性中只使用已知的类以避免任何漏洞。
org.example
是一个示例软件包,您可以定义您要使用的任何软件包。您可以用逗号分隔的多个软件包,例如 org.example 1945 , org.example2 , org.example3114 , org.example3 the
。
您还可以添加特定的类,例如 org.example1.Mydata1,org.example2.Mydata2
。
第 5 章 为 KIE 服务器配置 JDBC 数据源
数据源是一个对象,它允许 Java 数据库连接(DSL)客户端(如应用服务器)与数据库建立连接。应用程序在 Java 命名和目录接口(JNDI)树或本地应用程序上下文中查找数据源,并请求数据库连接来检索数据。您必须为 KIE 服务器配置数据源,以确保服务器和指定数据库之间的正确数据交换。
通常,使用 Red Hat Process Automation Manager 的解决方案在一个事务中管理多个资源。JMS,用于异步作业、事件和计时器,例如:Red Hat Process Automation Manager 需要数据源中的 XA 驱动程序,以确保数据原子性和一致的结果。如果监听器中存在不同模式的事务代码,或来自 jBPM 引擎提供的 hook,则还需要 XA 驱动程序。
除非还没有参与单个事务的多个资源,否则请不要使用非 XA 数据源。
对于生产环境,请指定实际的数据源。不要在生产环境中使用示例数据源。
先决条件
- 用于创建数据库连接的 JDBC 供应商是在您要在其上部署 KIE 服务器的所有服务器上配置的,如 Red Hat JBoss Enterprise Application Server Configuration Guide 中的"Creating Datasources"和"Demo Driver"部分所述。
-
Red Hat Process Automation Manager 7.11.0 Add Ons (
rhpam-7.11.0-add-ons.zip
)文件从红帽客户门户网站的软件下载页面下载。https://access.redhat.com/jbossnetwork/restricted/listSoftware.html
流程
完成以下步骤以准备您的数据库:
-
将
rhpam-7.11.0-add-ons.zip
提取到临时目录中,例如TEMP_DIR
。 -
Extract
TEMP_DIR/rhpam-7.11.0-migration-tool.zip
. -
将您的当前目录更改为
TEMP_DIR/rhpam-7.11.0-migration-tool/ddl-scripts
目录。此目录包含多个数据库类型的 DDL 脚本。 将数据库类型的 DDL 脚本导入到您要使用的数据库中。
- 以下示例在 PostreSQL 中创建了 192.168.1.0/24 数据库结构
psql jbpm < /ddl-scripts/postgresql/postgresql-jbpm-schema.sql
注意如果您将 PostgreSQL 或 Oracle 与 Spring Boot 结合使用,您必须导入相应的 Spring Boot DDL 脚本,例如
/ddl-scripts/oracle/oracle-springboot-jbpm-schema.sql
或/ddl-scripts/postgresql/postgresql-springboot-jbpm-schema.sql
。注意PostgreSQL DDL 脚本创建 PostgreSQL 模式,其自动递增整数值(OID)列,用于使用
@LOB
注解的实体属性。要使用其他二进制列类型,如 BYTEA 而不是 OID,您必须使用postgresql-bytea-jbpm-schema.sql
脚本创建 PostgreSQL 模式,并设置 Red Hat Process Automation Managerorg.kie.persistence.postgresql.useBytea=true
标志。Red Hat Process Automation Manager 不提供从基于 OID 的 OID 变为基于 BYTEA 模式的迁移工具。
-
将
-
在文本编辑器中打开
EAP_HOME/standalone/configuration/standalone-full.xml
,并找到 <system-properties>
标签。 在 <
system-properties
> 标签中添加以下属性,其中 <DATASOURCE
> 是数据源的 JNDI 名称,<HIBERNATE_DIALECT
> 是数据库的休眠问题。注意org.kie.server.persistence.ds
属性的默认值为java:jboss/datasources/ExampleDS
。org.kie.server.persistence.dialect
属性的默认值为org.hibernate.dialect.H2Dialect
。<property name="org.kie.server.persistence.ds" value="<DATASOURCE>"/> <property name="org.kie.server.persistence.dialect" value="<HIBERNATE_DIALECT>"/>
以下示例演示了如何为 PostgreSQL hibernate dialect 配置数据源:
<system-properties> <property name="org.kie.server.repo" value="${jboss.server.data.dir}"/> <property name="org.kie.example" value="true"/> <property name="org.jbpm.designer.perspective" value="full"/> <property name="designerdataobjects" value="false"/> <property name="org.kie.server.user" value="rhpamUser"/> <property name="org.kie.server.pwd" value="rhpam123!"/> <property name="org.kie.server.location" value="http://localhost:8080/kie-server/services/rest/server"/> <property name="org.kie.server.controller" value="http://localhost:8080/business-central/rest/controller"/> <property name="org.kie.server.controller.user" value="kieserver"/> <property name="org.kie.server.controller.pwd" value="kieserver1!"/> <property name="org.kie.server.id" value="local-server-123"/> <!-- Data source properties. --> <property name="org.kie.server.persistence.ds" value="java:jboss/datasources/KieServerDS"/> <property name="org.kie.server.persistence.dialect" value="org.hibernate.dialect.PostgreSQLDialect"/> </system-properties>
支持以下 dialects:
-
DB2:
org.hibernate.dialect.DB2Dialect
-
MSSQL:
org.hibernate.dialect.SQLServer2012Dialect
-
MySQL:
org.hibernate.dialect.MySQL5InnoDBDialect
-
MariaDB:
org.hibernate.dialect.MySQL5InnoDBDialect
-
Oracle:
org.hibernate.dialect.Oracle10gDialect
-
PostgreSQL:
org.hibernate.dialect.PostgreSQL82Dialect
-
PostgreSQL 加上:
org.hibernate.dialect.PostgresPlusDialect
-
Sybase:
org.hibernate.dialect.SybaseASE157Dialect
第 6 章 受管 KIE 服务器
受管实例需要一个可用的 Process Automation Manager 控制器来启动 KIE 服务器。
Process Automation Manager 控制器以集中的方式管理 KIE 服务器配置。每个流程自动化管理器控制器可以同时管理多个配置,并可在环境中有多个流程自动化管理器控制器。受管 KIE 服务器可以使用 Process Automation Manager 控制器列表进行配置,但每次只能连接到一个控制器。
所有 Process Automation Manager 控制器都应同步,以确保为服务器提供了相同的配置集合,而不考虑它连接的 Process Automation Manager 控制器。
当使用 Process Automation Manager 控制器列表配置 KIE 服务器时,它将尝试在启动时连接到每个控制器,直到连接成功与其中一个连接成功建立。如果无法建立连接,服务器也不会启动,即使配置有可用的本地存储。这样可确保服务器的一致性,并防止服务器使用冗余配置运行。
要在不连接到 Process Automation Manager 控制器的情况下以独立模式运行 KIE 服务器,请参阅 第 7 章 Unmanaged KIE Server。
第 7 章 Unmanaged KIE Server
非受管 KIE 服务器是一个独立实例,因此必须使用 KIE 服务器本身的 REST/JMS API 来单独配置。该配置由服务器自动保留到文件中,并在重启时用作内部服务器状态。
配置会在以下操作过程中更新:
- 部署 KIE 容器
- 取消部署 KIE 容器
- 启动 KIE 容器
- 停止 KIE 容器
如果 KIE 服务器重启,它将尝试在关闭前重新建立相同的状态。因此,正在运行的 KIE 容器(部署单元)将启动,但不会停止的容器。
第 8 章 在 KIE 服务器和 Business Central 中配置环境模式
您可以将 KIE 服务器设置为 在生产
模式 或开发
模式下运行。开发模式提供了一个灵活的部署策略,可让您更新现有的部署单元(KIE 容器),同时维护活跃进程实例以进行小更改。它还允许您在更新活跃进程实例以进行较大的更改前重置部署单元状态。生产环境模式最适合生产环境,每个部署都会创建一个新的部署单元。
在开发环境中,您可以点 Deploy in Business Central 将构建的 KJAR 文件部署到 KIE 服务器中,而不停止任何正在运行的实例(如果适用),或者点 Redeploy 来部署构建的 KJAR 文件并替换所有实例。您下次部署或重新部署构建的 KJAR 时,以前的部署单元(KIE 容器)会在相同的目标 KIE 服务器中自动更新。
在生产环境中,Business Central 中的 Redeploy 选项被禁用,您只能点 Deploy 将构建的 KJAR 文件部署到 KIE 服务器上的新部署单元(KIE 容器)。
流程
-
要配置 KIE 服务器环境模式,请将
org.kie.server.mode
系统属性设置为org.kie.server.mode=development
或org.kie.server.mode=production
。 要在 Business Central 中为项目配置部署行为,请转至 Settings → General Settings → Version,并切换 Development Mode 选项。
注意默认情况下,Business Central 中的 KIE 服务器和所有新项目都处于开发模式。
您不能部署启用了 开发模式 的项目,或手动将
SNAPSHOT
版本后缀添加到处于生产环境模式的 KIE 服务器中。
第 9 章 配置 KIE 服务器以连接到 Business Central
本节提供了可用于测试目的的设置示例。对于生产环境,一些值不可理解,并被标记为这样。
如果在 Red Hat Process Automation Manager 环境中没有配置 KIE 服务器,或者在 Red Hat Process Automation Manager 环境中需要额外的 KIE 服务器,您必须配置 KIE 服务器来连接到 Business Central。
如果要在 Red Hat OpenShift Container Platform 上部署 KIE 服务器,请参阅使用 Operator 在 Red Hat OpenShift Container Platform 4 上部署 Red Hat Process Automation Manager 环境。
KIE 服务器可以管理或非受管。如果 KIE Server 是非受管服务器,您必须手动创建和维护 KIE 容器(部署单元)。如果管理 KIE 服务器,则 Process Automation Manager 控制器管理 KIE 服务器配置,并与 Process Automation Manager 控制器交互,以创建和维护 KIE 容器。
如果 KIE 服务器由 Business Central 管理,并且已从 ZIP 文件安装了 Red Hat Process Automation Manager,请进行本节中描述的更改。如果安装了 Business Central,您可以使用无头流程自动化管理器控制器来管理 KIE 服务器,如 第 10 章 安装并运行无头 Process Automation Manager 控制器 所述。
先决条件
-
Business Central 和 KIE 服务器安装在 Red Hat JBoss EAP 安装(
EAP_HOME
)的基础镜像中。
您必须在生产环境中的不同服务器上安装 Business Central 和 KIE 服务器。在本例中,我们只使用一个名为 controllerUser
的用户,其中包含 rest-all
和 kie-server
角色。但是,如果您在同一服务器上安装 KIE 服务器和 Business Central,例如在开发环境中,在共享 standalone-full.xml
文件中进行更改,如本节所述。
存在具有以下角色的用户:
-
在 Business Central 中,具有角色
rest-all
的用户 -
在 KIE 服务器上,具有角色
kie-server
的用户
-
在 Business Central 中,具有角色
流程
-
在 Red Hat Process Automation Manager 安装目录中,进入
standalone-full.xml
文件。例如,如果您为 Red Hat Process Automation Manager 使用 Red Hat JBoss EAP 安装,请转至$EAP_HOME/standalone/configuration/standalone-full.xml
。 打开
standalone-full.xml
文件并在 <system-properties>
; 标签下设置以下 JVM 属性:表 9.1. KIE 服务器实例的 JVM 属性 属性 值 备注 org.kie.server.id
default-kie-server
KIE 服务器 ID。
org.kie.server.controller
http://localhost:8080/business-central/rest/controller
Business Central 的位置。用于连接到 Business Central API 的 URL。
org.kie.server.controller.user
controllerUser
具有可登录到 Business Central 的角色
rest-all
的用户名。org.kie.server.controller.pwd
controllerUser1234;
可以登录到 Business Central 的用户的密码。
org.kie.server.location
http://localhost:8080/kie-server/services/rest/server
KIE 服务器的位置。用于连接到 KIE 服务器的 API 的 URL。
表 9.2. Business Central 实例的 JVM 属性 属性 值 备注 org.kie.server.user
controllerUser
角色
kie-server
的用户名。org.kie.server.pwd
controllerUser1234;
用户的密码。
以下示例演示了如何配置 KIE 服务器实例:
<property name="org.kie.server.id" value="default-kie-server"/> <property name="org.kie.server.controller" value="http://localhost:8080/business-central/rest/controller"/> <property name="org.kie.server.controller.user" value="controllerUser"/> <property name="org.kie.server.controller.pwd" value="controllerUser1234;"/> <property name="org.kie.server.location" value="http://localhost:8080/kie-server/services/rest/server"/>
以下示例演示了如何为 Business Central 实例配置:
<property name="org.kie.server.user" value="controllerUser"/> <property name="org.kie.server.pwd" value="controllerUser1234;"/>
要验证 KIE 服务器是否已成功启动,请在 KIE 服务器运行时向
http://SERVER:PORT/kie-server/services/rest/server/
发送 GET 请求。有关在 KIE 服务器上运行 Red Hat Process Automation Manager 的更多信息,请参阅 运行 Red Hat Process Automation Manager。成功验证后,您会收到类似以下示例的 XML 响应:
<response type="SUCCESS" msg="Kie Server info"> <kie-server-info> <capabilities>KieServer</capabilities> <capabilities>BRM</capabilities> <capabilities>BPM</capabilities> <capabilities>CaseMgmt</capabilities> <capabilities>BPM-UI</capabilities> <capabilities>BRP</capabilities> <capabilities>DMN</capabilities> <capabilities>Swagger</capabilities> <location>http://localhost:8230/kie-server/services/rest/server</location> <messages> <content>Server KieServerInfo{serverId='first-kie-server', version='7.5.1.Final-redhat-1', location='http://localhost:8230/kie-server/services/rest/server', capabilities=[KieServer, BRM, BPM, CaseMgmt, BPM-UI, BRP, DMN, Swagger]}started successfully at Mon Feb 05 15:44:35 AEST 2018</content> <severity>INFO</severity> <timestamp>2018-02-05T15:44:35.355+10:00</timestamp> </messages> <name>first-kie-server</name> <id>first-kie-server</id> <version>7.5.1.Final-redhat-1</version> </kie-server-info> </response>
验证注册是否成功:
- 登录 Business Central。
点 Menu → Deploy → Execution Servers。
如果注册成功,您会看到注册的服务器 ID。
第 10 章 安装并运行无头 Process Automation Manager 控制器
您可以将 KIE 服务器配置为以受管或非受管模式运行。如果 KIE Server 是非受管服务器,您必须手动创建和维护 KIE 容器(部署单元)。如果管理 KIE 服务器,则 Process Automation Manager 控制器管理 KIE 服务器配置,并与 Process Automation Manager 控制器交互,以创建和维护 KIE 容器。
Business Central 有一个嵌入式 Process Automation Manager 控制器。如果安装了 Business Central,请使用 Execution Server 页面创建和维护 KIE 容器。如果要在没有 Business Central 的情况下自动执行 KIE 服务器管理,您可以使用无头流程 Automation Manager 控制器。
10.1. 使用安装程序使用 Process Automation Manager 控制器配置 KIE 服务器
KIE 服务器可由 Process Automation Manager 控制器管理,也可以是非受管。如果 KIE Server 是非受管服务器,您必须手动创建和维护 KIE 容器(部署单元)。如果管理 KIE 服务器,则 Process Automation Manager 控制器管理 KIE 服务器配置,并与 Process Automation Manager 控制器交互,以创建和维护 KIE 容器。
Process Automation Manager 控制器与 Business Central 集成。如果安装了 Business Central,您可以使用 Business Central 中的 Execution Server 页面与 Process Automation Manager 控制器交互。
您可以使用互动或 CLI 模式的安装程序来安装 Business Central 和 KIE 服务器,然后使用 Process Automation Manager 控制器配置 KIE 服务器。
先决条件
- 有备份 Red Hat JBoss EAP 7.3 服务器安装的两个计算机可用。
- 授予足够的用户权限来完成安装。
流程
- 在第一个计算机上,以交互模式或 CLI 模式运行安装程序。如需更多信息 ,请参阅在 Red Hat JBoss EAP 7.3 上安装和配置 Red Hat Process Automation Manager。
- 在 组件选择 页面中,清除 KIE Server 复选框。
- 完成 Business Central 安装。
- 在第二个计算机上,以交互模式或 CLI 模式运行安装程序。
- 在 组件选择 页面中,清除 Business Central 复选框。
- 在 Configure Runtime Environment 页面上,选择 Execution Advanced Configuration。
- 选择 Customize KIE Server properties 并点 Next。
输入 Business Central 的控制器 URL,并为 KIE 服务器配置附加属性。控制器 URL 的格式如下,其中 <
;HOST:PORT
> 是第二个计算机上的 Business Central 地址:<HOST:PORT>/business-central/rest/controller
- 完成安装。
- 要验证 Process Automation Manager 控制器现在与 Business Central 集成,请转至 Business Central 中的 Execution Servers 页面,并确认您配置的 KIE 服务器出现在 REMOTE SERVERS 下。
10.2. 安装无头流程自动化管理器控制器
您可以安装无头进程自动化管理器控制器,并使用 REST API 或 KIE Server Java Client API 与其交互。
先决条件
-
提供了备份的 Red Hat JBoss EAP 安装版本 7.3。Red Hat JBoss EAP 安装的主目录称为
EAP_HOME
。 - 授予足够的用户权限来完成安装。
流程
导航到红帽客户门户网站中的 Software Downloads 页面(需要登录),然后从下拉菜单中选择产品和版本:
- 产品 : 流程自动化管理器
- Version: 7.11
-
下载 Red Hat Process Automation Manager 7.11.0 Add Ons (
rhpam-7.11.0-add-ons.zip
文件)。 -
提取
rhpam-7.11.0-add-ons.zip
文件。rhpam-7.11.0-controller-ee7.zip
文件位于提取的目录中。 -
将
rhpam-7.11.0-controller-ee7
存档提取到临时目录中。在以下示例中,此目录名为TEMP_DIR
。 将
TEMP_DIR/rhpam-7.11.0-controller-ee7/controller.war
目录复制到EAP_HOME/standalone/deployments/
。警告确保您复制的无头流程自动化管理器控制器部署的名称不会与 Red Hat JBoss EAP 实例中的现有部署冲突。
-
将
TEMP_DIR/rhpam-7.11.0-controller-ee7/SecurityPolicy/
目录的内容复制到EAP_HOME/bin
。 - 当提示覆盖文件时,请选择 Yes。
-
在
EAP_HOME/standalone/deployments/
目录中,创建一个名为controller.war.dodeploy
的空文件。此文件可确保服务器启动时自动部署无头 Process Automation Manager 控制器。
10.2.1. 创建无头进程自动化管理器控制器用户
在使用无头 Process Automation Manager 控制器前,您必须创建一个具有 kie-server
角色的用户。
先决条件
-
无头流程自动化管理器控制器安装在 Red Hat JBoss EAP 安装(
EAP_HOME
)的基本目录中。
流程
-
在终端应用中,导航到
EAP_HOME/bin
目录。 输入以下命令,并将 <
;USER_NAME&
gt; 和 <PASSWORD
> 替换为您选择的用户名和密码。$ ./add-user.sh -a --user <USER_NAME> --password <PASSWORD> --role kie-server
注意确保指定的用户名与现有用户、角色或组不同。例如,不要创建名为
admin
的用户。密码必须至少有 8 个字符,且必须至少包含一个数字,以及一个非字母数字字符,但不能包括 & (ampersand)。
- 记录您的用户名和密码。
10.2.2. 配置 KIE 服务器和无头进程自动化管理器控制器
如果 KIE 服务器将由无头进程自动化管理器控制器管理,您必须在 KIE Server 安装中编辑 standalone-full.xml
文件,以及在无头进程自动化管理器控制器安装中编辑 standalone.xml
文件。
先决条件
-
KIE 服务器安装在
EAP_HOME
中。 无头流程自动化管理器控制器安装在
EAP_HOME
中。注意您应该在生产环境中的不同服务器上安装 KIE 服务器和无头进程自动化管理器控制器。但是,如果您在同一服务器上安装 KIE 服务器和无头进程自动化管理器控制器,例如在开发环境中,在共享的
standalone-full.xml
文件中进行这些更改。-
在 KIE Server 节点上,存在具有
kie-server
角色的用户。 在服务器节点上,存在具有
kie-server
角色的用户。流程
在
EAP_HOME/standalone/configuration/standalone-full.xml
文件中,将以下属性添加到 <system-properties
> 部分,并将 <USERNAME
> 和 <USER_PWD
> 替换为kie-server
角色:<property name="org.kie.server.user" value="<USERNAME>"/> <property name="org.kie.server.pwd" value="<USER_PWD>"/>
在 KIE Server
EAP_HOME/standalone/configuration/standalone-full.xml
文件中,将以下属性添加到 <system-properties>
部分:<property name="org.kie.server.controller.user" value="<CONTROLLER_USER>"/> <property name="org.kie.server.controller.pwd" value="<CONTROLLER_PWD>"/> <property name="org.kie.server.id" value="<KIE_SERVER_ID>"/> <property name="org.kie.server.location" value="http://<HOST>:<PORT>/kie-server/services/rest/server"/> <property name="org.kie.server.controller" value="<CONTROLLER_URL>"/>
- 在这个文件中,替换以下值:
-
将
<CONTROLLER_USER
> 和 <CONTROLLER_PWD
> 替换为用户的凭证,并替换为kie-server
角色。 -
将
<KIE_SERVER_ID
> 替换为 KIE 服务器安装的 ID 或名称,如rhpam-7.11.0-kie-server-1
。 -
将
<HOST
> 替换为 KIE 服务器主机的 ID 或名称,例如localhost
或192.7.8.9
。 将
<PORT
> 替换为 KIE 服务器主机的端口,如8080。
注意org.kie.server.location
属性指定 KIE 服务器的位置。-
将
<CONTROLLER_URL
> 替换为无头进程自动化管理器控制器的 URL。KIE 服务器在启动时连接到此 URL。
10.3. 运行无头进程自动化管理器控制器
在 Red Hat JBoss EAP 上安装无头 Process Automation Manager 控制器后,使用此流程运行无头 Process Automation Manager 控制器。
先决条件
-
无头流程自动化管理器控制器在 Red Hat JBoss EAP 安装(
EAP_HOME
)的基域中安装和配置。
流程
-
在终端应用中,导航到
EAP_HOME/bin
。 如果您在安装 KIE 服务器的 Red Hat JBoss EAP 实例相同的 Red Hat JBoss EAP 实例上安装了无头 Process Automation Manager 控制器,请输入以下命令之一:
在 Linux 或基于 UNIX 的系统上:
$ ./standalone.sh -c standalone-full.xml
对于 Windows:
standalone.bat -c standalone-full.xml
如果您在安装 KIE 服务器的 Red Hat JBoss EAP 实例中的独立 Red Hat JBoss EAP 实例上安装了无头 Process Automation Manager 控制器,请使用
standalone.sh
脚本启动无头 Process Automation Manager 控制器:注意在这种情况下,请确保对
standalone.xml
文件进行了所有必要的配置更改。在 Linux 或基于 UNIX 的系统上:
$ ./standalone.sh
对于 Windows:
standalone.bat
要验证无头流程自动化管理器控制器是否在 Red Hat JBoss EAP 上工作,请输入以下命令,其中 <
CONTROLLER>
和 <CONTROLLER_PWD
> 是用户名和密码。此命令的输出提供有关 KIE 服务器实例的信息。curl -X GET "http://<HOST>:<PORT>/controller/rest/controller/management/servers" -H "accept: application/xml" -u '<CONTROLLER>:<CONTROLLER_PWD>'
另外,您可以使用 KIE Server Java API 客户端来访问无头进程自动化管理器控制器。
10.4. 使用无头进程自动化管理器控制器集群 KIE 服务器
Process Automation Manager 控制器与 Business Central 集成。但是,如果您没有安装 Business Central,您可以安装无头流程自动化管理器控制器,并使用 REST API 或 KIE Server Java 客户端 API 与其交互。
先决条件
-
提供了备份的 Red Hat JBoss EAP 安装版本 7.3 或更高版本。Red Hat JBoss EAP 安装的主目录称为
EAP_HOME
。 - 授予足够的用户权限来完成安装。
- Red Hat JBoss EAP 集群环境中安装和配置 Red Hat Process Automation Manager 所述,具有共享文件夹的 NFS 服务器。
流程
导航到红帽客户门户网站中的 Software Downloads 页面(需要登录),然后从下拉菜单中选择产品和版本:
- 产品 :流程自动化管理器
- Version: 7.11
-
下载 Red Hat Process Automation Manager 7.11.0 Add Ons (
rhpam-7.11.0-add-ons.zip
文件)。 -
提取
rhpam-7.11.0-add-ons.zip
文件。rhpam-7.11.0-controller-ee7.zip
文件位于提取的目录中。 -
将
rhpam-7.11.0-controller-ee7
存档提取到临时目录中。在以下示例中,此目录名为TEMP_DIR
。 将
TEMP_DIR/rhpam-7.11.0-controller-ee7/controller.war
目录复制到EAP_HOME/standalone/deployments/
。警告确保您复制的无头流程自动化管理器控制器部署的名称不会与 Red Hat JBoss EAP 实例中的现有部署冲突。
-
将
TEMP_DIR/rhpam-7.11.0-controller-ee7/SecurityPolicy/
目录的内容复制到EAP_HOME/bin
。 - 当提示覆盖文件时,请单击 Yes。
-
在
EAP_HOME/standalone/deployments/
目录中,创建一个名为controller.war.dodeploy
的空文件。此文件可确保服务器启动时自动部署无头 Process Automation Manager 控制器。 -
在文本编辑器中打开
EAP_HOME/standalone/configuration/standalone.xml
文件。 在 <
system-properties>
元素中添加以下属性,并将 <NFS_STORAGE
> 替换为存储模板配置的 NFS 存储的绝对路径:<system-properties> <property name="org.kie.server.controller.templatefile.watcher.enabled" value="true"/> <property name="org.kie.server.controller.templatefile" value="<NFS_STORAGE>"/> </system-properties>
模板文件包含特定部署场景的默认配置。
如果
org.kie.server.controller.templatefile.watcher.enabled
属性的值被设置为 true,则会启动单独的线程来监控模板文件的修改。这些检查的默认间隔为 30000 毫秒,可由org.kie.server.controller.templatefile.watcher.interval
系统属性进一步控制。如果此属性的值设为 false,则仅在服务器重启时检测到对模板文件的更改。要启动无头 Process Automation Manager 控制器,请导航到
EAP_HOME/bin
并输入以下命令:在 Linux 或基于 UNIX 的系统上:
$ ./standalone.sh
对于 Windows:
standalone.bat
有关在 Red Hat JBoss Enterprise Application Platform 集群环境中运行 Red Hat Process Automation Manager 的更多信息,请参阅 在 Red Hat JBoss EAP 集群环境中安装和配置 Red Hat Process Automation Manager。
第 11 章 为 TLS 配置智能路由器
您可以为传输层安全(TLS)支持配置智能路由器(KIE Server Router),以允许 HTTPS 流量。另外,您可以禁用到智能路由器的不安全 HTTP 连接。
先决条件
- KIE 服务器安装在 Red Hat JBoss EAP 7.3 集群的每个节点上。
- 安装并配置智能路由器。如需更多信息,请参阅 在 Red Hat JBoss EAP 集群环境中安装和配置 Red Hat Process Automation Manager。
流程
要启动智能路由器,请使用以下方法之一:
要启动启用了 TLS 支持的智能路由器,并启用 HTTPS 并允许 HTTP 连接,请输入以下命令:
java -Dorg.kie.server.router.tls.keystore = <KEYSTORE_PATH> -Dorg.kie.server.router.tls.keystore.password = <KEYSTORE_PASSWORD> -Dorg.kie.server.router.tls.keystore.keyalias = <KEYSTORE_ALIAS> -Dorg.kie.server.router.tls.port = <HTTPS_PORT> -jar rhpam-7.11.0-smart-router.jar
在本例中,替换以下变量:
-
<KEYSTORE_PATH
> :存储密钥存储的路径。 -
<KEYSTORE_PASSWORD
> :密钥存储密码。 -
<KEYSTORE_ALIAS
> :用于存储证书的别名名称。 -
<HTTPS_PORT&
gt; :HTTPS 端口。默认 HTTPS 端口为9443
。 要启动带有 TLS 支持的智能路由器,并启用 HTTPS 并禁用 HTTP 连接,请输入以下命令:
java -Dorg.kie.server.router.tls.keystore = <KEYSTORE_PATH> -Dorg.kie.server.router.tls.keystore.password = <KEYSTORE_PASSWORD> -Dorg.kie.server.router.tls.keystore.keyalias = <KEYSTORE_ALIAS> -Dorg.kie.server.router.tls.port = <HTTPS_PORT> -Dorg.kie.server.router.port=0 -jar rhpam-7.11.0-smart-router.jar
当
org.kie.server.router.port
系统属性设置为0
时,不会注册 HTTP 侦听器。如果配置了 TLS 且未注册 HTTP 侦听器,则智能路由器仅侦听 HTTPS 端口。注意如果没有配置 TLS,且您可以通过将
org.kie.server.router.port
设置为0
来禁用 HTTP,则会出现错误,并停止智能路由器。
第 12 章 在 KIE 服务器上激活或停用 KIE 容器
现在,您可以通过停用、但同时继续处理现有进程实例和任务来停止从给定容器创建新进程实例。如果停用是临时的,您可以稍后再次激活容器。KIE 容器的激活或取消激活不需要重启 KIE 服务器。
先决条件
- 在 Business Central 中创建和配置 KIE 容器。
流程
- 登录 Business Central。
- 在主菜单中,点击 Menu → Deploy → Execution Servers。
- 在 Server Configuration 窗格中选择您的服务器。
- 在 Deployment Units 窗格中,选择您要激活或停用的部署单元。
点部署单元窗格右上角的 Activate 或 Deactivate。
当一个 KIE 容器被取消激活后,您无法从 KIE 容器创建进程实例。
第 13 章 部署描述符
进程和规则存储在基于 Apache Maven 的打包中,称为 知识存档或 KJAR。规则、流程、资产和其他项目工件是 Maven 创建和管理的 JAR 文件的一部分。保存在名为 kmodule.xml
的 KJAR 的 META-INF
目录中的文件可用于定义 KIE 基础和会话。默认情况下,这个 kmodule.xml
文件为空。
每当 KIE 服务器等运行时组件负责处理 KJAR 时,它会查找 kmodule.xml
来构建运行时表示。
部署描述符是对 kmodule.xml
文件进行补充的补充,并对部署提供精细的控制。存在这些描述符是可选的,您的部署可以成功进行。您可以使用这些描述符设置纯技术属性,包括持久性、审计和运行时策略等元值。
这些描述符允许您在多个级别上配置 KIE 服务器,包括服务器级别默认、每个 KJAR 的不同部署描述符和其他服务器配置。您可以使用描述符对默认 KIE 服务器配置进行简单的自定义,可能每个 KJAR。
您可以在名为 kie-deployment-descriptor.xml
的文件中定义这些描述符,并将该文件放在 META-INF
文件夹中的 kmodule.xml
文件。您可以通过将它指定为系统参数来更改此默认位置和文件名:
-Dorg.kie.deployment.desc.location=file:/path/to/file/company-deployment-descriptor.xml
13.1. 部署描述符配置
部署描述符允许用户在多个级别上配置执行服务器:
- 服务器级别 :主级别,以及应用于服务器上部署的所有 KJAR 的主级别。
- KJAR 级别 :这可让您基于 KJAR 配置描述符。
- 部署时间级别 :部署 KJAR 时应用的描述符。
部署描述符指定的粒度配置项优先于服务器级别,但基于集合的配置项目被合并,这些项目会被合并。层次结构的工作方式如下: 部署时间配置 > KJAR configuration > server configuration。
部署时间配置适用于通过 REST API 进行的部署。
例如,如果在服务器级别定义的持久性模式(您可以配置的一个项目)是 NONE
,但相同的模式指定为 KJAR 级别的 JPA
,则实际模式将是 KJAR 的 JPA
。如果在 KJAR 的部署描述符中为持久性模式指定任何内容(或者没有部署描述符),它将回退到服务器级配置,本例中为 NONE
(如果没有服务器级别部署描述符)。
您可以配置什么?
可通过部署描述符配置高级别技术配置详情。下表列出了它们以及每个表的适用值和默认值。
配置 | XML 条目 | 允许的值 | 默认值 |
---|---|---|---|
运行时数据的持久性单元名称 | persistence-unit | 任何有效的持久性软件包名称 | org.jbpm.domain |
审计数据的持久性单元名称 | audit-persistence-unit | 任何有效的持久性软件包名称 | org.jbpm.domain |
持久性模式 | persistence-mode | JPA, NONE | JPA |
审计模式 | audit-mode | JPA、JMS 或 NONE | JPA |
运行时策略 | runtime-strategy | SINGLETON、PER_REQUEST 或 PER_PROCESS_INSTANCE | 单例 |
要注册的事件 Listeners 列表 | event-listeners |
有效的监听程序类名称作为 | 没有默认值 |
要注册的任务事件 Listeners 列表 | task-event-listeners |
有效的监听程序类名称作为 | 没有默认值 |
要注册的工作流处理程序列表 | work-item-handlers |
有效的 Work Handler 类指定为 | 没有默认值 |
要注册的全局列表 | Globals |
指定为 | 没有默认值 |
要注册的 Marshalling 策略(用于可插拔变量持久性) | marshalling-strategies |
有效的 | 没有默认值 |
授予 KJAR 资源访问权限所需的角色 | required-roles | 字符串角色名称 | 没有默认值 |
KIE 会话的其他环境条目 | environment-entries |
valid | 没有默认值 |
KIE 会话的额外配置选项 | 配置 |
valid | 没有默认值 |
用于在远程服务中序列化的类 | remoteable-class |
有效的 | 没有默认值 |
不要在生产环境中使用 EJB Timer 调度程序( KIE Server 中的默认调度程序)使用 Singleton 运行时策略。这个组合可能会导致负载出现 Hibernate 问题。如果没有特定原因来使用其他策略,则建议每个进程实例运行时策略。有关此限制的更多信息,请参阅 Singleton 策略和 EJBTimerScheduler 的 Hibernate 问题。
13.2. 管理部署描述符
Deployment 描述符可以在 Menu → Design → $PROJECT_NAME → Settings → Deployments 中的 Business Central 中配置。
每次创建项目时,都会生成带有默认值的库存 kie-deployment-descriptor.xml
文件。
不需要为所有 KJAR 提供完整的部署描述符。推荐提供部分部署描述符。例如,如果您需要使用不同的审计模式,您可以指定 KJAR,所有其他属性将在服务器级别定义默认值。
在使用 OVERRIDE_ALL
合并模式时,必须指定所有配置项目,因为相关的 KJAR 将始终使用指定的配置,且不会与层次结构中的任何其他部署描述符合并。
13.3. 限制对运行时引擎的访问
在部署描述符中可编辑 required-roles
配置项。此属性通过确保对特定进程的访问权限仅授予属于此属性定义的组的用户,从而限制对每个KJAR 或每服务器级别的运行时引擎的访问。
security 角色可用于限制对进程定义的访问或限制在运行时的访问。
默认行为是根据存储库限制将所需的角色添加到此属性中。如果需要,您可以通过提供与安全域中定义的实际角色匹配的角色来手动编辑这些属性。
流程
- 要在 Business Central 中打开项目部署描述符配置,请打开 Menu → Design → $PROJECT_NAME → Settings → Deployments。
- 从配置设置列表中,单击 Required Roles,然后单击 Add Required Role。
- 在 Add Required Role 窗口中,键入您要具有访问此部署的角色的名称,然后单击 Add。
- 若要添加更多具有访问部署权限的角色,请重复前面的步骤。
- 添加完所有所需角色后,点 Save。
第 14 章 从 Business Central 访问运行时数据
Business Central 中的以下页面允许您查看 KIE 服务器的运行时数据:
- 进程报告
- 任务报告
- 进程定义
- 进程实例
- 执行错误
- Jobs
- 任务
这些页面使用当前登录的用户的凭证从 KIE 服务器加载数据。因此,要能够在 Business Central 中查看运行时数据,请确保满足以下条件:
-
用户存在于运行 Business Central 应用程序的 KIE 容器(部署单元)。除了
kie-server
角色外
,此用户必须分配了admin
、Bitit 或developer
角色,并完全访问运行时数据。manager
和process_admin
角色还允许访问 Business Central 中的运行时数据页面。 -
用户存在于运行 KIE 服务器的 KIE 容器(部署单元),并分配了
kie-server
角色。 - 建立了 Business Central 和 KIE 服务器之间的通信。也就是说,KIE 服务器在 Process Automation Manager 控制器(属于 Business Central 的一部分)中注册。
deployment.business-central.war
登录模块存在于运行 Business Central 的服务器的standalone.xml
配置中:<login-module code="org.kie.security.jaas.KieLoginModule" flag="optional" module="deployment.business-central.war"/>
第 15 章 执行错误管理
当为启动过程发生执行错误时,该过程会停止并恢复到最新稳定状态(最接近的安全点),并继续执行。如果整个事务回滚的进程没有处理任何类型的错误,请将进程实例保持在上一个等待状态。这的任何追踪都仅在日志中可见,通常会显示在向进程引擎发送请求的调用者。
具有进程管理员(process-
)或管理员(管理员)角色的用户可以访问 Business Central 中的错误消息。执行错误消息提供以下主要优点:
admin
- 更好的可追溯性
- 关键进程时的可见性
- 根据错误情况报告和分析
- 外部系统错误处理和编译
可配置错误处理负责在整个进程引擎执行(包括任务服务)期间收到任何技术错误。以下技术例外适用:
-
扩展
java.lang.Throwable
的任何内容 - 进程级别错误处理以及之前处理的任何其他例外
有几个组件组成错误处理机制,并允许可插拔的方法扩展其功能。
错误处理的进程引擎入口点是 ExecutionErrorManager
。这与 RuntimeManager
集成,然后负责将其提供给底层 KieSession
和 TaskService
。
从 API 的视图中,ExecutionErrorManager
提供对以下组件的访问:
-
ExecutionErrorHandler
:错误处理的主要机制 -
ExecutionErrorStorage
:用于执行错误信息的可插拔存储
15.1. 管理执行错误
通过定义,检测到和存储的每个进程错误都会被取消确认,且必须由某人或某个项处理(在自动错误恢复时)。错误会根据是否被确认来决定。确认错误可节省用户信息和可追溯的时间戳。您可以随时访问 Error Management 视图。
流程
- 在 Business Central 中,进入 Menu → Manage → Execution Errors。
- 从列表中选择一个错误以打开 Details 选项卡。这将显示有关错误或错误的信息。
点 Acknowledge 按钮确认并清除错误。您可以在 Manage Execution Errors 页面中选择 Yes 来查看错误。
如果错误与某个任务相关,则会显示 Go to Task 按钮。
点 Go to Task 按钮(如果适用),查看 Manage Tasks 页面中的关联的作业信息。
在 Manage Tasks 页面中,您可以重新启动、重新调度或重试对应的任务。
15.2. ExecutionErrorHandler
ExecutionErrorHandler
是所有进程错误处理的主要机制。它绑定到 RuntimeEngine 的生命周期;这意味着在创建新运行时引擎时创建它,并在 RuntimeEngine 被处理时销毁。在给定的执行上下文或事务中使用 ExecutionErrorHandler
的单一实例。KieSession
和 TaskService
都使用该实例通知处理节点/任务的错误处理。ExecutionErrorHandler
告知以下相关信息:
- 启动给定节点实例的处理。
- 完成给定节点实例的处理。
- 开始处理给定任务实例。
- 完成给定任务实例的处理。
此信息主要用于未知类型的错误;也就是说,不提供有关进程上下文的信息的错误。例如,在提交时,数据库例外不会执行任何进程信息。
15.3. 执行错误存储
ExecutionErrorStorage
是一种可插拔策略,允许各种方法保留有关执行错误的信息。存储直接由创建存储实例时获得存储实例的处理程序使用(在创建 RuntimeEngine 时)。默认存储实施基于数据库表,它存储每个错误并包含所有可用信息。某些错误可能不包含详细信息,因为这取决于错误的类型以及是否可以提取特定信息。
15.4. 错误类型和过滤器
错误处理尝试捕获和处理任何类型的错误,因此需要一种方法来分类错误。这样,就可以从错误正确提取信息,并使其可插拔,因为有些用户可能需要以不同于默认提供的方式进行特定类型错误。
错误分类和过滤基于 ExecutionErrorFilters
。此接口仅负责构建 ExecutionError
实例,这些实例以 ExecutionErrorStorage
策略的形式存储。它有以下方法:
-
接受
:指示过滤器是否可以处理给定错误。 -
过滤
:发生实际过滤、处理等。 -
getPriority
: 表示调用过滤器时使用的优先级。
每次过滤一个错误,并使用优先级系统来避免多个过滤器返回同一错误的替代"views"。优先级启用更为特殊的过滤器来查看是否可以接受错误,或者允许另一个过滤器处理它。
ExecutionErrorFilter
可使用 ServiceLoader
机制来提供,这使得错误处理的功能可轻松扩展。
Red Hat Process Automation Manager 附带以下 ExecutionErrorFilters
:
类名称 | 类型 | 优先级 |
---|---|---|
org.jbpm.runtime.manager.impl.error.filters.ProcessExecutionErrorFilter | Process | 100 |
org.jbpm.runtime.manager.impl.error.filters.TaskExecutionErrorFilter | 任务 | 80 |
org.jbpm.runtime.manager.impl.error.filters.DBExecutionErrorFilter | DB | 200 |
org.jbpm.executor.impl.error.JobExecutionErrorFilter | 作业 | 100 |
根据优先级的最低值,会给过滤器赋予更高的执行顺序。在下表中,按以下顺序调用过滤器:
- 任务
- Process
- 作业
- DB
15.5. 自动确认执行错误
当发生错误时,默认情况下,不会确认它们,否则需要将手动确认视为需要注意的信息。如果是较大的卷,则手动操作可能会消耗时间,在某些情况下不适合。
自动确认解决了这个问题。它以 jbpm-executor
的形式基于调度的作业,它有以下三种类型的作业:
org.jbpm.executor.commands.error.JobAutoAckErrorCommand
-
负责查找之前失败的作业,但现在为另一个执行取消、完成或重新调度。此任务仅确认类型为
Job
的执行错误。 org.jbpm.executor.commands.error.TaskAutoAckErrorCommand
-
负责自动确认之前失败的任务执行错误,但现在处于其中一个退出状态(completed、failed、exited、obsolete)。此任务只确认
Task
类型的执行错误。 org.jbpm.executor.commands.error.ProcessAutoAckErrorCommand
-
负责自动确认附加错误的进程实例。它确认进程实例已经完成的错误(完成或中止)或错误源自的任务已经完成。这基于
init_activity_id
值。此作业确认符合上述条件的任何类型的执行错误。
作业可以在 KIE 服务器上注册。在 Business Central 中,您可以为错误配置自动确认作业:
先决条件
- 一个或多个类型的执行错误已在进程执行过程中累积,但不需要进一步注意。
流程
- 在 Business Central 中,点击 Menu → Manage → Jobs。
- 在屏幕右上角,单击 New Job。
- 在 Business Key 字段中输入进程关联密钥。
- 在 Type 字段中,添加以上列表中自动确认作业类型的类型。
为要完成的作业选择 Due On 时间:
-
要立即运行作业,请选择
Run now
选项。 要在特定时间运行作业,请选择
Run later
。Run later
选项旁边会显示一个日期和时间字段。点该字段打开日历,并调度作业的特定时间和日期。
-
要立即运行作业,请选择
- 点 Create 创建作业并返回 Manage Jobs 页面。
以下步骤是可选的,并允许您将自动确认作业配置为运行一次(单一
运行),或者以在特定时间间隔(NextRun
)上运行,或使用实体管理器工厂的自定义名称来搜索要确认的作业(EmfName
)。
- 点 Advanced 标签页。
- 点 Add Parameter 按钮。
输入您要应用到作业的配置参数:
-
SingleRun
:true
或false
-
NextRun
:时间表达式,如 2h、5d、1m 等。 EmfName
:自定义实体管理器工厂名称。
-
15.6. 清理错误列表
可以清理 ExecutionErrorInfo
错误列表表以删除冗余信息。根据流程的生命周期,错误可能会保留在列表中,且没有直接 API 来清理列表。相反,可以调度 ExecutionErrorCleanupCommand
命令来定期清理错误。
可以为 clean up 命令设置以下参数。该命令仅限于删除已经完成或中止的进程实例的执行错误:
DateFormat
-
日期格式用于进一步与日期相关的参数 - 如果没有给出
yyyy-MM-dd
(因为SimpleDateFormat
类)。
-
日期格式用于进一步与日期相关的参数 - 如果没有给出
EmfName
- 用于查询的实体管理器工厂的名称(valid 持久性单元名称)。
SingleRun
-
指明执行是否只为单运行(
true
|false
)。
-
指明执行是否只为单运行(
NextRun
- 提供下一次执行时间(例如:1d、5h 等)
OlderThan
- 指明应删除哪些错误 - 早于给定日期。
OlderThanPeriod
- 指明应删除比给定时间表达式旧的错误(例如 1d、5h 等)
ForProcess
- 表示仅针对给定进程定义删除错误。
ForProcessInstance
- 表示仅针对给定进程实例删除的错误。
ForDeployment
- 表示要从给定部署 ID 中删除的错误。
第 16 章 Red Hat Process Automation Manager 中的 Prometheus 指标监控
Prometheus 是一个开源系统监控工具包,您可以与 Red Hat Process Automation Manager 搭配使用,以收集和存储与执行新规则、流程、决策模型和表示法(DMN)模型和其他 Red Hat Process Automation Manager 资产相关的指标。您可以通过 REST API 调用 KIE 服务器、通过 Prometheus 表达式浏览器或使用数据图形化工具(如 Grafana)来访问存储的指标。
您可以为内部 KIE 服务器实例、Spring Boot 上的 KIE 服务器或 Red Hat OpenShift Container Platform 上的 KIE 服务器部署配置 Prometheus 指标监控。
有关 KIE 服务器与 Prometheus 公开的可用指标列表,请从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 Source Distribution /kie -server-services-prometheus/src/main/7.11.0-sources/src/droolsjbpm-integration-$VERSION/kie-server-parent/kie-server-services/kie-server-services-prometheus/src/main/java/org/kie/server/services/prometheus
。https://access.redhat.com/jbossnetwork/restricted/listSoftware.html
红帽对 Prometheus 的支持仅限于红帽产品文档中提供的设置和配置建议。
16.1. 为 KIE 服务器配置 Prometheus 指标监控
您可以将 KIE 服务器实例配置为使用 Prometheus 在 Red Hat Process Automation Manager 中收集和存储与业务资产活动相关的指标。有关 KIE 服务器与 Prometheus 公开的可用指标列表,请从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 Source Distribution /kie -server-services-prometheus/src/main/7.11.0-sources/src/droolsjbpm-integration-$VERSION/kie-server-parent/kie-server-services/kie-server-services-prometheus/src/main/java/org/kie/server/services/prometheus
。https://access.redhat.com/jbossnetwork/restricted/listSoftware.html
先决条件
- KIE 服务器已安装。
-
您有对 KIE 服务器的
kie-server
用户角色访问权限。 - 已安装 Prometheus。有关下载和使用 Prometheus 的详情,请查看 Prometheus 文档页面。
流程
-
在 KIE 服务器实例中,将
org.kie.prometheus.server.ext.disabled
系统属性设置为false
以启用 Prometheus 扩展。您可以在启动 KIE 服务器或 Red Hat Process Automation Manager 发行版本的standalone.xml
或standalone-full.xml
文件中定义此属性。 如果您在 Spring Boot 上运行 Red Hat Process Automation Manager,请在
application.properties
系统属性中配置所需的键:Red Hat Process Automation Manager 和 Prometheus 的 Spring Boot application.properties 键
kieserver.jbpm.enabled=true kieserver.drools.enabled=true kieserver.dmn.enabled=true kieserver.prometheus.enabled=true
在 Prometheus 发行版本的
prometheus.yaml
文件中,在scrape_configs
部分添加以下设置,将 Prometheus 配置为从 KIE Server 中提取指标:在 prometheus.yaml 文件中提取配置
scrape_configs: - job_name: 'kie-server' metrics_path: /SERVER_PATH/services/rest/metrics basicAuth: username: USER_NAME password: PASSWORD static_configs: - targets: ["HOST:PORT"]
提取 Spring Boot 的 prometheus.yaml 文件中的配置(如果适用)
scrape_configs: - job_name: 'kie' metrics_path: /rest/metrics static_configs: - targets: ["HOST:PORT"]
根据您的 KIE 服务器位置和设置替换值。
启动 KIE 服务器实例。
Red Hat JBoss EAP 上 Red Hat Process Automation Manager 的 start 命令示例
$ cd ~/EAP_HOME/bin $ ./standalone.sh --c standalone-full.xml
启动配置的 KIE 服务器实例后,Prometheus 开始收集指标和 KIE 服务器将指标发布到 REST API 端点
http://HOST:PORT/SERVER/services/rest/metrics
(或在 Spring Boot 中)发送到
http://HOST:PORT/rest/metrics。在 REST 客户端或 curl 工具中,发送带有以下组件的 REST API 请求,以验证 KIE 服务器是否发布指标:
对于 REST 客户端:
-
身份验证 :使用
kie-server
角色输入 KIE 服务器用户的用户名和密码。 HTTP 标头 :设置以下标头:
-
接受
:application/json
-
-
HTTP 方法 :设置为
GET
。 -
URL :输入 KIE Server REST API 基本 URL 和指标端点,如
http://localhost:8080/kie-server/services/rest/metrics
(或在 Spring Boot 中,http://localhost:8080/rest/metrics
)。
对于 curl 工具:
-
-u
:使用kie-server
角色输入 KIE 服务器用户的用户名和密码。 -h
: 设置以下标头:-
接受
:application/json
-
-
-x
: 设置为GET
。 -
URL :输入 KIE Server REST API 基本 URL 和指标端点,如
http://localhost:8080/kie-server/services/rest/metrics
(或在 Spring Boot 中,http://localhost:8080/rest/metrics
)。
Red Hat JBoss EAP 上 Red Hat Process Automation Manager 的 curl 命令示例
curl -u 'baAdmin:password@1' -X GET "http://localhost:8080/kie-server/services/rest/metrics"
Spring Boot 上 Red Hat Process Automation Manager 的 curl 命令示例
curl -u 'baAdmin:password@1' -X GET "http://localhost:8080/rest/metrics"
服务器响应示例
# HELP kie_server_container_started_total Kie Server Started Containers # TYPE kie_server_container_started_total counter kie_server_container_started_total{container_id="task-assignment-kjar-1.0",} 1.0 # HELP solvers_running Number of solvers currently running # TYPE solvers_running gauge solvers_running 0.0 # HELP dmn_evaluate_decision_nanosecond DMN Evaluation Time # TYPE dmn_evaluate_decision_nanosecond histogram # HELP solver_duration_seconds Time in seconds it took solver to solve the constraint problem # TYPE solver_duration_seconds summary solver_duration_seconds_count{solver_id="100tasks-5employees.xml",} 1.0 solver_duration_seconds_sum{solver_id="100tasks-5employees.xml",} 179.828255925 solver_duration_seconds_count{solver_id="24tasks-8employees.xml",} 1.0 solver_duration_seconds_sum{solver_id="24tasks-8employees.xml",} 179.995759653 # HELP drl_match_fired_nanosecond Drools Firing Time # TYPE drl_match_fired_nanosecond histogram # HELP dmn_evaluate_failed_count DMN Evaluation Failed # TYPE dmn_evaluate_failed_count counter # HELP kie_server_start_time Kie Server Start Time # TYPE kie_server_start_time gauge kie_server_start_time{name="myapp-kieserver",server_id="myapp-kieserver",location="http://myapp-kieserver-demo-monitoring.127.0.0.1.nip.io:80/services/rest/server",version="7.4.0.redhat-20190428",} 1.557221271502E12 # HELP kie_server_container_running_total Kie Server Running Containers # TYPE kie_server_container_running_total gauge kie_server_container_running_total{container_id="task-assignment-kjar-1.0",} 1.0 # HELP solver_score_calculation_speed Number of moves per second for a particular solver solving the constraint problem # TYPE solver_score_calculation_speed summary solver_score_calculation_speed_count{solver_id="100tasks-5employees.xml",} 1.0 solver_score_calculation_speed_sum{solver_id="100tasks-5employees.xml",} 6997.0 solver_score_calculation_speed_count{solver_id="24tasks-8employees.xml",} 1.0 solver_score_calculation_speed_sum{solver_id="24tasks-8employees.xml",} 19772.0 # HELP kie_server_case_started_total Kie Server Started Cases # TYPE kie_server_case_started_total counter kie_server_case_started_total{case_definition_id="itorders.orderhardware",} 1.0 # HELP kie_server_case_running_total Kie Server Running Cases # TYPE kie_server_case_running_total gauge kie_server_case_running_total{case_definition_id="itorders.orderhardware",} 2.0 # HELP kie_server_data_set_registered_total Kie Server Data Set Registered # TYPE kie_server_data_set_registered_total gauge kie_server_data_set_registered_total{name="jbpmProcessInstanceLogs::CUSTOM",uuid="jbpmProcessInstanceLogs",} 1.0 kie_server_data_set_registered_total{name="jbpmRequestList::CUSTOM",uuid="jbpmRequestList",} 1.0 kie_server_data_set_registered_total{name="tasksMonitoring::CUSTOM",uuid="tasksMonitoring",} 1.0 kie_server_data_set_registered_total{name="jbpmHumanTasks::CUSTOM",uuid="jbpmHumanTasks",} 1.0 kie_server_data_set_registered_total{name="jbpmHumanTasksWithUser::FILTERED_PO_TASK",uuid="jbpmHumanTasksWithUser",} 1.0 kie_server_data_set_registered_total{name="jbpmHumanTasksWithVariables::CUSTOM",uuid="jbpmHumanTasksWithVariables",} 1.0 kie_server_data_set_registered_total{name="jbpmProcessInstancesWithVariables::CUSTOM",uuid="jbpmProcessInstancesWithVariables",} 1.0 kie_server_data_set_registered_total{name="jbpmProcessInstances::CUSTOM",uuid="jbpmProcessInstances",} 1.0 kie_server_data_set_registered_total{name="jbpmExecutionErrorList::CUSTOM",uuid="jbpmExecutionErrorList",} 1.0 kie_server_data_set_registered_total{name="processesMonitoring::CUSTOM",uuid="processesMonitoring",} 1.0 kie_server_data_set_registered_total{name="jbpmHumanTasksWithAdmin::FILTERED_BA_TASK",uuid="jbpmHumanTasksWithAdmin",} 1.0 # HELP kie_server_execution_error_total Kie Server Execution Errors # TYPE kie_server_execution_error_total counter # HELP kie_server_task_completed_total Kie Server Completed Tasks # TYPE kie_server_task_completed_total counter # HELP kie_server_container_running_total Kie Server Running Containers # TYPE kie_server_container_running_total gauge kie_server_container_running_total{container_id="itorders_1.0.0-SNAPSHOT",} 1.0 # HELP kie_server_job_cancelled_total Kie Server Cancelled Jobs # TYPE kie_server_job_cancelled_total counter # HELP kie_server_process_instance_started_total Kie Server Started Process Instances # TYPE kie_server_process_instance_started_total counter kie_server_process_instance_started_total{container_id="itorders_1.0.0-SNAPSHOT",process_id="itorders.orderhardware",} 1.0 # HELP solver_duration_seconds Time in seconds it took solver to solve the constraint problem # TYPE solver_duration_seconds summary # HELP kie_server_task_skipped_total Kie Server Skipped Tasks # TYPE kie_server_task_skipped_total counter # HELP kie_server_data_set_execution_time_seconds Kie Server Data Set Execution Time # TYPE kie_server_data_set_execution_time_seconds summary kie_server_data_set_execution_time_seconds_count{uuid="jbpmProcessInstances",} 8.0 kie_server_data_set_execution_time_seconds_sum{uuid="jbpmProcessInstances",} 0.05600000000000001 # HELP kie_server_job_scheduled_total Kie Server Started Jobs # TYPE kie_server_job_scheduled_total counter # HELP kie_server_data_set_execution_total Kie Server Data Set Execution # TYPE kie_server_data_set_execution_total counter kie_server_data_set_execution_total{uuid="jbpmProcessInstances",} 8.0 # HELP kie_server_process_instance_completed_total Kie Server Completed Process Instances # TYPE kie_server_process_instance_completed_total counter # HELP kie_server_job_running_total Kie Server Running Jobs # TYPE kie_server_job_running_total gauge # HELP kie_server_task_failed_total Kie Server Failed Tasks # TYPE kie_server_task_failed_total counter # HELP kie_server_task_exited_total Kie Server Exited Tasks # TYPE kie_server_task_exited_total counter # HELP dmn_evaluate_decision_nanosecond DMN Evaluation Time # TYPE dmn_evaluate_decision_nanosecond histogram # HELP kie_server_data_set_lookups_total Kie Server Data Set Running Lookups # TYPE kie_server_data_set_lookups_total gauge kie_server_data_set_lookups_total{uuid="jbpmProcessInstances",} 0.0 # HELP kie_server_process_instance_duration_seconds Kie Server Process Instances Duration # TYPE kie_server_process_instance_duration_seconds summary # HELP kie_server_case_duration_seconds Kie Server Case Duration # TYPE kie_server_case_duration_seconds summary # HELP dmn_evaluate_failed_count DMN Evaluation Failed # TYPE dmn_evaluate_failed_count counter # HELP kie_server_task_added_total Kie Server Added Tasks # TYPE kie_server_task_added_total counter kie_server_task_added_total{deployment_id="itorders_1.0.0-SNAPSHOT",process_id="itorders.orderhardware",task_name="Prepare hardware spec",} 1.0 # HELP drl_match_fired_nanosecond Drools Firing Time # TYPE drl_match_fired_nanosecond histogram # HELP kie_server_container_started_total Kie Server Started Containers # TYPE kie_server_container_started_total counter kie_server_container_started_total{container_id="itorders_1.0.0-SNAPSHOT",} 1.0 # HELP kie_server_process_instance_sla_violated_total Kie Server Process Instances SLA Violated # TYPE kie_server_process_instance_sla_violated_total counter # HELP kie_server_task_duration_seconds Kie Server Task Duration # TYPE kie_server_task_duration_seconds summary # HELP kie_server_job_executed_total Kie Server Executed Jobs # TYPE kie_server_job_executed_total counter # HELP kie_server_deployments_active_total Kie Server Active Deployments # TYPE kie_server_deployments_active_total gauge kie_server_deployments_active_total{deployment_id="itorders_1.0.0-SNAPSHOT",} 1.0 # HELP kie_server_process_instance_running_total Kie Server Running Process Instances # TYPE kie_server_process_instance_running_total gauge kie_server_process_instance_running_total{container_id="itorders_1.0.0-SNAPSHOT",process_id="itorders.orderhardware",} 2.0 # HELP solvers_running Number of solvers currently running # TYPE solvers_running gauge solvers_running 0.0 # HELP kie_server_work_item_duration_seconds Kie Server Work Items Duration # TYPE kie_server_work_item_duration_seconds summary # HELP kie_server_job_duration_seconds Kie Server Job Duration # TYPE kie_server_job_duration_seconds summary # HELP solver_score_calculation_speed Number of moves per second for a particular solver solving the constraint problem # TYPE solver_score_calculation_speed summary # HELP kie_server_start_time Kie Server Start Time # TYPE kie_server_start_time gauge kie_server_start_time{name="sample-server",server_id="sample-server",location="http://localhost:8080/kie-server/services/rest/server",version="7.52.1-SNAPSHOT",} 1.557285486469E12
如果 KIE 服务器中没有指标,请查看并验证本节中描述的 KIE 服务器和 Prometheus 配置。
您还可以在
http://HOST:PORT/graph
的 Prometheus 表达式浏览器中与收集的指标交互,或使用 data-graphing 工具(如 Grafana)集成 Prometheus 数据源:图 16.1. 带有 KIE 服务器指标的 Prometheus 表达式浏览器
图 16.2. 带有 KIE 服务器目标的 Prometheus 表达式浏览器
图 16.3. 带有 DMN 模型的 KIE 服务器指标的 Grafana 仪表板
图 16.4. 带有用于解析器的 KIE 服务器指标的 Grafana 仪表板
图 16.5. 带有 KIE 服务器指标的 Grafana 仪表板,用于进程、情况和任务
-
身份验证 :使用
16.2. 在 Red Hat OpenShift Container Platform 上为 KIE 服务器配置 Prometheus 指标监控
您可以在 Red Hat OpenShift Container Platform 上配置 KIE 服务器部署,以使用 Prometheus 收集和存储与 Red Hat Process Automation Manager 中业务资产活动相关的指标。有关 KIE 服务器与 Prometheus 公开的可用指标列表,请从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 Source Distribution /kie -server-services-prometheus/src/main/7.11.0-sources/src/droolsjbpm-integration-$VERSION/kie-server-parent/kie-server-services/kie-server-services-prometheus/src/main/java/org/kie/server/services/prometheus
。https://access.redhat.com/jbossnetwork/restricted/listSoftware.html
先决条件
- KIE 服务器已安装并部署在 Red Hat OpenShift Container Platform 上。如需有关 OpenShift 上的 KIE Server 的更多信息,请参阅 Red Hat Process Automation Manager 7.11 产品文档中的相关 OpenShift 部署选项。
-
您有对 KIE 服务器的
kie-server
用户角色访问权限。 - 已安装 Prometheus Operator。有关下载和使用 Prometheus Operator 的详情,请参考 GitHub 中的 Prometheus Operator 项目。
流程
在 OpenShift 上的 KIE 服务器部署的
DeploymentConfig
对象中,将PROMETHEUS_SERVER_EXT_DISABLED
环境变量设置为false
来启用 Prometheus 扩展。您可以在 OpenShift Web 控制台中设置此变量,或者在命令终端中使用oc
命令:oc set env dc/<dc_name> PROMETHEUS_SERVER_EXT_DISABLED=false -n <namespace>
如果您还没有在 OpenShift 上部署 KIE 服务器,然后在计划用于 OpenShift 部署的 OpenShift 模板中(如
rhpam711-prod-immutable-kieserver.yaml
),您可以将PROMETHEUS_SERVER_EXT_DISABLED
模板参数设置为false
来启用 Prometheus 扩展。如果您使用 OpenShift Operator 在 OpenShift 上部署 KIE Server,然后在 KIE Server 配置中,将
PROMETHEUS_SERVER_EXT_DISABLED
环境变量设置为false
来启用 Prometheus 扩展:apiVersion: app.kiegroup.org/v1 kind: KieApp metadata: name: enable-prometheus spec: environment: rhpam-trial objects: servers: - env: - name: PROMETHEUS_SERVER_EXT_DISABLED value: "false"
创建
service-metrics.yaml
文件,以添加从 KIE Server 公开给 Prometheus 的指标数据的服务:apiVersion: v1 kind: Service metadata: annotations: description: RHPAM Prometheus metrics exposed labels: app: myapp-kieserver application: myapp-kieserver template: myapp-kieserver metrics: rhpam name: rhpam-app-metrics spec: ports: - name: web port: 8080 protocol: TCP targetPort: 8080 selector: deploymentConfig: myapp-kieserver sessionAffinity: None type: ClusterIP
在命令终端中,使用
oc
命令将service-metrics.yaml
文件应用到 OpenShift 部署:oc apply -f service-metrics.yaml
-
创建一个 OpenShift secret,如
metrics-secret
,以访问 KIE 服务器上的 Prometheus 指标。secret 必须包含带有 KIE 服务器用户凭证的 "username" 和 "password" 元素。如需有关 OpenShift 机密的信息,请参阅 OpenShift 开发人员指南 中的 机密 章节。 创建定义
ServiceMonitor
对象的service-monitor.yaml
文件。服务监控器可让 Prometheus 连接到 KIE 服务器指标服务。apiVersion: monitoring.coreos.com/v1 kind: ServiceMonitor metadata: name: rhpam-service-monitor labels: team: frontend spec: selector: matchLabels: metrics: rhpam endpoints: - port: web path: /services/rest/metrics basicAuth: password: name: metrics-secret key: password username: name: metrics-secret key: username
在命令终端中,使用
oc
命令将service-monitor.yaml
文件应用到 OpenShift 部署:oc apply -f service-monitor.yaml
完成这些配置后,Prometheus 开始收集指标和 KIE 服务器将指标发布到 REST API 端点
http://HOST:PORT/kie-server/services/rest/metrics
。您可以在
http://HOST:PORT/graph
的 Prometheus 表达式浏览器中与收集的指标交互,或使用 data-graphing 工具(如 Grafana)集成 Prometheus 数据源。Prometheus 表达式浏览器位置
http://HOST:PORT/graph
的主机和端口是在安装 Prometheus Operator 时公开 Prometheus Web 控制台的路由中定义。如需有关 OpenShift 路由的信息,请参阅 OpenShift 架构 文档中的 路由 章节。图 16.6. 带有 KIE 服务器指标的 Prometheus 表达式浏览器
图 16.7. 带有 KIE 服务器目标的 Prometheus 表达式浏览器
图 16.8. 带有 DMN 模型的 KIE 服务器指标的 Grafana 仪表板
图 16.9. 带有用于解析器的 KIE 服务器指标的 Grafana 仪表板
图 16.10. 带有 KIE 服务器指标的 Grafana 仪表板,用于进程、情况和任务
16.3. 使用自定义指标在 KIE 服务器中扩展 Prometheus 指标监控
将 KIE 服务器实例配置为使用 Prometheus 指标监控后,您可以在 KIE 服务器中扩展 Prometheus 功能,以根据您的业务需求使用自定义指标。然后,Prometheus 会收集并存储您的自定义指标,以及 KIE 服务器通过 Prometheus 公开的默认指标。
例如,此步骤定义了由 Prometheus 收集和存储的自定义决策模型和表示法(DMN)指标。
先决条件
- Prometheus 指标监控为您的 KIE 服务器实例配置。有关内部使用 KIE 服务器的 Prometheus 配置的详情,请参考 第 16.1 节 “为 KIE 服务器配置 Prometheus 指标监控”。有关在 Red Hat OpenShift Container Platform 上使用 KIE 服务器的 Prometheus 配置的详情,请参考 第 16.2 节 “在 Red Hat OpenShift Container Platform 上为 KIE 服务器配置 Prometheus 指标监控”。
流程
创建一个空的 Maven 项目,并在项目的
pom.xml
文件中定义以下打包类型和依赖项:示例项目中的 pom.xml 文件示例
<packaging>jar</packaging> <properties> <version.org.kie>7.52.0.Final-redhat-00007</version.org.kie> </properties> <dependencies> <dependency> <groupId>org.kie</groupId> <artifactId>kie-api</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-api</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-services-common</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-services-drools</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-services-prometheus</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie</groupId> <artifactId>kie-dmn-api</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie</groupId> <artifactId>kie-dmn-core</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.jbpm</groupId> <artifactId>jbpm-services-api</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.jbpm</groupId> <artifactId>jbpm-executor</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.optaplanner</groupId> <artifactId>optaplanner-core</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>io.prometheus</groupId> <artifactId>simpleclient</artifactId> <version>0.5.0</version> </dependency> </dependencies>
作为定义自定义 Prometheus 指标的自定义监听程序类的一部分,从
org.kie.server.services.prometheus.PrometheusMetricsProvider
接口实现相关的监听程序,如下例所示:自定义监听程序类中的
DMNRuntimeEventListener
侦听器实现示例package org.kie.server.ext.prometheus; import io.prometheus.client.Gauge; import org.kie.dmn.api.core.ast.DecisionNode; import org.kie.dmn.api.core.event.AfterEvaluateBKMEvent; import org.kie.dmn.api.core.event.AfterEvaluateContextEntryEvent; import org.kie.dmn.api.core.event.AfterEvaluateDecisionEvent; import org.kie.dmn.api.core.event.AfterEvaluateDecisionServiceEvent; import org.kie.dmn.api.core.event.AfterEvaluateDecisionTableEvent; import org.kie.dmn.api.core.event.BeforeEvaluateBKMEvent; import org.kie.dmn.api.core.event.BeforeEvaluateContextEntryEvent; import org.kie.dmn.api.core.event.BeforeEvaluateDecisionEvent; import org.kie.dmn.api.core.event.BeforeEvaluateDecisionServiceEvent; import org.kie.dmn.api.core.event.BeforeEvaluateDecisionTableEvent; import org.kie.dmn.api.core.event.DMNRuntimeEventListener; import org.kie.server.api.model.ReleaseId; import org.kie.server.services.api.KieContainerInstance; public class ExampleCustomPrometheusMetricListener implements DMNRuntimeEventListener { private final KieContainerInstance kieContainer; private final Gauge randomGauge = Gauge.build() .name("random_gauge_nanosecond") .help("Random gauge as an example of custom KIE Prometheus metric") .labelNames("container_id", "group_id", "artifact_id", "version", "decision_namespace", "decision_name") .register(); public ExampleCustomPrometheusMetricListener(KieContainerInstance containerInstance) { kieContainer = containerInstance; } public void beforeEvaluateDecision(BeforeEvaluateDecisionEvent e) { } public void afterEvaluateDecision(AfterEvaluateDecisionEvent e) { DecisionNode decisionNode = e.getDecision(); ReleaseId releaseId = kieContainer.getResource().getReleaseId(); randomGauge.labels(kieContainer.getContainerId(), releaseId.getGroupId(), releaseId.getArtifactId(), releaseId.getVersion(), decisionNode.getModelName(), decisionNode.getModelNamespace()) .set((int) (Math.random() * 100)); } public void beforeEvaluateBKM(BeforeEvaluateBKMEvent event) { } public void afterEvaluateBKM(AfterEvaluateBKMEvent event) { } public void beforeEvaluateContextEntry(BeforeEvaluateContextEntryEvent event) { } public void afterEvaluateContextEntry(AfterEvaluateContextEntryEvent event) { } public void beforeEvaluateDecisionTable(BeforeEvaluateDecisionTableEvent event) { } public void afterEvaluateDecisionTable(AfterEvaluateDecisionTableEvent event) { } public void beforeEvaluateDecisionService(BeforeEvaluateDecisionServiceEvent event) { } public void afterEvaluateDecisionService(AfterEvaluateDecisionServiceEvent event) { } }
PrometheusMetricsProvider
接口包含收集 Prometheus 指标所需的监听程序。接口由您在pom.xml
文件中声明的kie-server-services-prometheus
依赖项合并。在本例中,
ExampleCustomPrometheusMetricListener
类实现DMNRuntimeEventListener
侦听器(来自PrometheusMetricsProvider
接口),并定义要由 Prometheus 收集和存储的自定义 DMN 指标。将
PrometheusMetricsProvider
接口作为自定义指标供应商类的一部分,它将您的自定义监听程序与PrometheusMetricsProvider
接口相关联,如下例所示:自定义指标供应商类中的
PrometheusMetricsProvider
接口的实现示例package org.kie.server.ext.prometheus; import org.jbpm.executor.AsynchronousJobListener; import org.jbpm.services.api.DeploymentEventListener; import org.kie.api.event.rule.AgendaEventListener; import org.kie.api.event.rule.DefaultAgendaEventListener; import org.kie.dmn.api.core.event.DMNRuntimeEventListener; import org.kie.server.services.api.KieContainerInstance; import org.kie.server.services.prometheus.PrometheusMetricsProvider; import org.optaplanner.core.impl.phase.event.PhaseLifecycleListener; import org.optaplanner.core.impl.phase.event.PhaseLifecycleListenerAdapter; public class MyPrometheusMetricsProvider implements PrometheusMetricsProvider { public DMNRuntimeEventListener createDMNRuntimeEventListener(KieContainerInstance kContainer) { return new ExampleCustomPrometheusMetricListener(kContainer); } public AgendaEventListener createAgendaEventListener(String kieSessionId, KieContainerInstance kContainer) { return new DefaultAgendaEventListener(); } public PhaseLifecycleListener createPhaseLifecycleListener(String solverId) { return new PhaseLifecycleListenerAdapter() { }; } public AsynchronousJobListener createAsynchronousJobListener() { return null; } public DeploymentEventListener createDeploymentEventListener() { return null; } }
在本例中,
MyPrometheusMetricsProvider
类实施PrometheusMetricsProvider
接口,并包含自定义ExampleCustomPrometheusMetricListener
侦听器类。-
要使新指标提供程序可以被 KIE 服务器发现,请在 Maven 项目中创建一个
META-INF/services/org.kie.server.services.prometheus.PrometheusMetricsProvider
文件,并在文件中添加PrometheusMetricsProvider
实现类的完全限定域名。在本例中,文件包含一行org.kie.server.ext.prometheus.MyPrometheusMetricsProvider
。 构建您的项目,并将生成的 JAR 文件复制到项目的
~/kie-server.war/WEB-INF/lib
目录中。例如,在 Red Hat JBoss EAP 上,此目录的路径是EAP_HOME/standalone/deployments/kie-server.war/WEB-INF/lib
。如果要在 Red Hat OpenShift Container Platform 上部署 Red Hat Process Automation Manager,请创建一个自定义 KIE Server 镜像,并将此 JAR 文件添加到镜像中。有关使用额外 JAR 文件创建自定义 KIE 服务器镜像的更多信息,请参阅使用 Operator 在 Red Hat OpenShift Container Platform 4 上部署 Red Hat Process Automation Manager 环境。
启动 KIE 服务器,并将构建的项目部署到正在运行的 KIE 服务器中。您可以使用 Business Central 接口或 KIE Server REST API (到
http://SERVER:PORT/kie-server/services/rest/server/containers/{containerId}
的PUT
请求)部署项目。在项目部署到正在运行的 KIE 服务器上后,Prometheus 开始收集指标和 KIE 服务器将指标发布到 REST API 端点
http://HOST:PORT/SERVER/services/rest/metrics
(或在 Spring Boot 中,或将指标发布到http://HOST:PORT/rest/metrics)。
第 17 章 配置 OpenShift 连接超时
默认情况下,OpenShift 路由配置为超时超过 30 秒的 HTTP 请求。这可能会导致 Business Central 中的会话超时问题,从而导致以下行为:
- "无法完成您的请求。发生以下异常:(TypeError):Cannot read attributes 'indexOf' of null."
- "无法完成您的请求。发生以下异常:(TypeError): b is null。
- 当点击 Business Central 中的 Project 或 Server 链接时,会显示空白页面。
所有 Business Central 模板都已包含扩展超时配置。
要在 Business Central OpenShift 路由上配置较长的超时,请在目标路由中添加 haproxy.router.openshift.io/timeout: 60s
注解:
- kind: Route apiVersion: v1 id: "$APPLICATION_NAME-rhpamcentr-http" metadata: name: "$APPLICATION_NAME-rhpamcentr" labels: application: "$APPLICATION_NAME" annotations: description: Route for Business Central's http service. haproxy.router.openshift.io/timeout: 60s spec: host: "$BUSINESS_CENTRAL_HOSTNAME_HTTP" to: name: "$APPLICATION_NAME-rhpamcentr"
有关特定于全局路由的超时注解的完整列表,请参阅 OpenShift 文档。
第 18 章 Persistence
二进制持久性或 marshaling 将进程实例的状态转换为二进制数据集。二进制持久性是用于永久存储和检索信息的机制。相同的机制也应用于会话状态和工作项目状态。
当您启用进程实例的持久性时:
- Red Hat Process Automation Manager 将进程实例信息转换为二进制数据。出于性能的原因,使用自定义序列化而不是 Java 序列化。
- 二进制数据与其他进程实例元数据一起存储,如进程实例 ID、进程 ID 和进程启动日期。
会话也可以存储其他类型的状态,如计时器作业的状态,或者这些规则评估所需的数据。会话状态作为二进制数据集单独存储,以及会话和元数据的 ID。您可以通过重新载入给定 ID 的会话来恢复会话状态。使用 ksession.getId ()
获取会话 ID。
在配置持久性时,Red Hat Process Automation Manager 将保留以下内容:
- 会话状态 :这包括会话 ID、上次修改的日期、新规则需要评估的会话数据,以及计时器作业状态。
- 进程实例状态 :这包括进程实例 ID、进程 ID、上次修改的日期、上次读取访问日期、进程实例启动日期、运行时数据(包括正在执行的节点、变量值和其他进程实例数据)以及事件类型。
- 工作项目运行时状态 :这包括工作项目 ID、创建日期、名称、进程实例 ID 以及工作项目状态本身。
根据持久数据,您可以在出现故障时恢复所有正在运行的进程实例的执行状态,或者临时从内存中删除运行的实例,并在以后恢复它们。
18.1. 配置 KIE 服务器持久性
您可以通过将 Hibernate 或 JPA 参数作为系统属性传递来配置 KIE 服务器持久性。
KIE 服务器可以使用以下前缀确认系统属性,您可以使用具有以下前缀的每个 Hibernate 或 JPA 参数:
-
javax.persistence
-
hibernate
流程
要配置 KIE 服务器持久性,请完成以下任一任务:
如果要使用 Red Hat JBoss EAP 配置文件配置 KIE 服务器持久性,请完成以下任务:
-
在 Red Hat Process Automation Manager 安装目录中,进入
standalone-full.xml
文件。例如,如果您为 Red Hat Process Automation Manager 使用 Red Hat JBoss EAP 安装,请转至$EAP_HOME/standalone/configuration/standalone-full.xml
文件。 打开
standalone-full.xml
文件,并在 <system-properties&
gt; 标签下,将 Hibernate 或 JPA 参数设置为系统属性。使用 Hibernate 参数配置 KIE 服务器持久性的示例
<system-properties> ... <property name="hibernate.hbm2ddl.auto" value="create-drop"/> ... <system-properties>
使用 JPA 参数配置 KIE 服务器持久性的示例
<system-properties> ... <property name="javax.persistence.jdbc.url" value="jdbc:mysql://mysql.db.server:3306/my_database?useSSL=false&serverTimezone=UTC"/> ... <system-properties>
如果要使用命令行配置 KIE 服务器持久性,请完成以下任务:
使用
-Dkey=value
直接从命令行传递参数,如下所示:使用 Hibernate 参数配置 KIE 服务器持久性示例:
$EAP_HOME/bin/standalone.sh -Dhibernate.hbm2ddl.auto=create-drop
使用 JPA 参数配置 KIE 服务器持久性示例:
$EAP_HOME/bin/standalone.sh -Djavax.persistence.jdbc.url=jdbc:mysql://mysql.db.server:3306/my_database?useSSL=false&serverTimezone=UTC
-
在 Red Hat Process Automation Manager 安装目录中,进入
18.2. 配置安全点
要允许持久性,请将 jbpm-persistence
JAR 文件添加到应用的类路径中,并将进程引擎配置为使用持久性。当进程引擎到达安全点时,进程引擎会自动将运行时状态存储在存储中。
安全点是进程实例暂停的位置。当进程实例调用到达进程引擎的安全点时,进程引擎会将进程实例的任何更改存储为进程运行时数据的快照。但是,当进程实例完成后,进程实例运行时数据的持久性快照会被自动删除。
Tailoring2 安全点节点确保进程引擎在执行停止和提交事务的位置保存进程定义的状态。以下 192.168.1.0/242 节点被视为安全点:
所有中间 CATCH 事件
- 计时器中间事件
- 错误 Intermediate 事件
- 条件中间事件
- compensation Intermediate 事件
- signal Intermediate 事件
- 升级中间事件
- 消息中间事件
- 用户任务
- 自定义(由用户定义)没有完成处理程序中的任务
如果发生故障,且您需要从存储中恢复进程引擎运行时,则进程实例会自动恢复,其执行恢复,因此无需手动重新加载和触发进程实例。
将运行时持久数据视为进程引擎内部。您不应该访问持久运行时数据或修改它们,因为这可能会具有意外的副作用。
有关当前执行状态的更多信息,请参阅历史记录日志。仅在需要时查询数据库以获取运行时数据。
18.3. 会话持久性实体
会话保留为 SessionInfo
实体。它们保留 runtime KIE 会话的状态,并存储以下数据:
字段 | 描述 | nullable |
---|---|---|
| 主密钥。 | NOT NULL |
| 实体保存到数据库最后一次的时间。 | |
| 会话的状态。 | NOT NULL |
| 会话开始时间。 | |
| 包含锁定值的版本字段。 |
18.4. 进程实例持久性实体
进程实例保留为 ProcessInstanceInfo
实体,该实体会在运行时保留进程实例的状态并存储以下数据:
字段 | 描述 | nullable |
---|---|---|
| 主密钥。 | NOT NULL |
| 实体保存到数据库最后一次的时间。 | |
| 从数据库检索实体最后一次的时间。 | |
| 进程的 ID。 | |
| 以二进制数据集的形式的进程实例的状态。 | NOT NULL |
| 进程的开始时间。 | |
| 代表进程实例状态的整数。 | NOT NULL |
| 包含锁定值的版本字段。 |
ProcessInstanceInfo
与 EventTypes
实体有一个 1:N 关系。
EventTypes
实体包含以下数据:
字段 | 描述 | nullable |
---|---|---|
|
此列上对 | NOT NULL |
| 进程中的一个已完成事件。 |
18.5. 工作项目持久性实体
工作项目保留为 WorkItemInfo
实体,该实体会在运行时保留特定工作项目实例的状态,并存储以下数据:
字段 | 描述 | nullable |
---|---|---|
| 主密钥。 | NOT NULL |
| 工作项目的名称。 | |
| (主密钥)ID。此字段没有外键约束。 | NOT NULL |
| 作业项目的状态。 | NOT NULL |
| 包含锁定值的版本字段。 | |
| 作为一个二进制数据集中的工作项目状态。 | NOT NULL |
18.6. 关联密钥实体
CorrelationKeyInfo
实体包含有关分配给给定进程实例的关联密钥的信息。这个表是可选的。仅在需要关联功能时使用它。
字段 | 描述 | nullable |
---|---|---|
| 主密钥。 | NOT NULL |
| 关联密钥的分配名称。 | |
| 分配给关联密钥的进程实例的 ID。 | NOT NULL |
| 包含锁定值的版本字段。 |
CorrelationPropertyInfo
实体包含有关分配给进程实例的关联密钥的相关属性的信息。
字段 | 描述 | nullable |
---|---|---|
| 主密钥。 | NOT NULL |
| 属性的名称。 | |
| 属性的值。 | NOT NULL |
| 包含锁定值的版本字段。 | |
| 映射到关联密钥的外部密钥。 | NOT NULL |
18.7. 上下文映射实体
ContextMappingInfo
实体包含有关映射到 KieSession
的上下文信息的信息。这是 RuntimeManager
的内部部分,在不使用 RuntimeManager
时可以被视为可选的。
字段 | 描述 | nullable |
---|---|---|
| 主密钥。 | NOT NULL |
| 上下文标识符。 | NOT NULL |
|
| NOT NULL |
| 包含锁定值的版本字段。 | |
| 包含给定映射关联的部署单元的标识符 |
18.8. pessimistic locking 支持
进程持久性的默认锁定机制是 选择的。当多线程对同一进程实例的并发并发时,这个锁定策略可能会导致性能不正确。
18.8.1. 通过代码配置 pessimistic locking 支持
您可以基于每个进程设置锁定机制,并允许它进行 缺陷。您还可以在每个 KIE 会话级别或 Runtime Manager 级别进行更改,而不只是在进程级别进行更改。
要设置进程以使用 pessimistic 锁定,请在运行时环境中使用以下配置:
import org.kie.api.runtime.Environment; import org.kie.api.runtime.EnvironmentName; import org.kie.api.runtime.manager.RuntimeManager; import org.kie.api.runtime.manager.RuntimeManagerFactory; ... env.set(EnvironmentName.USE_PESSIMISTIC_LOCKING, true); 1 RuntimeManager manager = RuntimeManagerFactory.Factory.get().newPerRequestRuntimeManager(environment); 2
18.8.2. 在 Business Central 中配置 Pessimistic locking 支持
Business Central 支持流程的缺陷锁定。要将进程设置为在 Business Central 中使用 pessimistic 锁定,请使用以下流程:
先决条件
- 在 Business Central 中有足够的用户权限。
- 您已创建了 Business Central 项目。
流程
- 在 Business Central 中,进入 Menu → Design → Projects。
- 选择您的项目。
- 单击 Settings 选项卡,以访问项目设置。
- 进入 Deployments → Environment 条目。
- 点 Add Environment Entry。
要添加环境条目,请输入以下值:
- 名称 :输入您的环境名称。
- 值 :输入您的环境值。
- 解析器类型 : 根据您的要求,选择 MVEL、Reflection 或 Spring resolver 类型。
- 参数 :添加参数。
- 单击 Save,然后再次点击 Save 以确认您的更改。
18.9. 在 Red Hat Process Automation Manager 中保留独立数据库模式中的进程变量
当您在您定义的进程内创建进程变量时,Red Hat Process Automation Manager 会将这些进程变量存储为二进制数据存储在默认数据库架构中。您可以在单独的数据库模式中保留进程变量,以便在维护和实施进程数据方面具有更大的灵活性。
例如,在单独的数据库模式中保留您的进程变量可帮助您执行以下任务:
- 以人类可读格式维护进程变量
- 使变量可供 Red Hat Process Automation Manager 之外的服务使用
- 清除 Red Hat Process Automation Manager 中默认数据库表的日志,而不丢失进程变量数据
此流程只适用于进程变量。此流程不适用于问题单变量。
先决条件
- 您已在 Red Hat Process Automation Manager 中定义了要实施变量的进程。
- 如果要在 Red Hat Process Automation Manager 之外的数据库模式中保留变量,则已创建了数据源以及您要使用的独立数据库模式。有关创建数据源的详情,请参考 配置 Business Central 设置和属性。
流程
在用作进程变量的数据对象文件中,添加以下元素来配置变量持久性:
为变量持久性配置的 Person.java 对象示例
@javax.persistence.Entity 1 @javax.persistence.Table(name = "Person") 2 public class Person extends org.drools.persistence.jpa.marshaller.VariableEntity 3 implements java.io.Serializable { 4 static final long serialVersionUID = 1L; @javax.persistence.GeneratedValue(strategy = javax.persistence.GenerationType.AUTO, generator = "PERSON_ID_GENERATOR") @javax.persistence.Id 5 @javax.persistence.SequenceGenerator(name = "PERSON_ID_GENERATOR", sequenceName = "PERSON_ID_SEQ") private java.lang.Long id; private java.lang.String name; private java.lang.Integer age; public Person() { } public java.lang.Long getId() { return this.id; } public void setId(java.lang.Long id) { this.id = id; } public java.lang.String getName() { return this.name; } public void setName(java.lang.String name) { this.name = name; } public java.lang.Integer getAge() { return this.age; } public void setAge(java.lang.Integer age) { this.age = age; } public Person(java.lang.Long id, java.lang.String name, java.lang.Integer age) { this.id = id; this.name = name; this.age = age; } }
要使数据对象持久使用 Business Central,进入项目中的数据对象文件,点窗口右上角的 Persistence 图标,并配置持久性行为:
图 18.1. Business Central 中的持久性配置
在项目的
pom.xml
文件中,添加以下持久性支持依赖项。此依赖项包含您在数据对象中配置的变量
类。项目持久性依赖项
<dependency> <groupId>org.drools</groupId> <artifactId>drools-persistence-jpa</artifactId> <version>${rhpam.version}</version> <scope>provided</scope> </dependency>
在项目的
~/META-INF/kie-deployment-descriptor.xml
文件中,配置 JPA marshalling 策略和持久性单元,以用于 marshaller。对于定义为实体的对象,需要 JPA marshalling 策略和持久性单元。在 kie-deployment-descriptor.xml 文件中配置的 JPA marshaller 和 persistence 单元
<marshalling-strategy> <resolver>mvel</resolver> <identifier>new org.drools.persistence.jpa.marshaller.JPAPlaceholderResolverStrategy("myPersistenceUnit", classLoader)</identifier> <parameters/> </marshalling-strategy>
在项目的
~/META-INF
目录中,创建一个persistence.xml
文件,用于指定您要保留进程变量的数据源:带有数据源配置的 persistence.xml 文件示例
<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:orm="http://java.sun.com/xml/ns/persistence/orm" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.0" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"> <persistence-unit name="myPersistenceUnit" transaction-type="JTA"> <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider> <jta-data-source>java:jboss/datasources/ExampleDS</jta-data-source> 1 <class>org.space.example.Person</class> <exclude-unlisted-classes>true</exclude-unlisted-classes> <properties> <property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQLDialect"/> <property name="hibernate.max_fetch_depth" value="3"/> <property name="hibernate.hbm2ddl.auto" value="update"/> <property name="hibernate.show_sql" value="true"/> <property name="hibernate.id.new_generator_mappings" value="false"/> <property name="hibernate.transaction.jta.platform" value="org.hibernate.service.jta.platform.internal.JBossAppServerJtaPlatform"/> </properties> </persistence-unit> </persistence>
- 1
- 设置保留进程变量的数据源
要使用 Business Central 配置 marshalling 策略、持久性单元和数据源,请导航到 Project Settings → Deployments → Marshalling Policies and to project Settings → Persistence :
图 18.2. Business Central 中的 JPA marshaller 配置
图 18.3. Business Central 中的持久性单元和数据源配置
第 19 章 定义 LDAP 登录域
当您将 Red Hat Process Automation Manager 设置为使用 LDAP 进行身份验证和授权时,请定义 LDAP 登录域,因为 Git SSH 身份验证可能使用另一个安全域。
要定义 LDAP 登录域,请使用 org.uberfire.domain
系统属性。例如,在 Red Hat JBoss Enterprise Application Platform 中,在 standalone.xml
文件中添加此属性,如下所示:
<system-properties> <!-- other system properties --> <property name="org.uberfire.domain" value="LDAPAuth"/> </system-properties>
确保经过身份验证的用户在 LDAP 中具有与其关联的适当角色(管理员
、技术、审查
器)。
第 20 章 通过 RH-SSO 验证第三方客户端
要使用 Business Central 或 KIE 服务器提供的不同远程服务,您的客户端(如 curl、wget、Web 浏览器或自定义 REST 客户端)必须通过 RH-SSO 服务器进行身份验证,并具有有效令牌来执行请求。要使用远程服务,经过身份验证的用户必须具有以下角色:
-
rest-all
用于使用 Business Central 远程服务。 -
使用 KIE 服务器远程服务的
kie-server
。
使用 RH-SSO 管理控制台创建这些角色,并将它们分配到将使用远程服务的用户。
您的客户端可以使用以下选项之一通过 RH-SSO 进行身份验证:
- 基本身份验证(如果客户端支持)
- 基于令牌的验证
20.1. 基本身份验证(Basic authentication)
如果您在为 Business Central 和 KIE 服务器的 RH-SSO 客户端适配器配置中启用了基本身份验证,您可以避免令牌授权和刷新调用并调用服务,如下例所示:
对于基于 Web 的远程存储库端点:
curl http://admin:password@localhost:8080/business-central/rest/repositories
对于 KIE 服务器:
curl http://admin:password@localhost:8080/kie-server/services/rest/server/
第 21 章 KIE 服务器系统属性
KIE 服务器接受以下系统属性(引导交换机)来配置服务器的行为:
属性 | 值 | 默认 | 描述 |
---|---|---|---|
|
|
|
如果设置为 |
|
|
|
如果设置为 |
|
|
|
如果设置为 |
|
|
|
如果设置为 |
|
|
|
如果设置为 |
|
|
|
如果设置为 |
|
|
|
如果设置为 |
|
|
|
如果设置为 |
|
|
|
如果设置为 |
下表中列出的一些 Process Automation Manager 控制器属性被标记为必需。在 Business Central 中创建或删除 KIE 服务器容器时,设置这些属性。如果您在没有与 Business Central 交互的情况下单独使用 KIE 服务器,则不需要设置所需的属性。
属性 | 值 | 默认 | 描述 |
---|---|---|---|
| 字符串 | N/A | 要分配给服务器的任意 ID。如果在 Business Central 外部配置了无头进程自动化管理器控制器,这是服务器连接到无头进程自动化管理器控制器的 ID,以获取 KIE 容器配置。如果没有提供,则会自动生成 ID。 |
| 字符串 |
| 在以受管模式运行时,从 Process Automation Manager 控制器与 KIE 服务器连接的用户名需要。在 Business Central 系统属性中设置此属性。在使用 Process Automation Manager 控制器时设置此属性。 |
| 字符串 |
| 在以受管模式运行时,从 Process Automation Manager 控制器连接到 KIE 服务器的密码。在 Business Central 系统属性中设置此属性。在使用 Process Automation Manager 控制器时设置此属性。 |
| 字符串 | 不适用 | 一个属性,允许您在 Process Automation Manager 控制器和 KIE 服务器间使用基于令牌的身份验证,而不是基本用户名和密码身份验证。Process Automation Manager 控制器将令牌作为请求标头中的参数发送。服务器需要长期访问令牌,因为令牌不会被刷新。 |
| URL | N/A |
Process Automation Manager 控制器用来在这个服务器上调用的 KIE 服务器实例的 URL,例如 |
| 以逗号分隔的列表 | N/A |
Process Automation Manager 控制器 REST 端点的以逗号分隔的 URL 列表,例如 |
| 字符串 |
| 连接到 Process Automation Manager 控制器 REST API 的用户名。使用 Process Automation Manager 控制器时需要设置此属性。 |
| 字符串 |
| 连接到 Process Automation Manager 控制器 REST API 的密码。使用 Process Automation Manager 控制器时需要设置此属性。 |
| 字符串 | 不适用 | 一个属性,允许您在 KIE 服务器和 Process Automation Manager 控制器之间使用基于令牌的身份验证,而不是基本用户名和密码身份验证。服务器在请求标头中将令牌作为参数发送。服务器需要长期访问令牌,因为令牌不会被刷新。 |
| Long |
| 服务器启动时,重复尝试将 KIE 服务器连接到 Process Automation Manager 控制器之间的等待时间(毫秒)。 |
属性 | 值 | 默认 | 描述 |
---|---|---|---|
| 字符串 | N/A | 数据源 JNDI 名称。在启用 BPM 支持时设置此属性。 |
| 字符串 | N/A | Hibernate 属性的事务管理器平台。在启用 BPM 支持时设置此属性。 |
| 字符串 | N/A | 要使用的 Hibernate dialect。在启用 BPM 支持时设置此属性。 |
| 字符串 | N/A | 要使用的数据库架构。 |
属性 | 值 | 默认 | 描述 |
---|---|---|---|
| 整数 |
|
Red Hat Process Automation Manager executor 完成某个作业的时间,并在 |
|
|
|
指定 |
| 整数 |
| Red Hat Process Automation Manager executor 使用的线程数量。 |
| 整数 |
| 在失败的作业中重试 Red Hat Process Automation Manager executor 尝试重试的次数。 |
| 字符串 |
| KIE 服务器的作业执行 JMS 队列。 |
|
|
|
如果设置为 |
属性 | 值 | 默认 | 描述 |
---|---|---|---|
|
|
| 指定要使用的用户组回调实现的属性:
|
| 完全限定名称 | N/A |
在将 |
|
|
| 启用任务清理任务监听程序,以在进程实例完成后删除任务。 |
|
|
| 启用任务 BAM 模块来存储与任务相关的信息。 |
| 字符串 |
| 可以从 KIE 服务器访问所有任务的用户。 |
| 字符串 |
| 用户必须属于的组才能查看 KIE 服务器中的所有任务。 |
属性 | 值 | 默认 | 描述 |
---|---|---|---|
| URL | N/A |
URL 用于加载 Java Cryptography Extension KeyStore (JCEKS)。例如, |
| 字符串 | N/A | 密码用于 JCEKS。 |
| 字符串 | N/A | 保存密码的 REST 服务的密钥别名名称。 |
| 字符串 | N/A | REST 服务的别名密码。 |
| 字符串 | N/A | 默认 REST Process Automation Manager 控制器的密钥别名。 |
| 字符串 | N/A | 默认 REST Process Automation Manager 控制器的别名密码。 |
属性 | 值 | 默认 | 描述 |
---|---|---|---|
| 整数 | 5 | 此属性描述了进程引擎在永久失败前重试事务的次数。 |
| 整数 | 50 | 第一次重试前的延迟时间,以毫秒为单位。 |
| 整数 | 4 | 增加后续重试的延迟时间的倍数。使用默认值时,进程引擎会在第一次重试前等待 50 毫秒,在第二个重试前等待 200 毫秒,在第三个重试前的 800 毫秒等。 |
属性 | 值 | 默认 | 描述 |
---|---|---|---|
| 路径 | N/A |
Maven 配置的自定义 |
| 字符串 |
| JMS 的响应队列 JNDI 名称。 |
|
|
|
当设置为 |
|
|
| 允许您绕过经过身份验证的用户以获取与任务相关的操作的属性,如查询。 |
| 整数 |
| 此属性指定执行的最大规则数量,以避免规则在无限循环中运行,并使服务器完全无响应。 |
|
|
| 此属性关闭 EJB Timers 本地缓存。 |
| 字符串 | N/A |
使用 JMS 时用于验证用户的 JAAS |
| 路径 |
| KIE 服务器状态文件的位置。 |
|
|
| 指示 KIE 服务器存放部署的属性,直到 Process Automation Manager 控制器提供容器部署配置。此属性仅影响在受管模式下运行的服务器。可用的选项如下:
ACTIVE |
|
|
| KIE 服务器的启动策略,用于控制部署的 KIE 容器以及它们部署的顺序。 |
|
|
|
当设置为 |
|
Java 软件包,如 | N/A | 指定使用 XStream 进行 marshalling 的允许列表的额外软件包的属性。 |
| 字符串 |
|
实施 |
|
|
|
在使用 JSON marshalling 时,如果属性设为 |
|
|
|
当此属性的值设置为 |
第 22 章 KIE 服务器功能和扩展
KIE 服务器中的功能由插件扩展来决定,您可以启用、禁用或进一步扩展以满足您的业务需求。KIE 服务器支持以下默认功能和扩展:
功能名称 | 扩展名称 | 描述 |
---|---|---|
|
| 提供 KIE 服务器的核心功能,如在服务器实例中创建并分离 KIE 容器 |
|
| 提供业务逻辑管理(BRM)功能,如插入事实和执行新规则 |
|
| 提供 Business Process Management (DSL)功能,如管理用户任务和执行流程 |
|
| 提供额外的用户界面功能,如在进程图中呈现 XML 表单和 SVG 镜像 |
|
| 为业务流程提供问题单管理功能,如管理问题单定义和里程 |
|
| 提供业务资源规划(BRP)功能,如实施解析器 |
|
| 提供决策模型和表示法(DMN)功能,如管理 DMN 数据类型和执行 DMN 模型 |
|
| 提供用于与 KIE Server REST API 交互的 Swagger web-interface 功能 |
要查看正在运行的 KIE 服务器实例支持的扩展,请将 GET
请求发送到以下 REST API 端点,并查看 XML 或 JSON 服务器响应:
KIE 服务器信息 GET 请求的基本 URL
http://SERVER:PORT/kie-server/services/rest/server
带有 KIE 服务器信息的 JSON 响应示例
{ "type": "SUCCESS", "msg": "Kie Server info", "result": { "kie-server-info": { "id": "test-kie-server", "version": "7.52.0.20190818-050814", "name": "test-kie-server", "location": "http://localhost:8080/kie-server/services/rest/server", "capabilities": [ "KieServer", "BRM", "BPM", "CaseMgmt", "BPM-UI", "BRP", "DMN", "Swagger" ], "messages": [ { "severity": "INFO", "timestamp": { "java.util.Date": 1566169865791 }, "content": [ "Server KieServerInfo{serverId='test-kie-server', version='7.52.0.20190818-050814', name='test-kie-server', location='http:/localhost:8080/kie-server/services/rest/server', capabilities=[KieServer, BRM, BPM, CaseMgmt, BPM-UI, BRP, DMN, Swagger]', messages=null', mode=DEVELOPMENT}started successfully at Sun Aug 18 23:11:05 UTC 2019" ] } ], "mode": "DEVELOPMENT" } } }
要启用或禁用 KIE 服务器扩展,请配置相关的 192.168.1.0/24 server.ext.disabled
KIE Server 系统属性。例如,要禁用 BRM
功能,请设置系统属性 org.drools.server.ext.disabled=true
。有关所有 KIE 服务器系统属性,请参阅 第 21 章 KIE 服务器系统属性。
默认情况下,KIE 服务器扩展通过 REST 或 JMS 数据传输公开,并使用预定义的客户端 API。您可以使用额外的 REST 端点扩展现有 KIE 服务器功能,扩展 REST 或 JMS 以外的支持的传输方法,或者在 KIE Server 客户端中扩展功能。
KIE 服务器功能中的这种灵活性可让您将 KIE 服务器实例适应您的业务需求,而不是将您的业务需求适应默认的 KIE 服务器功能。
如果您扩展了 KIE 服务器功能,红帽不支持用作自定义实现和扩展的自定义代码。
22.1. 使用自定义 REST API 端点扩展现有 KIE 服务器功能
KIE Server REST API 可让您在不使用 Business Central 用户界面的情况下与 Red Hat Process Automation Manager 中的 KIE 容器和业务资产交互。可用的 REST 端点由 KIE 服务器系统属性中启用的功能(例如: org.drools.server.ext.disabled=false
用于 BRM
功能)。您可以使用自定义 REST API 端点扩展现有 KIE 服务器功能,以进一步将 KIE Server REST API 适应您的业务需求。
例如,这个流程使用以下自定义 REST API 端点扩展了 dros KIE Server 扩展(用于 BRM
功能):
自定义 REST API 端点示例
/server/containers/instances/{containerId}/ksession/{ksessionId}
这个示例自定义端点接受要插入到决策引擎工作内存的事实列表,自动执行所有规则,并从指定 KIE 容器中的 KIE 会话检索所有对象。
流程
创建一个空的 Maven 项目,并在项目的
pom.xml
文件中定义以下打包类型和依赖项:示例项目中的 pom.xml 文件示例
<packaging>jar</packaging> <properties> <version.org.kie>7.52.0.Final-redhat-00007</version.org.kie> </properties> <dependencies> <dependency> <groupId>org.kie</groupId> <artifactId>kie-api</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie</groupId> <artifactId>kie-internal</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-api</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-services-common</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-services-drools</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-rest-common</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.drools</groupId> <artifactId>drools-core</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.drools</groupId> <artifactId>drools-compiler</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.25</version> </dependency> </dependencies>
在项目中的 Java 类中实施
org.kie.server.services.api.KieServerApplicationComponentsService
接口,如下例所示:KieServerApplicationComponentsService
接口的实现示例public class CusomtDroolsKieServerApplicationComponentsService implements KieServerApplicationComponentsService { 1 private static final String OWNER_EXTENSION = "Drools"; 2 public Collection<Object> getAppComponents(String extension, SupportedTransports type, Object... services) { 3 // Do not accept calls from extensions other than the owner extension: if ( !OWNER_EXTENSION.equals(extension) ) { return Collections.emptyList(); } RulesExecutionService rulesExecutionService = null; 4 KieServerRegistry context = null; for( Object object : services ) { if( RulesExecutionService.class.isAssignableFrom(object.getClass()) ) { rulesExecutionService = (RulesExecutionService) object; continue; } else if( KieServerRegistry.class.isAssignableFrom(object.getClass()) ) { context = (KieServerRegistry) object; continue; } } List<Object> components = new ArrayList<Object>(1); if( SupportedTransports.REST.equals(type) ) { components.add(new CustomResource(rulesExecutionService, context)); 5 } return components; } }
- 1
- 为应用启动时部署的 KIE 服务器基础架构提供 REST 端点。
- 2
- 指定您要扩展的扩展,如本例中的 d
ro
al 扩展。 - 3
- 返回 REST 容器必须部署的所有资源。KIE 服务器实例中启用的每个扩展都会调用
getAppComponents
方法,因此if (!OWNER_EXTENSION.equals (extension)
调用返回空集合,用于指定OWNER_EXTENSION
扩展以外的任何扩展。 - 4
- 列出您要使用的指定扩展中的服务,如本例中的 lvs 扩展中的
RulesExecutionService
和KieServerRegistry
服务。 - 5
- 指定扩展的传输类型,可以是
REST
或JMS
(本例中为REST
),以及作为组件列表返回资源的CustomResource
类。
实现 KIE 服务器可以用来为新 REST 资源提供额外的功能的
CustomResource
类,如下例所示:CustomResource
类的实现示例// Custom base endpoint: @Path("server/containers/instances/{containerId}/ksession") public class CustomResource { private static final Logger logger = LoggerFactory.getLogger(CustomResource.class); private KieCommands commandsFactory = KieServices.Factory.get().getCommands(); private RulesExecutionService rulesExecutionService; private KieServerRegistry registry; public CustomResource() { } public CustomResource(RulesExecutionService rulesExecutionService, KieServerRegistry registry) { this.rulesExecutionService = rulesExecutionService; this.registry = registry; } // Supported HTTP method, path parameters, and data formats: @POST @Path("/{ksessionId}") @Consumes({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON}) public Response insertFireReturn(@Context HttpHeaders headers, @PathParam("containerId") String id, @PathParam("ksessionId") String ksessionId, String cmdPayload) { Variant v = getVariant(headers); String contentType = getContentType(headers); // Marshalling behavior and supported actions: MarshallingFormat format = MarshallingFormat.fromType(contentType); if (format == null) { format = MarshallingFormat.valueOf(contentType); } try { KieContainerInstance kci = registry.getContainer(id); Marshaller marshaller = kci.getMarshaller(format); List<?> listOfFacts = marshaller.unmarshall(cmdPayload, List.class); List<Command<?>> commands = new ArrayList<Command<?>>(); BatchExecutionCommand executionCommand = commandsFactory.newBatchExecution(commands, ksessionId); for (Object fact : listOfFacts) { commands.add(commandsFactory.newInsert(fact, fact.toString())); } commands.add(commandsFactory.newFireAllRules()); commands.add(commandsFactory.newGetObjects()); ExecutionResults results = rulesExecutionService.call(kci, executionCommand); String result = marshaller.marshall(results); logger.debug("Returning OK response with content '{}'", result); return createResponse(result, v, Response.Status.OK); } catch (Exception e) { // If marshalling fails, return the `call-container` response to maintain backward compatibility: String response = "Execution failed with error : " + e.getMessage(); logger.debug("Returning Failure response with content '{}'", response); return createResponse(response, v, Response.Status.INTERNAL_SERVER_ERROR); } } }
在本例中,自定义端点的
CustomResource
类指定以下数据和行为:-
使用基本端点
server/containers/instances/{containerId}/ksession
-
使用
POST
HTTP 方法 预期在 REST 请求中给出以下数据:
-
containerId
作为路径参数 -
ksessionId
作为路径参数 - 作为消息有效负载的事实列表
-
支持所有 KIE 服务器数据格式:
- XML (SPICEB、XStream)
- JSON
-
将有效负载解压缩到
List<?>
集合中,对于列表中的每个项目,创建一个InsertCommand
实例,后跟FireAllRules
和GetObject
命令。 -
将所有命令添加到调用决策引擎的
BatchExecutionCommand
实例中。
-
使用基本端点
-
要使 KIE 服务器可以发现新的端点,请在 Maven 项目中创建一个
META-INF/services/org.kie.server.services.api.KieServerApplicationComponentsService
文件,并在文件中添加KieServerApplicationComponentsService
实现类的完全限定类名称。在本例中,文件包含一行org.kie.server.ext.drools.rest.CusomtDroolsKieServerApplicationComponentsService
。 -
构建您的项目,并将生成的 JAR 文件复制到项目的
~/kie-server.war/WEB-INF/lib
目录中。例如,在 Red Hat JBoss EAP 上,此目录的路径是EAP_HOME/standalone/deployments/kie-server.war/WEB-INF/lib
。 启动 KIE 服务器,并将构建的项目部署到正在运行的 KIE 服务器中。您可以使用 Business Central 接口或 KIE Server REST API (
PUT
请求http://SERVER:PORT/kie-server/services/rest/server/containers/{containerId}
)来部署项目。在项目部署到正在运行的 KIE 服务器上后,您可以开始与您的新 REST 端点交互。
在本例中,您可以使用以下信息来调用新端点:
-
请求 URL 示例:
http://localhost:8080/kie-server/services/rest/server/containers/instances/demo/ksession/defaultKieSession
-
HTTP 方法:
POST
HTTP 标头:
-
content-Type: application/json
-
接受:application/json
-
消息有效负载示例:
[ { "org.jbpm.test.Person": { "name": "john", "age": 25 } }, { "org.jbpm.test.Person": { "name": "mary", "age": 22 } } ]
-
服务器响应示例:
200
(成功) 服务器日志输出示例:
13:37:20,347 INFO [stdout] (default task-24) Hello mary 13:37:20,348 INFO [stdout] (default task-24) Hello john
-
请求 URL 示例:
22.2. 扩展 KIE 服务器以使用自定义数据传输
默认情况下,KIE 服务器扩展通过 REST 或 JMS 数据传输公开。您可以扩展 KIE 服务器,以支持自定义数据传输,以符合您的业务需求。
例如,这个流程向 KIE 服务器添加自定义数据传输,它使用 do ls
扩展,且基于 Apache MINA,它是一个开源 Java 网络应用程序框架。自定义 MINA 传输交换基于字符串的数据,它们依赖于现有的 marshalling 操作并只支持 JSON 格式。
流程
创建一个空的 Maven 项目,并在项目的
pom.xml
文件中定义以下打包类型和依赖项:示例项目中的 pom.xml 文件示例
<packaging>jar</packaging> <properties> <version.org.kie>7.52.0.Final-redhat-00007</version.org.kie> </properties> <dependencies> <dependency> <groupId>org.kie</groupId> <artifactId>kie-api</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie</groupId> <artifactId>kie-internal</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-api</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-services-common</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-services-drools</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.drools</groupId> <artifactId>drools-core</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.drools</groupId> <artifactId>drools-compiler</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.25</version> </dependency> <dependency> <groupId>org.apache.mina</groupId> <artifactId>mina-core</artifactId> <version>2.1.3</version> </dependency> </dependencies>
在项目中的 Java 类中实施
org.kie.server.services.api.KieServerExtension
接口,如下例所示:KieServerExtension
接口的实现示例public class MinaDroolsKieServerExtension implements KieServerExtension { private static final Logger logger = LoggerFactory.getLogger(MinaDroolsKieServerExtension.class); public static final String EXTENSION_NAME = "Drools-Mina"; private static final Boolean disabled = Boolean.parseBoolean(System.getProperty("org.kie.server.drools-mina.ext.disabled", "false")); private static final String MINA_HOST = System.getProperty("org.kie.server.drools-mina.ext.port", "localhost"); private static final int MINA_PORT = Integer.parseInt(System.getProperty("org.kie.server.drools-mina.ext.port", "9123")); // Taken from dependency on the `Drools` extension: private KieContainerCommandService batchCommandService; // Specific to MINA: private IoAcceptor acceptor; public boolean isActive() { return disabled == false; } public void init(KieServerImpl kieServer, KieServerRegistry registry) { KieServerExtension droolsExtension = registry.getServerExtension("Drools"); if (droolsExtension == null) { logger.warn("No Drools extension available, quitting..."); return; } List<Object> droolsServices = droolsExtension.getServices(); for( Object object : droolsServices ) { // If the given service is null (not configured), continue to the next service: if (object == null) { continue; } if( KieContainerCommandService.class.isAssignableFrom(object.getClass()) ) { batchCommandService = (KieContainerCommandService) object; continue; } } if (batchCommandService != null) { acceptor = new NioSocketAcceptor(); acceptor.getFilterChain().addLast( "codec", new ProtocolCodecFilter( new TextLineCodecFactory( Charset.forName( "UTF-8" )))); acceptor.setHandler( new TextBasedIoHandlerAdapter(batchCommandService) ); acceptor.getSessionConfig().setReadBufferSize( 2048 ); acceptor.getSessionConfig().setIdleTime( IdleStatus.BOTH_IDLE, 10 ); try { acceptor.bind( new InetSocketAddress(MINA_HOST, MINA_PORT) ); logger.info("{} -- Mina server started at {} and port {}", toString(), MINA_HOST, MINA_PORT); } catch (IOException e) { logger.error("Unable to start Mina acceptor due to {}", e.getMessage(), e); } } } public void destroy(KieServerImpl kieServer, KieServerRegistry registry) { if (acceptor != null) { acceptor.dispose(); acceptor = null; } logger.info("{} -- Mina server stopped", toString()); } public void createContainer(String id, KieContainerInstance kieContainerInstance, Map<String, Object> parameters) { // Empty, already handled by the `Drools` extension } public void disposeContainer(String id, KieContainerInstance kieContainerInstance, Map<String, Object> parameters) { // Empty, already handled by the `Drools` extension } public List<Object> getAppComponents(SupportedTransports type) { // Nothing for supported transports (REST or JMS) return Collections.emptyList(); } public <T> T getAppComponents(Class<T> serviceType) { return null; } public String getImplementedCapability() { return "BRM-Mina"; } public List<Object> getServices() { return Collections.emptyList(); } public String getExtensionName() { return EXTENSION_NAME; } public Integer getStartOrder() { return 20; } @Override public String toString() { return EXTENSION_NAME + " KIE Server extension"; } }
KieServerExtension
接口是 KIE 服务器可用于为新的 MINA 传输提供额外的功能的主要扩展接口。接口由以下组件组成:KieServerExtension
接口概述public interface KieServerExtension { boolean isActive(); void init(KieServerImpl kieServer, KieServerRegistry registry); void destroy(KieServerImpl kieServer, KieServerRegistry registry); void createContainer(String id, KieContainerInstance kieContainerInstance, Map<String, Object> parameters); void disposeContainer(String id, KieContainerInstance kieContainerInstance, Map<String, Object> parameters); List<Object> getAppComponents(SupportedTransports type); <T> T getAppComponents(Class<T> serviceType); String getImplementedCapability(); 1 List<Object> getServices(); String getExtensionName(); 2 Integer getStartOrder(); 3 }
在之前的
Mina
示例实现中,Drools
KieServerExtensioninit
方法是从 dol 扩展收集服务的主要元素,用于引导 MINA 服务器。KieServerExtension
接口中的所有其他方法都可以与标准实施保持下来,以满足接口要求。TextBasedIoHandlerAdapter
类是在 MINA 服务器上响应传入请求的处理程序。为 MINA 服务器实现
TextBasedIoHandlerAdapter
处理程序,如下例所示:TextBasedIoHandlerAdapter
处理程序实现示例public class TextBasedIoHandlerAdapter extends IoHandlerAdapter { private static final Logger logger = LoggerFactory.getLogger(TextBasedIoHandlerAdapter.class); private KieContainerCommandService batchCommandService; public TextBasedIoHandlerAdapter(KieContainerCommandService batchCommandService) { this.batchCommandService = batchCommandService; } @Override public void messageReceived( IoSession session, Object message ) throws Exception { String completeMessage = message.toString(); logger.debug("Received message '{}'", completeMessage); if( completeMessage.trim().equalsIgnoreCase("quit") || completeMessage.trim().equalsIgnoreCase("exit") ) { session.close(false); return; } String[] elements = completeMessage.split("\\|"); logger.debug("Container id {}", elements[0]); try { ServiceResponse<String> result = batchCommandService.callContainer(elements[0], elements[1], MarshallingFormat.JSON, null); if (result.getType().equals(ServiceResponse.ResponseType.SUCCESS)) { session.write(result.getResult()); logger.debug("Successful message written with content '{}'", result.getResult()); } else { session.write(result.getMsg()); logger.debug("Failure message written with content '{}'", result.getMsg()); } } catch (Exception e) { } } }
在本例中,处理器类接收文本消息并在 drools 服务中
执行它们
。使用
TextBasedIoHandlerAdapter
处理程序实现时,请考虑以下处理程序要求和行为:- 您提交到处理器的任何内容都必须是一个行,因为每个传入的传输请求都是一行。
-
您必须在此一行中传递 KIE 容器 ID,以便处理程序需要
containerID|payload
格式。 - 您可以按照 marshaller 生成的方式设置响应。响应可以是多行。
-
处理程序支持 流模式,允许您在不断开 KIE Server 会话的情况下发送命令。要以流模式结束 KIE 服务器会话,请将
退出
或退出
命令发送到服务器。
-
要使 KIE 服务器可以发现新的数据传输,请在 Maven 项目中创建一个
META-INF/services/org.kie.server.services.api.KieServerExtension
文件,并在文件中添加KieServerExtension
实现类的完全限定域名。在本例中,文件包含一行org.kie.server.ext.mina.MinaDroolsKieServerExtension
。 -
构建您的项目并将生成的 JAR 文件和
mina-core-2.0.9.jar
文件复制到项目的~/kie-server.war/WEB-INF/lib
目录中。例如,在 Red Hat JBoss EAP 上,此目录的路径是EAP_HOME/standalone/deployments/kie-server.war/WEB-INF/lib
。 启动 KIE 服务器,并将构建的项目部署到正在运行的 KIE 服务器中。您可以使用 Business Central 接口或 KIE Server REST API (
PUT
请求http://SERVER:PORT/kie-server/services/rest/server/containers/{containerId}
)来部署项目。在项目部署到正在运行的 KIE 服务器上后,您可以在 KIE 服务器日志中查看新数据传输的状态,并开始使用您的新数据传输:
服务器日志中的新数据传输
Drools-Mina KIE Server extension -- Mina server started at localhost and port 9123 Drools-Mina KIE Server extension has been successfully registered as server extension
在本例中,您可以使用 Telnet 与 KIE 服务器中基于 MINA 的数据传输进行交互:
启动 Telnet 并在命令终端中连接到端口 9123 上的 KIE 服务器
telnet 127.0.0.1 9123
在命令终端中与 KIE 服务器交互示例
Trying 127.0.0.1... Connected to localhost. Escape character is '^]'. # Request body: demo|{"lookup":"defaultKieSession","commands":[{"insert":{"object":{"org.jbpm.test.Person":{"name":"john","age":25}}}},{"fire-all-rules":""}]} # Server response: { "results" : [ { "key" : "", "value" : 1 } ], "facts" : [ ] } demo|{"lookup":"defaultKieSession","commands":[{"insert":{"object":{"org.jbpm.test.Person":{"name":"mary","age":22}}}},{"fire-all-rules":""}]} { "results" : [ { "key" : "", "value" : 1 } ], "facts" : [ ] } demo|{"lookup":"defaultKieSession","commands":[{"insert":{"object":{"org.jbpm.test.Person":{"name":"james","age":25}}}},{"fire-all-rules":""}]} { "results" : [ { "key" : "", "value" : 1 } ], "facts" : [ ] } exit Connection closed by foreign host.
服务器日志输出示例
16:33:40,206 INFO [stdout] (NioProcessor-2) Hello john 16:34:03,877 INFO [stdout] (NioProcessor-2) Hello mary 16:34:19,800 INFO [stdout] (NioProcessor-2) Hello james
22.3. 使用自定义客户端 API 扩展 KIE Server 客户端
KIE 服务器使用预定义的客户端 API,您可以与之交互来使用 KIE 服务器服务。您可以使用自定义客户端 API 扩展 KIE 服务器客户端,以符合您的业务需求。
例如,这个流程向 KIE 服务器添加一个自定义客户端 API,以适应基于 Apache MINA 的开源 Java 网络应用程序框架的自定义数据传输(以前配置为这种情况)。
流程
创建一个空的 Maven 项目,并在项目的
pom.xml
文件中定义以下打包类型和依赖项:示例项目中的 pom.xml 文件示例
<packaging>jar</packaging> <properties> <version.org.kie>7.52.0.Final-redhat-00007</version.org.kie> </properties> <dependencies> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-api</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.kie.server</groupId> <artifactId>kie-server-client</artifactId> <version>${version.org.kie}</version> </dependency> <dependency> <groupId>org.drools</groupId> <artifactId>drools-compiler</artifactId> <version>${version.org.kie}</version> </dependency> </dependencies>
在项目中的 Java 类中实施相关的
ServicesClient
接口,如下例所示:RulesMinaServicesClient
接口示例public interface RulesMinaServicesClient extends RuleServicesClient { }
需要一个特定的接口,因为您必须根据接口注册客户端实施,并且只能为给定接口有一个实施。
在本例中,基于 MINA 的数据传输使用 dols 扩展,因此这个示例
RulesMinaServicesClient
接口从 dol 扩展中扩展现有的RuleServicesClient
客户端 API。实现 KIE 服务器可以用来为新 MINA 传输提供额外的客户端功能,如下例所示:
RulesMinaServicesClient
接口的实现示例public class RulesMinaServicesClientImpl implements RulesMinaServicesClient { private String host; private Integer port; private Marshaller marshaller; public RulesMinaServicesClientImpl(KieServicesConfiguration configuration, ClassLoader classloader) { String[] serverDetails = configuration.getServerUrl().split(":"); this.host = serverDetails[0]; this.port = Integer.parseInt(serverDetails[1]); this.marshaller = MarshallerFactory.getMarshaller(configuration.getExtraJaxbClasses(), MarshallingFormat.JSON, classloader); } public ServiceResponse<String> executeCommands(String id, String payload) { try { String response = sendReceive(id, payload); if (response.startsWith("{")) { return new ServiceResponse<String>(ResponseType.SUCCESS, null, response); } else { return new ServiceResponse<String>(ResponseType.FAILURE, response); } } catch (Exception e) { throw new KieServicesException("Unable to send request to KIE Server", e); } } public ServiceResponse<String> executeCommands(String id, Command<?> cmd) { try { String response = sendReceive(id, marshaller.marshall(cmd)); if (response.startsWith("{")) { return new ServiceResponse<String>(ResponseType.SUCCESS, null, response); } else { return new ServiceResponse<String>(ResponseType.FAILURE, response); } } catch (Exception e) { throw new KieServicesException("Unable to send request to KIE Server", e); } } protected String sendReceive(String containerId, String content) throws Exception { // Flatten the content to be single line: content = content.replaceAll("\\n", ""); Socket minaSocket = null; PrintWriter out = null; BufferedReader in = null; StringBuffer data = new StringBuffer(); try { minaSocket = new Socket(host, port); out = new PrintWriter(minaSocket.getOutputStream(), true); in = new BufferedReader(new InputStreamReader(minaSocket.getInputStream())); // Prepare and send data: out.println(containerId + "|" + content); // Wait for the first line: data.append(in.readLine()); // Continue as long as data is available: while (in.ready()) { data.append(in.readLine()); } return data.toString(); } finally { out.close(); in.close(); minaSocket.close(); } } }
这个示例实现指定以下数据和行为:
- 使用基于套接字的通信以简单起见
-
依赖于 KIE 服务器客户端的默认配置,并使用
ServerUrl
提供 MINA 服务器的主机和端口 - 指定 JSON 作为 marshalling 格式
-
需要收到的消息是以 open bracket
{
开头的 JSON 对象 - 在等待响应的第一行时,使用直接套接字与阻塞 API 通信,然后读取所有可用的行
- 不要使用 流模式,因此在调用命令后断开 KIE 服务器会话
在项目中的 Java 类中实施
org.kie.server.client.helper.KieServicesClientBuilder
接口,如下例所示:KieServicesClientBuilder
接口的实现示例public class MinaClientBuilderImpl implements KieServicesClientBuilder { 1 public String getImplementedCapability() { 2 return "BRM-Mina"; } public Map<Class<?>, Object> build(KieServicesConfiguration configuration, ClassLoader classLoader) { 3 Map<Class<?>, Object> services = new HashMap<Class<?>, Object>(); services.put(RulesMinaServicesClient.class, new RulesMinaServicesClientImpl(configuration, classLoader)); return services; } }
-
要使新客户端 API 可发现 KIE 服务器客户端,请在 Maven 项目中创建一个
META-INF/services/org.kie.server.client.helper.KieServicesClientBuilder
文件,并在文件中添加KieServicesClientBuilder
实现类的完全限定类。在本例中,文件包含一行org.kie.server.ext.mina.client.MinaClientBuilderImpl
。 -
构建您的项目,并将生成的 JAR 文件复制到项目的
~/kie-server.war/WEB-INF/lib
目录中。例如,在 Red Hat JBoss EAP 上,此目录的路径是EAP_HOME/standalone/deployments/kie-server.war/WEB-INF/lib
。 启动 KIE 服务器,并将构建的项目部署到正在运行的 KIE 服务器中。您可以使用 Business Central 接口或 KIE Server REST API (
PUT
请求http://SERVER:PORT/kie-server/services/rest/server/containers/{containerId}
)来部署项目。在项目部署到正在运行的 KIE 服务器上后,您可以开始与新的 KIE Server 客户端交互。您可以通过创建客户端配置和客户端实例、根据类型检索服务客户端并调用客户端方法,以与标准 KIE 服务器客户端相同的方式使用您的新客户端。
在本例中,您可以创建一个
RulesMinaServiceClient
客户端实例,并通过 MINA 传输调用 KIE 服务器上的操作:创建
RulesMinaServiceClient
客户端的实现示例protected RulesMinaServicesClient buildClient() { KieServicesConfiguration configuration = KieServicesFactory.newRestConfiguration("localhost:9123", null, null); List<String> capabilities = new ArrayList<String>(); // Explicitly add capabilities (the MINA client does not respond to `get-server-info` requests): capabilities.add("BRM-Mina"); configuration.setCapabilities(capabilities); configuration.setMarshallingFormat(MarshallingFormat.JSON); configuration.addJaxbClasses(extraClasses); KieServicesClient kieServicesClient = KieServicesFactory.newKieServicesClient(configuration); RulesMinaServicesClient rulesClient = kieServicesClient.getServicesClient(RulesMinaServicesClient.class); return rulesClient; }
通过 MINA 传输调用 KIE 服务器上操作的配置示例
RulesMinaServicesClient rulesClient = buildClient(); List<Command<?>> commands = new ArrayList<Command<?>>(); BatchExecutionCommand executionCommand = commandsFactory.newBatchExecution(commands, "defaultKieSession"); Person person = new Person(); person.setName("mary"); commands.add(commandsFactory.newInsert(person, "person")); commands.add(commandsFactory.newFireAllRules("fired")); ServiceResponse<String> response = rulesClient.executeCommands(containerId, executionCommand); Assert.assertNotNull(response); Assert.assertEquals(ResponseType.SUCCESS, response.getType()); String data = response.getResult(); Marshaller marshaller = MarshallerFactory.getMarshaller(extraClasses, MarshallingFormat.JSON, this.getClass().getClassLoader()); ExecutionResultImpl results = marshaller.unmarshall(data, ExecutionResultImpl.class); Assert.assertNotNull(results); Object personResult = results.getValue("person"); Assert.assertTrue(personResult instanceof Person); Assert.assertEquals("mary", ((Person) personResult).getName()); Assert.assertEquals("JBoss Community", ((Person) personResult).getAddress()); Assert.assertEquals(true, ((Person) personResult).isRegistered());
第 23 章 KIE 服务器的性能调优注意事项
以下主要概念或推荐做法可帮助您优化 KIE 服务器性能。本节中总结了这些概念,并在适用的情况下在跨引用文档中进行更详细的说明。本节将根据新版本的 Red Hat Process Automation Manager 根据需要扩展或更改。
- 确保开发模式在开发过程中启用
您可以在 Business Central 中设置 KIE Server 或特定项目,以使用
生产
模式或开发模式
。默认情况下,Business Central 中的 KIE 服务器和所有新项目都处于开发模式。此模式提供有助于开发体验的功能,如灵活的项目部署策略,以及优化开发过程中 KIE 服务器性能的功能,如禁用重复的 GAV 检测。使用开发模式,直到您的 Red Hat Process Automation Manager 环境建立并完全准备好在生产环境中使用。有关配置环境模式或重复的 GAV 检测的更多信息,请参阅以下资源:
- 根据您的特定需求调整 KIE 服务器功能和扩展
KIE 服务器中的功能由插件扩展来决定,您可以启用、禁用或进一步扩展以满足您的业务需求。默认情况下,KIE 服务器扩展通过 REST 或 JMS 数据传输公开,并使用预定义的客户端 API。您可以使用额外的 REST 端点扩展现有 KIE 服务器功能,扩展 REST 或 JMS 以外的支持的传输方法,或者在 KIE Server 客户端中扩展功能。
KIE 服务器功能中的这种灵活性可让您将 KIE 服务器实例适应您的业务需求,而不是将您的业务需求适应默认的 KIE 服务器功能。
有关启用、禁用或扩展 KIE 服务器功能的详情,请参考 第 22 章 KIE 服务器功能和扩展。
第 24 章 其他资源
- 在 Red Hat JBoss EAP 7.3 上安装和配置 Red Hat Process Automation Manager
- 规划 Red Hat Process Automation Manager 安装
- 在 Red Hat JBoss EAP 7.3 上安装和配置 Red Hat Process Automation Manager
- 使用 Operator 在 Red Hat OpenShift Container Platform 4 上部署 Red Hat Process Automation Manager 环境
- 使用模板在 Red Hat OpenShift Container Platform 3 上部署 Red Hat Process Automation Manager 环境
部分 II. 配置 Business Central 设置和属性
作为管理员,您可以在 admin Settings 页面中自定义以下内容:
- 角色 :设置角色的主页、优先级和权限。
- 组 :设置组的主页、优先级和权限,以及创建和删除组。
- 用户 :创建和删除用户,从用户添加或删除组和角色,并查看用户权限。
- 工件 :查看 M2 存储库工件、上传工件、查看和下载 JAR 文件。
- 数据源:添加、更新或删除数据源和数据库驱动程序。
- 数据集 :创建、修改或删除数据集。
- 项目 :查看并编辑项目首选项,如文件导出属性、空间属性、默认值和高级 GAV 属性。
- 工件存储库 :管理工件存储库属性。
- 语言 :设置 Business Central 语言。
- Process Administration :在 Business Central 中设置默认分页选项。
- 进程设计器 :设置图形编辑器属性。
- SSH 密钥 :添加或删除 SSH 密钥。
- 自定义任务管理 :启用或禁用默认服务任务并上传自定义服务任务。
- Dashbuilder Data Transfer: 在 Business Central 中导入和导出 Dashbuilder 数据作为 ZIP 文件。
- 配置集 :将工作台配置集设置为 Planner 和 Rules 或 Full。
- archetypes : View, add, validate, 设置为 default,并删除 archetypes。在 Business Central 中创建新项目时用作模板。
先决条件
- 安装了 Red Hat JBoss Enterprise Application Platform 7.3.0。如需更多信息,请参阅 Red Hat JBoss Enterprise Application Platform 7.3 安装指南。
- Red Hat Process Automation Manager 已安装并运行。如需更多信息,请参阅在 Red Hat JBoss EAP 7.3 上安装和配置 Red Hat Process Automation Manager。
-
您可以使用
admin
用户角色登录到 Business Central。
第 25 章 用户和组管理
Business Central 为安全管理定义了三种类型的实体:用户、组和角色。您可以为角色和组分配权限。您可以在 Business Central 中分配以下角色:
- process-admin
- Manager
- admin
- 法国
- rest-all
- developer
- rest-project
- user
应用程序 Role Registry 中的用户角色具有角色标识符,而用户组则不需要。
根据需要,使用 Business Central 创建和管理多个用户和组。用户必须至少分配一个特定于用户的角色才能登录到 Business Central。用户权限取决于用户所属的组和角色的权限。请注意,如果用户分配了多个角色或组,则角色或组优先级将被视为。
25.1. 创建用户
用户特权和设置由分配给用户和组的角色控制。您可以在 Business Central 中创建任意数量的用户。
不要在进程引擎或 KIE Server 中创建名为 unknown
的用户。未知
用户帐户是一个具有超级用户访问权限的保留系统名称。当没有用户登录时,未知
用户帐户执行与 SLA 违反监听程序相关的任务。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Users。
- 单击 New user,输入用户名,然后单击 Next。
- 若要为用户分配角色分配给用户,请单击 Roles 选项卡,单击 Add Roles,选择所需的角色,然后单击 Add to selected roles。
- 可选: 要为用户分配组,点 Groups 选项卡,点 Add to groups,选择所需的组,然后点 Add to selected groups。
- 点 Create。
- 单击 Yes 以为用户设置密码,输入所需的密码,然后单击 Change。
用户必须至少有一个角色才能访问 Business Central。
25.2. 编辑用户
您可以使用 Business Central Settings 页面中的 Users 选项更改用户的组和角色。所有用户权限都基于用户的组和角色权限。您可以从 Permissions 选项卡中查看用户权限。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Users。
- 从 All users 列表中,点击您要编辑的用户。用户详情显示在右侧窗格中。
点 Edit 执行以下任务:
- 要更改用户的组,请单击 Groups 选项卡,单击 Add to groups,选择您希望用户所属的组,单击 Add to selected groups,然后点 Save。
- 要更改用户的角色,请单击 Roles 选项卡,单击 Add roles,选择您要分配给用户的角色,点 Add to selected roles,然后点 Save。
- 要查看用户权限,请点 Permissions 选项卡并展开属性。
- 若要更改密码,请单击 Change Password,输入新密码,然后单击 Change。
- 要删除用户,请单击 Delete,然后单击 Yes 以确认删除。
25.3. 创建组
在 Business Central 中,您可以使用组来控制一组用户的权限。您可以根据需要创建任意数量的组,但组必须至少有一个用户。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Groups。
- 单击 New group,输入组名称,然后单击 Next。
选择您要添加到此组中的用户,然后单击 Add selected users。
新创建的组列在 All groups 下。
25.4. 编辑组
您可以根据要求编辑组的属性,如主页、优先级和权限。在 Business Central Settings 页面中的 Groups 选项中,您可以修改或删除组。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Groups。
- 从 All groups 列表中,点击您要编辑的组。用户详情显示在右侧窗格中。
- 从 Home Page 列表中选择主页。
- 从 Priority 列表中选择优先级。
在 Permissions 部分中,展开 resource 属性并更改其权限。
注意您可以在 Pages、Editor s、Spaces 和 Projects 权限中添加例外。
- 单击 Save 以应用更改。
第 26 章 安全管理
安全管理是管理用户、组和权限的过程。您可以从 Business Central Security management 页面控制对 Business Central 资源和功能的访问。
Business Central 为安全管理定义了三种类型的实体:用户、组和角色。您可以为角色和组分配权限。用户从该用户所属的组和角色继承权限。
26.1. 安全管理供应商
在安全管理上下文中,域限制对不同应用资源的访问。realm 包含有关用户、组、角色和权限的信息。特定域的用户和组管理服务实施称为安全管理提供程序。
如果内置安全管理提供商不符合应用程序安全域的要求,您可以构建并注册您自己的安全管理提供程序。
如果没有安装安全管理提供程序,用于管理安全域的用户界面不可用。安装和配置安全管理提供程序后,安全管理用户界面中会自动启用用户和组管理功能。
Business Central 包括 Red Hat JBoss EAP 安全管理提供程序,它根据 application-users.properties
或 application-roles.properties
属性文件的内容支持 realm 类型。
26.1.1. 根据属性文件配置 Red Hat JBoss EAP 安全管理提供程序
您可以构建并注册您自己的 Red Hat JBoss EAP 安全管理提供程序。要根据属性文件使用 Red Hat JBoss EAP 安全管理提供程序,请完成此流程中的步骤。
先决条件
- 安装了 Red Hat JBoss EAP。
流程
要使用 Red Hat JBoss EAP 实例中的现有用户或角色属性文件,请在
EAP_HOME/standalone/configuration/application-users.properties
和EAP_HOME/standalone/configuration/application-roles.properties
文件中包含以下系统属性,如下例所示:<property name="org.uberfire.ext.security.management.wildfly.properties.realm" value="ApplicationRealm"/> <property name="org.uberfire.ext.security.management.wildfly.properties.users-file-path" value="/standalone/configuration/application-users.properties"/> <property name="org.uberfire.ext.security.management.wildfly.properties.groups-file-path" value="/standalone/configuration/application-roles.properties"/>
下表提供了这些属性的描述和默认值:
表 26.1. Red Hat JBoss EAP 安全管理提供程序基于属性文件 属性 描述 默认值 org.uberfire.ext.security.management.wildfly.properties.realm
域的名称。此属性不是强制的。
ApplicationRealm
org.uberfire.ext.security.management.wildfly.properties.users-file-path
users 属性文件的绝对文件路径。此属性是必需的。
./standalone/configuration/application-users.properties
org.uberfire.ext.security.management.wildfly.properties.groups-file-path
groups 属性文件的绝对文件路径。此属性是必需的。
./standalone/configuration/application-roles.properties
在应用程序的根目录中创建
security-management.properties
文件。例如,创建以下文件:src/main/resources/security-management.properties
在
security-management.properties
文件中输入以下系统属性和安全供应商名称作为值:<property name="org.uberfire.ext.security.management.api.userManagementServices" value="WildflyUserManagementService"/>
26.1.2. 根据属性文件和 CLI 模式配置 Red Hat JBoss EAP 安全管理提供程序
要使用基于属性文件和 CLI 模式的 Red Hat JBoss EAP 安全管理提供程序,请完成以下步骤。
先决条件
- 安装了 Red Hat JBoss EAP。
流程
要使用 Red Hat JBoss EAP 实例中的现有用户或角色属性文件,请在
EAP_HOME/standalone/configuration/application-users.properties
和EAP_HOME/standalone/configuration/application-roles.properties
文件中包含以下系统属性,如下例所示:<property name="org.uberfire.ext.security.management.wildfly.cli.host" value="localhost"/> <property name="org.uberfire.ext.security.management.wildfly.cli.port" value="9990"/> <property name="org.uberfire.ext.security.management.wildfly.cli.user" value="<USERNAME>"/> <property name="org.uberfire.ext.security.management.wildfly.cli.password" value="<USER_PWD>"/> <property name="org.uberfire.ext.security.management.wildfly.cli.realm" value="ApplicationRealm"/>
下表提供了这些属性的描述和默认值:
表 26.2. Red Hat JBoss EAP 安全管理提供程序基于属性文件和 CLI 模式 属性 描述 默认值 org.uberfire.ext.security.management.wildfly.cli.host
原生管理接口主机。
localhost
org.uberfire.ext.security.management.wildfly.cli.port
原生管理接口端口。
9990
org.uberfire.ext.security.management.wildfly.cli.user
原生管理界面用户名。
不适用
org.uberfire.ext.security.management.wildfly.cli.password
原生管理接口用户的密码。
不适用
org.uberfire.ext.security.management.wildfly.cli.realm
应用的安全上下文使用的域。
ApplicationRealm
在应用程序的根目录中创建
security-management.properties
文件。例如,创建以下文件:src/main/resources/security-management.properties
在
security-management.properties
文件中输入以下系统属性和安全供应商名称作为值:<property name="org.uberfire.ext.security.management.api.userManagementServices" value="WildflyCLIUserManagementService"/>
26.2. 权限和设置
权限是授予用户与应用程序中特定资源相关的操作的授权。例如,用户可以具有以下权限:
- 查看页面。
- 保存项目。
- 查看存储库。
- 删除仪表板。
您可以授予或拒绝权限,权限可以是全局或特定于资源的权限。您可以使用权限来保护对资源的访问和自定义应用程序内的功能。
26.2.1. 更改 Business Central 中组和角色的权限
在 Business Central 中,您无法更改单个用户的权限。但是,您可以更改组和角色的权限。更改的权限适用于具有角色或属于您更改的组的用户。
您对角色或组所做的任何更改都会影响与该角色或组关联的所有用户。
先决条件
-
您可以使用
admin
用户角色登录到 Business Central。
流程
- 要访问 Business Central 中的 Security management 页面,请选择屏幕右上角的 Admin 图标。
在 Business Central Settings 页面中,点 Roles、Groups 或 Users。
Security management 页面会在您点击的图标的标签页上打开。
- 从列表中选择您要编辑的角色或组。所有详情都显示在右侧面板中。
- 在 Settings 部分下设置 Home Page 或 Priority。
在 Permissions 部分下设置 Business Central、page、Edit、space 和 project 权限。
图 26.1. 设置权限
- 单击资源类型旁边的箭头,以展开您要更改其权限的资源类型。
可选: 要为资源类型添加一个例外,请点击 Add Exception,然后根据需要设置权限。
注意您不能为 Business Central 资源类型添加例外。
- 点击 Save。
26.2.2. 更改 Business Central 主页
主页是在登录到 Business Central 后出现的页面。默认情况下,主页设置为 Home
。您可以为每个角色和组指定不同的主页。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Roles 或 Groups。
- 选择角色或组。
- 从 Home Page 列表中选择一个页面。
点击 Save。
注意角色或组必须具有对页面的读访问权限,然后才能使其成为主页。
26.2.3. 设置优先级
用户可以有多个角色,并属于多个组。Priority 设置决定角色或组的优先级顺序。
先决条件
-
您可以使用
admin
用户角色登录到 Business Central。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Roles 或 Groups。
- 选择角色或组。
- 从 Priority 菜单中选择一个优先级,然后单击 Save。
如果用户有角色或属于具有冲突设置的组,则适用优先级最高的角色或组的设置。
第 27 章 工件管理
您可以从 Business Central 中的 Artifacts 页面中管理工件。artifact 存储库是一个本地 Maven 存储库,每个安装都只有一个 Maven 存储库。Business Central 建议使用 Maven 存储库解决方案,如 Sonatype Nexus™、Apache Archiva™ 或 JFrog Artifactory™。
Artifacts 页面列出了 Maven 存储库中的所有工件。您可以将工件上传到 Maven 存储库。
您只能将 JAR、KJAR 和 pom.xml
文件上传到 Artifacts 存储库。
27.1. 查看工件
您可以从 Artifacts 页面中查看本地 maven 存储库的所有内容。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Artifacts。
- 点 Open 查看工件详情。
- 单击 Ok 以返回到 Artifacts 页面。
27.2. 下载工件
您可以将工件从 Business Central 存储库下载并保存到项目的本地存储。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Artifacts。
- 点 Download。
- 浏览您要保存工件的目录。
- 点击 Save。
27.3. 上传工件
您可以将工件从本地存储上传到 Business Central 中的项目。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Artifacts。
- 点 Upload。
- 单击 Choose File,再浏览到您要从中上传工件的目录。
点 Upload。
注意如果您使用非 Maven 工件,首先使用
mvn deploy
命令将工件部署到 Maven 存储库,然后在 Business Central 中刷新工件列表。
第 28 章 数据源和数据库驱动程序管理
Business Central 提供数据源管理功能,允许您定义用于访问数据库的数据源。然后,其他 Business Central 组件会使用这些数据源,如数据集。数据库驱动程序允许数据源和目标数据库之间的通信。
在 Data Source Authoring 页面中,您可以将数据源和数据库驱动程序添加到 Business Central。
Business Central 提供可以使用但无法编辑或删除的默认数据源。
28.1. 添加数据源
您可以从 Data Sources Authoring 页面向 Business Central 添加新数据源。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Data Sources。
在 DataSource Explorer 窗格中,点 Add DataSource。
此时会打开 New data source 窗口。
- 在 New data source 窗口中,输入数据源的 Name,Connection URL,User,Password, 和 Driver 字段。
- 单击 Test Connection,以验证与数据库的连接。
- 点 Finish。
28.2. 编辑数据源
您可以编辑数据源的属性,并测试其与 Business Central 中的数据库的连接。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Data Sources。
- 在 DataSource Explorer 窗格中,点您要编辑的数据源。
- 在 Data Source Definition 窗格中,对 Name,Connection URL,User,Password, 和 Driver 字段进行必要的更改。
- 单击 Test Connection,以验证与数据库的连接。
- 点 Update。
- 点击 Save。
28.3. 删除数据源
您可以从 Business Central 中的 DataSource Explorer 窗格中删除现有数据源。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Data Sources。
- 在 DataSource Explorer 窗格中,点击您要删除的数据源。
- 单击 Remove。
- 点 Delete 以确认删除数据源。
28.4. 添加数据库驱动程序
您可以在 Business Central 中添加新的数据库驱动程序。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Data Sources。
在 DataSource Explorer 窗格中,点 Add Driver。
此时会打开 New driver 窗口。
- 在 New driver 窗口中,输入数据库驱动程序的 Name、Driver Class Name、Group Id、Artifact Id 和 Version 字段。
- 点 Finish。
28.5. 编辑数据库驱动程序
您可以从驱动程序 定义 窗格中编辑数据库驱动程序的属性。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Data Sources。
- 在 DataSource Explorer 窗格中,选择您要编辑的驱动程序。
- 在 Driver Definition 窗格中,对 Name、Driver Class Name、Group Id、Artifact Id 和 Version 字段进行必要的更改。
- 点 Update。
- 单击 Yes 。
28.6. 删除数据库驱动程序
您可以从 Business Central 的 Data Source Definition 窗格中删除数据库驱动程序。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Data Sources。
- 在 DataSource Explorer 窗格中,选择您要删除的驱动程序。
- 单击 Remove。
- 点 Delete。
第 29 章 数据集编写
数据集是一组相关信息集合,可以存储在数据库中、Microsoft Excel 文件中或内存中。数据集定义指示 Business Central 方法访问、读取和解析数据集。Business Central 不存储数据。它可让您定义对数据集的访问,无论存储数据是什么。
例如,如果数据存储在数据库中,则有效数据集可以包含整个数据库或数据库的子集,因为 SQL 查询。在这两种情况下,数据都用作 Business Central 报告组件的输入,然后显示信息。
要访问数据集,您必须创建并注册数据集定义。数据集定义指定数据集的位置、访问它的选项、读取和解析它,以及其包含的列。
Data Sets 页面仅对具有 admin 角色的用户可见。
29.1. 添加数据集
您可以创建一个数据集来从外部数据源获取数据,并将这些数据用于报告组件。
流程
在 Business Central 中,前往 Admin → Data Sets。
此时会打开 Data Sets 页面。
点 New Data Set 并选择以下供应商类型之一:
- bean: 从 Java 类生成数据集
- CSV: 从远程或本地 CSV 文件生成数据集
- SQL : 从 ANSI-SQL 兼容数据库生成数据集
- Elastic Search: 从 Elastic Search 节点生成数据集
- Prometheus : 使用 Prometheus 查询生成数据集
Kafka: 使用 Kafka 代理、消费者或制作者的指标生成数据集
注意您必须为 Prometheus、Kafka 和 Execution Server 选项配置 KIE 服务器。
完成 Data Set Creation 向导,再点 Test。
注意配置步骤因您选择的供应商而异。
- 点击 Save。
29.2. 编辑数据集
您可以编辑现有的数据集,以确保向报告组件获取的数据是最新的。
流程
在 Business Central 中,前往 Admin → Data Sets。
Data Set Explorer 页面将打开。
- 在 Data Set Explorer 窗格中,搜索您要编辑的数据集,选择数据集,然后点 Edit。
在 Data Set Editor 窗格中,使用适当的选项卡根据需要编辑数据。选项卡根据您选择的数据集供应商类型而有所不同。
例如,以下更改适用于编辑 CSV 数据供应商:
- CSV 配置 : 允许您更改数据集定义、源文件、分隔符和其他属性的名称。
预览: 允许您预览数据。在 CSV Configuration 选项卡中点 Test 后,系统会执行数据集查找调用,如果数据可用,则会出现预览。请注意,Preview 选项卡有两个子选项卡:
- data 列: 允许您指定哪个列是数据集定义的一部分。
- filter : 允许您添加新过滤器。
advanced : 允许您管理以下配置:
- Cache : 如需更多信息,请参阅缓存数据。
- 缓存生命周期 允许您指定刷新数据集(或数据)的时间间隔。当后端 数据更改时,对过时的数据功能的 Refresh 会刷新缓存的数据。
- 进行必要的更改后,单击 Validate。
- 点击 Save。
29.3. 数据刷新
数据刷新功能允许您指定数据集(或数据)刷新的时间间隔。您可以访问数据集 的高级 选项卡上的数据刷新每个 功能。当后端 数据更改时,对过时的数据功能的 Refresh 会刷新缓存的数据。
29.4. 缓存数据
Business Central 提供缓存机制,用于存储数据集并使用内存数据执行数据操作。缓存数据可减少网络流量、远程系统有效负载和处理时间。为了避免性能问题,请在 Business Central 中配置缓存设置。
对于导致数据集的任何数据查找调用,缓存方法决定数据查找调用的位置以及存储结果的数据集的位置。数据查找调用的一个示例是所有其 locale 参数设置为"Urban"的应用程序。
Business Central 数据集功能提供两个缓存级别:
- 客户端级别
- 后端级别
您可以在 数据集 的高级 标签页 上设置客户端缓存和后端缓存设置。
客户端缓存
打开缓存后,数据集会在查找操作过程中缓存到 Web 浏览器中,而进一步的查找操作不会对后端执行请求。数据集操作,如分组、聚合、过滤和排序在 Web 浏览器中处理。仅在数据集大小太小时才启用客户端缓存,例如,对于小于 10 MB 的数据集。对于大型数据集,可能会出现浏览器问题,如性能下降或间歇性。客户端缓存可减少后端请求数量,包括对存储系统的请求。
后端缓存
启用缓存后,决策引擎会缓存数据集。这可减少到远程存储系统的后端请求数。所有数据集操作都在决策引擎中使用内存数据执行。仅在数据集大小没有频繁更新且可以存储并处理在内存中时才启用后端缓存。在远程存储出现低延迟连接问题时,使用后端缓存也很有用。
Data Set Editor 的高级标签页中不会看到 后端缓存 设置,因为 Java 和 CSV 数据供应商依赖于后端缓存(数据集必须在内存中),以便使用内存决策引擎解析任何数据查找操作。
第 30 章 archetype 管理
Business Central 提供了一个 archetype 管理功能,可让您列出、添加、验证、设置为默认并删除 archetypes。您可以在 Business Central 中的 Archetypes 页面中管理 archetypes。archetypes 是在 Apache Maven 存储库中安装的项目,您可以根据需要设置或创建模板结构。
有关 archetypes 的最新和最新详情,请查看 Archetypes 页简介。
30.1. 列出 archetypes
Archetypes 页面列出了在 Business Central 中添加的所有 archetypes。此列表提供有关 组 ID、工件 ID、版本、创建日期、状态 以及架构类型操作的详细信息。
先决条件
- 您已创建了 archetype,并在 maven 存储库中的 Business Central Settings 中列出它。
流程
在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Archetypes。
在 Status 列中,绿色图标表示它是一个有效的 archetype,红色图标表示它是一个无效的架构类型,而蓝色图标表示对应的 archetype 是新空格的默认 archetype。
30.2. 添加 archetype
您可以将新的 archetype 添加到 Business Central。
先决条件
- 您已在 Maven 存储库中安装了 archetype。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Archetypes。
- 点 Add Archetype。
- 在 Add Archetype 面板中,分别在 Group ID、Artifact ID 和 Version 字段中输入 GAV 属性。
- 点击 Add。
Business Central 验证新添加的 archetype,并使其可在所有空格中用作模板。
30.3. 管理 archetype 的额外功能
您可以从 Business Central 中的 Archetypes 页面中删除、设置默认并验证 archetypes。
先决条件
- 您已创建了 archetype,并列在 Maven 存储库中的 Business Central Settings 中。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Archetypes。
在 Actions 列中,点 archetype 右侧的
图标。
- 从下拉菜单中选择 Delete 以删除 archetype。
从下拉菜单中选择 Validate,以验证 archetype 是否有效。
注意当 Business Central 启动时,所有注册的 archetypes 会自动验证。
- 从下拉菜单中选择 Set as default,将 archetype 设置为新空格的默认值。
30.4. 使用 archetypes 创建项目
您可以使用 archetypes 在 Business Central 中创建项目。当您在 Business Central 中创建项目时,它将添加到连接到 Red Hat Process Automation Manager 安装的 Git 存储库中。
先决条件
- 您已创建了 archetype,并在 Maven 存储库中的 Business Central Settings 中列出它。
- 您已在 Business Central 的空间中将 archetype 设置为默认值。
流程
- 在 Business Central 中,进入 Menu → Design → Projects。
- 选择或创建您要从 archetype 模板添加新项目的空间。
- 单击 Add Project。
- 在 Name 和 Description 字段中输入项目名称和描述。
- 单击 Configure Advanced Options。
- 选中 Based on template 复选框。
如果需要,从下拉列表中选择 archetype。
默认 archetype 已在空间中设置。
- 点 Add。
项目的 Assets 视图会根据所选的 archetype 模板打开。
30.5. 使用 Business Central 中的空间设置来管理架构类型
将 archetypes 添加到 Business Central 时,您可以在所有空格中使用它们作为模板。您可以从 Settings 选项卡中管理所有 archetypes,该选项卡可在空间中可用。此选项卡仅对具有 admin
角色的用户可见。
先决条件
- 您已在 Maven 存储库中安装了 archetype。
- 您已创建了 archetype,并在 Maven 存储库中的 Business Central Settings 中列出它。
流程
- 在 Business Central 中,进入 Menu → Design → Projects。
- 选择或创建您要管理架构类型的空间。默认空间为 MySpace。
- 单击 Settings。
- 要在空格中包含或排除 archetypes,请选择 Include 复选框。
-
在 Actions 列中,点 archetype 右侧的
图标,然后从下拉菜单中选择 Set 作为默认值,将 archetype 设置为空间的默认值。
- 点击 Save。
第 31 章 自定义项目首选项
在 Business Central 中,项目是您的空间的一部分,并存储相关的资产。您可以在一个空间中添加多个项目。
例如,一个机构包括各种部门,如 HR、Payroll、工程团队和 R&D。您可以将每个部门映射到 Business Central 中的空间,并添加相应的项目。
您可以在 Business Central 中自定义项目设置。另外,您可以创建新项目或从现有的 Git 存储库克隆项目。
流程
- 在 Business Central 中,选择右上角的 Admin 图标,然后选择 Projects。
在 Project Preferences 面板中,选择您要修改的首选项。项目首选项包括:
项目导入 :此首选项由以下属性组成:
- 选择要 在集群中导入的 Allow multiple projects,以导入集群中的多个项目。
文件导出 :此首选项由以下属性组成:
表 31.1. 文件导出属性 字段 描述 PDF 方向
确定 PDF 或ientation 是否为 portrait 还是环境。
PDF 单元
确定 PDF 单元是否为 PT、MM、CN 或 IN。
PDF 页面格式
确定 PDF 页面格式为 A[0-10]、B[0-10] 还是 C[0-10]。
空格 :此首选项由以下属性组成:
表 31.2. 空格属性 字段 描述 名称
如果不存在,会自动创建的空间的默认名称。
所有者
如果不存在,会自动创建的空间的默认所有者。
组 ID
如果不存在,会自动创建的空间的默认组 ID。
别名(单数)
决定空间的自定义别名(单数)。
别名(以复数为单位)
决定空间的自定义别名(复数)。
默认值 :此首选项由以下属性组成:
表 31.3. 默认值属性 字段 描述 版本
创建项目时项目的默认版本号。
描述
创建项目时项目的默认描述。
分支
使用 Git 存储库时要使用的默认分支。
每个页面的资产
用于自定义项目中每个页面的资产数量。默认值为
15
。高级 GAV 首选项 :此首选项由以下属性组成:
表 31.4. 高级 GAV 首选项属性 字段 描述 禁用 GAV 冲突检查?
决定是否启用或禁用 GAV 冲突检查。禁用此复选框可让项目包含相同的 GAV (组 ID、工件和版本)。
允许子 GAV 版本?
决定是否允许子项目或子项目包含 GAV 版本。
注意开发模式中的项目禁用重复的 GAV 检测。要为 Business Central 中的项目启用重复的 GAV 检测,请进入 Project Settings → General Settings → Version,并将 Development Mode 选项切换为 OFF (如果适用)。
- 点击 Save。
第 32 章 自定义工件存储库属性
在某些情况下,项目需要解析外部依赖项来构建域模型 JAR 文件。存储库包含所需的工件,并具有以下功能:
- 存储库是一个 Maven 存储库。
- 所有快照都是时间戳的。
- 资产主要存储在本地硬盘中。
默认情况下,工件存储库位于 $WORKING_DIRECTORY/repositories/kie
中。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Artifact Repository。此时会打开 Artifact Repository 页面。
- 在 Properties 部分进行选择并输入信息。
- 点击 Save。
第 33 章 自定义语言设置
您可以更改 Business Central Settings 页面中的语言。Business Central 支持以下语言:
- English
- 西班牙语
- 法语
- 日语
默认语言为英语。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Languages。此时会打开 Language Selector 窗口。
- 从 Language 列表中选择所需的语言。
- 点 确定。
第 34 章 自定义进程管理
您可以通过编辑 Process Administration 页面上的 Default items per page 属性来自定义 Business Central 中的默认分页选项。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Process Administration。
在 Properties 部分中,更新每个页面 属性的 Default items,然后点 Save。
注意您可以指定 10、20、50 或 100 个项目来在每个页面上显示。
第 35 章 自定义进程设计程序
您可以通过编辑 Business Central Settings 页面中的图形编辑器的属性来自定义 Business Central 中的进程设计器。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Process Designer。
在 Properties 部分中,更新以下任何属性:
- 选择 Auto hide category 面板 复选框,以自动隐藏类别工具栏面板。
- 在 Drawing 区域宽度 字段中,输入 2800 到 5600 之间的整数值,以设置 drawing 区域的宽度。
- 在 Drawing 区域 height 字段中,输入 1400 到 2800 之间的整数值,以设置 drawing 区域的高度。
- 如果您使用高分辨率显示并看到 blurry 文本和对象,请选择 Enable HiDPI 复选框。默认禁用这个选项。
- 点击 Save。
第 36 章 SSH 密钥
Business Central 提供了一个 SSH 密钥存储服务,以启用用户 SSH 身份验证。Business Central 提供可配置的默认 SSH 密钥存储、可扩展 API (用于自定义实施)并支持多个 SSH 公钥格式。
您可以在 Business Central Settings 页面中访问 SSH Keys 选项来注册 SSH 公钥。
36.1. 默认 SSH 密钥存储
Business Central 中包含的默认 SSH 密钥存储提供了基于文件的存储机制,用于存储用户的公钥。默认情况下,Eererer Central 使用 sVirt security
文件夹作为根目录。但是,您还可以通过设置 appformer.ssh.keys.storage.folder
系统属性的值来指向不同的文件夹来使用自定义存储路径。
SSH 公钥存储在 {securityPRESSPath}/pkeys/{userName}/
文件夹结构中。
每个 SSH 公钥由以下文件组成,位于存储文件夹中:
{keyID}.pub
:此文件包含 SSH 公钥内容。由于文件名决定了系统上的逻辑密钥 ID,请确保在运行时不会修改文件名。例如:
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDmak4Wu23RZ6XmN94bOsqecZxuTa4RRhhQmHmTZjMB7HM57/90u/B/gB/GhsPEu1nAXL0npY56tT/MPQ8vRm2C2W9A7CzN5+z5yyL3W01YZy3kzslk77CjULjfhrcfQSL3b2sPG5jv5E5/nyC/swSytucwT/PE7aXTS9H6cHIKUdYPzIt94SHoBxWRIK7PJi9d+eLB+hmDzvbVa1ezu5a8yu2kcHi6NxxfI5iRj2rsceDTp0imC1jMoC6ZDfBvZSxL9FXTMwFdNnmTlJveBtv9nAbnAvIWlilS0VOkdj1s3GxBxeZYAcKbcsK9sJzusptk5dxGsG2Z8vInaglN6OaOQ7b7tcomzCYYwviGQ9gRX8sGsVrw39gsDIGYP2tA4bRr7ecHnlNg1b0HCchA5+QCDk4Hbz1UrnHmPA2Lg9c3WGm2qedvQdVJXuS3mlwYOqL40aXPs6890PvFJUlpiVSznF50djPnwsMxJZEf1HdTXgZD1Bh54ogZf7czyUNfkNkE69yJDbTHjpQd0cKUQnu9tVxqmBzhX31yF4VcsMeADcf2Z8wlA3n4LZnC/GwonYlq5+G93zJpFOkPhme8c2XuPuCXF795lsxyJ8SB/AlwPJAhEtm0y0s0l1l4eWqxsDxkBOgN+ivU0czrVMssHJEJb4o0FLf7iHhOW56/iMdD9w== userName
.{keyID}.pub.meta
:此文件包含 JSON 格式的密钥元数据。如果密钥没有元数据,则会动态生成新的元数据文件。例如:
{ "name":"Key", "creationDate":"Oct 10, 2018 10:10:50 PM", "lastTimeUsed":"Oct 11, 2018 12:11:23 PM" }
36.2. 自定义 SSH 密钥存储
您可以根据要求扩展和自定义默认的 SSH 密钥存储。使用 appformer.ssh.keystore
系统属性指定要使用的 SSH 服务的 Java 类名称。如果未定义此属性或包含不正确的值,则会加载默认的 SSH 密钥存储。
要创建 SSH 密钥存储的自定义实施,您的 Java 类必须实施 uberfire-ssh-api
模块中定义的 org.uberfire.ssh.service.backend.keystore.SSHKeyStore
类。
36.3. 创建 SSH 密钥
在 Business Central 中添加或注册 SSH 密钥前,您必须在系统上生成 SSH 密钥。
流程
- 在您的系统中打开命令终端。
运行
ssh-keygen
命令来创建 SSH 密钥,如下例所示,其中 <user_login>
; 是您的用户名:ssh-keygen -t rsa -b 4096 -C "<user_login>"
注意Business Central keystore 支持的 SSH 密钥格式为
ssh-rsa
,ssh-dss
,ecdsa-sha2-nistp256
,ecdsa-sha2-nistp384
, 和ecdsa-sha2-nistp521
。提示时,按 Enter 键并接受默认密钥文件位置,如下例所示,其中 <
user_login>
; 是您的用户名:Enter a file in which to save the key (/home/<user_login>/.ssh/id_rsa): [Press enter]
在命令提示符输入并确认密码短语:
Enter passphrase (empty for no passphrase): [Type a passphrase] Enter same passphrase again: [Type passphrase again]
启动
ssh-agent
:eval "$(ssh-agent -s)" Agent pid <any-number-here>
将新的 SSH 私钥添加到
ssh-agent
。如果您使用其他密钥名称,替换该代码中的id_rsa
:ssh-add ~/.ssh/id_rsa
36.4. 使用 SSH 密钥存储注册 SSH 公钥
您必须使用 Business Central 密钥存储注册新创建的 SSH 公钥。
流程
- 在您的系统中打开命令终端。
如以下示例所示运行
cat
命令,其中id_rsa
是您的密钥名称:cat ~/.ssh/id_rsa.pub
- 复制 SSH 公钥的内容。
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 SSH Keys。
- 在 SSH Keys 页面上,单击 Add SSH Key。
在 Add SSH Key 窗口中,在 Name 字段中输入名称,并将 SSH 公钥的内容复制到 Key 字段。
注意Name 和 Key 字段是必需的。
- 单击 Add SSH Key 以注册密钥。
36.5. 删除 SSH 密钥
您可以从 SSH Keys 页面从 Business Central 中删除 SSH 密钥。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 SSH Keys。
- 在 SSH Keys 页面中,点击您要删除的 SSH 密钥的删除图标。
- 单击 Delete SSH Key 以确认删除。
第 37 章 在 Business Central 中管理自定义任务
自定义任务(工作流项目)是可以运行自定义逻辑的任务。您可以在多个业务进程或 Business Central 中的所有项目中自定义和重复使用自定义任务。您还可以在设计器面板中添加自定义元素,包括名称、图标、子类别、输入和输出参数以及文档。Red Hat Process Automation Manager 在 Business Central 中的自定义任务存储库中提供一组自定义任务。您可以启用或禁用默认自定义任务,并将自定义任务上传到 Business Central 中,以便在相关进程中实施任务。
Red Hat Process Automation Manager 包括一组有限的自定义任务。不支持没有包括在 Red Hat Process Automation Manager 中的自定义任务。
流程
在 Business Central 中,点右上角的
并选择 Custom Tasks Administration。
本页列出了自定义任务安装设置,以及在整个 Business Central 中项目中的进程可用的自定义任务。您在项目级别设置中启用的自定义任务在项目级别设置中可用,然后安装要在进程中使用的每个自定义任务。自定义任务安装到项目中的方式由您在此 Custom Tasks Administration 页面上的 Settings 下启用或禁用的全局设置决定。
在 Settings 下,启用或禁用每个设置,以确定用户在项目级别安装可用自定义任务时如何实施。
可用的自定义任务设置如下:
- 安装为 Maven 工件 :将自定义任务 JAR 文件上传到使用 Business Central 配置的 Maven 存储库(如果尚不存在)。
-
将 自定义任务依赖项安装到项目 :将任何自定义任务依赖项添加到安装任务的项目的
pom.xml
文件中。 -
将 自定义任务安装到项目时 使用版本范围 :使用版本范围而不是作为项目依赖项添加的自定义任务的固定版本。示例:
[7.16)
而不是7.16.0.Final
根据需要启用或禁用任何可用的自定义任务(设置为 ON 或 OFF)。您在 Business Central 中所有项目的项目级别设置中显示您启用的自定义任务。
图 37.1. 启用自定义任务和自定义任务设置
-
要添加自定义任务,请点 Add Custom Task,浏览到相关的 JAR 文件,然后点 Upload 图标。如果类实施
WorkItemHandler
,您可以通过将文件单独添加到 Business Central 来将注解替换为.wid
文件。 - 可选: 要删除自定义任务,请点击您要删除的自定义任务行的 remove,然后点击 Ok 以确认删除。
- 配置所有必要的自定义任务后,进入 Business Central 中的项目,再进入 project Settings → Custom Tasks 页面,以查看您启用的可用自定义任务。
- 对于每个自定义任务,点 Install 使任务可供该项目中的进程使用,或者点击 Uninstall 从项目中的进程中排除任务。
如果在安装自定义任务时提示您输入其他信息,请输入所需信息,然后再次点 Install。
自定义任务所需的参数取决于任务的类型。例如,规则和决策任务需要工件 GAV 信息(组 ID、工件 ID、版本)、电子邮件任务需要主机和端口访问信息,并且 REST 任务需要 API 凭据。其他自定义任务可能不需要任何其他参数。
图 37.2. 安装自定义任务以便在进程中使用
- 点击 Save。
返回到项目页面,在项目中选择或添加批准过程,并在流程设计器 palette 中选择 Custom Tasks 选项来查看您启用和安装的可用自定义任务:
图 37.3. 在进程设计器中访问已安装的自定义任务
第 38 章 LDAP 连接
Business Central 为带有 Red Hat Process Automation Manager 的 LDAP 服务器提供专用 UserGroup 回调
实施,以便用户任务服务直接从 LDAP 服务检索有关用户、组和角色的信息。
您可以配置以下 LDAP UserGroup 回调
实施属性:
属性 | 描述 |
---|---|
| 用于连接到 LDAP 服务器的用户名。 如果没有指定,此属性是可选的,并且 LDAP 服务器接受匿名访问。 |
| 用于连接到 LDAP 服务器的密码。 如果没有指定,此属性是可选的,并且 LDAP 服务器接受匿名访问。 |
| 带有用户信息的 LDAP 中的上下文。 |
| 带有组和角色的 LDAP 中的上下文。 |
| LDAP 中带有用户和组群和角色成员资格信息的上下文。
如果没有指定,此属性是可选的,并且使用 |
| 用于搜索用户信息的过滤器。 此属性通常包含替换为参数的替换键 {0}。 |
| 用于搜索组和角色信息的过滤。 此属性通常包含替换为参数的替换键 {0}。 |
| 用于搜索用户组和角色成员资格信息的过滤。 此属性通常包含替换为参数的替换键 {0}。 |
| LDAP 中用户 ID 的属性名称。
如果没有指定,此属性是可选的,并使用 |
| LDAP 中组和角色 ID 的属性名称。
如果没有指定,此属性是可选的,并且使用 |
|
DN 中的用户 ID,指示回调在搜索角色前查询用户 DN。这是可选的,默认为 |
|
初始上下文工厂类名称;默认为 |
|
身份验证类型,其中可能的值是 |
|
要使用的安全协议,例如 |
|
LDAP url (默认为 |
38.1. LDAP UserGroup 回调实施
您可以通过使用以下方法之一配置对应的 LDAP 属性来使用 LDAP 用户组 回调
实现:
以编程方式:使用对应的
LDAPUserGroupCallbackImpl
属性构建属性对象,并使用与其参数相同的属性对象创建LDAPUserGroupCallbackImpl
。例如:
import org.kie.api.PropertiesConfiguration; import org.kie.api.task.UserGroupCallback; ... Properties properties = new Properties(); properties.setProperty(LDAPUserGroupCallbackImpl.USER_CTX, "ou=People,dc=my-domain,dc=com"); properties.setProperty(LDAPUserGroupCallbackImpl.ROLE_CTX, "ou=Roles,dc=my-domain,dc=com"); properties.setProperty(LDAPUserGroupCallbackImpl.USER_ROLES_CTX, "ou=Roles,dc=my-domain,dc=com"); properties.setProperty(LDAPUserGroupCallbackImpl.USER_FILTER, "(uid={0})"); properties.setProperty(LDAPUserGroupCallbackImpl.ROLE_FILTER, "(cn={0})"); properties.setProperty(LDAPUserGroupCallbackImpl.USER_ROLES_FILTER, "(member={0})"); UserGroupCallback ldapUserGroupCallback = new LDAPUserGroupCallbackImpl(properties); UserGroupCallbackManager.getInstance().setCallback(ldapUserGroupCallback);
声明性:在应用程序根目录中创建
jbpm.usergroup.callback.properties
文件,或者将文件位置指定为系统属性。例如:
-Djbpm.usergroup.callback.properties=FILE_LOCATION_ON_CLASSPATH
确保您在启动用户任务服务器时注册 LDAP 回调。
例如:
#ldap.bind.user= #ldap.bind.pwd= ldap.user.ctx=ou\=People,dc\=my-domain,dc\=com ldap.role.ctx=ou\=Roles,dc\=my-domain,dc\=com ldap.user.roles.ctx=ou\=Roles,dc\=my-domain,dc\=com ldap.user.filter=(uid\={0}) ldap.role.filter=(cn\={0}) ldap.user.roles.filter=(member\={0}) #ldap.user.attr.id= #ldap.roles.attr.id=
其他资源
第 39 章 数据库连接
Business Central 为带有 Red Hat Process Automation Manager 的数据库服务器提供了一个专用的 UserGroup 回调
实施,以启用用户任务服务。用户任务服务有助于直接从数据库检索用户和组(角色)的信息。
您可以配置以下数据库 UserGroupCallback
实现属性:
属性 | 描述 |
---|---|
| 用于连接的数据源的 JNDI 名称 |
| 验证用户是否存在 |
| 为给定用户收集组 |
| 验证组是否存在 |
39.1. 数据库用户组回调实施
在数据库 UserGroup 回调
实现中,您必须创建所需的数据库。您可以通过使用以下方法之一配置对应的数据库属性来使用此实现:
以编程方式:使用对应的
DBUserGroupCallbackImpl
属性构建属性对象,并使用与其参数相同的属性对象创建DBUserGroupCallbackImpl
。例如:
import static org.jbpm.services.task.identity.DBUserGroupCallbackImpl.DS_JNDI_NAME; import static org.jbpm.services.task.identity.DBUserGroupCallbackImpl.PRINCIPAL_QUERY; import static org.jbpm.services.task.identity.DBUserGroupCallbackImpl.ROLES_QUERY; import static org.jbpm.services.task.identity.DBUserGroupCallbackImpl.USER_ROLES_QUERY; ... props = new Properties(); props.setProperty(DS_JNDI_NAME, "jdbc/jbpm-ds"); props.setProperty(PRINCIPAL_QUERY, "select userId from Users where userId = ?"); props.setProperty(ROLES_QUERY, "select groupId from UserGroups where groupId = ?"); props.setProperty(USER_ROLES_QUERY, "select groupId from UserGroups where userId = ?"); callback = new DBUserGroupCallbackImpl(props);
声明性:在应用程序根目录中创建
jbpm.usergroup.callback.properties
文件,或者将文件位置指定为系统属性。例如:
-Djbpm.usergroup.callback.properties=FILE_LOCATION_ON_CLASSPATH
确保您在启动用户任务服务器时注册数据库回调。
例如:
System.setProperty("jbpm.usergroup.callback.properties", "/jbpm.usergroup.callback.db.properties"); callback = new DBUserGroupCallbackImpl(true); ... db.ds.jndi.name = jdbc/jbpm-ds db.user.query = select userId from Users where userId = ? db.roles.query = select groupId from UserGroups where groupId = ? db.user.roles.query = select groupId from UserGroups where userId = ?
其他资源
第 40 章 使用 settings.xml 文件配置 Maven
Java 应用程序开发使用 Apache Maven 构建自动化工具来构建和管理软件项目。Maven 使用项目对象模型(POM)配置 XML 文件来定义项目属性和构建过程。
Maven 使用存储库来存储 Java 库、插件和其他构建工件。存储库可以是本地或远程存储库。本地存储库是从本地计算机上缓存的远程存储库下载工件。远程存储库是任何使用通用协议访问的其他存储库,如 http://
(位于 HTTP 服务器上),或者 file://
(位于文件服务器上)。默认存储库是公共远程 Maven 2 Central 存储库。Maven 的配置是通过修改 settings.xml 文件来执行的。您可以在 M2_HOME/conf/settings.xml
文件中配置全局 Maven 设置,或者在 USER_HOME/.m2/settings.xml
文件中配置用户级别设置。
其他资源
第 41 章 GAV 检查管理
在 Business Central 中,项目由 组 ID、Artifact ID 和版本(GAV) Maven 命名规则标识。GAV 值区分项目和项目版本,以及识别与特定项目的依赖关系。
默认情况下,Business Central 会检测重复的 GAV。具有 admin 角色的用户可以禁用此功能。
41.1. 配置 GAV 检查和子 GAV 版本
这个步骤描述了如何在 Business Central 中配置 GAV 检查。
流程
- 在 Business Central 中,进入 Menu → Design → Projects,然后点击项目名称。
- 在项目窗口中,点 Settings 选项卡。
在 General Settings 选项卡中,执行以下任务:
- 要启用其他项目具有相同的 GAV,请选择 Disable GAV conflict 复选框。
- 要启用子项目具有 GAV 版本,请选中 Allow sub GAV versions 复选框。
点击 Save。
注意您可以点击 Reset 来撤销所有更改。
- 单击 Save 以确认更改。
开发模式 中的项目禁用重复的 GAV 检测。要在 Business Central 中启用重复的 GAV 检测,请转至 Project Settings → General Settings → Version,并将 Development Mode 选项切换为 OFF (如果适用)。
41.2. 为所有项目配置 GAV 检查
这个步骤描述了如何为 Business Central 中的所有项目配置 GAV 检查。您还可以在系统启动时禁用 GAV 检查。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Projects。此时会打开 Projects 窗口。
在 Advanced GAV 首选项 选项卡中,执行以下任务:
- 要启用其他项目具有相同的 GAV,请选择 Disable GAV conflict 复选框。
- 要启用子项目具有 GAV 版本,请选中 Allow sub GAV versions 复选框。
- 点击 Save。
您还可以通过在系统启动时将 Business Central 的 org.guvnor.project.gav.check.disabled
系统属性设置为 true 来禁用重复的 GAV 检测功能:
$ ~/EAP_HOME/bin/standalone.sh -c standalone-full.xml -Dorg.guvnor.project.gav.check.disabled=true
第 42 章 在 KIE 服务器和 Business Central 中配置环境模式
您可以将 KIE 服务器设置为 在生产
模式 或开发
模式下运行。开发模式提供了一个灵活的部署策略,可让您更新现有的部署单元(KIE 容器),同时维护活跃进程实例以进行小更改。它还允许您在更新活跃进程实例以进行较大的更改前重置部署单元状态。生产环境模式最适合生产环境,每个部署都会创建一个新的部署单元。
在开发环境中,您可以点 Deploy in Business Central 将构建的 KJAR 文件部署到 KIE 服务器中,而不停止任何正在运行的实例(如果适用),或者点 Redeploy 来部署构建的 KJAR 文件并替换所有实例。您下次部署或重新部署构建的 KJAR 时,以前的部署单元(KIE 容器)会在相同的目标 KIE 服务器中自动更新。
在生产环境中,Business Central 中的 Redeploy 选项被禁用,您只能点 Deploy 将构建的 KJAR 文件部署到 KIE 服务器上的新部署单元(KIE 容器)。
流程
-
要配置 KIE 服务器环境模式,请将
org.kie.server.mode
系统属性设置为org.kie.server.mode=development
或org.kie.server.mode=production
。 要在 Business Central 中为项目配置部署行为,请转至 Settings → General Settings → Version,并切换 Development Mode 选项。
注意默认情况下,Business Central 中的 KIE 服务器和所有新项目都处于开发模式。
您不能部署启用了 开发模式 的项目,或手动将
SNAPSHOT
版本后缀添加到处于生产环境模式的 KIE 服务器中。
第 43 章 Git hook 和远程 Git 存储库集成
Git hook 是 Git 事件之前或之后执行的 bash 脚本,如 git commit
或 git push
。在 Business Central 中,您可以使用 Git hook 将存储库配置为在每次事件发生时触发指定的操作。如需有关 Git hook 的更多信息,请参阅自定义 Git Hook。
您可以使用提交 Git hook 将远程 Git 存储库与 Business Central 集成。这可让您在 Business Central 和远程存储库之间自动化内容复制。例如,您可以实施实时备份策略,其中对 Business Central 项目所做的更改被复制到远程 Git 存储库中。
Business Central 只支持提交 Git hook。
每次提交后 Git hook 作为同步操作执行。Business Central 等待提交后 bash 完成,且不会在存储库中发生其他写入操作。
43.1. 创建提交后 Git hook
您可以创建一个 post-commit Git hook bash 脚本文件,该文件中包含的代码或从不同文件(如 Java 程序)执行代码。
流程
创建
提交后
Git hook 文件:$ touch post-commit
将
post-commit
文件的权限设置为755
:$ chmod 755 post-commit
向
post-commit
文件添加 guestfish!/bin/bash
以及任何所需的代码,例如:将所有更改推送到远程存储库:
#!/bin/bash git push origin +master
记录信息:
#!/bin/bash echo 'Hello World'
执行另一个文件的代码:
#!/bin/bash java -jar _EAP_HOME_/bin/.niogit/<SPACE>/<PROJECT_NAME>.git/hooks/git-push.jar
注意要使用执行 Java 代码的 post-commit Git hook,您必须使用以下 Java 库:
- jgit :用于与内部 Business Central Git 存储库交互。
- 用于 Java 的 GitHub API :用于与 GitHub 通信。
有关提交 Git hook 和 Java 代码示例的更多信息,请参阅 Business Central post-commit Git Hooks 集成。
43.2. 导入远程 Git 存储库
您可以将远程 Git 存储库导入到 Business Central,并配置 post-commit Git hook,以自动将更改推送到该远程存储库。
先决条件
- Red Hat Process Automation Manager 安装在 Red Hat JBoss EAP 7.3 服务器实例中。
- Red Hat Process Automation Manager 项目存在于外部 Git 存储库中。
- 外部 Git 存储库的读取访问凭据。
-
(对于 Windows)Cygwin 安装在安装过程中添加的 Git 软件包,并且 Cygwin
/bin
文件夹的路径添加到您的环境变量中。例如:
C:\cygwin64\bin
。有关 Cygwin 安装的更多信息,请参阅 安装和更新 Cygwin 软件包。
流程
- 在 Business Central 中,进入 Menu → Projects。
- 选择或创建您要将 Git 项目导入到的空间。
-
点击屏幕右侧的
并选择 Import Project。
-
在 Import Project 窗口中,输入 Git 存储库的 URL,如
https://github.com/USERNAME/REPOSITORY_NAME.git
,以及 Git 存储库的凭据。 点 Import。
项目添加到 Business Central Git 存储库,然后在空间中可用。
重要使用 HTTPS 或 Git 协议而不是 SCP 风格的 SSH URL。Business Central 不支持基本的 SSH URL,如果使用此 URL,则会出现错误。
您必须在 Git 供应商中配置您的公共 ssh 密钥。
Git 存储库必须是 KJAR 项目,仅包含一个与 Red Hat Process Automation Manager 版本兼容的 KJAR。KJAR 内容必须位于仓库的根目录中。
在命令终端中,导航到位于项目的仓库 Git 文件夹中的
hook
文件夹。例如:$ cd _EAP_HOME_/bin/.niogit/<SPACE>/<PROJECT_NAME>.git/hooks
创建一个
提交后
的文件,将更改推送到远程 Git 存储库。例如:#!/bin/sh git push origin +master
有关创建提交后 Git hook 的更多信息,请参阅 第 43.1 节 “创建提交后 Git hook”。
可选: 要检查配置是否成功,请在 Business Central 中创建一个指导规则:
- 在 Business Central 中,进入 Menu → Projects → Add Asset → video Rule。
- 在 Create new blank Rule 页面中,输入所需信息。
点 确定。
Business Central 会自动将所有更改推送到远程存储库。
其他资源
43.3. 为现有远程 Git 项目存储库配置 Git hook
如果您有一个现有的远程 Git 存储库项目,您可以在该现有项目的远程 Git 存储库中创建一个 post-commit Git hook,并将远程 Git 存储库与 Business Central 集成。
先决条件
- Red Hat Process Automation Manager 安装在 Red Hat JBoss EAP 7.3 服务器实例中。
- Red Hat Process Automation Manager 项目存在于外部 Git 存储库中。
- 外部 Git 存储库的读取访问凭据。
-
(对于 Windows 操作系统)Cygwin 安装在安装过程中添加的 Git 软件包,Cygwin
/bin
文件夹添加到您的环境PATH
变量中。例如:C:\cygwin64\bin
。有关 Cygwin 安装的更多信息,请参阅 安装和更新 Cygwin 软件包。
流程
在命令终端中,导航到位于项目的仓库 Git 文件夹中的
hook
文件夹。例如:$ cd _EAP_HOME_/bin/.niogit/<SPACE>/<PROJECT_NAME>.git/hooks
创建一个
提交后
的文件,将更改推送到远程 Git 存储库。例如:#!/bin/sh git push origin +master
有关创建提交后 Git hook 的更多信息,请参阅 第 43.1 节 “创建提交后 Git hook”。
可选: 要检查配置是否成功,请在 Business Central 中创建一个指导规则:
- 在 Business Central 中,进入 Menu → Projects → Add Asset → video Rule。
- 在 Create new blank Rule 页面中,输入所需信息。
点 确定。
Business Central 会自动将所有更改推送到远程存储库。
43.4. 将 Git hook 配置为 Business Central 的系统属性
如果您没有现有的 Git 存储库项目,或者您要将 post-commit Git hook 应用到大量项目存储库,您可以指定一个包含 org.uberfire.nio.git.hooks
系统属性值的目录。此目录复制到 Git 存储库。
如果您指定了 org.uberfire.nio.git.hooks
系统属性,则所有 Business Central 内部存储库和项目存储库都使用 post-commit Git hook。您应该只在脚本中使用完全限定路径。
先决条件
- Red Hat Process Automation Manager 安装在 Red Hat JBoss EAP 7.3 服务器实例中。
-
(对于 Windows 操作系统)Cygwin 安装在安装过程中添加的 Git 软件包,Cygwin
/bin
文件夹添加到您的环境PATH
变量中。例如:C:\cygwin64\bin
。有关 Cygwin 安装的更多信息,请参阅 安装和更新 Cygwin 软件包。
流程
在本地系统的目录中创建 post-commit Git hook。
有关创建提交后 Git hook 的更多信息,请参阅 第 43.1 节 “创建提交后 Git hook”。
要指定带有
org.uberfire.nio.git.hooks
系统属性值的 hook 文件的目录,请执行以下操作之一:将
org.uberfire.nio.git.hooks
系统属性添加到standalone.xml
文件中。例如:<system-properties> <property name="org.uberfire.nio.git.hooks" value="_EAP_HOME_/hooks"> </property> ... </system-properties>
在执行 Business Central 时,请使用
-Dorg.uberfire.nio.git.hooks
环境变量。例如:$ ./standalone.sh -c standalone-full.xml -Dorg.uberfire.nio.git.hooks=_EAP_HOME_/hooks
启动 Business Central。
post-commit Git hook 复制到所有 Business Central 内部存储库和项目存储库中。
其他资源
43.5. 集成远程 Git 存储库
在以下示例中,您可以使用 post-commit Git hook 和 Java 代码将 Business Central 与远程 Git 存储库集成。有关 Java 代码示例,请参阅 Business Central post-commit Git Hooks Integration。这个示例提供以下功能:
-
自动生成模板
.gitremote
配置文件 -
为所需参数验证
.gitremote
配置文件 -
Git 忽略
.gitremote
文件的 ignore 参数中定义的模式 - 向用户发送的消息和通知输出
- 支持 GitLab 和 GitHub 令牌身份验证
- 支持 GitLab 组和子组项目创建
- 支持 GitHub 机构存储库创建
先决条件
- Red Hat Process Automation Manager 安装在 Red Hat JBoss EAP 7.3 服务器实例中。
- 安装了 Java Development Kit (JDK) 8。
- 已安装 Maven。
流程
在终端窗口中,将 GitHub 存储库克隆到您的系统:
$ git clone https://github.com/kiegroup/bc-git-integration-push.git
进入克隆的存储库:
$ cd bc-git-integration-push
执行 Maven 全新安装:
$ mvn clean install
在
EAP_HOME
目录中创建一个/hooks
文件夹:$ mkdir -p _EAP_HOME_/hooks/
将
git-push-2.1-SNAPSHOT.jar
复制到EAP_HOME/hooks/
文件夹:$ cp bc-git-integration-push/target/git-push-2.1-SNAPSHOT.jar _EAP_HOME_/hooks/
可选: 要创建模板
.gitremote
配置文件,请运行git-push-2.1-SNAPSHOT.jar
:$ java -jar git-push-2.1-SNAPSHOT.jar
模板
.gitremote
配置文件示例#This is an auto generated template empty property file provider=GIT_HUB login= password= token= remoteGitUrl=https://api.github.com/ useSSH=false ignore=.*demo.*, test.* githubOrg=OrgName gitlabGroup=Group/subgroup
修改
.gitremote
配置文件参数。表 43.1. .gitremote 参数示例 参数 描述 provider
Git 提供程序。只接受两个值: GIT_HUB 和 GIT_LAB。必填
login
Git 提供程序的用户名。必填
password
纯文本密码。如果提供了
令牌
,则不需要。token
生成的令牌来替换基于
不安全连接
。注:如果没有设置警告,则会显示您使用不安全的连接。如果提供了的用户名和密码
密码
,则不需要。注: GitLab 只支持令牌身份验证。remoteGitUrl
公共供应商 URL 或任何供应商的本地托管企业。必需。注: 公共 GitHub URL 应该是 API URL。例如: api.github.com。
useSSH
布尔值,以允许 SSH 协议将更改推送到远程存储库。可选。默认 = false。注意:此参数使用本地
~/.ssh/
目录来获取 SSH 配置。ignore
以逗号分隔的正则表达式,用于忽略与这些表达式匹配的项目名称。可选。
githubOrg
如果 GitHub 用作提供程序,则定义存储库组织。可选。
gitlabGroup
如果 GitLab 用作供应商可选,则定义存储库组和子组。
在
EAP_HOME/hooks
中创建post-commit
Git hook 文件:$ touch post-commit
将
post-commit
文件的权限设置为755
:$ chmod 755 post-commit
添加
192.168.1.0/24!/bin/bash
和 code,将git-push-2.1-SNAPSHOT.jar
添加到post-commit
文件中:$ echo "#\!/bin/bash\njava -jar $APP_SERVER_HOME/hooks/git-push-2.1-SNAPSHOT.jar" > hooks/post-commit
使用
-Dorg.uberfire.nio.git.hooks
环境变量启动 Business Central。例如:$ ./standalone.sh -c standalone-full.xml -Dorg.uberfire.nio.git.hooks=_EAP_HOME_/hooks
要使用执行 Java 代码的 post-commit Git hook,您必须使用以下 Java 库:
- jgit :用于与内部 Business Central Git 存储库交互。
- 用于 Java 的 GitHub API :用于与 GitHub 通信。
有关提交 Git hook 和 Java 代码示例的更多信息,请参阅 Business Central post-commit Git Hooks 集成。
43.6. Git hook 退出代码
当 Git hook 退出一个整数值时,会返回决定 Git hook 执行的状态。这个整数值称为 Git hook 退出代码。执行状态可以是成功(1),警告(2 到 30)或错误(31 到 7000。
43.7. 自定义 Git hook 通知
Business Central 提供了一种机制,允许用户根据 hook 退出代码接收自定义 Git hook 通知。
要启用通知机制,您必须创建一个包含自定义消息的 192.168.1.0/24 properties
文件,然后将该文件的路径指定为 appformer.git.hooks.bundle
系统属性的值。
流程
创建
192.168.1.0/24properties
文件,并为每个退出代码添加一行,并以以下格式对应的消息:<exit_code>=<display_message>
是 Git hook 退出代码,&
lt;display_message
> 是用户显示的自定义信息。<exit_code>
例如:
0=Success! All working as expected. 1=Warning! Please check the logs and advise your admin. . . 31=Error! Please advise your admin immediately.
注意不需要在 192.168.1.0/24properties 文件中定义所有可能的退出代码。通知仅针对在 sVirtproperties 文件中定义的退出代码出现。
重要通知服务只支持属性文件中设置的
ISO 8859-1
(LATIN 1
)字符。如果要使用扩展字符,请使用其转义的 Unicode 字符代码序列。要启用 Git hook 通知,请将文件的路径指定为
appformer.git.hooks.bundle
系统属性的值。请参阅以下指向
Messages.properties
文件的设置的standalone.xml
文件示例:<system-properties> <property name="appformer.git.hooks.bundle" value="/opt/jboss-as/git-hooks-messages/Messages.properties"> </property> ... </system-properties>
43.7.1. Business Central 中的 Git hook 通知
您可以在 Business Central 中查看 Git hook 通知。Git hook 退出代码通知类型有三个。
退出代码 | 自定义消息 | UI 通知颜色 |
---|---|---|
| 成功!所有工作都按预期工作。 | 绿色 |
| 警告!请检查日志并建议您的管理员。 | orange |
| 错误!请立即建议您的管理员。 | 红色 |
UNIX 机器只支持 0 (success)到 255 (错误),此范围之外的任何退出代码都将转换为不同的代码,这可能会导致错误的通知消息。
Windows 机器没有这个限制,并支持大量退出代码。
43.7.2. Git hook 通知国际化支持
您可以将其他属性文件放在与 appformer.git.hooks.bundle
系统属性中指定的原始属性文件相同的路径中,以国际化通知消息。
不同本地化文件的名称必须是 < filename>_<lang>.properties
,其中 <filename
> 与原始文件的名称相同。例如,如果系统属性指向 Messages.properties
,您可以为英语创建 Messages_en.properties
,为法语创建 Messages_fr.properties
,或用于意大利语的 Messages_it.properties
。
如果该语言没有可用于该语言,则通知服务将根据用户的语言选择属性文件,它将使用原始 Messages.properties
文件中的条目。
第 44 章 在 Business Central 中对分支的基于角色的访问控制
Business Central 为用户提供了特定协作器类型的目标分支的访问权限。安全检查使用 安全管理屏幕和 专家源来授予或拒绝空格和项目的权限。例如,如果用户有更新项目的安全权限,并且根据方法类型具有对该分支的写入权限,则他们能够创建新的资产。
44.1. 自定义基于角色的分支访问
您可以为 Business Central 中项目的每个分支自定义计费角色权限。例如,您可以为分配给分支的每个角色设置 Read,Write,Delete, 和 Deploy 访问权限。
流程
- 在 Business Central 中,进入 Menu → Design → Projects。
如果需要,请添加新的技术:
- 点项目名称,然后点 Contributors 选项卡。
- 点 Add Contributor。
- 在文本字段中输入用户名。
- 从下拉列表中选择 Contributor 角色类型。
- 点 确定。
为相关人员自定义基于角色的分支访问:
- 点 Settings → Branch Management。
- 从下拉列表中选择分支名称。
- 在 Role Access 部分中,选择或取消选择权限复选框,为每个可用角色类型指定基于角色的分支访问权限。
- 单击 Save,然后再次点击 Save 以确认您的更改。
第 45 章 查看进程实例日志
您可以从其 Logs 选项卡中查看实例的所有进程事件。实例日志列出所有当前和以前的进程状态。Business Central 有两个类型的日志,用于进程实例: 业务和技术 日志。
流程
- 在 Business Central 中,进入 Menu → Manage → Process Instances。
- 在 Manage Process Instances 页面上,单击您要查看其日志的进程实例。
选择 Logs 选项卡:
- 点 Business 查看业务事件日志。
- 点 tech 查看技术事件日志。
- 点 Asc 或 Desc 以更改日志文件的顺序。
第 46 章 Business Central 系统属性
本节中列出的 Business Central 系统属性将传递到 standalone thexml
文件。
- Git 目录
使用以下属性为 Business Central Git 目录设置位置和名称:
-
org.uberfire.nio.git.dir
: Business Central Git 目录的位置。 -
org.uberfire.nio.git.dirname
: Business Central Git 目录的名称。默认值:.niogit
。 -
org.uberfire.nio.git.ketch
: 启用或禁用 Git ketch。 -
org.uberfire.nio.git.hooks
: Git hook 目录的位置。
-
- Git over HTTP
使用以下属性通过 HTTP 配置对 Git 存储库的访问:
-
org.uberfire.nio.git.proxy.ssh.over.http
: 指定 SSH 是否应该使用 HTTP 代理。默认值:false
。 -
http.proxyHost
:定义 HTTP 代理的主机名。默认值:null
. -
http.proxyPort
:定义 HTTP 代理的主机端口(整数值)。默认值:null
. -
http.proxyUser
:定义 HTTP 代理的用户名。 -
http.proxyPassword
:定义 HTTP 代理的用户密码。 -
org.uberfire.nio.git.http.enabled
: 启用或禁用 HTTP 守护进程。默认值:true
。 -
org.uberfire.nio.git.http.host
:如果启用了 HTTP 守护进程,它将此属性用作主机标识符。这是一个信息性属性,用于显示如何通过 HTTP 访问 Git 存储库。HTTP 仍然依赖于 servlet 容器。默认值:localhost
。 -
org.uberfire.nio.git.http.hostname
:如果启用了 HTTP 守护进程,它将此属性用作主机名标识符。这是一个信息性属性,用于显示如何通过 HTTP 访问 Git 存储库。HTTP 仍然依赖于 servlet 容器。默认值:localhost
。 -
org.uberfire.nio.git.http.port
:如果启用了 HTTP 守护进程,它将此属性用作端口号。这是一个信息性属性,用于显示如何通过 HTTP 访问 Git 存储库。HTTP 仍然依赖于 servlet 容器。默认值:8080
。
-
- Git over HTTPS
使用以下属性通过 HTTPS 配置对 Git 存储库的访问:
-
org.uberfire.nio.git.proxy.ssh.over.https
: 指定 SSH 是否使用 HTTPS 代理。默认值:false
。 -
https.proxyHost
:定义 HTTPS 代理的主机名。默认值:null
. -
https.proxyPort
:定义 HTTPS 代理的主机端口(整数值)。默认值:null
. -
https.proxyUser
:定义 HTTPS 代理的用户名。 -
https.proxyPassword
:定义 HTTPS 代理的用户密码。 -
user.dir
:用户目录的位置。 -
org.uberfire.nio.git.https.enabled
: 启用或禁用 HTTPS 守护进程。默认值:false
-
org.uberfire.nio.git.https.host
:如果启用了 HTTPS 守护进程,它将此属性用作主机标识符。这是一个信息性属性,用于显示如何通过 HTTPS 访问 Git 存储库。HTTPS 仍依赖于 servlet 容器。默认值:localhost
。 -
org.uberfire.nio.git.https.hostname
:如果启用了 HTTPS 守护进程,它将此属性用作主机名标识符。这是一个信息性属性,用于显示如何通过 HTTPS 访问 Git 存储库。HTTPS 仍依赖于 servlet 容器。默认值:localhost
。 -
org.uberfire.nio.git.https.port
:如果启用了 HTTPS 守护进程,它将此属性用作端口号。这是一个信息性属性,用于显示如何通过 HTTPS 访问 Git 存储库。HTTPS 仍依赖于 servlet 容器。默认值:8080
。
-
- JGit
-
org.uberfire.nio.jgit.cache.instances
: 定义 JGit 缓存大小。 -
org.uberfire.nio.jgit.cache.overflow.cleanup.size
: 定义 JGit 缓存溢出清理大小。 -
org.uberfire.nio.jgit.remove.eldest.iterations
: 启用或禁用是否删除 eldest JGit iterations。 -
org.uberfire.nio.jgit.cache.evict.threshold.duration
: 定义 JGit 驱除阈值持续时间。 -
org.uberfire.nio.jgit.cache.evict.threshold.time.unit
: 定义 JGit 驱除阈值时间单位。
-
- Git 守护进程
使用以下属性启用和配置 Git 守护进程:
-
org.uberfire.nio.git.daemon.enabled
: 启用或禁用 Git 守护进程。默认值:true
。 -
org.uberfire.nio.git.daemon.host
:如果启用了 Git 守护进程,它将此属性用作本地主机标识符。默认值:localhost
。 -
org.uberfire.nio.git.daemon.hostname
:如果启用了 Git 守护进程,它将此属性用作本地主机名标识符。默认值:localhost
-
org.uberfire.nio.git.daemon.port
:如果启用了 Git 守护进程,它将此属性用作端口号。默认值:9418
. org.uberfire.nio.git.http.sslVerify
: 启用或禁用 Git 存储库的 SSL 证书检查。默认值:true
。注意如果默认值或分配的端口已在使用中,则会自动选择一个新端口。确保端口可用,并检查日志以了解更多信息。
-
- Git SSH
使用以下属性启用和配置 Git SSH 守护进程:
-
org.uberfire.nio.git.ssh.enabled
: 启用或禁用 SSH 守护进程。默认值:true
。 -
org.uberfire.nio.git.ssh.host
:如果启用了 SSH 守护进程,它将此属性用作本地主机标识符。默认值:localhost
。 -
org.uberfire.nio.git.ssh.hostname
:如果启用了 SSH 守护进程,它将此属性用作本地主机名标识符。默认值:localhost
。 org.uberfire.nio.git.ssh.port
:如果启用了 SSH 守护进程,它将此属性用作端口号。默认值:8001
。注意如果默认值或分配的端口已在使用中,则会自动选择一个新端口。确保端口可用,并检查日志以了解更多信息。
-
org.uberfire.nio.git.ssh.cert.dir
: 存储本地证书的.security
目录的位置。默认值 :工作目录。 -
org.uberfire.nio.git.ssh.idle.timeout
: 设置 SSH idle timeout。 -
org.uberfire.nio.git.ssh.passphrase
: 当使用 SCP 风格 URL 克隆 git 存储库时用于访问操作系统的公钥存储。示例:git@github.com:user/repository.git
。 -
org.uberfire.nio.git.ssh.algorithm
: SSH 使用的算法。默认值:RSA
。 -
org.uberfire.nio.git.gc.limit
:设置 GC 限制。 -
org.uberfire.nio.git.ssh.ciphers
:以逗号分隔的密码字符串。可用的密码是aes128-ctr
,aes192-ctr
,aes256-ctr
,arcfour128,
arcfour256,
aes192-cbc
,aes256-cbc
。如果没有使用属性,则会加载所有可用的密码。 org.uberfire.nio.git.ssh.macs
: 以逗号分隔的消息身份验证代码(MAC)字符串。可用的 MAC 是hmac-md5
,hmac-md5-96
,hmac-sha1
,hmac-sha1-96
,hmac-sha2-256
,hmac-sha2-512
。如果没有使用属性,则会加载所有可用的 MAC。注意如果您计划使用 RSA 或 DSA 以外的任何算法,请确保将应用服务器设置为使用 Bouncy Castle JCE 库。
-
- KIE 服务器节点和流程自动化管理器控制器
使用以下属性配置来自 Process Automation Manager 控制器的 KIE 服务器节点的连接:
-
org.kie.server.controller
:URL 用于连接到 Process Automation Manager 控制器。例如,ws://localhost:8080/business-central/websocket/controller
。 -
org.kie.server.user
: 用于从 Process Automation Manager 控制器连接到 KIE 服务器节点的用户名。只有在将此 Business Central 安装用作 Process Automation Manager 控制器时才需要此属性。 -
org.kie.server.pwd
: 用于从 Process Automation Manager 控制器连接到 KIE 服务器节点的密码。只有在将此 Business Central 安装用作 Process Automation Manager 控制器时才需要此属性。
-
- Maven 和其它
使用以下属性来配置 Maven 和其他各种功能:
kie.maven.offline.force
:强制 Maven 的行为与离线一样。如果为 true,则禁用在线依赖项解析。默认值:false
。注意仅将此属性用于 Business Central。如果您将运行时环境与任何其他组件共享,请隔离配置并将其应用到 Business Central。
-
org.uberfire.gzip.enable
:在GzipFilter
压缩过滤器上启用或禁用 Gzip 压缩。默认值:true
。 -
org.kie.workbench.profile
:选择 Business Central 配置集。可能的值有FULL
或PLANNER_AND_RULES
。前缀FULL_
设置配置集,并从管理员首选项隐藏配置集首选项。默认值:FULL
-
org.appformer.m2repo.url
: Business Central 在查找依赖项时使用 Maven 存储库的默认位置。它将定向到 Business Central 中的 Maven 存储库,例如http://localhost:8080/business-central/maven2
。在启动 Business Central 前设置此属性。默认值 :到内部m2
存储库的文件路径。 -
appformer.ssh.keystore
:通过指定类名称来定义要与 Business Central 搭配使用的自定义 SSH 密钥存储。如果属性不可用,则使用默认的 SSH 密钥存储。 -
appformer.ssh.keys.storage.folder
:使用默认 SSH 密钥存储时,此属性定义用户的 SSH 公钥的存储文件夹。如果属性不可用,则密钥将存储在 Business Central.security
文件夹中。 -
appformer.experimental.features
:启用实验性功能框架。默认值:false
。 -
org.kie.demo
:启用来自 GitHub 的演示应用程序的外部克隆。 -
org.uberfire.metadata.index.dir
: 存储 Lucene.index
目录的 Place。默认值 :工作目录。 -
org.uberfire.ldap.regex.role_mapper
: 用来将 LDAP 主体名称映射到应用程序角色名称的 Regex 模式。请注意,变量角色必须是模式的一部分,因为应用角色名称在匹配原则值和角色名称时替换变量角色。 -
org.uberfire.sys.repo.monitor.disabled
:禁用配置监控器。不要禁用,除非您确定。默认值:false
。 -
org.uberfire.secure.key
:由密码加密使用的密码。默认值:org.uberfire.admin
。 -
org.uberfire.secure.alg
: Crypto 算法由密码加密使用。默认值:PBEWithMD5AndDES
。 -
org.uberfire.domain
: uberfire 使用的安全域名。默认值:ApplicationRealm
. -
org.guvnor.m2repo.dir
: 存储 Maven 存储库文件夹的 Place。默认值: <working-directory>/repositories/kie
。 -
org.guvnor.project.gav.check.disabled
:禁用组 ID、工件 ID 和版本(GAV)检查。默认值:false
。 -
org.kie.build.disable-project-explorer
:禁用 Project Explorer 中所选项目的自动构建。默认值:false
。 -
org.kie.builder.cache.size
:定义项目构建器的缓存大小。默认值:20
。 -
org.kie.library.assets_per_page
:您可以在项目屏幕中自定义每个页面的资产数量。默认值:15
。 -
org.kie.verification.disable-dtable-realtime-verification
: 禁用路由表的实时验证和验证。默认值:false
。
- 处理自动化管理器控制器
使用以下属性来配置如何连接到 Process Automation Manager 控制器:
-
org.kie.workbench.controller
: 用于连接到 Process Automation Manager 控制器的 URL,例如:ws://localhost:8080/kie-server-controller/websocket/controller
。 -
org.kie.workbench.controller.user
: Process Automation Manager 控制器用户。默认值:kieserver
。 -
org.kie.workbench.controller.pwd
: Process Automation Manager 控制器密码。默认值:kieserver1!
。 -
org.kie.workbench.controller.token
:用于连接 Process Automation Manager 控制器的令牌字符串。
-
- Java Cryptography Extension KeyStore (JCEKS)
使用以下属性来配置 JCEKS:
-
kie.keystore.keyStoreURL
:用于加载 Java Cryptography Extension KeyStore (JCEKS)的 URL。例如:file:///home/kie/keystores/keystore.jceks。
-
kie.keystore.keyStorePwd
:用于 JCEKS 的密码。 -
kie.keystore.key.ctrl.alias
:默认 REST Process Automation Manager 控制器的密钥别名。 -
kie.keystore.key.ctrl.pwd
:默认 REST Process Automation Manager 控制器的别名密码。
-
- 渲染
使用以下属性在 Business Central 和 KIE Server rendered 表单间切换:
-
org.jbpm.wb.forms.renderer.ext
:切换 Business Central 和 KIE 服务器之间的表单。默认情况下,表单渲染由 Business Central 执行。默认值:false
。 -
org.jbpm.wb.forms.renderer.name
: 允许您在 Business Central 和 KIE Server rendered 表单间切换。默认值:工作台
。
-
第 47 章 Business Central 的性能调优注意事项
以下主要概念或推荐做法可帮助您优化 Business Central 配置和 Red Hat Process Automation Manager 性能。本节中总结了这些概念,并在适用的情况下在跨引用文档中进行更详细的说明。本节将根据新版本的 Red Hat Process Automation Manager 根据需要扩展或更改。
- 确保开发模式在开发过程中启用
您可以在 Business Central 中设置 KIE Server 或特定项目,以使用
生产
模式或开发模式
。默认情况下,Business Central 中的 KIE 服务器和所有新项目都处于开发模式。此模式提供有助于开发体验的功能,如灵活的项目部署策略,以及优化开发过程中 KIE 服务器性能的功能,如禁用重复的 GAV 检测。使用开发模式,直到您的 Red Hat Process Automation Manager 环境建立并完全准备好在生产环境中使用。有关配置环境模式或重复的 GAV 检测的更多信息,请参阅以下资源:
- 禁用复杂指导决策表的验证和验证
Business Central 的决策表验证和验证功能会被默认启用。此功能可帮助您验证指导的决策表,但具有复杂的指导决策表,此功能可能会隐藏决策引擎性能。您可以通过将
org.kie.verification.disable-dtable-realtime-verification
系统属性值设置为true
来禁用此功能。有关指导决策表验证的更多信息,请参阅使用指导决策表设计决策服务。
- 如果您有很多大型项目,则禁用自动构建
在 Business Central 中,当您在 Project Explorer 侧面板中的项目之间导航时,会自动构建所选项目,以便 Alerts 窗口被更新以显示项目的任何构建错误。如果您在活跃开发的许多项目之间具有大型项目或经常切换,此功能可能会干扰 Business Central 和决策引擎性能。
要禁用自动项目构建,请将
org.kie.build.disable-project-explorer
系统属性设置为true
。
部分 III. 在 Business Central 中使用独立视角
作为自定义规则开发人员,您可以在 web 应用程序中的 Business Central 中嵌入独立的视角,然后使用它们编辑规则、流程、路由表和其他资产。
先决条件
- Business Central 部署并在 Web/应用程序服务器上运行。
- 您已登录到 Business Central。
第 48 章 Business Central 中的独立视角
Business Central 根据资产的格式为编写资产提供专用编辑器。Business Central 具有一项功能,可让您单独使用这些编辑器。此功能称为编辑器的独立视角模式,或者只是 独立视角。
作为自定义规则开发人员,您可以在 web 应用程序中嵌入一个单独的视角,然后使用它编辑规则、流程、决策表和其他资产。嵌入视角后,您可以在不切换到 Business Central 的情况下在自己的应用程序中编辑资产。您可以使用此功能自定义 Web 应用程序。除了独立视角外,您还可以在应用程序中嵌入独立自定义页面(仪表板)。
您可以通过在带有独立和视角参数的浏览器中使用特定的 Web 地址来访问 独立
视角
。独立视角的 Web 地址也可以包含附加参数。
第 49 章 使用独立库视角
您可以使用 Business Central 的库视角来选择您要编辑的项目。您还可以在所选项目中执行所有编写功能。
独立库视角可以通过两种方式使用,使用 header=UberfireBreadcrumbsContainer
参数。区别在于,与 标头参数的地址 会在库视角的顶部显示一个面色结尾。使用这个链接,您可以为项目创建额外的 Spaces。
流程
- 登录 Business Central。
在 Web 浏览器中,输入适当的 Web 地址:
在没有
标头
参数的情况下访问独立库视角http://localhost:8080/business-central/kie-wb.jsp?standalone=true&perspective=LibraryPerspective
独立库视角没有在浏览器中打开结尾在浏览器中打开。
使用
header
参数访问独立库视角http://localhost:8080/business-central/kie-wb.jsp?standalone=true&perspective=LibraryPerspective&header=UberfireBreadcrumbsContainer
独立库视角在浏览器中打开带有面色结尾。
第 50 章 使用独立编辑器视角
您可以使用 Business Central 的独立编辑器视角来访问特定于资产的编辑器。通过使用此视角,您可以打开资产编辑器,并根据需要修改资产。
用于访问资产独立编辑器视角的 Web 地址包含 独立
和路径
参数。path
参数必须包含资产的完整路径,Web 地址可以以 sVirt StandaloneEditorPerspective
字符串结尾。另外,通过不同的 path
参数,您可以在独立模式下访问特定资产编辑器。
流程
- 登录 Business Central。
在 Web 浏览器中,根据需要输入适当的 Web 地址,例如:
编辑进程:
http://localhost:8080/business-central/kie-wb.jsp?standalone&path=default://master@MySpace/Shop/src/main/resources/com/purchase.bpmn#StandaloneEditorPerspective
Process Designer 在独立模式中打开。
编辑表单:
http://localhost:8080/business-central/kie-wb.jsp?standalone&path=default://master@MySpace/Mortgage_Process/src/main/resources/ApplicationMortgage.frm#StandaloneEditorPerspective
Form Modeler 在独立模式中打开。
第 51 章 使用独立内容管理器视角
通过使用应用程序中的独立内容管理器视角,您可以创建并编辑应用程序的内容及其导航菜单。
流程
- 登录 Business Central。
在 Web 浏览器中,在地址栏中输入以下 Web 地址:
http://localhost:8080/business-central/kie-wb.jsp?standalone=true&perspective=ContentManagerPerspective
独立内容管理器视角会在浏览器中打开。
第 52 章 使用独立自定义页面(dashboard)
除了独立视角外,您还可以在应用程序中嵌入自定义页面,也称为仪表板。要从应用程序访问自定义页面,请提供自定义页面的名称作为 perspective
参数的值。请注意 ,
point 参数区分大小写。
流程
- 登录 Business Central。
在网页浏览器中,在地址栏中输入自定义页面的 Web 地址,例如:
http://localhost:8080/business-central/kie-wb.jsp?standalone=true&perspective=CustomPageName
独立自定义页面在浏览器中打开。将值 CustomPageName 替换为您要在独立模式中使用的自定义页面的名称。
部分 IV. 在 Business Central 中创建自定义页面
作为业务公司或业务规则开发人员,您可以使用 Business Central 中的 Page Editor 来创建静态页面和动态仪表板,以显示有关项目的特定信息。仪表板是至少包含一个动态报告组件的页面集合。您可以定义数据集以提供仪表板报告组件。您可以将仪表板导出到 Red Hat JBoss EAP 上的独立 Dashbuilder Runtime dashboard viewer 或 Red Hat OpenShift Container Platform 上的 Dashbuilder Standalone 仪表板视图。
先决条件
- 您以有权编辑页面的用户身份登录 Business Central。
第 53 章 Business Central 自定义仪表板
仪表板是包含至少一个报告组件的 Business Central 页面的集合。仪表板通常包含数据集、导航树和权限。
创建自定义仪表板时有四个阶段:
其他资源
要从之前的 Business Central 版本迁移仪表板,请使用 第 58.1 节 “导出 Business Central 仪表板数据” 中描述的 Dashbuilder Data Transfer 功能。
第 54 章 Dashbuilder Runtime 和 Dashbuilder Standalone
Dashbuilder Runtime 和 Dashbuilder Standalone 是可用于查看从 Business Central 创建和导出的仪表板的附加组件。这可用于检查没有 Business Central 的环境中的商业指标。Dashbuilder 运行时可用于在红帽 JBoss EAP 上安装。您可以在 Red Hat OpenShift Container Platform 上独立部署 Dashbuilder Standalone。
在 Dashbuilder Runtime 和 Dashbuilder Standalone 中的仪表板页面之间导航与创建仪表板的 Business Central 实例中的导航相同。如果页面属于某个组,则该组将导入到 Dashbuilder Runtime 或 Dashbuilder Standalone 以及页面。如果页面导入到 Dashbuilder Runtime 或 Dashbuilder Standalone,但没有在导航中使用,则该页面将添加到 Runtime Dashboards 菜单组中。如果没有导出导航,则会将所有页面添加到 Runtime Dashboards 菜单组中。
54.1. 在 Red Hat JBoss EAP 上安装 Dashbuilder 运行时
要安装 Dashbuilder Runtime,请下载 Dashbuilder Runtime WAR 并创建一个具有 admin
角色的用户。
先决条件
- 您已安装了 Red Hat JBoss EAP。
- 您已在 Business Central 中创建并导出了仪表板。有关导出 Dashbuilder 数据的更多信息,请参阅配置 Business Central 设置和属性 指南中的 "Exporting and import Dashbuilder data" 部分。
流程
导航到红帽客户门户网站中的 Software Downloads 页面(需要登录),然后从下拉菜单中选择产品和版本:
- 产品 : 流程自动化管理器
- Version: 7.11
-
下载 Red Hat Process Automation Manager 7.11.0 Add Ons (
rhpam-7.11.0-add-ons.zip
)并提取 ZIP 文件。 -
导航到包含提取文件的目录,并提取
rhpam-7.11.0-dashbuilder-runtime.zip
文件。 -
复制您提取到 <
EAP_HOME>/standalone/deployments
文件夹的dashbuilder-runtime.zip
文件的内容,其中 <EAP_HOME
> 是包含 Red Hat JBoss EAP 安装的 Red Hat JBoss EAP 主目录。 在 Red Hat JBoss EAP 主目录中,输入以下命令创建具有
admin
角色的用户并指定密码。在以下示例中,将 <USER_NAME&
gt; 和 <PASSWORD
> 替换为您选择的用户名和密码。$<EAP_HOME>/bin/add-user.sh -a -e -u <USER_NAME> -p <PASSWORD> -g admin
-
在终端应用中,导航到
EAP_HOME/bin
。 输入以下命令启动 Red Hat JBoss EAP:
在 Linux 或基于 UNIX 的系统上:
$ ./standalone.sh -c standalone-full.xml
对于 Windows:
standalone.bat -c standalone-full.xml
-
在 Web 浏览器中,打开 URL
http://localhost:8080
。 - 使用您为 Dashbuilder Runtime 创建的用户的凭证登录。
- 当 promted 时,上传您从 Business Central 导出的仪表板。Dashbuilder Runtime 将使用该仪表板,直到重启为止。
54.1.1. Dashbuilder 运行时系统属性
您可以使用系统属性自定义 Dashbuilder 运行时。
- 仪表板路径
当仪表板上传时,它将存储在文件系统中。存储的路径由系统属性
dashbuilder.import.base.dir
控制。默认值为/tmp/dashbuilder
。系统属性是任何仪表板模型的根路径。例如,如果此路径上有多个文件,可以通过访问 Dashbuilder Runtime 并使用应加载的文件的名称传递查询参数导入。例如,如果要加载
Sales_dashboard
,请执行runtime_host?import=sales_dashboard
和 Dashbuilder Runtime 将尝试加载文件/tmp/dashbuilder/sales_dashboard.zip
。- 静态仪表板
-
如果您希望运行时实例加载特定的仪表板,您可以更改系统属性
dashbuilder.runtime.import
。将属性设置为本地文件路径将导致在运行时启动期间加载特定的仪表板。 - 控制上传大小
-
默认情况下,应用服务器控制 POST 请求大小。您可以使用系统属性
dashbuilder.runtime.upload.size
来控制上传的仪表板的允许大小。其大小应该为 KB,默认情况下,值为 96kb,这意味着如果某人尝试上传大于 96kb 的文件,则会显示错误,且不会安装仪表板。 - Dashbuilder 运行时中的默认页面
在 Dashbuilder Runtime 中导入的仪表板包含一个默认页面。以下列表提供了 Dashbuilder Runtime 默认页面的更新概述:
- 当导入的仪表板仅包含一个页面时,它将用作默认页面。
-
如果页面命名为
index
,则会将其用作默认页面。 - 在其他情况下,使用 Dashbuilder Runtime 的通用主页。
- 加载外部仪表板
位于可访问 URL 的 Dashboard 可以被 Dashbuilder Runtime 访问。您可以使用导入查询参数(如
runtime_host?import=http://filesHost/sales_dashboard.zip
)传递 URL 来访问 URL。注意出于安全考虑,默认禁用这个选项。您可以通过将系统属性
dashbuilder.runtime.allowExternal
设置为 true 来启用它。
54.2. 在 Red Hat OpenShift Container Platform 上部署 Dashbuilder Standalone
您可以使用 Dashbuilder Standalone 查看在 OpenShift 中创建并从 Business Central 中创建的仪表板。这可用于检查没有 Business Central 的环境中的商业指标。使用 Dashbuilder Standalone operator,独立于其他服务在 Red Hat OpenShift Container Platform 上部署 Dashbuilder Standalone。
先决条件
- OpenShift 注册表中提供了 Dashbuilder Standalone。
- 您已准备了 OpenShift 环境,如 使用 Operator 在 Red Hat OpenShift Container Platform 4 上部署 Red Hat Process Automation Manager 环境 中所述。
- 您已在 Business Central 中创建并导出了仪表板。
流程
- 在 Operator 安装 页面中,在 Application name 字段中输入应用程序的名称。
-
在 Environment 字段中输入您的环境的名称,如
rhpam-standalone-dashbuilder
。 - 点击 Next。
- 可选:在 Security 页面中,配置 LDAP 或红帽单点登录。
- 在 Components 页面中,从 Components 列表中选择 Dashbuilder。
要添加 KIE Server 数据集,请完成以下任务:
注意您可以通过重复此步骤来添加额外的 KIE Server 数据集。
- 点 Add new KIE Server DataSets。
-
在 DataSet name 字段中,输入
kieserver-1
。 -
在 Kie Server Location 字段中输入 KIE 服务器的位置,例如
https://my-kie-server:80/services/rest/server
。 要设置凭证,请完成以下任务之一:
- 如果您没有设置令牌,请在 Username 和 Password 字段中输入您的用户名和密码。将 Token 字段留空。
如果您有令牌,在 Token 字段中输入您的令牌。将 Username 和 Password 字段留空。
自定义资源示例:
apiVersion: app.kiegroup.org/v2 kind: KieApp metadata: name: standalone-dashbuilder spec: environment: rhpam-standalone-dashbuilder objects: dashbuilder: config: kieServerDataSets: - name: kieserver-1 location: 'https://my-kie-server:80/services/rest/server' user: kieserverAdmin password: kieserverAdminPwd replaceQuery: true
要添加 KIE Server 模板,请完成以下任务:
注意您可以通过重复此步骤来添加额外的 KIE Server 模板。
- 点 Add new KIE Server Templates。
-
在 Template name 字段中输入模板的名称,如
kieserver-template
。 -
在 KIE Server Location 字段中输入 KIE 服务器的位置,例如
https://my-other-kie-server:80/services/rest/server
。 要设置凭证,请完成以下任务之一:
- 如果您没有设置令牌,请在 Username 和 Password 字段中输入您的用户名和密码。将 Token 字段留空。
如果您有令牌,在 Token 字段中输入您的令牌。将 Username 和 Password 字段留空。
apiVersion: app.kiegroup.org/v2 kind: KieApp metadata: name: standalone-dashbuilder spec: environment: rhpam-standalone-dashbuilder objects: dashbuilder: config: kieServerDataSets: - name: kieserver-1 location: 'https://my-kie-server:80/services/rest/server' user: kieserverAdmin password: kieserverAdminPwd replaceQuery: true kieServerTemplates: - name: kieserver-template location: 'https://my-another-kie-server:80/services/rest/server' user: user password: pwd replaceQuery: true
54.2.1. Dashbuilder 独立环境变量
在 operator 中使用 Dashbuilder Container Image 时,您可以使用环境变量或通过自定义资源配置 Dashbuilder。
参数 | 等同的环境变量 | 描述 | 示例值 |
---|---|---|---|
|
| 允许下载外部(远程)文件。默认值为 false。 | False |
|
| 启用外部组件。 | true |
|
| 根据 Runtime Model ID 启用组件分区。默认值为 true。 | true |
|
| 允许使用带有 Dashbuilder 配置的属性文件。附加唯一属性,如果设置属性一次,则会使用属性文件中的一个属性。 | true |
|
| 根据运行时模型 ID 启用数据集 ID 分区。默认值为 true。 | true |
| — | 通过自动配置 Business Central 和 Dashbuilder 来启用与 Business Central 集成。仅在 operator 上可用。 | true |
| — | 通过自动配置 KIE 服务器和 Dashbuilder 来启用与 KIE 服务器集成。仅在 operator 上可用。 | true |
|
|
设置存储仪表板 ZIP 文件的基础目录。如果启用了 | — |
|
| 将静态仪表板设置为自动运行。如果设置了此属性,则不允许导入。 | — |
|
|
设置存储仪表板 ZIP 文件的基础目录。如果启用了 | — |
|
| 定义 KIE 服务器数据集访问配置。 | — |
|
| 定义 KIE 服务器模板访问配置。 | — |
|
| 启用从文件系统中自动删除模型文件。默认值为 false。 | False |
|
| 允许 Runtime 检查文件系统中最后一次更新的模型以更新内容。默认值为 true。 | true |
| `` |
将 Dashbuilder 设置为非临时。如果设置了 | true |
|
| 允许运行时允许导入(多租户)。默认值为 false。 | False |
|
| 为仪表板上传设置大小限制(以 kb 为单位)。默认值为 10485760 kb。 | 10485760 |
| — | 代表容器中存在的环境变量。 | — |
您可以使用 env
属性设置环境变量。以下示例将 DASHBUILDER_UPLOAD_SIZE
属性的值设置为 1000
。
apiVersion: app.kiegroup.org/v2 kind: KieApp metadata: name: standalone-dashbuilder spec: environment: rhpam-standalone-dashbuilder objects: dashbuilder: env: - name: DASHBUILDER_UPLOAD_SIZE value: '1000'
第 55 章 数据集编写
数据集是一组相关信息集合,可以存储在数据库中、Microsoft Excel 文件中或内存中。数据集定义指示 Business Central 方法访问、读取和解析数据集。Business Central 不存储数据。它可让您定义对数据集的访问,无论存储数据是什么。
例如,如果数据存储在数据库中,则有效数据集可以包含整个数据库或数据库的子集,因为 SQL 查询。在这两种情况下,数据都用作 Business Central 报告组件的输入,然后显示信息。
要访问数据集,您必须创建并注册数据集定义。数据集定义指定数据集的位置、访问它的选项、读取和解析它,以及其包含的列。
Data Sets 页面仅对具有 admin 角色的用户可见。
55.1. 添加数据集
您可以创建一个数据集来从外部数据源获取数据,并将这些数据用于报告组件。
流程
在 Business Central 中,前往 Admin → Data Sets。
此时会打开 Data Sets 页面。
点 New Data Set 并选择以下供应商类型之一:
- bean: 从 Java 类生成数据集
- CSV: 从远程或本地 CSV 文件生成数据集
- SQL : 从 ANSI-SQL 兼容数据库生成数据集
- Elastic Search: 从 Elastic Search 节点生成数据集
- Prometheus : 使用 Prometheus 查询生成数据集
Kafka: 使用 Kafka 代理、消费者或制作者的指标生成数据集
注意您必须为 Prometheus、Kafka 和 Execution Server 选项配置 KIE 服务器。
完成 Data Set Creation 向导,再点 Test。
注意配置步骤因您选择的供应商而异。
- 点击 Save。
55.2. 编辑数据集
您可以编辑现有的数据集,以确保向报告组件获取的数据是最新的。
流程
在 Business Central 中,前往 Admin → Data Sets。
Data Set Explorer 页面将打开。
- 在 Data Set Explorer 窗格中,搜索您要编辑的数据集,选择数据集,然后点 Edit。
在 Data Set Editor 窗格中,使用适当的选项卡根据需要编辑数据。选项卡根据您选择的数据集供应商类型而有所不同。
例如,以下更改适用于编辑 CSV 数据供应商:
- CSV 配置 : 允许您更改数据集定义、源文件、分隔符和其他属性的名称。
预览: 允许您预览数据。在 CSV Configuration 选项卡中点 Test 后,系统会执行数据集查找调用,如果数据可用,则会出现预览。请注意,Preview 选项卡有两个子选项卡:
- data 列: 允许您指定哪个列是数据集定义的一部分。
- filter : 允许您添加新过滤器。
advanced : 允许您管理以下配置:
- Cache : 如需更多信息,请参阅缓存数据。
- 缓存生命周期 允许您指定刷新数据集(或数据)的时间间隔。当后端 数据更改时,对过时的数据功能的 Refresh 会刷新缓存的数据。
- 进行必要的更改后,单击 Validate。
- 点击 Save。
55.3. 数据刷新
数据刷新功能允许您指定数据集(或数据)刷新的时间间隔。您可以访问数据集 的高级 选项卡上的数据刷新每个 功能。当后端 数据更改时,对过时的数据功能的 Refresh 会刷新缓存的数据。
55.4. 缓存数据
Business Central 提供缓存机制,用于存储数据集并使用内存数据执行数据操作。缓存数据可减少网络流量、远程系统有效负载和处理时间。为了避免性能问题,请在 Business Central 中配置缓存设置。
对于导致数据集的任何数据查找调用,缓存方法决定数据查找调用的位置以及存储结果的数据集的位置。数据查找调用的一个示例是所有其 locale 参数设置为"Urban"的应用程序。
Business Central 数据集功能提供两个缓存级别:
- 客户端级别
- 后端级别
您可以在 数据集 的高级 标签页 上设置客户端缓存和后端缓存设置。
客户端缓存
打开缓存后,数据集会在查找操作过程中缓存到 Web 浏览器中,而进一步的查找操作不会对后端执行请求。数据集操作,如分组、聚合、过滤和排序在 Web 浏览器中处理。仅在数据集大小太小时才启用客户端缓存,例如,对于小于 10 MB 的数据集。对于大型数据集,可能会出现浏览器问题,如性能下降或间歇性。客户端缓存可减少后端请求数量,包括对存储系统的请求。
后端缓存
启用缓存后,决策引擎会缓存数据集。这可减少到远程存储系统的后端请求数。所有数据集操作都在决策引擎中使用内存数据执行。仅在数据集大小没有频繁更新且可以存储并处理在内存中时才启用后端缓存。在远程存储出现低延迟连接问题时,使用后端缓存也很有用。
Data Set Editor 的高级标签页中不会看到 后端缓存 设置,因为 Java 和 CSV 数据供应商依赖于后端缓存(数据集必须在内存中),以便使用内存决策引擎解析任何数据查找操作。
55.5. 带有 Dashbuilder 运行时和 Dashbuilder Standalone 的 KIE 服务器数据集
数据集是相关信息的集合。如果您有一个包含导入的数据集的 KIE 服务器,您可以使用 Dashbuilder Runtime 或 Dashbuilder Standalone 和 KIE Server REST API 在导入的数据集上运行查询。
由于 KIE 服务器使用 Business Central 作为控制器,所以 KIE 服务器容器是在 Business Central 中创建的。数据集也在 Business Central 中创建。KIE 服务器配置是一个模板,您可以在创建数据集或安装容器时引用该模板。
其他服务(如 Dashbuilder Runtime 和 Dashbuilder Standalone)使用 KIE Server REST API 来检索 KIE 服务器信息。Dashbuilder Runtime 和 Dashbuilder Standalone 访问 KIE Server REST API,以便从数据集运行查询。
当在 Business Central 中创建 KIE Server 数据集时,会提供服务器模板信息,并由 Dashbuilder Runtime 和 Dashbuilder Standalone 用于查找 KIE 服务器信息。例如:
dashbuilder.kieserver.serverTemplate.{SERVER_TEMPLATE}.location={LOCATION} dashbuilder.kieserver.serverTemplate.{SERVER_TEMPLATE}.user={USER} dashbuilder.kieserver.serverTemplate.{SERVER_TEMPLATE}.password={PASSWORD} dashbuilder.kieserver.serverTemplate.{SERVER_TEMPLATE}.token={TOKEN}
您还可以为每个数据集设置 KIE 服务器。例如:
dashbuilder.kieserver.dataset.{DATA_SET_NAME}.location={LOCATION} dashbuilder.kieserver.dataset.{DATA_SET_NAME}.user={USER} dashbuilder.kieserver.dataset.{DATA_SET_NAME}.password={PASSWORD} dashbuilder.kieserver.dataset.{DATA_SET_NAME}.token={TOKEN}
如果提供了凭证,则不会使用令牌身份验证。
您可能希望针对另一个 KIE 服务器安装运行仪表板。当在开发环境中的 KIE 服务器上创建数据集时,会在开发 KIE 服务器上创建数据集查询,如 DEV。如果仪表板导出到生产环境,如 SVVP,具有不同的 KIE 服务器,您在 DEV 中创建的查询将不可用,因此会抛出错误。在这种情况下,可以通过服务器模板或数据集从数据集到另一个 KIE 服务器的端口查询使用替换查询功能:
服务器模板示例:
dashbuilder.kieserver.serverTemplate.{SERVER_TEMPLATE}.replace_query=true
数据集示例:
dashbuilder.kieserver.dataset.{DATA_SET_NAME}.replace_query=true
replace_query=true 属性
只需要设置一次,以便 Dashbuilder Runtime 或 Dashbuilder Standalone 创建查询。创建查询后,您可以删除此系统属性。
第 56 章 页面编写
页面是以下组件的集合:
- 核心组件
- 导航组件
- 报告组件
- heatmaps
另外,页面可以没有或任意数量的组件。Page Editor 工具用于编辑页面。
页面具有 Fluid 风格或 Page 风格。当页面超过可用高度时,Fl uid 风格是一个分类网页,带有垂直滚动条。Page 风格是一个网页,将始终适合窗口高度。
56.1. 创建页面
您可以使用 Pages 视角创建由不同类型的组件组成的页面。创建页面及其定义中的所有组件后,根据需要使用 Page Editor 保存、删除、重命名或复制页面。
以下流程描述了如何创建页面并为其添加所需的组件:
流程
- 在 Business Central 中,进入 Menu → Design → Pages。
- 在 Pages 面板中,单击 New。或者,单击 Page Editor 窗格中的 New Page。
- 在 New Page 对话框中,在 Name 字段中输入一个值,然后选择所需的样式。
- 点 确定。新页面将在 Page Editor 中打开。
- 在 Components 窗格中,展开组件并将所需的组件类型拖到编辑器 canvass 中。
- 将组件放在页面中后,从 Properties 窗格中编辑其属性。
- 点 Save,然后再次点 Save。
56.2. 保存、删除、重命名或复制页面
创建并定义了页面后,根据需要使用 Page Editor 保存、删除、重命名或复制页面。
流程
- 在 Business Central 中,进入 Menu → Design → Pages。
- 从 Pages 面板中选择一个页面。该页面在 Page Editor 中打开。
- 执行所需的操作,然后从 Page Editor 右上角的 Save、Delete、Rename 或 Copy 选择 Save、Delete、Rename 或 Copy。
图 56.1. 保存、删除、重命名或复制页面

56.3. 导航树
Workbench 导航树包含 Business Central 的 Main 菜单中显示的条目。对此导航树结构的更改将反映在 Home 页面中的主菜单中。例如,可以使用此类机制来发布新页面。
此外,也可以创建额外的导航树。这些自定义树可用于在页面中配置导航组件。您无法从导航面板中删除 Workbench 树,但您可以编辑 Workbench 树层次结构以满足您的要求。此功能可帮助用户使用新页面自定义 Business Central 的 Main 菜单。
Workbench 树(默认显示在导航面板中)是 Business Central 的 Main 菜单。
56.4. 组件
页面包含不同类型的组件。您可以使用 Components 面板在页面中使用以下组件类型:
- 核心组件
- 导航组件
- 报告组件
- heatmap 组件
56.4.1. 核心组件
您可以使用核心组件 指定自定义 HTML 信息或显示现有页面。核心组件有三种类型:
核心组件不是强制的。
核心组件子类型 | 描述 |
---|---|
HTML | 此组件打开 HTML 编辑器小部件,用于使用文本、镜像、表、链接和颜色创建 HTML 页面。如果需要,您还可以自定义 HTML 页面。 |
页面 | 此组件允许您将之前创建的 HTML 页面添加到新仪表板中。您可以使用此组件嵌套您在仪表板中创建的自定义页面。 |
logo | 此组件允许您在页面中添加镜像。要在页面中添加镜像,您可以为镜像提供 URL,并根据您的要求设置镜像的宽度和高度。默认镜像是 Dashbuilder 的徽标。徽标 URL 字段是必需的。 |
56.4.3. 报告组件
Reporting 组件以图形、表、映射的形式显示数据集中的数据。报告组件有正常类型。有关数据集的更多信息,请参阅 数据集编写 部分。
您可以使用 New Displayer widget 来配置报告组件,它包含以下标签页:
- 类型 :允许您选择如何以图形方式显示自定义数据。
- Data: 可让您从 Settings 菜单中的 Data Sets 部分中创建的自定义数据集列表中选择数据集。
- 显示 :允许您选择和自定义如何通过添加标题、更改颜色、大小来显示内容显示方式。
对于 时间序列 Chart 组件,新建显示器 小部件包含 Data、display 和 Component Editor 选项卡。
报告组件子类型 | 描述 |
---|---|
bar | 此组件用来以栏图表的形式显示数据集中的数据。 |
pie | 此组件用来以 pie chart 的形式显示数据集中的数据。在 pie 图表中,每个片段的 arc 长度与代表的数量成比例。 |
行 | 此组件用于将数据集中的数据显示为由两个路线段连接的一系列数据点。 |
区域 | 此组件将一行图表和栏图表相结合,以显示数据集中的数据。 |
bubble | 此组件在双维图中显示多个 circles (bubbles)。它是 scatter 图表的规范化,可将点替换为 bubbles。 |
英国 | 此组件用来以音频的形式显示数据集中的数据。 |
Map | 此组件允许您在使用不同层的上下文(通常是地理)中位置您的数据。data 值显示为映射上的标记。data 值可以充当协调或地址。 |
指标 | 此组件用来以指标的形式显示数据集中的数据。您可以使用 Preview、html 或 Javascript 选项卡编辑您的数据。 |
表 | 此组件用来以表的形式显示数据集中的数据。如果需要,您可以隐藏或显示列。 |
Filter | 此组件允许您过滤数据集中的数据。 |
时间序列图表 | 此组件用来以时间序列形式显示数据集中的数据。 |
56.4.4. 组件属性
页面中使用的组件关联有不同的属性。Properties 面板允许您通过编辑以下属性来自定义组件:
- 面板 属性 :用于自定义组件面板属性,如 Width、Height 和 Background Color。
- C itit 属性:用于自定义组件敏感度属性,如 Top、Bottom、Left 和 右边。
- padding 属性:用于自定义组件 padding 属性,如 Top、Bottom、Left 和 右边。
56.4.5. 将组件放在页面编辑器中,以创建页面
要创建页面,您必须将组件拖到 Pages 视角的 Editor canvas 中。在将所有必需的组件放在页面中后,单击 Save。
56.4.6. 使用 Preview 选项卡预览页面
在创建或编辑页面时,点 Page Editor 中的 Preview 选项卡来预览页面,然后再保存页面。
56.4.7. 在页面中添加时间序列 chart 组件
您可以使用时间序列 Chart 组件来表示任何时间序列数据。您可以创建自己的仪表板,这些仪表板可以连接到您的时间序列数据集。
您可以将时间序列组件导出到 Dashbuilder Runtime,并从 KIE 服务器或任何 Prometheus 数据集检索信息。您还可以使用时间序列 chart 组件创建、编辑和构建仪表板。
先决条件
- KIE 服务器部署并连接到 Business Central。
流程
使用以下步骤创建新的 KIE Server 数据集:
在 Business Central 中,前往 Admin → Data Sets。
Data Set Explorer 页面将打开。
点 New Data Set,根据您的要求选择任何供应商类型。
Data Set Creation Wizard 页面将打开。
- 在您选择的供应商类型的 Data Set Creation 向导中输入所需详情,然后点 Test。
- 点击 Save。
- 在 Business Central 中,进入 Menu → Design → Pages。
- 在 Pages 面板中,单击 New。
- 点击 OK。
在 New Page 对话框中,在 Name 字段中输入名称,然后选择所需的样式。
新页面将在 Page Editor 中打开。
- 在 Components 面板中,展开 Reporting 组件,并将时间序列图 表 拖到 Page Editor 中。
- 在 Displayer 编辑器 向导中,点 Data 选项卡并选择您创建的数据集。
- 在 Data 选项卡中,根据您的要求从 Columns 字段中选择值。
- 点 Display 选项卡,并根据需要编辑 Chart、Carigins、Filter、Refresh 和 Columns 的值。
点 Component Editor 选项卡,将以下组件属性更新为 Component Properties 字段:
表 56.4. 时间序列组件属性 组件属性 描述 Transpose dataset
定义提供的数据集使用时间序列作为单独的列或行。
显示区域
选中复选框,将类型设置为行图表或区域图表。
日期类别
从下拉列表中选择 category、datetime 或 number 选项。
标签
选中复选框以在数据点上启用或禁用数据标签。
缩放类型
从下拉列表中选择 x、y 或 xy 选项。
启用缩放
选中在 axis chart 中启用缩放的复选框。默认情况下会选中复选框。
缩放自动扩展 Y axis
选中根据可见区域重新缩放高和低的复选框。
工具栏自动选择
从下拉列表中选择 缩放、选择 或 pan 选项。
title 文本
编辑时间序列 chart 组件的标题。
title align
从下拉列表中选择 左下、中心 或 右 选项,以更改标题对齐。
显示工具栏
它是在图右上角启用或禁用工具栏的复选框。默认情况下会选中此复选框。如果启用了此组件属性,您可以使用 缩放 in、zoom out、选择缩放和时间序列图表组件的 panning 功能。
Chart 名称
根据您的要求设置 chart 名称。默认情况下,chart 名称被设置为 Newchart。
- 可选:点图表右上角的 sandwich 菜单图标下载 CSV、PNG 或 SVG 格式设置的数据。
点击 OK。
图 56.2. 时间序列组件示例
56.5. heatmap 组件
在 Business Central 中,您可以在页面中添加热图组件。heatmap 组件用于通过进程图显示 heat 信息。进程图节点上的颜色与您分配给每个节点的值相关,并基于分配的值,颜色因进程图而异。如果分配的值是最大值,则 heat 数值会定期显示,如果分配了最小值,则不会在进程图表中显示 heat。
您可以将 heatmap 组件导出到 Dashbuilder Runtime 或 Dashbuilder Standalone,并从 KIE 服务器数据集中检索 heat 信息。您还可以使用 heatmap 组件创建、编辑和构建仪表板。
56.5.1. 为进程创建 heatmap 组件
您可以为 Business Central 中的特定进程创建热图组件。
先决条件
- KIE 服务器部署并连接到 Business Central。
- 您已创建了一个在 Business Central 中至少有一个业务进程资产的项目。
- 在 Business Central 中部署了具有进程定义的项目。
- 创建示例进程实例。
流程
使用以下步骤创建新的 KIE Server 数据集:
在 Business Central 中,前往 Admin → Data Sets。
Data Set Explorer 页面将打开。
单击 New Data Set,再选择 Execution Server 供应商类型。
Data Set Creation Wizard 页面将打开。
- 输入 dataset 的名称。
- 选择服务器配置。如果部署了项目,则可以使用服务器配置。
- 从列表中选择 CUSTOM 查询目标。
在 Query 字段中,输入以下自定义 SQL 查询。
select pil.externalId, pil.processId, nil.nodeid, nil.nodetype, nil.nodename, count(nil.nodeid) as total_hits from NodeInstanceLog nil inner join ProcessInstanceLog pil on pil.processInstanceId = nil.processInstanceId where nil.type = 1 group by pil.externalId, nil.nodeid, nil.nodename
注意如果需要,您可以根据数据库修改 SQL 查询。
- 完成 Data Set Creation 向导,再点 Test。
- 点击 Save。
- 在 Business Central 中,进入 Menu → Design → Pages。
- 在 Pages 面板中,单击 New。
- 在 New Page 对话框中,在 Name 字段中输入一个值,然后选择所需的样式。
点击 OK。
新页面在 Page Editor 中打开,您可以看到 Heatmaps 组件在 Components 面板下可用。
- 在 组件 面板中,展开 Heatmaps 组件,并将 Process Heatmap 组件类型拖到 Page Editor 中。
- 在 Displayer 编辑器 向导中,点 Data 选项卡并选择新创建的 KIE Server 数据集。
- 在 Data 选项卡中,从 Columns 字段中选择 NODEID 和 TOTAL_HITS。
点 Component Editor 选项卡,在 Component Properties 字段中输入强制字段的值,包括 Server Template、Container ID 和 Process Definition ID。
注意要访问 Server Template 的值,请转至 Deploy → Execution Servers → Server Configuration。对于 Container ID 的值,请转至 Manage → Process Instances,您可以点要使用的进程实例,在 Deployment 中对应于容器 ID,定义 ID 是进程 定义 ID。
- 点 Display 选项卡,并根据您的要求编辑 Chart、Carigins、Filter、Refresh 和 Columns 的值。
点击 OK。
图 56.3. 进程热图组件示例
您可以查看进程图表的 heat 信息。
56.5.2. 为多个进程创建 heatmap 组件
您可以为 Business Central 中的多个进程创建 heatmap 组件。
先决条件
- KIE 服务器部署并连接到 Business Central。
- 您已在 Business Central 中创建了多个项目,它至少包含一个业务进程资产。
- 在 Business Central 中部署了具有进程定义的项目。
- 创建示例进程实例。
流程
使用以下步骤创建新的 KIE Server 数据集:
在 Business Central 中,前往 Admin → Data Sets。
Data Set Explorer 页面将打开。
单击 New Data Set,再选择 Execution Server 供应商类型。
Data Set Creation Wizard 页面将打开。
- 输入 dataset 的名称。
- 选择服务器配置。如果部署了项目,则可以使用服务器配置。
- 从列表中选择 CUSTOM 查询目标。
在 Query 字段中,输入以下自定义 SQL 查询。
select pil.externalId, pil.processId, nil.nodeid, nil.nodetype, nil.nodename, count(nil.nodeid) as total_hits from NodeInstanceLog nil inner join ProcessInstanceLog pil on pil.processInstanceId = nil.processInstanceId where nil.type = 1 group by pil.externalId, nil.nodeid, nil.nodename
注意如果需要,您可以根据数据库修改 SQL 查询。
- 完成 Data Set Creation 向导,再点 Test。
- 点击 Save。
- 在 Business Central 中,进入 Menu → Design → Pages。
- 在 Pages 面板中,单击 New。
- 在 New Page 对话框中,在 Name 字段中输入一个值,然后选择所需的样式。
点击 OK。
新页面在 Page Editor 中打开,您可以看到 Heatmaps 组件在 Components 面板下可用。
- 在 组件 面板中,展开 Heatmaps 组件,并将所有进程 Heatmaps 组件类型拖到 canvas。
- 在 Displayer 编辑器 向导中,点 Data 选项卡并选择新创建的 KIE Server 数据集。
- 在 Data 选项卡中,从 Columns 字段中选择 EXTERNALID、PROCESSID、NODEID 和 TOTAL_HITS。
- 在 Process Selector 框中,根据您的要求选择 Container and Process 值。
点 Component Editor 选项卡,然后在 Server Template (必需)字段中输入值。
注意要访问 Server Template 的值,请转至 Deploy → Execution Servers → Server Configuration。
- 点 Display 选项卡,并根据您的要求编辑 Chart、Carigins、Filter、Refresh 和 Columns 的值。
单击 +OK。
图 56.4. 多个进程热图组件示例
您可以查看进程图表的 heat 信息。
56.5.3. 执行热图组件
您可以在 Business Central 之外本地执行内部 heatmap 组件,用于测试目的。相同的 API 用于创建外部组件,您可以使用它来构建自己的组件。有关外部组件的更多信息,请参阅 第 56.6 节 “外部组件”
要运行特定的 heatmap 组件,请完成以下步骤:
先决条件
- 您已在系统中安装了 npm。有关安装 npm 的更多信息,请参阅 下载并安装 Node.js 和 npm。
- 您已在系统中安装了 Yarn。有关安装 Yarn 的更多信息,请参阅 Yarn 安装。
- 您已克隆了 Appformer 存储库,以便在 Business Central 之外运行组件。
流程
-
进入
appformer/dashbuilder/dashbuilder-shared/dashbuilder-js
目录。 在
dashbuilder-js
目录中打开终端,并输入以下命令:yarn run init && yarn run build:fast
您可以查看
dashbuilder-js/packages
目录中存在以下组件:- processes-heatmaps-component
- process-heatmap-component
- logo-component
- heatmap-component
进入
dashbuilder-js/packages
目录,打开所需的 heatmap 组件,并在终端中输入以下命令:yarn run start
要访问组件,请在网页浏览器中输入 http://localhost:9001/。
所选组件显示在网页浏览器中。
56.6. 外部组件
在 Business Central 中,您可以在页面中添加外部组件。组件默认是禁用的。要启用外部组件,请将 dashbuilder.components.enable
系统属性的值更改为 true
。
外部组件位置设置并使用 dashbuilder.components.dir
系统属性进行配置。此系统属性的默认值为 /tmp/dashbuilder/components
。您必须使用父目录(用作组件 ID)在 components 目录下设置组件。例如,如果组件 ID 是 mycomp
,并且组件目录为 /tmp/dashbuilder/components
,则组件基础目录为 /tmp/dashbuilder/components/mycomp
。
Business Central 检查组件目录中的 manifest.json
文件。manifest.json
必须至少包含一个 名称
文本参数。
参数 | 描述 |
---|---|
| 组件部分下显示的 组件名称。 |
| 组件部分下显示 的组件 图标。 |
| 表示组件不需要数据集的标记。 |
|
参数列表使用 |
manifest.json
文件示例
{ "name": "Heat Map Experiment", "icon": "fa fa-bell-o", "parameters": [ { "name": "svg", "type": "text", "defaultValue": "", "label": "SVG XML", "category": "SVG Content" "mandatory": true }, { "name": "svgUrl", "type": "text", "defaultValue": "", "label": "SVG URL", "category": "SVG URL" "mandatory": true } , { "name": "ksProcessId", "type": "text", "defaultValue": "", "label": "Process ID", "category": "Kie Server" "mandatory": true } ] }
56.6.1. 创建外部组件
以下流程描述了如何在页面中创建和添加外部组件:
流程
使用父目录在 components 目录下设置组件。
例如,如果组件 ID 是
mycomp
,并且组件目录为/tmp/dashbuilder/components
,则组件基础目录为/tmp/dashbuilder/components/mycomp
。-
在组件目录中创建
manifest.json
文件。 -
使用 HTML 内容创建
index.html
文件。 -
在终端应用中,导航到
EAP_HOME/bin
。 要启用外部组件,请将
dashbuilder.components.enable
系统属性的值设置为true
:$ ~/EAP_HOME/bin/standalone.sh -c standalone-full.xml -Ddashbuilder.components.dir={component directory base path} -Ddashbuilder.components.enable=true
启动 Business Central,进入 Menu → Design → Pages。
外部组件在组件 窗格中 可用。
- 在 Components 窗格中,展开 External 组件,并将所需的组件类型拖到 canvas。
- 点击 Save。
第 57 章 安全管理
安全管理是管理用户、组和权限的过程。您可以从 Business Central Security management 页面控制对 Business Central 资源和功能的访问。
Business Central 为安全管理定义了三种类型的实体:用户、组和角色。您可以为角色和组分配权限。用户从该用户所属的组和角色继承权限。
57.1. 安全管理供应商
在安全管理上下文中,域限制对不同应用资源的访问。realm 包含有关用户、组、角色和权限的信息。特定域的用户和组管理服务实施称为安全管理提供程序。
如果内置安全管理提供商不符合应用程序安全域的要求,您可以构建并注册您自己的安全管理提供程序。
如果没有安装安全管理提供程序,用于管理安全域的用户界面不可用。安装和配置安全管理提供程序后,安全管理用户界面中会自动启用用户和组管理功能。
Business Central 包括 Red Hat JBoss EAP 安全管理提供程序,它根据 application-users.properties
或 application-roles.properties
属性文件的内容支持 realm 类型。
57.1.1. 根据属性文件配置 Red Hat JBoss EAP 安全管理提供程序
您可以构建并注册您自己的 Red Hat JBoss EAP 安全管理提供程序。要根据属性文件使用 Red Hat JBoss EAP 安全管理提供程序,请完成此流程中的步骤。
先决条件
- 安装了 Red Hat JBoss EAP。
流程
要使用 Red Hat JBoss EAP 实例中的现有用户或角色属性文件,请在
EAP_HOME/standalone/configuration/application-users.properties
和EAP_HOME/standalone/configuration/application-roles.properties
文件中包含以下系统属性,如下例所示:<property name="org.uberfire.ext.security.management.wildfly.properties.realm" value="ApplicationRealm"/> <property name="org.uberfire.ext.security.management.wildfly.properties.users-file-path" value="/standalone/configuration/application-users.properties"/> <property name="org.uberfire.ext.security.management.wildfly.properties.groups-file-path" value="/standalone/configuration/application-roles.properties"/>
下表提供了这些属性的描述和默认值:
表 57.1. Red Hat JBoss EAP 安全管理提供程序基于属性文件 属性 描述 默认值 org.uberfire.ext.security.management.wildfly.properties.realm
域的名称。此属性不是强制的。
ApplicationRealm
org.uberfire.ext.security.management.wildfly.properties.users-file-path
users 属性文件的绝对文件路径。此属性是必需的。
./standalone/configuration/application-users.properties
org.uberfire.ext.security.management.wildfly.properties.groups-file-path
groups 属性文件的绝对文件路径。此属性是必需的。
./standalone/configuration/application-roles.properties
在应用程序的根目录中创建
security-management.properties
文件。例如,创建以下文件:src/main/resources/security-management.properties
在
security-management.properties
文件中输入以下系统属性和安全供应商名称作为值:<property name="org.uberfire.ext.security.management.api.userManagementServices" value="WildflyUserManagementService"/>
57.1.2. 根据属性文件和 CLI 模式配置 Red Hat JBoss EAP 安全管理提供程序
要使用基于属性文件和 CLI 模式的 Red Hat JBoss EAP 安全管理提供程序,请完成以下步骤。
先决条件
- 安装了 Red Hat JBoss EAP。
流程
要使用 Red Hat JBoss EAP 实例中的现有用户或角色属性文件,请在
EAP_HOME/standalone/configuration/application-users.properties
和EAP_HOME/standalone/configuration/application-roles.properties
文件中包含以下系统属性,如下例所示:<property name="org.uberfire.ext.security.management.wildfly.cli.host" value="localhost"/> <property name="org.uberfire.ext.security.management.wildfly.cli.port" value="9990"/> <property name="org.uberfire.ext.security.management.wildfly.cli.user" value="<USERNAME>"/> <property name="org.uberfire.ext.security.management.wildfly.cli.password" value="<USER_PWD>"/> <property name="org.uberfire.ext.security.management.wildfly.cli.realm" value="ApplicationRealm"/>
下表提供了这些属性的描述和默认值:
表 57.2. Red Hat JBoss EAP 安全管理提供程序基于属性文件和 CLI 模式 属性 描述 默认值 org.uberfire.ext.security.management.wildfly.cli.host
原生管理接口主机。
localhost
org.uberfire.ext.security.management.wildfly.cli.port
原生管理接口端口。
9990
org.uberfire.ext.security.management.wildfly.cli.user
原生管理界面用户名。
不适用
org.uberfire.ext.security.management.wildfly.cli.password
原生管理接口用户的密码。
不适用
org.uberfire.ext.security.management.wildfly.cli.realm
应用的安全上下文使用的域。
ApplicationRealm
在应用程序的根目录中创建
security-management.properties
文件。例如,创建以下文件:src/main/resources/security-management.properties
在
security-management.properties
文件中输入以下系统属性和安全供应商名称作为值:<property name="org.uberfire.ext.security.management.api.userManagementServices" value="WildflyCLIUserManagementService"/>
57.2. 权限和设置
权限是授予用户与应用程序中特定资源相关的操作的授权。例如,用户可以具有以下权限:
- 查看页面。
- 保存项目。
- 查看存储库。
- 删除仪表板。
您可以授予或拒绝权限,权限可以是全局或特定于资源的权限。您可以使用权限来保护对资源的访问和自定义应用程序内的功能。
57.2.1. 更改 Business Central 中组和角色的权限
在 Business Central 中,您无法更改单个用户的权限。但是,您可以更改组和角色的权限。更改的权限适用于具有角色或属于您更改的组的用户。
您对角色或组所做的任何更改都会影响与该角色或组关联的所有用户。
先决条件
-
您可以使用
admin
用户角色登录到 Business Central。
流程
- 要访问 Business Central 中的 Security management 页面,请选择屏幕右上角的 Admin 图标。
在 Business Central Settings 页面中,点 Roles、Groups 或 Users。
Security management 页面会在您点击的图标的标签页上打开。
- 从列表中选择您要编辑的角色或组。所有详情都显示在右侧面板中。
- 在 Settings 部分下设置 Home Page 或 Priority。
在 Permissions 部分下设置 Business Central、page、Edit、space 和 project 权限。
图 57.1. 设置权限
- 单击资源类型旁边的箭头,以展开您要更改其权限的资源类型。
可选: 要为资源类型添加一个例外,请点击 Add Exception,然后根据需要设置权限。
注意您不能为 Business Central 资源类型添加例外。
- 点击 Save。
57.2.2. 更改 Business Central 主页
主页是在登录到 Business Central 后出现的页面。默认情况下,主页设置为 Home
。您可以为每个角色和组指定不同的主页。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Roles 或 Groups。
- 选择角色或组。
- 从 Home Page 列表中选择一个页面。
点击 Save。
注意角色或组必须具有对页面的读访问权限,然后才能使其成为主页。
57.2.3. 设置优先级
用户可以有多个角色,并属于多个组。Priority 设置决定角色或组的优先级顺序。
先决条件
-
您可以使用
admin
用户角色登录到 Business Central。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Roles 或 Groups。
- 选择角色或组。
- 从 Priority 菜单中选择一个优先级,然后单击 Save。
如果用户有角色或属于具有冲突设置的组,则适用优先级最高的角色或组的设置。
第 58 章 导出、导入和部署仪表板
在 Business Central 中创建仪表板后,您可以导出仪表板数据,并将它导入到 Business Central 的另一个实例中、在 Dashbuilder Runtime 中或 Dashbuilder Standalone。
此功能只能由管理员用户访问。
58.1. 导出 Business Central 仪表板数据
您可以将仪表板数据(如数据集、页面和导航)导出为 ZIP 文件。
流程
- 在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Dashbuilder Data Transfer。
要导出仪表板数据,请完成以下任一任务:
如果要将所有仪表板数据导出为 ZIP 文件,请完成以下任务:
在 Dashbuilder Data Transfer 页面上,单击 Export all。
下载包含所有仪表板数据的
export.zip
文件。export.zip
文件结构通过数据类型分开,如下例所示:dashbuilder/datasets/definitions/dataset-example1.dset dashbuilder/datasets/definitions/dataset-example2.dset dashbuilder/datasets/readme.md dashbuilder/perspectives/page1/perspective_layout dashbuilder/perspectives/page1/perspective_layout.plugin dashbuilder/perspectives/page2/perspective_layout dashbuilder/perspectives/page2/perspective_layout.plugin dashbuilder/perspectives/readme.md dashbuilder/navigation/navigation/navtree.json dashbuilder/navigation/readme.md VERSION
如果要导出创建的自定义用户,并将仪表板数据提供为 ZIP 文件,请完成以下任务:
- 在 Dashbuilder Data Transfer 页面上,单击 Custom export。
选择您要包含在 Export Wizard 面板中的 ZIP 文件中的数据集和页面,然后点 Next。
Export Wizard 面板验证所选数据集和页面。数据集和页面摘要位于面板中。
注意导航始终包含在导出的 ZIP 文件中。
如果您的导出就绪,请单击 Download。
下载包含自定义仪表板数据的
export.zip
文件。注意您必须在 Export Wizard 面板中选择关联的页面和数据集。如果您无法同时选择数据集和页面,则会生成错误,您无法下载
export.zip
文件。因此,您必须至少选择一个页面。- 点 Finish。
58.2. 导入 Business Central 仪表板数据
如果存档结构,您可以使用 ZIP 文件将您在 Business Central 中创建的仪表板数据导入到另一个 Business Central 实例,如下例所示:
dashbuilder/datasets/definitions/dataset-example1.dset dashbuilder/datasets/definitions/dataset-example2.dset dashbuilder/datasets/readme.md dashbuilder/perspectives/page1/perspective_layout dashbuilder/perspectives/page1/perspective_layout.plugin dashbuilder/perspectives/page2/perspective_layout dashbuilder/perspectives/page2/perspective_layout.plugin dashbuilder/perspectives/readme.md dashbuilder/navigation/navigation/navtree.json dashbuilder/navigation/readme.md VERSION
流程
在 Business Central 中,选择屏幕右上角的 Admin 图标,然后选择 Dashbuilder Data Transfer。
警告您必须将仪表板数据导入到 Red Hat Process Automation Manager 的全新安装,以避免覆盖现有系统上的数据。
- 在 Dashbuilder Data Transfer 页面上,单击 Choose File 图标。
- 导航到您要导入的 ZIP 文件,然后选择该文件。
- 点 Upload 图标。
- 点 Import。
58.3. 在 Dashbuilder 运行时从 Business Central 部署仪表板
您可以从 Dashbuilder Runtime 上的 Business Central 自动部署仪表板。Business Central 使用逐步导出功能与 Dashbuilder 运行时相关联。
先决条件
- 在您的系统上配置了 Dashbuilder 运行时。
-
您已在
standalone.xml
文件中将dashbuilder.runtime.multi
系统属性设置为true
。 您已将
dashbuilder.runtime.location
系统属性的值设置为 Dashbuilder Runtime URL,如下例所示:<property name="dashbuilder.runtime.location" value=" http://localhost:8080"
您已将
dashbuilder.export.dir
系统属性设置为共享目录,其中 Dashbuilder Runtime 读取其模型,如下例所示:<property name="dashbuilder.export.dir" value="/tmp/dashbuilder/models/"
流程
- 在 Business Central 中,进入 Menu → Design → Pages。
- 在 Components 面板中,根据需要将所需的组件类型拖放到 canvas,然后点 Save 来完成。
- 选择屏幕右上角的 Admin 图标,然后选择 Dashbuilder Data Transfer。
- 在 Dashbuilder Data Transfer 页面上,单击 Custom export。
- 选择您要包含在 Export Wizard 面板中的 ZIP 文件中的页面,然后点 Next。
选择 Export Wizard 并点 Open。
您可以看到 Dashbuilder Runtime 主页。如果没有登录,您会被重定向到登录页面。
进入 Dashboards → Runtime Dashboards,您可以看到页面。
所选数据会被导出,Dashbuilder Runtime 在打开时更新模型内容。
附录 A. 版本信息
文档最后在 2022 年 3 月 8 日更新。
附录 B. 联系信息
Red Hat Process Automation Manager 文档团队: brms-docs@redhat.com