Tutoriel Kafka avec Java

De son installation à l’exécution d'un premier programme en Java

dimbo

J’ai rencontré plusieurs difficultés en voulant utiliser Kafka avec Java. Ainsi, j’ai souhaité réaliser ce tutoriel pour partager mon expérience avec d’autres personnes qui voudraient mettre en place Kafka.

L’objectif est de pouvoir envoyer un message et le réceptionner à l’aide de la messagerie Kafka en utilisant le langage JAVA.

Ce tutoriel expliquera comment installer Kafka à l'aide de Docker puis lancer un premier programme en Java.

Nous verrons étape par étape comment y arriver…

Ce tutoriel n’a pas vocation à expliquer le fonctionnement de Kafka.

Pour vos suggestions et commentaires, un espace est créé sur le forum : Commentez

- Titre : Tutoriel Kafka avec Java

- Auteur : dimbo

- Parution : 3 mai 2021

- Mise à jour : 25 mai 2021

- Public visé :

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2021 dimbo2. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Pour commencer : qu’est-ce que Kafka ?

- II. Environnement

- II-A. Technique

- II-B. Schéma

- III. Démarrage de l’image Docker Kafka

- III-A. Installation et lancement

- III-B. Administration par kafka-manager (CMAK)

- IV. Modélisation

- IV-A. Diagramme de classe

- IV-B. Diagramme de séquence

- V. Initialisation du projet

- VI. Programme

- VI-A. Structure du programme

- VI-B. Data To Object (dto)

- VI-C. Receiver

- VI-D. Sender

- VI-E. Main

- VII. Exécution

- VII-A. Exécuter

- VII-B. Résultat

- VIII. Conclusion

- IX. Liens

- X. Remerciements

I - Pour commencer : qu’est-ce que Kafka ?

Apache Kafka est une plate-forme de diffusion d'événements distribuée open source utilisée par des milliers d'entreprises pour des pipelines de données à haute performance, des analyses de streaming, l'intégration de données et des applications critiques (site officiel : https://kafka.apache.org/).

Vous pouvez également le découvrir au travers du tutoriel de SOAT (https://soat.developpez.com/tutoriels/bigdata/apprendre-kafka-concepts-fonctionnement/).

II - Environnement

II-A - Technique

- Système d’exploitation : Windows 10 (il est possible d’utiliser Linux).

- Docker pour déployer Kafka.

- Dans ce tutoriel, Docker Desktop de Windows a été utilisé (https://docs.docker.com/docker-for-windows/install/).

- A savoir : il est nécessaire d’activer la virtualisation dans le Bios et d’installer Linux pour Windows 10 (https://docs.microsoft.com/fr-fr/win.../install-win10).

- Environnement de développement : Eclipse (https://www.eclipse.org/).

- Langage : Java avec le Framework Spring et Maven.

II-B - Schéma

Le programme que nous allons réaliser permettra à un expéditeur d’envoyer un message à un destinataire au travers de la messagerie Kafka. Ce dernier sera démarré avec Docker.

Une partie du programme va envoyer un message au travers de la messagerie Kafka à un destinataire.

Une autre partie du programme écoutera la messagerie Kafka, si un message lui est destiné, il le réceptionnera.

Schéma global

III - Démarrage de l’image Docker Kafka

III-A - Installation et lancement

1. Démarrer Docker.

2. Créer un fichier « docker-compose.yml » dans un répertoire.

3. Copier le contenu ci-dessous dans le fichier.

Pour information : Les images utilisées de Docker pour Kafka sont :

https://hub.docker.com/r/wurstmeister/kafka

https://hub.docker.com/_/zookeeper

https://hub.docker.com/r/kafkamanager/kafka-manager

docker-compose.yml

version: '3.5'

services:
zookeeper:
image: zookeeper
ports:
- "2181:2181"
kafka:
image: wurstmeister/kafka
ports:
- "9092:9092"
environment:
# HOSTNAME_COMMAND: "route -n | awk '/UG[ \t]/{print $$2}'"
KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
KAFKA_ADVERTISED_HOST_NAME: kafka
KAFKA_ADVERTISED_PORT: 9092
KAFKA_BROKER_ID: 1
KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
KAFKA_JMX_OPTS: "-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=kafka -Dcom.sun.management.jmxremote.rmi.port=1099"
JMX_PORT: 1099
volumes:
- /var/run/docker.sock:/var/run/docker.sock
depends_on:
- zookeeper
kafka-manager:
image: kafkamanager/kafka-manager
ports:
- "9000:9000"
links:
- zookeeper
- kafka
environment:
ZK_HOSTS: zookeeper:2181

4. En ligne de commande (CMD sous Windows), se positionner dans le répertoire et lancer la ligne de commande : docker-compose upou docker compose up(suivant la version).

5. Les images vont se télécharger et démarrer (la première exécution peut prendre un certain temps).

6. Avec un autre invite de commande, il est également possible de vérifier que les conteneurs sont démarrés en tapant docker ps.

docker ps

C:\TutoKafka>docker ps
CONTAINER ID   IMAGE                        COMMAND                  CREATED          STATUS          PORTS                                                  NAMES
9a077b5079d5   kafkamanager/kafka-manager   "cmak-3.0.0.4/bin/cm…"   16 seconds ago   Up 15 seconds   0.0.0.0:9000->9000/tcp                                 kafka_kafka-manager_1
ac45367575e5   wurstmeister/kafka           "start-kafka.sh"         17 seconds ago   Up 16 seconds   0.0.0.0:9092->9092/tcp                                 kafka_kafka_1
7b7eca7f1642   zookeeper                    "/docker-entrypoint.…"   17 seconds ago   Up 16 seconds   2888/tcp, 3888/tcp, 0.0.0.0:2181->2181/tcp, 8080/tcp   kafka_zookeeper_1

III-B - Administration par kafka-manager (CMAK)

1. Via un navigateur, lancer http://localhost:9000.

2. Ajouter un cluster en renseignant les informations ci-après.

Kafka-manager

IV - Modélisation

IV-A - Diagramme de classe

Diagramme de classe

Le programme est structuré en package :

- dto (Data Transfer Object) : objet métier qui sera transmis comme message.

- sender : partie du programme pour envoyer le message.

- receiver : partie du programme pour écouter la réception du message et exécuter un traitement.

IV-B - Diagramme de séquence

Diagramme de séquence

Dans ce diagramme de séquence, les deux parties du programme sont visibles :

- Au démarrage de l’application, la partie destinataire écoute ou attend la réception d’un message. Si un message est réceptionné, un traitement est exécuté en affichant un message contenant l’objet « Person » dans la console.

- Au démarrage du programme principal, une boucle infinie est lancée pour instancier un objet « Person » et l’envoyer en tant que message.

V - Initialisation du projet

1. Aller sur le site https://start.spring.io/.

2. Renseigner les champs et ajouter dans les « Dependencies » (Spring for Apache Kafka) et enfin « Generate ».

Sprint initializr

3. Télécharger le fichier « zip » et l’extraire dans un répertoire.

Dossier projet

4. Lancer Eclipse.

5. Importer le projet.

Import projet maven

6. Ouvrir l’arborescence du projet.

Projet arborescence

7. Ouvrir et ajouter dans le fichier « pom.xml ».

pom.xml

Extraction pom.xml

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>

8. Si vous lancez le programme en local, il faudra ajouter dans le fichier Host « 127.0.0.1 kafka » (C:\Windows\System32\drivers\etc\hosts).

fichier hosts

# Copyright (c) 1993-2009 Microsoft Corp.
#
# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.
#
# This file contains the mappings of IP addresses to host names. Each
# entry should be kept on an individual line. The IP address should
# be placed in the first column followed by the corresponding host name.
# The IP address and the host name should be separated by at least one
# space.
#
# Additionally, comments (such as these) may be inserted on individual
# lines or following the machine name denoted by a '#' symbol.
#
# For example:
#
#      102.54.94.97     rhino.acme.com          # source server
#       38.25.63.10     x.acme.com              # x client host

# localhost name resolution is handled within DNS itself.
#    127.0.0.1       localhost
#    ::1             localhost
# Added by Docker Desktop
192.168.3.138 host.docker.internal
192.168.3.138 gateway.docker.internal
# To allow the same kube context to work on the host and the container:
127.0.0.1 kubernetes.docker.internal
127.0.0.1 kafka
# End of section

VI - Programme

VI-A - Structure du programme

Voici la structure finale du programme.

Structure finale

VI-B - Data To Object (dto)

Person.java

Utilisation d'un objet ex : "Person" qui sera transmis entre l’expéditeur et le destinataire.

Person.java

1. package fr.tutoriel.kafka.dto;

3. /**

4. * Exemple d'un objet

5. */

6. public class Person {

7. private String firstName;

8. private String lastName;

9. private int age;

11. public Person() {

13. }

15. public Person(String firstName, String lastName, int age) {

16. this.firstName = firstName;

17. this.lastName = lastName;

18. this.age = age;

19. }

21. public String getFirstName() {

22. return firstName;

23. }

24. public void setFirstName(String msg) {

25. this.firstName = msg;

26. }

28. public String getLastName() {

29. return lastName;

30. }

32. public void setLastName(String name) {

33. this.lastName = name;

34. }

36. public int getAge() {

37. return age;

38. }

40. public void setAge(int age) {

41. this.age = age;

42. }

44. @Override

45. public String toString() {

46. return     "{firstName:\""+firstName+"\", lastName:\""+lastName+"\", age:"+String.valueOf(age)+"}";

47. }

48. }

VI-C - Receiver

Développement de la partie Destinataire pour écouter et réceptionner les messages.

IProcess.java

Interface pour l'exécution d'un traitement.

(NB : facultatif : pour anticiper la séparation du programme)

IProcess.java

1. package fr.tutoriel.kafka.receiver;

3. import fr.tutoriel.kafka.dto.Person;

5. /**

6. * Interface pour gerer les traitements

7. *

8. * */

9. public interface IProcess {

11. /**

12. * Exécuter un traitement

13. * @param info

14. * @param person

15. */

16. public void execute(String info, Person person);

17. }

IReceiver.java

Interface pour écouter la réception d'un message.

Il serait possible d'utiliser la même interface pour écouter un message avec une autre messagerie que Kafka (ex : RabbitMQ).

(NB : facultatif : pour anticiper la séparation du programme)

IReceiver.java

1. package fr.tutoriel.kafka.receiver;

3. import fr.tutoriel.kafka.dto.Person;

5. /**

6. * Interface pour écouter la réception d'un message

7. *

8. * Il serait possible d'utiliser la même interface pour écouter

9. * un message avec une autre messagerie que Kafka (ex : RabbitMQ)

10. * */

11. public interface IReceiver {

12. public void listen(String topicName, Person person);

13. }

KafkaReceiverConfig.java

Configuration du destinataire avec l'adresse du serveur, le groupe, type de message en JSON.

KafkaReceiverConfig.java

1. package fr.tutoriel.kafka.receiver;

3. import java.util.HashMap;

4. import java.util.Map;

6. import org.apache.kafka.clients.consumer.ConsumerConfig;

7. import org.apache.kafka.common.serialization.StringDeserializer;

8. import org.springframework.beans.factory.annotation.Value;

9. import org.springframework.context.annotation.Bean;

10. import org.springframework.context.annotation.Configuration;

11. import org.springframework.kafka.annotation.EnableKafka;

12. import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;

13. import org.springframework.kafka.core.ConsumerFactory;

14. import org.springframework.kafka.core.DefaultKafkaConsumerFactory;

15. import org.springframework.kafka.support.serializer.JsonDeserializer;

17. import fr.tutoriel.kafka.dto.Person;

19. /**

20. * Configuration du destinataire

21. */

22. @EnableKafka

23. @Configuration

24. public class KafkaReceiverConfig {

26. @Value(value = "${kafka.bootstrapAddress:kafka:9092}") // Adresse du serveur Kafka pour envoyer les messages (il est possible de le configurer via application.properties)

27. private String bootstrapAddress;

29. private static final String groupId = "Tutorial"; // Définition du groupe ex: Tutorial

31. @Bean

32. public ConsumerFactory<String, Person> receiverFactory() {

33. Map<String, Object> props = new HashMap<>();

34. props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,bootstrapAddress); // Configuration de l'adresse du serveur

35. props.put(ConsumerConfig.GROUP_ID_CONFIG,groupId);// Configuration du groupe

36. return new DefaultKafkaConsumerFactory<>(props,new StringDeserializer(),new JsonDeserializer<>(Person.class));

37. }

39. @Bean

40. public ConcurrentKafkaListenerContainerFactory<String, Person> kafkaListenerContainerFactory() {

41. ConcurrentKafkaListenerContainerFactory<String, Person> factory =new ConcurrentKafkaListenerContainerFactory<>();

42. factory.setConsumerFactory(receiverFactory());

43. return factory;

44. }

45. }

KafkaReceiver.java

Permet d'écouter la réception d'un message et d'exécuter un traitement (au travers de l'interface).

KafkaReceiver.java

1. package fr.tutoriel.kafka.receiver;

3. import org.springframework.beans.factory.annotation.Autowired;

4. import org.springframework.kafka.annotation.KafkaListener;

5. import org.springframework.stereotype.Service;

7. import fr.tutoriel.kafka.dto.Person;

10. /**

11. * Receveur Kafka

12. *

13. */

14. @Service

15. public class KafkaReceiver implements IReceiver {

17. @Autowired

18. private IProcess process; // Affectation de l'instance pour la gestion des traitements

20. /**

21. * Ecoute sur le topic "Tuto1", s'il existe un message

22. *

23. * @param person

24. *              Objet reçu

25. */

26. @KafkaListener(topics = "Tuto1",containerFactory="kafkaListenerContainerFactory")

27. public void listenTuto1(Person person) {

28. listen("Tuto1",person);

29. }

31. /**

32. * Ecoute sur le topic "Tuto2", s'il existe un message

34. * @param person

35. *              Objet reçu

36. */

37. @KafkaListener(topics = "Tuto2",containerFactory="kafkaListenerContainerFactory")

38. public void listenTuto2(Person person) {

39. listen("Tuto2",person);

40. }

42. /**

43. *

44. * Exécution d'un traitement

45. * @param topicName

46. *              Nom du topic

47. * @param topicName

48. *          Objet reçu

49. *

50. */

51. @Override

52. public void listen(String topicName, Person person) {

53. process.execute(topicName+"Info", person);

54. }

55. }

ProcessExample.java

Permet d'exécuter un traitement.

Dans l'exemple, affichage d'un texte dans la console.

ProcessExample.java

1. package fr.tutoriel.kafka.receiver;

3. import org.springframework.stereotype.Service;

5. import fr.tutoriel.kafka.dto.Person;

8. /**

9. * Traitement exemple

10. */

11. @Service

12. public class ProcessExample implements IProcess {

14. /**

15. * Exécuter le traitement : Dans notre exemple affichage du message dans la console

16. * @param topicName

17. *              Nom du Topic

18. * @param person

19. *              objet person

20. */

21. @Override

22. public void execute(String info, Person person) {

23. System.out.println("Message reçu: info="+info +", person=" + person);

24. }

25. }

VI-D - Sender

Développement de la partie Expéditeur pour envoyer les messages.

ISender.java

Interface pour envoyer un message.

Il serait possible d'utiliser la même interface pour envoyer un message avec une autre messagerie que Kafka (ex : RabbitMQ).

(NB : facultatif : pour anticiper la séparation du programme)

ISender.java

1. package fr.tutoriel.kafka.sender;

3. import fr.tutoriel.kafka.dto.Person;

6. /**

7. * Interface pour envoyer un message

8. *

9. * Il serait possible d'utiliser la même interface pour envoyer

10. * un message avec une autre messagerie que Kafka (ex : RabbitMQ)

11. * */

12. public interface ISender {

13. void send(String topicName, Person person);

14. }

KafkaSenderConfig.java

Configuration de l'expéditeur avec l'adresse du serveur, type de message en JSON.

KafkaSenderConfig.java

1. package fr.tutoriel.kafka.sender;

3. import java.util.HashMap;

4. import java.util.Map;

6. import org.apache.kafka.clients.producer.ProducerConfig;

7. import org.apache.kafka.common.serialization.StringSerializer;

8. import org.springframework.beans.factory.annotation.Value;

9. import org.springframework.context.annotation.Bean;

10. import org.springframework.context.annotation.Configuration;

11. import org.springframework.kafka.core.DefaultKafkaProducerFactory;

12. import org.springframework.kafka.core.KafkaTemplate;

13. import org.springframework.kafka.core.ProducerFactory;

14. import org.springframework.kafka.support.serializer.JsonSerializer;

16. import fr.tutoriel.kafka.dto.Person;

18. /**

19. *  Configuration de l'expéditeur

20. */

21. @Configuration

22. public class KafkaSenderConfig {

24. @Value(value = "${kafka.bootstrapAddress:kafka:9092}") // Adresse du serveur Kafka (il est possible de le configurer via application.properties)

25. private String bootstrapAddress;

27. @Bean

28. public ProducerFactory<String, Person> senderFactory() {

29. Map<String, Object> configProps = new HashMap<>();

30. configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,bootstrapAddress); // Adresse du serveur

31. configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,StringSerializer.class);

32. configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,JsonSerializer.class);

33. return new DefaultKafkaProducerFactory<>(configProps);

34. }

36. @Bean

37. public KafkaTemplate<String, Person> kafkaTemplate() {

38. return new KafkaTemplate<>(senderFactory());

39. }

40. }

KafkaTopicConfig.java

Configuration Topic avec l'adresse du serveur.

KafkaTopicConfig.java

1. package fr.tutoriel.kafka.sender;

3. import java.util.HashMap;

4. import java.util.Map;

6. import org.apache.kafka.clients.admin.AdminClientConfig;

7. //import org.apache.kafka.clients.admin.NewTopic;

8. import org.springframework.beans.factory.annotation.Value;

9. import org.springframework.context.annotation.Bean;

10. import org.springframework.context.annotation.Configuration;

11. import org.springframework.kafka.core.KafkaAdmin;

13. /**

14. *  Configuration Topic

15. */

16. @Configuration

17. public class KafkaTopicConfig {

19. @Value(value = "${kafka.bootstrapAddress:kafka:9092}") // Adresse du serveur Kafka (il est possible de le configurer via application.properties)

20. private String bootstrapAddress;

22. @Bean

23. public KafkaAdmin kafkaAdmin() {

24. Map<String, Object> configs = new HashMap<>();

25. configs.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapAddress);

26. return new KafkaAdmin(configs);

27. }

28. }

KafkaSender.java

Permet d'envoyer un message (Person) dans un topic.

KafkaSender.java

1. package fr.tutoriel.kafka.sender;

3. import org.apache.kafka.clients.admin.NewTopic;

4. import org.springframework.beans.factory.annotation.Autowired;

5. import org.springframework.kafka.core.KafkaTemplate;

6. import org.springframework.stereotype.Service;

8. import fr.tutoriel.kafka.dto.Person;

10. /**

11. *

12. * Expediteur Kafka

13. */

14. @Service

15. public class KafkaSender implements ISender {

18. @Autowired

19. private KafkaTemplate<String, Person> kafkaTemplate;

21. /**

22. * Permet d'envoyer un message (Person) dans un topic

23. *

24. * @param topicName

25. *                      Nom du topic

26. * @param person

27. *                      Objet à envoyer

28. */

29. @Override

30. public void send(String topicName, Person person) {

31. System.out.println("Message à envoyer : topicName="+topicName +", person=" + person);

32. new NewTopic(topicName, 1, (short) 1);

33. kafkaTemplate.send(topicName, person);

34. }

35. }

VI-E - Main

Programme principal

KafkaApplication.java

Spring boot permet de démarrer et configurer les parties "réception" et "destinataire".

La méthode "run" permet d'envoyer en boucle des messages vers une messagerie (Kafka ou autre).

Au travers de la méthode "send", un texte est affiché dans la console.

En asynchrone, à la réception du message, celui-ci est affiché dans la console.

KafkaApplication.java

1. package fr.tutoriel.kafka;

3. import org.springframework.beans.factory.annotation.Autowired;

4. import org.springframework.boot.CommandLineRunner;

5. import org.springframework.boot.SpringApplication;

6. import org.springframework.boot.autoconfigure.SpringBootApplication;

8. import fr.tutoriel.kafka.dto.Person;

9. import fr.tutoriel.kafka.sender.ISender;

11. /**

12. * KafkaApplication

13. * Programme principal

14. */

15. @SpringBootApplication

16. public class KafkaApplication implements CommandLineRunner {

18. @Autowired

19. private ISender sender; // Affectation de l'instance sender

21. public static void main(String[] args) {

22. SpringApplication.run(KafkaApplication.class, args);

23. }

25. /**

26. * Exécuter le programme

27. * Permet d'envoyer des messages vers une messagerie (Kafka ou autre)

28. *

29. * La réception du message est asynchrone (en attente)

30. */

31. @Override

32. public void run(String... args) throws Exception {

33. int ageTuto1 = 10; //

34. int ageTuto2 = 20; //

35. while (true) { // Boucle infinie

36. Person personTuto1 = new Person("Jean", "DUPOND", ageTuto1); // Créer un objet pour Tuto1

37. sender.send("Tuto1", personTuto1); // Envoyer l'objet sur le topic "Tuto1"

38. Thread.sleep(3000); // Attendre 3s

39. Person personTuto2 = new Person("Pierre","DURAND",ageTuto2); // Créer un objet pour Tuto2

40. sender.send("Tuto2", personTuto2);  // Envoyer l'objet sur le topic "Tuto2"

41. Thread.sleep(3000); // Attendre 3s

42. ageTuto1++; // Incrémentation du texte

43. ageTuto2++;     // Incrémentation du texte

44. }

46. }

47. }

VII - Exécution

VII-A - Exécuter

1. Sélectionner le fichier KafkaApplication.java

2. Faire Clic droit > Run As > Java Application

Exécuter le programme

VII-B - Résultat

Après exécution, il est possible de visualiser dans la console les messages (envoi et réception).

Résultat dans la console

1. Message à envoyer : topicName=Tuto2, person={firstName:"Pierre", lastName:"DURAND", age:20}

2. Message reçu: info=Tuto2Info, person={firstName:"Pierre", lastName:"DURAND", age:20}

3. Message à envoyer : topicName=Tuto1, person={firstName:"Jean", lastName:"DUPOND", age:11}

4. Message reçu: info=Tuto1Info, person={firstName:"Jean", lastName:"DUPOND", age:11}

5. Message à envoyer : topicName=Tuto2, person={firstName:"Pierre", lastName:"DURAND", age:21}

6. Message reçu: info=Tuto2Info, person={firstName:"Pierre", lastName:"DURAND", age:21}

VIII - Conclusion

J’espère qu’à travers ce tutoriel vous réussirez à installer Kafka et exécuter votre premier programme en Java.

Pour aller plus loin :

- Il serait judicieux de séparer le programme au moins en 3 parties :

- Une bibliothèque partagée (pour mettre la classe « Person » et les interfaces)

- Une partie « Sender »

- Une partie « Receiver »

- Il est possible en gardant cette structure de faire fonctionner le programme avec une autre messagerie comme RabbitMQ (https://www.rabbitmq.com/)

IX - Liens

- Kafka : https://kafka.apache.org/

- Docker: https://www.docker.com/

- Docker Desktop : https://docs.docker.com/docker-for-windows/install/

- Code source inspiré du site : https://www.baeldung.com/spring-kafka

X - Remerciements

Je tiens à remercier Mickael Baron pour son accompagnement à la réalisation de ce tutoriel et ClaudeLELOUP pour sa relecture orthographique.