Déploiement - publier sur Internet

Félicitations ! Darwin est là avec la dernière leçon du Module 5 - le déploiement d'une application Flask !

Tu as construit une application Safari Database fonctionnelle avec formulaires, authentification et templates. Il est maintenant temps de la publier sur Internet pour que le monde entier puisse l'utiliser !

Analogie Safari : Le déploiement, c'est comme ouvrir le parc au public - jusqu'ici le parc ne fonctionnait qu'en interne (localhost), maintenant tu ouvres les portes aux touristes du monde entier (Internet) !

Développement vs Production

Développement (localhost)

app.run(debug=True) - serveur de développement Rechargement automatique après les modifications du code Erreurs détaillées dans le navigateur Localhost uniquement - inaccessible depuis Internet Lent - non optimisé

Production (Internet)

Serveur WSGI (Gunicorn, uWSGI) Pas de debug=True - sécurité ! Variables d'environnement - SECRET_KEY, DATABASE_URL Accessible publiquement - tout le monde peut le visiter Rapide - optimisé

N'utilise JAMAIS app.run(debug=True) en production !

Serveur WSGI - Gunicorn

Gunicorn (Green Unicorn) est un serveur WSGI populaire pour les applications Flask/Django.

WSGI = Web Server Gateway Interface - un standard de communication entre un serveur et une application Python.

Installation

1pip install gunicorn

Lancement

1# De base
2gunicorn app:app
3
4# Avec port et workers spécifiés
5gunicorn app:app --bind 0.0.0.0:8000 --workers 4
6
7# Avec rechargement (dev uniquement)
8gunicorn app:app --reload

Format : gunicorn <module>:<variable_app>

• app - nom du fichier (app.py)
• app - nom de la variable Flask (app = Flask(name))

Préparer le déploiement

1. Fichier requirements.txt

Enregistre toutes les dépendances :

1pip freeze > requirements.txt

requirements.txt :

1Flask==3.0.0
2Flask-WTF==1.2.1
3Flask-Login==0.6.3
4Werkzeug==3.0.1
5gunicorn==21.2.0

2. Variables d'environnement

Ne committe JAMAIS SECRET_KEY et les données sensibles sur git !

Utilise des variables d'environnement :

1# app.py
2import os
3
4app = Flask(__name__)
5
6# Récupérer depuis les variables d'environnement
7app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY') or 'dev-fallback-key'
8app.config['DATABASE_URL'] = os.environ.get('DATABASE_URL') or 'sqlite:///dev.db'
9
10# Débogage uniquement en dev
11app.config['DEBUG'] = os.environ.get('FLASK_ENV') == 'development'

3. .gitignore

1# .gitignore
2venv/
3__pycache__/
4*.pyc
5*.pyo
6.env
7instance/
8.DS_Store

4. Procfile (pour les plateformes comme Render/Heroku)

1web: gunicorn app:app

Le Procfile indique à la plateforme comment lancer ton application.

5. runtime.txt (facultatif)

1python-3.11.0

Spécifie la version de Python.

Déploiement sur Render (GRATUIT !)

Render est une plateforme d'hébergement moderne avec un plan gratuit. Une excellente alternative à Heroku !

Étape 1 : Préparer l'application

Structure du projet :

1safari_web/
2├── app.py
3├── models.py
4├── forms.py
5├── requirements.txt
6├── Procfile
7├── .gitignore
8├── templates/
9│   └── ...
10└── static/
11    └── ...

app.py - dernières lignes :

1if __name__ == '__main__':
2    # Uniquement pour le développement local
3    app.run(debug=True)

Render lance via le Procfile, donc le if __name__ ne s'exécutera pas !

Étape 2 : Pousser sur GitHub

1git init
2git add .
3git commit -m "Initial commit - Safari Database"
4git branch -M main
5git remote add origin https://github.com/your-username/safari-web.git
6git push -u origin main

Étape 3 : Créer un Web Service sur Render

1. Va sur https://render.com et inscris-toi (GRATUIT)

2. Clique sur « New + » → « Web Service »

3. Connecte ton dépôt GitHub

4. Sélectionne le dépôt safari-web

5. Configuration :

   • Name : safari-database
   • Environment : Python 3
   • Build Command : pip install -r requirements.txt
   • Start Command : gunicorn app:app
   • Plan : Free

6. Environment Variables - ajoute :

   • SECRET_KEY = your-random-secret-key-here
   • FLASK_ENV = production

7. Clique sur « Create Web Service »

Étape 4 : Déploie !

Render fait automatiquement :

• Installe les dépendances (pip install -r requirements.txt)
• Lance Gunicorn (gunicorn app:app)
• Attribue un domaine (https://safari-database.onrender.com)

Félicitations ! Ton application est EN LIGNE !

Déploiement sur Railway (aussi GRATUIT !)

Railway est une autre excellente plateforme avec une configuration simple.

Étapes :

1. https://railway.app - inscris-toi
2. « New Project » → « Deploy from GitHub repo »
3. Sélectionne le dépôt
4. Railway détecte automatiquement Flask !
5. Ajoute les Environment Variables :
   • SECRET_KEY
   • FLASK_ENV=production
6. Railway déploie automatiquement !

Domaine : https://safari-database.up.railway.app

Checklist de déploiement

Avant le déploiement, assure-toi de :

Sécurité

• DEBUG = False en production
• SECRET_KEY en variable d'environnement
• Mots de passe hachés (werkzeug.security)
• Protection CSRF activée (Flask-WTF)
• .gitignore contient venv/, .env

Fichiers

• requirements.txt à jour
• Procfile créé
• .gitignore créé
• Fichiers statiques correctement configurés

Base de données

• En dev : SQLite
• En prod : PostgreSQL (offre gratuite Render/Railway !)
• DATABASE_URL en variable d'environnement

Tests

• L'application fonctionne en local
• Toutes les routes fonctionnent
• Les formulaires fonctionnent
• La connexion/inscription fonctionne

Base de données en production

SQLite (Développement)

1app.config['DATABASE_URL'] = 'sqlite:///safari.db'

Problèmes : SQLite n'est pas recommandé en production (problèmes de concurrence).

PostgreSQL (Production)

Render/Railway offrent PostgreSQL GRATUIT !

Render : Ajoute une base de données PostgreSQL → copie DATABASE_URL

1import os
2
3database_url = os.environ.get('DATABASE_URL')
4
5if database_url and database_url.startswith('postgres://'):
6    # Render utilise postgres://, mais SQLAlchemy a besoin de postgresql://
7    database_url = database_url.replace('postgres://', 'postgresql://', 1)
8
9app.config['SQLALCHEMY_DATABASE_URI'] = database_url or 'sqlite:///dev.db'

Fichiers statiques en production

Flask sert automatiquement les fichiers depuis static/, mais en production il vaut mieux utiliser un CDN ou Nginx.

Configuration Flask de base :

1# app.py
2app = Flask(__name__)
3
4# Flask sert automatiquement les fichiers statiques depuis /static/
5# http://yourapp.com/static/css/style.css

Dans les templates :

1<link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
2<script src="{{ url_for('static', filename='js/script.js') }}"></script>

Surveillance et journaux

Logs Render

Dashboard → Ton Web Service → Logs

Logs Railway

Project → Ton Service → Logs

Exemple de logs :

1[2024-01-15 10:23:45] INFO: Starting gunicorn 21.2.0
2[2024-01-15 10:23:45] INFO: Listening at: http://0.0.0.0:10000
3[2024-01-15 10:23:45] INFO: Using worker: sync
4[2024-01-15 10:23:45] INFO: Booting worker with pid: 42

Mettre à jour l'application

Render/Railway

1. Fais les modifications du code en local
2. Committe sur git :

   1git add .
   2git commit -m "Update: Add new feature"
   3git push origin main

3. Render/Railway déploie automatiquement la nouvelle version !

Auto-deploy = push sur GitHub → déploiement automatique !

Domaine personnalisé (facultatif)

Au lieu de safari-database.onrender.com tu peux utiliser ton propre domaine :

1. Achète un domaine (par ex. safaridatabase.com)
2. Render/Railway → Settings → Custom Domain
3. Ajoute un enregistrement CNAME chez ton registrar de domaine
4. Terminé ! https://safaridatabase.com → Ton application

Plateformes alternatives

1. Fly.io

• Offre gratuite
• Déploiement mondial
• Excellente documentation

2. PythonAnywhere

• Offre gratuite pour Flask
• Configuration simple
• Bon pour les débutants

3. DigitalOcean App Platform

• 5 $/mois
• Plus de contrôle
• Évolutif

4. AWS/Google Cloud/Azure

• Avancé
• Plus cher
• Contrôle total

Exemple d'app.py prêt pour la production

1# app.py
2import os
3from flask import Flask, render_template, redirect, url_for, flash
4from flask_login import LoginManager, login_user, logout_user, login_required, current_user
5from flask_sqlalchemy import SQLAlchemy
6
7app = Flask(__name__)
8
9# Configuration depuis les variables d'environnement
10app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY') or 'dev-key-change-in-production'
11app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL') or 'sqlite:///dev.db'
12app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
13
14# Correctif pour l'URL PostgreSQL de Render
15if app.config['SQLALCHEMY_DATABASE_URI'].startswith('postgres://'):
16    app.config['SQLALCHEMY_DATABASE_URI'] = app.config['SQLALCHEMY_DATABASE_URI'].replace('postgres://', 'postgresql://', 1)
17
18db = SQLAlchemy(app)
19login_manager = LoginManager(app)
20login_manager.login_view = 'login'
21
22# Modèles, routes, etc...
23
24if __name__ == '__main__':
25    # Uniquement pour le développement local
26    port = int(os.environ.get('PORT', 5000))
27    app.run(host='0.0.0.0', port=port, debug=os.environ.get('FLASK_ENV') == 'development')

Résumé

Dans cette leçon tu as appris :

• La différence entre développement et production
• Les serveurs WSGI (Gunicorn)
• Préparer les applications au déploiement
• Les variables d'environnement (SECRET_KEY, DATABASE_URL)
• Le déploiement sur Render (GRATUIT !)
• Le déploiement sur Railway (GRATUIT !)
• La checklist de déploiement
• Les bases de données en production (PostgreSQL)
• Les fichiers statiques en production
• La surveillance et les journaux
• La mise à jour des applications (auto-deploy)

Analogie Safari finale : Le déploiement, c'est comme la grande ouverture d'un parc de safari - tu as préparé l'infrastructure (le code), embauché du personnel (le serveur WSGI), sécurisé le parc (SECRET_KEY, HTTPS) et ouvert les portes aux touristes du monde entier (Internet) ! Ton application Flask vit et tourne 24h/24 et 7j/7 dans le cloud !

Félicitations pour le Module 5 !

Tu as construit une application web complète avec :

• Frontend (HTML, CSS, JavaScript)
• Backend (Flask)
• Routage et fonctions de vue
• Templates Jinja2
• Formulaires avec validation (Flask-WTF)
• Authentification (Flask-Login)
• Déploiement sur Internet (Render/Railway)

Safari Database est maintenant EN LIGNE et accessible à tous sur Internet !

Darwin est fier de toi ! Prépare-toi pour les prochains modules, où tu apprendras des techniques avancées de Python et d'IA !