管理 Red Hat Process Automation Manager 和 KIE 服务器设置

流程

1. 在 Business Central 中，前往 Menu → Design → Projects 并点项目名称。
2. 单击项目 Settings 选项卡，然后单击 Validation 以打开存储库列表。

3. 选择或清除所有列出的仓库选项，以启用或禁用重复的 GAV 检测。

   以后，只针对您为验证启用的存储库，才会报告重复的 GAV。

   注意

   要禁用此功能，将系统启动时 Business Central 的 org.guvnor.project.gav.check.disabled 系统属性设置为 true ：

   Copy to Clipboard Toggle word wrap

   $ ~/EAP_HOME/bin/standalone.sh -c standalone-full.xml
   -Dorg.guvnor.project.gav.check.disabled=true

流程

1. 在第一个计算机上，以交互模式或 CLI 模式运行安装程序。如需更多信息 ，请参阅在 Red Hat JBoss EAP 7.4 上安装和配置 Red Hat Process Automation Manager。
2. 在 Component Selection 页面中，清除 KIE 服务器 框。
3. 完成 Business Central 安装。
4. 在第二个计算机上，以交互模式或 CLI 模式运行安装程序。
5. 在 组件选择 页面中，清除 Business Central 框。
6. 在 Configure Runtime Environment 页面中，选择 Perform Advanced Configuration。
7. 选择" 自定义 KIE 服务器"属性，然后单击" 下一步"。

8. 输入 Business Central 的控制器 URL，并为 KIE 服务器配置其他属性。控制器 URL 具有以下格式，其中 & lt;HOST:PORT > 是第二个计算机上的 Business Central 地址：

   Copy to Clipboard Toggle word wrap

   <HOST:PORT>/business-central/rest/controller

9. 完成安装。
10. 要验证流程自动化管理器控制器现在是否与 Business Central 集成，请转至 Business Central 中的 执行服务器 页面，并确认您配置的 KIE 服务器是否出现在 REMOTE SERVERS 下。

流程

1. 进入红帽客户门户网站中的 Software Downloads 页面（需要登录），然后从下拉列表中选择产品和版本：

   • 产品： 流程自动化管理器
   • 版本： 7.13.4
2. 下载 Red Hat Process Automation Manager 7.13.4 Add Ons ( rhpam-7.13.4-add-ons.zip 文件)。
3. 提取 rhpam-7.13.4-add-ons.zip 文件。rhpam-7.13.4-controller-ee7.zip 文件位于提取的目录中。
4. 将 rhpam-7.13.4-controller-ee7.zip 存档提取到临时目录。在以下示例中，此目录名为 TEMP_DIR。

5. 将 TEMP_DIR/rhpam-7.13.4-controller-ee7/controller.war 目录复制到 EAP_HOME/standalone/deployments/。

   警告

   确保您复制的无头进程自动化管理器控制器部署的名称与您在 Red Hat JBoss EAP 实例中的现有部署不冲突。

6. 将 TEMP_DIR/rhpam-7.13.4-controller-ee7/SecurityPolicy/ 目录的内容复制到 EAP_HOME/bin。
7. 当系统提示覆盖文件时，选择是 。
8. 在 EAP_HOME/standalone/deployments/ 目录中，创建名为 controller.war.dodeploy 的空文件。此文件确保服务器启动时自动部署无头进程自动化管理器控制器。

流程

1. 在终端应用中，导航到 EAP_HOME/bin。

2. 如果您在与安装 KIE 服务器的 Red Hat JBoss EAP 实例相同的 Red Hat JBoss EAP 实例中安装无头进程自动化管理器控制器，请输入以下命令：

   • 在 Linux 或基于 UNIX 的系统中：

     Copy to Clipboard Toggle word wrap

     $ ./standalone.sh -c standalone-full.xml

   • 在 Windows 中：

     Copy to Clipboard Toggle word wrap

     standalone.bat -c standalone-full.xml

3. 如果您在安装了 KIE 服务器的红帽 JBoss EAP 实例中安装了无头流程自动化管理器控制器，请使用 standalone.sh 脚本启动无头进程自动化管理器控制器：

   注意

   在这种情况下，请确保对 standalone.xml 文件进行所有必要的配置更改。

   • 在 Linux 或基于 UNIX 的系统中：

     Copy to Clipboard Toggle word wrap

     $ ./standalone.sh

   • 在 Windows 中：

     Copy to Clipboard Toggle word wrap

     standalone.bat

4. 要验证无头进程自动化管理器控制器是否在在红帽 JBoss EAP 上工作，请输入以下命令 < CONTROLLER> 和 & lt ;CONTROLLER_PWD > 是用户名和密码。此命令的输出提供有关 KIE 服务器实例的信息。

   Copy to Clipboard Toggle word wrap

   curl -X GET "http://<HOST>:<PORT>/controller/rest/controller/management/servers" -H  "accept: application/xml" -u '<CONTROLLER>:<CONTROLLER_PWD>'

流程

1. 进入红帽客户门户网站中的 Software Downloads 页面（需要登录），然后从下拉列表中选择产品和版本：

   • PRODUCT： 流程自动化管理器
   • 版本： 7.13.4
2. 下载 Red Hat Process Automation Manager 7.13.4 Add Ons ( rhpam-7.13.4-add-ons.zip 文件)。
3. 提取 rhpam-7.13.4-add-ons.zip 文件。rhpam-7.13.4-controller-ee7.zip 文件位于提取的目录中。
4. 将 rhpam-7.13.4-controller-ee7.zip 存档提取到临时目录。在以下示例中，此目录名为 TEMP_DIR。

5. 将 TEMP_DIR/rhpam-7.13.4-controller-ee7/controller.war 目录复制到 EAP_HOME/standalone/deployments/。

   警告

   确保您复制的无头进程自动化管理器控制器部署的名称与您在 Red Hat JBoss EAP 实例中的现有部署不冲突。

6. 将 TEMP_DIR/rhpam-7.13.4-controller-ee7/SecurityPolicy/ 目录的内容复制到 EAP_HOME/bin。
7. 当系统提示覆盖文件时，请单击 Yes。
8. 在 EAP_HOME/standalone/deployments/ 目录中，创建名为 controller.war.dodeploy 的空文件。此文件确保服务器启动时自动部署无头进程自动化管理器控制器。
9. 在文本编辑器中打开 EAP_HOME/standalone/configuration/standalone.xml 文件。

10. 在 < system-properties> 元素中添加以下属性，并将 &lt ;NFS_STORAGE > 替换为存储模板配置的 NFS 存储的绝对路径：

    Copy to Clipboard Toggle word wrap

    <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，则仅在服务器重启时检测到对模板文件的更改。

11. 要启动无头进程自动化管理器控制器，请导航到 EAP_HOME/bin，然后输入以下命令：

    • 在 Linux 或基于 UNIX 的系统中：

      Copy to Clipboard Toggle word wrap

      $ ./standalone.sh

    • 在 Windows 中：

      Copy to Clipboard Toggle word wrap

      standalone.bat

流程

1. 要在 Business Central 中打开项目部署描述符配置，打开 Menu → Design → Design → PROJECT_NAME → Settings → Deployments。
2. 从配置设置列表中，单击 Required Roles，然后单击 Add Required Role。
3. 在 Add Required Role 窗口中，键入您要具有访问此部署的权限的角色名称，然后点 Add。
4. 要添加更多具有访问部署权限的角色，请重复前面的步骤。
5. 添加完所有所需的角色后，点 Save。

流程

1. 在您的 KIE 服务器实例中，将 org.kie.prometheus.server.ext.disabled 系统属性设置为 false 以启用 Prometheus 扩展。您可在启动 KIE 服务器时，或者在 Red Hat Process Automation Manager 分发的 standalone.xml 或 standalone-full.xml 文件中定义此属性。

2. 如果您在 Spring Boot 上运行 Red Hat Process Automation Manager，在 application.properties 系统属性中配置所需的密钥：

   Red Hat Process Automation Manager 和 Prometheus 的 Spring Boot application.properties 密钥

   Copy to Clipboard Toggle word wrap

   kieserver.jbpm.enabled=true
   kieserver.drools.enabled=true
   kieserver.dmn.enabled=true
   kieserver.prometheus.enabled=true

3. 在 Prometheus 发行版本的 prometheus.yaml 文件中，在 scrape_configs 部分添加以下设置，将 Prometheus 配置为从 KIE 服务器中提取指标：

   prometheus.yaml 文件中的 scrape 配置

   Copy to Clipboard Toggle word wrap

   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 配置（如果适用）

   Copy to Clipboard Toggle word wrap

   scrape_configs:
     - job_name: 'kie'
       metrics_path: /rest/metrics
       static_configs:
         - targets: ["HOST:PORT"]

   根据您的 KIE 服务器位置和设置值。

4. 启动 KIE 服务器实例。

   Red Hat JBoss EAP 上 Red Hat Process Automation Manager 的开始命令示例

   Copy to Clipboard Toggle word wrap

   $ cd ~/EAP_HOME/bin
   $ ./standalone.sh --c standalone-full.xml

   启动配置的 KIE 服务器实例后，Prometheus 开始收集指标，KIE 服务器会将指标发布到 REST API 端点 http://HOST:PORT/SERVER/services/rest/metrics （或在 Spring Boot 上，或在 Spring Boot 上）发布指标到 http://HOST:PORT/rest/metrics。

5. 在 REST 客户端或 curl 实用程序中，使用以下组件发送 REST API 请求，以验证 KIE 服务器是否发布指标：

   对于 REST 客户端：

   • 身份验证 ：使用 kie-server 角色输入 KIE 服务器用户的用户名和密码。

   • HTTP 标头 ：设置以下标头：

     • 接受:application/json
   • HTTP 方法 ：设置为 GET。
   • URL ：输入 KIE 服务器 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 服务器 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 命令示例

   Copy to Clipboard Toggle word wrap

   curl -u 'baAdmin:password@1' -X GET "http://localhost:8080/kie-server/services/rest/metrics"

   Spring Boot 上的 Red Hat Process Automation Manager 的 curl 命令示例

   Copy to Clipboard Toggle word wrap

   curl -u 'baAdmin:password@1' -X GET "http://localhost:8080/rest/metrics"

   服务器响应示例

   Copy to Clipboard Toggle word wrap

   # 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.68.0-SNAPSHOT",} 1.557285486469E12

   如果 KIE 服务器中没有指标，请查看并验证本节中描述的 KIE 服务器和 Prometheus 配置。

   您还可以在 http://HOST:PORT/graph 中与 Prometheus 表达式浏览器中收集的指标进行交互，或者将 Prometheus 数据源与数据图形工具（如 Grafana）集成：

   图 15.1. 带有 KIE 服务器指标的 Prometheus 表达式浏览器

   

   图 15.2. 带有 KIE 服务器目标的 Prometheus 表达式浏览器

   

   图 15.3. DMN 型号的 KIE 服务器指标的 Grafana 仪表板

   

   图 15.4. 带有临时解决方案的 KIE 服务器指标的 Grafana 仪表板

   

   图 15.5. 带有进程、用例和任务的 KIE 服务器指标的 Grafana 仪表板

   

流程

1. 在 OpenShift 上的 KIE 服务器部署的 DeploymentConfig 对象中，将 PROMETHEUS_SERVER_EXT_DISABLED 环境变量设置为 false 来启用 Prometheus 扩展。您可以在 OpenShift web 控制台中设置此变量，或者在命令终端中使用 oc 命令：

   Copy to Clipboard Toggle word wrap

   oc set env dc/<dc_name> PROMETHEUS_SERVER_EXT_DISABLED=false -n <namespace>

   如果您尚未在 OpenShift 上部署您的 KIE 服务器，那么在计划用于 OpenShift 部署的 OpenShift 模板中（例如： rhpam713-prod-immutable-kieserver.yaml），您可以将 PROMETHEUS_SERVER_EXT_DISABLED 模板参数设置为 false 来启用 Prometheus 扩展。

   如果您使用 OpenShift Operator 在 OpenShift 上部署 KIE 服务器，然后在 KIE 服务器配置中，将 PROMETHEUS_SERVER_EXT_DISABLED 环境变量设置为 false 来启用 Prometheus 扩展：

   Copy to Clipboard Toggle word wrap

   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"

2. 创建一个 service-metrics.yaml 文件，以添加将 KIE 服务器的指标公开给 Prometheus 的服务：

   Copy to Clipboard Toggle word wrap

   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

3. 在命令终端中，使用 oc 命令将 service-metrics.yaml 文件应用到 OpenShift 部署：

   Copy to Clipboard Toggle word wrap

   oc apply -f service-metrics.yaml

4. 创建一个 OpenShift secret，如 metrics-secret，以访问 KIE 服务器上的 Prometheus 指标。secret 必须包含带有 KIE 服务器用户凭证的"username"和"password"元素。如需有关 OpenShift 机密的信息，请参阅《OpenShift 开发人员指南 》中的 机密 章节。

5. 创建一个 service-monitor.yaml 文件来定义 ServiceMonitor 对象。服务监控器可让 Prometheus 连接到 KIE 服务器指标服务。

   Copy to Clipboard Toggle word wrap

   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

6. 在命令终端中，使用 oc 命令将 service-monitor.yaml 文件应用到 OpenShift 部署：

   Copy to Clipboard Toggle word wrap

   oc apply -f service-monitor.yaml

   完成这些配置后，Prometheus 开始收集指标，KIE 服务器会将指标发布到 REST API 端点 http://HOST:PORT/kie-server/services/rest/metrics。

   您可以在 http://HOST:PORT/graph 中与 Prometheus 表达式浏览器中收集的指标交互，或者将 Prometheus 数据源与 Grafana 等数据图形工具集成。

   Prometheus 表达式浏览器位置 http://HOST:PORT/graph 的主机和端口在安装 Prometheus Operator 时公开 Prometheus Web 控制台的路由中定义。如需有关 OpenShift 路由的信息，请参阅 OpenShift 架构 文档中的 路由 章节。

   图 15.6. 带有 KIE 服务器指标的 Prometheus 表达式浏览器

   

   图 15.7. 带有 KIE 服务器目标的 Prometheus 表达式浏览器

   

   图 15.8. DMN 型号的 KIE 服务器指标的 Grafana 仪表板

   

   图 15.9. 带有临时解决方案的 KIE 服务器指标的 Grafana 仪表板

   

   图 15.10. 带有进程、用例和任务的 KIE 服务器指标的 Grafana 仪表板

   

流程

1. 创建一个空的 Maven 项目，并在项目的 pom.xml 文件中定义以下打包类型和依赖项：

   示例项目中的 pom.xml 文件示例

   Copy to Clipboard Toggle word wrap

   <packaging>jar</packaging>
   
   <properties>
     <version.org.kie>7.67.0.Final-redhat-00024</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>

2. 从 org.kie.services.prometheus.PrometheusMetricsProvider 接口实施相关的监听程序，作为定义自定义 Prometheus 指标的自定义监听程序的一部分，如下例所示：

   在自定义监听器类中的 DMNRuntimeEventListener 侦听程序实施示例

   Copy to Clipboard Toggle word wrap

   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 依赖项集成。

   在本例中，ExamplePrometheusMetricListener 类实施 DMNRuntimeEventListener 侦听器（从 PrometheusMetricsProvider 接口），并定义要收集和存储的自定义 DMN 指标。

3. 作为自定义指标提供商类的一部分，实施 PrometheusMetricsProvider 接口，将您的自定义监听程序与 PrometheusMetricsProvider 接口相关联，如下例所示：

   自定义 metrics 提供者类中的 PrometheusMetricsProvider 接口实施示例

   Copy to Clipboard Toggle word wrap

   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 侦听器类。

4. 要使新指标提供程序可供 KIE 服务器发现，请在 文件中创建一个 META-INF/services/org.kie.services.prometheus. PrometheusMetricsProvider 文件，并在文件中添加完全限定的类名称。在本例中，该文件包含一行 org.kie.server.ext.prometheus.MyPrometheusMetricsProvider。

5. 构建您的项目，并将生成的 JAR 文件复制到项目的 ~/kie-server.war/WEB-INF/lib 目录中。例如，在红帽 JBoss EAP 上，此目录的路径是 EAP_HOME/standalone/deployments/kie-server.war/WEB-INF/lib。

   如果要在 Red Hat OpenShift Container Platform 上部署 Red Hat Process Automation Manager，请创建一个自定义 KIE 服务器镜像，并将这个 JAR 文件添加到镜像中。有关使用额外 JAR 文件创建自定义 KIE 服务器镜像的更多信息，请参阅使用 Operator 在 Red Hat OpenShift Container Platform 4 上部署 Red Hat Process Automation Manager 环境。

6. 启动 KIE 服务器并将构建的项目部署到正在运行的 KIE 服务器。您可以使用 Business Central 接口或 KIE 服务器 REST API 部署项目（ PUT 请求到 http://SERVER:PORT/kie-server/services/rest/server/containers/{containerId}）。

   在正在运行的 KIE 服务器上部署项目后，Prometheus 开始收集指标和 KIE 服务器，将指标发布到 REST API 端点 http://HOST:PORT/SERVER/services/rest/metrics （或者在 Spring Boot 上，或在 Spring Boot 上）发布指标。

流程

1. 要配置 KIE 服务器持久性，请完成以下任一任务：

   如果要使用红帽 JBoss EAP 配置文件配置 KIE 服务器持久性，请完成以下任务：

   1. 在 Red Hat Process Automation Manager 安装目录中，导航至 standalone-full.xml 文件。例如，如果您使用红帽 JBoss EAP 安装红帽流程自动化管理器，请转至 $EAP_HOME/standalone/configuration/standalone-full.xml 文件。

   2. 打开 standalone-full.xml 文件并在 < system-properties& gt; 标签下，将 Hibernate 或 JPA 参数设置为系统属性。

      使用 Hibernate 参数配置 KIE 服务器持久性示例

      Copy to Clipboard Toggle word wrap

      <system-properties>
          ...
              <property name="hibernate.hbm2ddl.auto" value="create-drop"/>
          ...
      <system-properties>

      使用 JPA 参数配置 KIE 服务器持久性示例

      Copy to Clipboard Toggle word wrap

      <system-properties>
          ...
              <property name="javax.persistence.jdbc.url" value="jdbc:mysql://mysql.db.server:3306/my_database?useSSL=false&serverTimezone=UTC"/>
          ...
      <system-properties>

   如果要使用命令行配置 KIE 服务器持久性，请完成以下任务：

   1. 使用 -Dkey=value 直接从命令行中传递参数，如下所示：

      使用 Hibernate 参数配置 KIE 服务器持久性示例：

      Copy to Clipboard Toggle word wrap

      $EAP_HOME/bin/standalone.sh -Dhibernate.hbm2ddl.auto=create-drop

      使用 JPA 参数配置 KIE 服务器持久性示例：

      Copy to Clipboard Toggle word wrap

      $EAP_HOME/bin/standalone.sh -Djavax.persistence.jdbc.url=jdbc:mysql://mysql.db.server:3306/my_database?useSSL=false&serverTimezone=UTC

流程

1. 在用作进程变量的数据对象文件中，添加以下元素来配置变量持久性：

   为变量持久性配置 Person.java 对象示例

   Copy to Clipboard Toggle word wrap

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

   1

   将数据对象配置为持久性实体。

   2

   定义用于 data 对象的数据库表名称。

   3

   创建单独的 MappedVariable 映射表，用于维护此数据对象和相关进程实例之间的关系。如果您不需要此关系，则不需要扩展 VariableEntity 类。如果没有此扩展，数据对象仍会保留，但没有包含额外的数据。

   4

   将数据对象配置为 serializable 对象。

   5

   为对象设置持久性 ID。

   要使用 Business Central 使数据对象持久，请导航到项目中的 data 对象文件，单击窗口右上角的 Persistence 图标，并配置持久性行为：

   图 17.1. Business Central 中的持久性配置

   

2. 在项目的 pom.xml 文件中，添加以下用于持久性支持的依赖关系。这个依赖关系包含您在 data 对象中配置的 VariableEntity 类。

   持久性的项目依赖性

   Copy to Clipboard Toggle word wrap

   <dependency>
     <groupId>org.drools</groupId>
     <artifactId>drools-persistence-jpa</artifactId>
     <version>${rhpam.version}</version>
     <scope>provided</scope>
   </dependency>

3. 在项目的 ~/META-INF/kie-deployment-descriptor.xml 文件中，配置 JPA marshalling 策略以及要与 marshaller 搭配使用的持久性单元。对于定义为实体的对象，需要 JPA marshalling 策略和持久性单元。

   JPA marshaller 和 persistence 单元在 kie-deployment-descriptor.xml 文件中配置

   Copy to Clipboard Toggle word wrap

   <marshalling-strategy>
     <resolver>mvel</resolver>
     <identifier>new org.drools.persistence.jpa.marshaller.JPAPlaceholderResolverStrategy("myPersistenceUnit", classLoader)</identifier>
     <parameters/>
   </marshalling-strategy>

4. 在项目的 ~/META-INF 目录中，创建一个 persistence.xml 文件，用于指定您要保留的进程变量：

   带有数据源配置的 persistence.xml 文件示例

   Copy to Clipboard Toggle word wrap

   <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 策略、持久性单元和数据源，请导航至项目 Settings → Deployments → Marshalling Strategy 和 Project Settings → Persistence ：

   图 17.2. JPA marshaller 配置 Business Central

   

   图 17.3. Business Central 中的持久性单元和数据源配置

   

流程

1. 创建一个空的 Maven 项目，并在项目的 pom.xml 文件中定义以下打包类型和依赖项：

   示例项目中的 pom.xml 文件示例

   Copy to Clipboard Toggle word wrap

   <packaging>jar</packaging>
   
   <properties>
     <version.org.kie>7.67.0.Final-redhat-00024</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>

2. 在项目中的 Java 类中实施 org.kie.server.services.api.KieServerApplicationComponentsService 接口，如下例所示：

   KieServerApplicationComponentsService 接口的实现示例

   Copy to Clipboard Toggle word wrap

   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

   指定您要扩展的扩展，如本例中的 Drools 扩展。

   3

   返回 REST 容器必须部署的所有资源。在 KIE 服务器实例中启用的每个扩展会调用 getAppComponents 方法，因此 if（!OWNER_EXTENSION.equals(extension)） 调用为除指定的 OWNER_EXTENSION 扩展以外的扩展返回空集合。

   4

   列出您要使用的指定扩展中的服务，如本例中的 Drools 扩展中的 RulesExecutionService 和 KieServerRegistry 服务。

   5

   指定扩展的传输类型（即 REST ）（本例中为REST ），以及返回资源作为 组件 列表一部分的 CustomResource 类。

3. 实施 KIE 服务器可以用来为新的 REST 资源提供额外的功能，如下例所示：

   CustomResource 类的实现示例

   Copy to Clipboard Toggle word wrap

   // 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（JAXB、XStream）
     • JSON
   • Unmarshals 在 List<?& gt; 集合中，为列表中的每个项目创建一个 InsertCommand 实例，后跟 FireAllRules 和 GetObject 命令。
   • 将所有命令添加到调用决策引擎的 BatchExecutionCommand 实例中。
4. 要使新端点可以被 KIE 服务器发现，请在 文件中创建一个 META-INF/services/org.kie.server.api.KieServerApplicationApplicationComponentsService 文件，并添加 KieApplicationApplicationComponentsService 实施类的完全限定域名。在本例中，该文件包含一行 org.kie.server.ext.drools.rest.CusomtDroolsKieServerComponentsService。
5. 构建您的项目，并将生成的 JAR 文件复制到项目的 ~/kie-server.war/WEB-INF/lib 目录中。例如，在红帽 JBoss EAP 上，此目录的路径是 EAP_HOME/standalone/deployments/kie-server.war/WEB-INF/lib。

6. 启动 KIE 服务器并将构建的项目部署到正在运行的 KIE 服务器中。您可以使用 Business Central 接口或 KIE 服务器 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
     • accept: application/json

   • 消息有效负载示例：

     Copy to Clipboard Toggle word wrap

     [
       {
         "org.jbpm.test.Person": {
           "name": "john",
           "age": 25
         }
       },
       {
         "org.jbpm.test.Person": {
           "name": "mary",
           "age": 22
         }
       }
     ]

   • 服务器响应示例： 200 (success)

   • 服务器日志输出示例：

     Copy to Clipboard Toggle word wrap

     13:37:20,347 INFO  [stdout] (default task-24) Hello mary
     13:37:20,348 INFO  [stdout] (default task-24) Hello john

流程

1. 创建一个空的 Maven 项目，并在项目的 pom.xml 文件中定义以下打包类型和依赖项：

   示例项目中的 pom.xml 文件示例

   Copy to Clipboard Toggle word wrap

   <packaging>jar</packaging>
   
   <properties>
     <version.org.kie>7.67.0.Final-redhat-00024</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>

2. 在项目中的 Java 类中实施 org.kie.server.services.api.KieServerExtension 接口，如下例所示：

   KieServerExtension 接口的实现示例

   Copy to Clipboard Toggle word wrap

   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 接口概述

   Copy to Clipboard Toggle word wrap

   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

   
   }

   1

   指定此扩展涵盖的能力。能力在 KIE 服务器中必须是唯一的。

   2

   为扩展名定义人类可读的名称。

   3

   确定何时应启动指定的扩展。对于其他扩展具有依赖项的扩展，此设置不得与父设置冲突。例如，在这个示例中，这个自定义扩展依赖于 Drools 扩展，它的 StartOrder 设置为 0，因此这个自定义附加组件扩展必须大于 0（ 示例实现中的设置为 20 ）。

   在前面的 MinaDroolsKieServerExtension 示例实现中，init 方法是从 Drools 扩展收集服务的主要元素，用于引导 MINA 服务器。KieServerExtension 接口中的其他方法都可以与标准实施保持一致，以满足接口要求。

   TextBasedIoHandlerAdapter 类是响应传入请求的 MINA 服务器上的处理程序。

3. 为 MINA 服务器实施 text BasedIoHandlerAdapter 处理程序，如下例所示：

   TextBasedIoHandlerAdapter 处理程序的实现示例

   Copy to Clipboard Toggle word wrap

   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 服务器会话断开连接。要在流模式下结束 KIE 服务器会话，请将 exit 或 exit 命令发送至服务器。
4. 要使新数据传输可被 KIE 服务器发现，请在 文件中创建一个 META-INF/services/org.kie.server.api. KieServerExtension 文件，并在该文件中添加完全限定的类名称。在本例中，该文件包含一行 org.kie.server.ext.mina.MinastandaloneKieServerExtension。
5. 构建您的项目，并将生成的 JAR 文件复制到项目的 mina-core-2.0.9.jar 文件（此示例中取决于该扩展）到项目的 ~/kie-server.war/WEB-INF/lib 目录中。例如，在红帽 JBoss EAP 上，此目录的路径是 EAP_HOME/standalone/deployments/kie-server.war/WEB-INF/lib。

6. 启动 KIE 服务器并将构建的项目部署到正在运行的 KIE 服务器。您可以使用 Business Central 接口或 KIE 服务器 REST API 部署项目（ PUT 请求到 http://SERVER:PORT/kie-server/services/rest/server/containers/{containerId}）。

   在正在运行的 KIE 服务器上部署项目后，您可以在 KIE 服务器日志中查看新数据传输的状态，然后开始使用您的新数据传输：

   服务器日志中的新数据传输

   Copy to Clipboard Toggle word wrap

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

   Copy to Clipboard Toggle word wrap

   telnet 127.0.0.1 9123

   在命令终端中与 KIE 服务器交互示例

   Copy to Clipboard Toggle word wrap

   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.

   服务器日志输出示例

   Copy to Clipboard Toggle word wrap

   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

流程

1. 创建一个空的 Maven 项目，并在项目的 pom.xml 文件中定义以下打包类型和依赖项：

   示例项目中的 pom.xml 文件示例

   Copy to Clipboard Toggle word wrap

   <packaging>jar</packaging>
   
   <properties>
      <version.org.kie>7.67.0.Final-redhat-00024</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>

2. 在项目中的 Java 类中实施相关的 ServicesClient 接口，如下例所示：

   RulesMinaServicesClient 接口示例

   Copy to Clipboard Toggle word wrap

   public interface RulesMinaServicesClient extends RuleServicesClient {
   
   }

   需要特定的接口，因为您必须基于接口注册客户端实施，而且只能有一个给定接口的实施。

   在本例中，基于自定义 MINA 的数据传输使用 Drools 扩展，因此本例 RulesMinaServicesClient 接口扩展了 Drools 扩展中现有的 RuleServicesClient 客户端 API。

3. 实施 KIE 服务器可以用来为新的 MINA 传输提供额外客户端功能的 RulesMinaServicesClient 接口，如下例所示：

   RulesMinaServicesClient 接口的实现示例

   Copy to Clipboard Toggle word wrap

   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 服务器会话

4. 在项目中的 Java 类中实施 org.kie.client.client.helper.KieServicesClientBuilder 接口，如下例所示：

   KieServicesClientBuilder 接口的实现示例

   Copy to Clipboard Toggle word wrap

   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;
       }
   
   }

   1

   可让您向通用 KIE 服务器客户端基础架构提供额外的客户端 API

   2

   定义客户端使用的 KIE 服务器功能(extension)

   3

   提供客户端实施的映射，其中键是接口，值是完全初始化的实现

5. 要使新客户端 API 发现 KIE 服务器客户端，请在 文件中创建一个 META-INF/services/org.kie.client.client.helper. KieServicesClientBuilder 文件，并在文件中添加完全限定的类名称。在本例中，该文件包含一行 org.kie.server.ext.mina.client.MinaClientBuilderImpl。
6. 构建您的项目，并将生成的 JAR 文件复制到项目的 ~/kie-server.war/WEB-INF/lib 目录中。例如，在红帽 JBoss EAP 上，此目录的路径是 EAP_HOME/standalone/deployments/kie-server.war/WEB-INF/lib。

7. 启动 KIE 服务器并将构建的项目部署到正在运行的 KIE 服务器中。您可以使用 Business Central 接口或 KIE 服务器 REST API 部署项目（ PUT 请求到 http://SERVER:PORT/kie-server/services/rest/server/containers/{containerId}）。

   在某个正在运行的 KIE 服务器上部署项目后，您可以开始与新的 KIE 服务器客户端交互。您可以采用与标准 KIE 服务器客户端相同的方法，创建客户端配置和客户端实例，并通过类型检索服务客户端，以及调用客户端方法。

   在本例中，您可以创建一个 RulesMinaServiceClient 客户端实例，并通过 MINA 传输调用 KIE 服务器上的操作：

   创建 RulesMinaServiceClient 客户端的实现示例

   Copy to Clipboard Toggle word wrap

   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 服务器操作的示例配置

   Copy to Clipboard Toggle word wrap

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

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 用户。
2. 单击 New user，输入用户名，然后单击 Next。
3. 若要为用户分配角色，请单击 Roles 选项卡，单击 Add Roles，选择所需角色，然后单击 Add to selected roles。
4. 可选： 要为用户分配组，点 Groups 选项卡，点 Add to groups，选择所需组，然后点 Add to selected groups。
5. 点 Create。
6. 单击 Yes 为用户设置密码，输入所需的密码，然后单击 更改。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 用户。
2. 在 All users 列表中点击您要编辑的用户。用户详情显示在右侧窗格中。

3. 点 Edit 执行以下任务：

   • 要更改用户组，点 Groups 选项卡，点 Add to groups，选择您希望用户所属的组，点 Add to selected groups，然后点 Save。
   • 要更改用户的角色，请单击 Roles 选项卡，单击 Add roles，选择您要分配给用户的角色，单击 Add to selected roles，然后单击 Save。
   • 要查看用户权限，请点击 权限选项卡 并展开属性。
   • 要更改密码，请单击" 更改密码"，输入新密码，然后单击" 更改 "。
   • 若要删除用户，请单击 Delete，然后单击 Yes 以确认删除。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 组。
2. 单击 New group，输入组名称，然后单击 Next。

3. 选择您要添加到此组的用户，然后点 Add selected users。

   新创建的组列在 All groups 下。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 组。
2. 在 All groups 列表中点击您要编辑的组。用户详情显示在右侧窗格中。
3. 从 Home Page 列表中选择主页。
4. 从优先级列表中选择 优先级。

5. 在 Permissions 部分中，展开 resource 属性并更改其权限。

   注意

   您可为 页面、编辑器、空格和 项目权限 添加例外。

6. 点击 Save 以应用更改。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，再选择 Artifacts。
2. 点 Open 查看工件详情。
3. 单击 Ok 以返回 Artifacts 页面。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，再选择 Artifacts。
2. 点 Download。
3. 浏览要保存工件的目录。
4. 点击 Save。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，再选择 Artifacts。
2. 点 Upload。
3. 点 Choose File 并浏览到您要上传工件的目录。

4. 点 Upload。

   注意

   如果您使用非 Maven 工件，首先使用 mvn deploy 命令将工件部署到 Maven 存储库，然后刷新 Business Central 中的构件列表。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 Data Sources。

2. 在 DataSource Explorer 窗格中，点 Add DataSource。

   New data source 窗口将打开。

3. 在 New data source 窗口中，输入数据源的" 名称 "、"连接 URL、用户 "、"密码" 和"驱动程序"字段。
4. 单击 Test Connection，以验证与数据库的连接。
5. 点 Finish。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 Data Sources。
2. 在 DataSource Explorer 窗格中，点击您要编辑的数据源。
3. 在 Data Source Definition 窗格中，对 Name、Connection URL、User、Password 和 Driver 字段进行必要的更改。
4. 单击 Test Connection，以验证与数据库的连接。
5. 点 Update。
6. 点击 Save。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 Data Sources。
2. 在 DataSource Explorer 窗格中，点击您要删除的数据源。
3. 单击 Remove。
4. 单击 Delete 以确认删除数据源。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 Data Sources。

2. 在 DataSource Explorer 窗格中，点 Add Driver。

   New driver 窗口将打开。

3. 在 New driver 窗口中，输入名称 ,Driver Class Name 、Group Id、Artifact Id 和 Version 字段。
4. 点 Finish。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 Data Sources。
2. 在 DataSource Explorer 窗格中，选择您要编辑的驱动程序。
3. 在 Driver Definition 窗格中，对 Name、Driver Class Name 、组 Id、Artifact Id 和 Version 字段进行必要的更改。
4. 点 Update。
5. 点 是。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 Data Sources。
2. 在 DataSource Explorer 窗格中，选择您要删除的驱动程序。
3. 单击 Remove。
4. 点击 Delete。

流程

1. 在 Business Central 中，前往 Admin → Data Sets。

   这时将打开 Data Sets 页面。

2. 点 New Data Set 并选择以下供应商类型之一：

   • bean： 从 Java 类生成数据集
   • CSV： 从远程或本地 CSV 文件中生成数据集
   • SQL： 从 ANSI-SQL 兼容数据库生成数据集
   • Elastic Search： 从 Elastic Search 节点生成数据集
   • Prometheus： 使用 Prometheus 查询生成数据集

   • Kafka： 使用 Kafka 代理、消费者或制作者中的指标生成数据集

     注意

     您必须为 Prometheus、Kafka 和 Execution Server 选项配置 KIE 服务器。

3. 完成 Data Set Creation Wizard 并点 Test。

   注意

   配置步骤根据您选择的供应商的不同而有所不同。

4. 点击 Save。

流程

1. 在 Business Central 中，前往 Admin → Data Sets。

   这时将打开 Data Set Explorer 页面。

2. 在 Data Set Explorer 窗格中，搜索您要编辑的数据集合，选择数据集，然后单击 Edit。

3. 在 Data Set Editor 窗格中，根据需要使用适当的标签页编辑数据。该选项卡会根据您选择的数据集供应商类型而有所不同。

   例如，以下更改可用于编辑 CSV 数据供应商：

   • CSV 配置： 使您能够更改数据集定义的名称、源文件、分隔符和其他属性。

   • preview ： 允许您预览数据。在 CSV Configuration 选项卡中点 Test 后，系统会执行数据集查找调用，如果数据可用，会出现一个预览。请注意，Preview 选项卡有两个子选项卡：

     • data 列： 允许您指定数据设置定义中的哪些列。
     • filter： 允许您添加新过滤器。

   • 高级： 使您能够管理以下配置：

     • 缓存： 请参阅缓存数据 以了解更多信息。
     • 通过 缓存生命周期，您可以指定数据设置（或数据）被刷新的时间间隔。当 后端数据 改变时，刷新缓存的数据功能。
4. 进行必要的更改后，单击 Validate。
5. 点击 Save。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 Archetypes。

   在 Status 列中，绿色图标指示它是一个有效的 archetype，红色图标表示它是一个无效的架构架构，而 blue 图标则表示对应的 archetype 是新空格的默认 archetype。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 Archetypes。
2. 单击 Add Archetype。
3. 在 Add Archetype 面板中，分别在 Group ID、Artifact ID 和 Version 字段中输入 GAV 属性。
4. 点击 Add。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 Archetypes。

2. 在 Actions 列中，点 archetype 右侧的 图标。

   • 从下拉菜单中选择 Delete，从列表中删除 archetype。

   • 从下拉菜单中选择 Validate 以验证 archetype 是否有效。

     注意

     启动 Business Central 后，会自动验证所有已注册的 archetypes。

   • 从下拉菜单中选择 Set as default，将 archetype 设置为新空格的默认值。

流程

1. 在 Business Central 中，转至 Menu → Design → Projects。
2. 从 archetype 模板选择或创建要向其添加新项目的空间。
3. 单击 Add Project。
4. 在 Name 和 Description 字段中分别键入项目名称和描述。
5. 点 Configure Advanced Options。
6. 选择 基于模板 复选框。

7. 如果需要，从下拉列表中选择 archetype。

   在命名空间中已经设置了默认的 archetype。

8. 点击 Add。

流程

1. 在 Business Central 中，转至 Menu → Design → Projects。
2. 选择或创建您要管理 archetypes 的空格。默认空间为 MySpace。
3. 单击 Settings。
4. 要在空间中包含或排除 archetypes，请选择 Include 复选框。
5. 在 Actions 列中，点 archetype 右侧的 图标，然后从下拉菜单中选择 Set 作为默认值，将 archetype 设置为空间的默认值。
6. 点击 Save。

流程

1. 在 系统上打开一个命令终端。

2. 运行 ssh-keygen 命令创建 SSH 密钥，如下例所示，其中 < user_login& gt; 是您的用户名：

   Copy to Clipboard Toggle word wrap

   ssh-keygen -t rsa -b 4096 -C "<user_login>"

   注意

   Business Central 密钥存储支持的 SSH 密钥格式是 ssh-rsa、ssh-dss、ecdsa-sha2-nistp256、ecdsa-sha2-nistp384 和 ecdsa-sha2-nistp521。

3. 提示时，按 Enter 并接受默认密钥文件位置，如下例所示，其中 < user_login& gt; 是您的用户名：

   Copy to Clipboard Toggle word wrap

   Enter a file in which to save the key (/home/<user_login>/.ssh/id_rsa): [Press enter]

4. 在命令提示符处，输入并确认密码短语：

   Copy to Clipboard Toggle word wrap

   Enter passphrase (empty for no passphrase): [Type a passphrase]
   Enter same passphrase again: [Type passphrase again]

5. 启动 ssh-agent ：

   Copy to Clipboard Toggle word wrap

   eval "$(ssh-agent -s)"
   Agent pid <any-number-here>

6. 将新的 SSH 私钥添加到 ssh-agent。如果您使用了不同的密钥名称，请在该代码中替换 id_rsa ：

   Copy to Clipboard Toggle word wrap

   ssh-add ~/.ssh/id_rsa

流程

1. 在 系统上打开一个命令终端。

2. 如下例所示，其中 id_rsa 是您的密钥名称：

   Copy to Clipboard Toggle word wrap

   cat ~/.ssh/id_rsa.pub

3. 复制 SSH 公钥的内容。
4. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 SSH Keys。
5. 在 SSH Keys 页面中，点 Add SSH Key。

6. 在 Add SSH Key 窗口中，在 Name 字段中输入名称，并将 SSH 公钥的内容复制到 Key 字段。

   注意

   Name 和 Key 字段是必须的。

7. 点 Add SSH Key 注册密钥。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 SSH Keys。
2. 在 SSH Keys 页面中，点击您要删除的 SSH 密钥的删除图标。
3. 单击 Delete SSH Key 以确认删除。

流程

1. 在 Business Central 中，前往 Menu → Design → Projects 并点项目名称。
2. 在项目窗口中，单击 Settings 选项卡。

3. 在 General Settings 选项卡中，执行以下任一任务：

   • 要启用其他项目具有相同的 GAV，请选择 Disable GAV conflict 复选框。
   • 要启用子项目具有 GAV 版本，请选择 Allow child GAV 版本 复选框。

4. 点击 Save。

   注意

   您可以点击 重置 来撤消所有更改。

5. 单击 Save 以确认更改。

流程

1. 在 Business Central 中，选择屏幕右上角的 Admin 图标，然后选择 项目。这时将打开 Projects 窗口。

2. 在 Advanced GAV 首选项 选项卡中，执行以下任一任务：

   • 要启用其他项目具有相同的 GAV，请选择 Disable GAV conflict 复选框。
   • 要启用子项目具有 GAV 版本，请选择 Allow child GAV 版本 复选框。
3. 点击 Save。

流程

1. 创建 post-commit Git hook 文件：

   Copy to Clipboard Toggle word wrap

   $ touch post-commit

2. 将 post-commit 文件的权限设置为 755 ：

   Copy to Clipboard Toggle word wrap

   $ chmod 755 post-commit

3. 将 #!/bin/bash 以及任何所需代码添加到 post-commit 文件中，例如：

   • 将所有更改推送到远程存储库：

     Copy to Clipboard Toggle word wrap

     #!/bin/bash
     git push origin +master

   • 记录信息：

     Copy to Clipboard Toggle word wrap

     #!/bin/bash
     echo 'Hello World'

   • 执行另一个文件的代码：

     Copy to Clipboard Toggle word wrap

     #!/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 通信。

     有关 post-commit Git hook 和 Java 代码示例的更多信息，请参阅 Business Central post-commit Git Hooks Integration。