Direkt zum Inhalt

FastAPI Tutorial: Eine Einführung in die Verwendung von FastAPI

Erforsche das FastAPI-Framework und entdecke, wie du damit APIs in Python erstellen kannst
Aktualisierte 16. Jan. 2025  · 13 Min. Lesezeit

API (Application Programming Interface) sind das Rückgrat der modernen Architektur, weil sie es ermöglichen, Anwendungen modular und entkoppelt zu gestalten. Das bedeutet, dass du schnell und einfach Anwendungen erstellen kannst, die sich leicht warten und aktualisieren lassen. 

APIs sind auch beim maschinellen Lernen sehr wichtig, weil sie es verschiedenen Anwendungen ermöglichen, Daten auszutauschen und zusammenzuarbeiten, was Zeit und Mühe spart. Es gibt viele verschiedene Frameworks für die Erstellung von APIs in Python. Einige der beliebtesten Frameworks für die Erstellung von APIs in Python sind Django, Flask und FastAPI. Dieses Tutorial ist ein tiefer Einblick in eines der Frameworks namens FastAPI.

Was ist eine API?

API steht für Application Programming Interface. Eine API ist ein Software-Vermittler, der es zwei Anwendungen ermöglicht, miteinander zu kommunizieren. Wenn du eine Anwendung auf deinem Telefon verwendest, verbindet sich die Anwendung mit dem Internet und sendet Daten an einen Server. Der Server verarbeitet dann die Daten und sendet sie zurück an dein Telefon. Die Anwendung auf deinem Handy interpretiert dann die Daten und präsentiert sie dir in einer lesbaren Form. 

Eine API ist wie ein Kellner in einem Restaurant. Der Kellner nimmt deine Bestellung auf und schickt sie an die Küche. Die Küche bereitet dann das Essen zu und schickt es an den Kellner zurück. Der Kellner bringt dann das Essen zu dir. 

Auf die gleiche Weise nimmt eine API eine Anfrage von einer Anwendung entgegen und sendet sie an einen Server. Der Server verarbeitet dann die Anfrage und sendet die Daten zurück an die Anwendung. Die Anwendung interpretiert dann die Daten und präsentiert sie dem/der Nutzer/in.

Ein einfaches Design der API-Architektur

Image Source: https://www.techfunnel.com/wp-content/uploads/2021/07/api.png

Wenn du mehr über Pipelines für maschinelles Lernen, APIs und MLOps erfahren möchtest, kannst du dir unser Tutorial zu maschinellem Lernen, Pipelines, Bereitstellung und MLOps ansehen.

Was ist FastAPI?

FastAPI ist ein leistungsfähiges Web-Framework für die Erstellung von APIs mit Python 3.7+, das auf Standard-Python-Typ-Hinweisen basiert. Es hilft Entwicklern, Anwendungen schnell und effizient zu erstellen. FastAPI baut auf dem Starlette-Webserver auf und enthält Funktionen, die das Erstellen von Webanwendungen erleichtern, z. B. automatische Datenvalidierung, Fehlerbehandlung und interaktive API-Dokumente. 

In diesem Abschnitt werden wir alle diese Funktionen einzeln betrachten. Schauen wir uns zunächst die wichtigsten Funktionen an, die in der Originaldokumentation von FastAPI beschrieben sind.

  • Leistung: Auf Augenhöhe mit NodeJS und der Sprache Go.
  • Geschwindigkeit: Erhöhe die Entwicklungsgeschwindigkeit um das 2-3-fache.
  • Einfach: Großartige Unterstützung für Redakteure. Vollendung überall. Leicht zu erlernen und anzuwenden.
  • Robust: Serienreifer Code mit automatischer interaktiver Dokumentation.
  • OpenAPI basiert: Vollständig kompatibel mit OpenAPI und JSON Schema.

Installing FastAPI

FastAPI erfordert Python 3.7+. Es kann mit pip installiert werden. Du musst FastAPI und den ASGI-Server `uvicorn` installieren.

``

# install fastapi

pip install fastapi




# install uvicorn
pip install uvicorn

``

Eine einfache API erstellen

Lass uns direkt mit der Erstellung einer sehr einfachen Spielzeug-API beginnen. Ich verwende VS Code, um dies zu implementieren, aber du kannst jeden beliebigen Editor verwenden.

```

from typing import Union

from fastapi import FastAPI




app = FastAPI()




@app.get("")

def read_root():

    return {"Hello": "World"}




@app.get("/items/{item_id}")

def read_item(item_id: int, q: Union[str, None] = None):

    return {"item_id": item_id, "q": q}

```

(Das Beispiel stammt aus der Originaldokumentation). Danke an @tiangolo.

Führe diese API mit folgendem Befehl in einem Terminal aus:

```

uvicorn main:app –reload

```

main" ist der Name der Python-Datei und "app" ist die Variable, in der die FastAPI-Klasse gespeichert ist. Du kannst sie nennen, wie du willst. Wenn du den obigen Befehl ausführst, siehst du in deinem Terminal etwas wie das hier:

Befehlsterminal

Wenn du den Link in deinem Browser aufrufst und eine Seite mit der Aufschrift "Hallo Welt" siehst, ist die API betriebsbereit.

API läuft auf localhost im Browser

Bild vom Autor

Herzlichen Glückwunsch zur Erstellung deiner ersten API. 

Interaktive API-Dokumente

FastAPI erstellt ein "Schema" mit all deinen APIs und verwendet dabei den OpenAPI-Standard zur Definition von APIs. Ein "Schema" ist eine Definition oder Beschreibung von etwas. Nicht den Code, der ihn implementiert, sondern nur eine abstrakte Beschreibung. Das OpenAPI-Schema ist die Grundlage für die beiden interaktiven Dokumentationssysteme, die in FastAPI enthalten sind.

Um die Dokumentation zu sehen, füge einfach `/docs` an die URL (`http://127.0.0.1:8000/docs`) an. Dieser Link zeigt die automatische interaktive API-Dokumentation an.

Automatisierte Dokumentation, die von FastAPI erstellt wird

Bild vom Autor

Klicke auf die Schaltfläche "Ausprobieren" in der oberen rechten Ecke, um die API zu testen.

Automatisierte Dokumentation, erstellt von FastAPI 2

Bild vom Autor

Du kannst sehen, dass der Antwortkörper ein Wörterbuch ist. Dies ist der Rückruf der Funktion `read_item`, die in der Datei `main.py` definiert ist. Du kannst auch die Anfrage-Url `http://127.0.0.1:8000/items/1?q=orange` sehen. 1" und "Orange" waren unsere Eingaben an die API.

In FastAPI gibt es eine alternative interaktive automatische Dokumentation. Um das zu überprüfen, gehe auf http://127.0.0.1:8000/redoc`. So sieht es aus:

Automatisierte Dokumentation, erstellt von FastAPI 3

Bild vom Autor

Fortgeschrittene Beispiele

Bei der Erstellung einer API definiert der "Pfad" den Weg oder Endpunkt der Anfrage. Es gibt jedoch noch eine weitere Wahl, die wir treffen müssen, nämlich "Operation". Das Wort "Operation" bezieht sich hier auf eine der HTTP-"Methoden". Wenn du eine (oder mehrere) dieser sogenannten "Methoden" verwendest, kannst du mit jedem der verschiedenen Pfade kommunizieren, die das HTTP-Protokoll unterstützt. Normalerweise würdest du das verwenden:

  • POST: um Daten zu erstellen.
  • GET: um Daten zu lesen.
  • PUT: um Daten zu aktualisieren.
  • LÖSCHEN: um Daten zu löschen.
  • Und ein paar andere fortgeschrittene 

FastAPI unterstützt alle http-Methoden. 

Die Tatsache, dass FastAPI auf Python-Typ-Hinweisen basiert, ist ein weiterer wichtiger Aspekt dieses Frameworks. Typ-Hinweise werden in Python 3.6 und höher unterstützt. Die Typ-Hinweise sind eine spezielle Art der Syntax, die es ermöglicht, den Typ einer Variablen zu deklarieren. 

Wenn du Typen für deine Variablen deklarierst, können dir Editoren und andere Tools bessere Unterstützung bieten. Schauen wir uns ein fortgeschrittenes Beispiel an.

Wir werden unsere Datei `main.py` ändern, um eine neue `PUT`-Anfrage einzufügen, die mehrere Eingaben unterschiedlicher Datentypen entgegennimmt. 

```

from typing import Union




from fastapi import FastAPI

from pydantic import BaseModel




app = FastAPI()




class Item(BaseModel):

    name: str

    price: float

    is_offer: Union[bool, None] = None




@app.get("")

def read_root():

    return {"Hello": "World"}




@app.get("/items/{item_id}")

def read_item(item_id: int, q: Union[str, None] = None):

    return {"item_id": item_id, "q": q}




@app.put("/items/{item_id}")

def update_item(item_id: int, item: Item):

    return {"item_name": item.name, "item_id": item_id}

```

(Das Beispiel stammt aus der Originaldokumentation). Danke an @tiangolo.

Die Veränderung:

Es wird eine Anfrage "put" hinzugefügt, die zwei Eingaben benötigt. item_id" ist eine ganze Zahl und der Typ "item" verweist auf die benutzerdefinierte Klasse "item", die von "pydantic" das "BaseModel" geerbt hat. Die Klasse `Item` enthält drei Attribute: `Name`, `Preis`, `Angebot`, und alle haben unterschiedliche Datentypen.

Die FastAPI prüft das: 

  • Name" ist ein "Str".
  • Preis" ist eine "Fließkommazahl".
  • is_offer" ist ein bool, falls vorhanden.

Der Vorteil der Verwendung von Typ-Hinweisen ist, dass du die Typen von Parametern, Körper usw. als Funktionsparameter mit Standard-Python (3.6+) einmal deklarierst. Du bekommst:

  • Editor-Unterstützung, einschließlich Autovervollständigung, Typüberprüfung
  • Datenvalidierung
  • Umwandlung von Eingabedaten
  • Konvertierung der Ausgabedaten
  • Fehler, die leicht zu verstehen sind.

Vergleich von FastAPI mit Django und Flask

Alle drei Frameworks sind Python-Webframeworks, die du für die Entwicklung von Webanwendungen nutzen kannst. Sie haben alle ihre eigenen Stärken und Schwächen.

Django ist ein voll funktionsfähiges Framework, das alles enthält, was du für den Einstieg brauchst, einschließlich eines eingebauten ORM und eines Admin-Panels. Für Anfänger kann es ein bisschen überwältigend sein, aber dank der umfassenden Dokumentation ist es leicht zu erlernen.

Flask ist ein Mikroframework, das leichtgewichtig ist und mit dem du einfach loslegen kannst. Es enthält nicht so viele Funktionen wie Django, ist aber perfekt für einfache Projekte.

FastAPI ist ein neues Framework, das schnell und einfach zu bedienen sein soll. Es enthält Funktionen wie automatische Datenvalidierung und Dokumentation. 

 

Django

Flachmann

FastAPI

Community

Big. 

66K GitHub-Sterne

Big. 

61K GitHub-Sterne

Big. 

50K GitHub-Sterne

Leistung

Django ist riesig. Es ist nicht das Beste, was die Leistung angeht.

Flask ist ein Mikro-Webframework. Es funktioniert besser als Django.

FastAPI ist eines der schnellsten Web-Frameworks mit nativer asynchroner Unterstützung, die zur Effizienz des Frameworks beiträgt. 

Async-Unterstützung

Ja, mit begrenzter Latenzzeit.

Nein. 

Braucht Asyncio

FastAPI bietet native async-Unterstützung.

Einfachheit der Nutzung

Django ist sehr umfangreich und daher ein bisschen kompliziert zu lernen.

Flask ist einfach zu erlernen und ziemlich unkompliziert in der Anwendung.

FastAPI ist die einfachste von allen dreien.

Interaktive Dokumentation

Nicht interaktiv

Nein

Ja (OpenAI, Redoc)

Datenüberprüfung

Nein

Nein

Ja


FastAPI Leistungsvergleiche

Nach den Ergebnissen der von techempower durchgeführten Tests ist FastAPI allen anderen Frameworks in Bezug auf die Gesamtleistung überlegen. 

API-Leistungsbenchmarks

Source: https://www.techempower.com/benchmarks/

Beispiel: Aufbau einer End-to-End-Pipeline für maschinelles Lernen mit PyCaret und Bereitstellung mit FastAPI 

In diesem Abschnitt werden wir schnell eine Pipeline für maschinelles Lernen aufbauen und dann eine API erstellen, um das Modell zu bedienen. Wir werden die Python-Bibliothek PyCaret verwenden, um eine Pipeline zu erstellen und eine API zu entwickeln. PyCaret verfügt über eine Integration mit FastAPI, die es extrem einfach macht, Machine Learning-Modelle als API zu erstellen und bereitzustellen.

PyCaret

PyCaret ist eine Open-Source-Bibliothek für maschinelles Lernen in Python, die Workflows für maschinelles Lernen automatisiert. Es ist ein End-to-End-Tool für maschinelles Lernen und Modellmanagement, das den Experimentierzyklus exponentiell beschleunigt und dich produktiver macht.

```

pip install pycaret

```




```

import pycaret

pycaret.__version__

>>> 2.3.10

```

In diesem Beispiel werden wir den Datensatz "Versicherungen" verwenden. Es handelt sich um einen Regressionsanwendungsfall zur Vorhersage von medizinischen Kosten auf der Grundlage von Alter, Geschlecht, BMI und Region. 

```

from pycaret.datasets import get_data

data = get_data(‘insurance’)

```

Beispiel-Datensatz

Bild vom Autor

Als Nächstes werden wir die Funktion `setup` von pycaret initialisieren. Diese Funktion initialisiert das Experiment in PyCaret und erstellt die Transformationspipeline basierend auf allen in der Funktion übergebenen Parametern. 

Die Funktion `setup` muss vor allen anderen Funktionen ausgeführt werden. Sie benötigt zwei Parameter, um zu funktionieren: "Daten" und "Ziel". Alle anderen Argumente in `setup` sind optional. Die Funktion `setup` ist für die Steuerung der gesamten Datenvorverarbeitung zuständig. In der PyCaret-Dokumentation findest du eine umfassende Übersicht über alle Vorverarbeitungsprozesse, die in PyCaret unterstützt werden.

```

from pycaret.regression import *

s = setup(data, target = 'charges')

```

Ausgabe der Setup-Funktion von PyCaret

Bild vom Autor Ausgabe gekürzt.

Sobald die Einrichtung abgeschlossen ist, können wir mit nur einer Zeile Code mit dem Training und der Auswahl der Modelle beginnen: `compare_models`. Mit Hilfe der Kreuzvalidierung trainiert und bewertet diese Funktion die Modellleistung aller Schätzer in der Modellbibliothek. Das Ergebnis dieser Funktion ist ein Bewertungsraster, das die durchschnittliche Punktzahl aus der Kreuzvalidierung enthält.

Preprocessing für maschinelles Lernen in Python

Willst du mehr darüber erfahren, wie du deine bereinigten Daten für die Modellierung bereit machst? Besuche unseren Kurs Preprocessing for Machine Learning in Python.

Jetzt loslegen
```

best = compare_models()

```

Ausgabe der Funktion compare_models von PyCaret

Bild vom Autor

Das beste Modell ist der "Gradient Boosting Regressor". Wenn wir wollen, können wir das Modell mithilfe der Visualisierung analysieren und versuchen, die Leistung durch die Abstimmung der Hyperparameter oder die Zusammenstellung von Modellen zu verbessern, aber das werden wir in diesem Tutorial nicht tun. 

Wir werden direkt mit dem Aufbau der API des besten Modells beginnen, um mit FastAPI Vorhersagen in der Produktion zu erstellen. Vergiss nicht, dass PyCaret eine Integration mit FastAPI hat, so dass es mit der Funktion `create_api` automatisch eine REST-API aus dem Modell erstellen kann.

```

create_api (best, 'insurance_prediction_model')

```

API erfolgreich erstellt

Um diese API auszuführen, öffnest du die Eingabeaufforderung, navigierst zu dem Ordner, in dem sich dein Notebook befindet, und führst den folgenden Befehl aus: "Python insurance_prediction_model.py". 

Kommandozeile

Gehe zu `http://127.0.0.1:8000/docs` und du wirst die gleiche Benutzeroberfläche sehen, die du bereits in diesem Tutorial gesehen hast

API auf http:::127.0.0.1:8000:docs

Bild vom Autor

API auf http:::127.0.0.18000:docs

Bild vom Autor

Du kannst auch eine alternative interaktive Dokumentation sehen, indem du `http://127.0.0.1:8000/redoc'aufrufst.

API auf http:::127.0.0.1:8000:docs3

Bild vom Autor

Denke daran, dass sowohl die Standard- als auch die interaktive redoc-Dokumentation auf OpenAPI-Standards basieren. 

Wenn du die Datei sehen willst, die PyCaret erstellt hat, als du die Funktion `create_api` benutzt hast, kannst du die Datei im gleichen Ordner wie dein Notebook auschecken. Das sieht so aus:

```

import pandas as pd

from pycaret.regression import load_model, predict_model

from fastapi import FastAPI

import uvicorn




# Create the app

app = FastAPI()




# Load trained Pipeline

model = load_model('my_lr_api')




# Define predict function

@app.post('/predict')

def predict(age, sex, bmi, children, smoker, region):

    data = pd.DataFrame([[age, sex, bmi, children, smoker, region]])

    data.columns = ['age', 'sex', 'bmi', 'children', 'smoker', 'region']

    predictions = predict_model(model, data=data) 

    return {'prediction': list(predictions['Label'])}




if __name__ == '__main__':

    uvicorn.run(app, host='127.0.0.1', port=8000)




```

Fazit

In dem Artikel wurde die Idee der API diskutiert und warum sie verwendet werden. API ist in der modernen Architektur wichtig, weil sie es verschiedenen Softwareprogrammen ermöglicht, Daten und Funktionen gemeinsam zu nutzen. So können komplexe Systeme geschaffen werden, die zuverlässiger und leichter zu warten sind.

Dann tauchen wir tief in ein relativ neues Framework in Python namens FastAPI ein. FastAPI ist eine neuere API, die einfach zu bedienen und effizient sein soll. Es ist eine großartige Option für Entwickler, die schnell und einfach eine API erstellen wollen.

GitHub Sterngeschichte - erstellt mit star-history.com

GitHub Sterngeschichte - erstellt mit star-history.com

Wenn du außerdem lernen willst, wie du mit Flask eine einfache API aus einem Machine Learning-Modell in Python erstellst, dann schau dir das leicht verständliche Tutorial "Turning Machine Learning Models into APIs in Python" an.

FastAPI FAQs

Ist die FastAPI asynchron?

FastAPI unterstützt von Haus aus asynchronen Code mit den Python-Schlüsselwörtern async/await.

Ist FastAPI produktionsreif?

FastAPI ist vollständig produktionsreif und verfügt über eine hervorragende Dokumentation, Support und eine benutzerfreundliche Oberfläche.

Wie unterscheidet sich die FastAPI von Flask?

FastAPI unterstützt asynchrone Aufrufe. Es ist leichtgewichtig, schneller und einfacher zu erlernen als Flask. Sowohl Flask als auch FastAPI haben eine große Community.

Verfügt FastAPI auch über einen integrierten Entwicklungsserver?

Nein, FastAPI hat keinen eingebauten Entwicklungsserver. Dafür musst du `uvicorn` verwenden.

Wird FastAPI von Python 2 unterstützt?

Nein, FastAPI ist nur in Python 3.6+ verfügbar.

Ist FastAPI nur in Python verfügbar?

Ja

Ist FastAPI schneller als die Programmiersprache Go?

Nein. Laut techempower ist Golang Fiber die 50. schnellste API der Welt. FastAPI liegt auf Platz 183.

Ist FastAPI mit Pydantic kompatibel?

FastAPI ist vollständig kompatibel mit (und basiert auf) Pydantic.

Themen

Python-Kurse

Zertifizierung verfügbar

Kurs

Preprocessing für maschinelles Lernen in Python

4 hr
50.7K
Lerne, wie du deine Daten bereinigst und für das maschinelle Lernen vorbereitest!
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow