Cours
Principes de génie logiciel en Python
4 h
69.8K
Imaginez que vous ayez mené un projet de machine learning de bout en bout et trouvé la meilleure solution avec des modèles performants. Pourtant, une fois votre code remis à l’équipe d’ingénierie, ce qui fonctionnait chez vous ne marche plus sur leurs serveurs, dont le système d’exploitation et les versions de bibliothèques diffèrent.
Malgré toute votre rigueur, cette situation frustrante peut arriver. La plupart des développeurs y sont confrontés au moins une fois. Quelle est la solution ? C’est là que Docker entre en jeu. Avec Docker, vous définissez un environnement précis et cohérent pour votre projet, garantissant l’exécution fiable de votre code, quel que soit l’environnement sous-jacent.
Ce tutoriel vous présente Docker et ses concepts associés, et explique pourquoi il est essentiel pour les data scientists. Nous verrons ensuite comment l’installer et l’utiliser sur votre prochain projet, exemples à l’appui. Enfin, vous découvrirez les meilleures pratiques à adopter dans l’industrie et trouverez des réponses à toutes vos questions sur Docker.
Qu’est-ce que Docker, les conteneurs et les images ?
Docker est une plateforme pour créer, exécuter et livrer des applications.
Les conteneurs sont des paquets légers, autonomes et exécutables qui contiennent tout le nécessaire pour faire tourner une application : code, runtime, bibliothèques, variables d’environnement et fichiers de configuration.
Une image Docker est un fichier en lecture seule contenant toutes les instructions nécessaires pour créer un conteneur. Les images servent de base pour démarrer de nouveaux conteneurs à l’exécution.
Docker permet aux développeurs d’empaqueter leurs applications avec leurs dépendances dans un conteneur, exécutable sur toute machine disposant de Docker.
En quelque sorte, c’est comme si vous receviez une nouvelle machine pour un projet. Vous y installez les paquets requis, copiez les fichiers nécessaires et lancez les scripts. Vous pouvez ensuite « expédier » cette machine ailleurs. L’analogie est simplifiée, mais l’idée est là.
En quoi les conteneurs Docker diffèrent-ils des machines virtuelles ?
Dès que l’on définit les conteneurs, une question se pose : en quoi diffèrent-ils des machines virtuelles, puisque les deux technologies permettent d’exécuter plusieurs environnements isolés sur la même machine physique ?
Observez la différence d’architecture dans l’image ci-dessous et voyez si vous repérez la nuance.
Image de l’auteur
Chaque machine virtuelle est un environnement isolé pouvant exécuter des systèmes et configurations différents. Cela implique qu’elle embarque une copie complète du système d’exploitation, ce qui consomme beaucoup de ressources. Une application conteneurisée, à l’inverse, s’exécute dans un environnement isolé sans nécessiter une copie complète du système, d’où un fonctionnement plus léger et plus efficace.
Si les machines virtuelles sont utiles, les conteneurs sont en général suffisants et idéaux pour livrer des applications.
Pourquoi Docker pour les data scientists ?
Vous vous demandez peut-être pourquoi apprendre Docker en tant que data scientist. N’est-ce pas le rôle des équipes DevOps de gérer l’infrastructure ?
Question légitime — mais Docker est extrêmement important pour les data scientists, même avec une équipe DevOps. Voyons pourquoi Docker est si utile.
Intégration avec l’équipe DevOps
La présence d’une équipe DevOps n’annule pas les bénéfices de Docker ; au contraire, l’outil facilite le passage de relais entre développement et opérations. Les data scientists peuvent empaqueter leur code avec Docker et le transmettre à l’équipe DevOps pour le déploiement et la montée en charge. Vous le verrez souvent dans des équipes data structurées.
Environnement cohérent et reproductibilité
Les data scientists travaillent souvent avec des dépendances et configurations complexes à installer et maintenir. L’environnement doit rester identique pour obtenir des résultats comparables. Docker permet de créer et partager un environnement cohérent, avec toutes les dépendances et configurations préinstallées, facilement réplicable par d’autres.
Portabilité
Les conteneurs Docker s’exécutent sur tout environnement doté de Docker : ordinateurs portables, serveurs ou plateformes cloud. Les data scientists peuvent ainsi déplacer facilement leur travail d’un environnement à l’autre.
Isolement des ressources
Docker permet d’exécuter plusieurs conteneurs sur la même machine, chacun avec ses ressources isolées. Cela aide à gérer les ressources plus efficacement et à éviter les conflits entre applications. Si vous avez plusieurs projets de ML, cette fonctionnalité peut vous sauver la mise.
Favoriser la collaboration
Docker permet de partager son travail, y compris avec des équipes à distance, sous forme de conteneurs. La collaboration est centrale dans le métier, et Docker réduit considérablement les frictions.
La plupart des data scientists expérimentés s’accordent à dire qu’avec Docker, ils peuvent se concentrer sur leur travail sans se soucier de l’infrastructure sous-jacente.
Tutoriel Docker : utiliser Docker sur votre prochain projet
Maintenant que nous avons établi l’intérêt de Docker pour un data scientist, passons sans tarder à la prise en main. Commençons par installer Docker et nous familiariser avec les commandes usuelles.
Installer Docker sur votre machine ou serveur local
Docker est disponible pour les principaux systèmes d’exploitation : Linux, Windows et Mac. L’installation est simple et mieux décrite dans la documentation officielle.
- Instructions d’installation de Docker pour Linux.
- Instructions d’installation de Docker pour Windows.
- Instructions d’installation de Docker pour Mac.
Si vous souhaitez créer vos propres images et les pousser sur Docker Hub (comme dans certains exemples ci-dessous), vous devez créer un compte sur Docker Hub. Pensez à Docker Hub comme à un hub central où les développeurs stockent et partagent leurs images Docker.
Se familiariser avec les commandes Docker courantes
Une fois Docker installé sur votre machine (ou serveur), l’étape suivante consiste à vous familiariser avec quelques commandes. Voici la liste de référence dans la documentation officielle Docker.
Pour vous lancer, nous avons rassemblé les dix commandes les plus utilisées que vous rencontrerez très vite.
- docker run : lance un conteneur à partir d’une image. L’option -p mappe un port de l’hôte vers un port du conteneur. Par exemple, la commande suivante lance un conteneur depuis l’image "nginx" et mappe le port 80 de l’hôte sur le port 80 du conteneur.
docker run -p 80:80 nginx- docker ps : liste tous les conteneurs en cours d’exécution. Utile quand plusieurs conteneurs isolés tournent sur la même machine.
docker ps- docker stop : arrête un conteneur en cours d’exécution.
docker stop <container_id>- docker rm : supprime un conteneur arrêté.
docker rm <container_id>- docker images : liste toutes les images présentes sur la machine hôte. Utile pour visualiser les images locales disponibles avant de créer un conteneur.
docker images- docker rmi : supprime une image.
docker rmi <image_id>- docker build : construit une image à partir d’un Dockerfile. L’option -t spécifie le nom de l’image et le . final indique le contexte de build (le répertoire courant).
docker build -t my_image .- docker exec : exécute une commande à l’intérieur d’un conteneur en cours d’exécution.
docker exec -it <container_id> /bin/bash- docker pull : récupère une image depuis un registre, par exemple Docker Hub.
docker pull <image_name>- docker push : pousse une image vers un registre.
docker push <image_name>
Maintenant que nous avons vu l’installation et les commandes de base, passons à la containerisation d’une application de machine learning.
Vous souhaitez obtenir une certification Docker ? Consultez notre guide pour passer une certification Docker !
Containeriser une application de machine learning simple
Containeriser une application de machine learning est plus simple qu’il n’y paraît si l’on suit trois étapes claires.
Image de l’auteur.
Pour rester simple, prenons un script d’initiation au machine learning. L’objectif est de montrer comment containeriser un script. L’exemple ci-dessous entraîne un modèle de régression logistique sur le jeu de données iris.
# Load the libraries
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# Load the iris dataset
iris = load_iris()
X = iris.data
y = iris.target
# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# Train a logistic regression model
clf = LogisticRegression()
clf.fit(X_train, y_train)
# Make predictions
y_pred = clf.predict(X_test)
# Print the accuracy of the model
accuracy_score = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy_score}')1. Définir l’environnement
Vous devez connaître précisément l’environnement actuel pour pouvoir le reproduire ailleurs. Le moyen le plus simple (et le plus courant) consiste à créer un fichier requirements.txt listant toutes les bibliothèques utilisées par votre projet, avec leurs versions.
Voici à quoi peut ressembler le contenu du fichier :
scikit-learn==1.2.0
Remarque : une application de machine learning plus complète utilisera davantage de bibliothèques comme NumPy, pandas, matplotlib, etc. Ainsi, créer un fichier requirements.txt est préférable à l’installation « à la main » d’une seule bibliothèque (nous y revenons dans les meilleures pratiques).
2. Écrire un Dockerfile
Ensuite, créez un fichier nommé Dockerfile pour définir l’environnement et y exécuter l’application. Dit simplement, c’est le mode d’emploi de Docker : vous y décrivez l’environnement, son contenu et les étapes d’exécution.
FROM python:3.9
WORKDIR /src
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python","iris_classification.py"]Ce Dockerfile utilise l’image officielle Python comme base, définit le répertoire de travail, copie le fichier requirements.txt et installe les dépendances, copie le code de l’application, puis lance la commande python iris_classification.py pour démarrer l’application.
3. Construire l’image
Dernière étape pour obtenir un environnement reproductible : créer une image (un modèle) à partir de laquelle vous pourrez démarrer autant de conteneurs que nécessaire avec la même configuration.
Construisez l’image en exécutant la commande docker build -t <image-name> . dans le même répertoire que le Dockerfile.
Maintenant que vous avez containerisé notre application de machine learning simple, vous pouvez utiliser docker run pour créer des conteneurs, puis les arrêter selon vos besoins. Nous avons vu plus haut les commandes principales.
Passons des bases aux attentes de l’industrie.
Meilleures pratiques pour utiliser Docker à l’échelle
Comprendre les bases suffit pour démarrer, mais en contexte professionnel, il est essentiel d’appliquer les bonnes pratiques.
Limiter le nombre de couches
Chaque instruction du Dockerfile crée une nouvelle couche. Trop de couches alourdissent l’image et ralentissent les transferts.
Regardez l’exemple ci-dessous :
# Use the official Python image as the build image
FROM python:3.9
# Install the dependencies
RUN pip install pandas
RUN pip install matplotlib
RUN pip install seaborn
# Copy neccesary files
COPY my_script.py .
COPY data/ .
# Run the script
CMD ["python","my_script.py"]
Quel est le problème ? L’utilisation de plusieurs commandes run et copy est superflue. Voici une version corrigée :
# Use the official Python image as the build image
FROM python:3.9
# Install the dependencies using requirements.txt
COPY my_script.py requirements.txt data/ .
RUN pip install --no-cache-dir -r requirements.txt
# Run the script
CMD ["python","my_script.py"]Sur un petit fichier, cela saute aux yeux, mais vous seriez surpris de voir à quel point on écrit souvent des Dockerfiles plus verbeux que nécessaire. Grouper les commandes ayant des fonctions similaires ou modifiant les mêmes fichiers permet de réduire le nombre de couches.
Utiliser des images officielles
Les images officielles sont maintenues et prises en charge par l’éditeur. Elles sont généralement plus stables et plus sûres que d’autres images.
Par empressement, on utilise parfois une image non officielle. Dans la mesure du possible, basez vos images sur des images officielles.
Build multi-étapes pour optimiser les performances
Un build multi-étapes dans Docker permet d’utiliser plusieurs instructions FROM dans un même Dockerfile.
On peut utiliser une image plus lourde pour la phase de build de l’application, puis copier les fichiers nécessaires dans une image d’exécution plus légère. En excluant les fichiers inutiles, on réduit la taille de l’image finale : c’est plus performant et plus sûr.
Voyons un exemple courant dans l’industrie :
# Use the official Python image as the build image
FROM python:3.9 AS build
# Set the working directory
WORKDIR /app
# Copy the requirements.txt file
COPY requirements.txt ./
# Install the dependencies
RUN pip install --no-cache-dir -r requirements.txt
# Copy the application files
COPY . .
# Train the model
RUN python train.py
# Use the official Alpine Linux image as the runtime image
FROM alpine:3
# Set the working directory
WORKDIR /app
# Copy the model files from the build image
COPY --from=build /app/models /app/models
# Copy the requirements.txt file
COPY --from=build /app/requirements.txt /app
# Install the dependencies
RUN pip install --no-cache-dir -r requirements.txt
# Run the application
CMD ["python","predict.py"]Pour décrypter : nous utilisons d’abord l’image officielle Python comme image de build et y installons les dépendances.
Après exécution de train.py, nous copions les fichiers du modèle et le requirements.txt vers une image Alpine Linux plus légère pour l’exécution, afin de lancer l’application. En recourant au build multi-étapes et en excluant les dépendances de build et l’interpréteur Python de l’image finale, nous obtenons une image nettement plus compacte.
Utiliser des volumes pour persister les données
Les données d’un conteneur disparaissent lorsqu’il est arrêté et supprimé, alors que vous avez parfois besoin des résultats d’expériences plus tard. Vous pouvez aussi vouloir partager des données entre plusieurs conteneurs.
Avec la directive de volume, vous vous assurez que les données sont stockées en dehors du conteneur. Exemple :
# Use the official Python image as the base image
FROM python:3.9
# Set the working directory
WORKDIR /app
# Copy the requirements.txt file
COPY requirements.txt ./
# Install the dependencies
RUN pip install --no-cache-dir -r requirements.txt
# Copy the rest of the application files
COPY . .
# Create a directory for storing data
RUN mkdir /app/data
# Define a volume for the data directory
VOLUME /app/data
# Run the application
CMD ["python","main.py"]Organiser et versionner les images Docker
Quand vous multipliez les images Docker, il devient nécessaire de les organiser. Les pratiques varient selon les organisations, mais voici des usages répandus :
- Suivre une convention de nommage cohérente pour chaque image. Par exemple : <registry>/<organization>/<image>:<version>. Cela facilite l’identification des images et de leurs versions dans le registre.
- Appliquer des pratiques de versioning pour pouvoir revenir à une version antérieure si besoin. Comme vu ci-dessus, la version s’intègre au nommage et peut suivre le schéma <version majeure>.<version mineure>.<correctif>.
- Taguer les images avec des libellés parlants (latest, staging, production) aide à organiser et piloter les images selon les environnements et étapes de déploiement.
Il est recommandé de s’aligner avec les conventions de votre organisation afin que toute l’équipe les applique.
Conclusion
Cet article a souligné l’importance de créer des codes et applications reproductibles grâce à des outils comme Docker pour les data scientists. Nous avons présenté l’intérêt de Docker, les étapes d’installation et les commandes les plus utilisées. Nous avons ensuite montré comment containeriser une application de machine learning via des exemples, avant d’énoncer les meilleures pratiques à suivre en entreprise.
Pour aller plus loin, suivez notre cours Introduction to Docker, qui couvre l’essentiel. Vous pouvez aussi envisager de passer une certification Docker si vous travaillez dans le domaine.
Beaucoup de data scientists se concentrent sur les compétences cœur comme les statistiques, les mathématiques, le machine learning, le deep learning et le code, mais négligent les bonnes pratiques d’ingénierie logicielle attendues en entreprise.
Si vous souhaitez consolider vos fondamentaux en data science, découvrez le parcours Data Scientist with Python qui propose un apprentissage guidé par projets. À l’inverse, si vous voulez renforcer vos compétences d’ingénierie logicielle, explorez le cours software engineering for data scientists with Python, qui couvre des notions essentielles comme la modularité, la documentation et les tests automatisés.