Flask ist ein einfaches Python-Web-Framework, das sich ideal für die Produktion von RESTful-APIs und Microservices eignet. Im Gegensatz zu schwereren Frameworks wie Django ist Flask minimal und eigensinnig, sodass Entwickler die volle Kontrolle über die Anwendungsstruktur haben. Diese Flexibilität macht es zu einer großartigen Wahl für die Entwicklung benutzerdefinierter, skalierbarer Web-APIs, die auf spezifische Projektanforderungen zugeschnitten sind.
Aalso, Flasche Python ist ein Mikroframework, mit dem Sie eine Webanwendung in sehr wenigen Minuten und schnell ohne Einrichtung ausführen können. Je simpel dieses Framework und die starke Kontrolle auch, die Sie von Ihrer Anwendung erwarten, hat es zu einem der am häufigsten verwendeten gemacht Frameworks für die Webentwicklung.
Python ist eine sehr beliebte und mächtige Sprache mit einer großen Community, die es schon lange gibt. Viele großartige Unternehmen wie Google verwenden es für ihre Projekte und die Anzahl der Personen, für die es verwendet wird Web-Entwicklung nimmt immer noch zu.
Wir zeigen Ihnen, dass es einfach, flexibel und modular ist und zu einer angenehmen Entwicklungserfahrung führt.
Wir erwarten, dass der Benutzer über einige Grundkenntnisse verfügt Python um alle vorgestellten Schritte zu verstehen. Jede Person sollte in der Situation sein, die Anwendung zum Laufen bringen, nachdem sie dieses Tutorial ausgeführt hat.
Ein Framework ist eine Bibliothek, die von Entwicklern verwendet wird, um zuverlässige und skalierbare Webanwendungen zu erstellen und zu verwalten. Es gibt mehrere Condizioni rahmeno verfügbar für Python, wie Tornado, Pyramid und Natural Django (was oft mit Flask verglichen wird).
Flask (🌶️) ist ein Python-Mikroframework für Web-Entwicklung. Obgleich Flask mit kleinem Kern gebaut wurde und als sehr leichtes Web Server Gateway Interface (WSGI) gilt, zeichnet es sich durch seine einfach zu erweiterende Philosophie aus. Es wurde für die Skalierung auf komplexen Anwendungen entwickelt und unterstützt einen einfachen und schnellen Start.
Ein weiterer großer Vorteil von Flask ist seine Funtionalität. Wenngleich es Vorschläge anbietet, benötigt Flask nicht zwingend Projektlayouts oder andere Abhängigkeiten. Dadurch können Entwickler die Bibliotheken und Tools verwenden, die sie wollen, und bietet zusätzlich verschiedene Verlängerungen verfügbar, die von der Community zur Verfügung gestellt werden.
API ist eine Abkürzung für Application Programming Interface, was bedeutet, dass es im Grunde genommen wie sie mit einer Anwendung kommunizieren. Eine REST-API (Representational State Transfer) ermöglicht die Kommunikation zwischen Systemen unter Verwendung von HTTP-Standardmethoden und entspricht einer architektonischer Stil das auf standlose Kommunikation abzielt und Client- und Serverservices voneinander trennt. Es tauscht die Regeldaten im JSON-Format ein und arbeitet mit Endpunkten, den Aktionen wie Create (POST), Read (GET), Update (PUT oder PATCH) und Delete (DELETE). REST-APIs werden häufig aufgrund ihrer Einfachheit, Skalierbarkeit und Kompatibilität mit einer Vielzahl von Clients und Plattformen verwendet.
Das REST-API In dieser Praxis entsteht eine gefälschte Umsetzung von CRUD-Aktionen über eine Entität. Eine API mit CRUD ermöglicht das Erstellen, Lesen, Aktualisieren und Löschen von Operationen über die Elemente der Anwendung.
In diesem Artikel werden die ersten Schritte zum Erstellen einer REST-API mit Flask (🌶️) beschrieben.
Unten sehen Sie die Endpunkte, die Sie am Ende des Tutorials haben. Die vorab bereitgestellte Dokumentation wird ebenfalls von der Anwendung generiert, sie wird erstellt!
Sie müssen Python auf dem aktuellen Computer installiert haben. Der vorgestellte Code berücksichtigt Python3. Wenn Sie möchten, dass Python2 diesen Prozess auf einem Windows-Computer verwendet oder ausführt, folgen Sie bitte den Anweisungen in Installationsanleitung für Flaschen.
Fangen wir an mit ein Verzeichnis erstellen um das Projekt zu speichern. Verschieben Sie in das Verzeichnis, in dem Sie Ihr Projekt haben wollen, die folgenden Befehle auf der Shell:
Wir haben das geschaffen flask_demo Verzeichnis und habe es verschoben. Bevor wir mit der Installation von Abhängigkeiten beginnen, erstellen wir eine virtuelle Umgebung wenn Sie den folgenden Befehl ausführen:
Dadurch wird in Ihrem Projekt ein Ordner mit den Namen erstellt .venv. Danach müssen wir die entsprechende Umgebung aktivieren, indem wir Folgendes ausführen:
Das heißt, wir erwägen jetzt virtuelle Venv-Umgebung wenn Sie irgendeinen Python-Code ausführen. Es kann wichtig sein, die Umgebung anzugeben, die Sie bei der Ausführung in Ihrer IDE ziehen.
Stellen Sie sicher, dass Sie die Umgebung haben aktiv bevor sie die nächsten Schritte ausführen. Sie können überprüfen, ob Sie sich in der Umgebung befinden, indem Sie die Konsole auf der linken Seite ansehen. Wenn der Name der virtuellen Umgebung in den Klammern steht, können Sie loslegen.
Wenn du willst deaktiviere die Umgebung, führe einfach den folgenden Befehl aus:
Bevor Sie mit der Entwicklung einer Flask-API beginnen, stellen Sie sicher, dass Python installiert ist. Es wird empfohlen, eine virtuelle Umgebung zu verwenden, um Abhängigkeiten zu verwalten und Ihr Projekt zu isolieren.
Install the flask package with Pip (Python-Paketinstallationsprogramm):
pip install Flask==2.3.3
Zum Zeitpunkt des Schreibens ist die stabile Flask-Version 2.3.3. If you want, that the project specifications and be updated to this version, you can use a requirements.txt File, anstatt Flask manuell zu installieren. Sie können die folgende Datei in das Stammverzeichnis kopieren:
Flask==2.3.3
Danach müssen Sie nur noch den folgenden Befehl ausführen:
pip install -r requirements.txt
Now we are ready, with the development our REST api.
Das erster Endpunkt 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)
In diesem Beispiel wird ein einfacher Endpunkt eingerichtet, der eine JSON-Antwort zurückgibt. Der app.run () The function starts an development server, der standardmäßig auf Port 5000 läuft.
War?! Ist das so einfach? Ja, das ist es! The code is finished, to have a application with an implementation end point. Jetzt müssen wir nur noch das definieren Flask-Umgebungsvariablen and see your bewerbung?. Achte darauf, dass sie in dem Ordner mit ihnen sein müssen main.py File, to perform this commands.
Greifen Sie auf den Link zu http://localhost:5000/basic_api/hello_world um die klassische Botschaft zu sehen, die wir alle lieben.
When we now created our first end point, we back to the major weck this application blog posts: have REST-API with the central CRUD structure. Lass uns eine API erstellen, die CRUD-Operationen für eine Liste von Elementen unterstützt. This is a frequent application fall in the web development and backend services.
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)
This simple REST-API in Flask allows us customers to manage a list of elements with standard HTTP methods.
Now are available for each of the created routes different methods. Die folgenden Endpunkte sind verfügbar:
With this structure are ready create a api mit der ganzen Komplexität, die Sie benötigen. This is not the best skalable structure, as you take several validierungen for each route and the structure is not starr. In den nächsten Abschnitten werden wir mehr behandeln skalierbare Lösung das ermöglicht eine einfache Dokumentationserstellung bei der Entwicklung Ihrer Endgeräte.
Ein weiteres Tool, das bei der Entwicklung von APIs sehr nützlich und häufig verwendet wird, ist Postbote. When they have not used, we recommend them, it to a probiere and to review! Es ist sehr mächtig und wird steigere deine Entwicklung zum Mond und darüber hinaus. 🚀
Bevor wir andere Stärken von Flask vorstellen, wollen wir über Blueprints sprechen. A Blueprint is an object, that a flask application object is very similar, but but not create an new, allows the extension of the current application. This can be nützlich, wenn Sie mehrere Versionen einer API erstellen oder Dienste einfach innerhalb derselben Anwendung teilen möchten.
We are use this class type to presented different application scenarios a flask application. Lassen Sie uns den obigen Code so konvertieren, dass er in einen Blueprint eingefügt und in die Hauptanwendung geladen wird.
Create a new folder with the names Blauhausen to start with the insert of Blueprint modules, during we come to blog post. Create a order with the names Basische Endpunkte and then a file with the names __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!'})
Jetzt stirb main.py The file must only load the created blueprint and in registrare for the application object:
# 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)
Jetzt sollten Sie genau die gleichen Endpunkte haben, aber die von Blueprints bereitgestellte Struktur verwenden. This can be manage your application easier and scale, if they increase.
Wie bereits erwähnt, Flask ist ein sehr minimales Framework; es stützt sich jedoch auf ein praktisches Tool: die Jinja Template Engine. This allows the rendering dynamische HTML-Vorlagen. Wenngleich dieser Rahmen diese Blogbeiträge enthält, wollen wir nur ein kurzes Beispiel sein, um das Konzept zu verdeutlichen.
Das erste, was Sie tun müssen, ist zu erstellen Vorlagen Bestellen und hinzufügen Sie in diesen Ordner example.html Datei.
Achte darauf, dass es zwei Variablen wird in der Vorlage in {{}} verwendet. Dies ist ein spezielles Format, um Python-Code in die Vorlage aufzunehmen, sodass dynamische Inhalte erstellt werden können. In diesem Fall haben wir den oberen und unteren Teil der Variablen, die innerhalb des Textes konvertiert werden von <p> Etikett. Nachdem die Vorlage erstellt wurde, laden wir sie mit der Flasche. Lass uns einen neuen Blueprint in einer anderen Datei erstellen, um dieses Beispiel zu demonstrieren:
<!-- 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>
Achte darauf, dass in der Vorlage zwei Variablen verwendet werden {{}}. Dies ist ein bestimmtes Format, mit dem der Python-Code in der Vorlage dynamische Inhalte gerendert werden können. In diesem Fall haben wir den oberen und unteren Teil der Variablen, die innerhalb von Text konvertiert werden von <p> Etikett. Nachdem die Vorlage erstellt wurde, laden wir sie mit der Flasche. Lass uns einen neuen Blueprint in einer anderen Datei erstellen, um dieses Beispiel zu demonstrieren:
# 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)
Vergesst nicht, dies zu registrieren Bauplan in der Datei 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)
Hier finden Sie die Definition der oberen und unteren Variablen basierend auf Parameter abfragen die URL ist eingesendet. Zum Beispiel, wenn du zu gehst http://localhost:5000/jinja_template? oben=oberer_text&unten=unten_text Sie erhalten das folgende Ergebnis:
Für die Küche fügen wir noch etwas hinzu CSS zu der Seite, die wir jetzt erstellt haben. Erstelle dich statisch Bestellung mit der Datei example.css innen.
/* 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;
}
Fügen Sie danach den entsprechenden Verweis zum CSS Datei, die wir erstellt haben, durch die wir diese hinzugefügt haben Head-Tag for html file:
<!-- 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>
Gehe zu http://localhost:5000/jinja_template? top=Abbrechen%20The%20Rest%20API%20Creation&unten=I%20Muss%20Dien%20zu_Watch%20Dieses%20Vogel und du solltest so etwas sehen:
Papa! Du hast deine Jinja-Crashkurs und ein Meme-Generator-Endpunkt! Fass die Geschäftskatze nicht an! Sie werden überrascht sein, was Sie finden werden...
.webp)
Nun, da wir einige grundlegende Funktionen übertragen haben, sind die wichtigsten Endpunkte, die mit der Flasche erstellt wurden, Sie lassen uns eine bessere Projektstruktur für unsere Endgeräte erstellen.
Jeder weiß, dass der Typ Recht hat, aber es kann ein langweiliger Prozess sein. Fürchte dich nicht! Bei der Verwendung der Flaschenverlängerung Flasche RestPlus wir können Dokumentation erstellen automatisch und mit einem bessere Struktur wenn sie ihren Empfehlungen zu skalierbaren Projekten folgen.
Um Flask zu installieren, führen Sie den folgenden Befehl aus:
pip install flask-restplus
Wenn sie zum Zeitpunkt des Schreibens dieselbe Flask-Restplus-Version haben, wurde es einfach hinzugefügt
flask-restplus==0.13.0
in die Datei requirements.txt und installiere die Anforderungen. Es gibt einige Probleme im Zusammenhang mit Abhängigkeiten, daher müssen Sie auch die Version 0.16.1 von der Tool Paket, indem du folgendes ausführst:
pip install Werkzeug==0.16.1
Schauen wir uns jetzt die an Struktur des Projekts das haben wir bisher gemacht und den, den wir für diesen Entwurf vorschlagen, erstellen wir:
Für die dokumentierte Endpunkte, laß uns einen Ordner erstellen, um die Entität zu identifizieren, an der wir gerade arbeiten. Dies erleichterte die Navigation durch das Projekt, da es größer und komplexer war. Jeder der Ordner ist in der dokumentierte Endpunkte arbeitet als Modul mit den Funktionalitäten/Endpunkten, die in dieser Entität enthalten sind (in diesem Fall Benutzer und Katze).
Wir präsentieren alle bereits erstellten Endpoints mit einer neuen Struktur. Die Endpunkte haben keine Logik, aber sie ermöglichen es ihnen, die Schritte zu kennen, die für ihre Erstellung erforderlich sind.
Nachdem das gesagt ist, gehen wir zum Code. Zuerst sollten wir betrachtete die hallo_world Endpunkt mit der neuen Struktur:
# 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
Lass uns das jetzt aufschlüsseln. Eines der ersten Dinge, die Ihnen vielleicht auffallen, ist die Verwendung von Namespace- und Ressourcenklassen. Der Namespace ist direkt mit einer bestimmten Entität verbunden, was bedeutet, dass alle hallo_world Endpunkte sind mit dem entsprechenden Namespace verknüpft. Das wird generischer Tod hallo_world Swagger-Dokumentation.
Um Routen in diesem Namespace zu erstellen, werden verschiedene Klassen, die von der Resource Class stammen, zusammen mit dem jeweiligen Namespace-Routendekorator deklariert. In the created helloworld class deklarieren wir die Methoden, die sie in Anspruch nehmen. Nur in unserem Fall BEKOMMEN wird präsentiert, was zu einem GET-Methode verfügbar für die dokumentierte Endpunkte/Hallo Welt Endpunkt.
Das hallo_world verwandte Modelle werden vorgestellt und mit dem jeweiligen Endpunkt verknüpft. Dadurch wird die Dokumentation für die Endpunktreaktion und die entsprechende Antwort generiert.
Die erstellten Ressourcen und die jeweiligen Methoden sind generierte Kommentare Beschreibung zur endgültigen Dokumentation. Der mögliche Fehler, dass der Endpunkt zurückgesetzt werden kann, sollte ebenfalls im Beispiel angegeben werden und zu weitere Dokumentation zu Endpunkten. Die Erweiterung flask-restplus unterstützt mehr Funktionen, wie Parser und Fehlerbehandlung. Bitte beziehen Sie sich auf ihre Dokumentation wenn sie seine Funktionen voll ausschöpfen möchten.
Jetzt präsentieren wir den Code für verlinke diesen Namespace, den wir erstellt haben, mit einem Blueprint (blueprints/documented_endpoints/__init__.py) und die Blaupause mit der Anwendung (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)
Hier, ein API-Objekt aus dem Modul fask-restplus wird erstellt und mit ihnen verknüpft Documentated API Blaupause. Die Verbindung zwischen dem Bauplan und dem hallo_world Der von uns entworfene Namespace ist mit diesem Objekt fertig Namespace hinzufügen Methode. Schließlich müssen wir, genau wie bei allen vorherigen Bauplänen, nur hat den erstellten Blueprint für das App-Objekt registriert. Folgt dem Link http://localhost:5000/documented_api/doc und du bekommst diese Seite:
Lassen Sie uns nun den Code für die Dokumentation der Entitäten vorstellen REST-API und Jinja-Vorlagenseite so dass jede Person problemlos alle Endpunkte überprüfen kann, an denen wir gearbeitet haben. Dazu werden die folgenden Dateien hinzugefügt:
Auch wenn diese Dateien gruselig aussehen mögen, ist die Logik dieselbe wie für den Hello World-Endpunkt. Der Hauptunterschied ist der Verwendung von Modellen um Dokumentation zu generieren und die Methoden in POST und PUT auf gültig zu validieren. Parser werden auch für die Dokumentation der Anforderungsparameter verwendet und können zur Validierung verwendet werden. Dies ist nützlich für Szenarien, in denen Daten nicht per Textkörper gesendet werden, wie z. B. Anforderungsparameter oder FormData.
Zu guter Letzt vergessen Sie nicht, die folgenden Zeilen hinzuzufügen, um das zu erstellen Namespaces, die mit dem Blueprint verknüpft sind wir kreieren.
Im Folgenden kann ich das Bild der Dokumentation auf Bedarfsparameter und einen Anforderungstext überprüfen:
Jetzt haben wir die Dokumentation aller Endpunkte und der jeweiligen Endpunkte (natürlich!!).
Trotz seiner Einfachheit ist Flask ein extrem leistungsfähiges Python-Webframework. Es ist viel einfacher und unkomplizierter als die Erstellung kompletter serverseitiger Anwendungen. Außerdem kann es Ihnen so viel Zeit sparen!
Hoffentlich haben Sie am Ende dieses Artikels keine Probleme, eine REST-API mit Flask zu erstellen und automatisch eine Swagger-Dokumentationsseite zu generieren. Darüber hinaus sollten Sie vertraut sein mit bestimmten Funktionen (wie Blueprint-Objekten) und der Einrichtung von Jinja-Vorlagen.
Eine Flask-API bezieht sich auf einen RESTful-Webdienst, der mit dem Flask-Framework in Python erstellt wurde. Es bietet Endpunkte, mit denen Clients über HTTP kommunizieren und Daten normalerweise im JSON-Format ausgeben können.
Ja, Flask kann als Backend-Framework verwendet werden, um APIs zu erstellen, Daten für Frontend-Anwendungen oder Dienste von Drittanbietern bereitzustellen.
Flask ist ein Web-Framework, während REST ein Architekturstil für das Design von Netzwerkanwendungen ist. Sie können Flask verwenden, um REST-APIs zu implementieren.
Ja, Flask ist aufgrund seiner Einfachheit, Flexibilität und einer Reihe von Erweiterungen, Support-Dokumentation, Authentifizierung und Implementierung eine gute Wahl für die Erstellung von APIs.
Flask wird häufig zur Erstellung von REST-APIs, Microservices, Admin-Dashboards, Prototyping-Anwendungen und zur Integration in Modelle für maschinelles Lernen verwendet.
.webp)
Assoziierter Entwickler, der hauptsächlich mit Backend-Technologien arbeitet. Ein Unternehmer mit Interesse an Data Science. Liebe zu Sport, Hörbüchern, Kaffee und Memes!
CEO von Imaginary Cloud und Mitautor des Buches Product Design Process. Ich mag Essen, Wein und Krav Maga (nicht unbedingt in dieser Reihenfolge).
People who read this post, also found these interesting:
.webp)
.webp)
%20(2).webp)
