Création d'un conteneur

Notions théoriques

Docker offre 3 méthodes pour créer des conteneurs :

utiliser une image existante,
ou construire votre propre image avec un Dockerfile,
ou utiliser Docker Compose pour des applications complexes.

1) Image existante

La méthode la plus simple pour créer un conteneur consiste à utiliser une image Docker préexistante.

Cela peut être fait avec la commande suivante :

docker run -d --name mon_conteneur nom_image

Ici, nom_image est le nom de l'image que vous souhaitez utiliser, et mon_conteneur est le nom que vous attribuez à votre conteneur.

L'option -d permet de lancer le conteneur en mode détaché.

Création d'un conteneur interactif

Si vous souhaitez créer un conteneur et interagir avec lui, vous pouvez utiliser la commande suivante :

docker run -it --name mon_conteneur nom_image

L'option -it permet d'ouvrir un terminal interactif dans le conteneur, ce qui est idéal pour le développement et le débogage.

Clonage d'un conteneur existant

Il est également possible de créer un nouveau conteneur en clonant un conteneur existant.

Cela peut être fait en utilisant la commande docker commit :

docker commit mon_conteneur nouvelle_image
docker run -d --name nouveau_conteneur nouvelle_image

astuce

Cette méthode est utile si vous avez apporté des modifications à un conteneur en cours d'exécution et que vous souhaitez les conserver dans une nouvelle image.

2) Dockerfile

Un Dockerfile est un fichier texte contenant toutes les instructions nécessaires pour assembler une image Docker.

Pour créer un conteneur à partir d'un Dockerfile, vous devez :

d'abord écrire le contenu du fichier Dockerfile (on s'inspire souvent d'un Dockerfile existant)
puis construire l'image avec la commande suivante :

docker build -t mon_image

Ensuite, vous pouvez créer un conteneur à partir de cette image :

docker run -d --name mon_conteneur mon_image

Le Dockerfile vous permet de personnaliser l'environnement du conteneur en ajoutant des dépendances, en configurant des variables d'environnement, et bien plus encore.

attention

Si aucun processus n'est démarré dans le conteneur, alors le conteneur s'arrête automatiquement.

3) Docker Compose

Docker Compose est un outil qui vous permet de définir et de gérer des applications multi-conteneurs.

Vous créez un fichier docker-compose.yml pour spécifier les services, les réseaux et les volumes nécessaires.

Pour créer et démarrer les conteneurs définis dans le fichier, utilisez la commande :

docker-compose up -d

info

Cette méthode est particulièrement utile pour les applications complexes nécessitant plusieurs conteneurs interconnectés.

Exemples pratiques

1) Créer un conteneur avec une image

Cet exemple montre comment utiliser une image Docker préexistante pour créer un conteneur.

Objectif :

Créer un conteneur à partir de l'image nginx et le rendre accessible sur votre machine.

Étapes :

Téléchargez l'image officielle nginx depuis Docker Hub (si elle n'est pas déjà disponible localement) :
```
docker pull nginx
```
Créez et démarrez un conteneur basé sur cette image :
```
docker run -d --name mon_nginx -p 8080:80 nginx
```
- L'option -d exécute le conteneur en mode détaché (en arrière-plan).
- L'option -p 8080:80 redirige le port 80 du conteneur vers le port 8080 de votre machine.
Ouvrez un navigateur et accédez à http://localhost:8080. Vous devriez voir la page par défaut de Nginx.
Vérifiez que le conteneur fonctionne :
```
docker ps
```

2) Créer un conteneur interactif

Cet exemple illustre comment démarrer un conteneur interactif pour effectuer des tâches de développement ou de débogage.

Objectif :

Créer un conteneur interactif basé sur l'image debian et installer des outils à l'intérieur.

Étapes :

Téléchargez l'image officielle debian (si elle n'est pas déjà disponible localement) :
```
docker pull debian
```
Créez et démarrez un conteneur interactif :
```
docker run -it --name ma_debian debian
```
- L'option -it ouvre un terminal interactif dans le conteneur.
Une fois à l'intérieur du conteneur, installez un outil comme curl :
```
apt update
apt install curl -y
```
Testez l'installation en exécutant une commande curl :
```
curl https://joliciel.info
```
Pour quitter le conteneur sans l'arrêter, utilisez la combinaison de touches :
```
Ctrl + P, puis Ctrl + Q
```
Vous pouvez reprendre l'interaction avec le conteneur plus tard :
```
docker attach ma_debian
```

3) Créer avec Docker Compose

Voici un exemple pratique pour mettre en place une application Web avec un conteneur Apache (serveur Web) et un conteneur MariaDB (base de données).

Le but est de créer un petit site Web qui se connecte à une base de données MariaDB pour afficher un message.

Étapes :

1. Préparer le fichier `docker-compose.yml`

Créez un fichier nommé docker-compose.yml dans un répertoire de votre choix avec le contenu suivant :

version: '3.8'
services:
  Web:
    image: php:8.2-apache
    container_name: apache_Web
    ports:
      - "8080:80"
    volumes:
      - ./Web:/var/www/html
    networks:
      - app_network
    depends_on:
      - db

  db:
    image: mariadb:10.11
    container_name: mariadb_db
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: demo_db
      MYSQL_USER: demo_user
      MYSQL_PASSWORD: demo_password
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - app_network

networks:
  app_network:

volumes:
  db_data:

Explications :

Service Web :
- Utilise l'image PHP avec Apache intégré.
- Expose le port 8080 pour accéder au site Web.
- Monte un volume local ./Web pour stocker les fichiers du site.
- Dépend du service db pour garantir que MariaDB démarre en premier.
Service db :
- Utilise l'image officielle de MariaDB.
- Configure une base de données nommée demo_db et un utilisateur demo_user avec le mot de passe demo_password.
- Monte un volume nommé db_data pour persister les données.
Réseau app_network : Connecte les deux conteneurs.

2. Ajouter les fichiers du site Web

Créez un dossier nommé Web dans le même répertoire que le fichier docker-compose.yml.

Ajoutez-y un fichier index.php :

<?php

$host = 'db';
$dbname = 'demo_db';
$user = 'demo_user';
$password = 'demo_password';

try {

    // Connexion à la base de données
    $pdo = new PDO("mysql:host=$host;dbname=$dbname;charset=utf8mb4", $user, $password);

    // Création de la table si elle n'existe pas
    $pdo->exec("CREATE TABLE IF NOT EXISTS messages (id INT AUTO_INCREMENT PRIMARY KEY, message TEXT)");

    // Insertion d'un message 
    $pdo->exec("INSERT INTO messages (message) VALUES ('Ajout du message : Bienvenue sur mon site Web avec Docker !')");

    // Récupération des messages
    $stmt = $pdo->query("SELECT * FROM messages");
    $messages = $stmt->fetchAll(PDO::FETCH_ASSOC);

    // Affichage des messages
    print "<h1>Messages :</h1>";
    foreach ($messages as $row) {
        print "<p>" . htmlspecialchars($row['message']) . "</p>";
    }

} catch (PDOException $e) {
    print "Erreur de connexion à la base de données : " . $e->getMessage();
}

?>

Explications :

Ce script PHP se connecte à la base de données MariaDB via le conteneur db.
Il crée une table messages si elle n'existe pas.
Il insère un message par défaut si la table est vide.
Il affiche les messages stockés dans la base de données.

3. Démarrer les conteneurs

Dans le terminal, exécutez la commande suivante pour démarrer les conteneurs :

docker-compose up -d

Ce que fait cette commande :

Télécharge les images nécessaires (si elles ne sont pas déjà présentes).
Crée et démarre les conteneurs définis dans le fichier docker-compose.yml.
Monte le dossier Web dans le conteneur Apache pour servir le fichier index.php.

4. Vérifier le fonctionnement

Ouvrez un navigateur et accédez à l'adresse suivante :
http://localhost:8080
Vous devriez voir le message suivant affiché :
"Ajout du message : Bienvenue sur mon site Web avec Docker !"

5. Gestion des conteneurs

Pour vérifier l'état des conteneurs :
```
docker ps
```
Pour arrêter et supprimer les conteneurs :
```
docker-compose down
```
Pour supprimer les volumes (et donc les données de la base) :
```
docker-compose down -v
```

Résumé

Avec ce 3ème exemple :

Vous avez configuré un conteneur Apache avec PHP pour héberger un site Web.
Vous avez configuré un conteneur MariaDB pour gérer une base de données.
Vous avez utilisé Docker Compose pour orchestrer les deux conteneurs.

Résumé des commandes utilisées

Commande	Description
`docker pull <image>`	Télécharge une image Docker depuis Docker Hub.
`docker run`	Crée et démarre un conteneur.
`docker ps`	Liste les conteneurs en cours d'exécution.
`docker-compose up`	Démarre les conteneurs définis dans un fichier `docker-compose.yml`.
`docker-compose down`	Arrête et supprime les conteneurs définis dans Docker Compose.

Test de mémorisation/compréhension

Quelle commande permet de lancer un conteneur en mode interactif avec un terminal attaché ?

docker run -d

docker run -it

docker start -i

docker attach -it

docker exec -d

Dans un fichier `docker-compose.yml`, que permet l'instruction `depends_on` dans un service ?

Garantir que le service démarre avant les autres services.

Configurer les dépendances réseau entre les services.

Indiquer qu’un service est requis pour en démarrer un autre.

Assurer que les volumes sont montés avant le démarrage du service.

Rendre un conteneur dépendant d'une image spécifique.

Quelle commande permet de créer une nouvelle image Docker à partir d'un conteneur existant ?

docker save

docker commit

docker clone

docker export

docker snapshot

Que fait la commande `docker-compose down -v` par rapport à `docker-compose down` ?

Elle arrête les conteneurs mais ne supprime pas les réseaux.

Elle supprime également les volumes associés aux conteneurs.

Elle force l'arrêt des conteneurs même s'ils sont en cours d'exécution.

Elle supprime les images utilisées par les conteneurs.

Elle ne fait rien de plus que `docker-compose down`.

Quelle est la commande correcte pour construire une image Docker à partir d’un Dockerfile ?

docker build -t <nom_image>

docker create -f Dockerfile

docker run -f Dockerfile

docker compose build

docker image create -t <nom_image>

Dans un fichier `docker-compose.yml`, comment définit-on un réseau personnalisé pour relier plusieurs services ?

En utilisant l'instruction `links` dans chaque service.

En ajoutant une section `networks` au niveau global.

En configurant une variable d'environnement `DOCKER_NETWORK`.

En spécifiant `bridge` comme type de réseau dans chaque service.

En utilisant une option `network_mode: custom` dans chaque service.

Quelle commande permet de vérifier les conteneurs en cours d'exécution ?

docker ps

docker list

docker status

docker show

docker running

Dans un fichier `docker-compose.yml`, que fait l'instruction `volumes` dans un service ?

Elle configure les variables d'environnement pour le conteneur.

Elle définit les ports exposés par le conteneur.

Elle connecte un répertoire local ou un volume Docker au conteneur.

Elle configure les dépendances réseau entre les conteneurs.

Elle définit la mémoire maximale autorisée pour le conteneur.

Quelle commande permet de rediriger un port local vers un port exposé par un conteneur Docker ?

docker run -p <port_local>:<port_conteneur>

docker expose <port_local>:<port_conteneur>

docker port <port_local>:<port_conteneur>

docker map <port_local>:<port_conteneur>

docker redirect <port_local>:<port_conteneur>

Quelle est l'utilité principale d'un fichier `Dockerfile` ?

Créer un conteneur directement à partir d'une image.

Définir les instructions nécessaires pour construire une image Docker.

Configurer les réseaux et volumes pour plusieurs conteneurs.

Déployer une application multi-conteneurs.

Gérer les permissions d'accès des conteneurs Docker.

TP pour réfléchir et résoudre des problèmes

Dans ce TP, vous allez créer une application multi-conteneurs utilisant Python et MariaDB.

L'objectif est de construire une application Python qui se connecte à une base de données MariaDB pour insérer et lire des données.

Objectif :

Créer une application multi-conteneurs qui :

Utilise un script Python pour insérer et lire des données dans une base MariaDB.
Persiste les données de la base MariaDB même après l'arrêt des conteneurs.
Orchestre les conteneurs Python et MariaDB avec Docker Compose.

Étape 1 : Préparer le fichier `docker-compose.yml`

Consigne :

Créez un répertoire multi-container-app.

Créez un fichier docker-compose.yml dans le répertoire multi-container-app.

Ce fichier doit définir deux services :

app : un conteneur basé sur une image Python qui exécute un script Python.
db : un conteneur basé sur l'image officielle MariaDB pour gérer la base de données.

Voici les spécifications :

Le conteneur app doit :
- Être basé sur une image Python personnalisée que vous construirez.
- Être connecté à un réseau nommé app_network.
- Dépendre du conteneur db pour s'assurer que la base MariaDB est prête avant l'exécution du script.
Le conteneur db doit :
- Utiliser l'image officielle MariaDB.
- Configurer une base de données nommée demo_db avec un utilisateur demo_user et un mot de passe demo_password.
- Être connecté au réseau app_network.
- Utiliser un volume pour persister les données.

Une solution

Étape 2 : Créer le script Python

Consigne :

Créez un répertoire nommé app dans le même dossier que votre fichier docker-compose.yml.

multi-container-app/
│
├── app/
│   ├── main.py
│   └── requirements.txt
│
└── docker-compose.yml

Dans ce répertoire :

Créez un fichier app.py pour exécuter le script Python.
Créez un fichier requirements.txt pour lister les dépendances Python.
Créez un Dockerfile pour construire une image Python personnalisée.

Le script Python doit :

Se connecter à la base MariaDB.
Créer une table nommée messages (si elle n'existe pas).
Insérer un message dans la table.
Lire et afficher les messages stockés dans la base.

Fichiers nécessaires

Voici les fichiers nécessaires dans le répertoire app :

1. Fichier app.py :

import mysql.connector

# Configuration de la connexion à la base de données
config = {
    'user': 'demo_user',
    'password': 'demo_password',
    'host': 'db',  # Nom du service MariaDB dans docker-compose.yml
    'database': 'demo_db',
}

try:
    # Connexion à la base de données
    connection = mysql.connector.connect(**config)
    cursor = connection.cursor()

    # Création de la table si elle n'existe pas
    cursor.execute("""
    CREATE TABLE IF NOT EXISTS messages (
        id INT AUTO_INCREMENT PRIMARY KEY,
        message TEXT NOT NULL
    )
    """)

    # Insertion d'un message
    cursor.execute("INSERT INTO messages (message) VALUES ('Bienvenue dans Docker avec Python et MariaDB !')")
    connection.commit()

    # Lecture des messages
    cursor.execute("SELECT * FROM messages")
    rows = cursor.fetchall()

    print("Messages dans la base de données :")
    for row in rows:
        print(f"ID: {row[0]}, Message: {row[1]}")

except mysql.connector.Error as err:
    print(f"Erreur : {err}")
finally:
    if connection.is_connected():
        cursor.close()
        connection.close()

2. Fichier requirements.txt :

mysql-connector-python

3. Fichier Dockerfile :

# Utiliser une image Python comme base
FROM python:3.11-slim

# Définir le répertoire de travail
WORKDIR /app

# Copier les fichiers nécessaires
COPY requirements.txt requirements.txt
COPY app.py app.py

# Installer les dépendances
RUN pip install -r requirements.txt

# Exécuter le script Python
CMD ["python", "app.py"]

Explications :

app.py :
- Se connecte à MariaDB via son nom de service (db) défini dans docker-compose.yml.
- Crée une table messages si elle n'existe pas.
- Insère un message par défaut.
- Lit et affiche les messages stockés dans la base.
requirements.txt :
- Liste la bibliothèque mysql-connector-python pour interagir avec MariaDB.
Dockerfile :
- Définit une image Python personnalisée avec les dépendances nécessaires.
- Exécute automatiquement le script app.py au démarrage du conteneur.

Étape 3 : Démarrer les conteneurs

Consigne :

Utilisez Docker Compose pour démarrer les conteneurs définis dans votre fichier docker-compose.yml.

Une solution

Étape 4 : Tester la persistance des données

Consigne :

Arrêtez les conteneurs avec docker-compose down.
Relancez les conteneurs avec docker-compose up -d.
Vérifiez si les messages précédemment insérés sont toujours disponibles.

Une solution

Étape 5 : Nettoyer l'environnement

Consigne :

Supprimez tous les conteneurs, réseaux et volumes créés pour ce TP.

Une solution

Notions théoriques​

1) Image existante​

2) Dockerfile​

3) Docker Compose​

Exemples pratiques​

1) Créer un conteneur avec une image​

Objectif :​

Étapes :​

2) Créer un conteneur interactif​

Objectif :​

Étapes :​

3) Créer avec Docker Compose​

Étapes :​

1. Préparer le fichier docker-compose.yml​

2. Ajouter les fichiers du site Web​

3. Démarrer les conteneurs​

4. Vérifier le fonctionnement​

5. Gestion des conteneurs​

Résumé​

Résumé des commandes utilisées​

Test de mémorisation/compréhension​

Quelle commande permet de lancer un conteneur en mode interactif avec un terminal attaché ?

Dans un fichier `docker-compose.yml`, que permet l'instruction `depends_on` dans un service ?

Quelle commande permet de créer une nouvelle image Docker à partir d'un conteneur existant ?

Que fait la commande `docker-compose down -v` par rapport à `docker-compose down` ?

Quelle est la commande correcte pour construire une image Docker à partir d’un Dockerfile ?

Dans un fichier `docker-compose.yml`, comment définit-on un réseau personnalisé pour relier plusieurs services ?

Quelle commande permet de vérifier les conteneurs en cours d'exécution ?

Dans un fichier `docker-compose.yml`, que fait l'instruction `volumes` dans un service ?

Quelle commande permet de rediriger un port local vers un port exposé par un conteneur Docker ?

Quelle est l'utilité principale d'un fichier `Dockerfile` ?

TP pour réfléchir et résoudre des problèmes​

Objectif :​

Étape 1 : Préparer le fichier docker-compose.yml​

Consigne :​

Étape 2 : Créer le script Python​

Consigne :​

Étape 3 : Démarrer les conteneurs​

Consigne :​

Étape 4 : Tester la persistance des données​

Consigne :​

Étape 5 : Nettoyer l'environnement​

Consigne :​

Notions théoriques

1) Image existante

2) Dockerfile

3) Docker Compose

Exemples pratiques

1) Créer un conteneur avec une image

Objectif :

Étapes :

2) Créer un conteneur interactif

Objectif :

Étapes :

3) Créer avec Docker Compose

Étapes :

1. Préparer le fichier `docker-compose.yml`

2. Ajouter les fichiers du site Web

3. Démarrer les conteneurs

4. Vérifier le fonctionnement

5. Gestion des conteneurs

Résumé

Résumé des commandes utilisées

Test de mémorisation/compréhension

TP pour réfléchir et résoudre des problèmes

Objectif :

Étape 1 : Préparer le fichier `docker-compose.yml`

Consigne :

Étape 2 : Créer le script Python

Consigne :

Étape 3 : Démarrer les conteneurs

Consigne :

Étape 4 : Tester la persistance des données

Consigne :

Étape 5 : Nettoyer l'environnement

Consigne :