Deployer Flask avec Docker

Pourquoi Déployer Flask avec Docker ?

Dans un environnement professionnel, le déploiement d'applications web est un processus complexe qui nécessite une gestion rigoureuse des dépendances et des configurations. L'adoption de Docker pour le déploiement Flask offre plusieurs avantages réels :

1. Isolation des Environnements : Docker permet de créer des conteneurs isolés, chacun avec ses propres environnements d'exécution indépendants. Cela évite les conflits entre les dépendances des applications et facilite le développement et le déploiement.

2. Faciliter la Production et le Développement : Les développeurs peuvent travailler sur une machine locale, tandis que le même environnement est facilement reproductible en production avec Docker. Cela réduit les erreurs liées aux différences d'environnement.

3. Portabilité : Un conteneur Docker est portable et peut être exécuté sur n'importe quelle machine qui a Docker installé, indépendamment de la configuration système locale.

4. Automatisation du Déploiement : Docker peut être intégré à des outils d'intégration continue (CI) et de déploiement continu (CD), ce qui facilite l'automatisation du processus de livraison continue.

Prerequis

Pour suivre ce tutoriel, vous aurez besoin de :

• Python : Version 3.6 ou supérieure
• Docker : Version 20.10 ou supérieure
• Git (facultatif) : Pour gérer le code source et le versionnement

Concepts Fondamentaux

Concept 1: Dockerfile

Un Dockerfile est un fichier texte qui contient des instructions pour construire une image Docker. Voici un exemple basique :

## Dockerfile

## Utiliser une image de base Python
FROM python:3.9-slim

## Définir le répertoire de travail dans le conteneur
WORKDIR /app

## Copier les fichiers requirements.txt et installer les dépendances
COPY requirements.txt .
RUN pip install -r requirements.txt

## Copier tous les fichiers du répertoire local vers le répertoire de travail dans le conteneur
COPY . .

## Exposer le port 5000 pour Flask
EXPOSE 5000

## Définir la commande à exécuter lorsque le conteneur démarre
CMD ["python", "app.py"]

Concept 2: requirements.txt

Ce fichier liste toutes les dépendances nécessaires pour votre application Flask. Voici un exemple :

## requirements.txt

Flask==2.0.1
gunicorn==20.1.0

Concept 3: Docker Compose

Docker Compose est une outil pour définir et exécuter des applications multi-conteneurs. Voici un exemple de docker-compose.yml :

## docker-compose.yml

version: '3.8'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/app
      - /app/.venv

Mise en Pratique : Projet Fil Rouge

Étape 1: Créer un Nouveau Projet Flask

Créez un nouveau répertoire pour votre projet et initialisez-le avec git (facultatif) :

mkdir flask-docker-tutorial
cd flask-docker-tutorial
git init

Étape 2: Créer les Fichiers de Code

Créez un fichier app.py pour votre application Flask :

## app.py

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return jsonify(message="Hello, Docker!")

if __name__ == '__main__':
    app.run(debug=True)

Étape 3: Créer le Dockerfile

Créez un fichier Dockerfile dans le même répertoire que app.py :

## Dockerfile

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

EXPOSE 5000

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

Étape 4: Créer le requirements.txt

Créez un fichier requirements.txt avec les dépendances nécessaires :

## requirements.txt

Flask==2.0.1
gunicorn==20.1.0

Étape 5: Construire l'Image Docker

Construisez l'image Docker en exécutant la commande suivante dans le terminal :

docker build -t flask-docker-app .

Étape 6: Exécuter le Conteneur

Exécutez le conteneur avec Docker Compose (facultatif) :

docker-compose up

Ou exécutez manuellement la commande suivante :

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

Étape 7: Accéder à l'Application

Ouvrez un navigateur et accédez à http://localhost:5000. Vous devriez voir la réponse JSON {"message": "Hello, Docker!"}.

Erreurs Fréquentes et Debugging

Erreur 1 : L'image ne se construit pas correctement

Code incorrect :

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app.py"]

Erreur :

ERROR: Could not find a version that satisfies the requirement Flask==2.0.1 (from versions: none)
ERROR: No matching distribution found for Flask==2.0.1

Code correct :

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app.py"]

Erreur 2 : Le conteneur ne démarre pas

Code incorrect :

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

Erreur :

flask_docker_app | Error: No module named 'Flask'

Code correct :

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

Erreur 3 : L'application ne fonctionne pas

Code incorrect :

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return jsonify(message="Hello, Docker!")

if __name__ == '__main__':
    app.run(debug=True)

Erreur :

flask_docker_app |  * Serving Flask app "app" (lazy loading)
flask_docker_app |  * Environment: production
flask_docker_app |    WARNING: This is a development server. Do not use it in a production deployment.
flask_docker_app |    Use a production WSGI server instead.
flask_docker_app |  * Debug mode: on
flask_docker_app |  * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
flask_docker_app |  * Restarting with stat
flask_docker_app |  * Debugger is active!
flask_docker_app |  * Debugger PIN: 123-456-789

Code correct :

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return jsonify(message="Hello, Docker!")

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

Pour Aller Plus Loins

1. Intégration avec CI/CD

• Jenkins : Automatiser les tests et le déploiement.
• GitHub Actions : Utiliser des workflows pour automatiser les tâches.

2. Sécurité des Conteneurs

• Scanning des Images : Utiliser des outils comme Trivy ou Clair pour scanner les images Docker et détecter les vulnérabilités.
• Configuration Minimale : Réduire la taille de l'image en utilisant une image plus légère.

3. Performance

• Profiling : Utiliser des outils comme cProfile pour analyser le temps d'exécution de votre application.
• Optimisation : Optimiser les requêtes et améliorer le code pour améliorer la performance.

Défi Pratique

Créez un gestionnaire de tâches simple avec Flask et Docker. L'application devrait permettre d'afficher une liste de tâches, d'ajouter de nouvelles tâches, et de marquer des tâches comme terminées.