В FastAPI 0.163 можно ограничить, сколько запросов одновременно работают с базой данных

14 ноября вышел FastAPI 0.163.0, и в нём одна новая возможность, зато очень практичная. Зависимости, которые подключаются через Depends(), теперь можно ограничить по числу одновременных вызовов. Проще говоря, фреймворк сам следит, чтобы, например, сессию базы данных одновременно держали не больше пяти запросов, а остальные спокойно ждали своей очереди.

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

Как работает max_concurrency

У Depends() появился параметр max_concurrency. В документации его показывают на примере сессии базы данных из учебника по SQL:

from typing import Annotated

from fastapi import Depends, FastAPI
from sqlmodel import Session


def get_session():
    with Session(engine) as session:
        yield session


# не больше пяти открытых сессий одновременно
SessionDep = Annotated[Session, Depends(get_session, max_concurrency=5)]

app = FastAPI()


@app.get("/items/")
def read_items(session: SessionDep):
    ...

Если сессию запросил шестой запрос, он ждёт, пока закроется одна из первых пяти. Пока он ждёт, рабочий поток не занят, и сервер продолжает обслуживать остальные запросы. Значение должно быть целым положительным числом, а по умолчанию стоит None, то есть ограничения нет и всё работает как раньше.

Где лимит общий, а где у каждого свой

Здесь легко ошибиться, поэтому в документации этому отведён отдельный раздел. Лимит привязан не к функции get_session, а к конкретному объекту Depends(). Если во всех маршрутах используется один и тот же псевдоним SessionDep, они делят пять сессий на всех. Если же в каждом маршруте написать новый Depends(get_session, max_concurrency=5), у каждого будет свой лимит в пять сессий, и в сумме база получит гораздо больше подключений.

  • Сессия из зависимости с yield считается занятой, пока не выполнится код после yield. При обычном scope="request" это происходит уже после отправки ответа, при scope="function" сразу после выхода из функции обработчика.
  • Обычная зависимость без yield занимает место в лимите только пока выполняется сама функция.
  • Если FastAPI в рамках одного запроса берёт значение зависимости из кэша, повторного вызова нет и место в лимите он не тратит.
  • У каждого рабочего процесса свой лимит. Два воркера с max_concurrency=5 вместе откроют до десяти сессий. Если приложение запущено через Gunicorn или uvicorn с несколькими воркерами, число нужно делить на их количество.

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

Как не устроить взаимную блокировку

В документации честно предупреждают, что лимит может подвесить запрос. Простой пример: общий Depends(get_session, max_concurrency=1, use_cache=False) используется в одном запросе дважды. Первый вызов открыл сессию, второй ждёт, пока она закроется, а закроется она только в конце запроса, который как раз ждёт второй вызов. Запрос висит.

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

Исправление для отменённых запросов в 0.162.7

За день до этого, 13 ноября, вышел FastAPI 0.162.7 с исправлением, которое касается почти всех, кто открывает сессии через асинхронные зависимости с yield. Если запрос отменялся, например клиент обрывал соединение, код после yield мог прерваться на середине, и сессия или соединение не закрывались до конца. Теперь этот код защищён от отмены и выполняется полностью. С новым лимитом это особенно важно: незакрытая сессия так и осталась бы занимать место в очереди.

15 ноября вышла 0.163.1: она исправляет схему OpenAPI для моделей ответа, у которых вычисляемое поле (computed field) лежит во вложенной модели. Если документация API у вас генерируется для таких моделей, лучше сразу ставить эту версию.

Python 3.10 больше не поддерживается

В версии 0.162.6 от 13 ноября FastAPI отказался от Python 3.10. Начиная с неё пакет на PyPI требует Python 3.11 или новее. Сам Python 3.10 уже не получает исправлений безопасности с октября. На старом интерпретаторе pip и uv просто не поставят новую версию и останутся на 0.162.5, так что тихо сломаться ничего не должно, но и новых исправлений там уже не будет.

Проверить версию Python и FastAPI в окружении и обновиться можно так:

python --version
python -c "import fastapi; print(fastapi.__version__)"

# pip
pip install -U "fastapi>=0.163.1"

# uv
uv add "fastapi>=0.163.1"

Если коротко: обновляться на 0.163.1 стоит всем, кто сидит на Python 3.11 и новее, хотя бы ради исправления с отменёнными запросами. А max_concurrency пригодится там, где база или внешний сервис выдерживают ограниченное число подключений и под нагрузкой начинают сыпать ошибками. Главное, держать лимит в одном общем псевдониме и помнить, что у каждого воркера он свой.

Источники и ссылки


Комментарии загружаются…