Comment Dockeriser une Application Python Flask

  Administration système Linux, Virtualisation et informatique en nuage
Dockeriser une application Flask Python Linux Debian Centos Redhat Ubuntu

Introduction

La conteneurisation avec Docker a révolutionné la manière dont les développeurs déploient des applications, en offrant un environnement cohérent du développement à la production. Ce guide vous expliquera le processus de dockerisation d’une application Python Flask en utilisant Docker. Nous couvrirons tout, de la configuration de votre environnement, à la création de Dockerfiles, et à l’exécution de votre application Flask dans un conteneur Docker.

Qu’est-ce que Docker?

Docker est une plateforme open-source conçue pour automatiser le déploiement d’applications dans des conteneurs légers et portables. Ces conteneurs regroupent le code de l’application avec toutes ses dépendances, bibliothèques et configurations, garantissant qu’elle fonctionne de manière homogène sur différents environnements informatiques.

Pourquoi Dockeriser une Application Flask?

Dockeriser une application Flask offre plusieurs avantages :

  • Cohérence : Les conteneurs garantissent que l’application fonctionne dans le même environnement, éliminant ainsi le problème du “ça marche sur ma machine”.
  • Portabilité : Les conteneurs peuvent s’exécuter sur n’importe quel système prenant en charge Docker, ce qui facilite le déplacement des applications entre différents environnements.
  • Scalabilité : Docker permet de facilement faire évoluer les applications horizontalement en exécutant plusieurs instances de conteneurs.
  • Isolation : Chaque conteneur s’exécute dans son propre environnement isolé, évitant les conflits entre différentes applications sur le même hôte.

Prérequis

Avant de commencer, assurez-vous d’avoir les éléments suivants :

  • Connaissances de base en Python et Flask
  • Docker installé sur votre machine
  • Une application Flask d’exemple

Configuration de Votre Application Flask

Commençons par configurer une simple application Flask. Créez un répertoire pour votre projet et naviguez dedans :

$ mkdir flask_app
$ cd flask_app

Créez un environnement virtuel et activez-le :

$ python -m venv venv
$ source venv/bin/activate  # Sur Windows utilisez `venv\Scripts\activate`

Installez Flask :

$ pip install Flask

Créez un fichier nommé app.py avec le contenu suivant :

from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
    return "Hello, Docker!"
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Rédaction d’un Dockerfile

Un Dockerfile est un document texte qui contient toutes les commandes pour assembler une image. Créez un fichier nommé Dockerfile à la racine de votre répertoire de projet :

# Utiliser une image de base officielle Python
FROM python:3.9-slim
# Définir le répertoire de travail dans le conteneur
WORKDIR /app
# Copier le contenu du répertoire courant dans le conteneur à /app
COPY . /app
# Installer les packages nécessaires spécifiés dans requirements.txt
RUN pip install --no-cache-dir -r requirements.txt
# Rendre le port 5000 disponible pour le monde extérieur
EXPOSE 5000
# Définir une variable d'environnement
ENV NAME World
# Exécuter app.py au lancement du conteneur
CMD ["python", "app.py"]

Créez un fichier requirements.txt et ajoutez Flask :

Flask==2.0.1

Construction de l’Image Docker

Avec votre Dockerfile et application prêts, vous pouvez construire votre image Docker. Dans votre terminal, exécutez la commande suivante :

$ docker build -t flask-app .

Cette commande construit une image nommée flask-app en utilisant le Dockerfile dans le répertoire courant.

Exécution du Conteneur Docker

Après avoir construit l’image Docker, vous pouvez l’exécuter dans un conteneur. Utilisez la commande suivante pour démarrer le conteneur :

$ docker run -d -p 5000:5000 flask-app

Cette commande exécute le conteneur en mode détaché (-d) et mappe le port 5000 de votre hôte au port 5000 du conteneur.

Test de Votre Application Flask

Ouvrez votre navigateur web et naviguez à l’adresse http://localhost:5000. Vous devriez voir le message “Hello, Docker!” confirmant que votre application Flask s’exécute à l’intérieur d’un conteneur Docker.

Gestion des Dépendances avec Docker Compose

Docker Compose est un outil pour définir et exécuter des applications multi-conteneurs Docker. Pour gérer votre application Flask et ses dépendances, créez un fichier docker-compose.yml :

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"

Exécutez la commande suivante pour démarrer votre application avec Docker Compose :

$ docker-compose up -d

Gestion des Variables d’Environnement

Les variables d’environnement peuvent être gérées plus efficacement en utilisant Docker Compose. Créez un fichier .env pour vos variables d’environnement :

FLASK_ENV=development

Modifiez votre docker-compose.yml pour inclure les variables d’environnement :

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    environment:
      - FLASK_ENV=${FLASK_ENV}

Montage de Volumes pour le Développement

Pour activer le rechargement à chaud pendant le développement, montez votre répertoire de projet comme un volume dans le conteneur. Mettez à jour votre docker-compose.yml :

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/app
    environment:
      - FLASK_ENV=${FLASK_ENV}

Dockerisation d’une Application Flask avec une Base de Données

De nombreuses applications nécessitent une base de données. Dans cette section, nous ajouterons une base de données PostgreSQL à notre application Flask en utilisant Docker Compose.

Ajout de PostgreSQL à Docker Compose

Mettez à jour votre docker-compose.yml pour inclure un service PostgreSQL :

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/app
    environment:
      - FLASK_ENV=${FLASK_ENV}
      - DATABASE_URL=postgresql://postgres:password@db:5432/postgres
  db:
    image: postgres:13
    environment:
      - POSTGRES_PASSWORD=password

Mise à Jour de l’Application Flask

Modifiez votre application Flask pour utiliser SQLAlchemy pour les opérations de base de données. Installez les packages nécessaires :

$ pip install Flask-SQLAlchemy psycopg2-binary

Mettez à jour votre requirements.txt :

Flask==2.0.1
Flask-SQLAlchemy==2.5.1
psycopg2-binary==2.9.1

Mettez à jour app.py pour inclure les configurations de la base de données :

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://postgres:password@db:5432/postgres'
db = SQLAlchemy(app)
@app.route('/')
def home():
    return "Hello, Docker with PostgreSQL!"
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Exécution de l’Application

Construisez et démarrez l’application avec Docker Compose :

$ docker-compose up --build

Votre application Flask devrait maintenant être connectée à une base de données PostgreSQL s’exécutant à l’intérieur d’un conteneur Docker.

Optimisations Avancées du Dockerfile

L’optimisation de votre Dockerfile peut améliorer les temps de construction et réduire la taille de l’image. Voici quelques conseils :

Constructions Multi-Étapes

Utilisez des constructions multi-étapes pour garder votre image finale légère. Voici un exemple :

# Premier stade : construire les dépendances
FROM python:3.9-slim as builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Deuxième stade : copier uniquement les fichiers nécessaires
FROM python:3.9-slim
WORKDIR /app
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY . /app
EXPOSE 5000
CMD ["python", "app.py"]

Mise en Cache des Dépendances

Exploitez la mise en cache des couches de Docker en copiant uniquement le fichier des dépendances avant le code de l’application :

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

Débogage des Conteneurs Docker

Le débogage des conteneurs Docker peut être difficile. Voici quelques stratégies :

Accéder au Shell du Conteneur

Vous pouvez accéder au shell d’un conteneur en cours d’exécution en utilisant :

$ docker exec -it <container_id> /bin/bash

Visualisation des Logs du Conteneur

Visualisez les logs d’un conteneur en cours d’exécution :

$ docker logs <container_id>

Déploiement des Applications Flask Dockerisées

Le déploiement des applications Dockerisées peut être effectué en utilisant diverses plateformes. Voici quelques options populaires :

Docker Hub

Docker Hub est un dépôt cloud où vous pouvez stocker et partager des images Docker. Poussez votre image sur Docker Hub :

$ docker tag flask-app username/flask-app
$ docker push username/flask-app

Kubernetes

Kubernetes est un système open-source pour l’automatisation du déploiement, de la mise à l’échelle et de la gestion des applications conteneurisées. Créez une configuration de déploiement Kubernetes :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: flask-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: flask-app
  template:
    metadata:
      labels:
        app: flask-app
    spec:
      containers:
      - name: flask-app
        image: username/flask-app
        ports:
        - containerPort: 5000

Appliquez la configuration de déploiement :

$ kubectl apply -f deployment.yaml

AWS Elastic Beanstalk

AWS Elastic Beanstalk est un service facile à utiliser pour déployer et mettre à l’échelle des applications web. Initialisez Elastic Beanstalk dans votre projet :

$ eb init -p docker flask-app
$ eb create flask-app-env

Déployez votre application :

$ eb deploy

FAQs

Qu’est-ce que Docker? Docker est une plateforme open-source qui automatise le déploiement d’applications dans des conteneurs légers et portables.

Pourquoi devrais-je dockeriser mon application Flask? Dockeriser votre application Flask garantit la cohérence entre les différents environnements, améliore la portabilité, la scalabilité et offre une isolation par rapport aux autres applications.

Comment construire une image Docker pour mon application Flask? Créez un Dockerfile avec les instructions nécessaires et exécutez la commande docker build -t <image_name> ..

Puis-je utiliser Docker Compose pour mon application Flask? Oui, Docker Compose peut gérer les applications multi-conteneurs et gérer les variables d’environnement et les montages de volumes.

Comment connecter mon application Flask à une base de données PostgreSQL dans Docker? Définissez un service PostgreSQL dans votre fichier docker-compose.yml et configurez votre application Flask pour utiliser l’URL de la base de données.

Comment déployer mon application Flask Dockerisée? Vous pouvez déployer votre application en utilisant Docker Hub, Kubernetes ou AWS Elastic Beanstalk, entre autres plateformes.

Conclusion

Dockeriser une application Python Flask simplifie le déploiement, garantit la cohérence entre les environnements et améliore la scalabilité. En suivant ce guide, vous devriez être capable de configurer Docker, créer des Dockerfiles et exécuter votre application Flask dans des conteneurs. Exploitez les puissantes fonctionnalités de Docker pour améliorer votre flux de travail de développement et de déploiement.

Laisser un commentaire