Comment installer des librairies Python dans une image Docker.

Installer des librairies Python dans une image Docker se fait généralement en modifiant le Dockerfile utilisé pour construire l'image. Voici les étapes et les meilleures pratiques :

Méthode principale : Utiliser pip dans le Dockerfile

La méthode la plus courante et recommandée est d'utiliser le gestionnaire de paquets pip directement dans les instructions de votre Dockerfile.

Étapes générales :

1. Identifier l'image de base : Commencez votre Dockerfile avec une image de base contenant Python. Les images Python officielles sur Docker Hub (python:<version>) sont un bon point de départ.
2. Copier les fichiers de requirements (recommandé) : Créez un fichier requirements.txt dans le même répertoire que votre Dockerfile. Ce fichier listera toutes les librairies Python dont votre application a besoin, avec leurs versions si nécessaire. Cela permet de gérer les dépendances de manière claire et reproductible.

   # requirements.txt
   requests
   pandas==1.5.0
   numpy>=1.20
   

3. Installer les dépendances avec pip : Ajoutez une instruction RUN dans votre Dockerfile pour exécuter pip install -r requirements.txt. Il est important de le faire après avoir copié les fichiers de votre application (ou au moins le fichier requirements.txt) pour profiter du cache de Docker.
4. Copier le reste de l'application : Ajoutez une instruction COPY pour copier le reste de votre code source dans l'image.
5. Définir la commande d'exécution : Utilisez CMD ou ENTRYPOINT pour spécifier la commande à exécuter lorsque le conteneur démarre.

Exemple de Dockerfile :

Dockerfile

# Utilisez une image Python officielle comme base
FROM python:3.11-slim-buster

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

# Copier le fichier de requirements
COPY requirements.txt .

# Installer les dépendances Python
RUN pip install --no-cache-dir -r requirements.txt

# Copier le reste de l'application
COPY . .

# Définir la commande à exécuter lorsque le conteneur démarre
CMD ["python", "main.py"]

Explication des instructions :

• FROM python:3.11-slim-buster: Indique que l'image de base est la version 3.11 de Python, basée sur Debian Buster (une version allégée).
• WORKDIR /app: Définit le répertoire /app comme le répertoire de travail à l'intérieur du conteneur. Les commandes suivantes s'exécuteront dans ce contexte.
• COPY requirements.txt .: Copie le fichier requirements.txt du répertoire hôte vers le répertoire de travail (/app) dans l'image.
• RUN pip install --no-cache-dir -r requirements.txt: Exécute la commande pip install pour installer les librairies listées dans requirements.txt.
  • --no-cache-dir: Désactive le cache de pip pour réduire la taille de l'image finale.
  • -r requirements.txt: Indique à pip de lire la liste des paquets à installer depuis le fichier requirements.txt.
• COPY . .: Copie tout le contenu du répertoire hôte (où se trouve le Dockerfile) vers le répertoire de travail (/app) dans l'image. Attention : Dans un projet plus complexe, il est préférable de copier uniquement les fichiers nécessaires pour éviter d'inclure des éléments inutiles dans l'image. Utilisez un fichier .dockerignore pour exclure certains fichiers et dossiers.
• CMD ["python", "main.py"]: Définit la commande par défaut à exécuter lorsque le conteneur démarre. Dans cet exemple, il exécute le script Python main.py.

Autres méthodes (moins courantes ou pour des cas spécifiques) :

• Installer directement des paquets sans requirements.txt : Vous pouvez lister les paquets directement dans la commande RUN pip install : Dockerfile
  

  RUN pip install --no-cache-dir requests pandas numpy
  

  Cependant, cette méthode est moins maintenable et il est difficile de suivre les versions des dépendances.
• Inclure les librairies dans l'image de base (moins courant pour les applications spécifiques) : Vous pourriez créer une image de base personnalisée qui inclut déjà certaines librairies courantes. Cela est plus pertinent pour des équipes ou des environnements avec des besoins très spécifiques.
• Utiliser un environnement virtuel (généralement non nécessaire dans Docker) : Bien que vous utilisiez souvent des environnements virtuels localement pendant le développement, dans un contexte Docker, l'image elle-même est isolée. Il n'est généralement pas nécessaire de créer un environnement virtuel distinct à l'intérieur de l'image. pip install installera les librairies globalement dans l'environnement Python de l'image.

Meilleures pratiques :

• Utiliser un fichier requirements.txt : C'est la méthode la plus recommandée pour la gestion des dépendances.
• Installer les dépendances avant de copier le code de l'application : Cela permet de profiter du cache de Docker. Si les dépendances ne changent pas, la couche d'installation sera mise en cache et la construction de l'image sera plus rapide lors des modifications ultérieures du code de l'application.
• Utiliser --no-cache-dir avec pip : Cela réduit la taille de l'image en évitant de stocker le cache de téléchargement des paquets.
• Choisir une image de base minimale : Les images -slim ou -alpine sont plus petites et contiennent moins de composants inutiles, ce qui réduit la taille de l'image finale et potentiellement les risques de sécurité. Cependant, assurez-vous que l'image choisie contient les dépendances système nécessaires à vos librairies Python.
• Nettoyer les paquets inutiles (si nécessaire) : Pour les images très petites, vous pouvez ajouter des commandes pour supprimer les fichiers temporaires et les paquets inutiles après l'installation des dépendances. Cela est plus courant avec les images basées sur Alpine Linux.
• Utiliser un fichier .dockerignore : Pour éviter de copier des fichiers inutiles (comme les environnements virtuels locaux, les fichiers .git, etc.) dans votre image Docker, créez un fichier .dockerignore à la racine de votre projet.