Ein Leitfaden für Spring Boot Admin

1. Überblick

Spring Boot Admin ist eine Webanwendung, die zum Verwalten und Überwachen von Spring Boot-Anwendungen verwendet wird. Jede Anwendung wird als Client betrachtet und beim Admin-Server registriert. Hinter den Kulissen zaubern die Endpunkte des Spring Boot Actuators.

In diesem Artikel werden die Schritte zum Konfigurieren eines Spring Boot Admin-Servers und zum Werden einer Anwendung zum Client beschrieben.

2. Admin Server Setup

Zunächst müssen wir eine einfache Spring Boot-Webanwendung erstellen und die folgendenMaven dependencyhinzufügen:


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

Danach sind die@EnableAdminServer verfügbar, sodass wir sie 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 Administrationsserver eingerichtet haben, können wir jetzt unsere erste Spring Boot-Anwendung als Client registrieren. Wir müssen die folgendenMaven dependency hinzufügen:


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

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=http://localhost:8080

Ab Spring Boot 2 werden andere Endpunkte alshealth undinfo standardmäßig nicht verfügbar gemacht.

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, alsoit’s advised that we add some security configuration to both admin and client application.

Zunächst konzentrieren wir uns auf die Konfiguration der Sicherheit des Administrationsservers. Wir müssen die folgendenMaven dependencies hinzufügen:


    de.codecentric
    spring-boot-admin-server-ui-login
    1.5.7


    org.springframework.boot
    spring-boot-starter-security
    2.1.8.RELEASE

Dies aktiviert die Sicherheit und fügt der Admin-Anwendung eine Anmeldeschnittstelle hinzu.

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 Einstellungen hinzufügen:

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

Wir sind an dem Punkt angelangt, an dem wir unseren Administrationsserver 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 Administrationsserver 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 erforderlichen Metriken hinzufügen:

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

Im weiteren Verlauf werden wir feststellen, dass einige andere Funktionen untersucht werden können. Wir sprechen überJMX bean management mitJolokia und auch überLoglevel Management.

Spring Boot Admin unterstützt auch die Clusterreplikation mit Hazelcast. Wir müssen nur die folgendenMaven dependency 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 diemail starter dependency wie unten gezeigt hinzufügen:


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

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

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

Wenn nun unser registrierter Kunde seinen Status von UP auf OFFLINE oder auf andere Weise ändert, wird eine E-Mail an die oben konfigurierte Adresse gesendet. Bei den anderen Meldern ist die Konfiguration ähnlich.

6.2. Hipchat-Benachrichtigungen

Wie wir sehen werden, ist die Integration mit Hipchat recht einfach. Es müssen nur wenige obligatorische Eigenschaften festgelegt werden:

spring.boot.admin.notify.hipchat.auth-token=
spring.boot.admin.notify.hipchat.room-id=
spring.boot.admin.notify.hipchat.url=https://yourcompany.hipchat.com/v2/

Nachdem diese definiert wurden, werden wir im Hipchat-Raum feststellen, dass wir Benachrichtigungen erhalten, wenn sich der Status des Kunden ändert.

6.3. Benutzerdefinierte Benachrichtigungskonfiguration

Wir können ein benutzerdefiniertes Benachrichtigungssystem konfigurieren, das über einige leistungsstarke Tools verfügt. Wir könnenreminding notifier verwenden, um eine geplante Benachrichtigung zu senden, bis sich der Status des Clients ändert.

Oder wir möchten Benachrichtigungen an eine gefilterte Gruppe von Clients senden. Hierfür können wirfiltering 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

In diesem Tutorial werden die einfachen Schritte beschrieben, die zum Überwachen und Verwalten seiner Spring Boot-Anwendungen mit Spring Boot Admin ausgeführt werden müssen.

Die Autokonfiguration erlaubt es uns, nur einige kleinere Konfigurationen hinzuzufügen und am Ende einen voll funktionsfähigen Admin-Server zu haben.

Und wie immer finden Sie den Beispielcode dieses Handbuchs inover on Github.

TOC

Ein Leitfaden für Spring Boot Admin