Comment exécuter une application Flask en mode production dans Docker

Introduction

Docker est devenu un choix populaire pour le déploiement d'applications web, y compris les applications basées sur Flask. Dans ce tutoriel, nous vous guiderons tout au long du processus de conteneurisation (Dockerization) d'une application Flask et de son exécution en mode production à l'aide de Docker. À la fin de cet article, vous aurez une bonne compréhension de la façon d'utiliser Docker pour déployer votre application Flask dans un environnement de production.

Comprendre Docker

Docker est une plateforme open-source populaire qui permet aux développeurs de construire, déployer et exécuter des applications dans un environnement conteneurisé. Il offre un moyen de regrouper une application et toutes ses dépendances dans un seul conteneur, facilitant ainsi le déplacement de l'application entre différents environnements informatiques.

Qu'est-ce que Docker ?

Docker est une plateforme logicielle qui permet aux développeurs de construire, déployer et exécuter des applications dans des conteneurs. Un conteneur est un package léger, autonome et exécutable qui comprend 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. Les conteneurs sont isolés les uns des autres et du système d'exploitation hôte, garantissant un déploiement d'application cohérent et fiable.

Avantages de Docker

Portabilité : Les conteneurs Docker peuvent s'exécuter de manière cohérente sur différents environnements informatiques, depuis le portable d'un développeur jusqu'au serveur de production, garantissant que l'application se comportera de la même manière, quelle que soit l'infrastructure sous-jacente.
Évolutivité : Docker facilite la montée ou la descente en puissance des applications, en fonction de la demande, 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.
Cohérence : Docker garantit que l'application et ses dépendances sont regroupées, éliminant le problème « ça marche sur ma machine » et assurant un comportement cohérent sur différents environnements.

Architecture Docker

L'architecture Docker se compose des éléments clés suivants :

graph TD
    A[Docker Client] --> B[Docker Daemon]
    B --> C[Docker Images]
    B --> D[Docker Containers]
    B --> E[Docker Networking]
    B --> F[Docker Storage]

Client Docker : Le client Docker est l'interface utilisateur principale pour interagir avec Docker. Il permet aux utilisateurs d'émettre des commandes au démon Docker, telles que la construction, l'exécution et la gestion des conteneurs.
Démon Docker : Le démon Docker est le service backend qui gère la création, la modification et la suppression des objets Docker, tels que les images, les conteneurs, les réseaux et les volumes.
Images Docker : Les images Docker sont les modèles pour créer des conteneurs Docker. Elles contiennent le code de l'application, les bibliothèques, les dépendances et tous les autres fichiers nécessaires pour exécuter l'application.
Conteneurs Docker : Les conteneurs Docker sont les instances en cours d'exécution des images Docker. Ce sont des environnements isolés, légers et portables qui exécutent l'application.
Réseau Docker : Docker offre des fonctionnalités de réseau intégrées qui permettent aux conteneurs de communiquer entre eux et avec le monde extérieur.
Stockage Docker : Docker propose diverses options de stockage, notamment les volumes et les montages liés, pour gérer les données persistantes associées à un conteneur.

Comprendre l'architecture Docker et ses éléments clés est essentiel pour utiliser et gérer efficacement Docker dans vos processus de développement et de déploiement d'applications.

Conteneuriser une application Flask

Dans cette section, nous allons apprendre à conteneuriser une application Flask à l'aide de Docker.

Création d'une application Flask

Commençons par créer une simple application Flask. Créez un nouveau répertoire et accédez-y dans votre terminal. Ensuite, créez un nouveau fichier appelé app.py avec le contenu 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)

Cette application Flask a une seule route qui renvoie le message "Hello, LabEx!".

Conteneurisation de l'application Flask

Pour conteneuriser l'application Flask, nous devons créer un Dockerfile. Créez un nouveau fichier appelé Dockerfile avec le contenu suivant :

FROM python:3.9-slim

WORKDIR /app

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

COPY . .

CMD ["python", "app.py"]

Analysons le Dockerfile :

FROM python:3.9-slim : Cela spécifie l'image de base pour le conteneur Docker, qui dans ce cas est la version légère de l'image Python 3.9.
WORKDIR /app : Cela définit le répertoire de travail à l'intérieur du conteneur sur /app.
COPY requirements.txt . : Cela copie le fichier requirements.txt dans le répertoire de travail du conteneur.
RUN pip install --no-cache-dir -r requirements.txt : Cela installe les dépendances Python spécifiées dans le fichier requirements.txt.
COPY . . : Cela copie tout le code de l'application (y compris app.py) dans le répertoire de travail du conteneur.
CMD ["python", "app.py"] : Cela spécifie la commande à exécuter lorsque le conteneur démarre, qui consiste à exécuter le script app.py à l'aide de l'interpréteur Python.

Construction et exécution du conteneur Docker

Maintenant, construisons l'image Docker et exécutons le conteneur :

Construisez l'image Docker :
```
docker build -t labex-flask-app .
```

Exécutez le conteneur Docker :

docker run -p 5000:5000 labex-flask-app

L'option -p 5000:5000 mappe le port 5000 de l'hôte sur le port 5000 du conteneur, vous permettant d'accéder à l'application Flask depuis votre machine locale.

Après avoir exécuté le conteneur, vous pouvez accéder à l'application Flask en ouvrant un navigateur web et en vous rendant à l'adresse http://localhost:5000. Vous devriez voir le message "Hello, LabEx!" affiché.

Félicitations ! Vous avez réussi à conteneuriser une application Flask à l'aide de Docker.

Exécution d'une application Flask en mode production

Lorsque vous exécutez une application Flask dans un environnement de production, il est important d'utiliser un serveur adapté à la production plutôt que le serveur de développement intégré. Dans cette section, nous allons apprendre à exécuter une application Flask en mode production à l'aide de Docker.

Choix d'un serveur de production

Il existe plusieurs serveurs web adaptés à la production qui peuvent être utilisés pour exécuter une application Flask, tels que Gunicorn, uWSGI et Waitress. Dans cet exemple, nous utiliserons Gunicorn, un serveur web populaire et largement utilisé pour les applications Python.

Modification du Dockerfile

Pour exécuter l'application Flask en mode production à l'aide de Gunicorn, nous devons mettre à jour le Dockerfile. Remplacez le contenu du Dockerfile par le suivant :

FROM python:3.9-slim

WORKDIR /app

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

COPY..

RUN pip install gunicorn

CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

Les principales modifications sont les suivantes :

Nous avons ajouté RUN pip install gunicorn pour installer le serveur web Gunicorn.
Nous avons modifié l'instruction CMD pour utiliser Gunicorn pour démarrer l'application Flask. La commande "gunicorn", "--bind", "0.0.0.0:5000", "app:app" indique à Gunicorn de lier l'application à l'adresse 0.0.0.0:5000 et d'utiliser l'objet app du fichier app.py comme application WSGI.

Construction et exécution du conteneur Docker prêt pour la production

Maintenant, construisons l'image Docker et exécutons le conteneur en mode production :

Construisez l'image Docker :
```
docker build -t labex-flask-app-prod.
```

Exécutez le conteneur Docker :

docker run -p 5000:5000 labex-flask-app-prod

L'application devrait maintenant être exécutée en mode production à l'aide de Gunicorn.

Vérification de la configuration de production

Pour vérifier que l'application Flask est exécutée en mode production, vous pouvez utiliser la commande suivante pour consulter les journaux :

docker logs <container_id>

Vous devriez voir une sortie similaire à la suivante :

[2023-04-11 12:34:56 +0000] [1] [INFO] Starting gunicorn 20.1.0
[2023-04-11 12:34:56 +0000] [1] [INFO] Listening at: http://0.0.0.0:5000 (1)
[2023-04-11 12:34:56 +0000] [1] [INFO] Using worker: sync
[2023-04-11 12:34:56 +0000] [8] [INFO] Booting worker with pid: 8

Cela confirme que l'application Flask est exécutée en mode production à l'aide du serveur web Gunicorn.

Résumé

Ce tutoriel a couvert les étapes essentielles pour exécuter une application Flask en mode production à l'aide de Docker. Nous avons exploré le processus de conteneurisation (Dockerization) d'une application Flask, y compris la création d'un Dockerfile et la construction de l'image Docker. De plus, nous avons discuté de la manière d'exécuter l'application Flask en mode production dans le conteneur Docker, garantissant ainsi un déploiement fiable et évolutif. En suivant les pratiques décrites dans ce guide, vous pouvez utiliser efficacement Docker pour déployer vos applications web basées sur Flask dans un environnement de production.