管理红帽流程自动化管理器和 KIE 服务器设置

流程

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

3. 选择或清除任何列出的存储库选项，以启用或禁用重复的 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

流程

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

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

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

9. 完成安装。
10. 要验证 Process Automation Manager 控制器现在是否已与 Business Central 集成，请转至 Business Central 中的 Execution Servers 页面，并确认您在 REMOTE SERVERS 下配置的 KIE 服务器。

流程

1. 导航到红帽客户门户网站中的 Software Downloads 页面（需要登录），然后从下拉菜单中选择产品和版本：

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

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

   警告

   确保您复制的无头进程 Automation Manager 控制器部署的名称不会与 Red Hat JBoss EAP 实例中的现有部署冲突。

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

流程

1. 在终端应用中，前往 EAP_HOME/bin。

2. 如果您在与安装 KIE Server 的 Red Hat JBoss EAP 实例相同的 Red Hat JBoss EAP 实例上安装了无头处理 Automation Manager 控制器，请输入以下命令之一：

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

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

   • 在 Windows 中：

     standalone.bat -c standalone-full.xml

3. 如果您在与安装 KIE 服务器的 Red Hat JBoss EAP 实例独立的 Red Hat JBoss EAP 实例上安装了无头处理 Automation Manager 控制器，请使用 standalone.sh 脚本启动无头进程 Automation Manager 控制器：

   注意

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

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

     $ ./standalone.sh

   • 在 Windows 中：

     standalone.bat

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

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

流程

1. 导航到红帽客户门户网站中的 Software Downloads 页面（需要登录），然后从下拉菜单中选择产品和版本：

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

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

   警告

   确保您复制的无头进程 Automation Manager 控制器部署的名称不会与 Red Hat JBoss EAP 实例中的现有部署冲突。

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

10. 在 < system-properties> 元素中添加以下属性，并将 &lt ;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，则只有在服务器重启时，才会检测到模板文件的更改。

11. 要启动无头进程 Automation Manager 控制器，请导航到 EAP_HOME/bin 并输入以下命令：

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

      $ ./standalone.sh

    • 在 Windows 中：

      standalone.bat

流程

1. 要在 Business Central 中打开项目部署描述符配置，请打开 Menu → 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 键

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

3. 在 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 服务器位置和设置替换值。

4. 启动 KIE 服务器实例。

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

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

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

5. 在 REST 客户端或 curl 工具中，发送带有以下组件的 REST API 请求，以验证 KIE 服务器是否在发布指标：

   对于 REST 客户端：

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

   • HTTP Headers ：设置以下标头：

     • 接受: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 Server 用户的用户名和密码。

   • - 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.59.1-SNAPSHOT",} 1.557285486469E12

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

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

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

   

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

   

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

   

   图 15.4. 带有 KIE 服务器指标的 Grafana 仪表板

   

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

   

流程

1. 在 OpenShift 上的 KIE Server 部署的 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 Server，那么您可以在您计划用于 OpenShift 部署的 OpenShift 模板（例如： rhpam712-prod-immutable-kieserver.yaml）中，您可以将 PROMETHEUS_SERVER_EXT_DISABLED 模板参数设置为 false 来启用 Prometheus 扩展。

   如果您使用 OpenShift Operator 在 OpenShift 上部署 KIE 服务器，然后在 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"

2. 创建一个 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

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

   oc apply -f service-metrics.yaml

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

5. 创建定义 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

6. 在命令终端中，使用 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 表达式浏览器中与收集的指标交互，或者将 Prometheus 数据源与 Grafana 等数据工具集成。

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

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

   

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

   

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

   

   图 15.9. 带有 KIE 服务器指标的 Grafana 仪表板

   

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

   

流程

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

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

   <packaging>jar</packaging>
   
   <properties>
     <version.org.kie>7.59.0.Final-redhat-00006</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.server.services.prometheus.PrometheusMetricsProvider 接口实现相关的监听程序，作为定义自定义 Prometheus 指标的自定义监听程序类的一部分，如下例所示：

   自定义监听器类中的 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 指标。

3. 实施 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 侦听器类。

4. 要使 KIE 服务器发现新的指标提供程序，请在 Maven 项目中创建一个 META-INF/services/org.kie.server.services.prometheus.PrometheusMetricsProvider 文件，并在文件中添加 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 Server 镜像，并将此 JAR 文件添加到镜像中。有关使用额外 JAR 文件创建自定义 KIE Server 镜像的更多信息，请参阅使用 Operator 在 Red Hat OpenShift Container Platform 4 上部署 Red Hat Process Automation Manager 环境。

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

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

流程

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

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

   1. 在 Red Hat Process Automation Manager 安装目录中，进入 standalone-full.xml 文件。例如，如果您为 Red Hat Process Automation Manager 使用 Red Hat JBoss EAP 安装，请转到 $EAP_HOME/standalone/configuration/standalone-full.xml 文件。

   2. 打开 standalone-full.xml 文件，并在 &lt ;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 服务器持久性，请完成以下任务：

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

流程

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

   为变量持久性配置的 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;
   	}
   
   }

   1

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

   2

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

   3

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

   4

   将 data 对象配置为串行对象。

   5

   为对象设置持久性 ID。

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

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

   

2. 在项目的 pom.xml 文件中，添加以下依赖项以实现持久性支持。此依赖关系包含您在数据对象中配置的 VariableEntity 类。

   持久性的项目依赖项

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

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

   在 kie-deployment-descriptor.xml 文件中配置的 JPA marshaller 和持久性单元

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

4. 在项目的 ~/META-INF 目录中，创建一个 persistence.xml 文件，该文件指定要保留 process 变量的数据源：

   带有数据源配置的 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 策略、持久性单元和数据源，请导航到项目 Settings → Deployments → Marshalling Strategy 和 project Settings → Persistence ：

   图 17.2. 在 Business Central 中的 JPA marshaller 配置

   

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

   

流程

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

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

   <packaging>jar</packaging>
   
   <properties>
     <version.org.kie>7.59.0.Final-redhat-00006</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 接口的实现示例

   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 或 JMS （本例中为REST ），以及将资源返回为组件列表一部分的 CustomResource 类。

3. 实施 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 (JAXB、XStream)
     • JSON
   • 将有效负载放入 List<?> 集合，对于列表中的每个项目，创建一个 InsertCommand 实例，后跟 FireAllRules 和 GetObject 命令。
   • 向 BatchExecutionCommand 实例添加调用决策引擎的所有命令。
4. 要使 KIE Server 的新端点发现，请在 Maven 项目中创建一个 META-INF/services/org.kie.server.services.api.KieServerApplicationComponentsService 文件，并在文件中添加 KieServerApplicationComponentsService 实现类的完全限定名称。在本例中，文件包含一行 org.kie.server.ext.drools.rest.CusomtDroolsKieServerApplicationComponentsService。
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 Server 上后，您可以开始与新的 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

   • 消息有效负载示例：

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

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

   • 服务器日志输出示例：

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

   <packaging>jar</packaging>
   
   <properties>
     <version.org.kie>7.59.0.Final-redhat-00006</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 接口实现示例

   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

   
   }

   1

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

   2

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

   3

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

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

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

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

   text BasedIoHandlerAdapter 处理程序实现示例

   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 服务器会话，请向服务器发送 exit 或 quit 命令。
4. 要使 KIE 服务器发现新的数据传输，请在 Maven 项目中创建一个 META-INF/services/org.kie.server.services.api.KieServerExtension 文件，并在该文件中添加 KieServerExtension 实施类的完全限定类名称。在本例中，该文件包含一行 org.kie.server.ext.mina.MinaDroolsKieServerExtension。
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 服务器日志中查看新数据传输的状态，并开始使用新的数据传输：

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

   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

流程

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

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

   <packaging>jar</packaging>
   
   <properties>
      <version.org.kie>7.59.0.Final-redhat-00006</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 接口示例

   public interface RulesMinaServicesClient extends RuleServicesClient {
   
   }

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

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

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

   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 Server 客户端的默认配置，并使用 ServerUrl 提供 MINA 服务器的主机和端口
   • 将 JSON 指定为 marshalling 格式
   • 需要收到的消息是以打开的 bracket {开头的 JSON 对象。
   • 在等待响应的第一行时，使用与阻塞 API 的直接套接字通信，然后读取所有可用的行
   • 不使用流模式，因此在调用命令后断开 KIE 服务器会话

4. 在项目中的 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;
       }
   
   }

   1

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

   2

   定义客户端使用的 KIE 服务器功能（分机）

   3

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

5. 要使新的客户端 API 发现 KIE 服务器客户端，请在 Maven 项目中创建一个 META-INF/services/org.kie.server.client.helper.KieServicesClientBuilder 文件，并在文件中添加 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 Server 上部署项目后，您可以开始与新的 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 传输调用操作的示例配置

   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 中，选择屏幕右上角的 管理 图标，再选择 用户。
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 中，选择屏幕右上角的 管理 图标，再选择 用户。
2. 在 All users 列表中，点击您要编辑的用户。用户详情显示在右侧窗格中。

3. 点击 Edit 以执行以下任一任务：

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

流程

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

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

   新创建的组列在 All groups 下。

流程

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

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

   注意

   您可以为 Pages、Editor、Spaces 和 Projects 权限添加例外。

6. 点 Save 以应用更改。

流程

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

流程

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

流程

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

4. 点 Upload。

   注意

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

流程

1. 在 Business Central 中，选择屏幕右上角的 管理 图标，然后选择 数据源。

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

   New data source 窗口将打开。

3. 在 New data source 窗口中，输入数据源的名称 ,Connection URL,User,Password, 和 Driver 字段。
4. 单击 Test Connection 以验证与数据库的连接。
5. 点 Finish。

流程

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

流程

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

流程

1. 在 Business Central 中，选择屏幕右上角的 管理 图标，然后选择 数据源。

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

   此时会打开 New driver 窗口。

3. 在 New driver 窗口中，输入数据库驱动程序的 Name,Driver Class Name , Group Id ,Artifact Id, 和 Version 字段。
4. 点 Finish。

流程

1. 在 Business Central 中，选择屏幕右上角的 管理 图标，然后选择 数据源。
2. 在 DataSource Explorer 窗格中，选择您要编辑的驱动程序。
3. 在 Driver Definition 窗格中，对 Name、Driver Class Name 、Group Id、Arfact Id 和 Version 字段进行必要的更改。
4. 点 Update。
5. 单击 Yes 。

流程

1. 在 Business Central 中，选择屏幕右上角的 管理 图标，然后选择 数据源。
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 后，系统会执行数据集 lookup 调用，如果数据可用，则会出现预览。请注意，Preview 选项卡有两个子选项卡：

     • data 列： 允许您指定哪些列是数据集定义的一部分。
     • filter： 允许您添加新过滤器。

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

     • 缓存： 如需更多信息，请参阅缓存数据。
     • 缓存生命周期 允许您指定刷新数据集（或数据）的时间间隔。当后端 数据更改时，对过时的数据功能的 Refresh 会刷新缓存的数据。
4. 进行所需的更改后，单击 Validate。
5. 点击 Save。

流程

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

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

流程

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

流程

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

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

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

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

     注意

     当 Business Central 启动时，会自动验证所有注册的原型。

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

流程

1. 在 Business Central 中，前往 Menu → Design → Projects。
2. 从 archetype 模板选择要添加新项目的空格。
3. 单击 Add Project。
4. 在 Name 和 Description 字段中，输入项目名称和描述。
5. 单击 Configure Advanced Options。
6. 选中 Based on template 复选框。
7. 如果需要，从下拉列表中选择 archetype from-down 选项。选择了已在空间中设置的默认 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; 是您的用户名：

   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; 是您的用户名：

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

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

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

5. 启动 ssh-agent ：

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

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

   ssh-add ~/.ssh/id_rsa

流程

1. 在您的系统上打开终端。

2. 运行 cat 命令，如下例所示，其中 id_rsa 是您的密钥名称：

   cat ~/.ssh/id_rsa.pub

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

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

   注意

   Name 和 Key 字段是必需的。

7. 单击 Add SSH Key 以注册密钥。

流程

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