Mehdi Dadah - Architecte logiciel et artisan des solutions innovantes

Dans un monde où les applications évoluent rapidement et où les changements de code sont fréquents, maintenir la synchronisation entre le code et la base de données devient un défi majeur. Imaginez déployer une nouvelle fonctionnalité sans vous soucier des erreurs de compatibilité de la base de données, ou restaurer l'état précédent d'une base de données après un incident en quelques clics. C'est là que le versioning de base de données entre en jeu. Dans cet article, nous plongerons dans l'univers de Liquibase, un outil puissant et open-source pour le versioning des bases de données. Vous découvrirez comment cet outil peut transformer la façon dont vous gérez les schémas de vos bases de données, simplifiant ainsi les déploiements, les mises à jour et la collaboration au sein de votre équipe de développement. Nous vous guiderons étape par étape, de la configuration initiale à l'intégration continue, en passant par des exemples pratiques qui illustrent les bonnes pratiques et les avantages d'une telle approche. Prêt à révolutionner votre gestion des bases de données ? Lisez la suite pour découvrir comment Liquibase peut devenir votre allié indispensable.

Liquibase et le versioning de base de données

Pourquoi versionner sa base de données ?

Le versioning de base de données permet de maintenir la synchronisation entre le code de l'application et la structure de la base de données. Voici quelques avantages clés :

Cohérence entre le code et la base de données : Assurez-vous que les modifications de la base de données sont toujours alignées avec les changements de code.
Suivi des modifications : Gardez une trace des changements apportés à la base de données au fil du temps.
Collaboration améliorée : Facilitez la collaboration entre les membres de l'équipe en partageant les scripts de modification.
Déploiement simplifié : Automatisez les mises à jour de la base de données lors des déploiements.

Les solutions existantes

Petit à petit, des outils sont apparus comme Liquibase, Flyway ou DBMaintain, afin d’apporter des solutions au versioning des bases de données. Ceux-ci possèdent des caractéristiques communes comme :

Destruction et construction d’un schéma.
Identification de la version du schéma.
Connaissance des changements appliqués par le passé.
Vérification de l’intégration des scripts exécutés.
Impossibilité d’appliquer des changements ayant déjà été exécutés.

À partir de cela, il est alors possible de recréer un état de la base de données en accord avec le code de manière répétable. Grâce à ces fonctionnalités, on aperçoit déjà la possibilité d’inclure des tests unitaires sur la base de données.

Voici un tableau comparatif entre les solutions disponibles à ce jour et les fonctionnalités dont chacune dispose

Solutions	Clean	Upgrade	Rollback	Checksum	Compare
Flyway	Yes	Yes	No	Yes	No
Liquibase	Yes	Yes	Yes	Yes	Yes
DbMaintain	Yes	Yes	No	No	No

Présentation de Liquibase

Liquibase est un outil open-source qui permet de gérer les versions de la base de données en utilisant des fichiers de configuration appelés changeLogs. Ces fichiers contiennent des changeSets, chaque changeSet représentant une modification unique de la base de données.

Fonctionnalités principales

Traçabilité des changements : Suivez les modifications apportées à la base de données.
Rollback : Annulez facilement les changements en cas de besoin.
Intégration continue : Intégrez Liquibase dans votre pipeline de CI/CD pour des mises à jour automatisées.
Compatibilité multiplateforme : Fonctionne avec diverses bases de données comme PostgreSQL, MySQL, Oracle, Sybase ASE, etc.

Exemple pratique : Mise en place de Liquibase avec PostgreSQL

Pour illustrer l'utilisation de Liquibase, nous allons configurer un projet avec PostgreSQL dans un conteneur Docker et utiliser Liquibase pour gérer les versions de notre base de données.

Configuration Docker

Voici le fichier docker-compose.yml pour lancer PostgreSQL :

version: '3.1'

services:
  postgres:
    image: postgres:13
    container_name: postgres
    environment:
      POSTGRES_DB: demo
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
    - "5434:5432"

Pour démarrer le conteneur, exécutez la commande suivante :

docker-compose up -d

Configuration de Liquibase

Ensuite, configurons Liquibase pour se connecter à notre base de données PostgreSQL. Voici le contenu de notre fichier liquibase.properties :

changeLogFile=src/main/resources/db/changelog/db.changelog-master.xml
url=jdbc:postgresql://localhost:5434/demo
username=postgres
password=postgres
driver=org.postgresql.Driver

Intégration de Liquibase avec Maven

Ajoutez les dépendances Liquibase et PostgreSQL dans votre fichier pom.xml :

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://www.maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>io.dev.med</groupId>
        <artifactId>db-migration</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <artifactId>liquibase</artifactId>
    <name>Archetype - liquibase</name>
    <url>http://maven.apache.org</url>

    <properties>
        <liquibase.version>4.28.0</liquibase.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.liquibase</groupId>
            <artifactId>liquibase-core</artifactId>
            <version>${liquibase.version}</version>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>42.7.3</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.liquibase</groupId>
                <artifactId>liquibase-maven-plugin</artifactId>
                <version>${liquibase.version}</version>
                <configuration>
                    <propertyFile>src/main/resources/liquibase.properties</propertyFile>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Exemple de ChangeLog

Créez un fichier db.changelog-master.xml pour gérer vos changelogs. Voici un exemple incluant des changements dans les dossiers changelog-1.x et changelog-2.x :

<?xml version="1.0" encoding="UTF-8"?>
<databaseChangeLog
  xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog
        http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.8.xsd">

  <includeAll path="db/changelog/changelog-1.x" />
  <includeAll path="db/changelog/changelog-2.x" />
</databaseChangeLog>

Créez un fichier changelog-1.x/001-create-person-table.xml pour un exemple de changeSet :

<?xml version="1.0" encoding="UTF-8"?>
<databaseChangeLog
  xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog
        http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.8.xsd">

  <changeSet id="1" author="mdadah">
    <createTable tableName="person">
      <column name="id" type="int">
        <constraints primaryKey="true" nullable="false"/>
      </column>
      <column name="title" type="char(1)"/>
      <column name="first_name" type="varchar(50)"/>
      <column name="last_name" type="varchar(50)"/>
      <column name="birth_date" type="date"/>
      <column name="email" type="varchar(50)"/>
    </createTable>
  </changeSet>
</databaseChangeLog>

Et un fichier changelog-2.x/001-create-procedure.xml pour la procédure stockée :

<?xml version="1.0" encoding="UTF-8"?>
<databaseChangeLog
  xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog
        http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.8.xsd">

  <changeSet id="1" author="mdadah">
    <sql>
      DROP FUNCTION IF EXISTS sp_get_person();
    </sql>
    <createProcedure
      dbms="postgresql"
      schemaName="public"
      procedureName="sp_get_person">
      CREATE OR REPLACE FUNCTION sp_get_person()
      RETURNS TABLE(id int, first_name varchar, last_name varchar, birth_date date, email varchar, title char) AS $$
      BEGIN
      RETURN QUERY SELECT * FROM person;
      END $$
      LANGUAGE plpgsql;
    </createProcedure>
  </changeSet>
</databaseChangeLog>

Exécution de Liquibase

Pour exécuter Liquibase et appliquer les changements, utilisez la commande Maven suivante :

mvn liquibase:update

Bonnes pratiques pour le versioning de la base de données

Structuration des dossiers : Organisez vos fichiers de changelog dans des dossiers spécifiques par version (changelog-1.x, changelog-2.x, etc.). Cela permet de gérer et de suivre facilement les changements au fil du temps.
Utilisation de tags : Utilisez des tags pour marquer des points spécifiques dans l'historique des migrations. Cela peut aider à identifier les versions stables ou les releases importantes.
Validation des migrations : Testez les migrations dans un environnement de développement avant de les appliquer à la production. Utilisez des environnements de test identiques à la production pour éviter les surprises.
Documentation : Documentez chaque changeSet avec des commentaires clairs pour expliquer les raisons des changements. Cela facilitera la maintenance et la compréhension du code par d'autres développeurs.
Automatisation : Intégrez Liquibase dans votre pipeline CI/CD pour automatiser l'application des migrations de base de données. Cela garantit que les changements sont appliqués de manière cohérente et fiable.
Sécurité : Évitez de stocker des informations sensibles (comme les mots de passe) en clair dans les fichiers de configuration. Utilisez des variables d'environnement ou des outils de gestion de secrets pour sécuriser vos informations.

Conclusion

Liquibase est un outil puissant pour le versioning de bases de données, particulièrement utile dans des environnements où les bases de données évoluent rapidement. En combinant Liquibase avec Docker et Maven, vous pouvez facilement gérer les changements de schéma et assurer que votre base de données est toujours en synchronisation avec votre code applicatif.

En suivant ce guide, vous pourrez mettre en place un système de versioning de bases de données robuste et flexible, facilitant ainsi la gestion des modifications et assurant la cohérence entre votre code et votre base de données.