HawtIO Diagnostic Console Guide


Red Hat build of Apache Camel 4.0

使用红帽构建的 HawtIO 管理应用程序

摘要

当您部署支持 HawtIO 的应用程序时,您可以使用 HawtIO 监控并与集成交互。

前言

HawtIO 提供用于查看和管理启用了红帽 HawtIO 的应用程序的企业监控工具。它是一种基于 Web 的控制台,可从浏览器访问以监控和管理已启用 HawtIO 的容器。HawtIO 基于开源 HawtIO 软件(https://hawt.io/)。HawtIO 诊断控制台指南描述了如何使用 HawtIO 管理应用程序。

本指南的受众是 Apache Camel eco-system 开发人员和管理员。本指南假定对 Apache Camel 和您组织的处理要求有一定的了解。

使开源包含更多

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。我们从这四个术语开始:master、slave、黑名单和白名单。由于此项工作十分艰巨,这些更改将在即将推出的几个发行版本中逐步实施。详情请查看 CTO Chris Wright 的信息

第 1 章 HawtIO 概述

重要

技术预览功能不受红帽产品服务等级协议(SLA)支持,且功能可能并不完整。红帽不推荐在生产环境中实施任何技术预览功能。

此技术预览功能为您提供对即将推出的产品创新的早期访问,允许您在开发过程中测试并提供反馈。如需有关支持范围的更多信息,请参阅 技术预览功能支持范围

HawtIO 是红帽构建的 Apache Camel 和红帽构建的 AMQ 的诊断控制台。它是使用现代 Web 技术(如 ReactPatternFly )构建的可插拔 Web 诊断控制台。HawtIO 提供了一个中央接口,用于检查和管理一个或多个启用了 HawtIO 的容器的详细信息。当您将 HawtIO 独立安装或使用 OpenShift 中的 HawtIO 时,可以使用 HawtIO。您可以在 HawtIO 中查看和管理的集成取决于正在运行的插件。您可以监控 HawtIO 和系统资源,执行更新,以及启动或停止服务。

可插拔架构基于 Webpack Module Federation,具有高度可扩展的;您可以使用插件动态扩展 HawtIO,或者在 JVM 中自动发现插件。HawtIO 已内置 插件 可供您的 JVM 应用开箱即用。插件包括 Apache Camel、连接、JMX、日志、运行时、Qartz 和 Spring Boot。HawtIO 主要设计为用于 Camel Quarkus 和 Camel Spring Boot。它还是用于管理微服务应用的工具。HawtIO 是云原生的;它已准备好接管云!您可以使用 HawtIO Operator 将它部署到 Kubernetes 和 OpenShift。

HawtIO 的优点如下:

  • 通过 JMX 的运行时管理 JVM,特别是 Camel 应用程序和 AMQ 代理(带有特殊视图)
  • Camel 路由的视觉化和调试/追踪
  • 简单管理和监控应用程序指标

第 2 章 Installing HawtIO

使用 HawtIO 控制台有几个选项:

2.1. 将红帽软件仓库添加到 Maven

要访问位于 Red Hat Maven 存储库中的工件,您需要将这些存储库添加到 Maven 的 settings.xml 文件中。Maven 在用户主目录的 .m2 目录中查找 settings.xml 文件。如果没有用户指定的 settings.xml 文件,Maven 将使用 M2_HOME/conf/ settings.xml 中的系统级 settings.xml 文件。

先决条件:

您知道要在其中添加红帽软件仓库的 settings.xml 文件的位置。

流程

  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>
    Copy to Clipboard Toggle word wrap

2.2. 通过 CLI 运行(JBang)

您可以使用 JBang 从 CLI 安装并运行 HawtIO。

注意

如果您还没有 JBang,首先安装它 :https://www.jbang.dev/download/

流程

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

    $ jbang app install -Dhawtio.jbang.version=4.0.0.redhat-00040 hawtio@hawtio/hawtio
    Copy to Clipboard Toggle word wrap
    注意

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

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

    $ hawtio
    Copy to Clipboard Toggle word wrap
  3. 该命令将自动打开位于 http://0.0.0.0:8080/hawtio/ 的控制台。要更改端口号,请运行以下命令:

    $ hawtio --port 8090
    Copy to Clipboard Toggle word wrap
  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.
    Copy to Clipboard Toggle word wrap

2.3. 运行 Quarkus 应用程序

您可以在一个步骤中将 HawtIO 附加到 Quarkus 应用程序。

流程

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

    <dependencyManagement>
      <dependencies>
        <dependency>
          <groupId>io.hawt</groupId>
          <artifactId>hawtio-bom</artifactId>
          <version>4.0.0.redhat-00040</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-management-starter</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>
    Copy to Clipboard Toggle word wrap
  2. 在开发模式中使用 Quarkus 应用程序运行 HawtIO,如下所示:

    mvn compile quarkus:dev
    Copy to Clipboard Toggle word wrap
  3. 打开 http://localhost:8080/hawtio 以查看 HawtIO 控制台。

2.4. 运行 Spring Boot 应用程序

您可以通过两个步骤将 HawtIO 附加到 Spring Boot 应用程序。

流程

  1. io.hawt:hawtio-springboot 和支持 Camel Spring Boot 启动程序添加到 pom.xml 中的依赖项:

    <dependencyManagement>
      <dependencies>
        <dependency>
          <groupId>io.hawt</groupId>
          <artifactId>hawtio-bom</artifactId>
          <version>4.0.0.redhat-00040</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>
    Copy to Clipboard Toggle word wrap
  2. 通过在 application.properties 中添加以下行来启用 HawtIO 和 Jolokia 端点:

    spring.jmx.enabled = true
    management.endpoints.web.exposure.include = hawtio,jolokia
    Copy to Clipboard Toggle word wrap
  3. 在开发模式下使用 Spring Boot 应用程序运行 HawtIO,如下所示:

    mvn spring-boot:run
    Copy to Clipboard Toggle word wrap
  4. 打开 http://localhost:8080/actuator/hawtio 以查看 HawtIO 控制台。

2.4.1. 配置 HawtIO 路径

如果您不希望具有 HawtIO 端点的 /actuator 基本路径,您也可以执行以下操作:

  1. 使用 management.endpoints.web.base-path 属性自定义 Spring Boot 管理基础路径:

    management.endpoints.web.base-path = /
    Copy to Clipboard Toggle word wrap
  2. 您还可以通过设置 management.endpoints.web.path-mapping.hawtio 属性来自定义 HawtIO 端点的路径:

    management.endpoints.web.path-mapping.hawtio = hawtio/console
    Copy to Clipboard Toggle word wrap
  3. Example:

    1. 有一个正常工作的 Spring Boot 示例,它演示了如何监控一个 Web 应用程序,它公开 Apache Camel 路由、指标等信息,其中包含 HawtIO Spring Boot 示例
    2. 用于实时值和图表的良好 MBean 是 java.lang/OperatingSystem。尝试查看 Camel 路由。请注意,当您更改树中的选择时,根据内容动态更改可用选项卡列表。

第 3 章 配置 HawtIO

HawtIO 及其插件可以通过系统属性配置其行为。

3.1. 配置属性

下表列出了 HawtIO 核心系统和各种插件的配置属性。

Expand
Systemdefault描述

hawtio.disableProxy

false

将此属性设置为 true 时,ProxyServlet (/hawtio/proxyAttr)可以被禁用。这使得 Connect 插件不可用,这意味着 HawtIO 不再连接到远程 JVM,但有时用户可能希望这样做,因为没有使用 Connect 插件时,用户可能希望这样做。

hawtio.localAddressProbing

true

是否启用代理允许列表的本地地址探测。将此属性设置为 false 以禁用它。

hawtio.proxyAllowlist

localhost, 127.0.0.1

Connect 插件可以通过 ProxyServlet 连接到的目标主机的逗号分隔列表。出于安全原因,未在此允许列表中列出的所有主机都被拒绝进行连接。这个选项可以设置为 * 以允许所有主机。使用 "r:" 为列表添加前缀可以定义正则表达式(例如:localhost,r:myserver[0-9]+.mydomain.com)

hawtio.redirect.scheme

 

需要身份验证时,方案是将 URL 重定向到登录页面。

hawtio.sessionTimeout

 

servlet 容器将在客户端访问之间保持打开的最大时间间隔(以秒为单位)。如果没有配置这个选项,则 HawtIO 将使用 servlet 容器的默认会话超时。

3.1.1. Quarkus

对于 Quarkus,所有这些属性都可以在 application.propertiesapplication.yaml 中配置,且带有 quarkus.hawtio 前缀。

例如:

quarkus.hawtio.disableProxy = true
Copy to Clipboard Toggle word wrap

3.1.2. Spring Boot

对于 Spring Boot,所有这些属性都可以在 application.propertiesapplication.yaml 中进行配置,如下所示。

例如:

hawtio.disableProxy = true
Copy to Clipboard Toggle word wrap

3.2. 通过系统属性配置 Jolokia

Jolokia 代理使用 io.hawt.web.JolokiaConfiguredAgentServlet 自动部署,它扩展了 Jolokia 原生 org.jolokia.http.AgentServlet 类,在 hawtio-war/WEB-INF/web.xml 中定义。如果要使用 Jolokia 文档 中定义的配置参数自定义 Jolokia Servlet,您可以将它们作为前缀 jolokia 传递为系统属性。

例如:

jolokia.policyLocation = file:///opt/hawtio/my-jolokia-access.xml
Copy to Clipboard Toggle word wrap

3.2.1. RBAC Restrictor

对于一些支持 HawtIO RBAC (基于角色的访问控制)的运行时,HerwtIO 提供了一个自定义 Jolokia Restrictor 实现,它根据 ACL (访问控制列表)策略提供额外的保护功能。

警告

您不能在 Quarkus 和 Spring Boot 中使用 HawtIO RBAC。在这些运行时上启用 RBAC 限制仅会带来额外的负载,而无需任何好处。

要激活 HawtIO RBAC Restrictor,请通过 System 属性配置 Jolokia 参数 restrictorClass 以使用 io.hawt.web.RBACRestrictor,如下所示:

jolokia.restrictorClass = io.hawt.system.RBACRestrictor
Copy to Clipboard Toggle word wrap

第 4 章 HawtIO 的安全性和身份验证

HawtIO 根据其运行的 runtime/containers,启用开箱即用的身份验证。要将 HawtIO 与应用程序一起使用,需要为运行时设置身份验证或禁用 HawtIO 身份验证。

4.1. 配置属性

下表列出了 HawtIO 核心系统的安全相关配置属性。

Expand
Name默认描述

hawtio.authenticationContainerDiscoveryClasses

io.hawt.web.tomcat.TomcatAuthenticationContainerDiscovery

以逗号分开的已用 AuthenticationContainerDiscovery 实现列表。默认情况下,只有 TomcatAuthenticationContainerDiscovery,用于验证来自 tomcat-users.xml 文件的 Tomcat 用户。如果要从配置的 JAAS 登录模块验证 Tomcat 上的用户,或者可以自由地添加更多您自己的类,可以将其删除。

hawtio.authenticationContainerTomcatDigestAlgorithm

NONE

使用 Tomcat tomcat-users.xml 文件时,密码可以散列而不是纯文本。使用它来指定摘要算法;有效值为 NONE、MD5、SHA-256、SHA-256、SHA-384 和 SHA-512。

hawtio.authenticationEnabled

true

是否启用安全性。

hawtio.keycloakClientConfig

classpath:keycloak.json

用于前端的 Keycloak 配置文件。如果启用了 Keycloak 集成,则是必须的。

hawtio.keycloakEnabled

false

是否启用或禁用 Keycloak 集成。

hawtio.noCredentials401

false

在启用身份验证时是否返回 HTTP 状态 401,但没有提供凭证。返回 401 将导致浏览器弹出窗口提示凭据。默认情况下,这个选项为 false,返回 HTTP 状态 403。

hawtio.realm

hawtio

用于登录的安全域。

hawtio.rolePrincipalClasses

 

完全限定的主体类名称。逗号可以分隔多个类。

hawtio.roles

admin, manager, viewer

登录控制台需要用户角色。逗号可以分隔多个允许的角色。设置为 * 或空值,在 HawtIO 验证用户时禁用角色检查。

hawtio.tomcatUserFileLocation

conf/tomcat-users.xml

指定 tomcat-users.xml 文件的替代位置,如 /production/userlocation/。

4.2. Quarkus

HawtIO 使用 Quarkus 和 Keycloak 提供的验证机制进行保护。

如果要为 Quarkus 禁用 HawtIO 身份验证,请在 application.properties 中添加以下配置:

quarkus.hawtio.authenticationEnabled = false
Copy to Clipboard Toggle word wrap

4.2.1. Quarkus 身份验证机制

HawtIO 只是 Quarkus 中的一个 Web 应用程序,因此各种机制 Quarkus 提供用来验证 Web 应用程序的方式与验证 HawtIO 一样。

在这里,我们将如何通过 HawtIO 使用 基于属性的身份验证 来实现演示目的。

重要

不建议在生产环境中使用基于属性的身份验证。这种机制仅用于开发和测试目的。

  1. 要将基于属性的身份验证与 HawtIO 搭配使用,请将以下依赖项添加到 pom.xml 中:

    <dependency>
        <groupId>io.quarkus</groupId>
        <artifactId>quarkus-elytron-security-properties-file</artifactId>
    </dependency>
    Copy to Clipboard Toggle word wrap
  2. 然后您可以在 application.properties 中定义用户来启用身份验证。例如,使用密码 s3cr3t!role admin 定义 用户 hawtio 类似如下:

    quarkus.security.users.embedded.enabled = true
    quarkus.security.users.embedded.plain-text = true
    quarkus.security.users.embedded.users.hawtio = s3cr3t!
    quarkus.security.users.embedded.roles.hawtio = admin
    Copy to Clipboard Toggle word wrap

Example:

有关基于属性的身份验证的工作示例,请参阅 Quarkus 示例

4.2.2. 使用 Keycloak 的 Quarkus

请参阅 Keycloak 集成 - Quarkus

4.3. Spring Boot

除了标准的 JAAS 身份验证外,Spring Boot 上的 HawtIO 还可以通过 Spring SecurityKeycloak 进行保护。如果要为 Spring Boot 禁用 HawtIO 身份验证,请在 application.properties 中添加以下配置:

hawtio.authenticationEnabled = false
Copy to Clipboard Toggle word wrap

4.3.1. Spring Security

将 Spring Security 与 HawtIO 搭配使用:

  1. org.springframework.boot:spring-boot-starter-security 添加到 pom.xml 中的依赖项:

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    Copy to Clipboard Toggle word wrap
  2. src/main/resources/application.properties 中的 Spring Security 配置应该类似如下:

    spring.security.user.name = hawtio
    spring.security.user.password = s3cr3t!
    spring.security.user.roles = admin,viewer
    Copy to Clipboard Toggle word wrap
  3. 必须定义安全配置类来设置如何使用 Spring Security 保护应用程序:

    @EnableWebSecurity
    public class SecurityConfig
    {
        @Bean
        public SecurityFilterChain filterChain(HttpSecurity http) throws Exception
        {
            http.authorizeRequests().anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .httpBasic()
                .and()
                .csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());
            return http.build();
        }
    }
    Copy to Clipboard Toggle word wrap

Example:

有关工作 示例,请参阅 springboot-security 示例。

4.3.1.1. 使用 Spring Security 连接到远程应用程序

如果您试图连接到启用了 Spring Security 的远程 Spring Boot 应用程序,请确保 Spring Security 配置允许从 HawtIO 控制台访问。最有可能,默认的 CSRF 保护会禁止远程访问 Jolokia 端点,因此会在 HawtIO 控制台中导致身份验证失败。

警告

请注意,它会将您的应用程序暴露于 CSRF 攻击的风险。

  1. 最简单的解决方案是在远程应用中禁用 Jolokia 端点的 CSRF 保护,如下所示:

    import org.springframework.boot.actuate.autoconfigure.jolokia.JolokiaEndpoint;
    import org.springframework.boot.actuate.autoconfigure.security.servlet.EndpointRequest;
    
    @EnableWebSecurity
    public class SecurityConfig
    {
    
        @Bean
        public SecurityFilterChain filterChain(HttpSecurity http) throws Exception
        {
            ...
            // Disable CSRF protection for the Jolokia endpoint
            http.csrf().ignoringRequestMatchers(EndpointRequest.to(JolokiaEndpoint.class));
            return http.build();
        }
    
    }
    Copy to Clipboard Toggle word wrap
  2. 要保护 Jolokia 端点,即使没有 Spring Security 的 CSRF 保护,您需要在 src/main/resources/ 下提供一个 jolokia-access.xml 文件,类似以下(snippet),以便只有可信节点可以访问它:

    <restrict>
      ...
      <cors>
        <allow-origin>http*://localhost:*</allow-origin>
        <allow-origin>http*://127.0.0.1:*</allow-origin>
        <allow-origin>http*://*.example.com</allow-origin>
        <allow-origin>http*://*.example.com:*</allow-origin>
    
        <strict-checking />
      </cors>
    </restrict>
    Copy to Clipboard Toggle word wrap

4.3.2. 带有 Keycloak 的 Spring Boot

请参阅 Keycloak 集成 - Spring Boot

第 5 章 在 OpenShift 4 中设置 HawtIO

在 OpenShift 4.x 上,设置 HawtIO 涉及安装和部署它。此安装的首选机制是使用 OperatorHub 提供的 HawtIO Operator (请参阅第 5.1 节,"使用 OperatorHub 在 OpenShift 4.x 上安装和部署 HawtIO")。另外,您可以为 HawtIO 自定义基于角色的访问控制(RBAC),如 OpenShift 4.x 上的 HawtIO 第 2.3 节 "Role-based Access control for HawtIO" 所述。

HawtIO Operator 在 OpenShift OperatorHub 中提供,用于安装 HawtIO。要部署 HawtIO,您必须部署已安装 Operator 的实例以及 HawtIO 自定义资源(CR)。

安装和部署 HawtIO:

  1. 以具有集群管理员访问权限的用户身份登录 Web 浏览器中的 OpenShift 控制台。
  2. Operators,然后点 OperatorHub
  3. 在搜索字段窗口中,键入 HawtIO 来过滤 Operator 列表。点 HawtIO Operator
  4. 在 HawtIO Operator 安装窗口中,点 InstallCreate Operator Subscription 表单将打开:

    1. 对于 更新频道,请选择 stable-v1
    2. 对于 Installation Mode,接受默认值(集群中的特定命名空间)。

      注意

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

    3. 对于 Installed Namespace,选择要在其中安装 HawtIO Operator 的命名空间。
    4. 对于 Update Approval,选择 AutomaticManual 来配置 OpenShift 如何处理对 HawtIO Operator 的更新。

      1. 如果选择了 Automatic updates 选项,并且有新版本的 HawtIO Operator 可用,OpenShift Operator Lifecycle Manager (OLM)将自动升级正在运行的 HawtIO 实例,而无需人为干预;
      2. 如果选择了 Manual 更新选项,且有新版本的 Operator 可用,OLM 只会创建一个更新请求。然后,集群管理员必须手动批准更新请求,才能将 HawtIO Operator 更新至新版本。
  5. Install 和 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 (基于角色的访问控制),只有在 Config Map 字段中指定一个值,如果要自定义默认的 RBAC 行为,并且是否安装了 HawtIO Operator 的命名空间中已存在 ConfigMap 文件
      3. 对于 Nginx,请参阅 HawtIO Operator 安装的性能调优
      4. 对于 Type,指定:

        1. 集群 :用于为任何支持 HawtIO 的应用程序监控 OpenShift 集群上的所有命名空间;
        2. 命名空间 : 用于仅监控在同一命名空间中部署的启用了 HawtIO 的应用程序。
    4. CreateHawtIO 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 的应用程序 pod。
  9. Connect 查看被监控的应用程序。此时将打开一个新浏览器窗口,显示 HawtIO 中的应用程序。

5.2. OpenShift 4 上 HawtIO 的基于角色的访问控制

HawtIO 提供基于角色的访问控制(RBAC),它根据 OpenShift 提供的用户授权推断访问。在 HawtIO 中,RBAC 决定用户在 pod 上执行 MBean 操作。

如需有关 OpenShift 授权的信息,请参阅 OpenShift 文档中的使用 RBAC 定义和应用权限 部分。

当使用 Operator 在 OpenShift 上安装 HawtIO 时,默认启用基于角色的访问控制。HawtIO RBAC 利用 OpenShift 中的 pod 资源的操作动词访问,以确定用户在 HawtIO 中对 pod 的 MBean 操作的访问。默认情况下,对于 HawtIO,有两个用户角色:

  1. admin :如果用户可以在 OpenShift 中更新 pod,则用户会被限制掉 HawtIO 的 admin 角色。用户可以在 HawtIO 中为 pod 执行写 MBean 操作。
  2. Viewer: 如果用户可以在 OpenShift 中获取 pod,则用户会被限制掉 HawtIO 的 viewer 角色。用户可以在 HawtIO 中为 pod 执行只读 MBean 操作。

5.2.1. 确定 OpenShift 4 上 HawtIO 的访问角色

HawtIO 基于角色的访问控制是从用户的 pod 的 OpenShift 权限中推断出来的。要确定向特定用户授予 HawtIO 访问角色,请获取授予 Pod 用户的 OpenShift 权限。

先决条件:

  • 用户名
  • pod 的名称

流程

  1. 要确定用户是否为 pod 具有 HawtIO admin 角色,请运行以下命令来查看用户是否可以更新 OpenShift 上的 pod:

    oc auth can-i update pods/<pod> --as <user>
    Copy to Clipboard Toggle word wrap
  2. 如果响应是 yes,则用户具有 Pod 的 admin 角色。用户可以对 pod 执行 HawtIO 中的写入操作。
  3. 要确定用户是否为 pod 具有 HawtIO viewer 角色,请运行以下命令来查看用户是否可以在 OpenShift 上获取 pod:

    oc auth can-i get pods/<pod> --as <user>
    Copy to Clipboard Toggle word wrap
  4. 如果响应是 yes,则用户具有 pod 的 viewer 角色。用户可以在 HawtIO 中为 pod 执行只读操作。根据上下文,HawtIO 会阻止具有 viewer 角色的用户执行写入 MBean 操作,方法是禁用一个选项,或者在 用户尝试写入 MBean 操作时显示这个用户消息允许的操作
  5. 如果没有响应,用户不会绑定到任何 HawtIO 角色,用户无法在 HawtIO 中查看 pod。

如果您使用 OperatorHub 安装 HawtIO,则默认启用基于角色的访问控制(RBAC)。要自定义 HawtIO RBAC 行为,在部署 HawtIO 之前,必须提供 ConfigMap 资源(定义自定义 RBAC 行为)。此 ConfigMap 的名称应在 HawtIO 自定义资源(CR)的 rbac 配置部分中输入。

自定义 ConfigMap 资源必须添加到安装了 HawtIO Operator 的同一命名空间中。

先决条件

  • HawtIO Operator 已从 OperatorHub 安装。

流程

自定义 HawtIO RBAC 角色:

  1. 创建 RBAC ConfigMap:

    1. 确保当前的 OpenShift 项目是您要安装 HawtIO 的项目。例如,要在 hawtio-test 项目中安装 HawtIO,请运行以下命令:

      oc project hawtio-test
      Copy to Clipboard Toggle word wrap
    2. 从模板创建 HawtIO RBAC ConfigMap 文件,并运行这个命令:

      oc process -f https://raw.githubusercontent.com/hawtio/hawtio-online/2.x/docker/ACL.yaml -p APP_NAME=custom-hawtio | oc create -f -
      Copy to Clipboard Toggle word wrap
    3. 使用以下命令编辑新的自定义 ConfigMap:

      oc edit ConfigMap custom-hawtio-rbac
      Copy to Clipboard Toggle word wrap
    4. 通过保存编辑,ConfigMap 资源将更新
  2. 按照上述所述,创建一个新的 HawtIO CR,并通过在属性 configMap 下添加新 ConfigMap 的名称来编辑 rbac 部分。
  3. Create。Operator 应该部署一个新版本的 HawtIO,以使用自定义 ConfigMap

5.3. 从 Fuse 控制台迁移

HawtIO 自定义资源定义(CRD)的版本已从 v1alpha1 从 HawtIO 升级到 v1,包含兼容更改。因此,由于 CRD 是集群范围的,因此如果随后在同一集群中安装了 HawtIO,这将对 Fuse 控制台的现有安装产生影响。在继续安装 HawtIO 前,建议用户卸载所有 Fuse 控制台版本。

希望将现有 HawtIO 自定义资源迁移到 HawtIO 的用户可以将资源配置存储在文件中,并在安装了 HawtIO Operator 后重新应用这些资源。在重新应用时,CR 会自动升级到 v1 版本。新规格中的重要更改是,在 CR 中无法再指定 version 属性,因为版本作为 Operator 本身的内部常量提供。

5.4. 在 OpenShift 4 上升级 HawtIO

Red Hat OpenShift 4.x 处理对 Operator 的更新,包括 HawtIO operator。如需更多信息,请参阅 Operator OpenShift 文档。另外,Operator 更新会根据应用程序的配置方式触发应用程序升级。

5.5. 在 OpenShift 4 中调整 HawtIO 的性能

默认情况下,HerwtIO 使用以下 Nginx 设置:

  • clientBodyBufferSize: 256k
  • proxyBuffers: 16 128k
  • subrequestOutputBufferSize: 10m
注意

有关这些设置的描述,请参阅 Nginx 文档

要调整 HawtIO 的性能,您可以设置任何 clientBodyBufferSizeproxyBufferssubrequestOutputBufferSize 环境变量。例如,如果您使用 HawtIO 监控多个 pod 和路由(例如,共 100 个路由),您可以通过将 HawtIO 的 subrequestOutputBufferSize 环境变量设置为 100 m 来解决加载超时问题。

5.5.1. 对 HawtIO Operator 安装的性能调整

在 Openshift 4.x 上,您可以在部署 HawtIO 之前或之后设置 Nginx 性能调优环境变量。如果您随后这样做,OpenShift 会重新部署 HawtIO。

先决条件

  • 您必须具有 集群管理员对 OpenShift 集群的访问权限。

流程

您可以在部署 HawtIO 之前或之后设置环境变量。

  1. 在部署 HawtIO 前设置环境变量

    1. 在 OpenShift Web 控制台中,安装有 HawtIO Operator 的项目,选择 Operators> Installed Operators> HawtIO Operator
    2. 单击 HawtIO 选项卡,然后单击 Create HawtIO
    3. Create HawtIO 页面中,在 Form 视图中,向下滚动到 Config> Nginx 部分。
    4. 展开 Nginx 部分,然后设置环境变量。例如:

      1. clientBodyBufferSize: 256k
      2. proxyBuffers: 16 128k
      3. subrequestOutputBufferSize: 100m
    5. Create deploy HawtIO。
    6. 部署完成后,打开 Deployments> HawtIO-console 页面,然后单击 Environment 以验证环境变量是否在列表中。
  2. 在部署 HawtIO 后设置环境变量

    1. 在 OpenShift Web 控制台中,打开部署 HawtIO 的项目。
    2. 选择 Operators> Installed Operators> HawtIO Operator
    3. 单击 HawtIO 选项卡,然后单击 HawtIO
    4. 选择 Actions> Edit HawtIO
    5. 在 Editor 窗口中,滚动到 spec 部分。
    6. spec 部分,添加新的 nginx 部分并指定一个或多个环境变量,例如:

      apiVersion: hawt.io/v1
      kind: Hawtio
      metadata:
        name: hawtio-console
      spec:
        type: Namespace
        nginx:
          clientBodyBufferSize: 256k
          proxyBuffers: 16 128k
          subrequestOutputBufferSize: 100m
      Copy to Clipboard Toggle word wrap
    7. 点击 Save。OpenShift 重新部署 HawtIO。
    8. 重新部署完成后,打开 Workloads> Deployments> HawtIO-console 页面,然后点 Environment 来查看列表中的环境变量。

5.5.2. 在 HawtIO 中查看应用程序的性能调整

增强的 HawtIO 的性能调节功能允许查看具有大量 MBeans 的应用程序。要使用此功能,请执行以下步骤。

先决条件

  • 您必须具有 集群管理员对 OpenShift 集群的访问权限。

流程

增加应用程序的内存限值。

  1. 在部署 HawtIO 后增加内存限值

    1. 在 OpenShift Web 控制台中,打开部署 HawtIO 的项目。
    2. 选择 Operators> Installed Operators> HawtIO Operator
    3. 单击 HawtIO 选项卡,然后单击 HawtIO
    4. 选择 Actions> Edit HawtIO
    5. 在 Editor 窗口中,向下滚动到 spec.resources 部分。
    6. 请求和限值 的值更新为首选数量
    7. 点 Save
    8. HawtIO 应该使用新的资源规格重新部署。

第 6 章 为 HawtIO 在线设置应用程序

本节演示了如何在 OpenShift 上部署 Camel Quarkus 应用程序,并使用 Camel Quarkus 使它启用了 HawtIO。在 OpenShift 上部署后,它将由 HawtIO 在线发现。

  1. 此项目 使用 Quarkus 容器镜像Kubernetes 扩展来构建容器镜像,并将其部署到 Kubernetes/OpenShift 集群(pom.xml)。
  2. 启用了 HawtIO 的配置条款中最重要的部分在 < properties&gt; 部分中定义。要使它启用了 HawtIO,必须将 Jolokia 代理附加到配置了 HTTPS 和 SSL client-authentication 的应用。客户端主体应与 HawtIO 在线实例提供的匹配(默认为 hawtio-online.hawtio.svc)。

    <properties>
        <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>
    Copy to Clipboard Toggle word wrap
  3. 在本地运行应用程序:

    1. 使用以下命令在 development 模式下运行:

      mvn compile quarkus:dev
      Copy to Clipboard Toggle word wrap
    2. 或者构建项目并执行可运行的 JAR:

      mvn package && java -jar target/quarkus-app/quarkus-run.jar
      Copy to Clipboard Toggle word wrap
  4. 在本地使用 Jolokia 代理运行:

    1. 您可以在本地使用 Jolokia JVM 代理运行这个示例,如下所示:

      java -javaagent:target/quarkus-app/lib/main/org.jolokia.jolokia-agent-jvm-2.0.1-javaagent.jar -jar target/quarkus-app/quarkus-run.jar
      Copy to Clipboard Toggle word wrap
  5. 将其部署到 OpenShift:

    1. 要将其部署到集群中,首先更改 pom.xml 中的容器镜像参数,以适合开发环境。(默认镜像名称为 quay.io/hawtio/hawtio-online-example-camel-quarkus:latest,它应该被推送到 Quay.io 上的 hawtio 组织。

      <!--
        Container registry and group should be changed to those which your application uses.
      -->
      <quarkus.container-image.registry>quay.io</quarkus.container-image.registry>
      <quarkus.container-image.group>hawtio</quarkus.container-image.group>
      <quarkus.container-image.tag>latest</quarkus.container-image.tag>
      Copy to Clipboard Toggle word wrap
    2. 然后,使用选项 -Dquarkus.container-image.push=true 来构建项目,以将构建镜像推送到首选容器 registry:

      mvn install -Dquarkus.container-image.push=true
      Copy to Clipboard Toggle word wrap
    3. 部署的资源文件也会在 target/kubernetes/kubernetes.yml 上生成。使用 kubectloc 命令,使用 resources 文件部署应用程序:

      kubectl apply -f target/kubernetes/kubernetes.yml
      Copy to Clipboard Toggle word wrap
    4. 部署成功后,pod 已启动,可以在集群中看到应用程序日志

第 7 章 查看容器和应用程序

当您登录到 OpenShift 的 HawtIO 时,A HawtIO 主页会显示可用的容器。

流程

  1. 若要管理(创建、编辑或删除)容器,请使用 OpenShift 控制台。
  2. 要查看 OpenShift 集群上启用了 HawtIO 的应用程序和 AMQ Broker (如果适用),请点击 Online 选项卡

第 8 章 查看并管理 Apache Camel 应用程序

在 HawtIO 的 Camel 选项卡中,您可以查看和管理 Apache Camel 上下文、路由和依赖项。

您可以查看以下详情:

  1. 所有正在运行的 Camel 上下文列表
  2. 每个 Camel 上下文(如 Camel 版本号和运行时静态)的详细信息
  3. 每个 Camel 应用程序及其运行时统计中的所有路由列表
  4. 正在运行的路由的图形表示以及实时指标

您还可以通过以下方法与 Camel 应用程序交互:

  1. 启动和暂停上下文
  2. 管理所有 Camel 应用程序及其路由的生命周期,以便您可以重启、停止、暂停、恢复等。
  3. 运行路由的实时追踪和调试
  4. 浏览消息并将其发送到 Camel 端点
注意

只有在连接到使用一个或多个 Camel 路由的容器时,Camel 选项卡才可用。

8.1. 启动、暂停或删除上下文

  1. 在 Camel 选项卡的树视图中,单击 Camel Contexts。
  2. 选中列表中一个或多个上下文旁边的框。
  3. 点 Start 或 Suspend。
  4. 删除上下文:

    1. 停止上下文。
    2. 单击 ellipse 图标,然后从下拉菜单中选择 Delete。
注意

当您删除上下文时,您可以从部署的应用程序中删除它。

8.2. 查看 Camel 应用程序详情

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

8.3. 查看 Camel 路由列表并与之交互

  1. 查看路由列表

    1. Camel 选项卡。
    2. 在树视图中,点应用程序的路由文件夹:

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

    1. 选中列表中一个或多个路由旁边的框。
    2. StartStop
    3. 要删除路由,您必须首先停止它。然后,单击 ellipse 图标,然后从下拉菜单中选择 删除

      注意
      • 删除路由时,您可以将其从部署的应用程序中删除。
      • 您还可以在树视图中选择特定的路由,然后单击右上角的菜单来启动、停止或删除它。
  3. 要查看路由的图形图,请点 Route 图表
  4. 要查看动态和被阻止交换,请点击 Exchanges
  5. 要查看端点,请点 Endpoints。您可以根据 URL、Route ID 和方向过滤列表。
  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 选项卡,以查看消息通过路由流。

8.4. 调试路由

  1. Camel 选项卡的树视图中,选择一个路由。
  2. 选择 Debug,然后单击 Start debugging
  3. 要添加断点,请在图中选择一个节点,然后单击 Add breakpoint。节点中会出现一个红色的点:

  4. 节点添加到断点列表中:

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

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

第 9 章 查看并管理 JMX 域和 MBeans

Java 管理扩展(JMX)是一种 Java 技术,允许您在运行时动态管理资源(服务、设备和应用程序)。资源由名为 MBeans (用于 Managed Bean)的对象表示。您可以在资源创建、实施或安装后立即管理和监控资源。

借助 HawtIO 上的 JMX 插件,您可以查看和管理 JMX 域和 MBeans。您可以查看 MBean 属性、运行命令和创建显示 MBeans 统计信息的图表。

JMX 选项卡提供活动 JMX 域和以文件夹组织的 MBeans 的树状视图。您可以在 MBeans 上查看详情和执行命令。

流程

  1. 查看并编辑 MBean 属性

    1. 在树视图中,选择一个 MBean。
    2. 单击 Attributes 选项卡。
    3. 点一个属性查看其详情。
  2. 执行操作

    1. 在树视图中,选择一个 MBean。
    2. 单击 Operations 选项卡,展开列出的操作之一。
    3. 单击 Execute 以运行该操作。
  3. 查看图表

    1. 在树视图中,选择一个项目。
    2. Chart 选项卡。

第 10 章 查看并管理 Quartz Schedules

quartz 是一个功能丰富的开源作业调度库,您可以在大多数 Java 应用程序内集成。您可以使用 Quartz 为执行作业创建简单或复杂的计划。

作业被定义为一个标准 Java 组件,您可以几乎执行该组件来对其进行编程。

如果您的 Camel 路由部署了 camel-quartz 组件,则 HawtIO 显示 Quartz 选项卡。请注意,您还可以通过 JMX 树视图访问 Quartz mbeans。

流程

  1. 在 HawtIO 中,单击 Quartz 选项卡。Quartz 页面包含 Quartz 调度程序和调度程序、TriggersJobs 选项卡的树视图。
  2. 要暂停或启动调度程序,请单击 调度程序选项卡上的按钮
  3. Triggers 选项卡查看决定作业何时运行的触发器。例如,触发器可以指定在一天(到 millisecond)、在指定天数或指定次数或特定时间重复启动作业。

    1. 要过滤触发器列表,请从下拉列表中选择 StateGroupNameType。然后,您可以通过选择或键入 fill-on 字段来进一步过滤列表。
    2. 要暂停、恢复、更新或手动触发触发器,请单击 Action 列中的选项。
  4. Jobs 选项卡查看正在运行的作业列表。您可以根据表中的列对列表进行排序: GroupNameDurableRecoverJob ClassNameDescription

第 11 章 查看线程

您可以查看和监控线程状态。

流程

  1. 单击 Runtime 选项卡,然后单击 Threads 子选项卡。
  2. Threads 页面列出了每个线程的活跃线程和堆栈追踪详情。默认情况下,线程列表以降序 ID 顺序显示所有线程。
  3. 要通过增加 ID 进行排序,请点 ID 列标签。
  4. (可选)根据线程状态(如 Blocked)或线程名称过滤列表。
  5. 要深入查看特定线程的详细信息,如锁定类名称和该线程的完整堆栈追踪,请在 Actions 列中点击 More

第 12 章 确保在 HawtIO 中显示正确的数据

如果 HawtIO 中的队列和连接显示缺少队列、缺少连接或显示不一致的图标,请调整 Jolokia 集合大小参数,用于指定响应中 Jolokia marshals 中的最大元素数。

流程

  1. 在 HawtIO 右上角,单击用户图标,然后单击 Preferences

  2. 增加 Maximum collection size 选项的值(默认值为 50,000)。
  3. 单击 Close

法律通告

Copyright © 2024 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
返回顶部
Red Hat logoGithubredditYoutubeTwitter

学习

尝试、购买和销售

社区

关于红帽文档

通过我们的产品和服务,以及可以信赖的内容,帮助红帽用户创新并实现他们的目标。 了解我们当前的更新.

让开源更具包容性

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。欲了解更多详情,请参阅红帽博客.

關於紅帽

我们提供强化的解决方案,使企业能够更轻松地跨平台和环境(从核心数据中心到网络边缘)工作。

Theme

© 2025 Red Hat