Dockerfile avec Ubuntu : Guide complet du débutant à l’expert pour créer des images Docker

1. Introduction

Qu’est-ce que Docker et les Dockerfiles ?

Ces dernières années, Docker a rapidement gagné en popularité en tant que moyen efficace de rationaliser les environnements de développement et le déploiement d’applications. Docker emballe les applications et leurs dépendances dans une unité unique appelée un « conteneur », ce qui leur permet de s’exécuter de manière cohérente dans différents environnements.

Pour construire ces conteneurs Docker, un plan appelé un Dockerfile est requis. Un Dockerfile est un fichier texte qui définit l’image du système d’exploitation de base, les logiciels installés, les variables d’environnement et d’autres détails de configuration. Les développeurs peuvent l’utiliser pour construire automatiquement des environnements personnalisés.

Pourquoi utiliser Ubuntu comme image de base ?

Lors de la création d’un Dockerfile, la première étape consiste à sélectionner une image de système d’exploitation de base. Parmi les nombreuses options disponibles, Ubuntu est l’une des plus populaires. Ubuntu est une distribution Linux basée sur Debian, connue pour sa facilité d’utilisation et sa configuration d’environnement flexible, soutenue par un vaste écosystème de paquets.

Les Dockerfiles basés sur Ubuntu offrent plusieurs avantages :

• Une documentation officielle et communautaire étendue, ce qui entraîne une courbe d’apprentissage faible
• Installation facile des paquets et outils à l’aide d’APT
• Images légères et minimales fournies officiellement (telles que ubuntu:20.04 et ubuntu:24.04 )

Objectif de cet article et public cible

Cet article se concentre sur le mot-clé « Dockerfile Ubuntu » et explique comment créer des Dockerfiles basés sur Ubuntu de manière facile à comprendre pour les débutants.

Il couvre tout, de la structure de base d’un Dockerfile aux instructions étape par étape pour construire un environnement Ubuntu, des exemples de configuration d’environnements d’applications tels que Python, et des erreurs courantes avec leurs solutions.

Cet article est recommandé pour :

• Ceux qui souhaitent construire des environnements à l’aide de Dockerfiles pour la première fois
• Les développeurs qui veulent créer des environnements de développement reproductibles sur Ubuntu
• Toute personne qui souhaite approfondir sa compréhension, y compris les techniques de dépannage

2. Structure de base d’un Dockerfile

Qu’est-ce qu’un Dockerfile et quel est son rôle ?

Un Dockerfile est comme une recette pour créer des images Docker. Il définit quel système d’exploitation de base utiliser, quels logiciels installer et comment configurer l’environnement.

En exécutant la commande docker build basée sur ce fichier, vous pouvez facilement créer des environnements de développement et d’exécution hautement reproductibles.

Avantages de l’utilisation des Dockerfiles :

• Configuration d’environnement automatisée (pas besoin de répétitions manuelles)
• Élimine les incohérences d’environnement dans le développement d’équipe
• Intégration facile dans les pipelines CI/CD

Instructions couramment utilisées dans un Dockerfile

Un Dockerfile se compose de plusieurs instructions (directives). Les suivantes sont parmi les plus couramment utilisées. En les combinant de manière appropriée, vous pouvez construire un Dockerfile basé sur Ubuntu.

Exemple minimal de Dockerfile basé sur Ubuntu

Voici un exemple très basique de Dockerfile utilisant Ubuntu comme image de base.

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y \
    curl \
    vim

CMD ["/bin/bash"]

Ce Dockerfile utilise Ubuntu 24.04 comme image de base, installe les utilitaires curl et vim, et lance un shell Bash lorsque le conteneur démarre.

Sélection du tag Ubuntu approprié

Les images Docker Ubuntu sont publiées dans le dépôt officiel Docker Hub. Bien que la spécification de ubuntu:latest utilise la version la plus récente, il est recommandé d’épingler explicitement une version.

Par exemple :

• ubuntu:22.04 (LTS : Long-Term Support, axé sur la stabilité)
• ubuntu:24.04 (Dernier LTS, axé sur les nouvelles fonctionnalités)

Choisissez la version en fonction de si la stabilité ou les nouvelles fonctionnalités sont votre priorité.

3. Pratique : Création d’un Dockerfile basé sur Ubuntu

Installation des paquets requis dans un environnement Ubuntu

.Lorsque vous créez un environnement Ubuntu à l’aide d’un Dockerfile, il est souvent nécessaire d’installer des paquets supplémentaires. Par exemple, les utilitaires suivants sont couramment utilisés lors de la mise en place d’un environnement de développement :

• curl : pour télécharger des fichiers et tester des API
• vim : éditeur de texte léger
• git : système de contrôle de version
• build-essential : outils essentiels pour compiler des programmes C/C++

Pour installer ces paquets dans un Dockerfile, utilisez l’instruction RUN.

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y \
    curl \
    vim \
    git \
    build-essential

En exécutant d’abord apt-get update, vous vous assurez que les listes de paquets les plus récentes sont récupérées avant l’installation.

Configuration d’une installation non interactive

Sur Ubuntu, apt-get install peut parfois demander une saisie utilisateur. Or, les opérations interactives ne sont pas possibles pendant les builds Docker. Pour éviter cela, il est recommandé de définir une variable d’environnement et d’activer le mode non interactif.

ENV DEBIAN_FRONTEND=noninteractive

Cela supprime les invites telles que le choix de la locale ou du fuseau horaire et permet aux installations de se dérouler sans problème.

Réduction de la taille de l’image en supprimant le cache inutile

Lors de l’utilisation d’APT, les fichiers temporaires téléchargés (cache) peuvent rester dans l’image, augmentant ainsi sa taille finale. Vous pouvez réduire la taille de l’image en supprimant le cache comme indiqué ci‑dessous :

RUN apt-get update && apt-get install -y \
    curl \
    vim \
    && rm -rf /var/lib/apt/lists/*

Regrouper plusieurs commandes dans une seule instruction RUN aide également à éviter les augmentations inutiles du nombre de couches d’image.

Bonnes pratiques pour écrire des Dockerfiles

Dans les environnements de développement réels, les bonnes pratiques Dockerfile suivantes sont largement recommandées :

• Regroupez les instructions RUN chaque fois que possible afin de réduire le nombre de couches
• Définissez explicitement les versions et les paramètres à l’aide de ENV
• Utilisez des commentaires pour décrire clairement le but de chaque étape
• Évitez de laisser des fichiers inutiles en utilisant rm et --no-install-recommends

Exemple :

RUN apt-get update && apt-get install -y --no-install-recommends \
    curl \
    git \
    && rm -rf /var/lib/apt/lists/*

Cette approche donne un Dockerfile plus léger et plus maintenable.

4. Construction et vérification des images Docker

Construction d’une image Docker à partir d’un Dockerfile

Une fois votre Dockerfile prêt, l’étape suivante consiste à construire une image Docker. Cela se fait avec la commande docker build. Exécutez la commande suivante dans le répertoire contenant votre Dockerfile :

docker build -t my-ubuntu-image .

• L’option -t attribue un nom (tag) à l’image. Dans cet exemple, l’image est nommée my-ubuntu-image.
• Le point (.) fait référence au répertoire actuel contenant le Dockerfile.

Docker lira les instructions du Dockerfile séquentiellement et construira l’image en conséquence.

Vérification de l’image Docker construite

Après que l’image a été construite avec succès, vous pouvez la vérifier à l’aide de la commande suivante :

docker images

Cela affiche la liste des images Docker stockées localement, incluant les informations suivantes :

• REPOSITORY (nom de l’image)
• TAG
• IMAGE ID (identifiant unique)
• CREATED (date de création)
• SIZE

Exemple :

REPOSITORY        TAG       IMAGE ID       CREATED          SIZE
my-ubuntu-image   latest    abcd1234abcd   5 minutes ago    189MB

Cela confirme que l’image a bien été enregistrée.

Exécution d’un conteneur Docker pour la vérification

Pour vérifier que l’image créée fonctionne comme prévu, lancez un conteneur Docker avec la commande suivante :

docker run -it my-ubuntu-image

• L’option -it ouvre une session terminal interactive.
• Si tout se passe bien, une invite Bash apparaîtra, indiquant que vous êtes à l’intérieur du conteneur Ubuntu.

À l’intérieur du conteneur, vous pouvez vérifier les outils installés avec des commandes telles que :

curl --version
vim --version

Si ces commandes fonctionnent correctement, votre Dockerfile est correctement configuré.

Nettoyage des images et conteneurs inutilisés

Les builds et expériences répétés peuvent laisser des images et conteneurs Docker inutilisés sur votre système. Il est recommandé de les nettoyer périodiquement en utilisant les commandes suivantes :

• Supprimer les conteneurs arrêtés :

  docker container prune
  

• Supprimer les images inutilisées :

  docker image prune
  

• Supprimer toutes les données inutilisées (utiliser avec prudence) :

  docker system prune
  

Ces opérations aident à économiser de l’espace disque et à prévenir les problèmes potentiels.

5. Avancé : Construction d’un environnement Python

Activation de Python dans un Dockerfile basé sur Ubuntu

Lors de la construction d’un environnement Ubuntu à l’aide d’un Dockerfile, l’ajout d’un environnement d’exécution Python permet une large gamme de cas d’utilisation, y compris le développement, les tests et l’apprentissage automatique. Bien que Python puisse déjà être installé sur Ubuntu par défaut, il est courant de le configurer explicitement pour une meilleure gestion des versions et des paquets.

Installation de Python en utilisant APT

L’approche la plus simple consiste à installer Python en utilisant les paquets APT. Voici un exemple :

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y \
    python3 \
    python3-pip \
    && rm -rf /var/lib/apt/lists/*

Cette méthode fournit une version stable de Python système (telle que Python 3.10 ou 3.12, selon la version d’Ubuntu). Vous pouvez également installer des paquets Python supplémentaires en utilisant la commande pip.

Gestion des versions de Python avec pyenv

Si vous avez besoin d’une version spécifique de Python ou souhaitez basculer entre plusieurs versions, l’utilisation de pyenv est fortement recommandée.

L’exemple suivant montre comment installer Python 3.11.6 en utilisant pyenv dans un Dockerfile :

FROM ubuntu:24.04

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y \
    git \
    curl \
    make \
    build-essential \
    libssl-dev \
    zlib1g-dev \
    libbz2-dev \
    libreadline-dev \
    libsqlite3-dev \
    wget \
    llvm \
    libncurses5-dev \
    libncursesw5-dev \
    xz-utils \
    tk-dev \
    libffi-dev \
    liblzma-dev \
    && rm -rf /var/lib/apt/lists/*

# Install pyenv
RUN git clone https://github.com/pyenv/pyenv.git ~/.pyenv

ENV PYENV_ROOT="$HOME/.pyenv"
ENV PATH="$PYENV_ROOT/bin:$PATH"

RUN echo 'eval "$(pyenv init --path)"' >> ~/.bashrc

# Install a specific Python version
RUN pyenv install 3.11.6 && pyenv global 3.11.6

Cette configuration fournit un environnement Python flexible et bien contrôlé.

Gestion des paquets avec requirements.txt

La plupart des projets du monde réel nécessitent plusieurs bibliothèques Python. Ces dépendances sont couramment gérées en utilisant un fichier requirements.txt.

Premièrement, créez un fichier requirements.txt à la racine de votre projet :

flask==2.3.2
requests>=2.25.1
pandas

Ensuite, référencez-le dans votre Dockerfile comme suit :

COPY requirements.txt /app/requirements.txt
WORKDIR /app

RUN pip install --no-cache-dir -r requirements.txt

Cela permet d’installer toutes les bibliothèques requises en une seule fois et améliore considérablement la reproductibilité de l’environnement.

Bonnes pratiques

• Lors de l’utilisation de Python, la création d’un environnement virtuel avec virtualenv ou venv aide à prévenir les conflits de dépendances.
• L’utilisation d’options de suppression de cache telles que --no-cache-dir réduit la taille de l’image Docker.
• L’exécution de pip install --upgrade pip avant l’installation des paquets peut aider à éviter les erreurs d’installation.

6. Problèmes courants et dépannage

Erreurs de permission

Exemple :

Permission denied

Cette erreur se produit lorsque les fichiers copiés manquent de permissions d’exécution ou lorsque la propriété des fichiers et les utilisateurs d’exécution sont mal configurés.

Solution :

• Rendre le fichier exécutable :

  RUN chmod +x script.sh
  

• Changer la propriété du fichier si nécessaire :

  RUN chown root:root /path/to/file
  

Paquet non trouvé ou échec d’installation

Exemple :

E: Unable to locate package xxx

Cette erreur se produit généralement lorsque apt-get update n’a pas été exécuté ou lorsque le nom du paquet est incorrect.

Solution :

• Exécutez toujours apt-get update avant d’installer des paquets :

  RUN apt-get update && apt-get install -y curl
  

• Vérifiez les noms des paquets et corrigez les fautes de frappe

Erreurs liées au réseau

Exemple :

Temporary failure resolving 'deb.debian.org'

Cette erreur indique un problème de résolution DNS pendant le processus de construction.

Solution :

• Redémarrer le démon Docker peut résoudre le problème :

  sudo systemctl restart docker
  

• Vérifiez les paramètres DNS de Docker en ajoutant des serveurs DNS dans /etc/docker/daemon.json :

  {
    "dns": ["8.8.8.8", "8.8.4.4"]
  }
  

Construction avec un cache obsolète

Docker utilise le cache basé sur les couches pour accélérer les builds. En conséquence, les modifications d’un Dockerfile ne sont pas toujours reflétées immédiatement.

Solution :

• Reconstruisez sans cache :

  docker build --no-cache -t my-image .
  

Le conteneur se termine immédiatement ou la commande de démarrage ne s’exécute pas

Causes :

• La commande spécifiée dans CMD ou ENTRYPOINT contient une erreur
• Utiliser CMD ["/bin/bash"] sans mode interactif entraîne une sortie immédiate

Solution :

• Démarrez le conteneur en mode débogage :

  docker run -it my-image /bin/bash
  

• Comprenez les différences entre CMD et ENTRYPOINT et utilisez‑les correctement

En rencontrant et en résolvant ces problèmes, vos compétences en conception de Dockerfile s’amélioreront progressivement. Lorsque des erreurs surviennent, lisez attentivement les messages d’erreur et identifiez quelle instruction et quelle couche sont à l’origine du problème.

7. Résumé

Points clés pour créer des Dockerfiles basés sur Ubuntu

Cet article a fourni une explication pas à pas sur la façon de construire des environnements Ubuntu avec des Dockerfiles, en couvrant à la fois les notions fondamentales et avancées. Revenons sur les points essentiels :

• Comprendre les bases du Dockerfile est la première étape : des instructions telles que FROM, RUN, CMD et ENV permettent de créer automatiquement un environnement.
• Ubuntu est une image de base stable et flexible : son vaste écosystème de paquets, sa large communauté d’utilisateurs et ses versions LTS en font un choix idéal pour les environnements de développement.
• La gestion pratique des paquets permet d’installer les outils et bibliothèques nécessaires : une utilisation correcte de apt-get, le nettoyage du cache et l’installation non interactive sont essentiels.
• Construire des environnements pratiques comme Python est pleinement pris en charge par les Dockerfiles : des outils tels que pyenv, pip et requirements.txt assurent des configurations reproductibles.
• Les compétences de dépannage influent directement sur la stabilité : comprendre les permissions, le réseau et le comportement du cache de construction améliore considérablement la productivité.

Prochaines étapes dans l’apprentissage des Dockerfiles

Une fois que vous êtes à l’aise avec les Dockerfiles, vous pouvez étendre vos compétences au-delà du développement, vers les tests et les déploiements en production. Envisagez d’explorer les sujets suivants :

• Gestion d’installations multi‑conteneurs avec Docker Compose
• Intégration avec des outils CI/CD tels que GitHub Actions et GitLab CI
• Travail avec des plateformes d’orchestration de conteneurs comme Kubernetes

Documentation officielle et liens de référence

• Documentation officielle de Docker (japonais)
• Docker Hub – Images officielles Ubuntu
• Référentiel GitHub de pyenv

8. FAQ (Foire aux questions)

Q1. Quelle version d’Ubuntu devrais‑je choisir dans un Dockerfile ?

R1. Dans la plupart des cas, il est recommandé de choisir une version LTS (Long Term Support) pour la stabilité et la maintenance à long terme. Des versions comme ubuntu:22.04 et ubuntu:20.04 sont largement utilisées et supportées pendant cinq ans.

Si vous avez besoin des derniers paquets ou des versions les plus récentes des langages, vous pouvez opter pour une version plus récente telle que ubuntu:24.04, mais des tests approfondis sont conseillés.

Q2. Pourquoi apt-get install indique‑t‑il « package not found » ?

A2. La raison la plus courante est l’échec de l’exécution de apt-get update au préalable. Sans mettre à jour la liste des paquets, APT ne peut pas localiser les paquets demandés.

Exemple correct :

RUN apt-get update && apt-get install -y curl

Assurez-vous également que les noms des paquets sont corrects et non obsolètes (par exemple, utilisez python3 au lieu de python).

Q3. Comment définir des variables d’environnement dans un Dockerfile ?

A3. Utilisez l’instruction ENV pour définir des variables d’environnement disponibles à la fois pendant le temps de construction et l’exécution du conteneur.

Exemple :

ENV DEBIAN_FRONTEND=noninteractive

Cela est couramment utilisé pour supprimer les invites interactives pendant les installations APT. Les variables d’environnement sont également utiles pour la configuration d’application et les clés API.

Q4. Quelle est la différence entre CMD et ENTRYPOINT ?

A4. Les deux spécifient les commandes exécutées quand un conteneur démarre, mais leur comportement diffère.

Exemple :

CMD ["python3", "app.py"]
# vs
ENTRYPOINT ["python3"]
CMD ["app.py"]

Dans le dernier cas, vous pouvez passer des arguments en utilisant docker run my-image another_script.py.

Q5. Pourquoi mes changements dans le Dockerfile ne sont-ils pas reflétés ?

A5. Docker utilise le cache de construction, ce qui peut causer la réutilisation de couches inchangées même après l’édition du Dockerfile.

Solution :

docker build --no-cache -t my-image .

Cela force une reconstruction complète et assure que tous les changements sont appliqués.