Depuis sa pu­bli­ca­tion en 1995, Java compte au rang des langages de pro­gram­ma­tion les plus po­pu­laires et les plus utilisés. Ce langage orienté objet est par­ti­cu­liè­re­ment utile lorsqu’il s’agit de réaliser des ap­pli­ca­tions com­mer­ciales complexes (en ligne et hors ligne). Combinées à l’en­vi­ron­ne­ment d’exécution Java (JRE), ces ap­pli­ca­tions se dé­mar­quent prin­ci­pa­le­ment par leur in­dé­pen­dance vis-à-vis des pla­te­formes, ce qui les rend ac­ces­sibles à un vaste public.

Pour faciliter le travail avec Java, dif­fé­rentes in­fras­truc­tures lo­gi­cielles ont été dé­ve­lop­pées au cours de cette dernière décennie afin de mettre à dis­po­si­tion de l’uti­li­sa­teur une trame de base prête à l’emploi pour le programme Java qu’on souhaite dé­ve­lop­per. L’une des plus connues est l’in­fras­truc­ture lo­gi­cielle en open source Spring, publiée en 2003, qui diminue nettement la com­plexité de la spé­ci­fi­ca­tion Java standard (« J2EE » ou « pla­te­forme Java ») mais aussi de l’ar­chi­tec­ture de com­po­sants En­ter­prise JavaBeans (« EJB »). Après la mise à dis­po­si­tion de l’extension Spring Boot, qui simplifie encore la con­fi­gu­ra­tion de nouveaux projets Spring, cette trame s’est révélée un choix optimal et convivial pour toutes les personnes ne sou­hai­tant pas commencer le dé­ve­lop­pe­ment d’une nouvelle ap­pli­ca­tion Java en­tiè­re­ment de zéro.

Dans ce tutoriel Spring Boot, vous dé­cou­vri­rez quels sont les prérequis à respecter pour l’uti­li­sa­tion de cet outil et vous ap­pren­drez comment réaliser avec brio vos premiers pas dans cette in­fras­truc­ture lo­gi­cielle modulaire et « son extension Spring Boot.

Qu’est-ce que Spring Boot ?

Publiée en 2012, Spring Boot est une solution de « con­ven­tion plutôt que con­fi­gu­ra­tion » destinée à l’in­fras­truc­ture lo­gi­cielle Java Spring qui réduit la com­plexité de la con­fi­gu­ra­tion de nouveaux projets Spring. À cette fin, Spring Boot définit une con­fi­gu­ra­tion de base incluant des di­rec­tives pour l’uti­li­sa­tion de l’in­fras­truc­ture lo­gi­cielle ainsi que toutes les bi­blio­thèques de pres­ta­taires tiers per­ti­nentes, ce qui permet de faciliter autant que possible la création de nouveaux projets. Cette méthode simplifie con­si­dé­ra­ble­ment la création d’ap­pli­ca­tions in­dé­pen­dantes prêtes pour la pro­duc­tion, ce qui explique pourquoi la majorité des nouvelles ap­pli­ca­tions Spring reposent en grande partie sur Spring Boot.

Les ca­rac­té­ris­tiques de Spring Boot peuvent être résumées comme suit :

  • l’in­té­gra­tion directe d’ap­pli­ca­tions de serveur Web/de conteneur comme Apache Tomcat ou Jetty sans utiliser de fichiers WAR (Web Appli­ca­tion Archive)
  • la con­fi­gu­ra­tion sim­pli­fiée de Maven grâce à des POM (Project Object Models) « Starter »
  • lorsque c’est possible, la con­fi­gu­ra­tion au­to­ma­tique de Spring
  • la mise à dis­po­si­tion de capacités non fonc­tion­nelles telles que des outils de mesure ou des con­fi­gu­ra­tions dé­lo­ca­li­sées

Grâce à Spring Boot, la société de dé­ve­lop­pe­ment Pivotal Software a complété l’in­fras­truc­ture lo­gi­cielle parue en 2005 avec une nouvelle approche moderne et tournée vers l’avenir. L’in­fras­truc­ture technique de base de Spring, améliorée depuis des années, a été très largement intégrée dans l’extension Spring Boot. Vous trouverez des in­for­ma­tions dé­tail­lées sur cette in­fras­truc­ture lo­gi­cielle en open source (Licence Apache 2.0) dans notre article détaillé sur cette trame de base Java très largement utilisée.

Tutoriel Spring Boot : exigences, ins­tal­la­tion et premiers pas

Depuis l’extension de Spring avec Spring Boot, le logiciel de Pivotal Software est considéré comme l’une des meil­leures solutions en termes de dé­ve­lop­pe­ment de mi­cro­ser­vices sous Java. Grâce à près de 20 modules du framework de base pouvant être assemblés comme vous le souhaitez, Spring Boot convient toutefois également à une multitude d’autres scénarios et ne saurait vé­ri­ta­ble­ment être classé comme framework pour les ap­pli­ca­tions Web ou comme solution classique pour les ap­pli­ca­tions de bureau.

Avant d’aborder plus avant la con­fi­gu­ra­tion et la création d’un nouveau projet ainsi que la structure de Spring Boot dans ce tutoriel Spring Boot, nous trai­te­rons dans un premier temps des exigences tech­niques et de la mise en place des com­po­sants de projet né­ces­saires.

Quels sont les prérequis logiciels de Spring Boot ?

Java est in­con­tour­nable lorsqu’il s’agit de Spring Boot. C’est la raison pour laquelle l’en­vi­ron­ne­ment d’exécution Java (pla­te­forme Java) est la com­po­sante lo­gi­cielle in­dis­pen­sable au fonc­tion­ne­ment de l’in­fras­truc­ture. Puisque que cette pla­te­forme ne sert pas uni­que­ment à l’exécution de l’ap­pli­ca­tion, mais également au dé­ve­lop­pe­ment avec Java, vous aurez au minimum besoin de la version 8 (ou 1.8) du Java De­ve­lop­ment Kit (JDK). Celui-ci contient par ailleurs des outils pratiques venant compléter l’en­vi­ron­ne­ment d’exécution afin de pro­gram­mer et de tester les ap­pli­ca­tions Java. Il est dis­po­nible aussi bien sur Linux que sur Windows et macOS. Vous avez donc carte blanche en ce qui concerne le système d’ex­ploi­ta­tion.

Na­tu­rel­le­ment, l’extension requiert également que la version actuelle de l’in­fras­truc­ture Spring soit installée sur le système.

Maven (à partir de la version 3.3) ou Gradle (à partir de la version 4.4) peuvent être utilisés comme outils de pro­duc­tion.

Si vous souhaitez profiter de la pos­si­bi­lité d’intégrer un serveur Web exécutant votre ap­pli­ca­tion Java sur la base d’un Servlet, vous pouvez choisir parmi les trois solutions suivantes : Apache Tomcat (à partir de 9.0), Jetty (à partir de 9.4) et Undertow (à partir de 2.0).

Créez votre premier projet Spring Boot

L’uti­li­sa­tion de Spring Boot est similaire à celle de toute bi­blio­thèque Java standard : elle s’effectue en intégrant les fichiers JAR (Java Archive) ou WAR (Web Ap­pli­ca­tion Archive) cor­res­pon­dants dans le chemin de classes (Classpath). Java utilise ce chemin dans le système de fichier pour re­cher­cher les fichiers exé­cu­tables. Dans ce cadre, les fichiers archives pour Spring Boot peuvent être créés de deux façons :

  • Vous pouvez installer et utiliser Maven ou Gradle afin de créer per­son­nel­le­ment la trame du projet incluant les con­traintes né­ces­saires.
  • Vous pouvez utiliser le service Web Spring Ini­tia­lizr pour établir votre con­fi­gu­ra­tion Spring Boot puis la té­lé­char­ger sous la forme d’un modèle de projet fini.

La par­ti­cu­la­rité de cette seconde solution réside dans le fait que vous pourrez créer les fichiers JAR via une interface Web con­vi­viale qui simplifie con­si­dé­ra­ble­ment le processus. Comme le service Ini­tia­lizr a également recours à Maven ou Gradle afin de générer les fichiers, le résultat ne sera pas différent de celui d’une procédure manuelle. Dans le cadre de ce tutoriel Java ou Spring Boot, nous avons donc opté pour l’assistant Web dis­po­nible à l’adresse start.spring.io.

Note

Si vous optez pour l’uti­li­sa­tion de Spring Ini­tia­lizr, Java et Maven ou Gradle doivent également être installés pour pouvoir tra­vail­ler sur votre ap­pli­ca­tion Spring Boot.

Si vous avez ouvert Spring Ini­tia­lizr, vous pouvez définir dans l’ordre les pro­prié­tés sou­hai­tées pour votre première ap­pli­ca­tion Spring Boot : Tout d’abord, dé­ter­mi­nez le système de pro­duc­tion en sé­lec­tion­nant « Maven Project » ou « Gradle Project ». La deuxième ligne vous donne la pos­si­bi­lité d’opter pour le langage classique Java ou pour un autre langage de la famille Java tel que Kotlin ou Groovy. D’autre part, dé­fi­nis­sez la version de Spring Boot sous-jacente, les mé­ta­don­nées du projet (incluant la version de Java) ainsi que toutes les autres con­traintes per­ti­nentes (bases de données, fonc­tion­na­li­tés de sécurité, in­ter­faces Web, services Cloud, etc.). En cliquant sur « Generate Project », vous générez fi­na­le­ment les fichiers du projet.

Image: Spring Initializr : création d’un projet Spring Boot basé sur Maven
Le format WAR vient compléter JAR avec dif­fé­rents com­po­sants Web tels que le fichier de con­fi­gu­ra­tion XML web.xml qui décrit le processus de mise à dis­po­si­tion.
Conseil

Si vous souhaitez créer votre projet Spring Boot vous-même avec Maven et Gradle, vous pouvez suivre les ins­truc­tions d’ins­tal­la­tion figurant dans les manuels en ligne officiels.

Exécuter le projet Spring Boot créé

Spring Ini­tia­lizr vous propose de té­lé­char­ger les fichiers du projet créés sous la forme d’une archive ZIP que vous devrez dé­com­pres­ser après té­lé­char­ge­ment. Dans le dossier dé­com­pressé, vous trouverez notamment le fichier de con­fi­gu­ra­tion cor­res­pon­dant : si vous avez sé­lec­tionné Gradle pour la gestion de la pro­duc­tion, il s’agit dans ce cas du fichier build.gradle ; dans le cas des projets Maven, vous devriez y trouver le fichier pom.xml. Dans ce dernier cas, qui s’applique également à l’exemple de notre tutoriel Spring Boot, le contenu du fichier de con­fi­gu­ra­tion ressemble à peu près à ce qui suit :

Image: Extrait du fichier de configuration pom.xml généré pour Maven
Le fichier de con­fi­gu­ra­tion Maven se distingue par sa structure XML typique et comporte des mé­ta­don­nées es­sen­tielles.

À l’aide du logiciel de pro­duc­tion cor­res­pon­dant, créez une ap­pli­ca­tion Spring Boot exé­cu­table à partir des fichiers archives obtenus. Pour ce faire, ouvrez le terminal ou l’invite de commandes et exécutez la commande suivante dans le dossier cible (c’est-à-dire dans le dossier de vos fichiers Spring Boot) si vous utilisez Maven :

mvn clean install
Image: Invite de commandes Windows : génération du fichier JAR avec Maven
Maven fonc­tionne selon le modèle « con­ven­tion plutôt que con­fi­gu­ra­tion », raison pour laquelle les pa­ra­mètres de base tels que le format d’édition JAR sont au­to­ma­ti­que­ment utilisés pour le processus de pro­duc­tion dans la mesure où vous n’avez pas donné de consignes spé­ci­fiques.

Pour les projets Gradle, la commande se présente comme suit :

gradle clean build

Une fois le trai­te­ment de la commande réussi, vous obtenez dans les deux cas le message « BUILD SUCCESS » dès que les fichiers archives ont été créés avec succès. Dans ce cadre, le fichier exé­cu­table est en­re­gis­tré dans le dossier « target » (Maven) ou « build/libs » (Gradle). Dans notre cas, le nom de ce fichier JAR est « demo-0.0.1-SNAPSHOT.jar » :

Image: Fichier JAR généré dans le dossier Maven cible sous Windows 10
La création des fichiers archives peut prendre quelques minutes en fonction du nombre de con­traintes ajoutées au préalable avec Spring Ini­tia­lizr.

Vous pouvez procéder à l’exécution à l’aide de Java en sai­sis­sant la commande suivante :

java -jar demo-0.0.1-SNAPSHOT.jar
Image: Initialisation de l’application Spring Boot
Pour que le démarrage de l’ap­pli­ca­tion Spring Boot fonc­tionne, vous devez exécuter le code indiqué dans le dossier du fichier JAR (target).

Le nom du fichier JAR écrit en italique dans l’exemple de code doit être remplacé s’il ne cor­res­pond pas. Vous pouvez à présent vérifier, à l’aide de l’output affiché dans l’invite de commande, si l’ap­pli­ca­tion Spring Boot a pu être démarrée avec succès. Si vous avez intégré l’un des serveurs Web indiqués plus haut, comme Tomcat, celui-ci est également lancé. Vous pouvez l’atteindre avec le na­vi­ga­teur de votre choix en con­sul­tant l’adresse suivante :

http://localhost:8080

Connecter Spring Boot à la base de données et à la source de données

Spring Boot propose une as­sis­tance de premier ordre pour la création et l’in­té­gra­tion des sources de données dans les bases de données SQL ou NoSQL de votre choix. Vous n’aurez pas à écrire de code sup­plé­men­taire pour créer une source de données, mais uni­que­ment à ajouter les con­traintes né­ces­saires et les détails de la con­fi­gu­ra­tion. Cet avantage provient de l’interface de base de données homogène JDBC (Java Database Con­nec­ti­vity) pour laquelle il convient tout d’abord de créer une entrée Starter dans le fichier de con­fi­gu­ra­tion si vous n’avez pas déjà ajouté la con­trainte lors de la création du projet avec Spring Ini­tia­lizr (il en va de même pour l’ajout des autres con­traintes men­tion­nées).

Pour ce faire, les uti­li­sa­teurs Maven doivent saisir les lignes suivantes dans le fichier pom.xml :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

Les uti­li­sa­teurs Gradle réalisent cette étape en insérant l’entrée suivante dans le fichier build.gradle :

compile('org.springframework.boot:spring-boot-starter-jdbc')
Note

Vous pouvez ouvrir le fichier de con­fi­gu­ra­tion en question avec n’importe quel éditeur de code usuel. Il est essentiel que le fichier soit à nouveau en­re­gis­tré au format XML ou Gradle après les mo­di­fi­ca­tions.

Lors de la deuxième étape, vous allez compléter le fichier de con­fi­gu­ra­tion de la pro­duc­tion concerné en y ajoutant la con­trainte pour le système de gestion de base de données souhaité. Dans ce tutoriel Spring Boot, nous con­nec­tons notre ap­pli­ca­tion à une base de données MySQL que nous sou­hai­tons utiliser pour notre ap­pli­ca­tion et que nous avons installée au préalable.

Pour cela, le pom.xml des projets Maven doit recevoir la nouvelle entrée suivante :

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

Dans la con­fi­gu­ra­tion Gradle, la ligne suivante doit être saisie pour établir la connexion avec la base de données MySQL :

compile('mysql:mysql-connector-java')

Certaines pro­prié­tés doivent ensuite être ajoutées dans le fichier de PRO­PRIÉ­TÉS « ap­pli­ca­tion ». Ce fichier peut être trouvé en entrant \src\main\resources dans le ré­per­toire du projet Spring Boot. Ouvrez ce fichier texte et insérez les lignes de con­fi­gu­ra­tion suivantes :

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.tomcat.testOnBorrow = true
spring.datasource.tomcat.testWhileIdle = true
spring.datasource.tomcat.timeBetweenEvictionRunsMillis = 60000
spring.datasource.tomcat.minEvictableIdleTimeMillis = 30000
spring.datasource.tomcat.validationQuery = SELECT 1
spring.datasource.tomcat.max-active = 15
spring.datasource.tomcat.max-idle = 10
spring.datasource.tomcat.max-wait = 8000

Si vous ne l’avez pas déjà fait, vous pouvez à présent utiliser MySQL de la manière ha­bi­tuelle afin de créer une base de données com­por­tant les données sou­hai­tées. Les débutants trou­ve­ront des in­for­ma­tions dé­tail­lées sur l’uti­li­sa­tion du système de gestion de base de données re­la­tion­nelles dans notre tutoriel MySQL complet.

Générer un cer­ti­fi­cat SSL/TLS et activer HTTPS

Par défaut, une ap­pli­ca­tion Spring Boot créée utilise le protocole non sécurisé HTTP et le port TCP 8080 pour la connexion au serveur Web en question. Pour utiliser le protocole sécurisé HTTPS et con­fi­gu­rer le port TCP 443 prévu à cet effet comme choix par défaut, utilisez un cer­ti­fi­cat SSL/TLS ainsi que les pro­prié­tés adaptées dans le fichier PRO­PRIÉ­TÉS « ap­pli­ca­tion ».

Vous pouvez obtenir ce cer­ti­fi­cat auprès d’un organisme de cer­ti­fi­ca­tion ou en créant un cer­ti­fi­cat autosigné à l’aide de l’en­vi­ron­ne­ment d’exécution Java. Grâce à cet uti­li­taire de gestion, cet en­vi­ron­ne­ment dispose d’un outil de ligne de commande per­met­tant de créer en toute sim­pli­cité des fichiers PKCS12 (contenant un cer­ti­fi­cat X.509 et une clé privée) pour les serveurs comme Tomcat, Exchange, IIS etc. Si vous utilisez par exemple un serveur Tomcat, saisissez dans l’invite de commandes ou dans le terminal la commande suivante afin de générer le fichier d’en­re­gis­tre­ment de clé pour votre ap­pli­ca­tion Spring Boot :

keytool -genkeypair -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650

Afin de per­son­na­li­ser votre cer­ti­fi­cat, dé­fi­nis­sez ensuite un mot de passe personnel et indiquez quelques in­for­ma­tions sur vous-même, votre en­tre­prise et votre lo­ca­li­sa­tion.

Le fichier d’en­re­gis­tre­ment de clé est ensuite au­to­ma­ti­que­ment sau­ve­gardé dans le ré­per­toire où vous avez exécuté la commande (dans ce tutoriel Spring Boot, il s’agit du ré­per­toire d’uti­li­sa­teur). Copiez le fichier « keystore » dans le ré­per­toire de votre ap­pli­ca­tion Spring Boot et complétez le fichier PRO­PER­TIES « ap­pli­ca­tion » déjà utilisé pour l’in­té­gra­tion de la base de données avec les lignes suivantes :

server.port = 443
server.ssl.key-store = C:/demo/keystore.p12
server.ssl.key-store-password = springboot
server.ssl.key-store-type = PKCS12
server.ssl.key-alias = tomcat

Pour finir, créez à l’aide de la commande suivante un nouveau fichier JAR exé­cu­table qui sera connecté à Tomcat de la manière con­fi­gu­rée via HTTPS :

mvn -Dmaven.test.skip=true -DskipTests=true clean install

Faciliter le débogage de l’ap­pli­ca­tion Spring Boot avec Spring Cloud Sleuth et Zipkin

Les tests continus font partie des tâches les plus im­por­tantes en matière de dé­ve­lop­pe­ment logiciel, puisque cette phase permet de détecter et de corriger toutes les erreurs survenues lors de la pro­gram­ma­tion. En règle générale, l’analyse des fichiers journaux est toutefois très complexe, ce qui rend souvent le processus de débogage par­ti­cu­liè­re­ment laborieux, notamment pour les mi­cro­ser­vices. Pour conclure ce tutoriel Spring Boot, nous sou­hai­tons par con­sé­quent mettre en place les solutions de traçage Spring Cloud Sleuth et Zipkin afin d’assurer une sur­veil­lance de l’ap­pli­ca­tion Spring Boot de tous les côtés.

Grâce à ces deux ap­pli­ca­tions de traçage, vous pourrez suivre sans dif­fi­culté toutes les requêtes con­cer­nant un con­trô­leur REST mis en place au préalable et afficher la chro­no­lo­gie à tout moment.

Étape 1 : ajouter Spring Cloud Sleuth au projet

Intégrez tout d’abord le module Sleuth à votre ap­pli­ca­tion Spring Boot en dé­fi­nis­sant la con­trainte dans le fichier de con­fi­gu­ra­tion de la pro­duc­tion. Pour ce faire, insérez le contenu suivant dans le pom.xml si vous utilisez Maven :

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
    <version>${spring-cloud-sleuth.version}</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

Dans le fichier de con­fi­gu­ra­tion des projets Gradle, il vous faudra ajouter les lignes suivantes :

compile('org.springframework.cloud:spring-cloud-starter-sleuth')

Étape 2 : intégrer les journaux Sleuth dans le fichier de classes du con­trô­leur REST

Le con­trô­leur REST de votre ap­pli­ca­tion Spring Boot doit à présent être configuré de façon à traiter les fichiers journaux de Sleuth de la manière souhaitée. À cette fin, ajoutez au fichier .class du con­trô­leur le texte de con­fi­gu­ra­tion suivant – le nom de paquet (ici spring-boot-tutorial) cor­res­pond dans ce cadre au domaine du <groupId> dans le pom.xml:

package spring-boot-tutorial.sleuth;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class SleuthappApplication {
    private static final Logger LOG = Logger.getLogger(SleuthappApplication.class.getName());
    public static void main(String[] args) {
        SpringApplication.run(SleuthappApplication.class, args);
    }
    @RequestMapping("/")
    public String index() {
        LOG.log(Level.INFO, "Index API is calling");
        return "Sleuth: Spring-Boot-Tutorial-Test!";
    }
}

Étape 3 : indiquer le nom de l’ap­pli­ca­tion Spring dans les pro­prié­tés

Afin de garantir que le nom de l’ap­pli­ca­tion Spring Boot soit cor­rec­te­ment affiché dans Zipkin, vous devriez indiquer le nom dans le fichier PRO­PER­TIES « ap­pli­ca­tion ». Si vous en­re­gis­trez la con­fi­gu­ra­tion sur un serveur de con­fi­gu­ra­tion Spring Cloud, il vous faudra réaliser la même opération dans le fichier de PRO­PER­TIES « bootstrap » :

spring.application.name = Spring-Boot-Tutorial-App

Étape 4 : ajouter Zipkin au projet

Zipkin vous aide à sur­veil­ler et gérer les journaux Sleuth. Ce logiciel open source se compose d’une interface d’uti­li­sa­teur et d’une com­po­sante de serveur. Les con­traintes des deux com­po­santes sont ajoutées dans le fichier de con­fi­gu­ra­tion cor­res­pon­dant. Les uti­li­sa­teurs de Maven saisiront pour cela le contenu suivant dans le pom.xml :

<dependency>
    <groupId>io.zipkin.java</groupId>
    <artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
    <groupId>io.zipkin.java</groupId>
    <artifactId>zipkin-autoconfigure-ui</artifactId>
<scope>runtime</scope>
</dependency>

Dans le cas d’une con­fi­gu­ra­tion Gradle, les nouvelles lignes seront les suivantes :

compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')

Étape 5 : autoriser l’ap­pli­ca­tion à agir en tant que serveur Zipkin

L’étape suivante consiste à veiller à ce que votre projet Spring Boot puisse agir en tant que serveur Zipkin. Pour ce faire, vous allez créer un fichier intitulé zipkin.pro­per­ties et y insérer les lignes suivantes :

spring.application.name=zipkin
server.port=9411
logging.level.org.springframework.web=debug

Activez ensuite la com­po­sante de serveur dans le fichier Java du projet :

package spring-boot-tutorial.zipkin;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import zipkin.server.EnableZipkinServer;
@SpringBootApplication
@EnableZipkinServer
public class ZipkinappApplication {
    public static void main(String[] args) {
        SpringApplication.run(ZipkinappApplication.class, args);
    }
}

Si vous générez le fichier JAR exé­cu­table de la façon ha­bi­tuelle et si vous exécutez l’ap­pli­ca­tion, le serveur Zipkin est ac­ces­sible à l’adresse 'http://localhost:9411/zipkin'.

Étape 6 : ajouter la con­trainte Zipkin Spring Cloud

Ajoutez une dernière con­trainte dans le fichier de con­fi­gu­ra­tion de la pro­duc­tion afin d’associer Sleuth et Zipkin.

Maven :

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

Gradle :

compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')

Étape 7 : con­fi­gu­rer l’ex­por­ta­tion du journal Sleuth sur le serveur Zipkin

Complétez le fichier Java de votre ap­pli­ca­tion Spring Boot avec l’objet Al­ways­Sam­pler (Bean) afin d’activer l’ex­por­ta­tion au­to­ma­tique du journal Sleuth sur le serveur Zipkin :

@Bean
public AlwaysSampler defaultSampler() {
    return new AlwaysSampler();
}

Étape 8 : indiquer l’URL de base du serveur Zipkin dans le fichier PRO­PER­TIES « ap­pli­ca­tion »

Pour cette dernière étape, vous devrez indiquer l’URL de base du serveur Zipkin dans les pro­prié­tés de l’ap­pli­ca­tion en ouvrant une nouvelle fois le fichier PRO­PER­TIES de votre projet Spring Boot et en ajoutant la ligne suivante :

spring.zipkin.baseUrl = http://localhost:9411/zipkin/
Aller au menu principal