[PYTHON] FastAPI Tutorial Memo Teil 1

Einführung

FastAPI Souce: https://github.com/tiangolo/fastapi FastAPI Document: https://fastapi.tiangolo.com

Intro & First Step Hinweise zum FastAPI-Tutorial. Grundsätzlich beziehe ich mich auf das offizielle Tutorial von Fast API, aber ich lasse einige Teile weg oder ändere die Reihenfolge für mein eigenes Lernen. Die korrekten und detaillierten Informationen finden Sie in der offiziellen Dokumentation.

Da ich ein Anfänger von Web & Python bin und mich bei der Übersetzung auf Google und DeepL verlasse, würde ich mich freuen, wenn Sie auf Fehler hinweisen könnten.

Entwicklungsumgebung

Ubuntu 20.04 LTS Python 3.8.2 pipenv 2018.11.26

Ziel

1. [FastAPI installieren](# FastAPI installieren)
2. [Server starten](# Server starten)
3. [Check Swagger UI](# Swagger-Check UI)
4. [Code prüfen](#Check Code)

Was ist FastAPI?

FastAPI ist ein schnelles, leichtes und modernes Webframework zum Erstellen von APIs basierend auf Python-Hinweisen. Es entspricht OpenAPI (Swagger), einem offenen API-Standard, und dem JSON-Schema. Bitte überprüfen Sie die offiziellen Dokumente für Details.

Verfahren

Schnelle API-Installation

Installieren Sie FastAPI mit pip. Sie können alle von der Fast-API verwendeten Abhängigkeiten und Funktionen mit dem folgenden Befehl installieren. Lassen Sie uns daher vorerst in der Entwicklungsumgebung mit diesem Befehl installieren. Sie können auch "uvicorn", das als Server verwendet wird, in einem Stapel installieren.

$ pip install fastapi[all]

████████████████████████████████████████ 100%

Lassen Sie es uns mit der interaktiven Shell von Python überprüfen.

$ python
Python 3.8.2 (default, Apr 21 2020, 18:13:10) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 
>>> from fastapi import FastAPI
>>> 

Wenn kein Fehler angezeigt wird, ist die Installation erfolgreich. Da ich pipenv in meiner Umgebung verwende, habe ich es mit "pipenv install fastapi [all]" installiert, aber es gibt bisher kein Problem.

Ich werde es hier weglassen, aber es ist auch möglich, fastapi und uvicorn separat zu installieren.

Starten Sie den Server

Nachdem Sie FastAPI installiert haben, starten wir den Server sofort.

Schreiben Sie zunächst einen einfachen Fast API-Code in die Datei main.py. (Der Code stammt im Wesentlichen aus dem offiziellen Dokument. Bitte überprüfen Sie Referenz.)

main.py

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hello World"}

Starten Sie den Server nach dem Speichern des Codes mit dem folgenden Befehl.

$ uvicorn main:app --reload

Wenn die folgende Anzeige ausgegeben wird, wird der Server ausgeführt.

INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: Started reloader process [28720]
INFO: Started server process [28722]
INFO: Waiting for application startup.
INFO: Application startup complete.

Die Ausgabe enthält eine Zeile mit der Aufschrift "INFO: Uvicorn läuft unter http://127.0.0.1:8000 (Drücken Sie STRG + C, um das Programm zu beenden)". Es scheint Ihnen die URL (http://127.0.0.1:8000) mitzuteilen, unter der die App auf Ihrem lokalen Computer ausgeführt wird und wie Sie den Server stoppen (Strg-Taste + C).

Lassen Sie uns sofort http://127.0.0.1:8000 im Browser anzeigen. Sie sollten den Rückgabewert der Funktion "root" in "main.py" sehen ("return {" message ":" Hello World "}").

Über uvicorn main: app --reload

• Beziehen Sie sich auf die Datei main.py (= Python-Modul) für main
• Der Dateiname kann frei eingestellt werden. Ändern wir es in "control.py" usw. In diesem Fall müssen Sie auch den Befehl ändern. --app bezieht sich auf das Objekt, das von app = FastAPI in der Datei main.py erstellt wurde ――Dies kann ebenso wie der Dateiname frei eingestellt werden. ---- reload ist eine Option, um den Server jedes Mal neu zu starten, wenn sich der Code ändert --Diese Option wird nur zur Verwendung in einer Entwicklungsumgebung empfohlen.

Überprüfen Sie die Swagger-Benutzeroberfläche

FastAPI ist OpenAPI-kompatibel und generiert automatisch eine interaktive API-Dokumentation mit Swagger UI. Besuchen Sie http://127.0.0.1:8000/docs, um dies zu überprüfen.

Sie können die Dokumentation auch von ReDoc unter http://127.0.0.1:8000/redoc überprüfen.

Überprüfen Sie den Code

Lassen Sie uns den Inhalt von main.py überprüfen. Dieser Code ist der Basiscode für die Fast API.

Schneller API-Import

Importieren Sie zunächst die FastAPI-Klasse. Diese FastAPI bietet alle Funktionen der von Ihnen erstellten API.

from fastapi import FastAPI

Instanz erstellen

Erstellen Sie als Nächstes eine Variable, die eine Instanz der Fast-API ist. Diese Variable ist die Entität der Fast API.

from fastapi import FastAPI

app = FastAPI()

Die hier erstellte Instanzvariable app entspricht der Option main: app des Befehls uvicorn. Wenn der Dateiname "control.py" und die Instanzvariable "my_instance = FastAPI ()" lautet, lautet der Befehl "uvicorn" wie folgt.

$ uvicorn control:my_instance --reload

INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

Erstellen einer Pfadoperation

** Pfad ** bezieht sich hier auf den Teil der URL, der mit / nach dem Domainnamen und dem Portnamen beginnt. Bei der URL "https: // example.com / items / foo" entspricht der Teil "/ items / foo" dem Pfad in der Fast-API.

Sie können sich auch vorstellen, dass Pfad dieselbe Bedeutung hat wie der allgemeine ** Endpunkt ** und die ** Route **. In FastAPI ist die Rolle von ** Pfad ** die "Trennung von" Bedenken "(Interesse) und" Ressource "(Ressource) bei der API-Erstellung". Bedeutet das, das Programm in interessierende Einheiten (Zweck, was Sie tun möchten) und Ressourcen (Ressourcen, was Sie verwenden) zu unterteilen? Bitte lassen Sie mich wissen, wenn Sie Details haben.

Außerdem ist die Pfadoperation ** Operation ** gleichbedeutend mit der HTTP-Methode. Die wichtigsten Methoden sind:

--POST: Daten erstellen --GET: Daten lesen --PUT: Datenaktualisierung --DELETE: Daten löschen

HTTP kann mit diesen Methoden mit jedem Pfad des Webservers kommunizieren. Beim Erstellen der API verwenden wir diese HTTP-Methoden, um bestimmte Aktionen auszuführen.

Die HTTP-Methode wird in OpenAPI als ** Operation ** bezeichnet, und der Begriff ** Operation ** wird in FastAPI entsprechend verwendet.

Definieren wir ** Pfadoperationsdekorator ** mithilfe von Instanzvariablen.

from fastapi import FastAPI

app = FastAPI()


@app.get("/")

Mit der Dekorationsfunktion "@ app.get (" / ")" kann die Fast-API die folgenden Anforderungen mithilfe der unmittelbar folgenden Funktion verarbeiten.

• ** Pfad ** ist / und -Verwenden Sie die Methode "get" für die ** Operation **

Weitere Informationen zu Dekorationsfunktionen finden Sie in anderen Artikeln. Hier wird der Fast API mitgeteilt, dass die Funktion direkt unter der Decorator-Funktion ** path/** entspricht. Eine solche Dekorationsfunktion wird auch als ** Pfadoperationsdekorator ** bezeichnet.

Sie können auch andere Operationen als "get" verwenden, wie unten gezeigt.

• @app.post()
• @app.put()
• @app.delete()

Definition der Pfadoperationsfunktion

Definieren Sie am Ende der Codeüberprüfung die Pfadmanipulationsfunktion und legen Sie den Rückgabewert fest.

Mit dem Pfadoperationsdekorator "@ app.get (" / ")" konnten wir eine HTTP-Anforderung als Ausgangspunkt für die Verarbeitung definieren. Definieren Sie als Nächstes die Funktion für die Verarbeitung direkt unter dem Dekorateur.

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():

Die hier verwendete Pfadmanipulationsfunktion (async def root ():) unterscheidet sich nicht von einer normalen Python-Funktion. Die Fast API ruft diese Funktion jedes Mal auf, wenn der Client eine Anfrage an URL/with getoperation sendet und der Server sie empfängt. (Ich wollte auch, dass diese Funktion aufgerufen wird, wenn ich auf http://127.0.0.1:8000 zugreife.)

Sie können auch reguläre Funktionen anstelle von "async def" definieren.

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def root():
    return {"message": "Hello World"}

Informationen zu "asynchron" (asynchrone Verarbeitung) finden Sie im offiziellen Dokument von hier.

Danach setzen Sie den Rückgabewert mit "return" und die Bestätigung des ersten Codes wird abgeschlossen.

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hello World"}

In Bezug auf den Rückgabewert können Sie den Rückgabewert mit Typen wie "dict" und "list" für mehrere Werte und "str" und "int" für einzelne Werte festlegen. Alternativ ist es möglich, ein "Pydantic" -Modell zurückzugeben. Darüber hinaus gibt es viele Objekte und Modelle (einschließlich ORM), die automatisch in JSON konvertiert werden. Bitte probieren Sie es aus.

Zum Schluss noch zu OpenAPI

Diesmal unter den offiziellen Fast API-Tutorials Intro und First Steps Ich habe es aufgehoben. Schauen wir uns zum Schluss die Open API und das Schema an.

Was ist Open API?

Open API ist ein Format zum Schreiben der REST-API, und Swagger ist ein Open Source-Toolset, das beim Schreiben der Open API verwendet wird. Es wurde im folgenden Artikel kurz zusammengefasst.

• OpenAPI (Swagger) Super Introduction
• What Is OpenAPI?

In FastAPI sind API-Definitionen OpenAPI-kompatibel und alle APIs generieren ein "Schema".

Was ist ein Schema?

Ein "Schema" ist eine Definition oder Beschreibung. Es bezieht sich auf ein abstraktes Konzept, nicht implementierten Code.

API-Schema

Bei der Betrachtung des "Schemas" in einer API ist OpenAPI eine Spezifikation, die angibt, wie das Schema der erstellten API definiert wird.

Diese Schemadefinition enthält den Pfad zur API und die Parameter, die die API möglicherweise erhält.

Datenschema

Das Wort "Schema" kann sich auch auf irgendeine Form von Daten beziehen, beispielsweise auf JSON-Inhalte.

In diesem Fall bedeutet dies die Attribute von JSON und die Datentypen, die sie haben.

Beziehung zwischen OpenAPI- und JSON-Schema

OpenAPI definiert das "API-Schema" der erstellten API, das das "JSON-Schema" verwendet, das der Standard des JSON-Datenschemas ist, um die von der API gesendeten und empfangenen Daten (oder andere "Schemata") zu definieren. Es beinhaltet.

FastAPI verwendet das OpenAPI-Schema, um zwei Arten interaktiver Dokumentensysteme auszuführen (Swagger UI, ReDoc).

Referenz

FastAPI Official Tutorial Intro Erste Schritte zum offiziellen FastAPI-Tutorial