Exposer un serveur web Flask dans un conteneur Docker : Guide complet

Introduction

Dans ce tutoriel, nous explorerons comment exposer un serveur web Flask exécuté à l'intérieur d'un conteneur Docker. À la fin de ce guide, vous apprendrez à construire une application Flask, à l'emballer dans un conteneur Docker et à la rendre accessible à l'extérieur. Que vous soyez développeur web ou ingénieur DevOps, ce tutoriel vous fournira les connaissances nécessaires pour tirer parti de Docker pour vos projets basés sur Flask.

Introduction à Docker et Flask

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 cohérent et isolé appelé conteneurs. Les conteneurs regroupent une application et toutes ses dépendances dans une seule unité portable, garantissant que l'application fonctionnera de la même manière quel que soit l'infrastructure sous-jacente.

Qu'est-ce que Flask ?

Flask est un framework web Python léger et open-source. Il est conçu pour être facile à utiliser et à démarrer, ce qui en fait un choix populaire pour la création d'applications web, d'API et de microservices. Flask offre un moyen simple et flexible de créer des applications web, en gérant des tâches telles que le routage, la gestion des requêtes HTTP et l'affichage de modèles.

Pourquoi utiliser Docker avec Flask ?

Combiner Docker et Flask offre plusieurs avantages :

Déploiement cohérent : Les conteneurs Docker garantissent que l'application Flask et ses dépendances sont regroupées, ce qui facilite le déploiement cohérent de l'application dans différents environnements (par exemple, développement, préproduction, production).
Scalabilité : La conteneurisation de Docker facilite la mise à l'échelle de l'application Flask en exécutant plusieurs instances du conteneur, lui permettant de gérer un trafic et une charge accrus.
Isolation : Les conteneurs Docker offrent un niveau d'isolation, garantissant que l'application Flask et ses dépendances sont isolées du système hôte et des autres applications, réduisant ainsi le risque de conflits et rendant l'application plus sécurisée.
Portabilité : Les conteneurs Docker peuvent être facilement partagés et déplacés entre différentes plateformes et environnements, ce qui facilite le développement, les tests et le déploiement de l'application Flask.

Configuration de l'environnement de développement

Pour commencer à utiliser Docker et Flask, vous devez avoir les éléments suivants installés sur votre système :

Docker : Vous pouvez télécharger et installer Docker sur le site officiel (https://www.docker.com/get-started).
Python : Flask étant un framework web Python, vous devez avoir Python installé sur votre système. Vous pouvez télécharger Python sur le site officiel (https://www.python.org/downloads/).

Une fois Docker et Python installés, vous pouvez commencer à construire votre application Flask et à la déployer dans un conteneur Docker.

graph TD
    A[Installer Docker] --> B[Installer Python]
    B --> C[Construire l'application Flask]
    C --> D[Déplacer Flask dans le conteneur Docker]

Création d'une application web Flask

Création d'une application Flask

Pour créer une application web Flask, suivez ces étapes :

Installation de Flask : Ouvrez un terminal et exécutez la commande suivante pour installer Flask :
```
pip install flask
```
Création d'une application Flask : Créez un nouveau fichier Python (par exemple, app.py) et ajoutez le code suivant :
```
from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return 'Bonjour, LabEx !'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
```
Ce code crée une application Flask de base avec une seule route (/) qui renvoie le message "Bonjour, LabEx !".
Exécution de l'application Flask : Dans le terminal, accédez au répertoire contenant le fichier app.py et exécutez la commande suivante :
```
python app.py
```
Ceci démarrera le serveur de développement Flask et rendra votre application disponible à l'adresse http://localhost:5000/.

Ajout de routes et de vues

Pour ajouter plus de fonctionnalités à votre application Flask, vous pouvez créer des routes et des vues supplémentaires :

from flask import Flask, render_template, request

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/about')
def about():
    return render_template('about.html')

@app.route('/contact', methods=['GET', 'POST'])
def contact():
    if request.method == 'POST':
        ## Gérer la soumission du formulaire
        return 'Formulaire soumis avec succès !'
    return render_template('contact.html')

Dans cet exemple, nous avons ajouté trois routes : / (la page d'accueil), /about (une page À propos) et /contact (un formulaire de contact). La route du formulaire de contact gère les requêtes GET et POST, permettant aux utilisateurs d'afficher le formulaire et de le soumettre.

Affichage de modèles

Flask utilise le moteur de modèles Jinja2 pour afficher les modèles HTML. Créez un répertoire templates dans votre projet et ajoutez les fichiers suivants :

index.html :

<!doctype html>
<html>
  <head>
    <title>Application Flask LabEx</title>
  </head>
  <body>
    <h1>Bienvenue dans l'application Flask LabEx !</h1>
    <p>Ceci est la page d'accueil.</p>
  </body>
</html>

about.html :

<!doctype html>
<html>
  <head>
    <title>À propos - Application Flask LabEx</title>
  </head>
  <body>
    <h1>À propos de l'application Flask LabEx</h1>
    <p>Ceci est la page À propos.</p>
  </body>
</html>

contact.html :

<!doctype html>
<html>
  <head>
    <title>Contact - Application Flask LabEx</title>
  </head>
  <body>
    <h1>Contactez-nous</h1>
    <form method="post">
      <label for="name">Nom :</label>
      <input type="text" id="name" name="name" /><br />

      <label for="email">Email :</label>
      <input type="email" id="email" name="email" /><br />

      <label for="message">Message :</label>
      <textarea id="message" name="message"></textarea><br />

      <input type="submit" value="Envoyer" />
    </form>
  </body>
</html>

Ces modèles fournissent une structure de base pour les pages de votre application Flask.

Déploiement de Flask dans un conteneur Docker

Création d'un Dockerfile

Pour déployer votre application Flask dans un conteneur Docker, vous devez créer un Dockerfile. Un Dockerfile est un fichier texte contenant les instructions pour construire une image Docker.

Voici un exemple de Dockerfile pour votre application Flask :

## Utilisation de l'image Python officielle comme image de base
FROM python:3.9-slim

## Définition du répertoire de travail à /app
WORKDIR /app

## Copie du fichier requirements.txt dans le conteneur
COPY requirements.txt .

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

## Copie du code de l'application Flask dans le conteneur
COPY . .

## Exposition du port sur lequel l'application Flask fonctionnera
EXPOSE 5000

## Définition de la commande pour démarrer l'application Flask
CMD ["python", "app.py"]

Ce Dockerfile effectue les opérations suivantes :

Utilise l'image Python 3.9 slim officielle comme image de base.
Définit le répertoire de travail à /app.
Copie le fichier requirements.txt dans le conteneur.
Installe les dépendances Python listées dans le fichier requirements.txt.
Copie le code de l'application Flask dans le conteneur.
Expose le port 5000, qui est le port par défaut du serveur de développement Flask.
Définit la commande pour démarrer l'application Flask.

Construction et exécution de l'image Docker

Pour construire l'image Docker, exécutez la commande suivante dans le même répertoire que votre Dockerfile :

docker build -t labex-flask-app .

Ceci créera une image Docker nommée labex-flask-app basée sur les instructions du Dockerfile.

Pour exécuter le conteneur Docker, utilisez la commande suivante :

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

Ceci démarrera le conteneur Docker et mappera le port 5000 de l'hôte au port 5000 dans le conteneur, vous permettant d'accéder à l'application Flask à l'adresse http://localhost:5000/.

Mise à l'échelle et gestion du conteneur Docker

Une fois votre application Flask déployée dans un conteneur Docker, vous pouvez profiter des fonctionnalités de mise à l'échelle et de gestion de Docker :

Mise à l'échelle : Vous pouvez facilement mettre à l'échelle votre application Flask en exécutant plusieurs instances du conteneur Docker, manuellement ou à l'aide d'outils d'orchestration de conteneurs comme Docker Compose ou Kubernetes.
Supervision : Docker fournit des outils et des intégrations intégrés pour surveiller l'état et les performances de vos conteneurs, ce qui facilite la gestion de votre application Flask en production.
Versioning et Rollbacks : L'approche basée sur les images de Docker facilite la version de votre application Flask et la réalisation de rollbacks si nécessaire, garantissant un processus de déploiement plus fiable et stable.

En utilisant Docker, vous pouvez garantir que votre application Flask est déployée et gérée de manière cohérente sur différents environnements, simplifiant ainsi le cycle de développement, de test et de production.

Résumé

Dans ce tutoriel, vous avez appris à exposer un serveur web Flask exécuté dans un conteneur Docker. En encapsulant votre application Flask dans un conteneur Docker, vous pouvez garantir un déploiement cohérent et fiable sur différents environnements. Grâce aux connaissances acquises, vous pouvez désormais tirer parti de la puissance de Docker pour rationaliser vos processus de développement et de déploiement web Flask.

Comment exposer un serveur web Flask dans un conteneur Docker