HawtIO tuning Console Guide

1. 在 settings.xml 文件中，为红帽软件仓库添加 存储库 元素，如下例所示：

   <?xml version="1.0"?>
   <settings>
   
     <profiles>
       <profile>
         <id>extra-repos</id>
         <activation>
           <activeByDefault>true</activeByDefault>
         </activation>
         <repositories>
          <repository>
            <id>redhat-ga-repository</id>
            <url>https://maven.repository.redhat.com/ga</url>
            <releases>
              <enabled>true</enabled>
            </releases>
            <snapshots>
              <enabled>false</enabled>
            </snapshots>
           </repository>
           <repository>
             <id>redhat-ea-repository</id>
             <url>https://maven.repository.redhat.com/earlyaccess/all</url>
             <releases>
               <enabled>true</enabled>
             </releases>
             <snapshots>
               <enabled>false</enabled>
             </snapshots>
           </repository>
         </repositories>
         <pluginRepositories>
           <pluginRepository>
             <id>redhat-ga-repository</id>
             <url>https://maven.repository.redhat.com/ga</url>
             <releases>
               <enabled>true</enabled>
             </releases>
             <snapshots>
               <enabled>false</enabled>
             </snapshots>
           </pluginRepository>
           <pluginRepository>
             <id>redhat-ea-repository</id>
             <url>https://maven.repository.redhat.com/earlyaccess/all</url>
             <releases>
               <enabled>true</enabled>
             </releases>
             <snapshots>
               <enabled>false</enabled>
             </snapshots>
           </pluginRepository>
         </pluginRepositories>
       </profile>
     </profiles>
   
     <activeProfiles>
       <activeProfile>extra-repos</activeProfile>
     </activeProfiles>
   
   </settings>

流程

1. 使用 jbang 命令在您的机器上安装最新版本的 HawtIO ：

   $ jbang app install -Dhawtio.jbang.version=4.1.0.redhat-00015 hawtio@hawtio/hawtio

   注意

   这个安装方法仅适用于 jbang>=0.115.0。

2. 它将安装 HawtIO 命令。使用以下命令启动 HawtIO 实例：

   $ hawtio

3. 该命令将在 http://localhost:8080/hawtio/ 自动打开控制台。要更改端口号，请运行以下命令：

   $ hawtio --port 8090

4. 如需有关 CLI 配置选项的更多信息，请运行以下代码：

   $ hawtio --help
   Usage: hawtio [-hjoV] [-c=<contextPath>] [-d=<plugins>] [-e=<extraClassPath>]
                 [-H=<host>] [-k=<keyStore>] [-l=<warLocation>] [-p=<port>]
                 [-s=<keyStorePass>] [-w=<war>]
   Run HawtIO
     -c, --context-path=<contextPath>
                         Context path.
     -d, --plugins-dir=<plugins>
                         Directory to search for .war files to install as 3rd
                           party plugins.
     -e, --extra-class-path=<extraClassPath>
                         Extra class path.
     -h, --help          Print usage help and exit.
     -H, --host=<host>   Hostname to listen to.
     -j, --join          Join server thread.
     -k, --key-store=<keyStore>
                         JKS keyStore with the keys for https.
     -l, --war-location=<warLocation>
                         Directory to search for .war files.
     -o, --open-url      Open the web console automatic in the web browser.
     -p, --port=<port>   Port number.
     -s, --key-store-pass=<keyStorePass>
                         Password for the JKS keyStore with the keys for https.
     -V, --version       Print HawtIO version
     -w, --war=<war>     War file or directory of the hawtio web application.

1. 将 io.hawt:hawtio-quarkus 和支持的 Camel Quarkus 扩展添加到 pom.xml 中的依赖项：

   <dependencyManagement>
     <dependencies>
       <dependency>
         <groupId>io.hawt</groupId>
         <artifactId>hawtio-bom</artifactId>
         <version>4.1.0.redhat-00015</version>
         <type>pom</type>
         <scope>import</scope>
       </dependency>
     </dependencies>
     <!-- ... other BOMs or dependencies ... -->
   </dependencyManagement>
   
   <dependencies>
     <dependency>
       <groupId>io.hawt</groupId>
       <artifactId>hawtio-quarkus</artifactId>
     </dependency>
   
      <!-- Mandatory for enabling Camel management via JMX / HawtIO -->
     <dependency>
       <groupId>org.apache.camel.quarkus</groupId>
       <artifactId>camel-quarkus-management</artifactId>
     </dependency>
   
     <!-- (Optional) Required for HawtIO Camel route diagram tab -->
     <dependency>
       <groupId>org.apache.camel.quarkus</groupId>
       <artifactId>camel-quarkus-jaxb</artifactId>
     </dependency>
   
     <!-- ... other dependencies ... -->
   </dependencies>

2. 通过将以下配置添加到 application.properties 来禁用身份验证：

   quarkus.hawtio.authenticationEnabled = false

   1. 您还可以配置身份验证。请参阅"Quarkus 身份验证机制"。

3. 在开发模式下运行带有 Quarkus 应用程序的 HawtIO，如下所示：

   mvn compile quarkus:dev

4. 打开 http://localhost:8080/hawtio/ 以查看 HawtIO 控制台。

流程

1. 将 io.hawt:hawtio-springboot 和支持的 Camel Spring Boot starters 添加到 pom.xml 中的依赖项中：

   <dependencyManagement>
     <dependencies>
       <dependency>
         <groupId>io.hawt</groupId>
         <artifactId>hawtio-bom</artifactId>
         <version>4.1.0.redhat-00015</version>
         <type>pom</type>
         <scope>import</scope>
       </dependency>
       <!-- ... other BOMs or dependencies ... -->
     </dependencies>
   </dependencyManagement>
   
   <dependencies>
     <dependency>
       <groupId>io.hawt</groupId>
       <artifactId>hawtio-springboot</artifactId>
     </dependency>
   
      <!-- Mandatory for enabling Camel management via JMX / HawtIO -->
     <dependency>
       <groupId>org.apache.camel.springboot</groupId>
       <artifactId>camel-management-starter</artifactId>
     </dependency>
   
     <!-- (Optional) Required for HawtIO Camel route diagram tab -->
     <dependency>
       <groupId>org.apache.camel.springboot</groupId>
       <artifactId>camel-spring-boot-xml-starter</artifactId>
     </dependency>
   
     <!-- ... other dependencies ... -->
   </dependencies>

2. 通过将以下行添加到 application.properties 来启用 HawtIO 和 Jolokia 端点：

   spring.jmx.enabled = true
   management.endpoints.web.exposure.include = hawtio,jolokia

3. 在开发模式下运行带有 Spring Boot 应用程序的 HawtIO，如下所示：

   mvn spring-boot:run

4. 打开 http://localhost:8080/actuator/hawtio 以查看 HawtIO 控制台。

1. 准备 Keycloak 服务器
2. 将 HawtIO 部署到 favourite 运行时(Quarkus、Spring Boot、Wild、Jetty、Tomcat 等)，并将它配置为使用 Keycloak 进行身份验证

1. 在 Web 浏览器中以具有 集群管理员访问权限 的用户身份登录 OpenShift 控制台。
2. 点 Operators，然后点 OperatorHub。
3. 在搜索字段窗口中，键入 HawtIO 来过滤操作器列表。单击 HawtIO Operator。

4. 在 HawtIO Operator 安装窗口中，单击 Install。Create Operator Subscription 表单将打开：

   1. 对于 更新频道，请选择 stable-v1。

   2. 对于 Installation Mode，接受 default （集群中的特定命名空间）。

      注意

      此模式决定了 Operator 将监控 HawtIO CR 的命名空间。这与命名空间 HawtIO 在完全部署时监控它不同。后者可以通过 HawtIO CR 配置。

   3. 对于 Installed Namespace，选择要在其中安装 HawtIO Operator 的命名空间。

   4. 对于 Update Approval，选择 Automatic 或 Manual 来配置 OpenShift 如何处理对 HawtIO Operator 的更新。

      1. 如果选择了 Automatic 更新选项，且有新版本的 HawtIO Operator，OpenShift Operator Lifecycle Manager (OLM)将自动升级运行 HawtIO 的实例，而无需人为干预；
      2. 如果选择了 Manual 更新选项，且有较新的 Operator 版本可用，OLM 只会创建更新请求。然后，集群管理员必须手动批准更新请求，使 HawtIO Operator 更新至新版本。
5. 点 Install and OpenShift 将 HawtIO Operator 安装到当前命名空间中。
6. 要验证安装，点 Operators，然后点 Installed Operators。HawtIO 应在操作器列表中可见。

7. 使用 OpenShift Web 控制台部署 HawtIO：

   1. 在 Installed Operators 列表中，单击 Name 列下的 HawtIO Operator。
   2. 在 Provided APIs 下的 Operator Details 页面中，单击 Create HawtIO。

   3. 接受配置默认值或选择性地编辑它们。

      1. 对于 Replicas，要提高 HawtIO 性能（例如在高可用性环境中），可以增加分配给 HawtIO 的 pod 数量；
      2. 对于 RBAC （基于角色的访问控制），只有在您要自定义默认的 RBAC 行为以及安装 HawtIO Operator 的命名空间中已存在时，才在 Config Map 字段中指定一个值
      3. 对于 Nginx，请参阅 HawtIO Operator 安装的性能调整

      4. 对于 类型，请指定：

         1. Cluster: 用于 HawtIO 监控 OpenShift 集群上的所有命名空间，适用于任何启用了 HawtIO 的应用；
         2. 命名空间 ：对于 HawtIO，仅监控在同一命名空间中部署的启用了 HawtIO 的应用程序。
   4. 点 Create。HawtIO Operator Details 页面将打开，并显示部署的状态。

8. 打开 HawtIO ：

   1. 对于 命名空间 部署：在 OpenShift Web 控制台中，打开安装 HawtIO 操作器的项目，然后选择 Overview。在 Project Overview 页面中，向下滚动到 Launcher 部分，再单击 HawtIO 链接。
   2. 对于 集群部署，在 OpenShift Web 控制台的标题栏中，单击网格图标。在弹出菜单中，单击 Red Hat Applications 下的 HawtIO URL 链接。
   3. 登录到 HawtIO。在列出所需权限的浏览器中打开 Authorize Access 页面。
   4. 点击 Allow selected permissions。HawtIO 在浏览器中打开，并显示任何有权访问的 HawtIO 的应用容器集。
9. 点 Connect 查看被监控的应用程序。这时将打开一个新的浏览器窗口，显示 HawtIO 中的应用程序。

1. admin: 如果用户可以在 OpenShift 中更新 pod，则用户会被路由了 HawtIO 的 admin 角色。用户可以在 HawtIO 中对 pod 执行写入 MBean 操作。
2. viewer: 如果用户可以在 OpenShift 中获取 pod，则用户会被路由了 HawtIO 的 viewer 角色。用户可以在 HawtIO 中对 pod 执行只读 MBean 操作。

1. auth: 身份验证配置 | type: object

   1. clientCertCheckSchedule: CronJob 调度，用于定义检查证书的过期频率。如果没有设置调度，则不会启用客户端轮转 | type: 字符串
   2. clientCertCommonName: 生成的客户端证书 CN | type: 字符串
   3. clientCertExpirationDate: 生成的客户端证书过期日期 | type: 字符串 | format: date-time
   4. clientCertExpirationPeriod ：证书过期日期前的持续时间，在此期间可以轮转证书。默认值为 24 小时 | 类型：整数

2. config: HawtIO 控制台配置 | 类型：对象

   1. 关于： 在 About 页面中显示的信息 | type: object

      1. additionalInfo: description 部分的文本 | type: string
      2. Copyright: 版权部分的文本 | type: 字符串
      3. imgSrc ：页面中显示的镜像。它可以是相对于 HawtIO 状态 URL 的路径，也可以是绝对 URL | 类型：字符串

      4. productInfo: 产品信息列表 | 类型：数组

         1. items: 在 About 页面中显示的产品信息 | type: object | required: [ "name", "value" ]

            1. name ：产品信息的名称 | type: 字符串
            2. 值 ：产品信息的值 | type: string
      5. title: 页面的标题 | type: 字符串

   2. 品牌 ：用户界面品牌 | 类型：对象

      1. appLogoUrl ：导航栏中显示的徽标 URL。它可以是相对于 HawtIO 状态 URL 的路径，也可以是绝对 URL。| type: 字符串
      2. appName ：应用程序标题，它通常显示在 Web 浏览器标签页中。| type:字符串
      3. CSS ：外部 CSS 风格表的 URL，可用于风格应用程序。它可以是相对于 HawtIO 状态 URL 的路径，也可以是绝对 URL。| type: 字符串
      4. favicon: favicon 的 URL，通常显示在 Web 浏览器选项卡中。它可以是相对于 HawtIO 状态 URL 的路径，也可以是绝对 URL。| type: 字符串

   3. disabledRoutes ：禁用具有匹配路由的 UI 组件 | type: 数组 |

      1. items:type: string

   4. 在线 ：OpenShift 相关配置 | 类型：对象

      1. ConsoleLink ：OpenShift Web 控制台链接的配置。当 HawtIO 部署等于 'cluster' 时，会将链接添加到应用程序菜单。否则，链接会添加到 HawtIO 项目仪表板中。| type: object

         1. imageRelativePath ：路径相对于 HawtIO 状态 URL，用于应用程序菜单中链接前面的图标。只有在 HawtIO 部署类型等于 集群 时才适用。该镜像应该为方括号，将显示在 24x24 pixels. | type: 字符串
         2. 第 : 应该出现链接的应用程序菜单的部分。只有在 HawtIO 部署类型等于 'cluster' 时才适用。| type: 字符串
         3. 文本: 链接的文本显示 | type: 字符串
      2. ProjectSelector ：用于监视项目的选择器。只有在 HawtIO 部署类型等于 'cluster' 时才适用。默认情况下，登录的用户有权访问的所有项目都将被监视。必须提供选择器的字符串表示，如 opend by the- selector, or -l, options from kubectl get 命令。请参阅： Kubernetes Labels 和 Selectors | type: 字符串

3. externalRoutes ：将由 Operator 注解的外部路由名称列表，以使用 routes | type: 数组访问控制台。

   1. items:type: string

4. metadataPropagation ：在 HawtIO 自定义资源上将元数据传播到生成的资源（如部署、Pod、服务和路由 | 类型）的配置

   1. annotations: Annotations to propagate | type: array |

      1. items:type: string

   2. 标签：要传播 | type: 数组 的标签 |

      1. items:type: string

5. Nginx ：Nginx 运行时配置 类型：object

   1. clientBodyBufferSize ：读取客户端请求正文的缓冲区大小。默认值为 256k. | type: 字符串
   2. proxyBuffers ：用于从代理服务器读取响应的缓冲区的数量和大小，用于单个连接。默认为 16 128k. | type: 字符串
   3. subrequestOutputBufferSize ：用于存储子请求的响应正文的缓冲区的大小。默认值为 10m。| 类型：字符串

6. RBAC ：RBAC 配置 | 类型：对象

   1. ConfigMap : 包含 ACL 定义的 ConfigMap 名称。| type:字符串
   2. disableRBACRegistry ：禁用 RBACRegistry 带来的性能改进，并恢复到经典的行为。默认为 false. | type: boolean
7. 副本 ：所需 pod 的数量。这是一个指针，用于区分显式零和未指定的。默认为 1. | type: integer | format: int32

8. 资源 ： HawtIO 控制台计算资源 | 类型：对象

   1. claim : Claims 列出此容器使用的 spec.resourceClaims 中定义的资源名称。这是一个 alpha 字段，需要启用 DynamicResourceAllocation 功能门。此字段不可变。它只能为容器设置。| type: 数组 |

      1. items: ResourceClaim 引用 PodSpec.ResourceClaims 中的一个条目。| type: object | required: [ "name" ]
      2. 名称 ：名称必须与使用此字段的 Pod.spec.resourceClaims 中的一个条目的名称匹配。它使该资源在容器内可用。| type: 字符串
   2. 限制 ：限制描述了允许的最大计算资源量。请参阅： Kubernetes 资源管理 Pod 和容器 | 类型：对象
   3. Request: Requests 描述了所需的最少计算资源。如果容器省略了 Requests，则默认为 Limits （如果明确指定），否则默认为实现定义的值。请求不能超过限值。请参阅： Kubernetes 资源管理 Pod 和容器 | 类型：对象

9. Route: 用于路由的自定义证书配置（在大多数 OpenShift 安装中不需要）。| 类型：对象

   1. caCert: Ca certificate secret key selector | type: object | required: [ "key" ]

      1. Key: 要从中选择的 secret 的密钥。必须是有效的 secret 密钥。| type: 字符串
      2. 名称 ：引用的名称。请参阅： Kubernetes Names | type: string
      3. 可选 ：指定是否需要定义 Secret 或其密钥 | type: 布尔值

   2. certSecret: TLS secret 的名称，带有用于路由 TLS 终止的自定义证书 | type: object

      1. 名称 ：引用的名称。请参阅： Kubernetes Names | type: string
10. routeHostName ：在外部公开 HawtIO 服务的路由的边缘主机名。如果没有指定，则自动生成它，格式为： [-]。其中 是为集群配置的默认路由子域。请注意，如果字段被禁止，Operator 将重新创建路由，以便重新生成主机。| type: 字符串

11. 类型 ：部署类型。默认为 集群. | type: 字符串

    1. Cluster : HawtIO 能够发现和管理经过身份验证的用户可以访问的所有命名空间中的应用程序。
    2. Namespace: HawtIO 能够发现和管理部署命名空间中的应用程序。
12. Version: HawtIO 控制台容器镜像版本。弃用: 为旧的 operator (<1.0.0)仍然需要它进行安装。| type: 字符串

1. 根据需要自定义这些值：

   archetypeVersion

   4.8.0.redhat-00022

   groupId

   io.hawtio.online.examples

   artifactId

   hawtio-online-example-camel-springboot-os

   version

   1.0.0

2. 运行 maven archetype：

   mvn archetype:generate  \
     -DarchetypeGroupId=org.apache.camel.archetypes  \
     -DarchetypeArtifactId=camel-archetype-spring-boot  \
     -DarchetypeVersion=4.8.0.redhat-00022  \
     -DgroupId=io.hawt.online.examples  \
     -DartifactId=hawtio-online-example  \
     -Dversion=1.0.0  \
     -DinteractiveMode=false \
     -Dpackage=io.hawtio

3. 更改到名为 artifactId 的新项目（上例中为 hawtio-online-example）

   创建 hello world 应用程序示例，您可以编译它。

   此时，应用程序应该在本地执行。

4. 使用 mvn spring-boot:run maven 目标来测试应用程序：

   $ mvn spring-boot:run

1. 将所需的依赖项添加到 < dependencies> 部分：

   <dependencies>
     ...
   
     <!-- Camel -->
     ...
   
     <!-- Dependency is mandatory for exposing Jolokia endpoint -->
     <dependency>
         <groupId>org.apache.camel.springboot</groupId>
         <artifactId>camel-jolokia-starter</artifactId>
     </dependency>
   
     <!-- Optional: enables debugging support for Camel -->
     <dependency>
       <groupId>org.apache.camel</groupId>
       <artifactId>camel-debug</artifactId>
       <version>4.8.0</version>
    </dependency>
   
   ...
   </dependencies>

   有关配置详情，请参阅 Jolokia 组件文档

2. 要启用动态监控，根据 Spring Boot 文档 在 application.properties 文件中添加以下属性：

   camel.springboot.inflight-repository-browse-enabled=true

1. 先决条件

   • 选择适当的项目( 请参阅文档)；
   • 所有文件均已配置。

2. 运行以下 maven 命令：

   mvn clean install -DskipTests -P openshift

   该应用使用 S2I 编译 并部署到 OpenShift。

3. 验证 Spring Boot 应用程序是否在正确运行：

   按照 Red Hat build of Quarkus 文档中的 Deploying Red Hat build of Quarkus Java applications to OpenShift Container Platform 部分中详述的验证步骤。

4. 当您的新 Spring Boot 应用程序正常运行时，由 HawtIO 实例发现它（取决于其模式 - 'Namespace' 模式需要它在同一项目中）。

   新容器应在以下屏幕截图中显示：

   

5. 点 Connect 以检查 Spring Boot 应用程序可以使用 HawtIO：

   

1. 对于新的 Quarkus 应用程序，maven quarkus quick-start 可用，例如：

   mvn com.redhat.quarkus.platform:quarkus-maven-plugin:<quarkus.platform.version>:create\
   -DprojectGroupId=org.hawtio \
   -DprojectArtifactId=quarkus-helloworld \
   -Dextensions='openshift,camel-quarkus-quartz'

   注意

   使用 Camel Quarkus 官方文档中的最新的 quarkus.platform.version。

   1. 使用 quarkus-maven-plugin 生成项目构建
   2. 将项目 maven groupId 设置为 org.hawtio，并根据情况进行自定义
   3. 将项目 maven artifactId 设置为 quarkus-helloworld，并根据情况自定义

   4. 使用以下 Quarkus 扩展：

      1. OpenShift ：启用 maven 以部署到本地 OpenShift 集群；
      2. camel-quarkus-quartz ：启用 Camel 扩展 quartz 以便在示例 Quarkus 应用程序中使用
   5. 执行 quick-start 为 Quarkus 项目创建构建，然后允许对单个应用程序进行进一步自定义。

2. 要构建应用并将其部署到 OpenShift，应在 src/main/resources/application.properties 文件中指定以下属性( 请参阅相关文档)。

     # Set the Docker build strategy
     quarkus.openshift.build-strategy=docker
   
     # Expose the service to create an OpenShift Container Platform route
     quarkus.openshift.route.expose=true

1. 在本例中，将实施简单的 Camel 'hello-world' Quarkus 应用。使用以下内容将 src/main/java/org/hawtio/SampleCamelRoute.java 文件添加到项目中：

   package org.hawtio;
   
   import jakarta.enterprise.context.ApplicationScoped;
   import org.apache.camel.builder.endpoint.EndpointRouteBuilder;
   
   @ApplicationScoped
   public class SampleCamelRoute extends EndpointRouteBuilder
   {
   
   	@Override
   	public void configure()
   	{
   		from(quartz("cron").cron("{{quartz.cron}}")).routeId("cron")
   			.setBody().constant("Hello Camel! - cron")
   			.to(stream("out"))
   			.to(mock("result"));
   
        	from("quartz:simple?trigger.repeatInterval={{quartz.repeatInterval}}").routeId("simple")
   			.setBody().constant("Hello Camel! - simple")
   			.to(stream("out"))
   			.to(mock("result"));
   	}
   }

   1. 这个示例通过 Camel 路由在容器日志中记录 "Hello Camel …​" 条目。

2. 使用以下属性修改 src/main/resources/application.properties 文件：

     # Camel
     camel.context.name = SampleCamel
   
     # Uncomment the following to enable the Camel plugin Trace tab
     #camel.main.tracing = true
     #camel.main.backlogTracing = true
     #camel.main.useBreadcrumb = true
   
     # Uncomment to enable debugging of the application and in turn
     # enables the Camel plugin Debug tab even in non-development
     # environment
     #quarkus.camel.debug.enabled = true
   
     # Define properties for the Camel quartz component used in the
     # example
     quartz.cron = 0/10 * * * * ?
     quartz.repeatInterval = 10000

3. 将以下依赖项添加到文件 pom.xml 的 & lt;dependencies > 部分。由于 src/main/java/org/hawtio/SampleCamelRoute.java 中定义的路由需要这些；如果添加到应用程序的 Camel 路由发生了变化，则需要修改它们：

   <dependency>
     <groupId>org.apache.camel.quarkus</groupId>
     <artifactId>camel-quarkus-stream</artifactId>
   </dependency>
   <dependency>
     <groupId>org.apache.camel.quarkus</groupId>
     <artifactId>camel-quarkus-mock</artifactId>
   </dependency>

1. 为确保 maven 属性可以传递给 src/main/resources/application.properties 文件，应将以下内容添加到 pom.xml 文件的 & lt;build > 部分：

   <resources>
     <resource>
       <directory>src/main/resources</directory>
       <filtering>true</filtering>
     </resource>
   </resources>

2. 将以下 Jolokia 属性添加到文件 pom.xml 的 <properties > 部分。它们将用于在 Quarkus 容器中配置正在运行的 jolokia java-agent （有关属性的说明，请参阅 Jolokia JVM 代理 文档）：

     <properties>
     	...
   
     	<!-- The current HawtIO Jolokia Version -->
     	<jolokia-version>2.1.0</jolokia-version>
   
     	<!--
   
       ===============================================================
       === Jolokia agent configuration for the connection with HawtIO
       ===============================================================
   
   	It should use HTTPS and SSL client authentication at minimum.
   	The client principal should match those the HawtIO instance provides (the default is `hawtio-online.hawtio.svc`).
     	-->
     	<jolokia.protocol>https</jolokia.protocol>
     	<jolokia.host>*</jolokia.host>
     	<jolokia.port>8778</jolokia.port>
   	<jolokia.useSslClientAuthentication>true</jolokia.useSslClientAuthentication>
   	<jolokia.caCert>/var/run/secrets/kubernetes.io/serviceaccount/service-ca.crt</jolokia.caCert>
     	<jolokia.clientPrincipal.1>cn=hawtio-online.hawtio.svc</jolokia.clientPrincipal.1>
     	<jolokia.extendedClientCheck>true</jolokia.extendedClientCheck>
     	<jolokia.discoveryEnabled>false</jolokia.discoveryEnabled>
   
   	...
     </properties>

3. 将以下依赖项添加到文件 pom.xml 的 < dependencies > 部分：

   <!--
   	This dependency is required for enabling Camel management via JMX / HawtIO.
   -->
   <dependency>
   	<groupId>org.apache.camel.quarkus</groupId>
   	<artifactId>camel-quarkus-management</artifactId>
   </dependency>
   
   <!--
   	This dependency is optional for monitoring with HawtIO but is required for HawtIO view the Camel routes source XML.
   -->
   <dependency>
   	<groupId>org.apache.camel.quarkus</groupId>
   	<artifactId>camel-quarkus-jaxb</artifactId>
   </dependency>
   
   <!--
   	Add this optional dependency, to enable Camel plugin debugging feature.
   -->
   <dependency>
   	<groupId>org.apache.camel.quarkus</groupId>
   	<artifactId>camel-quarkus-debug</artifactId>
   </dependency>
   
   <!--
   	This dependency is required to include the Jolokia agent jvm for
   	access to JMX beans.
   -->
   <dependency>
   	<groupId>org.jolokia</groupId>
   	<artifactId>jolokia-agent-jvm</artifactId>
   	<version>${jolokia-version}</version>
   	<classifier>javaagent</classifier>
   </dependency>

4. 实施 maven 属性过滤后，${jolokia…​} 环境变量应该在构建应用程序期间从 pom.xml 传递。此属性的目的是将 JVM 选项附加到运行 jolokia java-agent 的容器的执行过程中。使用以下属性修改 src/main/resources/application.properties 文件：

   # Enable the jolokia java-agent on the quarkus application
   quarkus.openshift.env.vars.JAVA_OPTS_APPEND=-javaagent:lib/main/org.jolokia.jolokia-agent-jvm-${jolokia-version}-javaagent.jar=protocol=${jolokia.protocol}\,host=${jolokia.host}\,port=${jolokia.port}\,useSslClientAuthentication=${jolokia.useSslClientAuthentication}\,caCert=${jolokia.caCert}\,clientPrincipal.1=${jolokia.clientPrincipal.1}\,extendedClientCheck=${jolokia.extendedClientCheck}\,discoveryEnabled=${jolokia.discoveryEnabled}

1. 要使 HawtIO 发现部署的应用程序，执行容器必须具有名为 jolokia 的端口。因此，需要在 src/main/resources/application.properties 文件中添加以下属性：

   # Define the Jolokia port on the container for HawtIO access
   quarkus.openshift.ports.jolokia.container-port=${jolokia.port}
   quarkus.openshift.ports.jolokia.protocol=TCP

1. 命令行(CLI)已登录到 OpenShift 集群，并选择了 项目。

2. 配置了所有文件后，可以执行以下 maven 命令：

   ./mvnw clean package -Dquarkus.kubernetes.deploy=true

3. 使用 此处 详述的验证步骤验证 Quarkus 应用程序是否在正确运行。

4. 假设应用程序正确运行，新的 Quarkus 应用程序应该由 HawtIO 实例发现（取决于其 mode - 'Namespace' 模式要求它在同一项目中）。新容器应在以下屏幕截图中显示：

   

5. 通过单击 Connect，可以通过 HawtIO 检查 Quarkus 应用程序。

   

1. 将 Quarkus 应用程序部署到 OpenShift
2. Quarkus 应用程序： Getting started
3. 使用 Quarkus Openshift 扩展

1. 在 Camel 选项卡的树视图中，点 Camel Contexts。
2. 选中列表中一个或多个上下文旁边的框。
3. 点 Start 或 Suspend。

4. 删除上下文：

   1. 停止上下文。
   2. 单击省略图标，然后从下拉菜单中选择删除。

1. 在 Camel 选项卡的树视图中，点 Camel 应用程序。
2. 要查看应用属性和值列表，请单击 Attributes。
3. 要查看应用程序属性的图形表示，请点 Chart，然后点 Edit 以选择您要在图表中看到的属性。
4. 要查看动态和阻止的交换，请点 Exchanges。
5. 要查看应用端点，请单击 Endpoints。您可以根据 URL、路由ID 和 方向 过滤列表。
6. 要查看、启用和禁用与 Camel 内置类型转换机制相关的统计信息，该机制用于将消息正文和消息标头转换为不同类型的消息，请单击 Type Converters。
7. 要查看和执行 JMX 操作，如从 XML 添加或更新路由，或查找 classpath 中提供的所有 Camel 组件，请单击 Operations。

1. 查看路由列表 ：

   1. 点 Camel 标签页。

   2. 在 tree 视图中，点应用程序的 routes 文件夹：

      

2. 启动、停止或删除一个或多个路由 ：

   1. 选中列表中一个或多个路由旁边的框。
   2. 点 Start 或 Stop。

   3. 要删除路由，您必须首先停止它。然后单击省略图标，然后从下拉菜单中选择 删除。

      
      注意
      • 删除路由时，您可以将其从部署的应用程序中删除。
      • 您也可以在树形视图中选择一个特定的路由，然后单击右上角的菜单来启动、停止或删除。
3. 要查看路由的图形图表，请点 Route 图表。
4. 要查看动态和阻止的交换，请点 Exchanges。
5. 要查看端点，请单击 Endpoints。您可以根据 URL、Route ID 和 direction 来过滤列表。
6. 点 Type Converters 查看、启用和禁用与 Camel 内置类型转换机制相关的统计信息，用于将消息正文和消息标头转换为不同的类型。

7. 与特定路由交互 ：

   1. 在 Camel 选项卡的树视图中，选择一个路由。要查看路由属性和值列表，请单击 Attributes。
   2. 要查看路由属性的图形表示，请点 Chart。您可以点 Edit 来选择要在图表中看到的属性。
   3. 要查看动态和阻止的交换，请点 Exchanges。
   4. 单击 Operations 以在路由上查看并执行 JMX 操作，如以 XML 转储路由或获取路由的 Camel ID 值。

8. 通过路由跟踪信息 ：

   1. 在 Camel 选项卡的树视图中，选择一个路由。
   2. 选择 Trace，然后单击 Start tracing。

9. 发送消息到路由 ：

   1. 在 Camel 选项卡的树视图中，打开上下文的端点文件夹，然后选择端点。
   2. 点 Send 子选项卡。
   3. 以 JSON 或 XML 格式配置消息。
   4. 单击 Send。
   5. 返回到路由的 Trace 选项卡，以查看通过路由的消息流。

1. 在 Camel 选项卡的树视图中，选择一个路由。
2. 选择 Debug，然后单击 Start debugging。

3. 要添加断点，请在图表中选择节点，然后单击 Add breakpoint。节点上会出现一个红色点：

   

4. 该节点被添加到断点列表中：

   

5. 点下箭头来进入下一个节点，或点 Resume 按钮来恢复运行路由。

   
6. 单击 暂停 按钮，以暂停路由的所有线程。
7. 完成后 ，点 Stop debug。所有断点都会被清除。

1. 资源服务器 ：

   托管受保护资源的服务器组件，其中根据访问令牌限制或授予其访问。通常，这个服务器通过 REST API 访问，且不会自行提供用户界面。

2. 客户端 ：

   应用程序（通常使用用户界面），它们代表用户（被视为资源所有者）访问资源服务器。若要访问资源服务器，客户端必须先获取访问令牌。

   在 OpenID Connect 规格中，客户端被命名为依赖方(RP)。

3. 授权服务器 ：

   协调客户端和资源服务器之间通信的服务器。客户端要求授权服务器验证用户（资源所有者），如果身份验证成功，则会为客户端发出访问令牌来访问资源服务器。

   在 OpenID Connect 规格中，授权服务器名为 OpenID Provider (OP)。

1. 带有角色 管理器、admin、viewer 和 user的admin /admin
2. 带有角色查看器和 用户的 viewer /viewer
3. 只使用用户角色的 jdoe/jdoe

1. Web 平台 ：

   这种类型的客户端适合服务器端应用程序和 API。

2. SPA 平台 ：

   SPA 应用程序在浏览器中运行，它自然使用"Authorization Code Flow"和所谓的公共客户端。其原因是，在浏览器应用程序中存储凭证和 secret 没有好的方式。