springboot actuator 自定义健康检查和端口

已于 2024-08-20 10:27:13 修改
阅读量571 收藏 7
点赞数 3
文章标签： spring boot 后端 java
于 2024-07-22 22:25:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_30409927/article/details/140620691
版权

什么是Actuator

spring boot actuator模块提供了生产级别的功能，比如健康检查、审计、指标收集、http跟踪等，帮助我们监控和管理spring boot应用。这个模块是一个采集应用内部信息暴露给外部的模块，上述的功能都可以通过HTTP和JMX访问。

因为暴露内部信息的特征，Actuator也可以和一些外部的应用监控系统整合（prometheus、graphite、apollo、nacos等）

集成Actuator

只要加上了下列包，springboot 在运行时会自动开启/actuator/health和/actuator/info这两个endpoint

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

访问http://localhost:8081/actuator/health

{
    "status": "UP",
    "components": {
        "db": {
            "status": "UP",
            "details": {
                "database": "MySQL",
                "validationQuery": "select 1",
                "result": 1
            }
        },
        "discoveryComposite": {
            "status": "UP",
            "components": {
                "discoveryClient": {
                    "status": "UP",
                    "details": {
                        "services": [
                            "service-member"
                        }
                    }
                }
            }
        },
        "hystrix": {
            "status": "UP"
        },
        "livenessState": {
            "status": "UP"
        },
        "readinessState": {
            "status": "UP"
        },
        "tomcat": {
            "status": "UP",
            "details": {
                "threadPool": {
                    "currentThreadsBusy": 0,
                    "currentThreadCount": 10,
                    "maxThreads": 200
                }
            }
        }
    },
    "groups": [
        "liveness",
        "readiness"
    ]
}

访问http://localhost:8081/actuator暴露出来的端点

{
    "_links": {
        "self": {
            "href": "http://localhost:8081/actuator",
            "templated": false
        },
        "archaius": {
            "href": "http://localhost:8081/actuator/archaius",
            "templated": false
        },
        "start": {
            "href": "http://localhost:8081/actuator/start",
            "templated": false
        },
        "beans": {
            "href": "http://localhost:8081/actuator/beans",
            "templated": false
        },
        "caches": {
            "href": "http://localhost:8081/actuator/caches",
            "templated": false
        },
        "caches-cache": {
            "href": "http://localhost:8081/actuator/caches/{cache}",
            "templated": true
        },
        "health": {
            "href": "http://localhost:8081/actuator/health",
            "templated": false
        },
        "health-path": {
            "href": "http://localhost:8081/actuator/health/{*path}",
            "templated": true
        },
        "info": {
            "href": "http://localhost:8081/actuator/info",
            "templated": false
        },
        "conditions": {
            "href": "http://localhost:8081/actuator/conditions",
            "templated": false
        },
        "shutdown": {
            "href": "http://localhost:8081/actuator/shutdown",
            "templated": false
        },
        "configprops": {
            "href": "http://localhost:8081/actuator/configprops",
            "templated": false
        },
        "env-toMatch": {
            "href": "http://localhost:8081/actuator/env/{toMatch}",
            "templated": true
        },
        "env": {
            "href": "http://localhost:8081/actuator/env",
            "templated": false
        },
        "loggers": {
            "href": "http://localhost:8081/actuator/loggers",
            "templated": false
        },
        "loggers-name": {
            "href": "http://localhost:8081/actuator/loggers/{name}",
            "templated": true
        },
        "heapdump": {
            "href": "http://localhost:8081/actuator/heapdump",
            "templated": false
        },
        "threaddump": {
            "href": "http://localhost:8081/actuator/threaddump",
            "templated": false
        },
        "prometheus": {
            "href": "http://localhost:8081/actuator/prometheus",
            "templated": false
        },
        "metrics-requiredMetricName": {
            "href": "http://localhost:8081/actuator/metrics/{requiredMetricName}",
            "templated": true
        },
        "metrics": {
            "href": "http://localhost:8081/actuator/metrics",
            "templated": false
        },
        "scheduledtasks": {
            "href": "http://localhost:8081/actuator/scheduledtasks",
            "templated": false
        },
        "mappings": {
            "href": "http://localhost:8081/actuator/mappings",
            "templated": false
        },
        "refresh": {
            "href": "http://localhost:8081/actuator/refresh",
            "templated": false
        },
        "features": {
            "href": "http://localhost:8081/actuator/features",
            "templated": false
        },
        "service-registry": {
            "href": "http://localhost:8081/actuator/service-registry",
            "templated": false
        }
    }
}

Endpoints介绍

spring boot提供了所谓的endpoints（下文翻译为端点）给外部来与应用程序进行访问和交互
eg：/health端点提供了关于应用健康情况的一些基础信息。metrics端点提供了一些有用的应用程序指标（JVM内存使用、系统cpu使用等）

这些Actuator 模块本来就有的端点我们称之为原生端点。根据端点的作用

  • 应用配置类：获取应用程序中加载的应用配置、环境变量、自动化配置报告等与Spring Boot应用密切相关的配置类信息。
  • 度量指标类：获取应用程序运行过程中用于监控的度量指标，比如：内存信息、线程池信息、HTTP请求统计等。
  • 操作控制类：提供了对应用的关闭等操作类功能。

端点配置

#指定端口号
management.server.port=8081
#同时可以将health修改成healthcheck
management.endpoints.web.path-mapping.health=healthcheck
#這樣寫的話，原本內建的/actuator/xxx路徑，都會變成/manage/xxx，可以用來防止被其他人猜到
management.endpoints.web.base-path=/manage
# 可以這樣寫，就會開啟所有endpoints(不包含shutdown)
management.endpoints.web.exposure.include=*
# 也可以這樣寫，就只會開啟指定的endpoint，因此此處只會再額外開啟/actuator/beans和/actuator/mappings
management.endpoints.web.exposure.include=beans,mappings

# exclude可以用來關閉某些endpoints
# exclude通常會跟include一起用，就是先include了全部，然後再exclude /actuator/beans這個endpoint
management.endpoints.web.exposure.exclude=beans
management.endpoints.web.exposure.include=*

# 如果要開啟/actuator/shutdown，要額外再加這一行
management.endpoint.shutdown.enabled=true

自定义端口号

package com.xxxxxx.starter.autoconfigure.config;

import com.ctrip.framework.apollo.util.ConfigUtil;
import com.xxxxxx.starter.autoconfigure.health.ApolloHealthIndicator;
import com.xxxxxx.starter.autoconfigure.health.NacosHealthIndicator;
import com.xxxxxx.starter.autoconfigure.health.StartEndpoint;
import com.xxxxxx.starter.gray.core.config.NacosAutoGrayRuleConfigUpdater;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.ConfigurableEnvironment;

import javax.annotation.PostConstruct;

@Slf4j
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(ConfigUtil.class)
@ConditionalOnProperty(name = "xxxxxx.starter.health.enabled", havingValue = "true",
    matchIfMissing = true)
public class HealthIndicatorConfiguration {

    private final ApplicationContext applicationContext;
    @Autowired
    private  ConfigurableEnvironment environment;


    public HealthIndicatorConfiguration(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    @PostConstruct
    public void init() {
        if (log.isInfoEnabled()) {
            log.info("ApolloHealthIndicatorConfiguration init completed");
        }
    }

//    @Bean
//    @ConditionalOnMissingBean(ApolloHealthIndicator.class)
//    public ApolloHealthIndicator apolloHealthIndicator() {
//        return new ApolloHealthIndicator();
//    }


    @Value("${gray.config.nacos-namespace.date-id:xxxxxx-go}")
    private String dateId;
    @Value("${gray.config.nacos-namespace.group:gray-dev}")
    private String group;

    @Value("${gray.config.nacos-namespace:01269cd6-7f0e-41a2-a492-18783d0075ee}")
    private String nacosNameSpace;

    @Value("${gray.config.nacos-user-name:nacos}")
    private String nacosUser;

    @Value("${gray.config.nacos-password:nacos}")
    private String nacosPassword;

    @Value("${gray.config.nacos-server:10.6.4.124:8848}")
    private String nacosServer;

    @Bean
    @ConditionalOnMissingBean(ApolloHealthIndicator.class)
    public StartEndpoint startEndpoint() {
        ApolloHealthIndicator apolloHealthIndicator = new ApolloHealthIndicator(environment);
        String nameSpace =  environment.getProperty("gray.config.namespace");
        nameSpace = StringUtils.isEmpty(nameSpace) ? "01269cd6-7f0e-41a2-a492-18783d0075ee" : nameSpace ;
        NacosHealthIndicator nacosHealthIndicator = new NacosHealthIndicator(dateId, group, nacosNameSpace, nacosUser, nacosPassword, nacosServer);
        return new StartEndpoint(applicationContext, apolloHealthIndicator, nacosHealthIndicator, environment);
    }

}


package com.xxxxxx.starter.autoconfigure.health;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
import org.springframework.boot.actuate.endpoint.annotation.Selector;
import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthComponent;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.boot.actuate.health.Status;
import org.springframework.context.ApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;


@Endpoint(id = "start")
@Slf4j
public class StartEndpoint {
    private final ApplicationContext applicationContext;
    private final ApolloHealthIndicator apolloHealthIndicator;
    private final  NacosHealthIndicator nacosHealthIndicator;

    private final ConfigurableEnvironment environment;

    public StartEndpoint(ApplicationContext applicationContext,ApolloHealthIndicator apolloHealthIndicator
                         ,NacosHealthIndicator nacosHealthIndicator,ConfigurableEnvironment environment) {
        this.applicationContext = applicationContext;
        this.apolloHealthIndicator = apolloHealthIndicator;
        this.nacosHealthIndicator = nacosHealthIndicator;
        this.environment = environment;
    }
    @ReadOperation
    public WebEndpointResponse<HealthComponent> getStartHealth() {
        return checkHealth();
    }

    public WebEndpointResponse<HealthComponent> checkHealth() {
        List<HealthIndicator> allHealthIndicators = getAllHealthIndicators();
        for (HealthIndicator healthIndicator : allHealthIndicators) {
            Health health = healthIndicator.health();

            log.info("health is {},class is {}",health.getDetails(), healthIndicator.getClass());
            boolean healthBoolean = health.getStatus().equals(Status.DOWN);
            log.info("healthStatus is {},healthBoolean is {}",health.getStatus(),healthBoolean);
            if (healthBoolean) {
                return new WebEndpointResponse(health, 503);
            }
        }

        String nacosProperty = environment.getProperty("xxxxxx.starter.nacos.health.enabled");
        if (StringUtils.isEmpty(nacosProperty) || "true".equals(nacosProperty)) {
            Health nacosHealth = nacosHealthIndicator.health();
            log.info("nacosHealth is {},nacosProperty is {}", nacosHealth ,nacosProperty);
            boolean nacosHealthBoolean = nacosHealth.getStatus().equals(Status.DOWN);
            log.info("nacosHealthStatus is {},nacosHealthBoolean is {}", nacosHealth.getStatus(), nacosHealthBoolean);
            if (nacosHealthBoolean) {
                return new WebEndpointResponse(nacosHealthBoolean, 503);
            }
        }

        String apolloProperty = environment.getProperty("xxxxxx.starter.apollo.health.enabled");
        if (StringUtils.isEmpty(apolloProperty) || "true".equals(apolloProperty)) {
            Health apolloHealth = apolloHealthIndicator.health();
            log.info("apolloHealth is {},apolloProperty is {}", apolloHealth, apolloProperty);
            boolean apolloHealthBoolean = apolloHealth.getStatus().equals(Status.DOWN);
            log.info("apolloHealthStatus is {},apolloHealthBoolean is {}", apolloHealth.getStatus(), apolloHealthBoolean);
            if (apolloHealthBoolean) {
                return new WebEndpointResponse(apolloHealthBoolean, 503);
            }
        }

        return new WebEndpointResponse(Health.up().build(), 200);
    }

    public List<HealthIndicator> getAllHealthIndicators() {
        List<HealthIndicator> healthIndicators = new ArrayList<>();

        Map<String, HealthIndicator> beansOfType = applicationContext.getBeansOfType(HealthIndicator.class);

        for (HealthIndicator healthIndicator : beansOfType.values()) {
            // 排除自定义的 HealthIndicatorProvider 类本身
            healthIndicators.add(healthIndicator);
        }

        return healthIndicators;
    }
}

apollo健康检查

package com.xxxxxx.starter.autoconfigure.health;


import com.ctrip.framework.apollo.ConfigService;
import com.ctrip.framework.apollo.build.ApolloInjector;
import com.ctrip.framework.apollo.core.ConfigConsts;
import com.ctrip.framework.apollo.internals.DefaultConfig;
import com.ctrip.framework.apollo.spring.config.PropertySourcesConstants;
import com.ctrip.framework.apollo.util.ConfigUtil;
import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import com.google.common.collect.Maps;
import com.google.common.escape.Escaper;
import com.google.common.net.UrlEscapers;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.web.client.RestTemplate;

import java.util.List;
import java.util.Map;
import java.util.Set;

@Slf4j
public class ApolloHealthIndicator implements HealthIndicator {
    private final RestTemplate restTemplate = new RestTemplate();
    private final ConfigUtil m_configUtil = ApolloInjector.getInstance(ConfigUtil.class);

    private static final Escaper queryParamEscaper = UrlEscapers.urlFormParameterEscaper();

    private static final Joiner.MapJoiner MAP_JOINER = Joiner.on("&").withKeyValueSeparator("=");

    private static final Splitter NAMESPACE_SPLITTER = Splitter.on(",").omitEmptyStrings().trimResults();
    private ConfigurableEnvironment environment;

    public ApolloHealthIndicator(ConfigurableEnvironment environment) {
        this.environment = environment;
    }

//    @Autowired
//    public void setEnvironment(ConfigurableEnvironment environment) {
//        this.environment = environment;
//    }
    @Override
    public Health health() {
        try {
            restTemplate.getForObject(assembleMetaServiceUrl(), String.class);
            String namespaces = environment.getProperty(PropertySourcesConstants.APOLLO_BOOTSTRAP_NAMESPACES, ConfigConsts.NAMESPACE_APPLICATION);
            List<String> namespaceList = NAMESPACE_SPLITTER.splitToList(namespaces);

            for (String namespace : namespaceList) {
                DefaultConfig config = (DefaultConfig) ConfigService.getConfig(namespace);
                Set<String> propertyNames = config.getPropertyNames();
                if (propertyNames.isEmpty()) {
                    log.error("ApolloHealthIndicator namespace is {} empty",namespace);
                    continue;
                    //return Health.down().build();
                } else {
                    return Health.up().build();
                }
            }
            return Health.down().build();
        } catch (Exception e) {
            log.error("health error",e);
            return Health.down(e).build();
        }
    }

    private String assembleMetaServiceUrl() {
        String domainName = m_configUtil.getMetaServerDomainName();
        String appId = m_configUtil.getAppId();
        String localIp = m_configUtil.getLocalIp();

        Map<String, String> queryParams = Maps.newHashMap();
        queryParams.put("appId", queryParamEscaper.escape(appId));
        if (!Strings.isNullOrEmpty(localIp)) {
            queryParams.put("ip", queryParamEscaper.escape(localIp));
        }

        return domainName + "/services/config?" + MAP_JOINER.join(queryParams);
    }
}

nacos健康检查

package com.xxxxxx.starter.autoconfigure.health;

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.PropertyKeyConst;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;

import java.util.Properties;

@Slf4j
public class NacosHealthIndicator implements HealthIndicator {

    private final String dateId;
    private final String group;
    private final String nacosNameSpace;
    private final String nacosUser;
    private final String nacosPassword;
    private final String nacosServer;

    public NacosHealthIndicator(String dateId,String group,String nacosNameSpace,String nacosUser,String nacosPassword,String nacosServer) {
        this.dateId = dateId;
        this.group = group;
        this.nacosNameSpace = nacosNameSpace;
        this.nacosUser = nacosUser;
        this.nacosPassword = nacosPassword;
        this.nacosServer = nacosServer;
    }

    @Override
    public Health health() {
        ConfigService configService = getConfig();
        try {
            String content = configService.getConfig(dateId, group, 3000L);
            if (!StringUtils.isEmpty(content)) {
                return Health.up().build();
            }
        } catch (NacosException e) {
            log.error("NacosHealthIndicator error is ",e);
            return Health.down().build();
        }
        return Health.down().build();
    }

    public ConfigService getConfig() {
        Properties properties = new Properties();
        properties.put(PropertyKeyConst.USERNAME, nacosUser);
        properties.put(PropertyKeyConst.PASSWORD, nacosPassword);
        properties.put(PropertyKeyConst.SERVER_ADDR, nacosServer);
        properties.put(PropertyKeyConst.NAMESPACE, nacosNameSpace);

        log.info("灰度配置信息: data-id:{}, group:{}, namespace:{}", dateId, group, nacosNameSpace);
        try {
            return NacosFactory.createConfigService(properties);
        } catch (NacosException e) {
            log.error("getConfig error",e);
        }
        return null;
    }
}
bingbingYang_88
关注
spring boot之actuator健康检查
weixin_44504392的博客
11-26 3829
什么是actuator SpringBoot自带监控功能Actuator，可以帮助实现对程序内部运行情况监控，比如监控状况、Bean加载情况、环境变量、日志信息、线程信息等。 官翻文档：https://blog.csdn.net/alinyua/article/details/80009435 快速使用教程：https://blog.csdn.net/pengjunlee/article/details/80235390 进阶使用：https://blog.csdn.net/alinyua/article/
springboot干货——自定义健康检查指标
东天里的冬天
10-28 1969
springboot——汇总篇 前言 在系统运行过程中我们需要监控系统运行是否正常，而有时因为系统或者需求的特殊之处，我们需要自定义相关健康指标用以监测我们的系统。本篇博客主要带大家了解下相关内容，不做深入探讨，有兴趣的可以百度。 健康检查有两种方式查看，一种是http，另一种是JMX，http方式很好理解，JMX一般可以用jdk的bin目录下的jconsole工具 YES表示默认使...
Spring boot 2.0 Actuator 的健康检查
西京刀客
04-02 9515
Spring boot 2.0 Actuator 的健康检查 官网参考：https://docs.spring.io/spring-boot/docs/2.1.3.RELEASE/reference/htmlsingle/#production-ready-health Spring boot 2.0 Actuator 的健康检查 参考URL: https://www.jianshu.com/p/...
SpringBoot学习（17）Actuator
最新发布
L08130421的博客
09-11 861
Spring Boot 使用“习惯优于配置的理念”，采用包扫描和自动化配置的机制来加载依赖 Jar 中的 Spring bean，不需要任何 Xml 配置，就可以实现 Spring 的所有配置。Actuator 是 Spring Boot 提供的对应用系统的自省和监控的集成功能，可以查看应用配置的详细信息，例如自动化配置信息、创建的 Spring beans 以及一些环境属性等。自定义端点主要是指扩展性，用户可以根据自己的实际应用，定义一些比较关心的指标，在运行期进行监控。
Spring Boot Actuator自定义监控集成到/health接口实战
吴代庄的博客
02-20 3886
在本文中，我们详细探讨了如何通过自定义监控集成到 Spring Boot 的 `/health` 端点。首先，我们介绍了 `HealthEndpointWebExtension` 的概念，它允许我们对健康检查端点进行扩展和自定义。然后，我们了解了如何使用 `AbstractHealthIndicator` 创建自定义的健康指标，这些指标可以插入到健康检查流程中，提供有关应用程序特定部分的健康状况信息。
springboot添加健康检查
fh_luchenxi的博客
02-18 1431
springboot添加健康检查
Spring Boot Actuator ——健康检查神器
秃了也弱了
08-22 1873
Spring Boot 有一个 Actuator 模块，封装了诸如健康检测、应用内部信息、Metrics 指标等生产就绪的功能。Spring Boot Actuator 的快速使用入门Spring Boot Actuator 的一些重要的endpoints的介绍如何通过Actuator 模块实时查看当前应用的线程 dump信息如何通过Actuator 模块实时查看当前应用的堆信息如何通过Actuator 模块实时修改当前应用的日志打印等级…
Java一分钟之-Spring Boot Actuator：健康检查与监控
zevjay的博客
06-07 766
Spring Boot Actuator是提升应用可观察性和维护性的强大工具。正确配置和使用它，不仅可以帮助开发者快速定位问题，还能在生产环境中提供必要的监控和管理能力。通过上述介绍和示例，希望能帮助你更好地理解和运用Actuator，为你的微服务架构增添一份保障。在实践中不断探索，根据具体需求灵活调整配置，是发挥Actuator最大效能的关键。
使用SpringBoot Actuator监控应用示例
08-27
Actuator还允许你通过实现`HealthIndicator`接口创建自定义的健康检查端点，以扩展监控功能。同时，你可以通过编写自己的端点控制器来增加更多的监控指标。 最后，`/shutdown`端点允许你通过POST请求关闭应用程序，...
Spring Boot 项目健康检查工具Actuator
q1472750149的博客
11-19 1717
前言 公司经过野蛮生长阶段，系统稳定性，CI，CD持续集成交付，基于Spring Cloud 微服务系统使用Spring Boot健康检查工具，提高发布的效率和全方位监控。在没有监控之前，比如说一个Feign微服务项目，我们可能在SpringBoot项目启动之后通过一个Rest接口比如说 127.0.0.1:8888/ok 这个种接口的形式，集成在自动化脚本里面去校验发布时候正常，或者人工去做一些校验。 其实这些都可以通过 Actuator 工具包去做。 官方文档： docs.spring.io/sp
SpringBoot自定义服务器端口与激光振镜管理
这样，SpringBoot的健康检查、监控和其他Actuator端点就会监听指定的8081端口，而不是默认的端口（通常是8080或8000）。 SpringBoot是一个快速开发框架，旨在简化Spring应用的初始搭建以及开发过程。它集成了大量...
SpringBoot实现项目健康检查与监控
08-27
主要介绍了SpringBoot实现项目健康检查与监控,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
Springboot Actuator监控
热门推荐
weixin_43971312的博客
12-09 1万+
springboot 2.7.5 监控官网翻译
Spring Boot中的健康检查端点配置
聚娃科技开发者博客
07-07 507
从默认的端点配置到自定义健康检查指示器的实现，Spring Boot提供了灵活和强大的功能，帮助开发者轻松实现应用的健康状态监控。在微服务架构中，健康检查是非常重要的一环，它能够告知运维人员和监控系统应用的运行状态，从而及时发现并解决问题。在上面的例子中，我们创建了一个自定义的健康检查指示器（HealthIndicator），它会执行一些特定的健康检查逻辑，根据检查结果返回不同的健康状态。例如，我们可以创建一个自定义的健康检查端点，用于检查某些特定的资源或服务是否可用。端点暴露出来，使其可以被外部访问。
Spring Boot 健康检查、度量指标、监控，一文搞定！
2401_83412087的博客
04-17 1585
当然你也可以自定义一个Health Indicator，只需要实现接口或者继承类。
说一说spring boot服务的健康检测
天草二十六
07-07 2011
经过上文对程序的修正，重启后，consul和k8s对服务的健康检测均为OK点击进去，查看详情，可以看到其健康检测接口地址及检测结果。K8S容器里的只要也保持该健康检测地址即可，本文就不再赘述~
Spring Boot Actuator健康检查
weixin_49613823的博客
01-08 7808
Spring Boot 有一个 Actuator 模块，封装了诸如健康检测、应用内部信息、Metrics 指标等生产就绪的功能。
springboot actuator 常用接口
只为成功找方法 不为失败找借口
10-25 2043
微服务作为一项在云中部署应用和服务的新技术是当下比较热门话题，而微服务的特点决定了功能模块的部署是分布式的，运行在不同的机器上相互通过服务调用进行交互，业务流会经过多个微服务的处理和传递，在这种框架下，微服务的监控显得尤为重要。而Actuator正是Spring Boot提供的对应用系统的监控和管理的集成功能，可以查看应用配置的详细信息，例如自动化配置信息、创建的Spring beans信息、系统环境变量的配置信以及Web请求的详细信息等。
Spring-boot 添加自定义健康检测 /actuator/health
killgodaa的专栏
03-16 2572
spring健康检测体系，通过请求/actuator/health,返回程序的健康指标，也可以自定义健康检测指标
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值