Comment installer et configurer MySQL dans Docker

Quant à l'utilisation de MySQL à l'intérieur des conteneurs Docker, eh bien, c'est tout simplement un match fait dans les nuages. Si vous avez déjà travaillé avec Docker, tous ses avantages s'appliquent également aux conteneurs MySQL :

• Isolement et cohérence : L'instance MySQL sera isolée des autres logiciels et dépendances, ce qui évitera les conflits potentiels.
• Contrôle des versions : Docker vous permet de versionner l'ensemble de votre pile logicielle en même temps que MySQL. Cela signifie que vous pouvez reproduire votre environnement à tout moment, ce qui facilite le développement et les tests.
• Évolutivité et gestion des ressources : Avec Docker, vous pouvez faire évoluer votre application MySQL en allouant facilement davantage de ressources telles que la mémoire ou le processeur.
• Gestion de la dépendance : Docker encapsule votre instance MySQL, ce qui vous permet d'en gérer différentes versions sans avoir à vous préoccuper de quoi que ce soit sur votre machine locale.

Et surtout, votre application MySQL fonctionnera partout, et pas seulement sur votre ordinateur.

Si vous souhaitez comparer MySQL à son deuxième concurrent le plus populaire ( ), consultez notre site PostgreSQL vs. MySQL comparison.

Aujourd'hui, vous apprendrez donc les principes fondamentaux de l'exécution de MySQL en tandem avec Docker. Commençons !

Conditions préalables

Comme cet article se concentre sur les conteneurs Docker MySQL, il comporte quelques prérequis pour le suivre :

• Ligne de commande/accès au terminal : vous avez besoin d'un environnement local avec accès au terminal. Si vous êtes dans un environnement Jupyter comme Colab, changez maintenant.
• Une instance Docker en cours d'exécution : vous devez avoir installé Docker Desktop (voir les instructions dans notre tutoriel Docker for Data Science). Lorsqu'il sera pleinement opérationnel, un bébé baleine vert figurera en bas à gauche de l'interface :

et la commande docker --help fonctionne sans erreur sur le terminal.

• Connaissance de base de Docker : même si j'expliquerai toutes les commandes utilisées dans l'article, une compréhension de base de Docker augmentera considérablement les avantages que vous pouvez tirer de cet article.
• SQL : il en va de même pour SQL - je n'expliquerai pas les commandes SQL utilisées dans cet article, car cela nous éloignerait du sujet principal. Si vos compétences en SQL sont un peu rouillées, vous pouvez revoir les sujets les plus importants de ce cours SQL.

Télécharger l'image Docker officielle de MySQL

Nous allons commencer par télécharger l'image Docker officielle de MySQL avec la commande suivante :

$ docker pull mysql:latest

docker pull requiert le nom et la version de l'image avec la syntaxe image:version. L'utilisation du mot-clé latest permet de télécharger la version stable la plus récente.

Si vous visitez la page officielle de l 'image MySQL sur Docker Hub, vous pouvez voir de nombreuses autres versions pour différents usages.

Voici comment télécharger la version 8.2, à titre d'exemple :

$ docker pull mysql:8.2

Une fois l'image téléchargée, elle devrait être listée parmi vos images Docker existantes :

Il est également possible de lister les images Docker à partir du terminal :

$ docker images

Rappelez-vous : Les images Docker sont des plans de construction de conteneurs. Tout comme un plan vous permet de construire une maison, une image Docker contient toutes les instructions et tous les composants nécessaires pour créer une instance opérationnelle d'une application ou d'un service.

Si vous venez d'un milieu OOP, considérez les images Docker comme des classes. Tout comme la création d'une classe unique vous permet de créer plusieurs objets, les images Docker vous permettent de créer plusieurs conteneurs à partir d'elles.

Exécution et gestion d'un conteneur de serveur MySQL

Maintenant, créons notre premier conteneur à partir de l'image mysql. Voici la commande que nous allons utiliser :

$ docker run --name test-mysql -e MYSQL_ROOT_PASSWORD=strong_password -d mysql

• run: crée un nouveau conteneur ou démarre un conteneur existant
• --name CONTAINER_NAME: donne un nom au conteneur. Le nom doit être lisible et court. Dans notre cas, le nom est test-mysql.
• -e ENV_VARIABLE=valuela balise -e crée une variable d'environnement qui sera accessible à l'intérieur du conteneur. Il est essentiel de définir MYSQL_ROOT_PASSWORD afin de pouvoir exécuter ultérieurement des commandes SQL à partir du conteneur. Veillez à conserver votre mot de passe fort dans un endroit sûr (pas dans votre cerveau).
• -d: abréviation de detached (détaché), la balise -d fait fonctionner le conteneur en arrière-plan. Si vous supprimez cette étiquette, la commande continuera d'imprimer les journaux jusqu'à ce que le conteneur s'arrête.
• image_name: le dernier argument est le nom de l'image à partir de laquelle le conteneur sera construit. Dans ce cas, notre image est mysql.

Si la commande renvoie une longue chaîne de caractères en charabia (l'ID du conteneur), cela signifie que le conteneur a démarré. Vous pouvez vérifier son état à l'adresse docker ps:

N'oubliez pas : un conteneur Docker est un puissant émulateur de système d'exploitation. Outre l'exécution de MySQL, vous pouvez effectuer n'importe quelle tâche que vous feriez normalement avec le terminal de votre ordinateur depuis le conteneur.

Pour accéder au terminal à l'intérieur de votre conteneur, vous pouvez utiliser la commande suivante :

$ docker exec -it container_name bash

Cela lancera une session bash.

Connexion locale au conteneur de serveur MySQL

Tous les conteneurs MySQL lancent un serveur MySQL qui comprend tout ce qu'il faut pour créer et gérer des bases de données à l'aide de SQL. Pour se connecter au serveur, les conteneurs sont également fournis avec un client MySQL qui nous permet d'exécuter des requêtes SQL. Le client n'est qu'un nom fantaisiste pour la commande mysql du terminal. Utilisons-le dans le terminal de test-mysql:

1. Ouvrez le terminal bash de test-mysql:

$ docker exec -it test-mysql bash

2. Connectez-vous au client en tant qu'utilisateur root :

$ mysql -u root -p
Enter password: ...
mysql>

Nous utilisons la balise -u pour spécifier le nom d'utilisateur (root) et nous ajoutons la balise -p pour saisir le mot de passe lorsqu'il est demandé.

Il est également possible de se connecter au serveur MySQL en dehors du conteneur. Par exemple, pour vous connecter à partir de votre machine hôte, vous pouvez installer manuellement le client MySQL dans votre système.

Pour installer MySQL et son client sous Windows, vous pouvez suivre les instructions du guide d'installation officiel de MySQL.

Pour Mac, vous pouvez utiliser Homebrew :

$ brew install mysql

Pour Linux ou WSL2 (mon choix), vous pouvez utiliser sudo:

$ sudo apt update
$ sudo apt install mysql-client

Après l'installation, si vous utilisez le conteneur, arrêtez-le et supprimez-le :

$ docker stop test-mysql
test-mysql
$ docker rm test-mysql

Ensuite, nous allons redémarrer le conteneur en faisant correspondre un port du conteneur à un port de notre machine locale :

$ docker run -d --name test-mysql -e MYSQL_ROOT_PASSWORD=strong_password -p 3307:3306 mysql

Cette commande permet d'effectuer les opérations suivantes :

• -p 3307:3306: Mapper le port 3306 du conteneur (le port par défaut pour MySQL) à votre port local 3307. Cela signifie que tout le trafic envoyé à votre port local 3307 sera transféré au port 3306 du conteneur et que votre serveur MySQL sera accessible sur ce port.
• -d: Exécute à nouveau le conteneur en mode détaché.
• --name test-mysql: Réutilise le même nom de conteneur "test-mysql".
• -e MYSQL_ROOT_PASSWORD=strong_password: Définit à nouveau le mot de passe de la racine pour le serveur MySQL.
• mysql: Spécifie l'image Docker à exécuter, qui est l'image officielle de MySQL.

Après que le terminal ait produit un nouvel identifiant pour le conteneur, nous pouvons vérifier les correspondances entre les ports :

$ docker port test-mysql
3306/tcp -> 0.0.0.0:3307

C'est un succès ! Maintenant, depuis votre machine locale, vous pouvez vous connecter au serveur sur le port 3307 en utilisant le client mysql:

$ mysql --host=127.0.0.1 --port=3307 -u root -p
Enter password:

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 8
Server version: 8.2.0 MySQL Community Server - GPL

Copyright (c) 2000, 2023, Oracle and/or its affiliates…

Configuration du conteneur MySQL

Vous pouvez configurer les conteneurs MySQL pour de nombreux paramètres à l'aide d'un fichier de configuration. En général, le fichier est stocké dans l'un des répertoires suivants du conteneur :

• /etc/mysql/
• /etc/mysql/conf.d
• /etc/mysql/mysql.conf.d

Les répertoires changent d'une image à l'autre. Mais le nom et l'extension standard d'un fichier de configuration sont my.cnf. Si le fichier n'existe dans aucun des répertoires listés ci-dessus, cela signifie que le conteneur a besoin d'un fichier de configuration personnalisé. C'est le cas de notre conteneur test-mysql:

$ ls /etc/mysql/conf.d/ # Returns no output

Dans de telles situations, nous devons prendre les mesures de précaution suivantes :

1. Arrêtez-vous et retirez le conteneur :

$ docker stop test-mysql; docker rm test-mysql

2. Créez un fichier de configuration vide localement (sur votre machine) :

$ sudo mkdir -p /etc/docker/test-mysql # Create a dir
$ sudo touch /etc/docker/test-mysql/my.cnf # Create a config file inside dir

3. Redémarrez le conteneur en reliant les deux fichiers .cnf vides :

$ docker run \
   --name test-mysql \
   -v /etc/docker/test-mysql:/etc/mysql/conf.d \
   -e MYSQL_ROOT_PASSWORD=strong_password \
   -d mysql

Nous sommes en train d'écrire un nouveau tag : -v qui est l'abréviation de volume. La balise peut être utilisée pour lier des répertoires entre le conteneur et la machine locale. Dans le jargon informatique, ce processus s'appelle le montage.

Ainsi, dans la commande ci-dessus, nous montons le répertoire local /etc/docker/test-mysql dans le répertoire /etc/mysql/conf.d du conteneur. Cela permettra de lier le contenu des deux répertoires. Toute modification apportée dans l'un ou l'autre de ces répertoires sera répercutée dans les deux.

Le montage nous permet d'éditer le fichier my.cnf sur notre machine locale pour modifier les configurations des conteneurs Docker. Et le plus beau, c'est que les configurations modifiées persistent dans notre machine locale même après l'arrêt ou la suppression du conteneur. Il sera réutilisable.

Après cette étape, quel type de configuration pouvons-nous modifier ? La réponse dépend de votre cas d'utilisation. Nous les aborderons ci-dessous.

Vous souhaitez obtenir la certification Docker ? Consultez notre guide pour obtenir une certification Docker!

Quelles options devez-vous configurer ?

Bien que la configuration par défaut des conteneurs MySQL Docker fonctionne pour de nombreux scénarios courants, vous devez modifier certains paramètres pour optimiser les performances, la sécurité et l'utilisation des ressources. Voici quelques-unes des options de configuration les plus couramment modifiées :

Performance

• innodb_buffer_pool_size: Ce paramètre détermine la quantité de mémoire allouée au pool de mémoire tampon InnoDB, qui met en cache les données fréquemment consultées afin de les récupérer plus rapidement. L'augmentation de cette valeur peut améliorer les performances pour les charges de travail lourdes en lecture, mais elle consomme également plus de mémoire.
• query_cache_size: Ce paramètre contrôle la taille du cache des requêtes, qui stocke les requêtes précédemment exécutées pour les réexécuter plus rapidement. L'augmentation de cette valeur peut améliorer les performances pour les requêtes répétitives, mais elle consomme également plus de mémoire et peut ne pas être efficace pour les requêtes dynamiques.
• Taille du pool de threads: Ce paramètre détermine le nombre maximum de connexions simultanées que le serveur peut gérer. En ajustant cette valeur en fonction de la charge de trafic prévue, vous pouvez optimiser l'utilisation des ressources et éviter les goulets d'étranglement.

Sécurité

• bind-address: Cette option permet au serveur MySQL de n'écouter que sur des interfaces réseau spécifiques, ce qui limite l'accès à des sources non autorisées.
• mysql_bind_host: Ce paramètre permet de lier le serveur MySQL à des adresses IP spécifiques au lieu d'écouter sur toutes les interfaces.
• validate_password_policy: Cette option permet d'imposer des exigences plus strictes en matière de mot de passe afin d'améliorer la sécurité.

Utilisation des ressources

• max_connections: Ce paramètre contrôle le nombre maximum de connexions simultanées autorisées. Le réglage de cette valeur permet d'éviter l'épuisement des ressources et d'assurer un fonctionnement efficace du serveur.
• innodb_file_per_table: Cette option permet de stocker chaque tableau InnoDB dans un fichier distinct, ce qui améliore potentiellement les performances mais augmente l'espace de stockage nécessaire.
• innodb_io_capacity: Cette option définit l'estimation des IOPS (opérations d'entrée/sortie par seconde) pour le système de stockage, ce qui permet au moteur d'optimiser l'utilisation du pool de mémoire tampon et les opérations sur le disque.

Autres modifications courantes

• character_set_server: Cette option définit le jeu de caractères par défaut pour le serveur, ce qui garantit un encodage et un traitement cohérents des données.
• collation_server: Cette option détermine les règles de collation par défaut utilisées pour le tri et la comparaison des données de caractères.
• log_bin: Cette option permet l'enregistrement binaire de l'activité du serveur, ce qui peut être utile pour le dépannage et la réplication.

Pour voir la liste complète des options de configuration, vous pouvez exécuter la commande suivante :

$ docker run -it --rm mysql:tag --verbose --help

Vous pouvez modifier le fichier .cnf avec n'importe quel éditeur de texte. Voici la syntaxe à suivre :

[mysqld]
max_connections=200
other_params=value
...

Comment préserver les données stockées dans le conteneur Docker MySQL ?

La persistance des données stockées dans vos conteneurs MySQL est cruciale pour de nombreuses raisons :

• Persistance des données: Lorsque vous arrêtez ou supprimez un conteneur, toutes les données sont perdues, y compris votre base de données. Le découplage des données du conteneur les rend toujours accessibles.
• Partage des données entre les conteneurs: Détacher les données du conteneur permet à plusieurs conteneurs d'y avoir accès. Vous éviterez ainsi la duplication des données et simplifierez la synchronisation entre les projets qui utilisent les mêmes données.
• Portabilité et sauvegarde: les données persistantes peuvent être facilement sauvegardées et partagées indépendamment, ce qui constitue un moyen fiable de récupérer les données perdues ou supprimées accidentellement.
• Amélioration des performances et de l'évolutivité: En stockant les données fréquemment consultées sur des supports persistants tels que les disques SSD, vous pouvez améliorer les performances de votre application par rapport à la couche inscriptible du conteneur, qui est généralement plus lente.

Le processus est le même que celui que nous avons déjà vu - nous allons créer un volume et le monter à l'endroit où les données sont stockées dans notre conteneur. Voici la marche à suivre :

1. Créez un volume :

$ docker volume create test-mysql-data

La commande volume create crée un espace de stockage dédié au volume sur votre système de fichiers local. Une fois le volume monté, toutes les données du conteneur y seront liées.

2. Redémarrez le conteneur avec le volume monté :

$ docker stop test-mysql; docker rm test-mysql
$ docker run \
   --name test-mysql \
   -v test-mysql-data:/var/lib/mysql \
   -e MYSQL_ROOT_PASSWORD=strong_password \
   -d mysql

Cette fois, la syntaxe est la suivante : -v volume_name:directory_in_container. Tous les volumes créés doivent être montés sur le répertoire /var/lib/mysql comme spécifié dans la documentation de l'image MySQL.

Ainsi, désormais, toutes les bases de données ou tous les tableaux créés à l'intérieur de test-mysql seront conservés localement, même après l'arrêt ou la suppression du conteneur.

Le commandement final

Tout au long de l'article, notre commande docker run a évolué de manière significative. Rassemblons donc toutes ses variantes en une seule et unique commande maîtresse. Nous devons nous arrêter et retirer à nouveau le conteneur. Nous supprimerons également le volume pour repartir à zéro :

$ docker stop test-mysql; docker rm test-mysql
$ docker volume rm test-mysql-data

Voici donc le dernier ordre principal :

$ docker run \
   --name final-mysql \
   -e MYSQL_ROOT_PASSWORD=strong_password \
   -p 3307:3306 \
   -v /etc/docker/test-mysql:/etc/mysql/conf.d \
   -v final-mysql-data:/var/lib/mysql \
   -d mysql

Cette commande monte notre ancien fichier local my.cnf à l'emplacement souhaité, crée un nouveau volume nommé final-mysql-data et le monte.

Gérer des configurations MySQL complexes avec Docker Compose

Pour les configurations plus avancées impliquant plusieurs conteneurs, comme l'exécution de MySQL avec d'autres services (par exemple, des serveurs web ou des backends d'application), Docker Compose simplifie le processus en vous permettant de définir et de gérer des applications multi-conteneurs à l'aide d'un seul fichier de configuration.

Voici un exemple de base d'un fichier docker-compose.yml pour un conteneur MySQL :

version: '3.9'
services:
  db:
    image: mysql:8.3.0
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: strong_password
      MYSQL_DATABASE: example_db
      MYSQL_USER: user
      MYSQL_PASSWORD: user_password
    ports:
      - "3306:3306"
    volumes:
      - db_data:/var/lib/mysql
      - ./mysql-config:/etc/mysql/conf.d
volumes:
  db_data:

Étapes à suivre pour utiliser Docker Compose :

• Créez un fichier docker-compose.yml : Enregistrez le fichier de configuration dans le répertoire de votre projet.
• Démarrez les services: Exécutez la commande suivante pour démarrer tous les services définis dans le fichier :

docker-compose up -d

• Arrêtez les services: Arrêtez les services lorsque vous avez terminé :

docker-compose down

Avantages de Docker Compose pour MySQL :

• Configuration simplifiée: Gérez les configurations, les ports et les volumes de MySQL dans un seul fichier.
• Une mise à l'échelle plus facile: Augmentez facilement la taille de la base de données ou intégrez-la à d'autres services dans votre pile d'applications.
• Données persistantes: Gérez automatiquement les volumes pour la persistance des données lors des redémarrages de conteneurs.

L'utilisation de Docker Compose est particulièrement utile pour gérer plusieurs environnements (par exemple, développement, mise en scène et production) ou pour collaborer avec des équipes.

Conclusion

Cet article a couvert les aspects essentiels de l'exécution et de la gestion des bases de données MySQL dans les conteneurs Docker. Nous avons appris à télécharger et à configurer des images MySQL, à démarrer des serveurs MySQL dans des conteneurs, à modifier ces conteneurs et à ajouter des volumes pour une configuration personnalisée et la persistance des données.

Pour en savoir plus sur le sujet, je vous recommande les ressources suivantes :

• Introduction à Docker pour la science des données
• Cours d'introduction à Docker
• Conteneurisation Docker et Kubernetes pour l'apprentissage automatique
• Documentation de l'image Docker MySQL
• Manuel de référence MySQL

Merci de votre lecture !