Wenn Sie diesen Artikel lesen, wissen Sie wahrscheinlich bereits, welche Möglichkeiten sich bei der Verwendung der API (Application Programming Interface) eröffnen.
Durch das Hinzufügen einer der vielen öffentlichen APIs zu Ihrer Anwendung können Sie die Funktionalität dieser Anwendung erweitern oder sie mit den erforderlichen Daten ergänzen. Was aber, wenn Sie eine einzigartige Funktion entwickelt haben, die Sie mit der Community teilen möchten?
Die Antwort ist einfach: Sie brauchen .
Obwohl dies auf den ersten Blick wie eine entmutigende Aufgabe erscheint, ist es eigentlich ganz einfach. Wir zeigen Ihnen, wie das mit Python geht.
Was Sie brauchen, um loszulegen
Die API-Entwicklung erfordert:
- Python3;
- — ein einfaches und benutzerfreundliches Framework zum Erstellen von Webanwendungen;
- ist eine Erweiterung für Flask, mit der Sie schnell und mit minimaler Konfiguration eine REST-API entwickeln können.
Die Installation wird mit dem folgenden Befehl durchgeführt:
pip install flask-restfulFür Einsteiger empfehlen wir eine kostenlose Intensivprogrammierung:
— 26.–28. August. Ein kostenloser Intensivkurs, der es Ihnen ermöglicht, die Funktionsweise von Hilfsbots, die Funktionen der Arbeit mit der Telegram-API und andere Nuancen zu verstehen. Die drei besten Teilnehmer erhalten 30 Rubel von Skillbox.
Bevor du anfängst
Wir werden eine RESTful-API mit einer Basis entwickeln .
Um die Aufgabe vollständig zu verstehen, sollten wir uns mit den beiden oben genannten Begriffen befassen.
Was ist REST?
REST API (Representational State Transfer) ist eine API, die HTTP-Anfragen zum Austausch von Daten verwendet.
REST-APIs müssen bestimmte Kriterien erfüllen:
- Client-Server-Architektur: Der Client interagiert mit der Benutzeroberfläche und der Server interagiert mit dem Backend und dem Datenspeicher. Der Client und der Server sind unabhängig, jeder von ihnen kann separat ersetzt werden.
- Zustandslos – Es werden keine Clientdaten auf dem Server gespeichert. Der Sitzungsstatus wird auf der Clientseite gespeichert.
- Cachefähigkeit – Clients können Serverantworten zwischenspeichern, um die Gesamtleistung zu verbessern.
Was ist CRUD?
GRAUSAM ist ein Programmierkonzept, das vier grundlegende Aktionen beschreibt (Erstellen, Lesen, Aktualisieren und Löschen).
In der REST-API sind Anforderungstypen und Anforderungsmethoden für Aktionen wie Post, Get, Put, Delete verantwortlich.
Nachdem wir uns nun mit den Grundbegriffen beschäftigt haben, können wir mit der Erstellung der API beginnen.
Entwicklung
Lassen Sie uns eine Sammlung von Zitaten zum Thema künstliche Intelligenz erstellen. KI ist heute eine der am schnellsten wachsenden Technologien und Python ist ein beliebtes Werkzeug für die Arbeit mit KI.
Mit dieser API kann ein Python-Entwickler schnell etwas über KI lernen und sich von neuen Errungenschaften inspirieren lassen. Wenn der Entwickler wertvolle Gedanken zu diesem Thema hat, kann er diese dem Repository hinzufügen.
Beginnen wir mit dem Importieren der erforderlichen Module und dem Einrichten von Flask:
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 brauchen.
Reqparse ist eine Flask-RESTful-Anfrage-Parsing-Schnittstelle ... Sie benötigen außerdem das Zufallsmodul, um ein zufälliges Zitat anzuzeigen.
Jetzt erstellen wir eine Sammlung von Zitaten zum Thema KI.
Jeder Repo-Eintrag enthält:
- digitale ID;
- der Name des Autors des Zitats;
- zitieren.
Da es sich lediglich um ein Lernbeispiel handelt, speichern wir alle Einträge in einer Python-Liste. In einer realen Anwendung würden wir höchstwahrscheinlich stattdessen eine Datenbank verwenden.
ai_quotes = [
{
"id": 0,
"author": "Kevin Kelly",
"quote": "The business plans of the next 10,000 startups are easy to forecast: " +
"Take X and add AI."
},
{
"id": 1,
"author": "Stephen Hawking",
"quote": "The development of full artificial intelligence could " +
"spell the end of the human race… " +
"It would take off on its own, and re-design " +
"itself at an ever increasing rate. " +
"Humans, who are limited by slow biological evolution, " +
"couldn't compete, and would be superseded."
},
{
"id": 2,
"author": "Claude Shannon",
"quote": "I visualize a time when we will be to robots what " +
"dogs are to humans, " +
"and I’m rooting for the machines."
},
{
"id": 3,
"author": "Elon Musk",
"quote": "The pace of progress in artificial intelligence " +
"(I’m not referring to narrow AI) " +
"is incredibly fast. Unless you have direct " +
"exposure to groups like Deepmind, " +
"you have no idea how fast — it is growing " +
"at a pace close to exponential. " +
"The risk of something seriously dangerous " +
"happening is in the five-year timeframe." +
"10 years at most."
},
{
"id": 4,
"author": "Geoffrey Hinton",
"quote": "I have always been convinced that the only way " +
"to get artificial intelligence to work " +
"is to do the computation in a way similar to the human brain. " +
"That is the goal I have been pursuing. We are making progress, " +
"though we still have lots to learn about " +
"how the brain actually works."
},
{
"id": 5,
"author": "Pedro Domingos",
"quote": "People worry that computers will " +
"get too smart and take over the world, " +
"but the real problem is that they're too stupid " +
"and they've already taken over the world."
},
{
"id": 6,
"author": "Alan Turing",
"quote": "It seems probable that once the machine thinking " +
"method had started, it would not take long " +
"to outstrip our feeble powers… " +
"They would be able to converse " +
"with each other to sharpen their wits. " +
"At some stage therefore, we should " +
"have to expect the machines to take control."
},
{
"id": 7,
"author": "Ray Kurzweil",
"quote": "Artificial intelligence will reach " +
"human levels by around 2029. " +
"Follow that out further to, say, 2045, " +
"we will have multiplied the intelligence, " +
"the human biological machine intelligence " +
"of our civilization a billion-fold."
},
{
"id": 8,
"author": "Sebastian Thrun",
"quote": "Nobody phrases it this way, but I think " +
"that artificial intelligence " +
"is almost a humanities discipline. It's really an attempt " +
"to understand human intelligence and human cognition."
},
{
"id": 9,
"author": "Andrew Ng",
"quote": "We're making this analogy that AI is the new electricity." +
"Electricity transformed industries: agriculture, " +
"transportation, communication, manufacturing."
}
]Jetzt müssen wir eine Quote-Ressourcenklasse erstellen, die die Vorgänge unserer API-Endpunkte definiert. Innerhalb der Klasse müssen vier Methoden deklariert werden: get, post, put, delete.
Beginnen wir mit der GET-Methode
Sie können ein bestimmtes Angebot erhalten, indem Sie dessen ID angeben, oder ein zufälliges Angebot, 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 "Quote not found", 404Die GET-Methode gibt ein zufälliges Anführungszeichen zurück, wenn die ID den Standardwert enthält, d. h. Beim Aufruf der Methode wurde keine ID festgelegt.
Wenn es festgelegt ist, durchsucht die Methode die Anführungszeichen und findet das Anführungszeichen, das die angegebene ID enthält. Wenn nichts gefunden wird, wird die Meldung „Angebot nicht gefunden, 404“ angezeigt.
Denken Sie daran, dass die Methode einen HTTP-Status von 200 zurückgibt, wenn die Anfrage erfolgreich war, und 404, wenn der Eintrag nicht gefunden wurde.
Erstellen wir nun eine POST-Methode, um dem Repository ein neues Angebot hinzuzufügen
Während der Eingabe wird die ID jedes neuen Zitats abgerufen. Darüber hinaus verwendet POST reqparse, um die Parameter zu analysieren, die im Anforderungstext enthalten sind (Autor und Zitattext).
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"Quote with id {id} already exists", 400
quote = {
"id": int(id),
"author": params["author"],
"quote": params["quote"]
}
ai_quotes.append(quote)
return quote, 201Im obigen Code akzeptierte die POST-Methode eine Angebots-ID. Anschließend wurden mithilfe von reqparse der Autor und das Zitat aus der Anfrage abgerufen und im Parameterwörterbuch gespeichert.
Wenn bereits ein Angebot mit der angegebenen ID vorhanden ist, zeigt die Methode die entsprechende Meldung und den Code 400 an.
Wenn noch kein Zitat mit der angegebenen ID erstellt wurde, erstellt die Methode einen neuen Eintrag mit der angegebenen ID und dem Autor sowie weiteren Parametern. Anschließend wird der ai_quotes-Liste ein Eintrag hinzugefügt und ein Eintrag mit einem neuen Zitat zusammen mit einem 201-Code zurückgegeben.
Jetzt erstellen wir eine PUT-Methode, um ein vorhandenes Zitat im Repository zu ändern
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 nimmt, ähnlich wie im vorherigen Beispiel, eine ID und eine Eingabe und analysiert die Anführungszeichenparameter mithilfe von reqparse.
Wenn ein Angebot mit der angegebenen ID vorhanden ist, aktualisiert die Methode es mit den neuen Parametern und gibt dann das aktualisierte Angebot mit Code 200 aus. Wenn noch kein Angebot mit der angegebenen ID vorhanden ist, wird ein neuer Datensatz mit Code 201 erstellt.
Zum Schluss erstellen wir eine DELETE-Methode, um ein Zitat zu entfernen, das nicht mehr inspirierend ist.
def delete(self, id):
global ai_quotes
ai_quotes = [qoute for qoute in ai_quotes if qoute["id"] != id]
return f"Quote with id {id} is deleted.", 200Diese Methode verwendet die Angebots-ID als Eingabe und aktualisiert die Liste der ai_quotes mithilfe der gemeinsam genutzten Liste.
Nachdem wir nun alle Methoden erstellt haben, müssen wir nur noch die Ressource zur API hinzufügen, den Pfad festlegen und Flask ausführen.
api.add_resource(Quote, "/ai-quotes", "/ai-quotes/", "/ai-quotes/<int:id>")
if __name__ == '__main__':
app.run(debug=True)Unser REST API Service ist bereit!
Als Nächstes können wir den Code in der Datei app.py speichern, indem wir ihn in der Konsole mit dem folgenden Befehl ausführen:
python3 app.pyWenn alles in Ordnung ist, erhalten wir so etwas:
* Debug-Modus: aktiviert
* Läuft weiter :5000/ (Drücken Sie STRG+C zum Beenden)
* Neustart mit stat
* Debugger ist aktiv!
* Debugger-PIN: XXXXXXX
Testen der API
Nachdem die API erstellt wurde, muss sie getestet werden.
Dies kann mit dem Curl-Konsolendienstprogramm oder dem Insomnia REST-Client oder durch Veröffentlichung der API auf der Rapid API erfolgen.
Veröffentlichung unserer API
RapidAPI ist der größte Marktplatz der Welt mit über 10 APIs (und etwa 000 Million Entwicklern).
RapidAPI bietet nicht nur eine einzige Schnittstelle für die Arbeit mit APIs von Drittanbietern, sondern ermöglicht Ihnen auch die schnelle und einfache Veröffentlichung Ihrer eigenen API.
Auf , müssen Sie es zunächst auf einem Server im Netzwerk veröffentlichen. In unserem Fall verwenden wir . Die Zusammenarbeit mit ihm sollte keine Schwierigkeiten bereiten, ().
So veröffentlichen Sie Ihre API auf Heroku
1. Installieren Sie Heroku.
Der erste Schritt besteht darin, das Heroku Command Line Interface (CLI) zu registrieren und zu installieren. Dies funktioniert unter Ubuntu 16+.
sudo snap install heroku --classic
Dann loggen wir uns ein:
Heroku Login
2. Fügen Sie die erforderlichen Dateien hinzu.
Jetzt müssen wir die zu veröffentlichenden Dateien einem Ordner in unserer Anwendung hinzufügen:
- „requirements.txt“ mit einer Liste der erforderlichen Python-Module;
- Procfile, das angibt, welche Befehle ausgeführt werden müssen, um die Anwendung auszuführen;
- .gitignore – um Dateien auszuschließen, die auf dem Server nicht benötigt werden.
Die Datei „requirements.txt“ enthält die folgenden Zeilen:
- Flasche
- Kolben-erholsam
- Gunicorn
Bitte beachten Sie, dass wir gunicorn (Python WSGI HTTP Server) zur Liste hinzugefügt haben, da wir unsere Anwendung auf dem Server ausführen müssen.
Procfile enthält:
Web: Gunicorn App: App
Inhalt von .gitignore:
*.pyc
__pycache__/Nachdem die Dateien nun erstellt sind, initialisieren wir das Git-Repo und führen einen Commit durch:
git init
git add
git commit -m "First API commit"3. Erstellen Sie eine neue Heroku-App.
heroku createDen Master-Zweig in das Remote-Heroku-Repo verschieben:
git push heroku masterJetzt können Sie beginnen, indem Sie den API-Dienst mit den folgenden Befehlen öffnen:
heroku ps:scale web=1
heroku open
Die API wird unter verfügbar sein .
So fügen Sie Ihre Python-API zum RapidAPI-Marktplatz hinzu
Sobald der API-Dienst auf Heroku veröffentlicht ist, können Sie ihn zur Rapid API hinzufügen. Hier Zu diesem Thema.
1. Erstellen Sie ein RapidAPI-Konto.
Wir registrieren ein kostenloses Konto – dies kann über Facebook, Google, GitHub erfolgen.
2. Fügen Sie der Systemsteuerung eine API hinzu.
3. Geben Sie als Nächstes allgemeine Informationen zu Ihrer API ein.
4. Nachdem Sie auf „API hinzufügen“ geklickt haben, erscheint eine neue Seite, auf der Sie Informationen zu unserer API eingeben können.
5. Jetzt können Sie die API-Endpunkte entweder manuell eingeben oder herunterladen mit OpenAPI.
Nun müssen Sie die Endpunkte unserer API auf der Seite „Endpunkte“ festlegen. In unserem Fall entsprechen die Endpunkte dem Konzept von CRUD (get, post, put, delete).
Als Nächstes müssen Sie einen GET AI Quote-Endpunkt erstellen, der ein zufälliges Angebot (wenn die ID standardmäßig ist) oder ein Angebot für die angegebene ID anzeigt.
Um einen Endpunkt zu erstellen, müssen Sie auf die Schaltfläche „Endpunkt erstellen“ klicken.
Wir wiederholen diesen Vorgang 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:
Abschluss
In diesem Artikel haben wir den Prozess der Erstellung unseres eigenen RESTful-API-Dienstes in Python sowie den Prozess der Veröffentlichung der API in der Heroku-Cloud und des Hinzufügens zum RapidAPI-Verzeichnis besprochen.
In der Testversion wurden jedoch nur die Grundprinzipien der API-Entwicklung gezeigt – Nuancen wie Sicherheit, Fehlertoleranz und Skalierbarkeit wurden nicht berücksichtigt.
Bei der Entwicklung einer echten API muss all dies berücksichtigt werden.
Source: habr.com