Eine Anleitung zum Spring Boot Admin

1. Übersicht

Spring Boot Admin ist eine Webanwendung, mit der Spring Boot-Anwendungen verwaltet und überwacht werden. Jede Anwendung wird als Client betrachtet und beim Administrationsserver registriert. Hinter den Kulissen wird die Magie von den Spring Boot Actuator-Endpunkten gegeben.

In diesem Artikel beschreiben wir die Schritte zum Konfigurieren eines Spring Boot Admin-Servers und wie eine Anwendung zum Client wird.

2. Admin Server Setup

Zunächst müssen wir eine einfache Spring Boot-Webanwendung erstellen und die folgende Maven-Abhängigkeit hinzufügen:

 de.codecentric spring-boot-admin-starter-server 2.2.2 

Danach ist der @ EnableAdminServer verfügbar, sodass wir ihn der Hauptklasse hinzufügen, wie im folgenden Beispiel gezeigt:

@EnableAdminServer @SpringBootApplication public class SpringBootAdminServerApplication { public static void main(String[] args) { SpringApplication.run(SpringBootAdminServerApplication.class, args); } }

An diesem Punkt können wir den Server starten und Clientanwendungen registrieren.

3. Einrichten eines Clients

Nachdem wir unseren Admin-Server eingerichtet haben, können wir jetzt unsere erste Spring Boot-Anwendung als Client registrieren. Wir müssen die folgende Maven-Abhängigkeit hinzufügen:

 de.codecentric spring-boot-admin-starter-client 2.2.2 

Als Nächstes müssen wir den Client so konfigurieren, dass er die Basis-URL des Administrationsservers kennt. Dazu fügen wir einfach die folgende Eigenschaft hinzu:

spring.boot.admin.client.url=//localhost:8080

Ab Spring Boot 2 werden andere Endpunkte als Health und Info standardmäßig nicht angezeigt.

Lassen Sie uns alle Endpunkte offenlegen:

management.endpoints.web.exposure.include=* management.endpoint.health.show-details=always

4. Sicherheitskonfiguration

Der Spring Boot Admin-Server hat Zugriff auf die vertraulichen Endpunkte der Anwendung. Es wird daher empfohlen, sowohl der Administrator- als auch der Clientanwendung eine Sicherheitskonfiguration hinzuzufügen.

Zunächst konzentrieren wir uns auf die Konfiguration der Sicherheit des Administrationsservers. Wir müssen die folgenden Maven-Abhängigkeiten hinzufügen:

 de.codecentric spring-boot-admin-server-ui-login 1.5.7   org.springframework.boot spring-boot-starter-security 2.1.8.RELEASE 

Dadurch wird die Sicherheit aktiviert und der Administratoranwendung eine Anmeldeschnittstelle hinzugefügt.

Als Nächstes fügen wir eine Sicherheitskonfigurationsklasse hinzu, wie Sie unten sehen können:

@Configuration public class WebSecurityConfig extends WebSecurityConfigurerAdapter { private final AdminServerProperties adminServer; public WebSecurityConfig(AdminServerProperties adminServer) { this.adminServer = adminServer; } @Override protected void configure(HttpSecurity http) throws Exception { SavedRequestAwareAuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler(); successHandler.setTargetUrlParameter("redirectTo"); successHandler.setDefaultTargetUrl(this.adminServer.getContextPath() + "/"); http .authorizeRequests() .antMatchers(this.adminServer.getContextPath() + "/assets/**").permitAll() .antMatchers(this.adminServer.getContextPath() + "/login").permitAll() .anyRequest().authenticated() .and() .formLogin() .loginPage(this.adminServer.getContextPath() + "/login") .successHandler(successHandler) .and() .logout() .logoutUrl(this.adminServer.getContextPath() + "/logout") .and() .httpBasic() .and() .csrf() .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()) .ignoringRequestMatchers( new AntPathRequestMatcher(this.adminServer.getContextPath() + "/instances", HttpMethod.POST.toString()), new AntPathRequestMatcher(this.adminServer.getContextPath() + "/instances/*", HttpMethod.DELETE.toString()), new AntPathRequestMatcher(this.adminServer.getContextPath() + "/actuator/**")) .and() .rememberMe() .key(UUID.randomUUID().toString()) .tokenValiditySeconds(1209600); } }

Es gibt eine einfache Sicherheitskonfiguration, aber nach dem Hinzufügen werden wir feststellen, dass sich der Client nicht mehr beim Server registrieren kann.

Um den Client auf dem neu gesicherten Server zu registrieren, müssen wir der Eigenschaftendatei des Clients weitere Konfigurationen hinzufügen:

spring.boot.admin.client.username=admin spring.boot.admin.client.password=admin

Wir sind an dem Punkt angelangt, an dem wir unseren Admin-Server gesichert haben. In einem Produktionssystem sind natürlich die Anwendungen, die wir überwachen möchten, gesichert. Daher erhöhen wir auch die Sicherheit des Clients - und stellen in der Benutzeroberfläche des Administrationsservers fest, dass die Clientinformationen nicht mehr verfügbar sind.

Wir müssen einige Metadaten hinzufügen, die wir an den Admin-Server senden. Diese Informationen werden vom Server verwendet, um eine Verbindung zu den Endpunkten des Clients herzustellen:

spring.security.user.name=client spring.security.user.password=client spring.boot.admin.client.instance.metadata.user.name=${spring.security.user.name} spring.boot.admin.client.instance.metadata.user.password=${spring.security.user.password}

Das Senden von Anmeldeinformationen über HTTP ist natürlich nicht sicher - daher muss die Kommunikation über HTTPS erfolgen.

5. Überwachungs- und Verwaltungsfunktionen

Spring Boot Admin kann so konfiguriert werden, dass nur die Informationen angezeigt werden, die wir für nützlich halten. Wir müssen nur die Standardkonfiguration ändern und unsere eigenen benötigten Metriken hinzufügen:

spring.boot.admin.routes.endpoints=env, metrics, trace, jolokia, info, configprops

Wenn wir weiter gehen, werden wir sehen, dass es einige andere Funktionen gibt, die untersucht werden können. Wir sprechen über das JMX-Bean-Management mit Jolokia und das Loglevel- Management.

Spring Boot Admin unterstützt auch die Clusterreplikation mit Hazelcast. Wir müssen nur die folgende Maven-Abhängigkeit hinzufügen und die Autokonfiguration den Rest erledigen lassen:

 com.hazelcast hazelcast 3.12.2 

Wenn wir eine dauerhafte Instanz von Hazelcast wünschen, verwenden wir eine benutzerdefinierte Konfiguration:

@Configuration public class HazelcastConfig { @Bean public Config hazelcast() { MapConfig eventStoreMap = new MapConfig("spring-boot-admin-event-store") .setInMemoryFormat(InMemoryFormat.OBJECT) .setBackupCount(1) .setEvictionPolicy(EvictionPolicy.NONE) .setMergePolicyConfig(new MergePolicyConfig(PutIfAbsentMapMergePolicy.class.getName(), 100)); MapConfig sentNotificationsMap = new MapConfig("spring-boot-admin-application-store") .setInMemoryFormat(InMemoryFormat.OBJECT) .setBackupCount(1) .setEvictionPolicy(EvictionPolicy.LRU) .setMergePolicyConfig(new MergePolicyConfig(PutIfAbsentMapMergePolicy.class.getName(), 100)); Config config = new Config(); config.addMapConfig(eventStoreMap); config.addMapConfig(sentNotificationsMap); config.setProperty("hazelcast.jmx", "true"); config.getNetworkConfig() .getJoin() .getMulticastConfig() .setEnabled(false); TcpIpConfig tcpIpConfig = config.getNetworkConfig() .getJoin() .getTcpIpConfig(); tcpIpConfig.setEnabled(true); tcpIpConfig.setMembers(Collections.singletonList("127.0.0.1")); return config; } }

6. Benachrichtigungen

Lassen Sie uns als Nächstes die Möglichkeit diskutieren, Benachrichtigungen vom Administrationsserver zu erhalten, wenn mit unserem registrierten Client etwas passiert. Die folgenden Benachrichtigungen stehen für die Konfiguration zur Verfügung:

  • Email
  • PagerDuty
  • OpsGenie
  • Hipchat
  • Locker
  • Lass uns schreiben

6.1. E-Mail Benachrichtigungen

Wir konzentrieren uns zunächst auf die Konfiguration von E-Mail-Benachrichtigungen für unseren Administrationsserver. Dazu müssen wir die Mail-Starter-Abhängigkeit wie unten gezeigt hinzufügen:

 org.springframework.boot spring-boot-starter-mail 2.1.7.RELEASE 

Danach müssen wir einige Mail-Konfiguration hinzufügen:

spring.mail.host=smtp.example.com spring.mail.username=smtp_user spring.mail.password=smtp_password [email protected]

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= spring.boot.admin.notify.hipchat.room-id= spring.boot.admin.notify.hipchat.url=//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.

Oder wir möchten Benachrichtigungen an eine gefilterte Gruppe von Clients senden. Hierfür können wir einen Filter-Notifier verwenden:

@Configuration public class NotifierConfiguration { private final InstanceRepository repository; private final ObjectProvider
    
      otherNotifiers; public NotifierConfiguration(InstanceRepository repository, ObjectProvider
     
       otherNotifiers) { this.repository = repository; this.otherNotifiers = otherNotifiers; } @Bean public FilteringNotifier filteringNotifier() { CompositeNotifier delegate = new CompositeNotifier(this.otherNotifiers.getIfAvailable(Collections::emptyList)); return new FilteringNotifier(delegate, this.repository); } @Bean public LoggingNotifier notifier() { return new LoggingNotifier(repository); } @Primary @Bean(initMethod = "start", destroyMethod = "stop") public RemindingNotifier remindingNotifier() { RemindingNotifier remindingNotifier = new RemindingNotifier(filteringNotifier(), repository); remindingNotifier.setReminderPeriod(Duration.ofMinutes(5)); remindingNotifier.setCheckReminderInverval(Duration.ofSeconds(60)); return remindingNotifier; } }
     
    

7. Fazit

Dieses Intro-Tutorial behandelt die einfachen Schritte, die Sie ausführen müssen, um seine Spring Boot-Anwendungen mit Spring Boot Admin zu überwachen und zu verwalten.

Die automatische Konfiguration ermöglicht es uns, nur einige kleinere Konfigurationen hinzuzufügen und am Ende einen voll funktionsfähigen Administrationsserver zu haben.

Und wie immer finden Sie den Beispielcode dieses Handbuchs auf Github.