Comment créer une API REST avec Flask sur Ubuntu

Introduction

Dans ce tutoriel, vous apprendrez comment créer une API REST simple en utilisant Flask, un framework Web léger Python. Nous couvrirons les bases de la configuration d’une application Flask, la définition de routes, le traitement des demandes et le retour de réponses JSON. À la fin de ce tutoriel, vous aurez une API fonctionnelle que vous pouvez étendre et intégrer avec d’autres applications.

Prérequis

• Un serveur fonctionnant sous Ubuntu et un utilisateur non-root avec des privilèges sudo et un pare-feu actif. Pour des instructions sur la configuration, veuillez choisir votre distribution à partir de cette liste et suivez notre guide de configuration initiale du serveur. Veuillez vous assurer de travailler avec une version supportée d’Ubuntu.

• Famille avec la ligne de commande Linux. Pour une introduction ou un rappel sur la ligne de commande, vous pouvez visiter ce guide sur préliminaires de la ligne de commande Linux

• Un基本了解Python编程。

• Python 3.7或更高版本已安装在您的Ubuntu系统上。要了解如何在Ubuntu上运行Python脚本，请参考我们关于如何在Ubuntu上运行Python脚本的教程。

Étape 1 — Configuration de votre environnement Flask

Ubuntu 24.04 fournit Python 3 par défaut. Ouvrez le terminal et exécutez la commande suivante pour vérifier l’installation de Python 3 :

root@ubuntu:~# python3 --version
Python 3.12.3

Si Python 3 est déjà installé sur votre machine, la commande précédente retournera la version actuelle de l’installation de Python 3. Dans le cas où elle n’est pas installée, vous pouvez exécuter la commande suivante pour installer Python 3 :

root@ubuntu:~# sudo apt install python3

Next, vous devez installer l’outil d’installation de packages pip sur votre système :

root@ubuntu:~# sudo apt install python3-pip

Une fois que pip est installé, installez Flask.

Vous installerez Flask via pip. Il est recommandé de faire cela dans un environnement virtuel pour éviter les conflits avec d’autres paquets sur votre système.

root@ubuntu:~# python3 -m venv monprojetenv
root@ubuntu:~# source monprojetenv/bin/activate

root@ubuntu:~# pip install Flask

Étape 2 – Créer une application Flask

La prochaine étape consiste à écrire le code Python pour l’application Flask. Pour créer un nouveau script, naviguez vers le dossier de votre choix :

root@ubuntu:~# cd ~/chemin-vers-le-dossier-de-votre-script

Une fois dans le dossier, créez un nouveau fichier Python, app.py, et importez Flask. Ensuite, initialisez une application Flask et créez une route de base.

root@ubuntu:~# nano app.py

Cela ouvrira un éditeur de texte vide. Écrivez votre logique ici ou copiez le code suivant :

from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route('/')
def hello_world():
    return jsonify(message="Hello, World!")

# Stockage de données en mémoire
items = [{"id": 1, "name": "This is item 1"}, {"id": 2, "name": "This is item 2"}]

Étape 3 — Création de routes RESTful

Dans cette section, nous définirons des routes dans notre application Flask qui correspondent aux différentes actions qu’un utilisateur peut effectuer sur l’API. Chaque route traitera un certain nombre d’ méthodes HTTP spécifiques.

GET, POST, PUT, et DELETE. Ces méthodes correspondent aux quatre opérations de base du stockage persistant, souvent appelées CRUD (Créer, Lire, Mettre à jour, Supprimer).

Ajoutez les routes suivantes à votre script Python app.py :

from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route('/')
def hello_world():
    return jsonify(message="Hello, World!")

# Stockage de données en mémoire
items = [{"id": 1, "name": "This is item 1"}, {"id": 2, "name": "This is item 2"}]

# Requête GET : Récupérer tous les éléments
@app.route('/api/items', methods=['GET'])
def get_items():
    return jsonify(items)

# Requête GET : Récupérer un élément spécifique par ID
@app.route('/api/items/<int:item_id>', methods=['GET'])
def get_item(item_id):
    item = next((item for item in items if item["id"] == item_id), None)
    if item is None:
        return jsonify({"error": "Item not found"}), 404
    return jsonify(item)

# Requête POST : Créer un nouvel élément
@app.route('/api/items', methods=['POST'])
def create_item():
    new_item = {"id": len(items) + 1, "name": request.json.get('name')}
    items.append(new_item)
    return jsonify(new_item), 201

# Requête PUT : Mettre à jour un élément existant
@app.route('/api/items/<int:item_id>', methods=['PUT'])
def update_item(item_id):
    item = next((item for item in items if item["id"] == item_id), None)
    if item is None:
        return jsonify({"error": "Item not found"}), 404
    item['name'] = request.json.get('name', item['name'])
    return jsonify(item)

# Requête DELETE : Supprimer un élément
@app.route('/api/items/<int:item_id>', methods=['DELETE'])
def delete_item(item_id):
    global items
    items = [item for item in items if item["id"] != item_id]
    return '', 204

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

Cherchez-nous d’avantage sur ce que font chacune des fonctions :

• Imports Flask : Le code importe les composants nécessaires de Flask : Flask, jsonify, et request.

• Stockage de données en mémoire : items est une simple liste de dictionnaires qui agit comme un magasin de données temporaires pour l’API. Chaque élément possède un id et un name.

• GET /api/items : Lorsqu’une requête GET est effectuée sur /api/items, le serveur retourne une liste de tous les articles dans le magasin de données des articles. Cela est utile pour récupérer toutes les ressources d’une collection.

• POST /api/items : Une requête POST sur /api/items permet au client de créer un nouvel article. Le serveur attend un objet JSON contenant les détails du nouvel article dans le corps de la requête. Après la création de l’article, le serveur répond avec l’article nouvellement créé et un code d’état 201 Created.

• PUT /api/items/<int:item_id> : Une requête PUT sur /api/items/<item_id> est utilisée pour mettre à jour un article existant avec le item_id spécifié. Le client envoie les données mises à jour dans le corps de la requête, et le serveur modifie l’article existant. Si l’article n’est pas trouvé, le serveur retourne une erreur 404 Not Found.

• DELETE /api/items/<int:item_id> : Une requête DELETE à /api/items/<item_id> supprime l’élément avec l’item_id spécifié du magasin de données. Si l’élément est supprimé avec succès, le serveur répond avec un code de statut 204 No Content, indiquant que la suppression a réussi et qu’il n’y a pas de contenu supplémentaire à renvoyer.

• Exécution de l’application : Le bloc if __name__ == "__main__": garantit que l’application Flask s’exécute lorsque le script est exécuté directement.

Étape 4 — Exécution et test de votre API

Démarrez votre serveur Flask en utilisant la commande suivante :

root@ubuntu:~# python3 app.py

Vous devriez voir le serveur Flask en cours d’exécution avec l’affichage suivant :

Output
* Serving Flask app 'app'
 * Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 837-877-972

A partir de l’affichage ci-dessus, vous pouvez voir que le serveur fonctionne sur http://127.0.0.1 et écoute sur le port 5000.

Maintenant, vous pouvez tester les points d’accès en utilisant curl, Postman ou un autre client HTTP. Dans ce tutoriel, vous utiliserez curl pour tester les points d’accès et envoyer les demandes HTTP.

Ouvrez une autre console Ubuntu et exécutez les commandes curl suivantes une par une :

• GET : curl http://127.0.0.1:5000/api/items
• POST : curl -X POST -H "Content-Type: application/json" -d '{"name": "This is item 3"}' http://127.0.0.1:5000/api/items
• PUT : curl -X PUT -H "Content-Type: application/json" -d '{"name": "This is updated item 1"}' http://127.0.0.1:5000/api/items/1
• DELETE : curl -X DELETE http://127.0.0.1:5000/api/items/1

Voyons chacune de ces commandes en action :

root@ubuntu:~# curl http://127.0.0.1:5000/api/items

Output
[
  {
    "id": 1,
    "name": "This is item 1"
  },
  {
    "id": 2,
    "name": "This is item 2"
  }
]

Vous constateriez que le serveur retourne une liste de tous les éléments dans le magasin de données des éléments.

En utilisant la méthode POST, essayons d’ajouter un nouvel élément au magasin de données.

root@ubuntu:~# curl -X POST -H "Content-Type: application/json" -d '{"name": "This is item 3"}' http://127.0.0.1:5000/api/items

Output
{
  "id": 3,
  "name": "This is item 3"
}

* Running on http://127.0.0.1:5000
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 837-877-972
127.0.0.1 - - [23/Aug/2024 06:57:27] "GET /api/items HTTP/1.1" 200 -
127.0.0.1 - - [23/Aug/2024 06:59:56] "POST /api/items HTTP/1.1" 201 -

Ensuite, essayons d’exécuter une requête PUT. Une requête PUT vers /api/items/<item_id> met à jour un élément existant avec l’ID d’élément spécifié item_id.

root@ubuntu:~# curl -X PUT -H "Content-Type: application/json" -d '{"name": "This is updated item 1"}' http://127.0.0.1:5000/api/items/1

Output
{
  "id": 1,
  "name": "This is updated item 1"
}

Maintenant, essayons d’exécuter une requête GET pour voir l’élément mis à jour 1.

root@ubuntu:~# curl http://127.0.0.1:5000/api/items/1

Output
{
  "id": 1,
  "name": "This is updated item 1"
}

Enfin, essayons d’exécuter une requête DELETE pour supprimer un élément du magasin de données.

root@ubuntu:~# curl -X DELETE http://127.0.0.1:5000/api/items/1

Cela supprimera l’élément 1 du magasin de données.

Pour vérifier cela, exécutons une requête GET.

root@ubuntu:~# curl http://127.0.0.1:5000/api/items

Output
[
  {
    "id": 2,
    "name": "This is item 2"
  },
  {
    "id": 3,
    "name": "This is item 3"
  }
]

Vous constaterez que l’élément 1 est désormais absent et a été supprimé définitivement.

Conclusion

Dans ce tutoriel, vous avez créé une application de base REST en utilisant Flask. Vous pouvez maintenant étendre cette API avec des routes supplémentaires, intégrer une base de données ou la déployer sur une plateforme cloud comme DigitalOcean. Flask est une puissante plateforme pour construire des API rapidement et de manière efficace, et avec ces bases, vous êtes prêt à commencer la construction d’applications plus complexes.