Dockerfile Ubuntu : Guide du débutant pour les développeurs

1. Introduction

Qu’est-ce que Docker et Dockerfile ?

In recent years, Docker has rapidly gained popularity as a means to streamline the setup of development environments and the deployment of applications. Docker has the unique ability to package an application and its dependencies into a single « container, » which can then be run in the same environment anywhere.

To build this Docker container, a blueprint called « Dockerfile » is necessary. A Dockerfile is a text file that specifies the base OS image, software to be installed, environment variable settings, and more. Developers can use this file to automatically build customized environments.

Raisons de choisir Ubuntu comme base

When creating a Dockerfile, the first step is to specify the base OS image. Among the many options, Ubuntu is particularly popular. Ubuntu is a Debian-based Linux distribution known for its ease of use and the flexibility to build diverse environments thanks to its extensive package repository.

file based on Ubuntu offers the following advantages:

• Une documentation officielle et communautaire abondante est disponible, ce qui réduit la courbe d’apprentissage.
• De nombreux paquets et outils peuvent être installés facilement avec APT (Advanced Package Tool).
• Des images minimales légères (telles que ubuntu:20.04, ubuntu:24.04) sont fournies officiellement.

Objectif et public cible de cet article

In this article, we will focus on the keyword « Dockerfile Ubuntu » and provide an easy-to-understand explanation for beginners on how to create Ubuntu-based Dockerfiles.

Specifically, we will comprehensively cover everything from the basic structure of a Dockerfile to the steps for actually building an Ubuntu environment, examples of installing application environments like Python, and common errors with their solutions.

This article is recommended for:

• Ceux qui souhaitent créer un environnement avec Dockerfile pour la première fois.
• Ceux qui veulent créer un environnement de développement reproductible sur Ubuntu.
• Ceux qui souhaitent approfondir leurs connaissances, y compris la résolution de problèmes.

2. Structure de base d’un Dockerfile

Qu’est‑ce qu’un Dockerfile ? Comprendre son rôle

Un Dockerfile est comme une recette pour créer une image Docker. Concrètement, c’est un fichier qui décrit quel système d’exploitation de base utiliser, quels logiciels installer et quelles configurations appliquer.

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

Avantages d’utiliser un Dockerfile :

• Automatisation de la configuration de l’environnement (pas besoin de reproduire les étapes manuelles).
• Élimine les incohérences d’environnement lors du développement avec plusieurs membres de l’équipe.
• Facile à intégrer dans les pipelines CI/CD.

Instructions de base couramment utilisées (directives) dans un Dockerfile

Un Dockerfile contient plusieurs instructions (directives), dont les suivantes sont les plus représentatives. Nous les combinerons de manière appropriée pour créer un Dockerfile basé sur Ubuntu.

Exemple minimal d’un Dockerfile basé sur Ubuntu

Voici un exemple très basique de Dockerfile basé sur Ubuntu.

FROM ubuntu:24.04

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

CMD ["/bin/bash"]

Ce Dockerfile est configuré pour utiliser Ubuntu 2404 comme base, installer deux utilitaires (curl et vim) et enfin lancer le shell bash.

À propos du choix des tags Ubuntu

Les images Docker Ubuntu sont disponibles sur le dépôt officiel Docker Hub. Bien que spécifier ubuntu:latest utilise la version la plus récente, il est recommandé de fixer explicitement une version.

Par exemple :

• ubuntu:22.04 (LTS : version à support à long terme, privilégie la stabilité)
• ubuntu:24.04 (Candidat LTS le plus récent, privilégie les fonctionnalités)

Réfléchissez à privilégier la stabilité ou les nouvelles fonctionnalités selon votre objectif.

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

Installation des paquets nécessaires pour l’environnement Ubuntu

Lors de la création d’un environnement Ubuntu à l’aide d’un Dockerfile, vous devrez souvent installer paquets supplémentaires. Par exemple, les utilitaires suivants sont couramment utilisés pour configurer un environnement de développement :

• curl: Pour récupérer des fichiers et vérifier les API.
• vim: Un éditeur de texte simple.
• git: Un outil de contrôle de version.
• build-essential: Une collection d’outils de base nécessaires à la compilation de programmes C/C++.

Pour installer ceux-ci 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 dernières listes de paquets sont obtenues avant l’installation.

Configuration d’une installation non interactive

Dans Ubuntu, apt-get install peut nécessiter une saisie utilisateur, mais les opérations interactives ne sont pas possibles pendant le processus de construction du Docker. Par conséquent, il est recommandé de définir la variable d’environnement comme suit pour effectuer l’installation en mode non interactif.

ENV DEBIAN_FRONTEND=noninteractive

Cela évitera les invites telles que « Paramètres régionaux » qui apparaissent lors de la configuration des paquets, permettant à l’installation 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 la taille finale de l’image Docker. Vous pouvez réduire la taille de l’image en supprimant ce cache comme suit :

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

En combinant plusieurs commandes en une seule instruction RUN de cette manière, vous pouvez également éviter la création de couches inutiles.

Bonnes pratiques : organiser votre Dockerfile

Dans les environnements de développement réels, les meilleures pratiques pour écrire des Dockerfiles suivantes sont recommandées :

• Combinez les instructions RUN autant que possible pour réduire le nombre de couches.
• Définissez explicitement les versions et les configurations à l’aide de ENV.
• Utilisez des commentaires pour indiquer clairement le but de chaque opération.
• Utilisez rm et --no-install-recommends pour éviter de laisser des fichiers inutiles.

Exemple :

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

En faisant cela, vous pouvez créer un Dockerfile plus léger et plus maintenable.

4. Construction et vérification de l’image Docker

Construire une image Docker à partir d’un Dockerfile

Une fois que vous avez écrit votre Dockerfile, l’étape suivante consiste à construire l’image Docker. Cela se fait en utilisant la commande docker build. Exécutez la commande suivante dans le répertoire où se trouve votre Dockerfile :

docker build -t my-ubuntu-image .

• L’option -t sert à donner un nom (tag) à l’image. Dans cet exemple, nous l’appelons my-ubuntu-image.
• Le . fait référence au répertoire actuel où se trouve le Dockerfile.

Lorsque vous exécutez cette commande, Docker lit séquentiellement les instructions du Dockerfile et construit une nouvelle image en conséquence.

Vérifier l’image Docker construite

Une fois la création de l’image terminée, vous pouvez la vérifier avec la commande suivante :

docker images

Cela affichera la liste des images Docker présentes localement, et vous pourrez vérifier les informations suivantes :

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

Exemple :

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

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

Démarrer un conteneur Docker et vérifier son fonctionnement

Pour vérifier que l’image créée fonctionne correctement, démarrons un conteneur Docker. Utilisez la commande suivante :

docker run -it my-ubuntu-image

• Spécifier l’option -it vous permet d’ouvrir un terminal en mode interactif.
• Si le conteneur démarre correctement, une invite bash apparaîtra à l’intérieur, et vous vous retrouverez comme si vous étiez connecté à un environnement Ubuntu.

À l’intérieur du conteneur, vous pouvez exécuter des commandes comme celles-ci pour vérifier que les outils installés fonctionnent correctement :

curl --version
vim --version

S’il n’y a aucun problème, le Dockerfile a été rédigé avec succès.

Nettoyer les images et conteneurs inutiles

À mesure que vous répétez les constructions et les expérimentations, des images et conteneurs Docker inutiles peuvent s’accumuler localement. Il est recommandé de les nettoyer périodiquement à l’aide de commandes comme les suivantes :

• Suppression des conteneurs arrêtés :

docker container prune

• Suppression des images inutilisées :

docker image prune

• Suppression de toutes les données inutilisées (Attention !):

docker system prune

Ces opérations permettent de gagner de l’espace disque et d’éviter des problèmes.

5. Application : création d’un environnement Python

Rendre Python utilisable dans un Dockerfile basé sur Ubuntu

En ajoutant un environnement d’exécution Python lors de la construction d’un environnement Ubuntu avec un Dockerfile, vous pouvez prendre en charge un large éventail d’utilisations telles que le développement, les tests et l’apprentissage automatique. Bien qu’Ubuntu puisse déjà inclure Python, il est courant de le construire explicitement soi‑même du point de vue de la gestion des versions et des paquets.

Comment installer Python avec apt

La façon la plus simple est d’installer Python à l’aide des 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/*

Avec cette méthode, vous pouvez utiliser la version stable de Python installée sur le système (généralement Python 3.10 ou 3.12, etc.). De plus, vous pouvez ajouter des paquets Python en utilisant la commande pip.

Gestion des versions de Python avec pyenv

Si vous souhaitez utiliser une version spécifique de Python ou basculer entre plusieurs versions, l’utilisation de pyenv est pratique.
Voici un exemple d’utilisation de pyenv installer Python 3.11.6 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](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

Cela vous permet de créer et de gérer votre environnement Python de manière plus flexible.

Gestion des paquets requirements.txt

Dans les projets réels, vous avez souvent besoin de plusieurs bibliothèques Python. requirements.txt est utilisé pour les gérer.
Tout d’abord, préparez un fichier requirements.txt à la racine de votre projet :

flask==2.3.2
requests>=2.25.1
pandas

Ensuite, décrivez-le dans le Dockerfile comme suit :

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

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

Cela vous permet d’installer toutes les bibliothèques nécessaires en une seule fois, augmentant la reproductibilité de votre environnement de développement.

Bonnes pratiques

• Lors de l’utilisation de Python, créer un environnement virtuel avec virtualenv ou venv peut aider à éviter les conflits de dépendances.
• Vous pouvez réduire la taille de votre image Docker en supprimant le cache (--no-cache-dir).
• Installer la dernière version de pip avec pip install --upgrade pip avant d’installer les paquets Python peut prévenir les erreurs.

6. Problèmes courants et solutions

Erreurs d’autorisation

Exemple :

Permission denied

Cela se produit lorsque le fichier copié n’a pas les permissions d’exécution ou lorsque le propriétaire du fichier/l’utilisateur exécutant n’est pas approprié.

Solutions :

• Rendre le fichier exécutable :

  RUN chmod +x script.sh

• Changer l’utilisateur si nécessaire :

  RUN chown root:root /path/to/file

Paquet introuvable ou impossible à installer

Exemple :

E: Unable to locate package xxx

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

Solutions :

• Toujours exécuter apt-get update avant install :

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

• Vérifiez le nom du paquet pour les fautes de frappe et assurez-vous qu’il est correct.

Erreurs liées au réseau

Exemple :

Temporary failure resolving 'deb.debian.org'

Ce type d’erreur se produit lorsque la résolution DNS échoue pendant le processus de construction.
Solutions :

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

  sudo systemctl restart docker

• Vérifiez les paramètres DNS de Docker (ajoutez les spécifications DNS dans /etc/docker/daemon.json) :

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

La construction reste dans un état ancien en raison des effets du cache

Docker utilise un cache couche par couche pour la rapidité. En conséquence, même si vous modifiez le Dockerfile, il se peut qu’il ne se construise pas comme prévu parce que les couches en cache sont réutilisées.

Solution :

• Reconstruire sans utiliser le cache :

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

La commande de démarrage dans le conteneur échoue à s’exécuter ou se termine immédiatement

Causes :

• La commande spécifiée dans CMD ou ENTRYPOINT rencontre une erreur.
• Même si vous spécifiez ["/bin/bash"] dans CMD, elle se terminera immédiatement si elle n’est pas exécutée de façon interactive.

Solutions :

• Démarrez le conteneur pour le débogage et vérifiez :

  docker run -it my-image /bin/bash

• Comprenez la différence entre CMD et ENTRYPOINT et utilisez-les de manière appropriée à votre objectif.

En rencontrant ces problèmes, vos compétences en conception de Dockerfile s’amélioreront assurément. Lorsque vous rencontrez un problème, lisez calmement le message d’erreur et tracez soigneusement quelle couche ou instruction en est la cause.

7. Conclusion

Récapitulation des points clés pour créer des Dockerfiles basés sur Ubuntu

Dans cet article, nous avons expliqué étape par étape, du basique à l’appliqué, comment créer un environnement Ubuntu avec Dockerfile. Réitérons les points importants ici.

• Comprendre la structure de base d’un Dockerfile est la première étape. Vous pouvez automatiser la configuration de l’environnement en combinant des instructions telles que FROM, RUN, CMD et ENV.
• Ubuntu est une image de base stable et très flexible. Son riche dépôt de paquets, sa large communauté d’utilisateurs et la disponibilité des versions LTS en font une fondation adaptée aux environnements de développement.
• Vous pouvez installer les outils et bibliothèques nécessaires via une gestion de paquets pratique. Savoir comment utiliser apt-get, supprimer le cache et effectuer des installations non interactives est essentiel.
• Construire des environnements pratiques comme Python est également possible avec Dockerfile. Des outils tels que pyenv, pip et requirements.txt vous permettent de créer des environnements de développement hautement reproductibles.
• Les compétences en dépannage conduisent directement à une opération stable. Comprendre les pièges courants tels que les permissions, les problèmes réseau et le cache de construction peut améliorer considérablement l’efficacité du développement.

Prochaines étapes pour apprendre Dockerfile

Être capable de gérer les Dockerfiles vous permet de couvrir un large éventail d’utilisations, non seulement en développement mais aussi en test et déploiement en production. Pour les apprentissages futurs, il serait utile d’aborder les sujets suivants :

• Gérer les configurations multi-conteneurs en utilisant Docker Compose.
• Intégration avec les outils CI/CD (GitHub Actions, GitLab CI, etc.).
• Interopération avec les outils d’orchestration de conteneurs comme Kubernetes.

8. FAQ (Foire aux questions)

Q1. Which version of Ubuntu should I choose in my Dockerfile?

A1. En fait, si vous privilégiez la stabilité et le support à long terme, il est courant de choisir une LTS (Long Term Support) version. Par exemple, ubuntu:22.04 et ubuntu:20.04 sont utilisées dans de nombreux environnements de développement et peuvent être employées en toute confiance grâce à leur période de support de 5 ans.

En revanche, si vous souhaitez utiliser les paquets et versions de langage les plus récents, vous pouvez choisir une version plus récente comme ubuntu:24.04, mais nous recommandons de la tester au préalable.

Q2. Why do I get « Package not found » when using apt-get install?

A2. La raison la plus courante est que vous n’avez pas exécuté apt-get update au préalable. Si vous essayez d’installer sans mettre à jour la liste des paquets, vous obtiendrez une erreur car le paquet correspondant ne peut pas être trouvé dans la liste obsolète.

Exemple d’utilisation correcte :

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

De plus, faites attention aux fautes de frappe dans les noms de paquets et aux noms de paquets obsolètes (par ex., python3 au lieu de python).

Q3. How do I set environment variables in a Dockerfile?

A3. Vous définissez les variables d’environnement à l’aide de l’instruction ENV. Cette variable d’environnement sera valable à la fois pendant la construction et l’exécution du conteneur.

Exemple :

ENV DEBIAN_FRONTEND=noninteractive

Il s’agit d’un réglage typique utilisé pour supprimer les invites interactives lors de l’installation APT. Il sert également à définir les configurations d’application et les clés d’API dans le Dockerfile.

Q4. What is the difference between CMD and ENTRYPOINT in a Dockerfile?

A4. Les deux spécifient les commandes à exécuter au démarrage du conteneur, mais il existe des différences dans leur utilisation et leur comportement.

Exemple :

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

Dans ce dernier cas, vous pouvez passer le CMD comme argument sous la forme docker run my-image another_script.py.

Q5. I edited my Dockerfile, but the changes are not reflected. Why?

A5. Docker utilise le cache pendant le processus de construction, de sorte que même si vous apportez de petites modifications au Dockerfile, des couches en cache peuvent encore être utilisées.

Solution :

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

Cela effectuera une nouvelle construction sans utiliser le cache, et toutes les modifications seront prises en compte.