Spring Boot Actuator – monitoring w praktyce

Wyobrażasz sobie pilotowanie samolotu bez instrumentów pokładowych? Albo prowadzenie samochodu bez liczników na desce rozdzielczej? Tak samo absurdalne jest uruchamianie aplikacji Spring Boot w produkcji bez odpowiedniego monitorowania. Spring Boot Actuator to Twój „kokpit” – daje Ci pełny wgląd w to, co dzieje się z Twoją aplikacją.

Dlaczego monitoring jest krytyczny

W środowisku produkcyjnym nie wystarczy „modlić się, żeby działało”. Potrzebujesz precyzyjnych danych o wydajności, błędach i zasobach. Spring Boot Actuator eliminuje konieczność budowania własnych rozwiązań monitoringowych od zera. To jak mieć doświadczonego mechanika, który non-stop sprawdza silnik Twojego samochodu.

Konfiguracja Spring Boot Actuator

Dodanie Actuator do projektu to dosłownie jedna linijka w pliku konfiguracyjnym. W Maven dodaj zależność:

    org.springframework.boot
    spring-boot-starter-actuator

Dla Gradle:

implementation 'org.springframework.boot:spring-boot-starter-actuator'

Po dodaniu zależności i ponownym uruchomieniu aplikacji, domyślnie dostępne są podstawowe endpointy. Sprawdź w przeglądarce:

curl http://localhost:8080/actuator

Konfiguracja ekspozycji endpointów

Aby odblokować pełną moc Actuator, skonfiguruj które endpointy mają być dostępne przez HTTP w application.properties:

# Eksponuj wszystkie endpointy (TYLKO DEV!)
management.endpoints.web.exposure.include=*

# Lub wybierz konkretne endpointy
management.endpoints.web.exposure.include=health,metrics,info,env

# Zmień ścieżkę bazową
management.endpoints.web.base-path=/admin

# Zmień port dla endpointów
management.server.port=9090

Najważniejsze endpointy w praktyce

/health – Stan aplikacji

Endpoint /health to Twój „puls” aplikacji. Domyślnie zwraca prosty status UP/DOWN:

{
  "status": "UP"
}

Ale możesz uzyskać znacznie więcej szczegółów:

# Pokaż szczegóły health checków
management.endpoint.health.show-details=always

# Lub tylko dla uprzywilejowanych użytkowników
management.endpoint.health.show-details=when-authorized

Teraz otrzymasz pełny raport:

{
  "status": "UP",
  "components": {
    "db": {
      "status": "UP",
      "details": {
        "database": "MySQL",
        "validationQuery": "isValid()"
      }
    },
    "diskSpace": {
      "status": "UP",
      "details": {
        "total": 499963174912,
        "free": 91275618304,
        "threshold": 10485760
      }
    }
  }
}

/metrics – Metryki wydajności

Endpoint /metrics to skarb informacji o wydajności. Lista dostępnych metryk:

curl http://localhost:8080/actuator/metrics

Szczegóły konkretnej metryki:

curl http://localhost:8080/actuator/metrics/jvm.memory.used

/info – Informacje o aplikacji

Endpoint /info pozwala udostępnić informacje o wersji, środowisku, zespole. Konfiguracja w application.properties:

info.app.name=My Spring Boot App
info.app.version=@project.version@
info.app.description=Production monitoring demo
info.team.email=devops@company.com

Tworzenie własnych health checków

Czasami standardowe health checki nie wystarczą. Możesz stworzyć własny:

@Component
public class ExternalApiHealthIndicator implements HealthIndicator {
    
    private final RestTemplate restTemplate;
    
    public ExternalApiHealthIndicator(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    @Override
    public Health health() {
        try {
            // Sprawdź zewnętrzne API
            ResponseEntity response = restTemplate
                .getForEntity("https://api.external-service.com/health", String.class);
            
            if (response.getStatusCode().is2xxSuccessful()) {
                return Health.up()
                    .withDetail("service", "external-api")
                    .withDetail("responseTime", calculateResponseTime())
                    .build();
            } else {
                return Health.down()
                    .withDetail("error", "HTTP " + response.getStatusCode())
                    .build();
            }
        } catch (Exception e) {
            return Health.down()
                .withDetail("error", e.getMessage())
                .build();
        }
    }
    
    private long calculateResponseTime() {
        // Implementacja pomiaru czasu odpowiedzi
        return System.currentTimeMillis();
    }
}

Własne metryki z Micrometer

Spring Boot 2.0 używa Micrometer jako fasady dla różnych systemów metryk. Dodanie własnej metryki:

@Service
public class OrderService {
    
    private final MeterRegistry meterRegistry;
    private final Counter orderCounter;
    private final Timer orderProcessingTimer;
    
    public OrderService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.orderCounter = Counter.builder("orders.created")
            .description("Number of orders created")
            .register(meterRegistry);
        this.orderProcessingTimer = Timer.builder("orders.processing.time")
            .description("Order processing time")
            .register(meterRegistry);
    }
    
    public Order createOrder(OrderRequest request) {
        return orderProcessingTimer.recordCallable(() -> {
            Order order = processOrder(request);
            orderCounter.increment();
            
            // Metryka z tagami
            meterRegistry.counter("orders.by.status", "status", order.getStatus())
                .increment();
                
            return order;
        });
    }
    
    private Order processOrder(OrderRequest request) {
        // Logika tworzenia zamówienia
        return new Order();
    }
}

Zabezpieczanie endpointów Actuator

W produkcji endpointy Actuator mogą ujawnić wrażliwe informacje. Podstawowe zabezpieczenie z Spring Security:

@Configuration
@EnableWebSecurity
public class ActuatorSecurityConfig {
    
    @Bean
    public SecurityFilterChain actuatorFilterChain(HttpSecurity http) throws Exception {
        return http
            .requestMatcher(EndpointRequest.toAnyEndpoint())
            .authorizeHttpRequests(authorize -> 
                authorize
                    .requestMatchers(EndpointRequest.to(HealthEndpoint.class))
                        .permitAll()
                    .requestMatchers(EndpointRequest.toAnyEndpoint())
                        .hasRole("ACTUATOR")
            )
            .httpBasic(Customizer.withDefaults())
            .build();
    }
}

Konfiguracja użytkowników i ról:

# Podstawowa autentykacja dla Actuator
spring.security.user.name=admin
spring.security.user.password=secret123
spring.security.user.roles=ACTUATOR

Integracja z systemami monitorowania

Actuator świetnie współpracuje z popularnymi systemami monitorowania. Przykład konfiguracji dla Prometheus:

    io.micrometer
    micrometer-registry-prometheus

# Konfiguracja Prometheus
management.endpoints.web.exposure.include=health,metrics,prometheus
management.metrics.export.prometheus.enabled=true

Teraz endpoint /actuator/prometheus zwraca metryki w formacie Prometheus.

Monitoring w praktyce – case study

W jednym z projektów e-commerce zauważyliśmy spowalnianie aplikacji w godzinach szczytu. Dzięki Actuator szybko zidentyfikowaliśmy problem:

Rozwiązanie było proste – zwiększenie rozmiaru puli połączeń i dodanie connection pooling dla cache:

# Przed
spring.datasource.hikari.maximum-pool-size=10

# Po
spring.datasource.hikari.maximum-pool-size=25
spring.datasource.hikari.minimum-idle=5

Przydatne zasoby

• Spring Boot Actuator Documentation
• Micrometer Metrics Documentation
• Prometheus Exporters Guide
• Grafana Prometheus Integration
• Kubernetes Health Checks

Jak radzi sobie monitoring w Twoich aplikacjach Spring Boot? Używasz Actuator czy wolisz własne rozwiązania? Podziel się doświadczeniami w komentarzach!