Днес ще се запознаем с FastAPI – модерна Python библиотека за изграждане на високопроизводителни RESTful API-та. Ще видим как с малко код можем бързо да създадем мощно API с автоматична документация, валидация на данните и асинхронна обработка на заявките. Ще разгледаме основните концепции на FastAPI и ще изградим цялостен пример за API на блог.

Какво е FastAPI?

FastAPI е web framework за създаване на API-та с Python 3.6+ на базата на стандартния тип подсказки. Той е създаден да бъде лесен за използване, бърз за кодиране и подходящ за продукция. FastAPI се възползва от новите възможности на Python като типовите анотации, за да предостави невероятни функционалности като автоматична документация, валидация на данните и сериализация.

Някои от основните предимства на FastAPI включват:

  • Изключително бърз, сравним с Node.js и Go, благодарение на асинхронното програмиране с asyncio и ASGI;
  • Интуитивно и лесно за използване API, базирано на стандартния Python тип подсказки;
  • Автоматична интерактивна документация с OpenAPI (Swagger) и ReDoc;
  • Вградена валидация на данните за заявките и отговорите с Pydantic;
  • Директна поддръжка на JSON (както и други формати);
  • Достъп до множество допълнителни пакети чрез Starlette – CORS, аутентикация, сесии, WebSockets и др.

Нека сега видим FastAPI в действие, като изградим просто API за блог.

Инсталация и настройка

Започваме с инсталацията на FastAPI и uvicorn (ASGI сървър) чрез pip:


# Install the dependencies
pip install fastapi uvicorn

След това създаваме нов Python файл, например main.py, и добавяме следния код:


from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Welcome to Python.bg!"}

Това е минималното приложение във FastAPI. Импортираме FastAPI, създаваме инстанция на app и дефинираме route / с GET метод, който връща JSON отговор.

Стартираме приложението с uvicorn:


# Run the application with reloading
uvicorn main:app --reload

Сега можем да отворим http://localhost:8000 в браузъра и да видим JSON отговора.

Автоматична документация

Едно от най-впечатляващите неща във FastAPI е автоматичната документация. Без никакви допълнителни усилия, FastAPI генерира пълна OpenAPI (Swagger) документация за нашето API. Можем да я разгледаме на http://localhost:8000/docs или http://localhost:8000/redoc.

Дефиниране на модели с Pydantic

Следващата стъпка е да дефинираме моделите от данни за нашето API, използвайки Pydantic. Pydantic ни позволява да създаваме класове за данни със строга типизация и валидация. Ето как можем да дефинираме модел за публикация в блога:


from pydantic import BaseModel

class Post(BaseModel):
    title: str
    content: str
    published: bool = True

Тук дефинираме клас Post, който наследява BaseModel на Pydantic. Описваме полетата title, content и published с техните типове. Pydantic автоматично ще се погрижи за валидацията и сериализацията на данните.

Създаване на API ендпойнти

Сега можем да дефинираме API ендпойнтите за нашия блог. Ще добавим CRUD (Create, Read, Update, Delete) операции за публикациите:


from typing import List

posts = []

@app.post("/posts/", response_model=Post)
def create_post(post: Post):
    posts.append(post)
    return post

@app.get("/posts/", response_model=List[Post])
def read_posts():
    return posts

@app.get("/posts/{post_id}", response_model=Post)
def read_post(post_id: int):
    return posts[post_id]

@app.put("/posts/{post_id}", response_model=Post)
def update_post(post_id: int, post: Post):
    posts[post_id] = post
    return post

@app.delete("/posts/{post_id}")
def delete_post(post_id: int):
    posts.pop(post_id)
    return {"message": "Post deleted"}

Тук дефинираме няколко route хендлъра с различни HTTP методи (POST, GET, PUT, DELETE) и URL шаблони. Използваме модела Post за валидиране на входните данни и генериране на отговорите. Параметърът response_model указва очаквания тип на отговора, което се използва за автоматичната документация и валидация.

Забележете как FastAPI автоматично преобразува Path параметри като {post_id} в съответния тип (int), и Body параметри като post в инстанция на Post модела. Всичко това става прозрачно, благодарение на интеграцията с Pydantic.

Асинхронни операции

Една от силните страни на FastAPI е вградената поддръжка на асинхронно програмиране. Можем лесно да направим route хендлърите асинхронни, като използваме ключовата дума async def вместо def:


@app.get("/posts/{post_id}", response_model=Post)
async def read_post(post_id: int):
    await some_async_operation()
    return posts[post_id]

FastAPI ще се погрижи да изпълни асинхронните функции ефективно, без да блокира обработката на други заявки. Това е особено полезно при операции, които отнемат време, като достъп до база данни или извикване на външни услуги.

Заключение

В тази статия разгледахме основите на създаването на RESTful API с FastAPI. Видяхме как с няколко прости декоратора можем да дефинираме API ендпойнти, да валидираме входните данни и да генерираме автоматична документация.

FastAPI предлага още много възможности, които не можахме да покрием тук – dependency injection, middleware, background tasks, тестване, сигурност и др. Насърчавам ви да разгледате официалната документация и да експериментирате с различните функционалности.

Помнете, че добрата архитектура на API-то е ключова за дългосрочния успех на всеки уеб проект. Инвестирайте време в планирането на ясни и интуитивни ендпойнти, използвайте подходящи HTTP методи и кодове на състоянието, следвайте добрите практики за именуване и структуриране. И не на последно място – тествайте щателно API-то си, за да осигурите надеждност и стабилност.

Надявам се този урок да ви е дал добра отправна точка за изграждане на RESTful API-та с FastAPI.

Категории:

FastAPI, Уеб разработка,

Последно обновяване: май 3, 2024