Cet article concerne la création d'une API RESTful à l'aide de Flask, un framework Python léger.
De nombreux articles ont déjà été écrits sur les API RESTful utilisant Flask, mais Flask a également considérablement évolué récemment afin de pouvoir être décrit d'une manière moderne un peu différente de la littérature d'il y a deux ou trois ans. Il est devenu.
Même dans le test technique du stage, le nombre de cas où Python est adopté comme langage désigné augmente et je n'avais pas assez de compétences en codage pour appliquer couramment Python, j'ai donc étudié en utilisant Flask, ce qui m'intéressait depuis longtemps. J'ai décidé de le voir.
Il a également été constaté que la mode récente de Flask semble combiner une bibliothèque appelée Flask-SQL Alchemy, qui a été créée en enveloppant un ORM Python appelé SQL Alchemy, pour décrire un modèle avec Active Record, et en fait combiner cela pour créer une API RESTful. Je vais le créer.
Avant d'entrer dans le sujet principal, je vais également vous expliquer pourquoi j'ai choisi le framework appelé Flask.
Je crois que le plus gros obstacle à l'apprentissage d'un cadre est le coût de l'apprentissage. En particulier, l'API Web possède de nombreuses fonctions qui ne sont pas utilisées parmi les fonctions requises pour les applications Web telles que la gestion de session et la génération de vues.
Par conséquent, il est très efficace de ne pas dépenser de frais d'apprentissage inutiles, et personnellement, j'aime Slim de PHP en tant que framework léger. En Python, le framework Flask est célèbre pour son framework fin, j'ai donc choisi Flask cette fois.
Docker est utilisé à chaque fois pour créer l'environnement.
Il y a deux conteneurs utilisés cette fois, un conteneur d'exécution Python et un conteneur MySQL. En ce qui concerne MySQL, aucun package spécial n'est requis, utilisez donc le conteneur MySQL tel quel. Pour le conteneur d'exécution Python, Flask, SQLAlchemy et mysqlclient doivent être installés avec pip.
Veuillez vous référer au Référentiel Complété car seules les parties importantes sont décrites.
.
├── Build
│ └── app
│ ├── Dockerfile
│ └── requirements.txt
├── DB
├── LICENSE
├── README.md
├── docker-compose.sample
├── docker-compose.yml
└── share
├── app.py
├── controllers
│ ├── __init__.py
│ ├── top_controller.py
│ └── user_controller.py
├── db.py
└── models
├── __init__.py
└── user.py
Dockerfile Dockerfile est décrit comme suit Le chemin est Build / app / Dockerfile Déplacez ce Dockerfile dans le répertoire / web, copiez requirements.txt dans le conteneur et pip install.
#Spécification de l'image de base
FROM python:3.6.5
#Stocker le répertoire dans lequel la source est placée en tant que variable
ARG project_dir=/web/
#Copiez les fichiers requis du local vers le conteneur
ADD requirements.txt $project_dir
# requirements.Installez le package répertorié dans txt
WORKDIR $project_dir
RUN pip install -r requirements.txt
setUp.sh
docker-compose build
docker-compose up -d
Une fois la construction de l'environnement terminée, mettez-la en œuvre. La mise en œuvre se déroule selon la procédure suivante.
Pour développer une application avec Flask, exécutez la méthode d'exécution de l'objet d'application et démarrez le serveur intégré. Flask peut être démarré au minimum en écrivant les 7 lignes suivantes.
app.py
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello, World!'
if __name__ == '__main__':
app.run(host="0.0.0.0", port=80, debug=True)
Vous pouvez décrire les paramètres de l'application en ajoutant des valeurs au tableau app.config. Cette fois, définissez la base de données et le code de caractère. Les paramètres de la base de données sont dans l'ordre du nom d'utilisateur, du mot de passe, du nom d'hôte et du nom de la base de données.
app.py
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://%s:%s@%s/%s?charset=utf8' % (
"root",
"BzHSGDBv2fya",
"db",
"database",
)
app.config['JSON_AS_ASCII'] = False
Flask-Puisque SQLAlchemy est utilisé, créez une instance avec db.py. Créez une instance de base de données en écrivant les deux lignes suivantes. Après cela, enregistrez l'instance d'application dans db comme db.init_app (app) dans app.py.
db.py
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
Le routage par défaut de Flask est implémenté à l'aide d'un décorateur appelé @ app.route ('/'), mais ce routage limite les fonctions qui peuvent être appelées après le décorateur aux fonctions globales. Alors, utilisez app.add_url_rule. Les deux programmes suivants fonctionnent de la même manière
app.py
@app.route('/')
def get():
return 'Hello, World!'
app.py
class TopController(MethodView):
def get(self):
return 'Hello, World!'
app.add_url_rule('/',view_func=TopController.as_view('top_controller'))
Le fichier app.py final ressemble à ceci:
app.py
from flask import Flask
from db import db
from controllers.top_controller import TopController
from controllers.user_controller import UserController
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://%s:%s@%s/%s?charset=utf8' % (
"root",
"BzHSGDBv2fya",
"db",
"database",
)
app.config['JSON_AS_ASCII'] = False
app.secret_key = 'secret'
app.add_url_rule('/', view_func=TopController.as_view('top_controller'))
app.add_url_rule('/<int:id>', view_func=UserController.as_view('user_controller'))
if __name__ == '__main__':
db.init_app(app)
app.run(host="0.0.0.0", port=80, debug=True)
Étant donné que le modèle utilise également Flask-SQL Alchemy, créez-le à l'aide de l'instance db. La différence avec SQLAlchemy est que vous devez le préfixer avec db, tel que db.Column ou db.Model. Créez également une méthode très importante, to_dict (). to_dict () est une méthode pour passer à un type de dictionnaire car l'objet modèle ne peut pas être géré lors de la création de json en tant que réponse API après l'acquisition du modèle.
Afficher le modèle utilisateur créé,
user.py
from db import db
from datetime import datetime
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now, onupdate=datetime.now)
def to_dict(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'created_at': self.created_at.strftime('%Y-%m-%d %H:%M'),
'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M'),
}
def __repr__(self):
return '<User %r>' % self.username
Enfin, créez un contrôleur. J'ai le plus pensé à créer le contrôleur, mais je n'ai pas trouvé de bonne méthode, donc pour le moment, c'était dans sa forme actuelle. Je pense qu'il existe une meilleure méthode de conception, alors j'aimerais la considérer à l'avenir.
TopController est le suivant. Le fait est qu'il décrit le traitement de la demande pour l'URL de base. Puisque userId n'est pas spécifié, get renvoie toutes les données telles quelles. Dans la publication, créez un nouvel utilisateur. Utilisez jsonify pour changer le type de dictionnaire en json. De plus, chaque fois que vous accédez pour la première fois, exécutez db.drop_all () et db.create_all () pour créer une table.
top_controller.py
from flask import request
from models.user import User
from flask.json import jsonify
from flask.views import MethodView
from db import db
class TopController(MethodView):
def get(self):
"""
Obtenir toutes les données du tableau
:return: json
"""
# db.drop_all()
# db.create_all()
return jsonify({"data": [User.to_dict(user) for user in User.query.all()]})
def post(self):
"""
Créer un nouvel utilisateur
:return: json
"""
username = request.form['username']
email = request.form['email']
user = User(username=username, email=email)
db.session.add(user)
db.session.commit()
return jsonify({'response': 'ok'})
référence officielle du flacon référence officielle flask-sqlalchemy Flask – SQLAlchemy yoshiya0503 / Hermetica 04 View et API RESTful Flacon facile à utiliser
Recommended Posts