Utiliser des bases de données conteneurisées

L'utilisation d'une base de données conteneurisée locale offre flexibilité et facilité de configuration, vous permettant de refléter fidèlement les environnements de production sans les frais généraux des installations de bases de données traditionnelles. Docker simplifie ce processus, vous permettant de déployer, gérer et mettre à l'échelle des bases de données dans des conteneurs isolés avec seulement quelques commandes.

Dans ce guide, vous apprendrez à :

• Exécuter une base de données conteneurisée locale
• Accéder au shell d'une base de données conteneurisée
• Vous connecter à une base de données conteneurisée depuis votre hôte
• Vous connecter à une base de données conteneurisée depuis un autre conteneur
• Persister les données de la base de données dans un volume
• Construire une image de base de données personnalisée
• Utiliser Docker Compose pour exécuter une base de données

Ce guide utilise l'image MySQL pour les exemples, mais les concepts peuvent être appliqués à d'autres images de bases de données.

Prérequis

Pour suivre ce guide, vous devez avoir Docker installé. Pour installer Docker, consultez Obtenir Docker.

Exécuter une base de données conteneurisée locale

La plupart des systèmes de bases de données populaires, y compris MySQL, PostgreSQL et MongoDB, ont une image officielle Docker disponible sur Docker Hub. Ces images sont un ensemble d'images sélectionnées qui suivent les meilleures pratiques, vous assurant d'avoir accès aux dernières fonctionnalités et mises à jour de sécurité. Pour commencer, visitez Docker Hub et recherchez la base de données qui vous intéresse. La page de chaque image fournit des instructions détaillées sur la façon d'exécuter le conteneur, de personnaliser votre configuration et de configurer la base de données selon vos besoins. Pour plus d'informations sur l'image MySQL utilisée dans ce guide, consultez la page de l'image MySQL sur Docker Hub.

Pour exécuter un conteneur de base de données, vous pouvez utiliser soit l'interface graphique de Docker Desktop, soit la CLI.

$ docker run --name my-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -e MYSQL_DATABASE=mydb -d mysql:latest

Accéder au shell d'une base de données conteneurisée

Lorsque vous avez une base de données qui s'exécute dans un conteneur Docker, vous pouvez avoir besoin d'accéder à son shell pour gérer la base de données, exécuter des commandes ou effectuer des tâches administratives. Docker fournit un moyen simple de le faire en utilisant la commande docker exec. De plus, si vous préférez une interface graphique, vous pouvez utiliser l'interface graphique de Docker Desktop.

Si vous n'avez pas encore de conteneur de base de données en cours d'exécution, consultez Exécuter une base de données conteneurisée locale.

$ docker exec -it my-mysql bash

Une fois que vous avez accédé au terminal du conteneur, vous pouvez exécuter tous les outils disponibles dans ce conteneur. L'exemple suivant montre l'utilisation de mysql dans le conteneur pour lister les bases de données.

# mysql -u root -p
Enter password: my-secret-pw

mysql> SHOW DATABASES;

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mydb               |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.00 sec)

Se connecter à une base de données conteneurisée depuis votre hôte

La connexion à une base de données conteneurisée depuis votre machine hôte implique le mappage d'un port à l'intérieur du conteneur vers un port sur votre machine hôte. Ce processus garantit que la base de données à l'intérieur du conteneur est accessible via le réseau de la machine hôte. Pour MySQL, le port par défaut est 3306. En exposant ce port, vous pouvez utiliser divers outils de gestion de base de données ou applications sur votre machine hôte pour interagir avec votre base de données MySQL.

Avant de commencer, vous devez supprimer tous les conteneurs que vous avez précédemment exécutés pour ce guide. Pour arrêter et supprimer un conteneur, soit :

• Dans un terminal, exécutez docker rm --force my-mysql pour supprimer le conteneur nommé my-mysql.
• Ou, dans le tableau de bord de Docker Desktop, sélectionnez l'icône Supprimer à côté de votre conteneur dans la vue Conteneurs.

Ensuite, vous pouvez utiliser soit l'interface graphique de Docker Desktop, soit la CLI pour exécuter le conteneur avec le port mappé.

$ docker run -p 3307:3306 --name my-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -e MYSQL_DATABASE=mydb -d mysql:latest

$ docker ps

CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                               NAMES
6eb776cfd73c   mysql:latest   "docker-entrypoint.s…"   17 minutes ago   Up 17 minutes   33060/tcp, 0.0.0.0:3307->3306/tcp   my-mysql

At this point, any application running on your host can access the MySQL service in the container at localhost:3307.

Connect to a containerized database from another container

Connecting to a containerized database from another container is a common scenario in microservices architecture and during development processes. Docker's networking capabilities make it easy to establish this connection without having to expose the database to the host network. This is achieved by placing both the database container and the container that needs to access it on the same Docker network.

Before you begin, you must remove any containers you previously ran for this guide. To stop and remove a container, either:

• In a terminal, run docker remove --force my-mysql to remove the container named my-mysql.
• Or, in the Docker Desktop Dashboard, select the Delete icon next to your container in the Containers view.

To create a network and run containers on it:

1. Run the following command to create a Docker network named my-network.

   $ docker network create my-network
   

2. Run your database container and specify the network using the --network option. This runs the container on the my-network network.

   $ docker run --name my-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -e MYSQL_DATABASE=mydb --network my-network -d mysql:latest
   

3. Run your other containers and specify the network using the --network option. For this example, you'll run a phpMyAdmin container that can connect to your database.

   1. Run a phpMyAdmin container. Use the --network option to specify the network, the -p option to let you access the container from your host machine, and the -e option to specify a required environment variable for this image.

      $ docker run --name my-phpmyadmin -d --network my-network -p 8080:80 -e PMA_HOST=my-mysql phpmyadmin
      

4. Verify that the containers can communicate. For this example, you'll access phpMyAdmin and verify that it connects to the database.

   1. Open http://localhost:8080 to access your phpMyAdmin container.
   2. Log in using root as the username and my-secret-pw as the password. You should connect to the MySQL server and see your database listed.

At this point, any application running on your my-network container network can access the MySQL service in the container at my-mysql:3306.

Persist database data in a volume

Persisting database data in a Docker volume is necessary for ensuring that your data survives container restarts and removals. A Docker volume lets you store database files outside the container's writable layer, making it possible to upgrade the container, switch bases, and share data without losing it. Here's how you can attach a volume to your database container using either the Docker CLI or the Docker Desktop GUI.

Before you begin, you must remove any containers you previously ran for this guide. To stop and remove a container, either:

• In a terminal, run docker remove --force my-mysql to remove the container named my-mysql.
• Or, in the Docker Desktop Dashboard, select the Delete icon next to your container in the Containers view.

Next, you can use either the Docker Desktop GUI or CLI to run the container with a volume.

At this point, any MySQL container that mounts the my-db-volume will be able to access and save persisted data.

Build a customized database image

Customizing your database image lets you include additional configuration, scripts, or tools alongside the base database server. This is particularly useful for creating a Docker image that matches your specific development or production environment needs. The following example outlines how to build and run a custom MySQL image that includes a table initialization script.

Before you begin, you must remove any containers you previously ran for this guide. To stop and remove a container, either:

• In a terminal, run docker remove --force my-mysql to remove the container named my-mysql.
• Or, in the Docker Desktop Dashboard, select the Delete icon next to your container in the Containers view.

To build and run your custom image:

1. Create a Dockerfile.

   1. Create a file named Dockerfile in your project directory. For this example, you can create the Dockerfile in an empty directory of your choice. This file will define how to build your custom MySQL image.

   2. Add the following content to the Dockerfile.

      # syntax=docker/dockerfile:1
      
      # Use the base image mysql:latest
      FROM mysql:latest
      
      # Set environment variables
      ENV MYSQL_DATABASE mydb
      
      # Copy custom scripts or configuration files from your host to the container
      COPY ./scripts/ /docker-entrypoint-initdb.d/

      In this Dockerfile, you've set the environment variable for the MySQL database name. You can also use the COPY instruction to add custom configuration files or scripts into the container. In this example, files from your host's ./scripts/ directory are copied into the container's /docker-entrypoint-initdb.d/ directory. In this directory, .sh, .sql, and .sql.gz scripts are executed when the container is started for the first time. For more details about Dockerfiles, see the Dockerfile reference.

   3. Create a script file to initialize a table in the database. In the directory where your Dockerfile is located, create a subdirectory named scripts, and then create a file named create_table.sql with the following content.

   CREATE TABLE IF NOT EXISTS mydb.myothertable (
     column_name VARCHAR(255)
   );
   
   INSERT INTO mydb.myothertable (column_name) VALUES ('other_value');

   You should now have the following directory structure.

   ├── your-project-directory/
   │ ├── scripts/
   │ │ └── create_table.sql
   │ └── Dockerfile

2. Build your image.

   1. In a terminal, change directory to the directory where your Dockerfile is located.

   2. Run the following command to build the image.

      $ docker build -t my-custom-mysql .
      

      In this command, -t my-custom-mysql tags (names) your new image as my-custom-mysql. The period (.) at the end of the command specifies the current directory as the context for the build, where Docker looks for the Dockerfile and any other files needed for the build.

3. Run your image as you did in Run a local containerized database. This time, specify your image's name instead of mysql:latest. Also, you no longer need to specify the MYSQL_DATABASE environment variable as it's now defined by your Dockerfile.

   $ docker run --name my-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d my-custom-mysql
   

4. Verify that your container is running with the following command.

   $ docker ps
   

   You should see output like the following.

   CONTAINER ID   IMAGE              COMMAND                  CREATED        STATUS          PORTS                 NAMES
   f74dcfdb0e59   my-custom-mysql   "docker-entrypoint.s…"    2 hours ago    Up 51 minutes   3306/tcp, 33060/tcp   my-mysql
   

5. Verify that your initialization script was ran. Run the following command in a terminal to show the contents of the myothertable table.

   $ docker exec my-mysql mysql -u root -pmy-secret-pw -e "SELECT * FROM mydb.myothertable;"
   

   You should see output like the following.

   column_name
   other_value
   

Any container ran using your my-custom-mysql image will have the table initialized when first started.

Use Docker Compose to run a database

Docker Compose is a tool for defining and running multi-container Docker applications. With a single command, you can configure all your application's services (like databases, web apps, etc.) and manage them. In this example, you'll create a Compose file and use it to run a MySQL database container and a phpMyAdmin container.

To run your containers with Docker Compose:

1. Create a Docker Compose file.

   1. Create a file named compose.yaml in your project directory. This file will define the services, networks, and volumes.

   2. Add the following content to the compose.yaml file.

      services:
        db:
          image: mysql:latest
          environment:
            MYSQL_ROOT_PASSWORD: my-secret-pw
            MYSQL_DATABASE: mydb
          ports:
            - 3307:3306
          volumes:
            - my-db-volume:/var/lib/mysql
      
        phpmyadmin:
          image: phpmyadmin/phpmyadmin:latest
          environment:
            PMA_HOST: db
            PMA_PORT: 3306
            MYSQL_ROOT_PASSWORD: my-secret-pw
          ports:
            - 8080:80
          depends_on:
            - db
      
      volumes:
        my-db-volume:

      For the database service:

      • db is the name of the service.
      • image: mysql:latest specifies that the service uses the latest MySQL image from Docker Hub.
      • environment lists the environment variables used by MySQL to initialize the database, such as the root password and the database name.
      • ports maps port 3307 on the host to port 3306 in the container, allowing you to connect to the database from your host machine.
      • volumes mounts my-db-volume to /var/lib/mysql inside the container to persist database data.

      In addition to the database service, there is a phpMyAdmin service. By default Compose sets up a single network for your app. Each container for a service joins the default network and is both reachable by other containers on that network, and discoverable by the service's name. Therefore, in the PMA_HOST environment variable, you can specify the service name, db, in order to connect to the database service. For more details about Compose, see the Compose file reference.

2. Run Docker Compose.

   1. Open a terminal and change directory to the directory where your compose.yaml file is located.

   2. Run Docker Compose using the following command.

      $ docker compose up
      

      You can now access phpMyAdmin at http://localhost:8080 and connect to your database using root as the username and my-secret-pw as the password.

   3. To stop the containers, press ctrl+c in the terminal.

Now, with Docker Compose you can start your database and app, mount volumes, configure networking, and more, all with a single command.

Summary

This guide introduced you to the essentials of using containerized databases, specifically focusing on MySQL, to enhance flexibility, ease of setup, and consistency across your development environments. The use-cases covered in this guide not only streamline your development workflows but also prepare you for more advanced database management and deployment scenarios, ensuring your data-driven applications remain robust and scalable.

Related information:

• Docker Hub database images
• Dockerfile reference
• Compose file reference
• CLI reference
• Database samples