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](#performance).
* **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
{% if sponsors %}
{% for sponsor in sponsors.gold -%}
{% endfor -%}
{%- for sponsor in sponsors.silver -%}
{% endfor %}
{% endif %}
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)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Deon Pillsbury -
Cisco (ref)
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
```console
$ 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.
```console
$ pip install "uvicorn[standard]"
---> 100%
```
## Példa
### Hozd létre
* Hozz létre a `main.py` fájlt a következő tartalommal:
```Python
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`:
```Python hl_lines="9 14"
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:
```console
$ 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:
```JSON
{"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):
### 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):
## 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.
```Python hl_lines="4 9-12 25-27"
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.
* 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:
* 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.
### 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.
### Ö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:
```Python
item_id: int
```
Egy komplexebb `Item` modellnek:
```Python
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:
```Python
return {"item_name": item.name, "item_id": item_id}
```
...ezt:
```Python
... "item_name": item.name ...
```
...erre:
```Python
... "item_price": item.price ...
```
... És figyeld meg hogy a szerkesztő automatikusan tudni fogja a típusokat és kiegészíti azokat:
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