Deployer Flask sur Fly.io

Pourquoi Deployer Flask sur Fly.io ?

Déployer une application Flask sur Fly.io est essentiel pour plusieurs raisons :

1. Scalabilité : Fly.io permet d'adapter facilement le nombre de instances en fonction du trafic, ce qui est crucial pour les applications croissantes.
2. Temps de mise en ligne rapide : Le processus de déploiement sur Fly.io est extrêmement rapide et simple, facilitant la mise à jour et l'évolution des applications.
3. Coût efficace : Avec une architecture payante basée sur le nombre d'heures d'utilisation, Fly.io offre un bon rapport qualité-prix pour les petites et moyennes entreprises.

Un cas concret serait un développeur qui crée une application web de gestion de projets simple mais nécessite de la haute disponibilité et de la scalabilité. Deployer cette application sur Fly.io permettrait d'ajuster facilement le nombre d'instances en fonction du volume de travail, tout en conservant des coûts réalistes.

Prerequis

Avant de commencer à déployer une application Flask sur Fly.io, vous aurez besoin des éléments suivants :

• Connaissance de base de Python et Flask
• Un compte Fly.io
• Un environnement local avec Python 3.7 ou plus récent installé
• L'outil flyctl pour interface CLI de Fly.io

Concepts fondamentaux

1. Comprendre les services Flask

Un service Flask est une application web qui gère les requêtes HTTP et renvoie des réponses.

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return 'Hello, World!'

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

2. Utiliser un fichier de configuration

Placer la configuration dans un fichier séparé rend le code plus propre et facile à gérer.

## config.py
import os

class Config:
    SECRET_KEY = 'your_secret_key'
python
from flask import Flask
from config import Config

app = Flask(__name__)
app.config.from_object(Config)

@app.route('/')
def home():
    return 'Hello, World!'

3. Utiliser une base de données

Pour stocker des données persistantes, il est recommandé d'utiliser une base de données.

## models.py
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)

4. Utiliser Fly.io pour le déploiement

Fly.io utilise des conteneurs Docker pour déployer les applications.

## Dockerfile
FROM python:3.9-slim

WORKDIR /app

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

COPY . .

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

5. Utiliser un fichier Procfile pour spécifier le point d'entrée

web: python app.py

Mise en pratique : projet fil rouge

Nous allons créer une application Flask simple qui permet de gérer des tâches.

Étape 1 : Créer la structure du projet

mkdir task_manager
cd task_manager
touch app.py config.py models.py requirements.txt Dockerfile Procfile

Étape 2 : Créer le fichier config.py

## config.py
import os

class Config:
    SECRET_KEY = 'your_secret_key'
    SQLALCHEMY_DATABASE_URI = os.getenv('DATABASE_URL', 'sqlite:///tasks.db')

Étape 3 : Créer les modèles de données dans models.py

## models.py
from flask_sqlalchemy import SQLAlchemy
from config import Config

db = SQLAlchemy()

class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    description = db.Column(db.String(255), nullable=False)
    completed = db.Column(db.Boolean, default=False)

Étape 4 : Créer l'application Flask dans app.py

## app.py
from flask import Flask, request, jsonify
from models import db, Task

app = Flask(__name__)
app.config.from_object('config.Config')

db.init_app(app)

@app.before_first_request
def create_tables():
    db.create_all()

@app.route('/tasks', methods=['POST'])
def add_task():
    data = request.get_json()
    new_task = Task(description=data['description'])
    db.session.add(new_task)
    db.session.commit()
    return jsonify({'id': new_task.id}), 201

@app.route('/tasks', methods=['GET'])
def get_tasks():
    tasks = Task.query.all()
    return jsonify([{'id': task.id, 'description': task.description, 'completed': task.completed} for task in tasks])

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

Étape 5 : Ajouter les dépendances dans requirements.txt

Flask==2.0.1
Flask-SQLAlchemy==2.5.1
gunicorn==20.1.0

Étape 6 : Créer le fichier Dockerfile

## Dockerfile
FROM python:3.9-slim

WORKDIR /app

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

COPY . .

CMD ["gunicorn", "-w", "4", "app:app"]

Étape 7 : Créer le fichier Procfile

web: gunicorn app:app

Étape 8 : Initialiser la base de données

export FLASK_APP=app.py
flask db init
flask db migrate -m "Initial migration."
flask db upgrade

Erreurs frequentes et debugging

1. Mauvais chemin pour le fichier de configuration

Erreur :

ModuleNotFoundError: No module named 'config'

Correction :

## app.py
from config import Config

2. Problème avec la base de données SQLite

Erreur :

sqlite3.Error: unable to open database file

Correction : Assurez-vous que le fichier tasks.db a les permissions correctes.

3. Mauvaise installation des dépendances

Erreur :

ModuleNotFoundError: No module named 'Flask'

Correction : Vérifiez que toutes les dépendances sont correctement installées dans votre environnement virtuel.

Pour aller plus loin

1. Utiliser des variables d'environnement pour la configuration : Cela améliore la sécurité et la flexibilité de votre application.
2. Ajouter une authentification JWT : Pour sécuriser l'accès aux routes sensibles.
3. Intégrer un service de notifications : Par exemple, envoyer des emails lorsqu'une tâche est ajoutée ou modifiée.

Défi pratique

Créez une petite API REST pour gérer les utilisateurs. Les fonctionnalités devraient inclure l'inscription, la connexion et la récupération d'utilisateurs. Utilisez Flask-Login pour la gestion de sessions utilisateur.