TOC

Guide de l’administrateur de démarrage printanier

Guide de l'administrateur de démarrage printanier

1. Vue d'ensemble

Spring Boot Admin est une application Web, utilisée pour gérer et surveiller les applications Spring Boot. Chaque application est considérée comme un client et s’enregistre auprès du serveur d’administration. En coulisse, la magie est donnée par les points d'extrémité Spring Boot Actuator.

Dans cet article, nous allons décrire les étapes de configuration d'un serveur d'administration Spring Boot et comment une application devient un client.

2. Configuration du serveur d'administration

Tout d'abord, nous devons créer une application Web Spring Boot simple et ajouter lesMaven dependency suivants: 


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

Après cela, les@EnableAdminServer seront disponibles, nous allons donc les ajouter à la classe principale, comme indiqué dans l'exemple ci-dessous: 

@EnableAdminServer
@SpringBootApplication
public class SpringBootAdminServerApplication {

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

À ce stade, nous sommes prêts à démarrer le serveur et à enregistrer les applications clientes.

3. Configurer un client

Maintenant, après avoir configuré notre serveur d'administration, nous pouvons enregistrer notre première application Spring Boot en tant que client. Nous devons ajouter lesMaven dependency suivants: 


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

Ensuite, nous devons configurer le client pour qu'il connaisse l'URL de base du serveur d'administration. Pour cela, nous ajoutons simplement la propriété suivante: 

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

À partir de Spring Boot 2, les points de terminaison autres quehealth etinfo ne sont pas exposés par défaut.

Exposons tous les points de terminaison: 

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

4. Configuration de sécurité

Le serveur d'administration Spring Boot a accès aux points de terminaison sensibles de l'application, doncit’s advised that we add some security configuration to both admin and client application.

Dans un premier temps, nous nous concentrerons sur la configuration de la sécurité du serveur d'administration. Nous devons ajouter lesMaven dependencies suivants: 


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


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

Cela activera la sécurité et ajoutera une interface de connexion à l’application admin.

Ensuite, nous allons ajouter une classe de configuration de sécurité comme vous pouvez le voir ci-dessous: 

@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);
    }
}

Il existe une configuration de sécurité simple, mais après l'avoir ajoutée, nous remarquerons que le client ne peut plus s'enregistrer sur le serveur.

Pour enregistrer le client sur le serveur nouvellement sécurisé, nous devons ajouter une configuration supplémentaire dans le fichier de propriétés du client: 

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

Nous en sommes au point où nous avons sécurisé notre serveur d'administration. Dans un système de production, naturellement, les applications que nous essayons de surveiller seront sécurisées. Nous ajouterons donc également la sécurité au client - et nous remarquerons dans l'interface utilisateur du serveur d'administration que les informations sur le client ne sont plus disponibles.

Nous devons ajouter des métadonnées que nous enverrons au serveur d'administration. Ces informations sont utilisées par le serveur pour se connecter aux points de terminaison du client: 

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}

Bien entendu, l'envoi d'informations d'identification via HTTP n'est pas sûr. La communication doit donc passer par HTTPS.

5. Fonctions de surveillance et de gestion

Spring Boot Admin peut être configuré pour afficher uniquement les informations que nous considérons utiles. Nous devons simplement modifier la configuration par défaut et ajouter nos propres mesures nécessaires: 

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

Au fur et à mesure que nous irons plus loin, nous verrons qu'il existe d'autres fonctionnalités qui peuvent être explorées. Nous parlons deJMX bean management utilisantJolokia et aussi la gestion deLoglevel.

Spring Boot Admin prend également en charge la réplication de cluster à l'aide de Hazelcast. Nous devons juste ajouter lesMaven dependencyuivants et laisser l'autoconfiguration faire le reste: 


    com.hazelcast
    hazelcast
    3.12.2

Si nous voulons une instance persistante de Hazelcast, nous allons utiliser une configuration personnalisée: 

@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. Notifications

Ensuite, discutons de la possibilité de recevoir des notifications du serveur d'administration si quelque chose se produit avec notre client enregistré. Les notificateurs suivants sont disponibles pour la configuration:

  • Email

  • PagerDuty

  • OpsGenie

  • Hipchat

  • Mou

  • Parlons

6.1. Notifications par email

Nous allons d'abord nous concentrer sur la configuration des notifications par e-mail pour notre serveur d'administration. Pour que cela se produise, nous devons ajouter lesmail starter dependency comme indiqué ci-dessous: 


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

Après cela, nous devons ajouter une configuration de messagerie: 

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

Maintenant, chaque fois que notre client enregistré change son statut de HAUT à HORS LIGNE ou autrement, un email est envoyé à l'adresse configurée ci-dessus. Pour les autres notificateurs, la configuration est similaire.

6.2. Notifications Hipchat

Comme nous le verrons, l'intégration avec Hipchat est assez simple; il n'y a que quelques propriétés obligatoires à définir: 

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/

Une fois ceux-ci définis, nous remarquerons dans la salle Hipchat que nous recevons des notifications chaque fois que le statut du client change.

6.3. Configuration des notifications personnalisées

Nous pouvons configurer un système de notification personnalisé disposant de puissants outils pour cela. Nous pouvons utiliser unreminding notifier pour envoyer une notification planifiée jusqu'à ce que le statut du client change.

Ou peut-être voulons-nous envoyer des notifications à un ensemble filtré de clients. Pour cela, nous pouvons utiliser unfiltering notifier: 

@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. Conclusion

Ce tutoriel d'introduction couvre les étapes simples à suivre pour surveiller et gérer ses applications Spring Boot à l'aide de Spring Boot Admin.

La configuration automatique nous permet d’ajouter uniquement quelques configurations mineures et, à la fin, de disposer d’un serveur d’administration pleinement opérationnel.

Et, comme toujours, l'exemple de code de ce guide peut être trouvéover on Github.

Related