Construire des applications d’intégration avec Camel sur Quarkus

Dans de nombreuses organisations, les systèmes d’information sont composés d’applications hétérogènes qui doivent échanger des données en temps réel. Ces échanges peuvent rapidement devenir complexes à maintenir, notamment lorsque les intégrations sont réalisées de manière spécifique ou ponctuelle.
Pour répondre à ce besoin croissant d’interopérabilité, il est essentiel de disposer d’un cadre d’intégration standardisé, léger et adapté aux environnements cloud et conteneurisés.

1. Introduction

Ce support s’appuie sur Quarkus comme environnement d’exécution.
L’objectif de cet article n’est pas d’apprendre Quarkus en profondeur, mais d’exploiter ses capacités pour développer, exécuter et illustrer des scénarios d’intégration avec Apache Camel.

Quarkus sera utilisé uniquement comme cadre technique pour exécuter et déployer des applications d’intégration développées avec Apache Camel. Ainsi, le fil conducteur du document est bien Camel : ses composants, ses routes, et ses cas d’usage. Les aspects propres à Quarkus (configuration, extensions, packaging, etc.) ne seront abordés que dans la mesure où ils sont nécessaires pour mettre en place et exécuter les solutions Camel.

Pourquoi Quarkus ?
- Démarrage ultra rapide
- Empreinte mémoire réduite
- Compatible GraalVM et JVM
- Idéal pour le cloud-native et Kubernetes
Pourquoi Apache Camel ?
- Framework d’intégration basé sur les Enterprise Integration Patterns (EIP)
- Large catalogue de composants (HTTP, Kafka, JMS, REST, DB, Files…)
- Camel Quarkus : intégration optimisée pour Quarkus

2. Mise en place de l’environnement

Prérequis :
- JDK 17 ou 21
- Maven 3.9+
- Quarkus CLI (optionnel) et un IDE (comme VS Code par exemple)
- Docker (si besoin pour les tests)

2.1. Installation de Maven

a. Vérifier Java

Quarkus fonctionne mieux avec Java 17 ou 21. Vérifie donc ton installation :

java -version

Si nécessaire, installe OpenJDK :

sudo apt update
sudo apt install openjdk-17-jdk

b. Télécharger et installer Maven

Télécharge Maven depuis : https://maven.apache.org/download.cgi
Extraire l’archive :

tar -xvzf apache-maven-3.9.9-bin.tar.gz
sudo mv apache-maven-3.9.9 /opt/maven

Ajouter Maven au PATH :

export M2_HOME=/opt/maven
export PATH=$M2_HOME/bin:$PATH

Vérifier l’installation :

mvn -version

2.2. Installation de Docker

a. Installer Docker Engine

sudo apt update
sudo apt install ca-certificates curl gnupg lsb-release
sudo mkdir -p /etc/apt/keyringscurl -fsSL https://download.docker.com/linux/ubuntu/gpg | 
sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpgecho "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \| 
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io

b. Vérifier l’installation

docker --version

A noté que si vous avez une version récente de Docker (Docker Desktop ≥ 2.20 / Docker Engine ≥ 20.10), pas besoin d’installer Docker Compose séparément, il est déjà intégré.

Si vous avez une vieille version par contre, vous devriez peut-être encore installer docker-compose manuellement.

2.3. Installation des services via docker-compose

Pour simplifier la mise en place de l’environnement de développement, nous allons utiliser un fichier docker-compose.yml qui orchestre automatiquement trois services essentiels pour effectuer nos tests: PostgreSQL pour la base de données, Kafka (avec Zookeeper) pour la gestion des messages, et Kafdrop comme interface web de supervision de Kafka.

a. Création du fichier docker-compose.yml

Créer le fichier docker-compose.yml dans le répertoire de votre choix et copier-coller le code ci-dessous :

# version: '3.9'
services:
 # ---------------------
 # Base de données PostgreSQL
 # ---------------------
 postgres:
   image: postgres:15
   container_name: postgres-demo
   environment:
     POSTGRES_USER: demo   # utilisateur applicatif
     POSTGRES_PASSWORD: demo   # mot de passe de l'utilisateur
     POSTGRES_DB: demo_db    # nom de la base de données
   ports:
     - "5432:5432"   # Expose PostgreSQL sur localhost:5432
   volumes:
     - postgres_data:/var/lib/postgresql/data
   networks:
     - dev-net

 # ---------------------
 # pgadmin (Interface graphique pour postgresql)
 # ---------------------
 pgadmin:
   image: dpage/pgadmin4:7.8
   container_name: pgadmin
   environment:
     PGADMIN_DEFAULT_EMAIL: admin@demo.com
     PGADMIN_DEFAULT_PASSWORD: admin
   ports:
     - "5050:80"
   depends_on:
     - postgres
   networks:
     - dev-net

 # ---------------------
 # Zookeeper (nécessaire pour Kafka)
 # ---------------------
 zookeeper:
   image: confluentinc/cp-zookeeper:7.5.0
   container_name: zookeeper
   environment:
     ZOOKEEPER_CLIENT_PORT: 2181
   ports:
     - "2181:2181"
   networks:
     - dev-net

 # ---------------------
 # Kafka (broker de messages)
 # ---------------------
 kafka:
   image: confluentinc/cp-kafka:7.5.0
   container_name: kafka
   depends_on:
     - zookeeper
   ports:
     - "9092:9092"
     - "29092:29092"
   environment:
     KAFKA_BROKER_ID: 1
     KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
     # Ici on expose le broker à localhost pour Quarkus
     KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
     KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092
     KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
     KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
   networks:
     - dev-net

 # ---------------------
 # Kafdrop (Interface graphique pour Kafka)
 # ---------------------
 kafdrop:
   image: obsidiandynamics/kafdrop:latest
   container_name: kafdrop
   depends_on:
     - kafka
   ports:
     - "9000:9000"
   environment:
     KAFKA_BROKERCONNECT: kafka:9092
   networks:
     - dev-net

 volumes:
   postgres_data:
   networks:
   dev-net:
   driver: bridge

b. Accès aux interfaces graphiques

Pour visualiser vos données sans ligne de commande, vous pouvez accéder aux interfaces graphiques. Démarrer d’abord vos services avant de cliquer sur les liens avec la commande :

Pour demarrer les services, aller dans le repertoire où se trouve votre fichier docker-compose.yml et entrer la commande :

docker compose up -d

pgAdmin (PostgreSQL) → http://localhost:5050

Email : admin@demo.com
Mot de passe : admin
Ajouter un serveur avec :

Hostname : postgres
Port : 5432
User : demo
Password : demo

Kafdrop (Kafka) → http://localhost:9000

Interface web pour créer/lister les topics Kafka, publier et consommer des messages

c. Quelques commandes utiles

Démarrer les services :

docker compose up -d

Vérifier les conteneurs en cours d’exécution :

docker ps

Arrêter les services :

docker compose stop

Accéder à PostgreSQL :

docker exec -it postgres-demo psql -U demo -d demo_db

Lister les topics Kafka (depuis le conteneur) :

docker exec -it kafka bash
kafka-topics --bootstrap-server localhost:9092 --list

3. Développement d’applications avec Camel Quarkus

3.1. Créer un projet

Pour créer votre projet quarkus, il existe deux méthodes :

Avec Maven en ligne de commande

Copier-coller le code dans votre terminal et l’exécuter

mvn io.quarkus.platform:quarkus-maven-plugin:3.0.0:create \
 -DprojectGroupId=com.example \
 -DprojectArtifactId=demo-quarkus \
 -DclassName="com.example.HelloResource" \
 -Dpath="/hello"

Cela va générer un projet avec :

Un HelloResource exposé en /hello
Un projet Maven avec les fichiers nécessaires
Un dossier demo-quarkus

Avec l’outil en ligne Quarkus (starter)

Rendez-vous sur le site https://code.quarkus.io/ et cliquer sur Generate your application pour télécharger le zip.

Dézipper le fichier et ouvrir le dossier dans votre IDE (Vs code).

Quelque soit la méthode utilisée, votre arborescence devrait ressembler à ceci :

Explication des dossiers clés :

pom.xml : le cœur du projet Maven → gère les dépendances (ex : quarkus-resteasy, quarkus-jdbc-postgresql, camel-quarkus-kafka), les plugins et la configuration.
src/main/java/ : tout ton code applicatif (Ressources REST, Services, Routes Camel, etc.).
src/main/resources/application.properties : fichier central de configuration (base de données, Kafka, ports, profils dev/prod, etc.).
src/main/resources/META-INF/resources/ : si tu poses un index.html ici → il est servi automatiquement sur /.
src/test/java/ : tests unitaires ou d’intégration avec @QuarkusTest.
target/ : généré par Maven → contient les .class compilés, le quarkus-app/, et le jar exécutable (ex : my-quarkus-project-1.0.0-runner.jar).

Tout est maintenant prêt pour développer vos applications.

Il faut savoir que par défaut, certaines extensions (librairies) ne sont pas installées, si tel est le cas vous devez les ajouter selon vos cas d’utilisation.

4. Cas pratique

Nous allons construire une mini-application complète d’intégration qui va :

Poster des données via API
Transformer les données
Publier un message dans Kafka
Insérer les données dans une base de données Postgres
Exposer une API REST pour récupérer les données transformées

Etapes de construction

Etape 1 : Création du projet

Créer un projet dans le répertoire de votre choix (Voir section 3.1. Créer un projet)

Etapes 2 : Ajout des extensions Camel + DB + Kafka

Ouvrir le projet dans Visual Studio Code et ajouter les extensions depuis le terminal

idiane@por-006:~/Documents/camel-quarkus-test$ ./mvnw quarkus:add-extension -Dextensions="camel-quarkus-core,camel-quarkus-http,camel-quarkus-rest,camel-quarkus-jdbc,camel-quarkus-kafka,quarkus-jdbc-postgresql"

Etape 3 : Créer la connexion à la base PostgreSQL et Kafka

Dans le dossier src/main/resources/application.properties copier-coller les paramètres de connexion aux différents services :

# PostgreSQL
quarkus.datasource.db-kind=postgresql
quarkus.datasource.username=demo
quarkus.datasource.password=demo
quarkus.datasource.jdbc.url=jdbc:postgresql://localhost:5432/demo_db
camel.component.kafka.brokers=localhost:29092
# Quarkus HTTP (par defaut, le port utilisé par quarkus est 8080 qui est déjà utilisé que j'ai remplacé par 8081)
quarkus.http.port=8081
# Désactiver DevServices
quarkus.kafka.devservices.enabled=false
quarkus.log.category."org.apache.camel.component.kafka".level=DEBUG

Etape 4 : Créer la table PostgreSQL et le topic Kafka

Depuis pgAdmin ou psql créer la table “messages”:

CREATE TABLE messages (
   id SERIAL PRIMARY KEY,
   content VARCHAR(255) NOT NULL
);

Depuis Kafdrop ou le terminal, créer le topic “demo-topic”:

idiane@por-006:~/Documents/camel-quarkus-test$ docker exec -it kafka kafka-topics --bootstrap-server localhost:29092 --create --topic demo-topic --partitions 1 --replication-factor 1

Etape 5 : Implémenter les routes Camel

Créer le fichier dans src/main/java/com/example/routes/DemoRoute.java :

package com.example.routes;
import org.apache.camel.CamelContext;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.kafka.KafkaComponent;
import org.apache.camel.model.dataformat.JsonLibrary;
import jakarta.annotation.PostConstruct;
import jakarta.inject.Inject;

public class CamelRoute extends RouteBuilder {
   @Override
   public void configure() throws Exception {
       // --- REST : Ajouter un message ---
       rest("/messages")
           .post()
               .consumes("application/json").produces("application/json")
               .to("direct:addMessage");

       from("direct:addMessage")
           .unmarshal().json(JsonLibrary.Jackson) // transforme JSON en Map
           .process(exchange -> {
               var body = exchange.getIn().getBody(java.util.Map.class);
               String content = (String) body.get("content");
               exchange.getMessage().setHeader("content", content);
           })
           // republier dans Kafka
           .setBody(simple("{\"content\":\"${header.content}\"}"))
           .to("kafka:demo-topic?brokers=localhost:29092")
           .setBody(simple("{\"status\":\"saved\"}"));
       // --- Kafka → PostgreSQL ---
     from("kafka:demo-topic?brokers=localhost:29092&groupId=consumer1")
           .unmarshal().json(JsonLibrary.Jackson)
           .process(exchange -> {
               var body =   exchange.getIn().getBody(java.util.Map.class);
               String content = (String) body.get("content");
               exchange.getMessage().setHeader("content", content);
           })
           .setBody(simple("INSERT INTO messages (content) VALUES ('${header.content}')"))
           .to("jdbc:dataSource");
       // --- REST : Lister les messages ---
       rest("/messages")
           .get()
               .produces("application/json")
               .to("direct:listMessages");
       from("direct:listMessages")
           .setBody(constant("SELECT * FROM messages"))
           .to("jdbc:dataSource")
           .marshal().json(true);
   }
}

Etape 6 : Tester l’application

Démarrer les services :

idiane@por-006:~/Documents/camel-quarkus-test$ docker-compose up -d

Lancer quarkus en mode dev :

./mvnw quarkus:dev

Ajouter un message en ligne de commande ou avec postman via POST :

idiane@por-006:~/Documents/camel-quarkus-test$ curl -X POST http://localhost:8081/messages   -H "Content-Type: application/json"   -d '{"content":"Hello camel quarkus"}'

Vérifier le message posté dans le topic demo-topic et dans la table messages en ligne de commande. A noter que vous pouvez vérifier dans pgAdmin pour Postgres et Kafdrop pour kafka que les données apparaissent. :

idiane@por-006:~/Documents/camel-quarkus-test$ kafkacat -b localhost:29092 -t demo-topic -o -1 -c 1
% Auto-selecting Consumer mode (use -P or -C to override)
{"content":"Hello camel quarkus"}

On voit que le message a bien été publié dans le topic demo-topic

idiane@por-006:~/Documents/camel-quarkus-test$ psql -h localhost -U demo -d demo_db -c "SELECT * FROM messages ORDER BY id DESC LIMIT 1;"
Password for user demo: 
 id |       content       
----+---------------------
 15 | Hello camel quarkus
(1 row)

Lister les messages via GET :

idiane@por-006:~/Documents/camel-quarkus-test$ curl http://localhost:8081/messages
[ {
  "id" : 15,
  "content" : "Hello camel quarkus"
} ]

L’application Camel Quarkus démarre correctement.
Elle peut :

exécuter des routes Camel,
se connecter à Kafka (si un broker est présent sur localhost:9092),
être étendue pour accéder à une base de données SQL (Oracle, MySQL, etc.).*

5. Conclusion

Ce cas d’usage illustre concrètement comment Apache Camel, déployé sur Quarkus, permet de relier différents systèmes — ici une base de données PostgreSQL, un broker Kafka et une API REST — au sein d’un même flux d’intégration. Cette approche montre toute la puissance de Camel pour orchestrer les échanges de données tout en bénéficiant des performances et de la légèreté de Quarkus.

Dans un contexte où les entreprises cherchent à rendre leurs systèmes d’information plus flexibles, Apache Camel constitue une solution éprouvée pour gérer les échanges de données et les flux d’intégration entre applications.
Combiné à Quarkus, Camel bénéficie d’un environnement d’exécution moderne, optimisé pour le cloud et les microservices.

Cette association permet non seulement de développer rapidement des routes d’intégration performantes, mais aussi de les exécuter dans des environnements à forte contrainte de ressources (containers, Kubernetes, serverless, etc.).
L’approche “Camel Quarkus” concilie ainsi l’efficacité opérationnelle (démarrage rapide, faible empreinte mémoire) et la robustesse des patterns d’intégration issus des Enterprise Integration Patterns (EIP).

À travers les exemples présentés, on voit comment il devient possible de :

lire et transformer des données depuis différentes sources (fichiers, bases de données, API, Kafka)
orchestrer les flux via des routes Camel simples et réutilisables
exposer des services REST légers tout en s’appuyant sur une infrastructure moderne.

En résumé, Camel sur Quarkus illustre une approche pragmatique et évolutive pour moderniser les intégrations applicatives et accélérer la transition vers le cloud-native, tout en capitalisant sur les bonnes pratiques des architectures d’intégration.

Construire des applications d’intégration avec Camel sur Quarkus

1. Introduction

2. Mise en place de l’environnement

2.1. Installation de Maven

a. Vérifier Java

b. Télécharger et installer Maven

2.2. Installation de Docker

a. Installer Docker Engine

b. Vérifier l’installation

2.3. Installation des services via docker-compose

a. Création du fichier docker-compose.yml

b. Accès aux interfaces graphiques

c. Quelques commandes utiles

3. Développement d’applications avec Camel Quarkus

4. Cas pratique

Etape 5 : Implémenter les routes Camel

5. Conclusion

A propos de l'auteur: idiane

Laissez un commentaire Annuler la réponse

Articles Récents

FORMEZ-VOUS AUX MEILLEURES SOLUTIONS

Le Festival online de la data avec la #Synalteam

Inscrivez-vous pour recevoir notre newsletter

A propos de cookies

Construire des applications d’intégration avec Camel sur Quarkus

1. Introduction

2. Mise en place de l’environnement

2.1. Installation de Maven

a. Vérifier Java

b. Télécharger et installer Maven

2.2. Installation de Docker

a. Installer Docker Engine

b. Vérifier l’installation

2.3. Installation des services via docker-compose

a. Création du fichier docker-compose.yml

b. Accès aux interfaces graphiques

c. Quelques commandes utiles

3. Développement d’applications avec Camel Quarkus

4. Cas pratique

Etape 5 : Implémenter les routes Camel

5. Conclusion

A propos de l'auteur: idiane

Laissez un commentaire Annuler la réponse

Articles Récents

FORMEZ-VOUS AUX MEILLEURES SOLUTIONS

Le Festival online de la data avec la #Synalteam

Inscrivez-vous pour recevoir notre newsletter