FastAPI в Python

Конечно, FastAPI - не единственный игрок на поле боя. Flask и Django уже много лет являются предпочтительными вариантами веб-разработки на Python. Но уникальное сочетание скорости, простоты использования и готовых функций FastAPI начинает привлекать внимание.

Это руководство должно послужить вам отправной точкой для знакомства с миром FastAPI. Здесь мы отправим вас в путешествие по пониманию FastAPI от основ, через более сложные темы, к лучшим практикам.

Установка и настройка

Для работы с FastAPI вам сначала понадобится функционирующая среда Python. Если вы еще этого не сделали, скачайте и установите последнюю версию Python с официального сайта. На момент написания этой статьи рекомендуется использовать Python версии 3.9 или новее, чтобы пользоваться всеми преимуществами, которые может предложить FastAPI.

FastAPI доступен в Python Package Index (PyPI) и может быть установлен с помощью pip, менеджера пакетов Python по умолчанию. Вам также следует установить uvicorn, ASGI-сервер, для обслуживания вашего приложения FastAPI:

$ pip install fastapi
$ pip install uvicorn

Настройка нового проекта FastAPI

Как только FastAPI a когда uvicorn установлен, вы готовы приступить к своему новому проекту FastAPI. Начните с создания нового каталога для вашего проекта:

$ mkdir fastapi-project
$ cd fastapi-project

В каталоге проекта создайте новый файл Python, например main. py. Это послужит точкой входа для вашего приложения FastAPI. Вот самое простое из возможных приложений FastAPI:

from fastapi import FastAPI

app = FastAPI()

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

Этот скрипт создает новое приложение FastAPI и определяет единственный маршрут, /, который принимает запросы GET и возвращает простой ответ в формате JSON.

Запуск вашего приложения FastAPI

Чтобы запустить ваше приложение FastAPI, используйте команду uvicorn, за которой следует имя вашего модуля (файл Python без расширения. py) и переменная, которая является вашим приложением FastAPI:

Флаг --reload включает горячую перезагрузку, что означает, что сервер будет автоматически обновляться всякий раз, когда вы вносите изменения в свои файлы Python.

Перейдя по ссылке http://localhost:8000 в вашем веб-браузере, вы должны увидеть ответ в формате JSON от вашего приложения FastAPI: {"Hello": "World"}.

Краткий обзор приложения FastAPI

Тот main. py созданный вами файл является ядром вашего приложения FastAPI. По мере роста вашего приложения вы будете добавлять больше функций маршрутизации в этот файл (или в другие модули), каждая из которых определяет другую конечную точку вашего API. Функции маршрутизации могут принимать параметры, тела запросов и возвращать множество различных ответов.

В следующем разделе мы рассмотрим основы FastAPI, такие как определение конечных точек и работа с различными типами запросов и ответов.

Основы FastAPI

FastAPI использует простой, но мощный подход к созданию API-интерфейсов. В основе этого подхода лежат аннотации типов Python, которые позволяют FastAPI автоматически обрабатывать большую часть проверки, сериализации и документации для вашего API.

Определение конечных точек

В FastAPI конечная точка определяется как функция Python, оформленная с помощью route decorato r. Декоратор маршрута, такой как @app. get(), указывает HTTP-метод и путь для конечной точки:

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

Это определяет конечную точку GET по пути /items/{item_id}, где {item_id} - параметр пути. Функция read_item() будет вызываться всякий раз, когда будет сделан запрос к этой конечной точке.

Параметры пути и параметры запроса

В предыдущем примере параметр пути item_id автоматически интерпретируется как целое число из-за аннотации типа : int. FastAPI проверит, что этот параметр является целым числом, и преобразует его из строки перед передачей в вашу функцию.

Параметры запроса определяются как параметры функции. Например, чтобы добавить параметр запроса q, вы могли бы изменить функцию read_item() следующим образом:

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

Здесь q - необязательный параметр запроса измеритель, со значением по умолчанию None.

Тело запроса

Чтобы определить конечную точку POST, которая принимает тело запроса (body), вы можете использовать модели Pydantic. Модель Pydantic - это класс Python, который расширяет pydantic. BaseModel и определяет набор атрибутов, каждый из которых имеет аннотацию типа:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

@app.post("/items/")
def create_item(item: Item):
    return item

В этом примере функция create_item() принимает один параметр item, который, как ожидается, будет экземпляром модели Item. FastAPI автоматически проверит тело запроса, чтобы убедиться, что оно соответствует модели, преобразует JSON в экземпляр Item и передаст этот экземпляр вашей функции.

Тело ответа

В FastAPI возвращаемое значение функции route автоматически преобразуется в JSON и возвращается в виде тела HTTP-ответа. Вы можете возвращать практически любой тип значений, включая Pydantic модели, списки, словари, и т. д. :

@app.get("/ping")
def ping():
    return "pong"

Здесь строка "pong" будет возвращена в качестве ответа JSON ("pong").

Эти примеры кода должны помочь вам понять основы FastAPI. По мере прочтения статьи вы сможете применять эти принципы к более сложным примерам и вашим собственным приложениям FastAPI. В следующем разделе мы рассмотрим расширенные разделы FastAPI, включая обработку ошибок, внедрение зависимостей, безопасность и многое другое.

Расширенные темы в FastAPI

Несмотря на то, что FastAPI прост в освоении и работе с ним, он также обладает множеством расширенных функций, которые делают его мощным и гибким. В этом разделе мы обсудим некоторые из этих сложных тем.

Использование моделей Pydantic для проверки и сериализации данных

FastAPI в значительной степени полагается на модели Pydantic не только для проверки текстов запросов, но и для проверки данных ответа, параметров запроса, параметров пути и многого другого. Использование Pydantic аннотаций типов Python делает проверку данных простой, понятной и эффективной как понять:

from pydantic import BaseModel, Field

class Item(BaseModel):
    name: str = Field(..., example="Foo")
    description: str = Field(None, example="A very nice Item")
    price: float = Field(..., example=35.4)
    tax: float = Field(None, example=3.2)

@app.post("/items/")
def create_item(item: Item):
    return item

Функция Field используется для добавления дополнительной проверки к полям модели Pydantic и предоставления примеров значений.

Обработка ошибок и исключений

FastAPI предоставляет способ унифицированной обработки ошибок и исключений. Вы можете использовать HttpException для возврата ответов об ошибках HTTP:

from fastapi import HTTPException

@app.get("/items/{item_id}")
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return {"item_id": item_id}

Внедрение зависимостей

FastAPI имеет простую, но мощную систему внедрения зависимостей. Он основан на аннотациях типов Python и не требует какой-либо сложной конфигурации:

from fastapi import Depends

def get_db():
    db = ...
    try:
        yield db
    finally:
        db.close()

@app.get("/items/{item_id}")
def read_item(item_id: int, db = Depends(get_db)):
    item = db.get(item_id)
    return item

Безопасность и аутентификация

FastAPI предоставляет несколько встроенных инструментов безопасности, таких как OAuth2 с токенами JWT и хэшированием:

from fastapi import Depends, FastAPI, HTTPException
from fastapi.security import OAuth2PasswordBearer

app = FastAPI()

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.get("/items/{item_id}")
async def read_item(token: str = Depends(oauth2_scheme)):
    return {"token": token}

В этом примере класс OAuth2PasswordBearer используется для обработки OAuth2. Конечная точка /items/{item_id} требует повторно введите заголовок авторизации с помощью токена на предъявителя.

Интеграция с базами данных

FastAPI не диктует, какую базу данных вы должны использовать, и может использоваться с любым ORM или клиентом базы данных:

from fastapi import Depends, FastAPI
from sqlalchemy.orm import Session

from . import crud, models, schemas
from .database import SessionLocal, engine

app = FastAPI()

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.post("/users/", response_model=schemas.User)
def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
    db_user = crud.get_user_by_email(db, email=user.email)
    ...

В этом примере используется SQLAlchemy для взаимодействия с базой данных. Зависимость get_db предоставляет сеанс базы данных для каждого запроса и закрывает его по завершении запроса.

Модульное тестирование в FastAPI

Приложения FastAPI можно легко протестировать с помощью TestClient из fastapi. testclient:

from fastapi.testclient import TestClient

def test_read_item():
    client = TestClient(app)
    response = client.get("/items/42")
    assert response.status_code == 200
    assert response.json() == {"item_id": 42}

Это базовый тест, который отправляет запрос GET к конечной точке /items/42 и утверждает, что код состояния ответа равен 200, а тело ответа - {"item_id": 42}.

В следующем разделе мы применим эти концепции к реальному приложению, шаг за шагом показывая вам, как создать базовое CRUD-приложение с помощью FastAPI.

Применение в реальном мире

В этом разделе мы будем использовать все концепции, которые мы изучили до сих пор, для создания реального приложения: CRUD (Создание, чтение, обновление, удаление) API для гипотетического книжного магазина. Это приложение позволит нам создавать, извлекать, обновлять и удалять книги из инвентаря магазина.

Шаг 1 - Настройка Вашего проекта

Прежде чем мы начнем, убедитесь, что ваш проект настроен правильно. Убедитесь, что у вас установлены FastAPI и Uvicorn, и создайте новый каталог проекта, если вы еще этого не сделали.

Шаг 2 - Определение модели данных

Мы начнем с определения данных модель для книг в нашем магазине. Для этого мы будем использовать класс BaseModel от Pydantic. из базовой модели импорта pydantic учебное пособие (базовая модель):

from pydantic import BaseModel

class Book(BaseModel):
    name: str
    author: str
    isbn: str

Шаг 3 - Настройка базы данных в памяти

Далее, давайте настроим базу данных в памяти для нашего API. Мы будем использовать простой словарь Python для хранения наших данных:

books_db = {}

Примечание: В реальном приложении вы, скорее всего, использовали бы здесь соответствующую базу данных.

Шаг 4 - Определение конечных точек API

Теперь мы можем определить конечные точки для нашего API.

Чтобы создать книгу, нам понадобится конечная точка POST в path /books:

@app.post("/books/")
def create_book(book: Book):
    if book.isbn in books_db:
        raise HTTPException(status_code=400, detail="ISBN already exists")
    books_db[book.isbn] = book.dict()
    return books_db[book.isbn]

Чтобы получить книгу, нам понадобится конечная точка GET по пути /books/{isbn}:

@app.get("/books/{isbn}")
def read_book(isbn: str):
    if isbn not in books_db:
        raise HTTPException(status_code=404, detail="Book not found")
    return books_db[isbn]

Нам понадобится конечная точка PUT по пути /books/{isbn}, чтобы обновить книгу:

@app.put("/books/{isbn}")
def update_book(isbn: str, book: Book):
    if isbn not in books_db:
        raise HTTPException(status_code=404, detail="Book not found")
    books_db[isbn] = book.dict()
    return books_db[isbn]

Чтобы удалить книгу, нам понадобится конечная точка УДАЛЕНИЯ по пути /books/{isbn}.

@app.delete("/books/{isbn}")
def delete_book(isbn: str):
    if isbn not in books_db:
        raise HTTPException(status_code=404, detail="Book not found")
    del books_db[isbn]
    return {"message": "Book deleted successfully!"}

Используя FastAPI, вы создали CRUD API в кратчайшие сроки. Теперь у вас есть работающее приложение который готов к развертыванию и использованию.

Экосистема FastAPI

В дополнение к самому FastAPI, существует ряд других инструментов и библиотек, которые могут улучшить ваши приложения FastAPI и сделать их более мощными и гибкими.

SQLModel

SQLModel - это библиотека для взаимодействия с базами данных SQL с использованием моделей Python. Он построен поверх SQLAlchemy и Pydantic и предназначен для хорошей работы с FastAPI. Если ваше приложение использует базу данных SQL, SQLModel может упростить определение ваших моделей данных и выполнение операций с базой данных.

Пользователи FastAPI

Пользователи FastAPI - это библиотека, которая предоставляет общие функции управления пользователями для приложений FastAPI, такие как регистрация пользователя, логин, сброс пароля и проверка электронной почты. Он поддерживает различные методы аутентификации, включая JWT, OAuth2 и HTTP Basic Auth.

Разрешения FastAPI

Разрешения FastAPI - это простая и эффективная библиотека для управления разрешениями и ролями в приложении FastAPI. Это позволяет вам определять разрешения декларативным способом. nd автоматически проверяет их для каждого запроса.

Утилиты FastAPI

FastAPI Utils - это набор утилит для приложений FastAPI. Он включает в себя помощники для разбивки на страницы, идентификаторы запросов, ответы, базы данных и многое другое.

Typer

Наборщик Typer - это библиотека для создания приложений командной строки, созданная тем же автором, что и FastAPI. Он использует те же принципы, что и FastAPI, и разработан таким образом, чтобы быть простым в использовании и написанным на языке Python. Если вашему приложению FastAPI требуется интерфейс командной строки, Typer может стать отличным выбором.

Starlette

FastAPI построен поверх Starlette, облегченного фреймворка ASGI. В то время как FastAPI предоставляет высокоуровневый API для создания веб-приложений, Starlette предоставляет базовые инструменты для обработки HTTP-запросов и ответов, маршрутизации, веб-сокетов и многого другого. Понимание Starlette может дать вам более глубокое представление о FastAPI и о том, как он работает.

Все эти инструменты и библиотеки могут улучшить ваши приложения FastAPI и сделать их более мощными, гибкими и надежными. Благодаря пониманию экономики FastAPI таким образом, вы можете максимально использовать FastAPI и все, что он может предложить.

Вывод

В этом вводном руководстве мы совершили путешествие по миру FastAPI, начав с базовых концепций, углубившись в более сложные темы и, наконец, создав реальное приложение. FastAPI, с его скоростью, простотой и многофункциональностью, предлагает отличный выбор для разработки современных веб-приложений. Мы изучили возможности моделей Pydantic, простоту определения конечных точек, преимущества автоматической проверки данных и простоту обработки ошибок в FastAPI. Мы также углубились в такие продвинутые темы, как внедрение зависимостей, безопасность и аутентификация, а также интеграция с базами данных. При создании CRUD-приложения мы видели, как все эти компоненты объединяются в реальном сценарии. Следование лучшим практикам обеспечивает удобство обслуживания и масштабируемость наших приложений. Более того, динамичная экосистема вокруг FastAPI предоставляет вам инструменты для управления пользователями, разрешения, командную строку создание электронных приложений и многое другое, что делает его не просто автономным фреймворком, но частью мощного инструментария. Мы надеемся, что это руководство послужит вам полезным ресурсом.

Помните, что ключом к освоению FastAPI, как и любого другого инструмента, является практика. Так что вперед, создавайте и развертывайте приложения, решайте реальные проблемы и наслаждайтесь кодированием!