Fiche api rest

Par /

1. Introduction

Les API REST occupent une place centrale dans les infrastructures modernes. Tu les retrouves dans les applications web, les outils DevOps, les solutions cloud, les logiciels métiers, les applications mobiles et les plateformes de cybersécurité.

Dans un BTS CIEL ou SIO, comprendre le fonctionnement d’une API REST permet de :

  • communiquer entre plusieurs applications ;
  • automatiser des tâches d’administration ;
  • superviser des équipements ;
  • interagir avec des services distants ;
  • développer des applications modernes ;
  • sécuriser les échanges réseau.

Cette fiche t’explique le fonctionnement d’une API REST, les méthodes HTTP principales, la structure des requêtes et des réponses, ainsi que les outils utiles pour tester et dépanner une API sous Debian ou Ubuntu.

2. Sommaire

  1. Introduction
  2. Sommaire
  3. Comprendre le fonctionnement d’une API REST
  4. Installation des outils nécessaires
  5. Synthèse Markdown pour ta fiche bristol
  6. Fichiers importants
  7. Exemple complet d’API REST
  8. Comprendre les méthodes HTTP
  9. Comprendre les codes de retour HTTP
  10. Tester une API REST avec curl
  11. Tester une API REST avec Postman
  12. Utiliser JSON dans les API REST
  13. Sécuriser une API REST
  14. Pare-feu et ports réseau
  15. Commandes utiles et dépannage
  16. Logs et analyse des erreurs
  17. Cas concrets d’utilisation
  18. Erreurs fréquentes
  19. Bonnes pratiques
  20. Pour aller plus loin
  21. Liens utiles et ressources officielles
  22. Propositions de TP

3. Comprendre le fonctionnement d’une API REST

Une API REST permet à plusieurs applications de communiquer via le protocole HTTP.

Le client envoie une requête HTTP vers un serveur. Ensuite, le serveur répond généralement avec des données au format JSON.

Tu peux voir REST comme une interface de communication standardisée entre logiciels.

Exemple :

  • un site web demande une liste d’utilisateurs ;
  • une application mobile récupère des données météo ;
  • un script Python envoie des mesures à un serveur ;
  • un outil de supervision interroge une API réseau.

Architecture simplifiée :

[Client] ---> HTTP/HTTPS ---> [API REST] ---> [Base de données]

Les API REST utilisent principalement :

  • HTTP ou HTTPS ;
  • JSON ;
  • des URL structurées ;
  • des méthodes HTTP.

Exemple d’URL :

https://api.exemple.local/utilisateurs/15

Ici :

  • https:// : protocole sécurisé ;
  • api.exemple.local : serveur ;
  • /utilisateurs/15 : ressource demandée.

4. Installation des outils nécessaires

Sous Debian ou Ubuntu, installe plusieurs outils utiles pour travailler avec les API REST.

Installation de curl

curl permet d’envoyer des requêtes HTTP directement depuis le terminal.

sudo apt update
sudo apt install curl

Explication des commandes

  • apt update : met à jour la liste des paquets disponibles.
  • apt install curl : installe le client HTTP curl.

Installation de jq

jq permet de lire et formater les réponses JSON.

sudo apt install jq

Vérification des versions

curl --version
jq --version

5. Synthèse Markdown pour ta fiche bristol

Synthèse Markdown pour ta fiche bristol

# API REST

## Principe
Une API REST permet à des applications de communiquer via HTTP/HTTPS.

## Méthodes HTTP
- GET : lire des données
- POST : créer
- PUT : modifier totalement
- PATCH : modifier partiellement
- DELETE : supprimer

## Formats
- JSON principalement

## Exemple GET
```bash
curl http://api.local/users
```

## Exemple POST
```bash
curl -X POST http://api.local/users \
-H "Content-Type: application/json" \
-d '{"nom":"alice"}'
```

## Codes HTTP
- 200 : OK
- 201 : créé
- 400 : erreur client
- 401 : non authentifié
- 403 : interdit
- 404 : introuvable
- 500 : erreur serveur

## Sécurité
- HTTPS obligatoire
- Authentification
- Validation des entrées
- Limitation des accès

## Ports
- HTTP : 80
- HTTPS : 443

6. Fichiers importants

Même si une API REST ne possède pas toujours les mêmes fichiers selon la technologie utilisée, certains emplacements reviennent très souvent.

API Node.js / Express

/var/www/api/
/var/www/api/package.json
/var/www/api/server.js
/var/www/api/routes/
/var/www/api/controllers/
/var/www/api/middlewares/

API Python Flask

/opt/api/
/opt/api/app.py
/opt/api/requirements.txt

Configuration Nginx

/etc/nginx/nginx.conf
/etc/nginx/sites-available/api.conf
/etc/nginx/sites-enabled/api.conf

Logs système

/var/log/nginx/access.log
/var/log/nginx/error.log
/var/log/apache2/access.log
/var/log/apache2/error.log

7. Exemple complet d’API REST

Voici un exemple minimal d’API REST avec Python Flask.

Installation

sudo apt install python3 python3-pip
pip3 install flask

Exemple complet

from flask import Flask, jsonify, request

app = Flask(__name__)

users = [
    {"id": 1, "nom": "alice"},
    {"id": 2, "nom": "bob"}
]

@app.route("/users", methods=["GET"])
def get_users():
    return jsonify(users)

@app.route("/users", methods=["POST"])
def add_user():
    data = request.json
    users.append(data)
    return jsonify({"message": "Utilisateur ajouté"}), 201

@app.route("/users/<int:user_id>", methods=["DELETE"])
def delete_user(user_id):
    global users
    users = [u for u in users if u["id"] != user_id]
    return jsonify({"message": "Utilisateur supprimé"})

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

8. Comprendre les méthodes HTTP

GET

GET récupère des informations.

Exemple :

curl http://localhost:5000/users

POST

POST crée une nouvelle ressource.

curl -X POST http://localhost:5000/users \
-H "Content-Type: application/json" \
-d '{"id":3,"nom":"charlie"}'

Explication des options

  • -X POST : force la méthode HTTP POST.
  • -H : ajoute un en-tête HTTP.
  • -d : envoie des données.

PUT

PUT remplace complètement une ressource.

PATCH

PATCH modifie uniquement certains champs.

DELETE

DELETE supprime une ressource.

curl -X DELETE http://localhost:5000/users/3

9. Comprendre les codes de retour HTTP

200 OK

La requête fonctionne.

201 Created

Le serveur crée une ressource.

400 Bad Request

Le client envoie une requête invalide.

401 Unauthorized

Le client doit s’authentifier.

403 Forbidden

Le serveur refuse l’accès.

404 Not Found

La ressource n’existe pas.

500 Internal Server Error

Le serveur rencontre une erreur interne.

10. Tester une API REST avec curl

Requête GET simple

curl http://localhost:5000/users

Afficher les en-têtes HTTP

curl -I http://localhost:5000/users

Explication

  • -I : récupère uniquement les en-têtes HTTP.

Mode verbeux

curl -v http://localhost:5000/users

Pourquoi utiliser -v

Cette option affiche :

  • la connexion TCP ;
  • les en-têtes ;
  • les négociations HTTP ;
  • les éventuelles erreurs SSL/TLS.

Formater du JSON avec jq

curl http://localhost:5000/users | jq

11. Tester une API REST avec Postman

Postman permet de :

  • créer des requêtes ;
  • sauvegarder des tests ;
  • automatiser des scénarios ;
  • tester des authentifications.

Sous Linux, tu peux installer Postman via Snap :

sudo snap install postman

12. Utiliser JSON dans les API REST

Les API REST utilisent principalement JSON.

Exemple :

{
  "id": 1,
  "nom": "alice",
  "role": "admin"
}

Pourquoi JSON ?

JSON :

  • reste léger ;
  • se lit facilement ;
  • fonctionne dans tous les langages modernes.

13. Sécuriser une API REST

Utiliser HTTPS

HTTPS chiffre les échanges réseau.

Ports :

  • HTTP : 80
  • HTTPS : 443

Ajouter une authentification

Méthodes fréquentes :

  • API Key ;
  • JWT ;
  • OAuth2 ;
  • Basic Auth.

Limiter les accès

Tu peux :

  • filtrer les IP ;
  • limiter le nombre de requêtes ;
  • utiliser un reverse proxy Nginx.

Valider les données

Une API doit toujours :

  • vérifier les types ;
  • filtrer les caractères dangereux ;
  • empêcher les injections SQL ;
  • contrôler les tailles de données.

14. Pare-feu et ports réseau

Autoriser HTTPS avec UFW

sudo ufw allow 443/tcp

Explication

  • allow : autorise le trafic.
  • 443/tcp : ouvre HTTPS.

API locale uniquement

Si l’API reste locale, ne publie pas le port vers Internet.

Exemple :

  • API locale : accès uniquement depuis 127.0.0.1
  • API interne : accès LAN uniquement
  • API publique : HTTPS obligatoire

Vérifier les ports ouverts

sudo ss -tulpn

Explication

  • -t : TCP
  • -u : UDP
  • -l : ports en écoute
  • -p : processus
  • -n : mode numérique

15. Commandes utiles et dépannage

Tester la connectivité

ping serveur.local

Tester un port

nc -vz serveur.local 443

Explication

  • -v : mode verbeux
  • -z : scan sans transfert

Voir les requêtes HTTP

curl -v https://api.local

Vérifier les processus

ps aux | grep python

Vérifier les ports

sudo ss -tulpn

Tester TLS

openssl s_client -connect api.local:443

16. Logs et analyse des erreurs

Logs Nginx

/var/log/nginx/access.log
/var/log/nginx/error.log

Lecture en temps réel

sudo tail -f /var/log/nginx/access.log

Explication

  • tail -f : affiche les nouvelles lignes en direct.

Que voit-on dans les logs ?

Dans access.log :

  • IP source ;
  • URL ;
  • méthode HTTP ;
  • code retour ;
  • navigateur ;
  • temps de réponse.

Dans error.log :

  • erreurs PHP ;
  • problèmes proxy ;
  • erreurs backend ;
  • erreurs TLS.

Logs Flask

Si tu exécutes Flask manuellement :

python3 app.py

Le terminal affiche directement :

  • les requêtes ;
  • les erreurs Python ;
  • les codes HTTP.

Journalctl avec systemd

sudo journalctl -u nginx

Ou :

sudo journalctl -u apache2

17. Cas concrets d’utilisation

API REST pour WordPress

WordPress expose une API REST :

https://site.local/wp-json/

Exemple :

curl https://site.local/wp-json/wp/v2/posts

Supervision réseau

Un serveur récupère :

  • état des équipements ;
  • métriques ;
  • alertes.

Domotique

Les objets connectés utilisent souvent REST :

  • capteurs ;
  • caméras ;
  • automates.

Cybersécurité

Les API REST servent aussi à :

  • automatiser des scans ;
  • récupérer des IOC ;
  • piloter des firewalls ;
  • centraliser des logs.

18. Erreurs fréquentes

Erreur 401

Cause :

  • authentification absente ;
  • token invalide.

Erreur 403

Cause :

  • droits insuffisants ;
  • filtrage IP.

Erreur 404

Cause :

  • mauvaise URL ;
  • route inexistante.

Erreur 500

Cause :

  • bug applicatif ;
  • problème base de données ;
  • exception Python/PHP.

JSON invalide

Cause :

  • virgule oubliée ;
  • guillemets incorrects ;
  • structure invalide.

19. Bonnes pratiques

  • Utilise HTTPS systématiquement.
  • Active les logs.
  • Filtre les entrées utilisateur.
  • N’expose jamais une API de test sur Internet.
  • Limite les permissions.
  • Documente les routes API.
  • Utilise des codes HTTP cohérents.
  • Sépare environnement de développement et production.
  • Place l’API derrière Nginx ou Apache.
  • Surveille les erreurs et le trafic.

20. Pour aller plus loin

Tu peux approfondir :

  • JWT ;
  • OAuth2 ;
  • GraphQL ;
  • OpenAPI ;
  • Swagger ;
  • FastAPI ;
  • sécurisation des API ;
  • reverse proxy Nginx ;
  • Docker pour APIs ;
  • monitoring Prometheus/Grafana.

21. Liens utiles et ressources officielles

Documentation officielle HTTP

RFC officielle HTTP :

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

Cette RFC décrit le fonctionnement moderne du protocole HTTP.

Documentation curl

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

La documentation officielle de curl détaille toutes les options du client HTTP.

Documentation Flask

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

Documentation officielle du framework Flask utilisé dans les exemples.

Documentation Debian UFW

https://wiki.debian.org/Uncomplicated%20Firewall%20%28ufw%29

Cette page explique la configuration du pare-feu UFW sous Debian.

Documentation Ubuntu UFW

https://help.ubuntu.com/community/UFW

Guide Ubuntu officiel sur UFW.

Documentation JSON

https://www.json.org/json-fr.html

Présentation complète du format JSON.

OpenClassrooms — Découvrez le fonctionnement des API REST

https://openclassrooms.com/fr/courses/6224541-creez-des-api-restful-avec-python-et-flask

Cours francophone progressif avec Flask et REST.

OpenClassrooms — Administrez un système Linux

https://openclassrooms.com/fr/courses/7170491-administrez-un-systeme-linux

Très utile pour comprendre les outils système et réseau utilisés avec les API.

Mozilla Developer Network — HTTP

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

Excellente ressource pédagogique sur HTTP et les méthodes REST.

22. Propositions de TP

TP 1 — Tester une API publique

Objectif :

  • utiliser curl ;
  • lire du JSON ;
  • comprendre HTTP.

Travail demandé :

  • interroger une API météo ;
  • récupérer un JSON ;
  • identifier les codes HTTP.

TP 2 — Créer une API Flask

Objectif :

  • développer une API REST simple.

Travail demandé :

  • créer une route GET ;
  • ajouter une route POST ;
  • retourner du JSON.

TP 3 — Sécuriser une API

Objectif :

  • mettre en place HTTPS.

Travail demandé :

  • installer Nginx ;
  • ajouter un reverse proxy ;
  • ouvrir le port 443 avec UFW.

TP 4 — Analyser les logs API

Objectif :

  • comprendre les journaux HTTP.

Travail demandé :

  • provoquer des erreurs 404 ;
  • observer les logs ;
  • identifier les IP sources ;
  • analyser les codes HTTP.

TP 5 — Automatiser des appels API

Objectif :

  • utiliser Bash ou Python.

Travail demandé :

  • envoyer automatiquement des requêtes ;
  • parser les réponses JSON ;
  • sauvegarder les résultats dans un fichier.

Publications similaires

Retour en haut