Wenn Sie diesen Artikel lesen, sind Sie wahrscheinlich bereits mit den Möglichkeiten vertraut, die sich durch die Nutzung von APIs (Application Programming Interface) ergeben.
Indem Sie Ihrer Anwendung eine der vielen offenen APIs hinzufügen, können Sie die Funktionalität dieser Anwendung erweitern oder sie mit den benötigten Daten ergänzen. Aber was, wenn Sie eine einzigartige Funktion entwickelt haben, die Sie mit der Community teilen möchten?
Die Antwort ist einfach: Sie müssen .
Obwohl dies zunächst wie eine anspruchsvolle Aufgabe erscheint, ist es in der Tat ganz einfach. Wir zeigen Ihnen, wie Sie dies mit Python umsetzen können.
Was Sie für den Anfang benötigen
Für die API-Entwicklung sind folgende Dinge notwendig:
- Python 3;
- – ein einfaches und benutzerfreundliches Framework zur Erstellung von Webanwendungen;
- – eine Erweiterung für Flask, die es ermöglicht, schnell und mit minimalem Aufwand ein REST API zu entwickeln.
Die Installation erfolgt mit dem Befehl:
pip install flask-restfulWir empfehlen einen kostenlosen Intensivkurs in Programmierung für Anfänger:
– 26. bis 28. August. Ein kostenloser Intensivkurs, der es ermöglicht, zu verstehen, wie Assistenz-Bots funktionieren, einschließlich der Besonderheiten der Arbeit mit der Telegram API und weiteren Details. Die drei besten Teilnehmer erhalten von Skillbox 30.000 Rubel..
Bevor wir beginnen
Werden wir ein RESTful API mit grundlegender .
Um die Aufgabe vollständig zu verstehen, lassen Sie uns mit zwei der oben erwähnten Begriffe vertraut machen.
Was ist REST?
REST API (Representational State Transfer) ist eine API, die HTTP-Anfragen zum Austausch von Daten verwendet.
REST APIs müssen bestimmten Kriterien entsprechen:
- Client-Server-Architektur: Der Client interagiert mit der Benutzeroberfläche, während der Server mit dem Backend und dem Datenspeicher interagiert. Client und Server sind unabhängig, jeder von beiden kann unabhängig vom anderen ersetzt werden.
- Zustandslos – es werden keine Clientdaten auf dem Server gespeichert. Der Sitzungsstatus wird auf der Client-Seite verwaltet.
- Cachebarkeit – Clients können die Serverantworten zwischenspeichern, um die Gesamtleistung zu verbessern.
Was ist CRUD?
CRUD ist ein Programmierkonzept, das vier grundlegende Aktionen beschreibt (create, read, update und delete).
In einer REST API sind die Anfragearten und die Anfragemethoden für Aktionen wie post, get, put, delete verantwortlich.
Jetzt, da wir die grundlegenden Begriffe geklärt haben, können wir mit der Erstellung der API beginnen.
Entwicklung
Lassen Sie uns ein Repository von Zitaten über künstliche Intelligenz erstellen. KI ist eine der am schnellsten wachsenden Technologien heute, und Python ist ein beliebtes Werkzeug zur Arbeit mit KI.
Mit dieser API kann ein Python-Entwickler schnell Informationen über KI abrufen und sich von neuen Fortschritten inspirieren lassen. Wenn der Entwickler wertvolle Gedanken zu diesem Thema hat, kann er sie im Repository hinzufügen.
Lassen Sie uns mit dem Import der erforderlichen Module und der Einrichtung von Flask beginnen:
from flask import Flask
from flask_restful import Api, Resource, reqparse
import random
app = Flask(__name__)
api = Api(app)In diesem Snippet sind Flask, Api und Resource die Klassen, die wir benötigen.
Reqparse ist eine Schnittstelle zum Parsen von Anfragen in Flask-RESTful… Auch das Modul random wird benötigt, um ein zufälliges Zitat anzuzeigen.
Jetzt erstellen wir ein Repository von Zitaten über KI.
Jeder Eintrag im Repo wird folgendes enthalten:
- eine digitale ID;
- den Namen des Autors des Zitats;
- das Zitat.
Da dies nur ein Beispiel zum Lernen ist, werden wir alle Einträge in einer Python-Liste speichern. In einer echten Anwendung würden wir stattdessen wahrscheinlich eine Datenbank verwenden.
ai_quotes = [
{
"id": 0,
"author": "Kevin Kelly",
"quote": "Die Geschäftspläne der nächsten 10.000 Startups sind leicht vorherzusagen: " +
"Nehmt X und fügt KI hinzu."
},
{
"id": 1,
"author": "Stephen Hawking",
"quote": "Die Entwicklung einer vollen künstlichen Intelligenz könnte " +
"das Ende der menschlichen Rasse bedeuten… " +
"Sie würde eigenständig abheben und " +
"sich in einem immer schneller werdenden Tempo neu gestalten. " +
"Menschen, die durch langsame biologische Evolution begrenzt sind, " +
"könnten nicht konkurrieren und würden ersetzt werden."
},
{
"id": 2,
"author": "Claude Shannon",
"quote": "Ich stelle mir eine Zeit vor, in der wir für Roboter sind, was " +
"Hunde für Menschen sind, " +
"und ich drücke den Maschinen die Daumen."
},
{
"id": 3,
"author": "Elon Musk",
"quote": "Das Tempo des Fortschritts in der künstlichen Intelligenz " +
"(ich spreche nicht von engmaschiger KI) " +
"ist unglaublich schnell. Es sei denn, man hat direkten " +
"Kontakt zu Gruppen wie Deepmind, " +
"hat man keine Vorstellung davon, wie schnell — sie wächst " +
"in einem nahezu exponentiellen Tempo. " +
"Das Risiko, dass etwas ernsthaft Gefährliches " +
"passiert, liegt im Zeitraum von fünf Jahren." +
"Maximal 10 Jahre."
},
{
"id": 4,
"author": "Geoffrey Hinton",
"quote": "Ich war immer überzeugt, dass der einzige Weg, " +
"künstliche Intelligenz zum Laufen zu bringen, " +
"darauf basiert, die Berechnungen auf eine Weise zu machen, die dem menschlichen Gehirn ähnlich ist. " +
"Das ist das Ziel, dem ich nachgehe. Wir machen Fortschritte, " +
"obwohl wir noch viel über " +
"die tatsächliche Funktionsweise des Gehirns lernen müssen."
},
{
"id": 5,
"author": "Pedro Domingos",
"quote": "Die Leute machen sich Sorgen, dass Computer " +
"zu schlau werden und die Welt übernehmen, " +
"aber das eigentliche Problem ist, dass sie zu dumm sind " +
"und die Welt bereits übernommen haben."
},
{
"id": 6,
"author": "Alan Turing",
"quote": "Es scheint wahrscheinlich, dass es, sobald die Denkweise der Maschinen " +
"einsetzte, nicht lange dauern würde, " +
"um unsere schwachen Fähigkeiten zu übertreffen… " +
"Sie wären in der Lage, " +
"miteinander zu sprechen, um ihren Verstand zu schärfen. " +
"In gewisser Weise sollten wir daher " +
"erwarten, dass die Maschinen die Kontrolle übernehmen."
},
{
"id": 7,
"author": "Ray Kurzweil",
"quote": "Künstliche Intelligenz wird etwa 2029 " +
"menschliche Ebenen erreichen. " +
"Wenn wir das weiter verfolgen, sagen wir bis 2045, " +
"werden wir die Intelligenz, " +
"die menschliche biologische Maschinenintelligenz " +
"unserer Zivilisation um das Billionenfache vervielfacht haben."
},
{
"id": 8,
"author": "Sebastian Thrun",
"quote": "Niemand formuliert es so, aber ich denke, " +
"dass künstliche Intelligenz " +
"fast eine Disziplin der Geisteswissenschaften ist. Es ist wirklich der Versuch, " +
"menschliche Intelligenz und menschliche Kognition zu verstehen."
},
{
"id": 9,
"author": "Andrew Ng",
"quote": "Wir ziehen diese Analogie, dass KI die neue Elektrizität ist." +
"Elektrizität hat Industrien transformiert: Landwirtschaft, " +
"Transport, Kommunikation, Fertigung."
}
]Jetzt müssen wir eine Ressourcenklasse Quote erstellen, die die Operationen der Endpunkte unserer API definiert. Innerhalb der Klasse müssen vier Methoden deklariert werden: get, post, put, delete.
Lassen Sie uns mit der GET-Methode beginnen.
Dies ermöglicht es, ein bestimmtes Zitat durch Angabe seiner ID oder ein zufälliges Zitat zu erhalten, wenn keine ID angegeben ist.
class Quote(Resource):
def get(self, id=0):
if id == 0:
return random.choice(ai_quotes), 200
for quote in ai_quotes:
if(quote["id"] == id):
return quote, 200
return "Zitat nicht gefunden", 404Die GET-Methode gibt ein zufälliges Zitat zurück, wenn ID den Standardwert enthält, d.h. bei Aufruf der Methode wurde keine ID angegeben.
Wenn eine ID angegeben ist, sucht die Methode unter den Zitaten und findet das, das die angegebene ID enthält. Wenn nichts gefunden wird, wird die Nachricht “Zitat nicht gefunden, 404” ausgegeben.
Denken Sie daran: Die Methode gibt den HTTP-Status 200 bei erfolgreichem Antrag und 404 zurück, wenn der Eintrag nicht gefunden wurde.
Jetzt erstellen wir die POST-Methode zum Hinzufügen eines neuen Zitats in das Repository.
Es wird die ID jedes neuen Zitats bei der Eingabe erhalten. Darüber hinaus wird POST reqparse verwenden, um die Parameter zu parsen, die im Anfragekörper (Autor und Text des Zitats) übermittelt werden.
def post(self, id):
parser = reqparse.RequestParser()
parser.add_argument("author")
parser.add_argument("quote")
params = parser.parse_args()
for quote in ai_quotes:
if(id == quote["id"]):
return f"Zitat mit ID {id} existiert bereits", 400
quote = {
"id": int(id),
"author": params["author"],
"quote": params["quote"]
}
ai_quotes.append(quote)
return quote, 201Im obigen Code hat die POST-Methode die ID des Zitats angenommen. Dann hat sie unter Verwendung von reqparse den Autor und das Zitat aus der Anfrage erhalten und in das Wörterbuch params gespeichert.
Wenn ein Zitat mit der angegebenen ID bereits existiert, gibt die Methode die entsprechende Nachricht und den Code 400 aus.
Wenn ein Zitat mit der angegebenen ID noch nicht erstellt wurde, erstellt die Methode einen neuen Eintrag mit der angegebenen ID und dem Autor sowie weiteren Parametern. Dann fügt sie den Eintrag zur Liste ai_quotes hinzu und gibt den Eintrag mit dem neuen Zitat zusammen mit dem Code 201 zurück.
Jetzt erstellen wir die PUT-Methode zum Ändern eines vorhandenen Zitats im Repository.
def put(self, id):
parser = reqparse.RequestParser()
parser.add_argument("author")
parser.add_argument("quote")
params = parser.parse_args()
for quote in ai_quotes:
if(id == quote["id"]):
quote["author"] = params["author"]
quote["quote"] = params["quote"]
return quote, 200
quote = {
"id": id,
"author": params["author"],
"quote": params["quote"]
}
ai_quotes.append(quote)
return quote, 201Die PUT-Methode, ähnlich dem vorherigen Beispiel, nimmt die ID und Eingaben und parst die Zitatparameter mit reqparse.
Wenn das Zitat mit der angegebenen ID existiert, wird es mit den neuen Parametern aktualisiert und das aktualisierte Zitat mit dem Code 200 ausgegeben. Wenn das Zitat mit der angegebenen ID noch nicht existiert, wird ein neuer Eintrag mit dem Code 201 erstellt.
Zuletzt erstellen wir eine DELETE-Methode zum Löschen eines Zitats, das nicht mehr inspiriert.
def delete(self, id):
global ai_quotes
ai_quotes = [quote for quote in ai_quotes if quote["id"] != id]
return f"Zitat mit der ID {id} wurde gelöscht.", 200Diese Methode erhält die ID des Zitats bei der Eingabe und aktualisiert die Liste der ai_quotes, indem sie die gemeinsame Liste verwendet.
Jetzt, da wir alle Methoden erstellt haben, müssen wir nur noch die Ressource zum API hinzufügen, den Pfad festlegen und Flask starten.
api.add_resource(Quote, "\/ai-quotes", "\/ai-quotes\/", "\/ai-quotes\/\")
if __name__ == '__main__':
app.run(debug=True)Unser REST API-Dienst ist bereit!
Als nächstes können wir den Code in die Datei app.py speichern und ihn in der Konsole mit dem Befehl ausführen:
python3 app.pyWenn alles gut geht, erhalten wir etwa Folgendes:
* Debug-Modus: aktiv
* Wird ausgeführt auf :5000\/ (Drücken Sie CTRL+C zum Beenden)
* Neustart mit stat
* Debugger ist aktiv!
* Debugger-PIN: XXXXXXX
Testen des APIs
Nachdem das API erstellt wurde, muss es getestet werden.
Dies kann mit dem Konsolenwerkzeug curl oder dem Insomnia REST-Client erfolgen oder indem das API auf Rapid API veröffentlicht wird.
Veröffentlichen unseres APIs
RapidAPI ist der größte Marktplatz der Welt mit über 10.000 APIs (und etwa 1 Million Entwicklern).
RapidAPI bietet nicht nur eine einheitliche Schnittstelle für den Zugriff auf Drittanbieter-APIs, sondern ermöglicht es auch, Ihr eigenes API schnell und problemlos zu veröffentlichen.
Um , müssen wir es zuerst auf einem Server im Internet veröffentlichen. In unserem Fall nutzen wir . Der Umgang damit sollte keine Schwierigkeiten verursachen, ().
Wie Sie Ihr API auf Heroku veröffentlichen
1. Installieren von Heroku.
Zuerst müssen Sie sich registrieren und die Heroku Command Line Interface (CLI) installieren. Dies funktioniert auf Ubuntu 16+.
sudo snap install heroku —classic
Dann melden wir uns an:
heroku login
2. Benötigte Dateien hinzufügen.
Sie müssen nun die zum Veröffentlichen erforderlichen Dateien in den Ordner unserer Anwendung hinzufügen:
- requirements.txt mit einer Liste der erforderlichen Python-Module;
- Procfile, welches angibt, welche Befehle zur Ausführung der Anwendung ausgeführt werden sollen;
- .gitignore — um Dateien auszuschließen, die auf dem Server nicht benötigt werden.
Die Datei requirements.txt wird folgende Zeilen enthalten:
- flask
- flask-restful
- gunicorn
Bitte beachten Sie: Wir haben gunicorn (Python WSGI HTTP Server) zur Liste hinzugefügt, da wir unsere Anwendung auf dem Server starten müssen.
Die Procfile enthält:
web: gunicorn app:app
Inhalt von .gitignore:
*.pyc
__pycache__/Jetzt, da die Dateien erstellt wurden, lassen Sie uns das git-Repo initialisieren und commiten:
git init
git add
git commit -m "Erster API-Commit"3. Erstellen Sie eine neue Heroku-Anwendung.
heroku createSenden Sie den master-Branch an das Remote-Repo Heroku:
git push heroku masterJetzt können wir beginnen, indem wir den API-Service mit den folgenden Befehlen öffnen:
heroku ps:scale web=1
heroku open
Die API ist unter folgender Adresse verfügbar: .
Wie Sie Ihre Python-API zum RapidAPI-Marktplatz hinzufügen
Nachdem der API-Service auf Heroku veröffentlicht ist, können Sie ihn zu Rapid API hinzufügen. Hier ist zu diesem Thema.
1. Erstellen Sie ein RapidAPI-Konto.
Registrieren Sie ein kostenloses Konto – das kann über Facebook, Google oder GitHub geschehen.
2. Fügen Sie die API zum Dashboard hinzu.
3. Geben Sie nun allgemeine Informationen zu Ihrer API ein.
4. Nach dem Klicken auf „API hinzufügen“ erscheint eine neue Seite, auf der Sie Informationen zu unserer API eingeben können.
5. Jetzt können Sie entweder die Endpoints der API manuell eingeben oder hochladen mit OpenAPI.
Jetzt müssen wir die Endpoints unserer API auf der Seite Endpoints festlegen. In unserem Fall entsprechen die Endpoints dem CRUD-Konzept (get, post, put, delete).
Als Nächstes müssen wir den GET AI Quote-Endpoint erstellen, der ein zufälliges Zitat ausgibt (wenn die ID standardmäßig ist) oder ein Zitat für die angegebene ID.
Um einen Endpoint zu erstellen, klicken Sie auf die Schaltfläche „Endpoint erstellen“.
Wiederholen Sie diesen Prozess für alle anderen API-Endpunkte. Das ist alles! Herzlichen Glückwunsch, Sie haben Ihre API veröffentlicht!
Wenn alles gut geht, sieht die API-Seite etwa so aus:
Fazit
In diesem Artikel haben wir den Prozess der Erstellung eines eigenen RESTful API-Services in Python untersucht, zusammen mit dem Veröffentlichungsprozess der API in der Cloud von Heroku und der Hinzufügung zum RapidAPI-Katalog.
Im Testmodell wurden jedoch nur die grundlegenden Prinzipien der API-Entwicklung gezeigt – Aspekte wie Sicherheit, Fehlertoleranz und Skalierbarkeit wurden nicht behandelt.
Bei der Entwicklung einer realen API muss all dies berücksichtigt werden.
Quelle: habr.com
