Tuto conteneuriser une application : l'exemple de Redmine

Prérequis pour conteneuriser une application

Avant de commencer à vouloir conteneuriser quoi que ce soit, il est important d'être à l'aise avec l'environnement Docker. Si ce n'est pas le cas, pas de panique, on a fait plusieurs articles à ce sujet, que l'on vous conseil de checker avant de revenir ici.

Créer un backup des données sensibles

C'est parti ! Dans un premier temps, avant de penser à couper l'application, les serveurs ou les bases de données, il est primordial de penser à créer des backups des données pouvant être impactées pendant les opérations. (Ça serait dommage de tout perdre en route…)

Pour se faire :

1. Avec la commande tar, on sauvegarde dans un premier temps les fichiers à conserver tel que les assets, les fichiers de configuration de l'application, ou encore les fichiers spécifiques comme les plugins ou les "files" de Redmine.
2. Ensuite, grâce à la commande mysqldump, on créé un backup de notre base de données reliée à notre application (MySql, Postgres, Sqlite, …)

Voici à quoi devrait ressembler ces deux commandes :

tar -czf path_to_redmine.tar.gz path_to_redmine_files
mysqldump -u <username> -p<password> -h <hostname> <database> > path_to_backup_redmine.sql

Trouver une image Docker pour son application

Félicitations, vos données sont désormais en sécurité ! Maintenant, on va pouvoir commencer à transférer notre application Redmine dans un container.

Pour se faire, il va nous falloir trouver à la fois une image Docker pour l'application, et une pour la base de données. Attention à bien prendre une image dont la version correspond avec celle de votre application et de votre base de données. Par exemple, si vous avez une application Redmine 5.0.5, il faut prendre une image docker redmine:5.0.5

Prenez de préférence l'image officielle de Redmine publiée sur le DockerHub. Les images officielles sont mises à jour plus régulièrement (maintenance, sécurité, montée de version…) et contiennent généralement une meilleure documentation.

Voici quelques liens pour les retrouver :

• https://hub.docker.com/_/redmine/
• https://hub.docker.com/_/mysql

Maintenant que l'on a nos images Docker, il ne reste plus qu'à y transférer les donnés de notre application.

Transférer son application dans un container, et l'exécuter

Désormais, pour transférer les données de notre application dans les images Docker que nous avons trouvées, il suffit d'exécuter les conteneurs.

Étant donné que dans notre cas, nous avons plusieurs container (un pour Redmine, et un pour la base de données), on se retrouve donc avec une application dite "multi-conteneurs". Le mieux pour ce genre de situation, est d'utiliser l'outil Docker Compose, qui permet de définir et de lancer les conteneurs à partir d'un fichier YAML, et ce, via une seule commande.

Vous pouvez retrouver la documentation officielle de docker compose ici : https://docs.docker.com/compose/

À noter : Dans le cas d'une application plus complexe ou ne disposant pas d'image : il convient de build sa propre image docker à partir d'instruction, comme par exemple via un Dockerfile.

Voici comment configurer ces fameux fichiers YAML pour Docker Compose :

Configurer MySql

Pour une base de données standard avec les données sauvegardées précédemment :

services:
  mysql:
    image: mysql:8.0 # Version de MySql souhaité
    restart: always
    ports: # Redirection des ports host:container
      - 3306:3306
    expose: # Exposition des ports au services du network
      - 3306
    volumes: # Permet de restaurer les données du path_to_backup_redmine.sql
      - ./mysql-dump:/docker-entrypoint-initdb.d
    environment: # Définition des utilisateurs mysql
      MYSQL_ROOT_PASSWORD: root_password
      MYSQL_DATABASE: redmine_database
      MYSQL_USER: redmine_user
      MYSQL_PASSWORD: mysql_password

Redmine

Pour l'application Redmine avec la base de données précédemment configuré :

redmine:
    image: redmine # Version de redmine souhaitée
    restart: always
    expose: # Exposition des ports au services du network
      - 8080
    ports: # Redirection des ports host:container
      - 8080:3000
    volumes: # Permet de partager les fichiers locaux avec le conteneur notamment les assets pour redmine
      - ./redmine/files:/usr/src/redmine/files
    environment: # Définition des variable d'environnement redmine
      REDMINE_DB_MYSQL: mysql
      REDMINE_DB_PASSWORD: mysql_password
      REDMINE_DB_USERNAME: redmine_user
      REDMINE_SECRET_KEY_BASE: redmine_key
    depends_on: # Passage de redmine dans la file d'attente à exécuter
      - mysql

Fichier final

Voici à quoi devrait ressembler votre fichier YAML final :

version: '3.1'

services:

  mysql:
    image: mysql:8.0
    restart: always
    ports:
      - 3306:3306
    expose:
      - 3306
    volumes:
      - ./mysql-dump:/docker-entrypoint-initdb.d
    environment:
      MYSQL_ROOT_PASSWORD: root_password
      MYSQL_DATABASE: redmine_database
      MYSQL_USER: redmine_user
      MYSQL_PASSWORD: mysql_password

  redmine:
    image: redmine
    restart: always
    expose:
      - 8080
    ports:
      - 8080:3000
    volumes:
      - ./redmine/files:/usr/src/redmine/files
    environment:
      REDMINE_DB_MYSQL: mysql
      REDMINE_DB_PASSWORD: mysql_password
      REDMINE_DB_USERNAME: redmine_user
      REDMINE_SECRET_KEY_BASE: redmine_key
    depends_on:
      - mysql

On y est presque ! Maintenant que votre fichier YAML est prêt, il ne vous reste plus qu'à exécuter la commande docker-compose up -d . Elle permet de lancer l'application et de générer les fichiers nécessaires.

Félicitations, vous avez conteneurisé votre application ! Désormais, pour la détruire, il vous suffit d'exécuter la commande docker-compose down

Tester son conteneur avec Docker

Ne crions pas victoire trop tôt pour autant, maintenant que l'application est lancée, il s'agit de la tester, pour vérifier que tout fonctionne parfaitement. Pour cela, la première chose à faire est de vérifier le statut de vos conteneurs.

• Pour se faire, vérifiez le statut "running" des conteneurs via la commande docker ps ou via un Docker Desktop : 

  

• Testons désormais la connexion à la base de données. Accédez à votre base via le CLI MySQLMoteur de gestion de base de données. ou un outil d'administration de base de données tel que DBeaver : 

  

Vérifiez que vos tables sont bien présentes, et que les données sont là.

• Enfin, testez l'accès à l'application en local via l'URL : localhost:8080 
  

Étape finale : ajouter ses fichiers à son conteneur Docker

Il est maintenant possible d'explorer votre application : accéder au shell, explorer les fichiers, etc.

Pour se faire, il vous suffit de vous connecter au conteneur avec la commande suivante :

docker exec -u 0 -it <_conteneur_id> bash # le -u 0 permet de se connecter en root (user par défaut)

Maintenant que nous pouvons explorer l'application, il est temps de récupérer les fichiers sauvegardés précédemment et de les ajouter à notre conteneur. Pour cela, vous trouverez dans le répertoire courant de votre application, un dossier nommé "redmine", qui contient tous les fichiers nécessaires à l'application. Vous pouvez y placer vos fichiers, par exemple vos différents assets, afin qu'ils soient inclus à votre conteneur.

Cette fois, promis, votre application est officiellement conteneurisée, et complètement fonctionnelle !

Environnement et versions de Docker

Voici, à titre indicatif, les différentes versions des outils qui ont été utilisés durant ce tuto :

> lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 22.04.2 LTS
Release:        22.04
Codename:       jammy

> docker -v
Docker version 24.0.5, build ced0996

> docker-compose -v
Docker Compose version v2.20.2-desktop.1

Besoin d'aide ou de plus de précisions ? AXOPEN peut vous accompagner dans la conteneurisation et le déploiement de vos applications, alors n'hésitez pas à nous contacter !