TOC

Guide rapide de Spring Cloud Consul

Un guide rapide sur Spring Cloud Consul

1. Vue d'ensemble

Le projetSpring Cloud Consul permet une intégration facile avec Consul pour les applications Spring Boot.

Consul est un outil qui fournit des composants pour résoudre certains des défis les plus courants dans une architecture de micro-services:

  • Découverte de service - pour enregistrer et désenregistrer automatiquement les emplacements réseau des instances de service

  • Bilan de santé - pour détecter le moment où une instance de service est opérationnelle

  • Configuration distribuée - pour s'assurer que toutes les instances de service utilisent la même configuration

Dans cet article, nous verrons comment nous pouvons configurer une application Spring Boot pour utiliser ces fonctionnalités.

2. Conditions préalables

Pour commencer, il est recommandé d’examiner rapidementConsul et toutes ses fonctionnalités.

Dans cet article, nous allons utiliser un agent Consul fonctionnant surlocalhost:8500. Pour plus d'informations sur l'installation de Consul et l'exécution d'un agent, reportez-vous à celink.

Tout d'abord, nous devons ajouter la dépendancespring-cloud-starter-consul-all à nospom.xml: 


    org.springframework.cloud
    spring-cloud-starter-consul-all
    1.3.0.RELEASE

3. Découverte de service

Écrivons notre première application Spring Boot et connectons-nous à l'agent Consul en cours d'exécution: 

@SpringBootApplication
public class ServiceDiscoveryApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(ServiceDiscoveryApplication.class)
          .web(true).run(args);
    }
}

By default, Spring Boot will try to connect to the Consul agent at localhost:8500. Pour utiliser d'autres paramètres, nous devons mettre à jour le fichierapplication.yml: 

spring:
  cloud:
    consul:
      host: localhost
      port: 8500

Ensuite, si nous visitons le site de l’agent Consul dans le navigateur àhttp://localhost:8500, nous verrons que notre application a été correctement enregistrée dans Consul avec l’identifiant de“$\{spring.application.name}:$\{profiles separated by comma}:$\{server.port}”.

Pour personnaliser cet identifiant, nous devons mettre à jour la propriétéspring.cloud.discovery.instanceId avec une autre expression: 

spring:
  application:
    name: myApp
  cloud:
    consul:
      discovery:
        instanceId: ${spring.application.name}:${random.value}

Si nous exécutons à nouveau l'application, nous verrons qu'elle a été enregistrée à l'aide de l'identifiant“MyApp” plus une valeur aléatoire. Nous en avons besoin pour exécuter plusieurs instances de votre application sur notre ordinateur local.

Enfin,to disable Service Discovery, we need to set the property spring.cloud.consul.discovery.enabled to false.

3.1. Recherche de services

Notre application est déjà enregistrée dans Consul, mais comment les clients peuvent-ils trouver les points de terminaison du service? Nous avons besoin d’un service client de découverte pour obtenir un service actif et disponible de Consul.

Spring provides a DiscoveryClient API for this, que nous pouvons activer avec l'annotation@EnableDiscoveryClient: 

@SpringBootApplication
@EnableDiscoveryClient
public class DiscoveryClientApplication {
    // ...
}

Ensuite, nous pouvons injecter le beanDiscoveryClient dans notre contrôleur et accéder aux instances: 

@RestController
public class DiscoveryClientController {

    @Autowired
    private DiscoveryClient discoveryClient;

    public Optional serviceUrl() {
        return discoveryClient.getInstances("myApp")
          .stream()
          .map(si -> si.getUri());
          .findFirst()
    }
}

Enfin, nous définirons nos points de terminaison d'application: 

@GetMapping("/discoveryClient")
public String discoveryPing() throws RestClientException,
  ServiceUnavailableException {
    URI service = serviceUrl()
      .map(s -> s.resolve("/ping"))
      .orElseThrow(ServiceUnavailableException::new);
    return restTemplate.getForEntity(service, String.class)
      .getBody();
}

@GetMapping("/ping")
public String ping() {
    return "pong";
}

Le chemin“myApp/ping” est le nom de l'application Spring avec le point de terminaison du service. Consul fournira toutes les applications disponibles nommées“myApp”.

4. Contrôle de santé

Consul vérifie périodiquement la santé des terminaux.

Par défaut,Spring implements the health endpoint to return 200 OK if the app is up. Si nous voulons personnaliser le point de terminaison, nous devons mettre à jour lesapplication.yml: 

spring:
  cloud:
    consul:
      discovery:
        healthCheckPath: /my-health-check
        healthCheckInterval: 20s

Par conséquent, Consul interrogera le point de terminaison“/my-health-check” toutes les 20 secondes.

Définissons notre service de vérification de l'état personnalisé pour renvoyer un étatFORBIDDEN: 

@GetMapping("/my-health-check")
public ResponseEntity myCustomCheck() {
    String message = "Testing my healh check function";
    return new ResponseEntity<>(message, HttpStatus.FORBIDDEN);
}

Si nous allons sur le site de l’agent Consul, nous verrons que notre application échoue. Pour résoudre ce problème, le service“/my-health-check” doit renvoyer le code d'état HTTP200 OK.

5. Configuration distribuée

Cette fonctionallows synchronizing the configuration among all the services. Consul surveillera tout changement de configuration, puis déclenchera la mise à jour de tous les services.

Tout d'abord, nous devons ajouter la dépendancespring-cloud-starter-consul-config à nospom.xml: 


    org.springframework.cloud
    spring-cloud-starter-consul-config
    1.3.0.RELEASE

Nous devons également déplacer les paramètres du nom de l'application Consul et Spring du fichierapplication.yml vers le fichierbootstrap.yml que Spring charge en premier.

Ensuite, nous devons activer Spring Cloud Consul Config: 

spring:
  application:
    name: myApp
  cloud:
    consul:
      host: localhost
      port: 8500
      config:
        enabled: true

Spring Cloud Consul Config recherchera les propriétés dans Consul à“/config/myApp”. Donc, si nous avons une propriété appelée“my.prop”, nous aurions besoin de créer cette propriété dans le site de l'agent Consul.

Nous pouvons créer la propriété en allant dans la section“KEY/VALUE”, puis en entrant“/config/myApp/my/prop” sous la forme“Create Key” et“Hello World” comme valeur. Enfin, cliquez sur le bouton“Create”.

N'oubliez pas que si vous utilisez des profils Spring, vous devez ajouter les profils en regard du nom de l'application Spring. Par exemple, si nous utilisons le profildev, le chemin final dans Consul sera“/config/myApp,dev”.

Voyons maintenant à quoi ressemble notre contrôleur avec les propriétés injectées: 

@RestController
public class DistributedPropertiesController {

    @Value("${my.prop}")
    String value;

    @Autowired
    private MyProperties properties;

    @GetMapping("/getConfigFromValue")
    public String getConfigFromValue() {
        return value;
    }

    @GetMapping("/getConfigFromProperty")
    public String getConfigFromProperty() {
        return properties.getProp();
    }
}

Et la classeMyProperties: 

@RefreshScope
@Configuration
@ConfigurationProperties("my")
public class MyProperties {
    private String prop;

    // standard getter, setter
}

Si nous exécutons l'application, les champsvalue etproperties ont la même valeur“Hello World” de Consul.

5.1. Mise à jour de la configuration

Qu'en est-il de la mise à jour de la configuration sans redémarrer l'application Spring Boot?

Si nous retournons sur le site de l'agent Consul et que nous mettons à jour la propriété“/config/myApp/my/prop” avec une autre valeur comme“New Hello World”, alors le champvalue ne changera pas et le champproperties aura été mis à jour en“New Hello World” comme prévu.

C'est parce que le champproperties est une classeMyProperties a l'annotation@RefreshScope. All beans annotated with the @RefreshScope annotation will be refreshed after configuration changes.

Dans la vraie vie, nous ne devrions pas avoir les propriétés directement dans Consul, mais nous devrions les stocker de manière persistante quelque part. Nous pouvons le faire en utilisant unConfig Server.

6. Conclusion

Dans cet article, nous avons vu comment configurer nos applications Spring Boot pour qu'elles fonctionnent avec Consul à des fins de découverte de services, personnaliser les règles de vérification de l'état et partager une configuration distribuée.

Nous avons également introduit un certain nombre d'approches pour que les clients invoquent ces services enregistrés.

Comme d'habitude, les sources peuvent être trouvéesover on GitHub.

Related