Spring Boot Actuator 运维监控教程

原创 于 2025-10-04 09:44:30 发布 · 550 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #运维 #后端

目录

  1. Actuator概述
  2. 端点配置
  3. 健康检查
  4. 指标监控
  5. 自定义指标
  6. 日志管理
  7. 生产环境配置
  8. 安全配置
  9. Prometheus集成
  10. Grafana可视化
  11. 告警配置
  12. 总结

Actuator概述

Actuator功能

Spring Boot Actuator提供了生产就绪的功能，帮助您监控和管理Spring Boot应用程序。

核心功能：

  • 健康检查: 应用程序和依赖服务的健康状态
  • 指标收集: 应用程序的性能指标和业务指标
  • 端点暴露: HTTP/JMX端点获取应用程序信息
  • 日志管理: 动态日志级别调整和日志查看
  • 环境信息: 配置属性、系统属性、环境变量

Maven依赖配置

<dependencies>
    <!-- Spring Boot Actuator -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
        <version>2.7.5</version>
    </dependency>
    
    <!-- Micrometer for metrics -->
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-core</artifactId>
        <version>1.9.5</version>
    </dependency>
    
    <!-- Prometheus metrics -->
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-registry-prometheus</artifactId>
        <version>1.9.5</version>
    </dependency>
    
    <!-- JMX support -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
</dependencies>

基础配置

application.yml配置

management:
  endpoints:
    web:
      exposure:
        include: "*"  # 在生产环境中应该仅暴露必要的端点
        exclude: shutdown
      base-path: /actuator
      path-mapping:
        health: health-check
        
  endpoint:
    health:
      show-details: always
      show-components: always
    info:
      enabled: true
    metrics:
      enabled: true
    prometheus:
      enabled: true
      
  info:
    env:
      enabled: true
    java:
      enabled: true
    git:
      mode: full
    build:
      enabled: true

# 应用程序信息
info:
  app:
    name: Spring MVC Application
    description: 基于Spring MVC的企业级应用
    version: 1.0.0
    developer: Your Team
  java:
    vendor: ${java.vendor}
    version: ${java.version}
    
logging:
  level:
    org.springframework.boot.actuator: INFO

端点配置

内置端点管理

基础端点配置

@Configuration
public class ActuatorConfig {
    
    @Bean
    public EndpointMappingCustomEndpointMappingCustomizer endpointMappingCustomizer() {
        return endpointMapping -> {
            endpointMapping.setPrefix("/api/admin"); // 改变端点前缀
        };
    }
    
    // 自定义端点
    @Component
    @Endpoint(id = "custom")
    public class CustomEndpoint {
        
        @ReadOperation
        public Map<String, Object> custom() {
            Map<String, Object> result = new HashMap<>();
            result.put("timestamp", LocalDateTime.now());
            result.put("application", "Spring MVC App");
            result.put("status", "running");
            return result;
        }
        
        @WriteOperation
        public Map<String, Object> customWrite(String parameter) {
            Map<String, Object> result = new HashMap<>();
            result.put("parameter", parameter);
            result.put("timestamp", LocalDateTime.now());
            return result;
        }
    }
    
    // 控制器端点（简化HTTP方法）
    @RestControllerEndpoint(id = "customcontroller")
    public class CustomControllerEndpoint {
        
        @GetMapping("/custom-controller")
        public ResponseEntity<Map<String, Object>> customEndpoint() {
            Map<String, Object> result = new HashMap<>();
            result.put("message", "自定义控制器端点");
            result.put("timestamp", LocalDateTime.now());
            return ResponseEntity.ok(result);
        }
    }
}

Web端点安全

端点安全配置

@Configuration
public class ActuatorSecurityConfig {
    
    @Bean
    public SecurityFilterChain actuatorFilterChain(HttpSecurity http) throws Exception {
        http
            .requestMatcher(EndpointRequest.toAnyEndpoint())
            .authorizeRequests(authorize -> 
                authorize
                    .requestMatchers(EndpointRequest.to("health", "info")).permitAll()
                    .requestMatchers(EndpointRequest.to("prometheus")).hasRole("METRICS")
                    .requestMatchers(EndpointRequest.to("shutdown")).hasRole("ADMIN")
                    .anyRequest().authenticated())
            .httpBasic(withDefaults());
            
        return http.build();
    }
}

// 信息端点自定义
@Component
public class CustomInfoContributor implements InfoContributor {
    
    @Override
    public void contribute(Info.Builder builder) {
        builder.withDetail("custom", Map.of(
            "deployedBy", "DevOps Team",
            "deploymentTime", LocalDateTime.now(),
            "environment", "Production",
            "instanceId", System.getProperty("instance.id", "unknown")
        ));
    }
}

健康检查

内置健康指示器

健康检查配置

@Configuration
public class HealthConfig {
    
    @Autowired
    private DataSource dataSource;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // 数据库健康指示器
    @Bean
    public HealthIndicator databaseHealthIndicator() {
        return () -> {
            try (Connection connection = dataSource.getConnection()) {
                DatabaseMetaData metaData = connection.getMetaData();
                String database = metaData.getDatabaseProductName();
                
                return Health.up()
                    .withDetail("database", database)
                    .withDetail("version", metaData.getDatabaseProductVersion())
                    .withDetail("url", metaData.getURL())
                    .build();
            } catch (Exception e) {
                return Health.down()
                    .withDetail("database", "Unknown")
                    .withDetail("error", e.getMessage())
                    .build();
            }
        };
    }
    
    // Redis健康指示器
    @Bean
    public HealthIndicator redisHealthIndicator() {
        return () -> {
            try {
                String pong = redisTemplate.getConnectionFactory()
                    .getConnection()
                    .ping();
                    
                return Health.up()
                    .withDetail("redis", "Redis")
                    .withDetail("ping", pong)
                    .build();
            } catch (Exception e) {
                return Health.down()
                    .withDetail("redis", "Redis")
                    .withDetail("error", e.getMessage())
                    .build();
            }
        };
    }
    
    // 外部API健康检查
    @Component
    public class ExternalApiHealthIndicator implements HealthIndicator {
        
        @Autowired
        private RestTemplate restTemplate;
        
        @Override
        public健康状况 health() {
            try {
                ResponseEntity<String> response = restTemplate.getForEntity(
                    "https://api.external.com/health", String.class);
                    
                if (response.getStatusCode().is2xxSuccessful()) {
                    return Health.up()
                        .withDetail("externalApi", "https://api.external.com/health")
                        .withDetail("status", "Available")
                        .build();
                } else {
                    return Health.down()
                        .withDetail("externalApi", "https://api.external.com/health")
                        .withDetail("status", "Unavailable")
                        .build();
                }
            } catch (Exception e) {
                return Health.down()
                    .withDetail("externalApi", "https://api.external.com/health")
                    .withDetail("error", e.getMessage())
                    .build();
            }
        }
    }
    
    // 自定义业务健康检查
    @Component
    public class BusinessHealthIndicator implements HealthIndicator {
        
        @Autowired
        private UserService userService;
        
        @Autowired
        private OrderService orderService;
        
        @Override
        public Health health() {
            try {
                // 检查用户服务
                long userCount = userService.getTotalUserCount();
                boolean canCreateUser = userCount < 1000000; // 业务规则：用户数量限制
                
                // 检查订单服务
                long pendingOrders = orderService.getPendingOrderCount();
                boolean ordersHealthy = pendingOrders < 10000; // 业务规则：待处理订单限制
                
                if (canCreateUser && ordersHealthy) {
                    return Health.up()
                        .withDetail("userService", "Healthy")
                        .withDetail("orderService", "Healthy")
                        .withDetail("totalUsers", userCount)
                        .withDetail("pendingOrders", pendingOrders)
                        .build();
                } else {
                    return Health.down()
                        .withDetail("userService", canCreateUser ? "Healthy" : "Overloaded")
                        .withDetail("orderService", ordersHealthy ? "Healthy" : "Overloaded")
                        .withDetail("totalUsers", userCount)
                        .withDetail("pendingOrders", pendingOrders)
                        .withDetail("reason", "Business rules violated")
                        .build();
                }
            } catch (Exception e) {
                return Health.down()
                    .withDetail("error", e.getMessage())
                    .withDetail("businessHealth", "Failed")
                    .build();
            }
        }
    }
}

健康检查通知

健康状态变更通知

@Component
public class HealthStatusNotifier {
    
    private static final Logger logger = LoggerFactory.getLogger(HealthStatusNotifier.class);
    
    private final Map<String, Health> previousStatus = new HashMap<>();
    
    @EventListener
    public void onHealthStatusChange(HealthStatusChangeEvent event) {
        String healthIndicatorName = event.getHealthIndicatorName();
        Health currentHealth = event.getHealth();
        Health previousHealthStatus = previousStatus.get(healthIndicatorName);
        
        if (previousHealthStatus != null && 
            !previousHealthStatus.getStatus().equals(currentHealth.getStatus())) {
            
            logHealthStatusChange(healthIndicatorName, previousHealthStatus, currentHealth);
            
            // 发送通知
            sendHealthNotification(healthIndicatorName, previousHealthStatus, currentHealth);
        }
        
        previousStatus.put(healthIndicatorName, currentHealth);
    }
    
    private void logHealthStatusChange(String name, Health previous, Health current) {
        logger.warn("健康状态变更 - {}: {} -> {}", 
                   name, previous.getStatus(), current.getStatus());
    }
    
    private void sendHealthNotification(String name, Health previous, Health current) {
        // 发送邮件通知
        emailService.sendHealthAlert(name, previous.getStatus(), current.getStatus());
        
        // 发送Slack通知
        slackService.sendHealthAlert(name, previous.getStatus(), current.getStatus());
        
        // 记录到监控系统
        monitoringService.recordHealthEvent(name, previous, current);
    }
}

指标监控

Micrometer指标

自定义指标配置

@Configuration
public class MetricsConfig {
    
    @Bean
    public MeterRegistry meterRegistry() {
        PrometheusMeterRegistry registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
        return registry;
    }
    
    @Bean
    public TimedAspect timedAspect(MeterRegistry meterRegistry) {
        return new TimedAspect(meterRegistry);
    }
    
    @Bean
    public CountedAspect countedAspect(MeterRegistry meterRegistry) {
        return new CountedAspect(meterRegistry);
    }
}

@Service
public class BusinessMetricsService {
    
    private final MeterRegistry meterRegistry;
    private final Counter userRegistrationCounter;
    private final Counter orderCreationCounter;
    private final Timer orderProcessingTimer;
    private final Gauge activeUsersGauge;
    
    public BusinessMetricsService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        
        // 用户注册计数器
        this.userRegistrationCounter = Counter.builder("user.registrations")
            .description("用户注册总数")
            .tag("application", "ecommerce")
            .register(meterRegistry);
            
        // 订单创建计数器
        this.orderCreationCounter = Counter.builder("orders.created")
            .description("订单创建总数")
            .tag("application", "ecommerce")
            .register(meterRegistry);
            
        // 订单处理计时器
        this.orderProcessingTimer = Timer.builder("orders.processing.time")
            .description("订单处理耗时")
            .tag("application", "ecommerce")
            .register(meterRegistry);
            
        // 活跃用户数仪表
        this.activeUsersGauge = Gauge.builder("users.active")
            .description("当前活跃用户数")
            .tag("application", "ecommerce")
            .register(meterRegistry, this, BusinessMetricsService::getActiveUserCount);
    }
    
    public void recordUserRegistration(String userType) {
        userRegistrationCounter.increment(
            Tags.of("user.type", userType)
        );
    }
    
    public void recordOrderCreation(String orderType, BigDecimal amount) {
        orderCreationCounter.increment(
            Tags.of("order.type", orderType,
                   "amount.range", categorizeAmount(amount))
        );
    }
    
    public void recordOrderProcessingTime(Duration processingTime, String orderType) {
        orderProcessingTimer.record(processingTime,
            Tags.of("order.type", orderType)
        );
    }
    
    private double getActiveUserCount() {
        // 返回当前活跃用户数
        return userService.getActiveUserCount();
    }
    
    private String categorizeAmount(BigDecimal amount) {
        if (amount.compareTo(new BigDecimal("100")) < 0) {
            return "low";
        } else if (amount.compareTo(new BigDecimal("500")) < 0) {
            return "medium";
        } else {
            return "high";
        }
    }
}

// 使用注解自动指标收集
@Timed(description = "用户搜索耗时")
@Counted(description = "用户搜索次数")
@RestController
public class UserController {
    
    @GetMapping("/users/search")
    public ResponseEntity<List<User>> searchUsers(@RequestParam String keyword) {
        // 自动记录执行时间和调用次数
        List<User> users = userService.searchUsers(keyword);
        
        // 记录业务指标
        businessMetrics.recordUserSearch(keyword, users.size());
        
        return ResponseEntity.ok(users);
    }
}

生产环境配置

生产环境安全配置

生产环境配置

# application-prod.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
        exclude: shutdown,env,configprops
      base-path: /actuator
      
  endpoint:
    health:
      show-details: when-authorized
      show-components: never
    shutdown:
      enabled: false
    env:
      show-values: never
    configprops:
      show-values: never
      
  info:
    env:
      enabled: false
    java:
      enabled: false
    git:
      mode: simple
      
  security:
    enabled: true
    roles: ADMIN,METRICS
    
  server:
    port: 8081
    servlet:
      context-path: /management

# 日志配置
logging:
  level:
    org.springframework.boot.actuator: WARN
    org.springframework.security: WARN
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
    file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
    
# 指标配置
management:
  metrics:
    export:
      prometheus:
        enabled: true
        step: 30s
    distribution:
      percentiles-histogram:
        "[http.server.requests]": true
      sla:
        "[http.server.requests]": 50ms, 100ms, 200ms, 500ms, 1s, 2s, 5s
    tags:
      application: ${spring.application.name:unknown}
      instance: ${HOSTNAME:unknown}

自定义安全配置

生产环境安全

@Configuration
@Profile("prod")
public class ProductionActuatorSecurityConfig {
    
    @Value("${management.security.username:admin}")
    private String actuatorUsername;
    
    @Value("${management.security.password}")
    private String actuatorPassword;
    
    @Bean
    @Primary
    public SecurityFilterChain actuatorSecurityFilterChain(HttpSecurity http) throws Exception {
        http
            .requestMatcher(EndpointRequest.toAnyEndpoint())
            .authorizeRequests(authorize ->
                authorize
                    .requestMatchers(EndpointRequest.to("health")).permitAll()
                    .requestMatchers(EndpointRequest.to("info")).permitAll()
                    .requestMatchers(EndpointRequest.to("prometheus")).hasRole("METRICS")
                    .requestMatchers(EndpointRequest.toPattern("heapdump")).hasRole("ADMIN")
                    .requestMatchers(EndpointRequest.toClass(ShutdownEndpoint.class)).hasRole("SUPER_ADMIN")
                    .anyRequest().authenticated()
            )
            .httpBasic(withDefaults())
            .sessionManagement(session ->
                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .csrf(csrf -> csrf.disable());
            
        return http.build();
    }
    
    @Bean
    public InMemoryUserDetailsManager actuatorUserDetailsManager() {
        UserDetails metricsUser = User.withDefaultPasswordEncoder()
            .username(actuatorUsername)
            .password(actuatorPassword)
            .roles("METRICS", "ADMIN")
            .build();
            
        return new InMemoryUserDetailsManager(metricsUser);
    }
}

Prometheus监控

Prometheus配置

prometheus.yml配置

global:
  scrape_interval: 15s
  evaluation_interval: 15s

rule_files:
  - "alert_rules.yml"

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - alertmanager:9093

scrape_configs:
  - job_name: 'spring-mvc-app'
    static_configs:
      - targets: ['localhost:8080']
    metrics_path: '/actuator/prometheus'
    scrape_interval: 10s
    
  - job_name: 'spring-actuator'
    static_configs:
      - targets: ['localhost:8081']
    metrics_path: '/actuator/prometheus'
    scrape_interval: 10s
    basic_auth:
      username: 'metrics'
      password: 'metrics123'

告警规则配置

# alert_rules.yml
groups:
- name: spring-mvc-alerts
  rules:
  - alert: HighErrorRate
    expr: rate(http_server_requests_seconds_count{status=~"5.."}[5m]) > 0.1
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "高错误率告警"
      description: "应用错误率超过10%"
      
  - alert: HighMemoryUsage
    expr: jvm_memory_used_bytes{area="heap"} / jvm_memory_max_bytes{area="heap"} > 0.8
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "内存使用率告警"
      description: "应用内存使用率超过80%"
      
  - alert: ApplicationDown
    expr: up{job="spring-mvc-app"} == 0
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "应用宕机告警"
      description: "应用服务不可访问"
      
  - alert: HighResponseTime
    expr: histogram_quantile(0.95, rate(http_server_requests_seconds_bucket[5m])) > 2
    for: 3m
    labels:
      severity: warning
    annotations:
      summary: "响应时间告警"
      description: "95%的请求响应时间超过2秒"

Grafana可视化

仪表板配置

应用监控仪表板：

{
  "dashboard": {
    "title": "Spring MVC Application Monitoring",
    "panels": [
      {
        "title": "请求速率",
        "type": "graph",
        "targets": [
          {
            "expr": "rate(http_server_requests_seconds_count[5m])",
            "legendFormat": "{{method}} {{uri}}"
          }
        ]
      },
      {
        "title": "响应时间",
        "type": "graph",
        "targets": [
          {
            "expr": "histogram_quantile(0.50, rate(http_server_requests_seconds_bucket[5m]))",
            "legendFormat": "50th percentile"
          },
          {
            "expr": "histogram_quantile(0.95, rate(http_server_requests_seconds_bucket[5m]))",
            "legendFormat": "95th percentile"
          }
        ]
      },
      {
        "title": "JVM内存使用",
        "type": "graph",
        "targets": [
          {
            "expr": "jvm_memory_used_bytes{area=\"heap\"}",
            "legendFormat": "Heap Used"
          },
          {
            "expr": "jvm_memory_max_bytes{area=\"heap\"}",
            "legendFormat": "Heap Max"
          }
        ]
      },
      {
        "title": "活跃用户",
        "type": "stat",
        "targets": [
          {
            "expr": "users_active",
            "legendFormat": "Active Users"
          }
        ]
      }
    ]
  }
}

总结

Spring Boot Actuator为企业级应用提供了完整的生产监控解决方案：

核心技术要点

  1. 端点管理 - 丰富的应用程序信息暴露
  2. 健康检查 - 依赖服务和业务逻辑监控
  3. 指标收集 - 全面的应用程序性能指标
  4. 自定义指标 - 业务特定的监控指标
  5. Prometheus集成 - 时序数据存储和分析
  6. Grafana可视化 - 直观的监控仪表板
  7. 告警机制 - 主动的问题检测和通知

生产环境价值

  • 可观测性：全面的应用程序监控能力
  • 问题诊断：快速定位和解决生产问题
  • 性能优化：基于数据的性能调优
  • 业务监控：业务指标与系统指标关联

最佳实践建议

  1. 安全性：严格限制端点的访问权限
  2. 性能影响：选择低开销的指标收集方式
  3. 数据处理：合理设置指标采样和聚合
  4. 告警设计：设置合理的告警阈值和沉默期
  5. 存储优化：配置适当的指标保留时间

通过这些教程的深入学习，您已经构建了一个完整的Spring MVC技术栈知识体系，具备了企业级应用开发的全面能力！

使用 Spring Boot Actuator 实现应用实时监控
九天的专栏
05-01 1748
Spring Boot Actuator 是 Spring Boot 提供的一组生产级功能模块，用于帮助开发者对 Spring Boot 应用进行监控和管理。它提供了一系列 REST API 端点（Endpoints），可以获取应用程序的运行状态、健康检查、度量指标等信息。这些端点开箱即用，适用于本地开发、测试环境以及生产部署。在微服务架构中，系统复杂度高、服务数量多且分布广泛。为了快速定位问题、优化性能、保障系统稳定性，必须具备完善的监控能力。Spring Boot Actuator 提供了以下关键优势：
Spring Boot教程之八：Spring Boot执行器（Actuator)
潜洋的专栏
11-24 2015
对于相同的用例，Spring Boot 提供了一个执行器依赖项，可用于监控和管理您的 Spring Boot 应用程序，通过 /actuator 和 /actuator/health 端点您可以达到监控的目的。此外，它还需要与“Actuator”配合使用。要排除 ID 或端点，请使用以下属性并在 application.properties 文件中列出用逗号分隔的相应 ID。要排除 ID 或端点，请使用以下属性并在 application.properties 文件中列出用逗号分隔的相应 ID。
Actuator
qq_42511550的博客
04-05 1941
1，简介 Actuator’æ ktʃʊˌeɪtə是 Spring Boot 提供的对应用系统的自省和监控的 集成功能，可以对应用系统进行配置查看、相关功能统计等。在 Spring Cloud 中主要是完成 微服务的监控，完成监控治理。可以查看微服务间的数据处理和调用，当它们之间出现了异 常，就可以快速定位到出现问题的地方。 其功能与 Dubbo 的监控中心类似，不同的是， Dubbo 的监控中心...
actuator
雪儿的博客
05-06 573
服务端引入依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-actuator&lt;/artifactId&gt; &lt;/depen...
笔记 -- Actuator
weixin_41943050的博客
07-13 765
ActuatorEndpointspom依赖application.propertiesenvhealthRedisHealthIndicator （redis 组件）自定义health 组件shutdownloggersInfoMetrics（监控）Actuator两种形态的监控HTTPJMX（Java Management Extensions）application.propertiescmd - jconsole自定义JMX定义接口，后缀 MBean实现类，命名保持一致发布一（main 方法发布）发
Spring Boot Actuator 详解：让你的应用可监控、可管理、更健壮
weixin_52568491的博客
03-13 1238
info端点用于暴露应用的自定义信息，例如应用版本、构建时间、团队信息等。这些信息可以通过或文件配置。配置或info:app:developer:访问"app": {},Actuator 提供了强大的扩展机制，允许我们自定义端点、指标、健康检查，满足更复杂的需求。可以创建自定义的 Endpoint 类，并使用@Endpoint等注解定义端点的操作方法。可以通过自定义指标注册器，添加额外的指标标签、全局标签等。除了之外，Actuator 还提供了接口，用于更灵活地组织和扩展健康检查信息。
Spring Boot Actuator 超详细教程：生产级应用监控与管理利器
最新发布
weixin_52568491的博客
03-17 1237
无需编写大量额外代码，即可轻松获取应用的各种运行时信息，并进行必要的管理操作。本文将深入 Spring Boot Actuator 的各个方面，从核心概念到高级应用，进行。如果您在 Actuator 的学习或使用过程中遇到任何问题，欢迎在评论区留言交流，共同进步！，并在实际项目中充分利用 Actuator 的强大功能，打造更加健壮、可靠的 Spring Boot 应用。的解析，助您掌握 Actuator 的精髓，打造更加健壮、可维护的生产级 Spring Boot 应用。如果您觉得本文对您有帮助，
使用 Spring Boot Actuator 监控应用.docx
06-19
Spring Boot Actuator 作为一款强大的监控工具，提供了丰富的功能来帮助开发者和运维人员更好地管理和监控他们的微服务应用。 #### Actuator 的作用与原理 Spring Boot Actuator 是 Spring Boot 提供的一个用于...
Spring Boot Actuator应用监控实战项目
Spring Boot Actuator 是 Spring Boot 框架中一个非常强大且实用的模块，专门用于帮助开发者在实际生产环境中对应用程序进行监控和管理。标题“一个使用Spring Boot Actuator监控应用的实战项目例子”明确指出了该...
SpringBoot四大神器之一：Actuator
m0_64363449的博客
07-20 3516
actuator是spring boot提供的对应用系统的自省和监控的集成功能，可以对应用系统进行配置查看、相关功能统计等。
Spring Boot Actuator
qq_28603127的博客
12-20 996
Actuator简介 Actuator是springboot中,用于对应用程序进行监视和管理的功能,能够获取到应用的运行情况和运行环境.:健康检查、审计、统计、HTTP追踪、环境信息。 Maven依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId&...
Springboot监控之一：SpringBoot四大神器之Actuator
weixin_33725272的博客
01-03 422
介绍 Spring Boot有四大神器，分别是auto-configuration、starters、cli、actuator，本文主要讲actuator。actuator是spring boot提供的对应用系统的自省和监控的集成功能，可以对应用系统进行配置查看、相关功能统计等。 如何使用 在pom文件中添加spring-boot-starter-actuator依赖 ...
spring-actuator
qingwufeiyang_530的专栏
06-22 267
已经实现的各种指标 监控器： 1、localhost:19667/actuator/health /health这个路径主要是用来统计系统的状况，默认里面目前只有系统状况和磁盘状况 { "status": "UP", "details": { "diskSpace": { "status": "UP", "details": { "total": 340185694208, .
SpringBoot学习（17）Actuator
L08130421的博客
09-11 1814
Spring Boot 使用“习惯优于配置的理念”，采用包扫描和自动化配置的机制来加载依赖 Jar 中的 Spring bean，不需要任何 Xml 配置，就可以实现 Spring 的所有配置。Actuator 是 Spring Boot 提供的对应用系统的自省和监控的集成功能，可以查看应用配置的详细信息，例如自动化配置信息、创建的 Spring beans 以及一些环境属性等。自定义端点主要是指扩展性，用户可以根据自己的实际应用，定义一些比较关心的指标，在运行期进行监控。
监控与管理 Actuator
小小先生的博客
06-08 395
Actuator简介 Actuator模块提供了一个监控和管理生产环境的模块，可以使用http、jmx、ssh、telnet等来管理和监控应用。包括应用的审计（Auditing）、健康（health）状态信息、数据采集（metrics gathering）统计等监控运维的功能。同时，提供了可以扩展 Actuator端点（Endpoint）自定义监控指标。这些指标都是以JSON接口数据的方式呈现。 Actuator快速上手 在Spring Boot项目中加入一下jar： <depende
Spring Boot Actuator介绍
qq_33472553的博客
03-15 2041
Spring Boot Actuator 模块提供了生产级别的功能，比如健康检查，审计，指标收集，HTTP 跟踪等，帮助我们监控和管理Spring Boot 应用。这个模块是一个采集应用内部信息暴露给外部的模块，上述的功能都可以通过HTTP 和 JMX 访问。因为暴露内部信息的特性，Actuator 也可以和一些外部的应用监控系统整合（Prometheus, Graphite, DataDog, Influx, Wavefront, New Relic等）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员小凯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值