Flask est un framework Web Python léger idéal pour créer des API RESTful et des microservices. Contrairement aux frameworks plus lourds tels que Django, Flask est minimal et sans opinion, donnant aux développeurs un contrôle total sur la structure de l'application. Cette flexibilité en fait un excellent choix pour développer des API Web personnalisées et évolutives adaptées aux exigences spécifiques des projets.
Donc, Flask Python est un microframework qui vous permettra d'exécuter une application Web en très peu d'étapes et pratiquement aucune configuration. La simplicité de ce framework et son contrôle strict sur ce que vous voulez dans votre application en ont fait l'un des plus utilisés cadres de développement Web.
Python est un langage très populaire et puissant avec une grande communauté qui existe depuis longtemps. De nombreuses grandes entreprises, comme Google, l'utilisent pour leurs projets et le nombre de personnes qui l'utilisent pour développement web continue d'augmenter.
Nous vous montrerons qu'il est simple, flexible et modulaire, pour une expérience de développement agréable.
Nous attendons de l'utilisateur qu'il ait des connaissances de base sur Python pour comprendre toutes les étapes présentées. Néanmoins, toute personne devrait être en mesure d'avoir l'application opérationnelle après avoir suivi ce tutoriel.
Un framework est une bibliothèque utilisée par les développeurs pour créer et gérer des applications Web fiables et évolutives. Il existe plusieurs cadres disponible pour Python, comme Tornado, Pyramind et, bien sûr, Django (qui est souvent comparé à Flask).
Flask (🌶️) est un microframework Python pour développement web. Bien qu'il soit construit avec un petit cœur et considéré comme une interface de passerelle de serveur Web (WSGI) très légère, Flask se distingue par sa philosophie facile à étendre. Il a été conçu pour s'adapter à des applications complexes et pour permettre un démarrage facile et rapide.
De plus, un autre avantage important de Flask est sa fonctionnalité. Même s'il propose des suggestions, Flask n'exige pas obligatoirement de mises en page de projet ou d'autres dépendances. Au lieu de cela, il permet aux développeurs de choisir les bibliothèques et les outils qu'ils souhaitent utiliser et propose en outre divers extensions disponibles, qui sont fournis par la communauté.
API est un acronyme de Application Programming Interface, ce qui signifie qu'il s'agit essentiellement la façon dont vous communiquez avec une application. Une API REST (Representational State Transfer) permet la communication entre les systèmes à l'aide de méthodes HTTP standard et correspond à un style architectural qui vise les communications sans état et sépare les préoccupations relatives aux clients et aux serveurs. Il échange généralement des données au format JSON et fonctionne à l'aide de points de terminaison correspondant à des actions telles que Créer (POST), Lire (GET), Mettre à jour (PUT ou PATCH) et Supprimer (DELETE). Les API REST sont largement utilisées pour leur simplicité, leur évolutivité et leur compatibilité avec un large éventail de clients et de plateformes.
Le API REST sur cet exercice créera une fausse implémentation de Actions CRUD au-dessus d'une entité. Une API avec CRUD permet les opérations de création, de lecture, de mise à jour et de suppression sur les éléments de l'application.
Cet article vous guidera dans les premières étapes pour créer une API REST à l'aide de Flask (🌶️).
Ci-dessous, vous pouvez voir les points de terminaison que vous aurez à la fin du didacticiel. La documentation présentée est également générée par l'application que vous allez créer !
Python doit être installé sur la machine actuelle. Le code présenté prendra en compte Python3. Si vous souhaitez utiliser Python2 et/ou si vous suivez cette procédure sur un ordinateur Windows, veuillez suivre les instructions présentées dans Guide d'installation du flacon.
Commençons par création d'un répertoire pour enregistrer le projet. Dans le répertoire dans lequel vous souhaitez placer votre projet, exécutez les commandes suivantes sur le shell :
Nous avons créé le flask_demo répertoire et l'a déplacé à l'intérieur. Avant de commencer à installer les dépendances, créons un environnement virtuel en exécutant la commande suivante :
Cela créera un dossier dans votre projet avec le nom .venv. Ensuite, nous devons activer l'environnement correspondant en exécutant :
Cela signifie que nous envisageons maintenant la environnement virtuel venv lors de l'exécution de n'importe quel code Python. Il peut être important de spécifier l'environnement que vous envisagez lorsque vous l'exécutez dans votre IDE.
Assurez-vous de respecter l'environnement actif avant de passer aux étapes suivantes. Vous pouvez vérifier si vous vous trouvez dans l'environnement en regardant sur le côté gauche de la console. Si le nom de l'environnement virtuel est entre parenthèses, vous êtes prêt à partir.
Si tu veux désactiver l'environnement, exécutez simplement la commande suivante :
Avant de commencer à développer une API Flask, assurez-vous que Python est installé. Il est recommandé d'utiliser un environnement virtuel pour gérer les dépendances et isoler votre projet.
Installez le package Flask à l'aide de pépin (programme d'installation du package Python) :
pip install Flask==2.3.3
Au moment de la rédaction de cet article, la version stable de Flask est la 2.3.3. Si vous souhaitez que les spécifications du projet soient mises à jour et alignées sur cette version, vous pouvez utiliser un requirements.txt fichier au lieu d'installer Flask manuellement. Vous pouvez copier le fichier ci-dessous dans le répertoire racine :
Flask==2.3.3
Après cela, il vous suffit d'exécuter la commande suivante :
pip install -r requirements.txt
Nous sommes maintenant prêts à commencer à développer notre API REST.
Le premier point de terminaison code :
### First Steps: Your Hello World Flask API
Here’s how to build your first minimal Flask REST API:
```python
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
return {'message': 'Hello, World!'}
if __name__ == '__main__':
app.run(debug=True)
Cet exemple configure un point de terminaison de base qui renvoie une réponse JSON. Le app.run () La fonction lance un serveur de développement qui écoute sur le port 5000 par défaut.
Quoi ? ! Est-ce aussi simple que cela ? Oui, ça l'est ! Le code est fait pour avoir une application avec un point de terminaison implémenté. Il ne nous reste plus qu'à définir Variables d'environnement Flask et voir votre candidature ? Notez que vous devez vous trouver dans le dossier contenant le main.py fichier pour exécuter ces commandes.
Accédez au lien http://localhost:5000/basic_api/hello_world pour voir le message classique que nous aimons tous.
Maintenant que nous avons créé notre premier point de terminaison, revenons à l'objectif principal de cet article de blog sur l'application : avoir API REST avec la structure de base du CRUD. Créons une API qui prend en charge les opérations CRUD sur une liste d'éléments. Il s'agit d'un cas d'utilisation courant dans les services de développement Web et de backend.
from flask import Flask, jsonify, request
app = Flask(__name__)
items = []
@app.route('/items', methods=['GET'])
def get_items():
return jsonify(items)
@app.route('/items', methods=['POST'])
def add_item():
data = request.get_json()
items.append(data)
return jsonify(data), 201
@app.route('/items/<int:index>', methods=['PUT'])
def update_item(index):
data = request.get_json()
items[index] = data
return jsonify(data)
@app.route('/items/<int:index>', methods=['DELETE'])
def delete_item(index):
item = items.pop(index)
return jsonify(item)
Cette API REST simple dans Flask permet aux clients de gérer une liste d'éléments à l'aide de méthodes HTTP standard.
Désormais, pour chacune des routes créées, différentes méthodes sont autorisées. Les points de terminaison suivants sont disponibles :
Avec cette structure, vous êtes prêt à créer une API avec toute la complexité dont vous avez besoin. Il ne s'agit pas de la structure la plus évolutive car vous considérez plusieurs validations pour chaque itinéraire et la structure n'est pas rigide. Dans les sections suivantes, nous aborderons un sujet plus détaillé solution évolutive qui permet de créer facilement de la documentation au fur et à mesure que vous développez vos terminaux.
Un autre outil très utile et courant à utiliser dans le développement d'API est Facteur. Si vous ne l'avez jamais utilisé, nous vous recommandons de l'essayer et de l'explorer ! Il est très puissant et va augmentez votre développement vers la lune et au-delà. 🚀
Avant de présenter les autres points forts de Flask, parlons des plans. Un plan est un objet très similaire à un objet d'application Flask, mais au lieu d'en créer un nouveau, il permet l'extension de l'application en cours. Cela peut être utile si vous souhaitez créer plusieurs versions d'une API ou simplement diviser des services au sein d'une même application.
Nous utiliserons ce type de classe pour présenter différents scénarios d'utilisation d'une application Flask. Convertissons le code ci-dessus pour l'insérer dans un plan et le charger dans l'application principale.
Créez un nouveau dossier nommé plans pour commencer à insérer des modules de plan au fur et à mesure que nous progressons dans le billet de blog. À l'intérieur, créez un dossier nommé points de terminaison de base puis un fichier nommé __init__.py:
# blueprints/basic_endpoints/__init__.py
from flask import Blueprint, jsonify
basic_bp = Blueprint('basic_bp', __name__)
@basic_bp.route('/')
def hello():
return jsonify({'message': 'Hello from a Blueprint!'})
À présent, le main.py le fichier a juste besoin de charger le plan créé et de l'enregistrer dans l'objet de l'application :
# main.py
from flask import Flask
from blueprints.basic_endpoints import basic_bp
app = Flask(__name__)
app.register_blueprint(basic_bp)
if __name__ == '__main__':
app.run(debug=True)
Vous devriez maintenant avoir exactement les mêmes points de terminaison, mais en utilisant la structure fournie par Blueprints. Cela facilitera la gestion de votre application et sa mise à l'échelle au fur et à mesure de sa croissance.
Comme cela a déjà été indiqué, Flask est un framework très minimal; toutefois, il s'appuie sur un outil pratique : le moteur de modèles Jinja. Cela permet le rendu modèles HTML dynamiques. Bien que cela dépasse le cadre de cet article de blog, nous ne donnerons qu'un petit exemple pour illustrer le concept.
La première chose à faire est de créer le modèles et à l'intérieur de ce dossier, insérez le example.html dossier.
Notez qu'il existe deux variables utilisé dans le modèle à l'intérieur de {{}}. Il s'agit d'un format spécial permettant d'inclure du code Python dans le modèle, ce qui permet de rendre du contenu dynamique. Dans ce cas, nous avons le haut et le bas de la variable, qui seront convertis en texte à l'intérieur du <p> étiquette. Maintenant que le modèle est créé, chargez-le à l'aide de Flask. Créons un nouveau plan dans un autre fichier pour illustrer cet exemple :
<!-- templates/example.html -->
<!DOCTYPE >
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Jinja Template Example</title>
</head>
<body>
<p>{{ top }}</p>
<p>{{ bottom }}</p>
</body>
</html>
Notez que deux variables sont utilisées dans le modèle à l'intérieur {{}}. Il s'agit d'un format spécial permettant d'inclure du code Python dans le modèle, ce qui permet de rendre du contenu dynamique. Dans ce cas, nous avons le haut et le bas de la variable, qui seront convertis en texte à l'intérieur du <p> étiquette. Maintenant que le modèle est créé, chargez-le à l'aide de Flask. Créons un nouveau plan dans un autre fichier pour illustrer cet exemple :
# blueprints/jinja_demo/__init__.py
from flask import Blueprint, render_template, request
jinja_bp = Blueprint('jinja_bp', __name__)
@jinja_bp.route('/jinja_template')
def jinja_example():
top = request.args.get('top', 'Default Top Text')
bottom = request.args.get('bottom', 'Default Bottom Text')
return render_template('example.html', top=top, bottom=bottom)
N'oubliez pas de l'enregistrer plan dans le fichier main.py:
# main.py
from flask import Flask
from blueprints.jinja_demo import jinja_bp
app = Flask(__name__)
app.register_blueprint(jinja_bp)
if __name__ == '__main__':
app.run(debug=True)
Ici, nous pouvons voir la définition des variables supérieures et inférieures sur la base de paramètres de requête envoyé dans l'URL. Par exemple, si vous allez à http://localhost:5000/jinja_template ? haut=texte_haut&bas=bas_texte_bas vous obtiendrez le résultat suivant :
Pour les fous rires, ajoutons quelques CSS vers la page que nous venons de créer. Créez le statique dossier contenant le fichier example.css à l'intérieur.
/* static/example.css */
body {
font-family: Arial, sans-serif;
text-align: center;
background-color: #f9f9f9;
margin-top: 50px;
}
p {
font-size: 24px;
font-weight: bold;
color: #333;
}
Ensuite, ajoutez la référence correspondante au CSS fichier que nous venons de créer en ajoutant ceci balise d'en-tête du fichier HTML:
<!-- templates/example.html -->
<!DOCTYPE >
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Jinja Template Example</title>
<link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='example.css') }}">
</head>
<body>
<p>{{ top }}</p>
<p>{{ bottom }}</p>
</body>
</html>
Accédez à http://localhost:5000/jinja_template ? haut=Annuler%20The%20Rest%20API%20Creation&bottom=I%20Have%20to%20Watch%20This%20Bird et vous devriez voir quelque chose comme ça :
Voilà ! Vous avez votre cours intensif de jinja et un terminal générateur de mèmes ! Ne touchez pas au Business Cat ! Vous serez peut-être surpris de ce que vous allez découvrir...
.webp)
Maintenant que nous avons considéré que certaines fonctionnalités de base étaient points de terminaison créés avec Flask, créons une meilleure structure de projet pour nos terminaux.
Tout le monde sait que le gars a raison, mais cela peut être ennuyeux. Ne craignez rien ! Avec l'utilisation de l'extension Flask Flacon REST Plus nous pouvons faire générer de la documentation automatiquement et avec un meilleure structure si vous suivez leurs recommandations en matière de projets évolutifs.
Pour l'installer, tout comme flask, exécutez la commande suivante :
pip install flask-restplus
Si vous voulez avoir la même version de flask-restplus au moment de la rédaction, ajoutez simplement
flask-restplus==0.13.0
dans le fichier requirements.txt et réinstallez la configuration requise. Il existe quelques problèmes liés aux dépendances, par conséquent, vous devez également installer la version 0.16.1 à partir du Werkzeug package en exécutant :
pip install Werkzeug==0.16.1
Jetons maintenant un coup d'œil à structure du projet nous l'avons fait jusqu'à présent et celui que nous proposons pour ce schéma directeur que nous sommes en train de créer :
Pour le terminaux documentés, créons un dossier pour identifier l'entité sur laquelle nous travaillons. Cela facilitera la navigation dans le projet à mesure qu'il s'agrandit et devient de plus en plus complexe. Chacun des dossiers à l'intérieur du endpoints_documentés fonctionne comme des modules avec les fonctionnalités/points de terminaison liés à cette entité (dans ce cas, les utilisateurs et les chats).
Nous présenterons tous les points de terminaison déjà créés avec une nouvelle structure. Les endpoints n'auront aucune logique mais vous permettront de comprendre les étapes de leur création.
Cela dit, passons au code. Tout d'abord, nous devrions considérez le bonjour_monde point final avec la nouvelle structure:
# blueprints/documented_endpoints/hello_world.py
from flask_restplus import Namespace, Resource, fields
hello_ns = Namespace('hello_world', description='Hello World operations')
hello_model = hello_ns.model('HelloWorld', {
'message': fields.String(required=True, description='A hello world message')
})
@hello_ns.route('/')
class HelloWorld(Resource):
@hello_ns.response(200, 'Success', hello_model)
@hello_ns.response(500, 'Internal Server Error')
def get(self):
'''Returns a Hello World message'''
return {'message': 'Hello, World!'}, 200
Maintenant, décomposons-le. L'une des premières choses que vous remarquerez peut-être est l'utilisation du Classes d'espace de noms et de ressources. L'espace de noms est directement lié à une entité spécifique, ce qui signifie que tous les bonjour_monde les points de terminaison seront liés à l'espace de noms correspondant. Ce sera générer le bonjour_monde section de la documentation Swagger.
Pour créer des itinéraires dans cet espace de noms, différentes classes héritant de la classe Resource sont déclarées avec le décorateur de route de l'espace de noms correspondant. Dans la classe HelloWorld créée, nous déclarons les méthodes qu'elle envisage. Dans notre cas, uniquement OBTENIR est présenté, ce qui donne lieu à un Méthode GET disponible pour points de terminaison documentés/hello_world point final.
Le bonjour_monde des modèles connexes sont présentés et seront liés au paramètre d'évaluation correspondant. Cela génère la documentation pour la réponse du terminal et rassemble la réponse correspondante.
Les commentaires associés aux ressources créées et aux méthodes respectives seront générés descriptions sur la documentation finale. Les erreurs possibles que le point de terminaison peut renvoyer doivent également être spécifiées comme indiqué dans l'exemple et entraîneront également documentation supplémentaire sur les terminaux. L'extension flask-restplus prend en charge d'autres fonctionnalités, telles que les analyseurs et la gestion des erreurs. Veuillez vous référer à leur documentation si vous souhaitez tirer pleinement parti de ses capacités.
Présentons maintenant le code pour lier cet espace de noms que nous avons créé à un plan (blueprints/documented_endpoints/__init__.py) et ensuite lier le plan à l'application (main.py) :
# blueprints/documented_endpoints/__init__.py
from flask import Blueprint
from flask_restplus import Api
from .hello_world import hello_ns
blueprint = Blueprint('documented_api', __name__, url_prefix='/documented_api')
api = Api(blueprint, doc='/doc', title='Documented API', description='Auto-generated Swagger Docs with Flask-RESTPlus')
api.add_namespace(hello_ns)
Ici, un Objet d'API du module fask-restplus est créé et lié au API_documentée plan. Le lien entre le plan et le bonjour_monde l'espace de noms que nous avons créé est fait avec cet objet avec le ajouter un espace de noms méthode. Enfin, comme pour tous les plans précédents, il suffit de enregistrer le plan créé dans l'objet de l'application. Suivez le lien http://localhost:5000/documented_api/doc et vous obtiendrez cette page :
Présentons maintenant le code pour la documentation des entités API REST et page de modèle de jinja afin que tout le monde puisse facilement vérifier tous les points de terminaison sur lesquels nous avons travaillé. Pour ce faire, ajoutez les fichiers suivants :
Même si ces fichiers peuvent sembler effrayants, la logique est la même que celle présentée pour le point de terminaison Hello World. La principale différence réside dans utilisation de modèles pour générer de la documentation et valider le corps de la requête envoyé dans les méthodes POST et PUT. Analyseurs sont également utilisés pour la documentation des paramètres de requête et peuvent également être utilisés pour la validation. Cela est utile pour les scénarios dans lesquels les données ne sont pas envoyées via body, tels que les paramètres de requête ou FormData.
Enfin et surtout, n'oubliez pas d'ajouter les lignes suivantes pour créer espaces de noms liés au Blueprint nous sommes en train de créer.
Ci-dessous, vous pouvez vérifier l'apparence de la documentation pour les paramètres de requête et le corps de la requête :
Nous avons maintenant documentation de tous les points de terminaison et des points de terminaison respectifs (bien sûr !).
Malgré sa simplicité, Flask est un framework web Python extrêmement puissant. C'est beaucoup plus facile et direct que de créer des applications complètes côté serveur. De plus, cela peut vous faire gagner beaucoup de temps !
J'espère qu'à la fin de cet article, vous n'aurez aucun mal à créer une API REST à l'aide de Flask et à générer automatiquement une page de documentation Swagger. En outre, vous devez être familiarisé avec des fonctions spécifiques (telles que les objets Blueprint) et la configuration de modèles Jinja.
Une API Flask fait référence à un service Web RESTful créé à l'aide du framework Flask en Python. Il expose les points de terminaison avec lesquels les clients peuvent interagir via HTTP, renvoyant généralement des données au format JSON.
Oui, Flask peut être utilisé comme framework backend pour créer des API qui fournissent des données à des applications frontales ou à des services tiers.
Flask est un framework Web, tandis que REST est un style architectural pour la conception d'applications en réseau. Vous pouvez utiliser Flask pour implémenter des API REST.
Oui, Flask est un excellent choix pour créer des API en raison de sa simplicité, de sa flexibilité et de sa large gamme d'extensions prenant en charge la documentation, l'authentification et le déploiement.
Flask est couramment utilisé pour créer des API REST, des microservices, des tableaux de bord d'administration, des applications de prototypage et l'intégration à des modèles d'apprentissage automatique.
.webp)
Développeur associé travaillant principalement avec les technologies Backend. Un entrepreneur qui s'intéresse à la science des données. J'adore le sport, les livres audio, le café et les mèmes !
CEO @ Imaginary Cloud et co-auteur du livre Product Design Process. J'aime la nourriture, le vin et le Krav Maga (pas nécessairement dans cet ordre).
People who read this post, also found these interesting:
.webp)
.webp)
%20(2).webp)
