Exécution d'une application Python dans un conteneur Docker : Guide complet

Introduction

Docker est devenu un véritable changement de paradigme dans le monde du développement logiciel, permettant aux développeurs d'emballer leurs applications et leurs dépendances dans des unités portables et autonomes appelées conteneurs. Dans ce tutoriel, nous vous guiderons à travers le processus d'exécution d'une application Python dans un conteneur Docker, couvrant les étapes essentielles, de la compréhension de Docker au déploiement de l'application conteneurisée.

Comprendre Docker

Qu'est-ce que Docker ?

Docker est une plateforme open-source qui permet aux développeurs de construire, déployer et exécuter des applications dans un environnement conteneurisé. Les conteneurs sont des paquets logiciels légers, autonomes et exécutables qui incluent tout ce dont une application a besoin pour fonctionner, y compris le code, l'environnement d'exécution, les outils système et les bibliothèques. Docker fournit un moyen d'emballer et de distribuer ces conteneurs, ce qui facilite le déploiement et la gestion des applications dans différents environnements.

Avantages de l'utilisation de Docker

Cohérence : Les conteneurs Docker garantissent que l'application fonctionne de la même manière, quel que soit l'infrastructure sous-jacente.
Scalabilité : Docker facilite le dimensionnement des applications, en ajoutant ou en supprimant des conteneurs selon les besoins.
Efficacité : Les conteneurs Docker sont légers et utilisent moins de ressources que les machines virtuelles traditionnelles, permettant une utilisation plus efficace des ressources informatiques.
Portabilité : Les conteneurs Docker peuvent être facilement déplacés entre différents environnements, tels que le développement, les tests et la production, sans avoir besoin de modifications de configuration complexes.

Architecture Docker

L'architecture Docker est basée sur un modèle client-serveur, où le client Docker communique avec le démon Docker, responsable de la construction, de l'exécution et de la gestion des conteneurs Docker. Les composants clés de l'architecture Docker incluent :

graph LR A[Client Docker] -- Communique avec --> B[Démon Docker] B -- Gère --> C[Images Docker] B -- Gère --> D[Conteneurs Docker] B -- Gère --> E[Volumes Docker] B -- Gère --> F[Réseaux Docker]

Démarrer avec Docker

Pour commencer à utiliser Docker, vous devez installer le moteur Docker sur votre système. Vous pouvez télécharger et installer Docker sur le site Web officiel Docker (https://www.docker.com/get-started). Une fois installé, vous pouvez utiliser l'interface de ligne de commande (CLI) docker pour interagir avec le démon Docker et gérer vos conteneurs.

Voici un exemple de la façon d'exécuter un conteneur simple "Bonjour, monde !" avec Docker :

$ docker run hello-world

Cette commande va télécharger l'image hello-world à partir du registre Docker Hub, créer un nouveau conteneur et exécuter l'application à l'intérieur du conteneur.

Contenir une application Python

Créer une image Docker pour une application Python

Pour contenir une application Python à l'aide de Docker, vous devez créer une image Docker. Une image Docker est un paquet exécutable léger et autonome qui inclut tout ce dont l'application a besoin pour fonctionner, y compris le code, l'environnement d'exécution, les outils système et les bibliothèques.

Voici un exemple de création d'une image Docker pour une application Python simple :

Créez un nouveau répertoire pour votre projet et accédez-y dans votre terminal.

Créez un nouveau fichier appelé app.py et ajoutez le code Python suivant :

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, LabEx!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Créez un nouveau fichier appelé Dockerfile et ajoutez le contenu suivant :
```
FROM python:3.9-slim
WORKDIR /app
COPY . /app
RUN pip install --no-cache-dir -r requirements.txt
CMD ["python", "app.py"]
```
Ce Dockerfile définit les étapes pour construire l'image Docker de votre application Python. Il commence par l'image de base python:3.9-slim, définit le répertoire de travail à /app, copie les fichiers de l'application dans le conteneur, installe les dépendances requises et exécute le script app.py.
Créez un nouveau fichier appelé requirements.txt et ajoutez la dépendance suivante :
```
flask
```
Construisez l'image Docker à l'aide de la commande suivante :
```
$ docker build -t my-python-app .
```
Cette commande construit l'image Docker avec l'étiquette my-python-app.

Exécuter l'application Python dans un conteneur Docker

Une fois que vous avez l'image Docker, vous pouvez exécuter l'application Python dans un conteneur Docker à l'aide de la commande suivante :

$ docker run -p 5000:5000 my-python-app

Cette commande exécute le conteneur my-python-app, en mappant le port 5000 du conteneur au port 5000 de l'hôte.

Vous pouvez maintenant accéder à l'application Python en ouvrant un navigateur web et en accédant à http://localhost:5000. Vous devriez voir le message "Hello, LabEx!" affiché.

Déploiement du conteneur Docker

Publication de l'image Docker sur un registre

Pour déployer votre conteneur Docker, vous devez d'abord publier l'image Docker sur un registre, comme Docker Hub ou un registre privé. Cela vous permet de partager et de distribuer votre application vers d'autres environnements.

Voici comment publier votre image my-python-app sur Docker Hub :

Créez un compte Docker Hub (si ce n'est pas déjà fait) sur https://hub.docker.com.
Connectez-vous à Docker Hub à l'aide de la commande docker login :
```
$ docker login
```
Entrez votre nom d'utilisateur et votre mot de passe Docker Hub lorsque vous y êtes invité.
Marquez votre image locale my-python-app avec votre nom d'utilisateur Docker Hub et une étiquette (par exemple, latest) :
```
$ docker tag my-python-app username/my-python-app:latest
```

Publiez l'image marquée sur Docker Hub :

$ docker push username/my-python-app:latest

Votre image Docker est maintenant disponible sur le registre Docker Hub et peut être extraite et déployée sur d'autres systèmes.

Déploiement du conteneur Docker

Pour déployer le conteneur Docker dans un environnement de production, vous pouvez utiliser une plateforme d'orchestration de conteneurs comme Kubernetes ou Docker Swarm. Ces plateformes offrent des fonctionnalités pour le dimensionnement, la charge équilibrée et la gestion du cycle de vie de vos conteneurs.

Voici un exemple de déploiement du conteneur my-python-app à l'aide de Docker Swarm :

Initialisez un cluster Docker Swarm :
```
$ docker swarm init
```
Créez un nouveau service pour le conteneur my-python-app :
```
$ docker service create --name my-python-app -p 5000:5000 username/my-python-app:latest
```
Cette commande crée un nouveau service nommé my-python-app et exécute l'image username/my-python-app:latest, en mappant le port 5000 du conteneur au port 5000 de l'hôte.
Mettez à l'échelle le service vers plusieurs répliques :
```
$ docker service scale my-python-app=3
```
Cette commande met à l'échelle le service my-python-app à 3 répliques, offrant une haute disponibilité et une charge équilibrée pour l'application.
Surveillez l'état du service :
```
$ docker service ls
$ docker service logs my-python-app
```
Ces commandes vous permettent d'afficher l'état du service my-python-app et d'inspecter les journaux.

En utilisant une plateforme d'orchestration de conteneurs comme Docker Swarm, vous pouvez facilement gérer, mettre à l'échelle et déployer vos conteneurs Docker dans un environnement de production.

Résumé

À la fin de ce tutoriel, vous aurez une compréhension solide de Docker et la capacité de contenir votre application Python. Vous apprendrez à construire une image Docker, à exécuter le conteneur et à déployer votre application de manière cohérente, fiable et évolutive. Maîtriser Docker pour le développement Python optimisera votre flux de travail et rendra votre application plus portable et facile à gérer.