1. Overview
Spring Boot Admin is a web application, used for managing and monitoring Spring Boot applications. Each application is considered as a client and registers to the admin server. Behind the scenes, the magic is given by the Spring Boot Actuator endpoints.
In this article, we’re going to describe steps for configuring a Spring Boot Admin server and how an application becomes a client.
2. Admin Server Setup
First of all, we need to create a simple Spring Boot web application and add the following Maven dependencies:
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-server</artifactId>
<version>1.5.4</version>
</dependency>
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-server-ui</artifactId>
<version>1.5.4</version>
</dependency>
After this, the @EnableAdminServer will be available, so we’ll be adding it to the main class, as shown in the example below:
@EnableAdminServer
@SpringBootApplication
public class SpringBootAdminServerApplication {
public static void main(String[] args) {
SpringApplication.run(SpringBootAdminServerApplication.class, args);
}
}
At this point, the server is ready to be started and can register client applications.
3. Setting Up a Client
Now, after we’ve set up our admin server, we can register our first Spring Boot application as client. We must add the following Maven dependency:
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-client</artifactId>
<version>1.5.4</version>
</dependency>
The only thing left is to configure the client to know about the admin server’s base URL. For this to happen, we just add the following properties:
spring.boot.admin.url=http://localhost:8080 management.security.enabled=false
4. Security Configuration
The Spring Boot Admin server has access to application’s sensitive endpoints, so it’s advised that we add some security configuration to both admin and client application.
At first, we’ll focus on configuring the admin server’s security. We must add the following Maven dependencies:
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-server-ui-login</artifactId>
<version>1.5.4</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
This will enable security and add a login interface to the admin application.
After, we’ll add a security configuration class as you can see below:
@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.formLogin()
.loginPage("/login.html")
.loginProcessingUrl("/login")
.permitAll();
http
.logout().logoutUrl("/logout");
http
.csrf().disable();
http
.authorizeRequests()
.antMatchers("/login.html", "/**/*.css", "/img/**", "/third-party/**")
.permitAll();
http
.authorizeRequests()
.antMatchers("/**")
.authenticated();
http.httpBasic();
}
}
There’s a simple security configuration, but after adding it, we’ll notice that the client cannot register to the server anymore.
In order to register the client to the newly secured server, we must add some more configuration into the property file of the client:
spring.boot.admin.username=admin spring.boot.admin.password=admin
We’re at the point, where our admin server is secured, but the client is not. In a production system, naturally, the applications we’re trying to monitor will be secured.
So, we’ll add security to the client as well – and we’ll notice in the UI interface of the admin server that the client information is not available anymore.
We have to add some metadata that we’ll be sent to the admin server. This information is used by the server to connect to client’s endpoints:
management.security.enabled=true
security.user.name=client
security.user.password=client
spring.boot.admin.client.metadata.user.name=${security.user.name}
spring.boot.admin.client.metadata.user.password=${security.user.password}
Sending credentials via HTTP is, of course, not safe – so the communication needs to go over HTTPS.
5. Monitoring and Management Features
Spring Boot Admin can be configured to display only the information that we consider useful. We just have to alter the default configuration and add our own needed metrics:
spring.boot.admin.routes.endpoints=env, metrics, trace, jolokia, info, configprops
As we go further, we’ll see that there are some other features that can be explored. We’re talking about JMX bean management using Jolokia and also Loglevel management.
Spring Boot Admin also supports cluster replication using Hazelcast. We just have to add the following Maven dependency and let the autoconfiguration do the rest:
<dependency>
<groupId>com.hazelcast</groupId>
<artifactId>hazelcast</artifactId>
</dependency>
If we want a persistent instance of Hazelcast, we’re going to use a custom configuration:
@Configuration
public class HazelcastConfig {
@Bean
public Config hazelcast() {
return new Config()
.setProperty("hazelcast.jmx", "true")
.addMapConfig(new MapConfig("spring-boot-admin-application-store")
.setBackupCount(1)
.setEvictionPolicy(EvictionPolicy.NONE))
.addListConfig(new ListConfig("spring-boot-admin-event-store")
.setBackupCount(1)
.setMaxSize(1000));
}
}
6. Notifications
Next, let’s discuss the possibility to receive notifications from the admin server if something happens with our registered client. The following notifiers are available for configuration:
- PagerDuty
- OpsGenie
- Hipchat
- Slack
- Let’s Chat
6.1. Email Notifications
We’ll focus on configuring mail notifications for our admin server. For this to happen, we have to add the mail starter dependency as shown below:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
<version>1.5.4</version>
</dependency>
After this, we must add some mail configuration:
spring.mail.host=smtp.example.com spring.mail.username=smtp_user spring.mail.password=smtp_password spring.boot.admin.notify.mail.to=admin@example.com
Now, whenever our registered client changes his status from UP to OFFLINE or otherwise, an email is sent to the address configured above. For the other notifiers, the configuration is similar.
6.2. Hipchat Notifications
As we’ll see, the integration with Hipchat is quite straightforward; there are only a few mandatory properties to set:
spring.boot.admin.notify.hipchat.auth-token=<generated_token> spring.boot.admin.notify.hipchat.room-id=<room-id> spring.boot.admin.notify.hipchat.url=https://yourcompany.hipchat.com/v2/
Having these defined, we’ll notice in the Hipchat room that we receive notifications whenever the status of the client changes.
6.3. Customized Notifications Configuration
We can configure a custom notification system having at our disposal some powerful tools for this. We can use a reminding notifier to send a scheduled notification until the status of client changes.
Or maybe we want to send notifications to a filtered set of clients. For this, we can use a filtering notifier:
@Configuration
@EnableScheduling
public class NotifierConfiguration {
@Autowired private Notifier notifier;
@Bean
public FilteringNotifier filteringNotifier() {
return new FilteringNotifier(notifier);
}
@Bean
@Primary
public RemindingNotifier remindingNotifier() {
RemindingNotifier remindingNotifier
= new RemindingNotifier(filteringNotifier());
remindingNotifier.setReminderPeriod(TimeUnit.MINUTES.toMillis(5));
return remindingNotifier;
}
@Scheduled(fixedRate = 60_000L)
public void remind() {
remindingNotifier().sendReminders();
}
}
7. Conclusion
This intro tutorial covers the simple steps that one has to do, in order to monitor and manage his Spring Boot applications using Spring Boot Admin.
The autoconfiguration permits us to add only some minor configurations and at the end, to have a fully working admin server.
And, as always, the sample code of this guide can be found over on Github.