BeanyOverTech

Développe la tech de demain

Développez une API Rest avec Python et Flask

Publié · Mis à jour

Les API sont devenues indispensables pour créer des applications et il y a une multitude de manière de les architecturer et de les structurer. Nous allons nous interesser au sein de cet article au développement d’une API REST via python et son framework Flask.

🔥 Ce que nous allons apprendre : 🔥

➡ Installer notre environnement virtuel grâce à venv

➡ Installer Flask et ses dépendances utiles

➡ Structurer nos dossiers pour architecturer notre API

➡ Implémenter un code simple pour notre première route en maitrisant les notions de modele et de schema

➡ Générer la documentation de notre API via Swagger

➡ Tester notre API via unittest

Les documentations utiles tout au long de l’article :

⁉ Pourquoi utiliser Flask pour notre API ⁉

Flask est un framework web WSGI léger. 

Il permet d’avoir une API rapidement et facilement tout en permettant d’évoluer davantage vers des applications complexes et robustes.

Selon la documentation officielle, Flask n’oppose de plus aucune dépendance ni architecture de projet. C’est un vous, maître développeur, de choisir les outils et bibliothèques que vous voulez.

Il est de plus très fiable. Cela permet de définir notre propre système d’authentification, de laisser le choix d’utiliser un ORM ou non à la différence de Django par exemple qui l’impose.

Si vous n’êtes pas convaincu, je vous laisse parcourir un bon nombre d’articles qui exposent l’ensemble des avantages et désavantages de ce framework, mais croyez-moi, il vaut le détour.

🐍 Initialisation du projet 🐍

Installation de VENV

Commençons par créer notre projet avec la creation de notre environnement virtuel et activons le. 

$ mkdir myProject  #on créé un nouveau dossier
$ cd myProject
$ pip install virtualenv # on installe virtualenv
$ virtualenv venv  # on créé notre environnement virtuel
$ cd venv/bin
$ chmod +x ./activate #on autorise l'activation
$  source ./activate # on active
$ cd ../.. # on retourne à la racine du projet
$ mkdir python-api-example # on créé un dossier de projet

Un dossier nommé « venv » est donc créé ainsi qu’un (venv) dans notre terminal.

Installation de Flask et de quelques dépendances utiles

Nous allons ensuite installer différentes choses comme suit : 

(venv) $ pip install flask
(venv) $ pip install flasgger
(venv) $ pip install flask-marshmallow
(venv)$ pip install apispec

Ici nous installons donc :

Flask : Qui est évidemment notre framework web

Flask Marshmallow : Qui nous permet de serialiser des objets afin de traiter les données Json dans notre API.

Flasgger : C’est le module qui va nous permettre d’intégrer des documents swagger à notre API Flask :

ApiSpec : Qui est obligatoire pour intégrer marshmallow et flasgger.

Structure du projet

Nous allons partir d’un projet vide, pour mieux comprendre ce que nous allons faire. Actuellement, nous n’avons que notre environement virtuel « venv ».

Nous allons donc créer un dossier nommé « python-api-example »

(venv) $ mkdir python-api-example

Et je vous laisse créer cette structure de base : 

python-api-example/
    api/
          model/
          route/
          schema/
    test/
    app.py

Ici la structure est assez simple mais efficace.

Nous avons 2 dossiers principaux au sein de notre projet : api et test.

Notre dossier api (la source de notre application) se décompose en 3 sous dossiers :

  • Model ℹ : Ce sont les descripteurs de données, et souvent liées aux modèles de notre base de donnée.
  • Routes ℹ : Ce sont les chemins de notre applications et c’est ici que l’on va définir la logique.
  • Schema ℹ :Cela comporte toutes les views de notre structure de données. Un schema par modèle en somme.

Et à la racine de notre dossier api, nous avons un fichier app.py, indispensable pour configurer notre API et l’initialiser.

Nous détaillerons tout cela par la suite.

En ce qui concerne notre dossier test, vous l’aurez compris, nous aborderons brièvement les tests unitaires pour notre application.

🐍 Codons notre première API utilisant Flask! 🐍

Attaquons-nous au développement de notre API.

La Route

Commençons par créer au sein de notre dossier route un fichier nommé home.py et insérons ce code : 

from http import HTTPStatus
from flask import Blueprint
from flasgger import swag_from
from api.model.homeModel import HomeModel
from api.schema.homeSchema import HomeSchema

home_api = Blueprint('api', __name__)

@home_api.route('/')
@swag_from({
    'responses': {
        HTTPStatus.OK.value: {
            'description': 'Display a welcome message',
            'schema': HomeSchema
        }
    }
})
def welcome():
    result = HomeModel()
    return HomeSchema().dump(result), 200

Que faisons-nous ici :

  • Tout d’abord nous créons un blueprint qui va permettre à notre api d’avoir son url local + /api ». Il est toujours mieux de séparer nos routes en plusieurs bluprints.
  • Nous déterminons notre route pour notre appel avec @home_api.route('/')
  • Ensuite, nous écrivons du code pour notre appel afin de générer une documentation Swagger en y ajoutant une description, le schema. C’est le cas le plus basique mais vous pourrez l’étoffer en lisant la documentation fournie plus haut.
  • Ensuite, nous devons placer le code de notre application, pour éventuellement renvoyer un objet de l’API. Pour sérialiser l’objet, nous utilisons nos schémas comme on peut le voir sur le code.

Le Modèle

Créons ensuite au sein de notre dossier nommé model un fichier nommé homeModel.py

class HomeModel:
    def __init__(self):
        self.message = "Hello World!"

Le Schema

Maintenant au sein du dossier schema, créons notre fichier homeSchema.py

from flask_marshmallow import Schema
from marshmallow.fields import Str


class HomeSchema(Schema):
    class Meta:
        # Fields to expose
        fields = ["message"]

    message = Str()

Le fichier app.py et la mise en place de Swagger

Nous avons le code principale de notre API. Mais encore une chose importante. Le developpement de notre fichier app.py qui nous permet d’initialiser notre application : 

from flask import Flask
from flasgger import Swagger

def create_app():
    app = Flask(__name__)

    app.config['SWAGGER'] = {
        'title': 'Flask API Starter Kit',
    }
    swagger = Swagger(app)

    return app


if __name__ == '__main__':
    from argparse import ArgumentParser

    parser = ArgumentParser()
    parser.add_argument('-p', '--port', default=5000, type=int, help='port to listen on')
    args = parser.parse_args()
    port = args.port

    app = create_app()

    app.run(host='0.0.0.0', port=port)

Lançons notre API

Pour lancer notre API rien de plus simple puisque nous avons déja configuré notre environnement. Faites : 

(venv) $ flask run

La réponse devrait être :

 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Notre localhost est donc http://127.0.0.1:5000/ mais n’oublions pas nous avons ajouter un chemin /api. Allez donc sur : http://127.0.0.1:5000/api

Vous devriez avoir : { « message » : « Hello World! »} comme ci dessus sur votre navigateur !

Et pour la documentation swagger ?

Allez sur http://127.0.0.1:5000/apidocs/

Notre documentation est ici !!

🐍 A vos tests ! 🐍

Testons désormais notre route simplement ! Ajoutons un dossier route à notre dossier test, puis créons un fichier nommé test_home.py

from unittest import TestCase
from app import create_app

class TestHome(TestCase):
    def setUp(self):
        self.app = create_app().test_client()

    def test_home(self):
        result = self.app.get('/api/')
        self.assertEqual({"message": 'Hello World!'}, result.get_json())

Pour lancer notre test faites :

(venv) $ python -m unittest

🐍 Conclusion 🐍

Il est facile et rapide de développer une API avec Flask ainsi que sa documentation Swagger ! Je vous invite à lire mes autres articles sur le sujet afin d’approfondir vos connaissances !

Étiquettes :

Vous aimerez aussi...