1. Introduction

Dans un BTS CIEL ou SIO, tu vas souvent développer des services réseau capables d’échanger des données avec d’autres applications. Les API REST occupent aujourd’hui une place centrale dans les architectures modernes. On les retrouve dans les applications web, les outils d’administration, les plateformes cloud, les objets connectés ou encore les infrastructures DevOps.

Flask permet de créer rapidement une API en Python avec une architecture simple et légère. Docker apporte ensuite un environnement isolé et reproductible pour exécuter cette API de manière fiable sur n’importe quel serveur Linux.

Dans cette fiche, tu vas apprendre à :

installer Flask ;
créer une API REST simple ;
conteneuriser l’application avec Docker ;
comprendre le fonctionnement réseau ;
exposer les bons ports ;
sécuriser le déploiement ;
diagnostiquer les erreurs courantes ;
tester concrètement les routes API.

L’objectif consiste à mettre en œuvre une API Flask dans un conteneur Docker comme on le ferait dans un environnement professionnel.

2. Sommaire

Introduction
Sommaire
Présentation de Flask et Docker
Installation de Docker sous Debian/Ubuntu
Architecture du projet Flask
Création de l’API Flask
Création du conteneur Docker
Construction et lancement du conteneur
Tests de l’API
Gestion réseau et pare-feu
Fichiers importants
Bloc de configuration complet
Explications détaillées
Exemples concrets
Commandes utiles et dépannage
Logs et diagnostic
Erreurs fréquentes
Bonnes pratiques de sécurité
Pour aller plus loin
Liens utiles
Propositions de TP

3. Présentation de Flask et Docker

3.1 Flask

Flask est un micro-framework Python destiné au développement web et aux API REST.

Tu peux :

créer des routes HTTP ;
recevoir des requêtes JSON ;
envoyer des réponses JSON ;
gérer des utilisateurs ;
interfacer une base de données ;
créer des outils d’administration.

Exemple d’utilisation :

API de supervision ;
backend web ;
outil de gestion réseau ;
serveur MQTT API ;
portail d’administration.

3.2 Docker

Docker permet d’exécuter une application dans un conteneur isolé.

Le conteneur embarque :

Python ;
Flask ;
les dépendances ;
la configuration.

Tu évites ainsi les problèmes de compatibilité entre machines.

4. Installation de Docker sous Debian/Ubuntu

4.1 Mise à jour du système

sudo apt update && sudo apt upgrade -y

Explications

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

4.2 Installation de Docker

sudo apt install docker.io -y

Explications

docker.io : paquet Docker officiel Debian/Ubuntu
-y : évite la confirmation interactive

4.3 Vérification du service

sudo systemctl status docker

Explications

systemctl pilote les services systemd
status affiche l’état du service Docker

4.4 Activation automatique au démarrage

sudo systemctl enable docker

Explications

enable active le démarrage automatique du service

4.5 Ajouter son utilisateur au groupe docker

sudo usermod -aG docker $USER

Explications

usermod modifie un utilisateur
-aG ajoute un groupe sans supprimer les autres
docker : groupe autorisé à utiliser Docker

Recharge ensuite la session :

newgrp docker

5. Architecture du projet Flask

5.1 Arborescence

flask-api/
├── app.py
├── requirements.txt
├── Dockerfile
└── .dockerignore

6. Création de l’API Flask

6.1 Création du dossier

mkdir flask-api
cd flask-api

6.2 Création du fichier app.py

from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route("/")
def accueil():
    return jsonify({"message": "API Flask opérationnelle"})

@app.route("/ping")
def ping():
    return jsonify({"response": "pong"})

@app.route("/addition", methods=["POST"])
def addition():
    data = request.get_json()

    a = data.get("a", 0)
    b = data.get("b", 0)

    resultat = a + b

    return jsonify({
        "a": a,
        "b": b,
        "resultat": resultat
    })

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

Explications

@app.route() crée une route HTTP
GET récupère des informations
POST envoie des données
jsonify() retourne du JSON valide
0.0.0.0 écoute sur toutes les interfaces réseau
5000 correspond au port Flask par défaut

6.3 Création du fichier requirements.txt

flask

Ce fichier liste les dépendances Python.

7. Création du conteneur Docker

7.1 Création du Dockerfile

Le fichier Dockerfile décrit comment construire le conteneur.

8. Construction et lancement du conteneur

8.1 Construction de l’image Docker

docker build -t flask-api .

Explications

build construit l’image
-t ajoute un nom
. utilise le dossier courant

8.2 Vérification des images

docker images

8.3 Lancement du conteneur

docker run -d -p 5000:5000 --name flask-api flask-api

Explications

run démarre un conteneur
-d lance en arrière-plan
-p 5000:5000 :
- port hôte : 5000
- port conteneur : 5000
--name attribue un nom

9. Tests de l’API

9.1 Tester la route principale

curl http://127.0.0.1:5000/

Résultat :

{"message":"API Flask opérationnelle"}

9.2 Tester la route ping

curl http://127.0.0.1:5000/ping

9.3 Tester la route POST

curl -X POST http://127.0.0.1:5000/addition \
-H "Content-Type: application/json" \
-d '{"a":10,"b":5}'

Explications

-X POST force la méthode POST
-H ajoute un header HTTP
-d envoie des données JSON

10. Gestion réseau et pare-feu

10.1 Ports utilisés

Service	Port
Flask	5000/tcp
HTTP standard	80/tcp
HTTPS	443/tcp

10.2 Autoriser le port avec UFW

sudo ufw allow 5000/tcp

Explications

allow autorise le trafic
5000/tcp cible Flask

10.3 Vérifier les règles

sudo ufw status verbose

10.4 Cas production

En environnement réel :

Flask ne doit pas être exposé directement ;
on utilise généralement :
- Nginx ;
- Apache ;
- Traefik ;
- HAProxy.

11. Fichiers importants

Fichier	Rôle
`/opt/flask-api/app.py`	code principal Flask
`/opt/flask-api/requirements.txt`	dépendances Python
`/opt/flask-api/Dockerfile`	construction du conteneur
`/var/lib/docker/`	stockage Docker
`/etc/docker/daemon.json`	configuration Docker
`/var/log/docker.log`	logs Docker selon configuration

12. Bloc de configuration complet

12.1 Synthèse Markdown pour ta fiche bristol

# API Flask avec Docker

## Installation Docker
```bash
sudo apt update
sudo apt install docker.io -y
sudo systemctl enable docker
sudo systemctl start docker
```

## Construction image
```bash
docker build -t flask-api .
```

## Lancement conteneur
```bash
docker run -d -p 5000:5000 --name flask-api flask-api
```

## Vérification
```bash
docker ps
docker logs flask-api
```

## Test API
```bash
curl http://127.0.0.1:5000/
```

## Pare-feu
```bash
sudo ufw allow 5000/tcp
```

12.2 Bloc de configuration Docker complet

FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

EXPOSE 5000

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

Explications

FROM définit l’image de base
WORKDIR crée le dossier de travail
COPY copie les fichiers
RUN exécute des commandes
EXPOSE documente le port
CMD lance l’application

13. Explications détaillées

13.1 Pourquoi utiliser Docker avec Flask

Docker apporte plusieurs avantages :

environnement identique partout ;
déploiement rapide ;
isolation ;
portabilité ;
facilité de sauvegarde ;
intégration DevOps.

Tu peux lancer le même conteneur :

sur Debian ;
Ubuntu ;
Proxmox ;
cloud ;
Raspberry Pi.

13.2 Pourquoi utiliser Flask

Flask reste très adapté aux projets BTS :

syntaxe simple ;
rapide à apprendre ;
peu de dépendances ;
idéal pour comprendre HTTP et REST.

14. Exemples concrets

14.1 API de supervision réseau

Routes possibles :

/api/ping
/api/status
/api/temperature
/api/cpu

14.2 API pour un serveur MQTT

Tu peux interfacer :

Mosquitto ;
Node-RED ;
MariaDB ;
Grafana.

14.3 API pour WordPress

WordPress peut interroger l’API Flask :

récupération JSON ;
supervision ;
affichage dynamique.

15. Commandes utiles et dépannage

15.1 Voir les conteneurs actifs

docker ps

15.2 Voir tous les conteneurs

docker ps -a

15.3 Arrêter un conteneur

docker stop flask-api

15.4 Redémarrer

docker restart flask-api

15.5 Supprimer un conteneur

docker rm flask-api

15.6 Voir les logs

docker logs flask-api

Options utiles :

-f : suivi temps réel
--tail 50 : affiche les 50 dernières lignes

Exemple :

docker logs -f --tail 50 flask-api

15.7 Accéder au shell du conteneur

docker exec -it flask-api bash

Explications

exec lance une commande
-it ouvre un terminal interactif
bash ouvre un shell

16. Logs et diagnostic

16.1 Logs Docker

Commande :

docker logs flask-api

Tu peux voir :

erreurs Python ;
erreurs Flask ;
requêtes HTTP ;
crashs applicatifs.

16.2 Journal systemd Docker

journalctl -u docker

Explications

journalctl lit les journaux systemd
-u docker filtre Docker

16.3 Vérifier les ports ouverts

ss -tulpn

Explications

-t TCP
-u UDP
-l écoute
-p processus
-n mode numérique

17. Erreurs fréquentes

17.1 Port déjà utilisé

Erreur :

bind: address already in use

Diagnostic :

ss -tulpn | grep 5000

17.2 Flask inaccessible depuis le réseau

Cause fréquente :

app.run(host="127.0.0.1")

Solution :

app.run(host="0.0.0.0")

17.3 Dépendance absente

Erreur :

ModuleNotFoundError

Solution :

Vérifie requirements.txt.

18. Bonnes pratiques de sécurité

évite d’exécuter Flask en mode debug ;
utilise HTTPS avec un reverse proxy ;
limite les ports exposés ;
applique les mises à jour Docker ;
filtre les accès avec UFW ;
évite d’exécuter les conteneurs en root ;
stocke les secrets dans des variables d’environnement ;
utilise des images officielles.

19. Pour aller plus loin

Tu peux approfondir :

Flask RESTful ;
Gunicorn ;
Docker Compose ;
Nginx reverse proxy ;
CI/CD GitLab ;
Kubernetes ;
JWT ;
Swagger/OpenAPI ;
SQLAlchemy ;
authentification OAuth2.

20. Liens vers : les sites officiels, les mooc ou autres contenus pédagogiques qui font références, etc

Documentation officielle Flask

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

Documentation officielle complète de Flask. Tu y trouveras les routes, le routage, les templates, les réponses JSON et les bonnes pratiques.

Documentation officielle Docker

https://docs.docker.com/get-started

Excellent point d’entrée pour comprendre les images, conteneurs, réseaux et volumes Docker.

Documentation Dockerfile

https://docs.docker.com/reference/dockerfile

Référence officielle détaillée des instructions Dockerfile.

Documentation Debian Docker

https://wiki.debian.org/Docker

Documentation Debian spécifique à l’installation et à l’administration de Docker.

Documentation Ubuntu UFW

https://ubuntu.com/server/docs/firewalls-ufw

Documentation officielle Ubuntu sur le pare-feu UFW.

OpenClassrooms — Découvrez le fonctionnement des API REST

https://openclassrooms.com/fr/courses/4668056-construisez-des-api-rest-avec-symfony

Même si le cours utilise Symfony, les principes REST restent identiques et très pédagogiques.

OpenClassrooms — Découvrez Docker

https://openclassrooms.com/fr/courses/1768796-reprenez-le-controle-a-laide-de-linux/6098926-utilisez-des-conteneurs-avec-docker

Très bon support pour débuter Docker progressivement.

RFC HTTP

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

Référence officielle du protocole HTTP.

21. Propositions de TP pour s’exercer

TP 1 — Créer une API ping

Objectif :

créer une route /ping
retourner du JSON

TP 2 — Ajouter une route POST

Objectif :

recevoir des données JSON ;
calculer une addition ;
retourner le résultat.

TP 3 — Ajouter une base SQLite

Objectif :

stocker des utilisateurs ;
lire les données via l’API.

TP 4 — Sécuriser avec UFW

Objectif :

ouvrir uniquement le port 5000 ;
bloquer le reste.

TP 5 — Déployer derrière Nginx

Objectif :

utiliser un reverse proxy ;
activer HTTPS ;
comprendre la séparation frontend/backend.

TP 6 — Créer un docker-compose.yml

Objectif :

lancer Flask ;
lancer MariaDB ;
connecter les conteneurs ensemble.