Introdução ao Spring Boot Actuator

Saudação, Khabrovites! Em uma semana, as aulas começarão no novo grupo do curso "Developer on the Spring Framework" . Nesse sentido, estamos compartilhando com você material útil que informa o que é o atuador de mola e como ele pode ser útil.

1. O que é o atuador de mola?
2. Como adicionar o Spring Actuator ao projeto Maven ou Gradle?
3. Crie um projeto Spring Boot com uma dependência do Spring Actuator.
4. Monitoramento de aplicativos com pontos finais do atuador de mola.

O que é o atuador de mola?

Depois de desenvolver o aplicativo e implantá-lo na produção, é muito importante monitorar seu desempenho. Isso é especialmente verdadeiro para aplicativos de missão crítica, como sistemas bancários, nos quais a falha do aplicativo afeta diretamente os negócios.

Tradicionalmente, antes do Spring Actuator, precisávamos escrever código para testar a integridade do aplicativo, mas com o Spring Actuator não precisávamos escrever código. O Spring Actuator fornece vários pontos de extremidade que podem ser úteis para monitorar o aplicativo.

Como adicionar o Spring Actuator ao projeto Maven ou Gradle?

Maven

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

Gradle

 dependencies { compile("org.springframework.boot:spring-boot-starter-actuator") } 

Criando um projeto de inicialização com o Spring Actuator

Vamos em frente e crie um projeto Spring Boot com as dependências Spring Actuator, Web e DevTools usando o Spring Initializer .

Observe que no momento da redação deste artigo, a versão do Spring Boot era 2.1.0.



Importe o projeto para o Eclipse ou qualquer outro IDE e execute SpringActuatorApplication.java .

No console, você verá o seguinte:



Você pode ver que o Tomcat incorporado está sendo executado na porta 8080 e o SpringActuatorApplication sendo executado no Tomcat. Você também pode ver que os pontos de extremidade do atuador estão disponíveis em /actuator.

 018-11-09 20:00:29.346 INFO 8338 --- [ restartedMain] osbwembedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path '' 2018-11-09 20:00:29.354 INFO 8338 --- [ restartedMain] nbjsSpringActuatorApplication : Started SpringActuatorApplication in 9.273 seconds (JVM running for 11.823) 2018-11-09 20:00:29.190 INFO 8338 --- [ restartedMain] osbaeweb.EndpointLinksResolver : Exposing 2 endpoint(s) beneath base path '/actuator'. 

Monitoramento de aplicativos com terminais de atuador de mola

Como dissemos acima, o Spring Actuator fornece vários pontos de extremidade que podemos usar para monitorar a integridade do aplicativo.


Habilitando pontos de extremidade

Por padrão, todos os terminais estão ativados, exceto o shutdown . Para ativar o terminal, use a seguinte propriedade no arquivo application.properties

 management.endpoint.<code><</code>id<code>></code>.enabled 

Nota do tradutor: por padrão, o acesso a todos os terminais é apenas através do JMX, não há acesso via HTTP a todos os terminais (veja abaixo).

Um exemplo:

Para ativar o terminal de shutdown , precisamos fazer a seguinte entrada no arquivo application.properties :

 management.endpoint.shutdown.enabled=true 

Podemos desativar todos os pontos de extremidade e incluir apenas aqueles que precisamos. Na próxima configuração, todos os pontos de extremidade, exceto info , serão desativados.

 management.endpoints.enabled-by-default=false management.endpoint.info.enabled=true 

Acesso aos terminais via HTTP

Vamos para a URL do host local : 8080 / atuador e ver os pontos de extremidade disponíveis.

Nota: Eu uso o Postman para testar, pois mostra o JSON em um formato bem estruturado. Você pode usar qualquer outra ferramenta ou apenas um navegador.



Como você já percebeu, apenas os pontos finais de health e info são mostrados aqui. Porque esses são os únicos pontos de extremidade acessíveis por padrão via http. O acesso via http a outros pontos de extremidade é fechado por padrão por motivos de segurança, pois eles podem conter informações confidenciais e, portanto, podem ser comprometidos.

Acesso a terminais específicos

Se queremos fornecer acesso via web (http) a outros terminais, precisamos fazer as seguintes entradas no arquivo application.properties .

 management.endpoints.web.exposure.include=<    ><a href="http://localhost:8080/actuator"></a> 

Um exemplo :

 management.endpoints.web.exposure.include= health,info,env 

Agora, depois de adicionar a entrada acima a application.properties , vamos novamente para http: // localhost: 8080 / actuator

Como podemos ver na captura de tela abaixo, o endpoint env também está incluído.



Acesso a todos os terminais

Se quisermos incluir todos os pontos de extremidade, podemos usar o sinal * como mostrado abaixo.

 management.endpoints.web.exposure.include=* 

Acesso a todos, exceto alguns pontos finais

As duas entradas abaixo ativam todos os pontos de extremidade, mas desativam o ponto de extremidade env.

 management.endpoints.web.exposure.include=* management.endpoints.web.exposure.exclude=env 

Desativando todos os terminais HTTP

Se você não deseja fornecer pontos de extremidade via HTTP, pode fazer isso configurando o seguinte no arquivo application.properties :

 management.server.port=-1 

ou mais:

 management.endpoints.web.exposure.exclude=* 

Configurar URLs para acesso aos terminais

Por padrão, todos os terminais estão acessíveis via URL /actuator nos endereços do formulário /actuator/{id} . No entanto, você pode alterar o caminho /actuator base usando a seguinte propriedade em application.properties .

 management.endpoints.web.base-path 

Por exemplo, se você deseja tornar o URL base como /monitor vez de /actuator faça o seguinte:

 management.endpoints.web.base-path=/monitor 

Nesse caso, todos os pontos de extremidade estarão disponíveis como /monitor/{id} vez de /actuator/{id}



Atuador de inicialização com mola de terminais

Vamos discutir alguns dos pontos de extremidade mais importantes.

/ saúde

O terminal de health fornece o status geral do aplicativo: se está em funcionamento ou não. Isso é muito importante para monitorar o status do aplicativo quando ele está em produção. Esse terminal pode ser integrado aos aplicativos de monitoramento e será muito útil para determinar a integridade dos aplicativos em tempo real.

A quantidade de informações fornecidas pelo terminal de health depende da propriedade management.endpoint.health.show-details no arquivo application.properties .

Se management.endpoint.health.show-details=never , nenhuma informação adicional será exibida. Nesse caso, você verá apenas o seguinte (esse é o comportamento padrão).



Se management.endpoint.health.show-details=always , informações adicionais serão mostradas a todos os usuários. Como podemos ver na resposta abaixo, temos informações sobre o espaço em disco (diskSpace). Se o seu aplicativo estiver conectado a um banco de dados, você também verá informações sobre o status do banco de dados.



Se management.endpoint.health.show-details=when-authorized , informações adicionais serão mostradas apenas para usuários autorizados. A autorização pode ser configurada usando a propriedade management.endpoint.health.roles .

Indicadores predefinidos

O Spring Boot Actuator possui muitos "indicadores de integridade" (HeathIndicators) configurados automaticamente para testar a integridade de várias partes do aplicativo. Por exemplo, DiskspaceHealthIndicator fornece informações de espaço em disco. Se você estiver usando o MongoDB, o MongoHealthIndicator verificará o banco de dados do Mongo (se o servidor está executando ou não) e exibirá as informações correspondentes. Por padrão, o status final do aplicativo é determinado pelo HealthAggregator , que simplesmente classifica a lista de status fornecida por cada HealthIndicator . O primeiro status na lista classificada é usado como o status final do aplicativo.

Desativando todos os indicadores pré-configurados

Os "indicadores de saúde" descritos acima são ativados por padrão, no entanto, você pode desativá-los usando a seguinte propriedade:

 management.health.defaults.enabled=false 

Desativando um Único Indicador

Como alternativa, você pode desativar um HealthIndicator separado, como mostrado abaixo, por exemplo, para desativar a verificação de espaço em disco:

 management.health.diskspace.enabled=false 

Nota: o identificador de qualquer HealthIndicator será o nome do bean sem o sufixo HealthIndicator .

Por exemplo :

 DiskSpaceHealthIndicator diskspace MongoHealthIndicator mongo CassandraHealthIndicator cassandra DataSourceHealthIndicator datasource 

e assim por diante ...

Escrevendo seus indicadores (HealthIndicator)

Juntamente com o HealthIndicator fornecido pelo Spring Boot Actuator, podemos criar indicadores de status personalizados. Para fazer isso, você precisa criar uma classe que implemente a interface HealthIndicator , implemente seu método health() e retorne Health como resposta com as informações relevantes, conforme mostrado abaixo:

 import org.springframework.boot.actuate.health.Health; import org.springframework.boot.actuate.health.HealthIndicator; import org.springframework.stereotype.Component; @Component public class CustomHealthIndicator implements HealthIndicator { @Override public Health health() { int errorCode = 0; // In the above line,I am simple assigning zero,but you can call Health check related code like below commented line and that method can return the appropriate code. // int errorCode = performHealthCheck(); if (errorCode != 0) { return Health.down().withDetail("Error Code", errorCode).build(); } return Health.up().build(); } } 

Vamos para o terminal de integridade novamente e ver se nosso indicador está refletido ou não.



Nós vemos o nosso indicador.

Status de componente único

Você também pode verificar o status de um componente individual. No exemplo acima, vimos o indicador que escrevemos e diskSpace.

Se queremos ver apenas o status do disco, podemos usar o seguinte URL:

http: // localhost: 8080 / atuador / saúde / diskSpace



/ info

O terminal de info fornece informações gerais sobre o aplicativo que ele recebe de arquivos como build-info.properties ou git.properties ou das propriedades especificadas em application.properties .

Como não existe esse arquivo em nosso projeto, a resposta estará vazia, como mostrado abaixo:



O Spring Boot Actuator exibe informações de compilação se META-INF/build-info.properties . Este arquivo de informações do projeto é criado no momento da build-info destino de build-info da build-info . Aqui você também pode adicionar um número arbitrário de propriedades adicionais.

Vamos adicionar um destino de build-info para o spring-boot-maven-plugin no pom.xm l.

 <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>2.1.0.RELEASE</version> <executions> <execution> <goals> <goal>build-info</goal> </goals> <configuration> <additionalProperties> <encoding.source>UTF-8</encoding.source> <encoding.reporting>UTF-8</encoding.reporting> <java.source>${maven.compiler.source}</java.source> <java.target>${maven.compiler.target}</java.target> </additionalProperties> </configuration> </execution> </executions> </plugin> 

Agora, vamos olhar novamente o ponto de info e ver as informações da montagem, como mostrado abaixo:



Além disso, podemos adicionar informações de aplicativos com a tecla info a application.properties , como mostrado abaixo, e elas serão exibidas no nó de extremidade /info .

 info.application.name=spring-actuator info.application.description=spring boot actuator application info.application.version=0.0.1-SNAPSHOT 

/ feijão

O terminal de beans mostra todos os beans definidos no contêiner Spring com as seguintes informações sobre cada bean:

 aliases :    scope :   type :    resource :  (),     dependencies :    

Por exemplo, criei um RestController chamado TestController e injetei um componente chamado TestService

 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class TestController { @Autowired private TestService testService; @GetMapping("/messages") public String getMessage() { return "Hello"; } } import org.springframework.context.annotation.Configuration; @Configuration public class TestService { } 

Você pode ver como isso é mostrado para o testController na captura de tela abaixo.



/ configprops
O configProps mostra todos os @ConfigurationProperties anotados por @ConfigurationProperties .



Na captura de tela acima, vemos dois beans que são definidos no próprio Spring Framework e são anotados com @ConfigurationProperties e, portanto, são exibidos neste terminal.

A captura de tela abaixo mostra o código-fonte HttpTraceProperties anotado por @ConfigurationProperties .



/ env

O terminal end fornece todas as informações ambientais na seguinte ordem:




/ heapdump

O nó de extremidade heapdump despeja a pilha do aplicativo. Esse ponto de extremidade retorna dados binários no formato HPROF. Como muitos dados geralmente são retornados, você deve salvá-los e analisá-los.

/ loggers

O loggers criadores de logs fornece informações aos criadores de logs de aplicativos sobre o nível de log configurado (configureLevel) e o nível efetivo (effectiveLevel). Se o nível configurado não for especificado para o criador de logs e seu pai (nulo), o nível do criador de logs raiz será um nível efetivo.

A propriedade level indica quais níveis de log são suportados pela estrutura de log.



Para obter informações sobre um criador de logs específico, passe o nome (id) do criador de logs na URL após o /loggers , conforme mostrado abaixo:

http: // localhost: 8080 / actuator / loggers / nl.blogpsot.javasolutionsguide.springactuator.SpringActuatorApplication



/ métricas

O terminal de metrics mostra todas as métricas que você pode rastrear para seu aplicativo.



Verificando métricas individuais

Você pode assistir a uma única métrica passando-a no URL após /metrics , conforme mostrado abaixo:

http: // localhost: 8080 / atuador / métricas / jvm.memory.used



Referências

docs.spring.io/spring-boot/docs/current/reference/html/production-ready-endpoints.html
docs.spring.io/spring-boot/docs/current/actuator-api/html

De acordo com a tradição estabelecida, aguardamos seus comentários e convidamos todos para o dia aberto , que será realizado em 23 de maio.