Activation des migrations de bases de données à l’aide de Kubernetes Init

Liquibase est une bibliothèque open source indépendante de la base de données pour le suivi, la gestion et l’application des modifications de la base de données. Il permet aux développeurs de contrôler les versions de leurs modifications de base de données et de les déployer facilement de manière contrôlée et prévisible.

Kubernetes, quant à lui, est un système d’orchestration de conteneurs open source qui automatise le déploiement, la mise à l’échelle et la gestion des applications conteneurisées.

Lors du déploiement d’une application conteneurisée sur Kubernetes, il est courant d’utiliser un conteneur init pour effectuer toutes les tâches de configuration nécessaires avant le démarrage du conteneur d’application principal. Cela peut inclure des tâches telles que l’installation de dépendances, la configuration de variables d’environnement ou l’exécution de migrations de bases de données.

Dans cet article, nous allons vous montrer comment configurer un conteneur init dans Kubernetes pour exécuter des migrations Liquibase sur votre base de données.

Configuration de Liquibase

Pour utiliser Liquibase dans un conteneur init, nous devons d’abord créer une image Docker qui contient l’outil Liquibase et toutes les dépendances nécessaires, comme un pilote JDBC pour la base de données. Le fichier Dockerfile suivant peut être utilisé pour créer une image qui inclut Liquibase et le pilote MySQL JDBC :

FROM openjdk:8-jdk-alpine

RUN apk add --update bash curl

ENV LIQUIBASE_VERSION=4.1.1

RUN curl -L https://github.com/liquibase/liquibase/releases/download/v${LIQUIBASE_VERSION}/liquibase-${LIQUIBASE_VERSION}.tar.gz \
    | tar -xz -C /opt \
    && ln -s /opt/liquibase-${LIQUIBASE_VERSION}/liquibase /usr/local/bin/liquibase

RUN curl -L https://repo1.maven.org/maven2/mysql/mysql-connector-java/8.0.22/mysql-connector-java-8.0.22.jar \
    -o /opt/mysql-connector-java-8.0.22.jar

Avant de commencer, assurez-vous que vous disposez des prérequis suivants :

• Un cluster Kubernetes configuré et en cours d’exécution
• Une base de données s’exécutant dans un conteneur séparé ou sur un hôte séparé
• Un projet Liquibase mis en place pour votre application

Voici les étapes que vous devez suivre :

1. Créez un nouveau déploiement Kubernetes pour votre application. Dans la définition de déploiement, spécifiez le conteneur d’initialisation et le conteneur d’application principal.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      initContainers:
      - name: liquibase
        image: liquibase/liquibase:latest
        env:
        - name: LIQUIBASE_URL
          value: jdbc:postgresql://my-database:5432/my-database
        - name: LIQUIBASE_USERNAME
          value: my-user
        - name: LIQUIBASE_PASSWORD
          value: my-password
        command: ["liquibase", "update"]
        volumeMounts:
        - name: liquibase-config
          mountPath: /liquibase/
      - name: my-app
        image: my-app:latest
        ports:
        - containerPort: 8080
        env:
        - name: DATABASE_URL
          value: jdbc:postgresql://my-database:5432/my-database
        - name: DATABASE_USERNAME
          value: my-user
        - name: DATABASE_PASSWORD
          value: my-password
      volumes:
      - name: liquibase-config
        configMap:
          name: liquibase-config

2. Créez une configMap pour stocker les fichiers de configuration de Liquibase.

apiVersion: v1
kind: ConfigMap
metadata:
  name: liquibase-config
data:
  liquibase.properties: |
    changeLogFile: /liquibase/changelog.xml
    driver: org.postgresql.Driver
    classpath: /liquibase/postgresql-42.2.18.jar

3. Exécutez le déploiement sur votre cluster Kubernetes.

kubectl apply -f my-app-deployment.yaml

Validation

Dans Liquibase, vous pouvez utiliser la table du journal des modifications de Liquibase pour valider si vos migrations de base de données ont réussi.

Dans Liquibase, un journal des modifications est un ensemble d’ensembles de modifications décrivant les modifications à apporter à la base de données. Chaque ensemble de modifications est une modification unique et atomique de la base de données, telle que l’ajout d’une nouvelle table, la modification d’une colonne existante ou l’exécution d’un script SQL.

Lorsque Liquibase s’exécute, il garde une trace des ensembles de modifications qui ont été exécutés dans la base de données en stockant des informations dans une table spéciale appelée la table DATABASECHANGELOG. Cette table contient un enregistrement pour chaque ensemble de modifications qui a été exécuté, y compris l’ID unique, l’auteur et la date d’exécution de la modification.

Par défaut, la table DATABASECHANGELOG est créée dans le même schéma que le reste de la base de données, mais son nom et son schéma peuvent être personnalisés.

Voici un exemple de structure de table DATABASECHANGELOG :

ID                 | VARCHAR(255)      | NOT NULL
AUTHOR              | VARCHAR(255)      | NOT NULL
FILENAME            | VARCHAR(255)      | NOT NULL
DATEEXECUTED        | TIMESTAMP         | NOT NULL
ORDEREXECUTED       | INT               | NOT NULL
EXECTYPE            | VARCHAR(10)       | NOT NULL
MD5SUM              | VARCHAR(35)       | 
DESCRIPTION         | VARCHAR(255)      |
COMMENTS            | VARCHAR(255)      |
TAG                 | VARCHAR(255)      |
LIQUIBASE           | VARCHAR(20)       |

Vous pouvez interroger la table DATABASECHANGELOG pour voir quels ensembles de modifications ont été exécutés et dans quel ordre. De plus, vous pouvez également utiliser l’outil de ligne de commande Liquibase pour générer des rapports sur l’état actuel de la base de données, y compris une liste de tous les ensembles de modifications exécutés et de toutes les modifications en attente qui n’ont pas encore été appliquées.

Restauration de Liquibase

Dans Liquibase, il est possible d’annuler un ensemble de modifications spécifique qui a déjà été appliqué à la base de données. Cela peut être utile dans les cas où une erreur a été commise lors d’une modification précédente ou si vous souhaitez annuler une modification dans un environnement de développement ou de test.

Pour annuler un ensemble de modifications dans Liquibase, vous pouvez utiliser la commande « rollback » et spécifier l’ID de l’ensemble de modifications que vous souhaitez annuler. La commande de restauration annulera les modifications apportées par l’ensemble de modifications spécifié et mettra à jour la table DATABASECHANGELOG pour refléter la modification.

Voici un exemple montrant comment annuler un ensemble de modifications portant l’ID « 12345 » à l’aide de l’outil de ligne de commande Liquibase :

Dans Kubernetes, pour annuler un ensemble de modifications, vous devrez créer un nouveau déploiement avec la commande rollback et l’appliquer au cluster.

Voici un exemple d’annulation d’un ensemble de modifications portant l’ID « 12345 » dans Kubernetes :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-rollback
spec:
  selector:
    matchLabels:
      app: my-app-rollback
  template:
    metadata:
      labels:
        app: my-app-rollback
    spec:
      initContainers:
      - name: liquibase-rollback
        image: liquibase/liquibase:latest
        env:
        - name: LIQUIBASE_URL
          value: jdbc:postgresql://my-database:5432/my-database
        - name: LIQUIBASE_USERNAME
          value: my-user
        - name: LIQUIBASE_PASSWORD
          value: my-password
        command: ["liquibase", "rollback", "12345"]
        volumeMounts:
        - name: liquibase-config
          mountPath: /liquibase/
      volumes:
      - name: liquibase-config
        configMap:
          name: liquibase-config

Il convient de noter qu’en fonction des modifications apportées par l’ensemble de modifications, son annulation peut ne pas être simple et peut avoir un impact sur d’autres parties de la base de données, par exemple, si l’ensemble de modifications crée une table, son annulation supprimera la table et tous les données à l’intérieur. il est important de tester la restauration dans un environnement de développement avant de l’appliquer à la production.

En conclusion, l’utilisation d’un conteneur init dans Kubernetes pour exécuter des migrations de base de données Liquibase est un moyen pratique et efficace de gérer et de versionner les modifications de base de données. Il permet aux développeurs de suivre et d’annuler facilement les modifications et garantit que la base de données est dans le bon état avant le démarrage de l’application principale.