FastAPI

FastAPI keretrendszer, nagy teljesítmény, könnyen tanulható, gyorsan kódolható, productionre kész

Dokumentáció: https://fastapi.tiangolo.com

Forrás kód: https://github.com/fastapi/fastapi

A FastAPI egy modern, gyors (nagy teljesítményű), webes keretrendszer API-ok építéséhez Python -al, a Python szabványos típusjelöléseire építve.

Kulcs funkciók:

Gyors: Nagyon nagy teljesítmény, a NodeJS-el és a Go-val egyenrangú (a Starlettenek és a Pydantic-nek köszönhetően). Az egyik leggyorsabb Python keretrendszer.
Gyorsan kódolható: A funkciók fejlesztési sebességét 200-300 százalékkal megnöveli. *
Kevesebb hiba: Körülbelül 40%-al csökkenti az emberi (fejlesztői) hibák számát. *
Intuitív: Kiváló szerkesztő támogatás. Kiegészítés mindenhol. Kevesebb hibakereséssel töltött idő.
Egyszerű: Egyszerű tanulásra és használatra tervezve. Kevesebb dokumentáció olvasással töltött idő.
Rövid: Kód duplikáció minimalizálása. Több funkció minden paraméter deklarálásával. Kevesebb hiba.
Robosztus: Production ready kód. Automatikus interaktív dokumentáció val.
Szabvány alapú: Az API-ok nyílt szabványaira alapuló (és azokkal teljesen kompatibilis): OpenAPI (korábban Swagger néven ismert) és a JSON Schema.

* Egy production alkalmazásokat építő belső fejlesztői csapat tesztjein alapuló becslés.

Szponzorok¶

További szponzorok

Vélemények¶

"[...] I'm using FastAPI a ton these days. [...] I'm actually planning to use it for all of my team's ML services at Microsoft. Some of them are getting integrated into the core Windows product and some Office products."

Kabir Khan - Microsoft (ref)

"We adopted the FastAPI library to spawn a REST server that can be queried to obtain predictions. [for Ludwig]"

Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - Uber (ref)

"Netflix is pleased to announce the open-source release of our crisis management orchestration framework: Dispatch! [built with FastAPI]"

Kevin Glisson, Marc Vilanova, Forest Monsen - Netflix (ref)

"I’m over the moon excited about FastAPI. It’s so fun!"

Brian Okken - Python Bytes podcast host (ref)

"Honestly, what you've built looks super solid and polished. In many ways, it's what I wanted Hug to be - it's really inspiring to see someone build that."

Timothy Crosley - Hug creator (ref)

"If you're looking to learn one modern framework for building REST APIs, check out FastAPI [...] It's fast, easy to use and easy to learn [...]"

"We've switched over to FastAPI for our APIs [...] I think you'll like it [...]"

Ines Montani - Matthew Honnibal - Explosion AI founders - spaCy creators (ref) - (ref)

"If anyone is looking to build a production Python API, I would highly recommend FastAPI. It is beautifully designed, simple to use and highly scalable, it has become a key component in our API first development strategy and is driving many automations and services such as our Virtual TAC Engineer."

Deon Pillsbury - Cisco (ref)

Typer, a CLI-ok FastAPI-ja¶

Ha egy olyan CLI alkalmazást fejlesztesz amit a parancssorban kell használni webes API helyett, tekintsd meg: Typer.

Typer a FastAPI kistestvére. A CLI-k FastAPI-ja. ⌨️ 🚀

Követelmények¶

A FastAPI óriások vállán áll:

Starlette a webes részekhez.
Pydantic az adat részekhez.

Telepítés¶

$ pip install fastapi

---> 100%

A production-höz egy ASGI szerverre is szükség lesz, mint például az Uvicorn vagy a Hypercorn.

$ pip install "uvicorn[standard]"

---> 100%

Példa¶

Hozd létre¶

Hozz létre a main.py fájlt a következő tartalommal:

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}

Vagy használd az async def-et...

Ha a kódod async / await-et, használ async def:

from typing import Union

from fastapi import FastAPI

app = FastAPI()


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


@app.get("/items/{item_id}")
async def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}

Megjegyzés:

Ha nem tudod, tekintsd meg a "Sietsz?" szekciót async és await-ről dokumentációba.

Futtasd le¶

Indítsd el a szervert a következő paranccsal:

$ uvicorn main:app --reload

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.

A parancsról uvicorn main:app --reload...

A uvicorn main:app parancs a következőre utal:

main: fájl main.py (a Python "modul").
app: a main.py-ban a app = FastAPI() sorral létrehozott objektum.
--reload: kód változtatás esetén újra indítja a szervert. Csak fejlesztés közben használandó.

Ellenőrizd¶

Nyisd meg a böngésződ a következő címen: http://127.0.0.1:8000/items/5?q=somequery.

A következő JSON választ fogod látni:

{"item_id": 5, "q": "somequery"}

Máris létrehoztál egy API-t ami:

HTTP kéréseket fogad a / és /items/{item_id} útvonalakon.
Mindkét útvonal a GET műveletet használja (másik elnevezés: HTTP metódus).
A /items/{item_id} útvonalnak van egy path paramétere, az item_id, aminek int típusúnak kell lennie.
A /items/{item_id} útvonalnak még van egy opcionális, str típusú query paramétere is, a q.

Interaktív API dokumentáció¶

Most nyisd meg a http://127.0.0.1:8000/docs címet.

Az automatikus interaktív API dokumentációt fogod látni (amit a Swagger UI-al hozunk létre):

Swagger UI

Alternatív API dokumentáció¶

És most menj el a http://127.0.0.1:8000/redoc címre.

Az alternatív automatikus dokumentációt fogod látni. (lásd ReDoc):

ReDoc

Példa frissítése¶

Módosítsuk a main.py fájlt, hogy PUT kérések esetén tudjon body-t fogadni.

Deklaráld a body-t standard Python típusokkal, a Pydantic-nak köszönhetően.

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}

A szerver automatikusan újraindul (mert hozzáadtuk a --reload paramétert a fenti uvicorn parancshoz).

Interaktív API dokumentáció frissítése¶

Most menj el a http://127.0.0.1:8000/docs címre.

Az interaktív API dokumentáció automatikusan frissült így már benne van az új body.

Swagger UI

Kattints rá a "Try it out" gombra, ennek segítségével kitöltheted a paramétereket és közvetlen használhatod az API-t:

Swagger UI interaction

Ezután kattints az "Execute" gompra, a felhasználói felület kommunikálni fog az API-oddal. Elküldi a paramétereket és a visszakapott választ megmutatja a képernyődön.

Swagger UI interaction

Alternatív API dokumentáció frissítés¶

Most menj el a http://127.0.0.1:8000/redoc címre.

Az alternatív dokumentáció szintúgy tükrözni fogja az új kérési paraméter és body-t.

ReDoc

Összefoglalás¶

Összegzésül, deklarálod egyszer a paraméterek, body, stb típusát funkciós paraméterekként.

Ezt standard modern Python típusokkal csinálod.

Nem kell új szintaxist, vagy specifikus könyvtár mert metódósait, stb. megtanulnod.

Csak standard Python.

Például egy int-nek:

item_id: int

Egy komplexebb Item modellnek:

item: Item

... És csupán egy deklarációval megkapod a:

Szerkesztő támogatást, beleértve:
- Szövegkiegészítés.
- Típus ellenőrzés.
Adatok validációja:
- Automatikus és érthető hibák amikor az adatok hibásak.
- Validáció mélyen ágyazott objektumok esetén is.
Bemeneti adatok átváltása : a hálózatról érkező Python adatokká és típusokká. Adatok olvasása következő forrásokból:
- JSON.
- Cím paraméterek.
- Query paraméterek.
- Cookie-k.
- Header-ök.
- Formok.
- Fájlok.
Kimeneti adatok átváltása: Python adatok is típusokról hálózati adatokká:
- válts át Python típusokat (str, int, float, bool, list, etc).
- datetime csak objektumokat.
- UUID objektumokat.
- Adatbázis modelleket.
- ...És sok mást.
Automatikus interaktív dokumentáció, beleértve két alternatív dokumentációt is:
- Swagger UI.
- ReDoc.

Visszatérve az előző kód példához. A FastAPI:

Validálja hogy van egy item_id mező a GET és PUT kérésekben.
Validálja hogy az item_id int típusú a GET és PUT kérésekben.
- Ha nem akkor látni fogunk egy tiszta hibát ezzel kapcsolatban.
ellenőrzi hogyha van egy opcionális query paraméter q névvel (azaz http://127.0.0.1:8000/items/foo?q=somequery) GET kérések esetén.
- Mivel a q paraméter = None-al van deklarálva, ezért opcionális.
- None nélkül ez a mező kötelező lenne (mint például a body PUT kérések esetén).
a /items/{item_id} címre érkező PUT kérések esetén, a JSON-t a következőképpen olvassa be:
- Ellenőrzi hogy létezik a kötelező name nevű attribútum és string.
- Ellenőrzi hogy létezik a kötelező price nevű attribútum és float.
- Ellenőrzi hogy létezik a is_offer nevű opcionális paraméter, ami ha létezik akkor bool
- Ez ágyazott JSON objektumokkal is működik
JSONről való automatikus konvertálás.
dokumentáljuk mindent OpenAPI-al amit használható:
- Interaktív dokumentációs rendszerekkel.
- Automatikus kliens kód generáló a rendszerekkel, több nyelven.
Hozzá tartozik kettő interaktív dokumentációs web felület.

Eddig csak a felszínt kapargattuk, de a lényeg hogy most már könnyebben érthető hogyan működik.

Próbáld kicserélni a következő sorban:

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

...ezt:

        ... "item_name": item.name ...

...erre:

        ... "item_price": item.price ...

... És figyeld meg hogy a szerkesztő automatikusan tudni fogja a típusokat és kiegészíti azokat:

editor support

Teljesebb példákért és funkciókért tekintsd meg a Tutorial - User Guide -t.

Spoiler veszély: a Tutorial - User Guidehoz tartozik:

Paraméterek deklarációja különböző helyekről: header-ök, cookie-k, form mezők és fájlok.
Hogyan állíts be validációs feltételeket mint a maximum_length vagy a regex.
Nagyon hatékony és erős Függőség Injekció rendszerek.
Biztonság és autentikáció beleértve, OAuth2, JWT tokens és HTTP Basic támogatást.
Több haladó (de ugyanannyira könnyű) technika mélyen ágyazott JSON modellek deklarációjára (Pydantic-nek köszönhetően).
GraphQL integráció Strawberry-vel és más könyvtárakkal.
több extra funkció (Starlette-nek köszönhetően) pl.:
- WebSockets
- rendkívül könnyű tesztek HTTPX és pytest alapokra építve
- CORS
- Cookie Sessions
- ...és több.

Teljesítmény¶

A független TechEmpower benchmarkok szerint az Uvicorn alatt futó FastAPI alkalmazások az egyik leggyorsabb Python keretrendszerek közé tartoznak, éppen lemaradva a Starlette és az Uvicorn (melyeket a FastAPI belsőleg használ) mögött.(*)

Ezeknek a további megértéséhez: Benchmarks.

Opcionális követelmények¶

Pydantic által használt:

email-validator - e-mail validációkra.
pydantic-settings - Beállítások követésére.
pydantic-extra-types - Extra típusok Pydantic-hoz.

Starlette által használt:

httpx - Követelmény ha a TestClient-et akarod használni.
jinja2 - Követelmény ha az alap template konfigurációt akarod használni.
python-multipart - Követelmény ha "parsing"-ot akarsz támogatni, request.form()-al.
itsdangerous - Követelmény SessionMiddleware támogatáshoz.
pyyaml - Követelmény a Starlette SchemaGenerator-ának támogatásához (valószínűleg erre nincs szükség FastAPI használása esetén).

FastAPI / Starlette által használt

uvicorn - Szerverekhez amíg betöltik és szolgáltatják az applikációdat.
orjson - Követelmény ha ORJSONResponse-t akarsz használni.
ujson - Követelmény ha UJSONResponse-t akarsz használni.

Ezeket mind telepítheted a pip install "fastapi[all]" paranccsal.

Licensz¶

Ez a projekt az MIT license, licensz alatt fut