Spring Boot Actuator é um subprojeto do Spring Boot que fornece recursos prontos para produção para ajudá-lo a monitorar e gerenciar seu aplicativo. Ele oferece um conjunto de endpoints integrados que permitem obter insights sobre a integridade, as métricas e o ambiente do seu aplicativo, bem como controlá-lo dinamicamente.

O que é o atuador Spring Boot?

Spring Boot Actuator fornece vários endpoints prontos para uso que podem ser usados ​​para monitorar e interagir com seu aplicativo. Esses endpoints podem ser acessados ​​por HTTP, JMX ou usando Spring Boot Admin.

Principais recursos do atuador Spring Boot

1. Verificações de integridade: monitore a integridade do seu aplicativo e suas dependências.
2. Métricas: Colete várias métricas, como uso de memória, coleta de lixo, detalhes de solicitação da web, etc.
3. Informações do ambiente: acesse as propriedades do ambiente da aplicação.
4. Informações da aplicação: recupera informações sobre a compilação da aplicação, como versão e nome.
5. Níveis de log dinâmicos: altere os níveis de log sem reiniciar o aplicativo.
6. Rastreamento HTTP: rastreia solicitações HTTP.

Configurando o atuador Spring Boot

1. Adicionando Dependência do Atuador

Para usar o Actuator em seu aplicativo Spring Boot, você precisa adicionar a dependência do Actuator ao seu arquivo pom.xml:

org.springframework.bootspring-boot-starter-actuator

Se você estiver usando Gradle, adicione o seguinte ao seu arquivo build.gradle:

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

2. Habilitando endpoints do atuador

Por padrão, apenas alguns endpoints estão habilitados. Você pode ativar endpoints adicionais em seu arquivo application.yml:

management:
  endpoints:
    web:
      exposure:
        include: "*"  # This exposes all available endpoints
  endpoint:
    health:
      show-details: always  # Show detailed health information

Usando pontos finais do atuador

Depois que o Atuador estiver configurado, você poderá acessar os vários endpoints fornecidos por ele. Aqui estão alguns endpoints comumente usados:

1. Ponto final de saúde

O endpoint /actuator/health fornece informações sobre a integridade do seu aplicativo:

GET http://localhost:8080/actuator/health

Exemplo de resposta:

{
  "status": "UP",
  "components": {
    "db": {
      "status": "UP",
      "details": {
        "database": "H2",
        "result": 1
      }
    },
    "diskSpace": {
      "status": "UP",
      "details": {
        "total": 499963174912,
        "free": 16989374464,
        "threshold": 10485760,
        "exists": true
      }
    }
  }
}

2. Ponto final de métricas

O endpoint /actuator/metrics fornece diversas métricas relacionadas à sua aplicação:

GET http://localhost:8080/actuator/metrics

Exemplo de resposta:

{
  "names": [
    "jvm.memory.used",
    "jvm.gc.pause",
    "system.cpu.usage",
    "system.memory.usage",
    "http.server.requests"
  ]
}

Para obter detalhes de uma métrica específica:

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

Exemplo de resposta:

{
  "name": "jvm.memory.used",
  "description": "The amount of used memory",
  "baseUnit": "bytes",
  "measurements": [
    {
      "statistic": "VALUE",
      "value": 5.1234567E7
    }
  ],
  "availableTags": [
    {
      "tag": "area",
      "values": [
        "heap",
        "nonheap"
      ]
    },
    {
      "tag": "id",
      "values": [
        "PS Eden Space",
        "PS Survivor Space",
        "PS Old Gen",
        "Metaspace",
        "Compressed Class Space"
      ]
    }
  ]
}

3. Ponto final do ambiente

O endpoint /actuator/env fornece informações sobre as propriedades do ambiente:

GET http://localhost:8080/actuator/env

Exemplo de resposta:

{
  "activeProfiles": [],
  "propertySources": [
    {
      "name": "systemProperties",
      "properties": {
        "java.runtime.name": {
          "value": "Java(TM) SE Runtime Environment"
        },
        "java.vm.version": {
          "value": "25.181-b13"
        }
      }
    },
    {
      "name": "systemEnvironment",
      "properties": {
        "PATH": {
          "value": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        },
        "HOME": {
          "value": "/root"
        }
      }
    }
  ]
}

4. Ponto final de informações

O endpoint /actuator/info fornece informações sobre o aplicativo:

GET http://localhost:8080/actuator/info

Para personalizar as informações, adicione propriedades em seu application.yml:

info:
  app:
    name: My Spring Boot Application
    description: This is a sample Spring Boot application
    version: 1.0.0

Protegendo endpoints do atuador

Por padrão, todos os endpoints do Atuador são acessíveis sem autenticação. Para proteger esses endpoints, você pode usar Spring Security. Adicione a dependência do Spring Security ao seu pom.xml:

org.springframework.bootspring-boot-starter-security

Atualize seu application.yml para restringir o acesso:

management:
  endpoints:
    web:
      exposure:
        include: "*"  # Expose all endpoints
  endpoint:
    health:
      show-details: always  # Show detailed health information

spring:
  security:
    user:
      name: admin  # Default username
      password: admin  # Default password

# Restrict actuator endpoints to authenticated users
management:
  endpoints:
    web:
      exposure:
        include: "*"
  endpoint:
    health:
      show-details: always
  security:
    enabled: true
    roles: ACTUATOR

Crie uma classe de configuração de segurança para configurar a segurança HTTP:

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/actuator/**").hasRole("ACTUATOR")
                .anyRequest().authenticated()
            .and()
            .httpBasic();
    }
}

Com esta configuração, apenas usuários autenticados com a função ACTUATOR podem acessar os endpoints do Actuator.

Personalização de endpoints do atuador

Você pode criar endpoints do Atuador personalizados para expor informações adicionais ou funcionalidades específicas para sua aplicação. Aqui está um exemplo de criação de um endpoint personalizado:

import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
import org.springframework.stereotype.Component;

@Endpoint(id = "custom")
@Component
public class CustomEndpoint {

    @ReadOperation
    public String customEndpoint() {
        return "Custom Actuator Endpoint";
    }
}

Acesse seu endpoint personalizado em:

GET http://localhost:8080/actuator/custom

Conclusão

Spring Boot Actuator fornece um conjunto robusto de ferramentas para ajudá-lo a monitorar e gerenciar seu aplicativo. Ao aproveitar seus endpoints integrados e a capacidade de criar endpoints personalizados, você pode obter insights valiosos sobre o desempenho e a integridade do seu aplicativo. Proteja esses endpoints com Spring Security para garantir que apenas usuários autorizados tenham acesso e você terá um aplicativo pronto para produção que é fácil de gerenciar e monitorar.

Actuator é uma parte essencial de qualquer aplicativo Spring Boot, permitindo que você mantenha o controle do ambiente de tempo de execução do seu aplicativo e responda rapidamente aos problemas que surgirem. Comece a usar o Spring Boot Actuator hoje para aprimorar a observabilidade e os recursos operacionais do seu aplicativo.