Application Java Quarkus fonctionnant avec IRIS

À titre d'exemple d'application en Java fonctionnant avec le dialecte Hibernate pour IRIS, je souhaitais utiliser l'application RealWorld et j'ai trouvé une réalisation pour Quarkus. L'application RealWorld est un exemple d'application proche d'une application réelle, avec des tests déjà préparés pour le backend. La plupart des exemples de réalisations sont à retrouver ici

L'exemple d'application RealWorld est souvent appelé « Wikipédia pour la création d'applications full-stack ». Il sert de prototype standardisé que les développeurs peuvent utiliser pour créer des applications à l'aide de divers langages et frameworks de programmation. L'application fournit un cas d'utilisation réel en imitant une plate-forme de blogs, avec des fonctionnalités telles que l'authentification des utilisateurs, la gestion des profils, la publication d'articles et les commentaires. Avec un ensemble complet de spécifications, y compris une documentation d'API backend prête à l'emploi et des conceptions frontend, il permet aux développeurs de voir comment les mêmes exigences fonctionnelles sont mises en œuvre dans différentes piles technologiques. L'exemple RealWorld est largement utilisé comme outil d'apprentissage et comme référence pour comparer diverses technologies.

Quarkus

Quarkus est un framework Java open source natif de Kubernetes, conçu pour GraalVM et HotSpot. Créé dans le but d'améliorer l'environnement cloud natif moderne, il réduit considérablement l'empreinte et le temps de démarrage des applications Java. Quarkus est connu pour sa philosophie « privilégiant le conteneur », permettant aux développeurs de créer des applications légères et performantes en mettant l'accent sur l'architecture des microservices. Cette flexibilité en a fait un choix populaire pour les organisations cherchant à passer à des plates-formes sans serveur ou basées sur le cloud, combinant des modèles de programmation impératifs et réactifs. Qu'il s'agisse d'une application Web traditionnelle ou d'un système complexe de microservices, Quarkus fournit une plate-forme robuste pour créer des logiciels évolutifs et maintenables.

La réalisation originale du projet peut être trouvée ici : https://github.com/diegocamara/realworld-api-quarkus. Il embarque la base de données mémoire H2 pendant les tests et PostgreSQL lors de l'exécution réelle. Et utilise Quarkus version 2.

J'ai eu besoin de le mettre à niveau vers la dernière version de Quarkus 3, qui utilise la dernière version d'Hibernate 6.

Configurer pour IRIS

Ensuite, nous pouvons ajouter le pilote InterSystems JDBC, ce projet utilise Maven, nous devons donc changer pom.xml. Pour pouvoir utiliser le pilote JDBC InterSystems, nous devons ajouter un lien vers le référentiel GitHub où il est stocké.

<repositories>
    <repository>
        <id>InterSystems IRIS DC Git Repository</id>
        <url>https://raw.githubusercontent.com/intersystems-community/iris-driver-distribution/main/JDBC/JDK18/</url>
        <snapshots>
            <enabled>true</enabled>
            <updatePolicy>always</updatePolicy>
        </snapshots>
    </repository>
</repositories>

Et ajoutez le pilote en tant que dépendance

<dependency>
    <groupId>com.intersystems</groupId>
    <artifactId>intersystems-jdbc</artifactId>
    <version>3.7.1</version>
</dependency>

Et il ne reste que le dialecte Hibernate. Et grâce à @Yuri Marx nous pouvons l'installer de cette façon

<dependency>
	<groupId>io.github.yurimarx</groupId>
	<artifactId>hibernateirisdialect</artifactId>
	<version>1.0.0</version>
</dependency>

Il est maintenant temps de passer les tests avec IRIS. La connectivité de la base de données dans les tests est implémentée dans le fichier DatabaseIntegrationTest.java. Il suffit de passer à IRIS depuis H2 à quelques endroits

  private static Properties properties() {
    Properties properties = new Properties();
    properties.put(Environment.DRIVER, "com.intersystems.jdbc.IRISDriver");
    properties.put(Environment.DIALECT, "io.github.yurimarx.hibernateirisdialect.InterSystemsIRISDialect");
    properties.put(Environment.SHOW_SQL, true);
    properties.put(Environment.FORMAT_SQL, true);
    properties.put(Environment.CURRENT_SESSION_CONTEXT_CLASS, "thread");
    properties.put(Environment.HBM2DDL_AUTO, "create-drop");
    properties.put(Environment.DATASOURCE, dataSource);
    return properties;
  }

Et lors de la création réelle de DataSource, où nous définissons l'hôte, le port, l'espace de noms et les informations d'identification pour accéder à IRIS, à l'aide d'IRISDataSource à partir du pilote JDBC.

  private static DataSource dataSource() {
    IRISDataSource jdbcDataSource = new IRISDataSource();
    jdbcDataSource.setServerName("localhost");
    jdbcDataSource.setPortNumber(5572);
    jdbcDataSource.setDatabaseName("USER");
    jdbcDataSource.setUser("_SYSTEM");
    jdbcDataSource.setPassword("SYS");
    return jdbcDataSource;
  }

La fonction clear, nécessite de petites modifications pour suivre la syntaxe IRIS SQL, afin de nettoyer les données avant tout test sans aucune vérification.

  public void clear() {
    transaction(
        () ->
            entities.forEach(
                tableName ->
                    entityManager
                        .createNativeQuery("TRUNCATE TABLE %NOCHECK " + tableName)
                        .executeUpdate()));
  }

Démarrer IRIS avec docker-compose

docker-compose up -d

Et nous sommes prêts à exécuter des tests. Il existe deux façons d'exécuter des tests pour les applications Quarkus, en utilisant Quarkus cli ou avec Maven, en supposant que Java version 17 ou 20 est déjà installé.

./mvnw clean test 

La première exécution prendra du temps, du fait du téléchargement de toutes les dépendances. Mais à la fin, cela devrait se terminer, avec une série de tests réussis. Pendant l'exécution, il affichera toutes les requêtes SQL exécutées sur IRIS.

[INFO] 
[INFO] Results:
[INFO] 
[INFO] Tests run: 41, Failures: 0, Errors: 0, Skipped: 0
[INFO] 
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  33.405 s
[INFO] Finished at: 2023-08-15T18:37:05+04:00
[INFO] ------------------------------------------------------------------------

Lorsque nos tests sont réussis, nous sommes prêts à exécuter le serveur et pour ce faire, nous devons également basculer l'application elle-même vers IRIS. Pour ce faire, nous devons modifier le fichier application.properties avec les nouvelles valeurs.

quarkus.datasource.db-kind=other
quarkus.datasource.jdbc.url=jdbc:IRIS://localhost:5572/USER
quarkus.datasource.jdbc.driver=com.intersystems.jdbc.IRISDriver
quarkus.datasource.username=_SYSTEM
quarkus.datasource.password=SYS
quarkus.hibernate-orm.dialect=io.github.yurimarx.hibernateirisdialect.InterSystemsIRISDialect

Pour démarrer le serveur, utilisez cette commande

./mvnw compile quarkus:dev

Et maintenant, nous pouvons exécuter des tests originaux, issus du projet RealWorld, pour tester l'API à l'aide de newman. Nécessite un deuxième terminal

./collections/run-api-tests.sh

Et tous les tests ont réussi

┌─────────────────────────┬────────────────────┬────────────────────┐
│                         │           executed │             failed │
├─────────────────────────┼────────────────────┼────────────────────┤
│              iterations │                  1 │                  0 │
├─────────────────────────┼────────────────────┼────────────────────┤
│                requests │                 31 │                  0 │
├─────────────────────────┼────────────────────┼────────────────────┤
│            test-scripts │                 46 │                  0 │
├─────────────────────────┼────────────────────┼────────────────────┤
│      prerequest-scripts │                 17 │                  0 │
├─────────────────────────┼────────────────────┼────────────────────┤
│              assertions │                280 │                  0 │
├─────────────────────────┴────────────────────┴────────────────────┤
│ total run duration: 19.8s                                         │
├───────────────────────────────────────────────────────────────────┤
│ total data received: 7.63kB (approx)                              │
├───────────────────────────────────────────────────────────────────┤
│ average response time: 121ms [min: 10ms, max: 969ms, s.d.: 168ms] │
└───────────────────────────────────────────────────────────────────┘

Nous disposons désormais d'une application Java qui utilise IRIS comme source de données.

Intégration continue

L'ensemble du processus de migration ne vaudrait pas la peine sans tests automatisés. Heureusement, le projet original implémentait déjà GitHub Actions, en utilisant PostgreSQL, et il nous suffit de le basculer vers IRIS.

Les images Docker d'InterSystems IRIS Community Edition avec IPM, intersystemsdc, prennent en charge l'utilisation de variables d'environnement pour définir les informations d'identification, grâce à cette capacité, il est très facile d'utiliser IRIS dans des tests comme dans cette application. Nous pouvons donc simplement remplacer un service existant par un nouveau, définir le nom d'utilisateur, le mot de passe et l'espace de noms. GitHub Actions utilisera cette image Docker pour créer un conteneur afin de l'exécuter lorsque les tâches réelles sont exécutées. Et le reste du workflow GitHub Actions reste le même.

    services:
      iris:
        image: intersystemsdc/iris-community
        ports:
          - 5572:1972
        env:
          IRIS_USERNAME: _SYSTEM
          IRIS_PASSWORD: SYS
          IRIS_NAMESPACE: REALWORLD

Nous disposons désormais d'une application entièrement migrée vers IRIS. Grâce à la nature native Kubernetes de l'application Quarkus et à la prise en charge d'IRIS Kubernetes, il est facile de la déployer.

Le code modifié est disponible sur OpenExchange et sur le repo GitHub. À vous d'essayer.