Fiche API avec flask - Eryann Breizh SecOps

1. Introduction

Dans un BTS CIEL ou SIO, tu vas très souvent développer ou interfacer des services web. Aujourd’hui, presque toutes les applications communiquent grâce à des API REST. Un serveur web, une application mobile, un outil de supervision ou un portail métier utilisent généralement des échanges HTTP au format JSON.

Flask permet de créer rapidement une API en Python avec une structure simple et pédagogique. Tu peux ainsi comprendre facilement le fonctionnement des routes HTTP, des réponses JSON, des méthodes GET/POST et des codes de retour.

Dans cette fiche, tu vas apprendre à :

installer Flask ;
créer une API REST simple ;
manipuler les méthodes HTTP ;
recevoir et retourner du JSON ;
sécuriser ton API ;
superviser les logs ;
ouvrir correctement les ports avec UFW ;
tester l’API avec curl.

Cette fiche utilise principalement Debian et Ubuntu.

2. Sommaire

Introduction
Sommaire
Comprendre le fonctionnement d’une API Flask
Installer Flask sur Debian et Ubuntu
Arborescence recommandée du projet
Synthèse Markdown pour ta fiche bristol
Fichiers importants
Configuration complète d’une API Flask
Comprendre le code Flask en détail
Tester l’API
Gérer les méthodes HTTP
Utiliser des paramètres et du JSON
Sécuriser une API Flask
Configurer le pare-feu UFW
Superviser et analyser les logs
Commandes utiles et dépannage
Cas concrets d’utilisation
Erreurs fréquentes
Bonnes pratiques
Pour aller plus loin
Liens utiles et documentation officielle
Propositions de TP

3. Comprendre le fonctionnement d’une API Flask

Une API REST fonctionne grâce au protocole HTTP.

Le client envoie une requête :

GET → lire des données ;
POST → ajouter des données ;
PUT → modifier ;
DELETE → supprimer.

Le serveur Flask répond généralement au format JSON.

Exemple :

Client :

GET /api/status HTTP/1.1

Réponse :

{
    "status": "ok"
}

Flask agit comme un micro-framework web Python. Il fournit :

un serveur HTTP ;
un système de routes ;
la gestion des requêtes ;
la gestion des réponses JSON.

4. Installer Flask sur Debian et Ubuntu

4.1 Mettre le système à jour

sudo apt update && sudo apt upgrade -y

apt update met à jour la liste des paquets.
apt upgrade installe les nouvelles versions.
-y valide automatiquement les confirmations.

4.2 Installer Python et venv

sudo apt install python3 python3-pip python3-venv -y

Paquets installés :

python3 : interpréteur Python ;
python3-pip : gestionnaire de paquets Python ;
python3-venv : environnement virtuel Python.

4.3 Créer le projet

mkdir -p ~/projets/flask-api
cd ~/projets/flask-api

mkdir -p crée les dossiers nécessaires.
cd permet d’entrer dans le répertoire.

4.4 Créer un environnement virtuel

python3 -m venv venv

Cette commande crée un environnement Python isolé.

4.5 Activer l’environnement virtuel

source venv/bin/activate

Le shell utilise maintenant les paquets Python du projet.

4.6 Installer Flask

pip install flask

Tu peux également installer Werkzeug et Gunicorn :

pip install gunicorn

gunicorn sert à exécuter Flask en production.

5. Arborescence recommandée du projet

flask-api/
├── app.py
├── requirements.txt
├── venv/
├── logs/
│   └── api.log
├── static/
└── templates/

Explications :

app.py : application principale ;
requirements.txt : dépendances Python ;
logs/ : journaux applicatifs ;
static/ : fichiers statiques ;
templates/ : templates HTML si besoin.

6. Synthèse Markdown pour ta fiche bristol

# API Flask

## Installation
sudo apt install python3 python3-pip python3-venv -y

python3 -m venv venv
source venv/bin/activate

pip install flask gunicorn

## Lancer l'API
python3 app.py

## Route GET
@app.route("/api/status", methods=["GET"])

## Retour JSON
return jsonify({"status": "ok"})

## Lire le JSON reçu
data = request.get_json()

## Tester avec curl
curl http://127.0.0.1:5000/api/status

curl -X POST http://127.0.0.1:5000/api/users \
-H "Content-Type: application/json" \
-d '{"nom":"alice"}'

## Pare-feu UFW
sudo ufw allow 5000/tcp

## Logs systemd
journalctl -u flask-api.service -f

7. Fichiers importants

Application Flask

~/projets/flask-api/app.py

Environnement virtuel

~/projets/flask-api/venv/

Dépendances Python

~/projets/flask-api/requirements.txt

Logs applicatifs

~/projets/flask-api/logs/api.log

Service systemd

/etc/systemd/system/flask-api.service

Configuration UFW

/etc/ufw/user.rules

8. Configuration complète d’une API Flask

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from flask import Flask, jsonify, request
import logging
from logging.handlers import RotatingFileHandler

app = Flask(__name__)

# Configuration des logs
handler = RotatingFileHandler(
    "logs/api.log",
    maxBytes=1000000,
    backupCount=3
)

handler.setLevel(logging.INFO)

formatter = logging.Formatter(
    "%(asctime)s %(levelname)s %(message)s"
)

handler.setFormatter(formatter)

app.logger.addHandler(handler)

# Base de données temporaire
users = [
    {"id": 1, "nom": "alice"},
    {"id": 2, "nom": "bob"}
]

@app.route("/api/status", methods=["GET"])
def status():
    """
    Retourne l'état de l'API.
    """

    app.logger.info("Consultation du status API")

    return jsonify({
        "status": "ok",
        "service": "flask-api"
    })

@app.route("/api/users", methods=["GET"])
def get_users():
    """
    Retourne la liste des utilisateurs.
    """

    app.logger.info("Lecture des utilisateurs")

    return jsonify(users)

@app.route("/api/users", methods=["POST"])
def add_user():
    """
    Ajoute un utilisateur.
    """

    data = request.get_json()

    if not data or "nom" not in data:
        return jsonify({
            "erreur": "Champ nom manquant"
        }), 400

    user = {
        "id": len(users) + 1,
        "nom": data["nom"]
    }

    users.append(user)

    app.logger.info(f"Ajout utilisateur : {data['nom']}")

    return jsonify(user), 201

@app.route("/api/users/<int:user_id>", methods=["DELETE"])
def delete_user(user_id):
    """
    Supprime un utilisateur.
    """

    global users

    users = [
        user for user in users
        if user["id"] != user_id
    ]

    app.logger.warning(f"Suppression utilisateur ID {user_id}")

    return jsonify({
        "message": "Utilisateur supprimé"
    })

if __name__ == "__main__":
    app.run(
        host="0.0.0.0",
        port=5000,
        debug=False
    )

9. Comprendre le code Flask en détail

9.1 Créer l’application Flask

app = Flask(__name__)

Cette ligne initialise l’application web.

9.2 Définir une route

@app.route("/api/status", methods=["GET"])

/api/status : URL appelée ;
methods=["GET"] : méthodes HTTP autorisées.

9.3 Retourner du JSON

return jsonify({
    "status": "ok"
})

jsonify() transforme automatiquement les données Python en JSON.

9.4 Lire des données JSON

data = request.get_json()

Cette méthode lit le contenu JSON envoyé par le client.

9.5 Utiliser les codes HTTP

return jsonify(data), 201

Code HTTP courant :

Code	Signification
200	Succès
201	Ressource créée
400	Mauvaise requête
401	Non authentifié
403	Accès interdit
404	Ressource absente
500	Erreur serveur

10. Tester l’API

10.1 Démarrer Flask

python3 app.py

Par défaut Flask écoute sur :

0.0.0.0:5000

Port utilisé :

TCP 5000

10.2 Tester avec curl

Lire le status

curl http://127.0.0.1:5000/api/status

Lire les utilisateurs

curl http://127.0.0.1:5000/api/users

Ajouter un utilisateur

curl -X POST http://127.0.0.1:5000/api/users \
-H "Content-Type: application/json" \
-d '{"nom":"charlie"}'

Explications :

-X POST : méthode HTTP ;
-H : ajoute un header HTTP ;
-d : envoie des données.

11. Gérer les méthodes HTTP

Méthode	Utilisation
GET	Lire
POST	Ajouter
PUT	Modifier
DELETE	Supprimer

Exemple PUT :

@app.route("/api/users/<int:user_id>", methods=["PUT"])

12. Utiliser des paramètres et du JSON

Paramètre dans l’URL

@app.route("/api/users/<int:user_id>")

Flask récupère automatiquement :

def get_user(user_id):

Paramètre GET

Exemple :

/api/search?nom=alice

Lecture :

request.args.get("nom")

13. Sécuriser une API Flask

13.1 Désactiver le mode debug

Ne laisse jamais :

debug=True

en production.

Le mode debug expose des informations sensibles.

13.2 Utiliser Gunicorn

Installation :

pip install gunicorn

Démarrage :

gunicorn -w 4 -b 0.0.0.0:5000 app:app

Explications :

-w 4 : 4 workers ;
-b : adresse d’écoute.

13.3 Utiliser un reverse proxy Nginx

Architecture recommandée :

Internet
   |
Nginx :80 / :443
   |
Gunicorn :5000
   |
Flask

13.4 Ajouter une authentification simple

Exemple avec un token :

API_TOKEN = "super-token"

Vérification :

token = request.headers.get("Authorization")

13.5 Limiter l’exposition réseau

Si l’API reste locale :

host="127.0.0.1"

Ainsi Flask n’écoute pas sur le réseau.

14. Configurer le pare-feu UFW

Autoriser le port Flask

sudo ufw allow 5000/tcp

Vérifier les règles

sudo ufw status verbose

Supprimer une règle

sudo ufw delete allow 5000/tcp

Cas recommandé en production

Si Nginx sert de reverse proxy :

sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw deny 5000/tcp

Dans ce cas :

Internet accède à Nginx ;
Flask reste inaccessible directement.

15. Superviser et analyser les logs

15.1 Logs Flask

Fichier :

logs/api.log

Exemple :

2026-05-22 15:00:10 INFO Lecture des utilisateurs
2026-05-22 15:01:12 WARNING Suppression utilisateur ID 2

15.2 Lire les logs en direct

tail -f logs/api.log

-f suit le fichier en temps réel.

15.3 Logs systemd

Créer un service

Fichier :

/etc/systemd/system/flask-api.service

Contenu :

[Unit]
Description=API Flask
After=network.target

[Service]
User=www-data
WorkingDirectory=/home/user/projets/flask-api
ExecStart=/home/user/projets/flask-api/venv/bin/gunicorn -w 4 -b 0.0.0.0:5000 app:app
Restart=always

[Install]
WantedBy=multi-user.target

Activer le service

sudo systemctl daemon-reload
sudo systemctl enable flask-api
sudo systemctl start flask-api

Lire les logs

journalctl -u flask-api -f

Ce que tu peux analyser

Tu peux observer :

les erreurs Python ;
les crashs ;
les connexions ;
les redémarrages ;
les erreurs réseau ;
les problèmes de permissions.

16. Commandes utiles et dépannage

Vérifier l’écoute réseau

ss -tulpn | grep 5000

-t : TCP ;
-u : UDP ;
-l : ports en écoute ;
-p : processus ;
-n : affichage numérique.

Tester le port

nc -vz 127.0.0.1 5000

Vérifier les processus Python

ps aux | grep python

Vérifier Gunicorn

systemctl status flask-api

Vérifier le pare-feu

sudo ufw status numbered

17. Cas concrets d’utilisation

API de supervision

Un Raspberry Pi peut envoyer :

température ;
charge CPU ;
état réseau.

API pour application mobile

Une application Android peut :

lire des utilisateurs ;
ajouter des données ;
récupérer des notifications.

API pour WordPress

WordPress peut communiquer avec Flask afin de :

récupérer des statistiques ;
gérer un inventaire ;
afficher des données temps réel.

18. Erreurs fréquentes

Port déjà utilisé

Erreur :

Address already in use

Diagnostic :

ss -tulpn | grep 5000

Module Flask absent

Erreur :

ModuleNotFoundError: No module named 'flask'

Correction :

pip install flask

JSON invalide

Erreur HTTP :

400 Bad Request

Cause :

JSON mal formé ;
header absent.

Permissions insuffisantes

Vérifie :

ls -l

19. Bonnes pratiques

utilise toujours un environnement virtuel Python ;
place Flask derrière Nginx ;
active HTTPS ;
désactive le mode debug ;
journalise les actions importantes ;
limite les ports ouverts ;
valide les données reçues ;
utilise des codes HTTP cohérents ;
sépare développement et production ;
stocke les secrets dans des variables d’environnement.

20. Pour aller plus loin

Tu peux approfondir :

Flask-RESTX ;
Flask-SQLAlchemy ;
JWT ;
OAuth2 ;
Docker ;
Kubernetes ;
Swagger/OpenAPI ;
PostgreSQL ;
Redis ;
Celery.

21. Liens utiles et documentation officielle

Documentation officielle Flask

https://flask.palletsprojects.com/en/stable

Documentation principale du framework Flask. Tu y trouveras les routes, le JSON, les blueprints et les bonnes pratiques.

Déploiement Gunicorn

https://docs.gunicorn.org/en/stable/run.html

Documentation officielle de Gunicorn pour comprendre le fonctionnement des workers et du binding réseau.

Documentation UFW Ubuntu

https://ubuntu.com/server/docs/security-firewall

Guide officiel Ubuntu pour configurer UFW correctement.

Documentation systemd Debian

https://www.freedesktop.org/software/systemd/man/systemd.service.html

Documentation officielle des services systemd.

Documentation curl

https://curl.se/docs/manpage.html

Référence complète des options curl.

OpenClassrooms — Découvrez les API REST

https://openclassrooms.com/fr/courses/6228236-demarrez-votre-projet-avec-python

Très bon contenu pédagogique pour débuter les API en Python.

OpenClassrooms — Apprenez à programmer en Python

https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python

Permet de revoir les bases Python nécessaires avant Flask.

Mozilla Developer Network HTTP

https://developer.mozilla.org/fr/docs/Web/HTTP

Excellente référence francophone sur HTTP et les codes de retour.

RFC HTTP/1.1

https://datatracker.ietf.org/doc/html/rfc9110

Référence officielle du protocole HTTP.

22. Propositions de TP

TP 1 — Créer une API de supervision

Objectif :

créer une route /api/status ;
retourner un JSON ;
journaliser les accès.

TP 2 — Ajouter une gestion utilisateurs

Objectif :

ajouter un utilisateur ;
modifier un utilisateur ;
supprimer un utilisateur ;
utiliser GET/POST/PUT/DELETE.

TP 3 — Déployer Flask avec Gunicorn

Objectif :

installer Gunicorn ;
créer un service systemd ;
superviser les logs.

TP 4 — Ajouter Nginx

Objectif :

mettre Flask derrière Nginx ;
activer HTTPS ;
sécuriser le port 5000.

TP 5 — Créer une API pour Raspberry Pi

Objectif :

envoyer des données JSON ;
stocker des mesures ;
afficher les données via une route Flask.