API mit Python (mit Flask und RapidAPI) entwickeln

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.

Durch die Integration eines der vielen verfügbaren offenen APIs in Ihre Anwendung können Sie deren Funktionalität erweitern oder mit den benötigten Daten anreichen. Aber was, wenn Sie eine einzigartige Funktion entwickelt haben, die Sie mit der Community teilen möchten?

Die Antwort ist einfach: Sie müssen Ihre eigene API erstellen..

Obwohl dies zunächst wie eine komplexe Aufgabe erscheinen mag, ist es tatsächlich recht einfach. Wir zeigen Ihnen, wie Sie das mit Python umsetzen können.

Was Sie für den Start benötigen

Für die Entwicklung einer API sind folgende Dinge erforderlich:

• Python 3;
• Flask — ein einfach zu nutzendes Framework zur Erstellung von Webanwendungen;
• Flask-RESTful — ein Erweiterung für Flask, die es ermöglicht, REST APIs schnell und mit minimalen Einstellungen zu entwickeln.

Die Installation erfolgt mit dem Befehl:

pip install flask-restful

Wir empfehlen einen kostenlosen Programmier-Intensivkurs für Anfänger:
Entwicklung eines Telegram-Bots in C# — vom 26. bis 28. August. Ein kostenloses Intensivtraining, das Ihnen hilft zu verstehen, wie Bot-Assistenten funktionieren, die Besonderheiten der Arbeit mit der Telegram-API und andere Feinheiten. Die drei besten Teilnehmer erhalten von Skillbox 30.000 Rubel..

Bevor wir beginnen

Wir planen die Entwicklung eines RESTful APIs mit grundlegenden CRUD-Funktionalitäten..

Um die Aufgabe vollständig zu verstehen, lassen Sie uns zwei der oben genannten Begriffe klären.

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 arbeitet. Client und Server sind unabhängig, jeder kann unabhängig vom anderen ersetzt werden.
• Zustandslos — keine Client-Daten werden auf dem Server gespeichert. Der Sitzungsstatus wird auf der Client-Seite gespeichert.
• Cache-Fähigkeit — Clients können die Antworten des Servers zwischenspeichern, um die Gesamtleistung zu verbessern.

Was ist CRUD?

CRUD ist ein Programmierkonzept, das vier grundlegende Aktionen beschreibt (create, read, update und delete).

In der REST-API sind die Anfragearten und Methoden für Aktionen wie POST, GET, PUT und DELETE verantwortlich.

Jetzt, wo wir die grundlegenden Begriffe geklärt haben, können wir mit der Erstellung der API beginnen.

Entwicklung

Lass uns ein Repository für Zitate über Künstliche Intelligenz erstellen. KI ist eine der am schnellsten wachsenden Technologien heute, und Python ist ein beliebtes Werkzeug für die Arbeit mit KI.

Mit dieser API kann der Python-Entwickler schnell Informationen über KI abrufen und sich von neuen Errungenschaften inspirieren lassen. Wenn der Entwickler wertvolle Gedanken zu diesem Thema hat, kann er sie im Repository hinzufügen.

Beginnen wir mit dem Import der notwendigen Module und der Einrichtung 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 benötigen.

Reqparse ist das Schnittstellenmodul für das Parsen von Anfragen in Flask-RESTful… Außerdem benötigen wir das Modul random für die Anzeige eines zufälligen Zitats.

Jetzt werden wir ein Repository für Zitate über KI erstellen.

Jeder Eintrag im Repository wird enthalten:

• eine digitale ID;
• den Namen des Autors des Zitats;
• das Zitat.

Da dies nur ein Beispiel für Schulungszwecke ist, werden wir alle Einträge in der Python-Liste speichern. In einer echten Anwendung würden wir wahrscheinlich stattdessen eine Datenbank verwenden.

ai_quotes = [
    {
        "id": 0,
        "author": "Kevin Kelly",
        "quote": "Die Geschäftsmodelle der nächsten 10.000 Startups sind leicht vorherzusagen: " +
                 "Nehmen Sie X und fügen Sie KI hinzu."
    },
    {
        "id": 1,
        "author": "Stephen Hawking",
        "quote": "Die Entwicklung einer voll funktionsfähigen künstlichen Intelligenz könnte " +
                 "das Ende der menschlichen Rasse bedeuten… " +
                 "Sie würde autonom starten und sich " +
                 "in einem ständig wachsenden Tempo neu gestalten. " +
                 "Menschen, die durch langsame biologische Evolution eingeschränkt sind, " +
                 "könnten nicht konkurrieren und würden abgelöst werden."
    },
    {
        "id": 2,
        "author": "Claude Shannon",
        "quote": "Ich stelle mir eine Zeit vor, in der wir zu Robotern sind wie " +
                 "Hunde zu Menschen, " +
                 "und ich unterstütze die Maschinen."
    },
    {
        "id": 3,
        "author": "Elon Musk",
        "quote": "Das Tempo des Fortschritts in der künstlichen Intelligenz " +
                 "(ich spreche nicht von eng gefasster KI) " +
                 "ist unglaublich schnell. Es sei denn, Sie haben direkten " +
                 "Kontakt mit Gruppen wie Deepmind, " +
                 "haben Sie keine Vorstellung davon, wie schnell – es wächst " +
                 "in einem Tempo, das nahezu exponentiell ist. " +
                 "Das Risiko, dass etwas ernsthaft Gefährliches " +
                 "passiert, liegt im Zeitrahmen von fünf Jahren. " +
                 "Höchstens 10 Jahre."
    },
    {
        "id": 4,
        "author": "Geoffrey Hinton",
        "quote": "Ich war immer davon überzeugt, dass der einzige Weg, " +
                 "um künstliche Intelligenz zum Funktionieren zu bringen, " +
                 "darin besteht, die Berechnungen ähnlich wie im menschlichen Gehirn durchzuführen. " +
                 "Das ist das Ziel, dem ich seit jeher nachgehe. Wir machen Fortschritte, " +
                 "auch wenn 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 intelligent werden und die Welt übernehmen, " +
                 "aber das wirkliche Problem ist, dass sie zu dumm sind " +
                 "und die Welt bereits übernommen haben."
    },
    {
        "id": 6,
        "author": "Alan Turing",
        "quote": "Es scheint wahrscheinlich, dass es nicht lange dauern wird, " +
                 "bis die maschinelle Denkweise " +
                 "unsere schwachen Kräfte übertrifft… " +
                 "Sie wären in der Lage, " +
                 "miteinander zu kommunizieren, um ihre Intelligenz zu schärfen. " +
                 "Daher sollten wir in einem bestimmten Stadium " +
                 "erwarten, dass die Maschinen die Kontrolle übernehmen."
    },
    {
        "id": 7,
        "author": "Ray Kurzweil",
        "quote": "Künstliche Intelligenz wird um das Jahr 2029 " +
                 "menschliche Niveau erreichen. " +
                 "Wenn man das weiterführt, sagen wir bis 2045, " +
                 "werden wir die Intelligenz, " +
                 "die menschliche biologische Maschinenintelligenz " +
                 "unserer Zivilisation billionenfach multipliziert haben."
    },
    {
        "id": 8,
        "author": "Sebastian Thrun",
        "quote": "Niemand sagt es so, aber ich denke, " +
                 "dass künstliche Intelligenz " +
                 "fast wie eine Geisteswissenschaft ist. Es ist wirklich ein Versuch " +
                 "das menschliche Denken und die 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 die Ressourcenklasse Quote erstellen, die die Operationen der Endpunkte unserer API definiert. Innerhalb der Klasse müssen wir vier Methoden deklarieren: get, post, put, delete.

Fangen wir mit der GET-Methode an.

Diese ermöglicht es, ein bestimmtes Zitat durch Angabe seiner ID oder ein zufälliges Zitat abzurufen, 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", 404

Die GET-Methode gibt ein zufälliges Zitat zurück, wenn die ID den Standardwert enthält, d.h. wenn beim Aufruf der Methode die ID nicht festgelegt wurde.

Wenn sie festgelegt ist, sucht die Methode unter den Zitaten und findet das, das die angegebene ID enthält. Wenn nichts gefunden wird, erscheint die Nachricht „Quote not found, 404“.

Denken Sie daran: Die Methode gibt den HTTP-Status 200 bei erfolgreicher Anfrage und 404 zurück, wenn der Datensatz nicht gefunden wurde.

Jetzt lassen Sie uns die POST-Methode erstellen, um ein neues Zitat im Repository hinzuzufügen.

Sie wird die ID jedes neuen Zitats beim Eingeben erhalten. Darüber hinaus wird POST reqparse verwenden, um die Parameter zu parsen, die im Anfragekörper enthalten sind (Autor und Text des Zitats).

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 der ID {id} existiert bereits", 400
      quote = {
          "id": int(id),
          "author": params["author"],
          "quote": params["quote"]
      }
      ai_quotes.append(quote)
      return quote, 201

Im obigen Code hat die POST-Methode die ID des Zitats übernommen. Anschließend wurden mit reqparse der Autor und das Zitat aus der Anfrage abgerufen und in einem Dictionary namens params gespeichert.

Wenn ein Zitat mit der angegebenen ID bereits existiert, gibt die Methode eine entsprechende Nachricht und den Statuscode 400 zurück.

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. Danach wird der Eintrag zur Liste ai_quotes hinzugefügt und der Eintrag mit dem neuen Zitat zusammen mit dem Statuscode 201 zurückgegeben.

Nun erstellen wir eine PUT-Methode, um ein bestehendes 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, 201

Die PUT-Methode, ähnlich dem vorherigen Beispiel, nimmt die ID und den Input und analysiert die Parameter für das Zitat mithilfe von reqparse.

Wenn das Zitat mit der angegebenen ID existiert, wird es mit den neuen Parametern aktualisiert und anschließend mit dem Code 200 ausgegeben. Wenn das Zitat mit der angegebenen ID noch nicht vorhanden ist, wird ein neuer Eintrag mit dem Code 201 erstellt.

Lassen Sie uns schließlich eine DELETE-Methode erstellen, um ein Zitat zu löschen, 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 ID {id} wurde gelöscht.", 200

Diese Methode erhält die ID des Zitats als Eingabe und aktualisiert die Liste ai_quotes unter Verwendung der globalen Liste.

Jetzt, da wir alle Methoden erstellt haben, müssen wir nur noch die Resource zum API hinzufügen, den Pfad festlegen und Flask starten.

api.add_resource(Quote, "/ai-quotes", "/ai-quotes/", "/ai-quotes/<int:id>")
if __name__ == '__main__':
    app.run(debug=True)

Unser REST API-Dienst ist bereit!

Als Nächstes können wir den Code in der Datei app.py speichern und ihn mit folgendem Befehl in der Konsole ausführen:

python3 app.py

Wenn alles gut läuft, erhalten wir etwa Folgendes:

* Debug-Modus: aktiv
* Läuft auf 127.0.0.1:5000/ (Drücken Sie CTRL+C zum Beenden)
* Neustart mit stat
* Debugger ist aktiv!
* Debugger-PIN: XXXXXXX

API testen

Nachdem das API erstellt wurde, muss es getestet werden.

Sie können dies mit dem Konsolenprogramm curl oder dem REST-Client Insomnia tun oder indem Sie Ihre API auf RapidAPI veröffentlichen.

Unsere API veröffentlichen

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 die Arbeit mit Drittanbieter-APIs, sondern ermöglicht es auch, Ihre eigene API schnell und problemlos zu veröffentlichen.

Um dies zu erreichen, müssen wir zunächstsie auf einem Server im Internet veröffentlichen. In unserem Fall verwenden wir Heroku. Die Arbeit damit sollte keine Schwierigkeiten bereiten, (mehr darüber erfahren Sie hier).

Wie Sie Ihre API auf Heroku veröffentlichen

1. Heroku installieren.

Zuerst müssen Sie sich registrieren und das Heroku Command Line Interface (CLI) installieren. Dies funktioniert auf Ubuntu 16+.

sudo snap install heroku —classic

Dann loggen wir uns ein:

heroku login

2. Notwendige Dateien hinzufügen.

Jetzt müssen wir die Dateien für die Veröffentlichung in den Ordner unserer Anwendung hinzufügen:

• requirements.txt mit der Liste der erforderlichen Python-Module;
• Procfile, der 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 die folgenden Zeilen enthalten:

• flask
• flask-restful
• gunicorn

Bitte beachten Sie: Wir haben gunicorn (Python WSGI HTTP Server) in die Liste aufgenommen, da unser Anwendung auf dem Server ausgeführt werden muss.

Procfile wird enthalten:

web: gunicorn app:app

Inhalt von .gitignore:

*.pyc
__pycache__/

Jetzt, wo die Dateien erstellt sind, lassen Sie uns das git-Repo initialisieren und committen:

git init
git add
git commit -m "Erster API-Commit"

3. Wir erstellen eine neue Heroku-Anwendung.

heroku create

Wir senden den master branch an das entfernte Heroku-Repo:

git push heroku master

Jetzt können wir starten, indem wir den API-Service mit den folgenden Befehlen öffnen:

heroku ps:scale web=1
heroku open
 

Die API wird unter folgender Adresse verfügbar sein: your-random-heroku-name.herokuapp.com/ai-quotes.

Wie Sie Ihre Python-API zum RapidAPI-Marktplatz hinzufügen

Nachdem der API-Dienst auf Heroku veröffentlicht wurde, können Sie ihn zu RapidAPI hinzufügen. Hier finden Sie die detaillierte Dokumentation zu diesem Thema.

1. Wir erstellen ein RapidAPI-Konto.

Registrieren Sie ein kostenloses Konto – dies kann über Facebook, Google oder GitHub erfolgen.

2. Wir fügen die API zum Dashboard hinzu.

3. Jetzt geben wir allgemeine Informationen über unsere API ein.

4. Nach dem Klick auf 'API hinzufügen' erscheint eine neue Seite, auf der wir Informationen zu unserer API eingeben können.

5. Jetzt können Sie entweder die Endpunkte der API manuell eingeben oder die Swagger-Datei hochladen. mit OpenAPI.

Jetzt müssen wir die Endpunkte unserer API auf der Seite "Endpoints" festlegen. In unserem Fall entsprechen die Endpunkte dem CRUD-Konzept (get, post, put, delete).

Als Nächstes erstellen wir den Endpunkt GET AI Quote, der ein zufälliges Zitat ausgibt (wenn die ID standardmäßig ist) oder ein Zitat für die angegebene ID.

Um den Endpunkt zu erstellen, klicken Sie auf die Schaltfläche "Create Endpoint".

Wiederholen Sie diesen Prozess für alle anderen API-Endpunkte. Das war’s! Glückwunsch, Sie haben Ihre API veröffentlicht!

Wenn alles gut läuft, sieht die API-Seite ungefähr so aus:

Fazit

In diesem Artikel haben wir den Prozess zur Erstellung eines eigenen RESTful API Service in Python untersucht, zusammen mit dem Prozess der Veröffentlichung der API in der Cloud Heroku und deren Hinzufügung zum RapidAPI-Verzeichnis.

Im Testfall 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 müssen all diese Aspekte berücksichtigt werden.

Quelle: habr.com