Fastapi python что это
Почему Вы должны попробовать FastAPI?
Лого взято из Github репозитория FastAPI
FastAPI — относительно новый веб-фреймворк, написанный на языке программирования Python для создания REST (а если сильно постараться то и GraphQL) API, основанный на новых возможностях Python 3.6+, таких как: подсказки типов (type-hints), нативная асинхронность (asyncio). Помимо всего прочего, FastAPI плотно интегрируется с OpenAPI-schema и автоматически генерирует документацию для вашего API посредством Swagger и ReDoc
FastAPI построен на базе Starlette и Pydantic.
Starlette — ASGI микро-фреймворк для написания веб-приложений.
Pydantic — библиотека для парсинга и валидации данных основанная на Python type-hints.
Что говорят о FastAPI?
«[. ] Я использую FastAPI очень часто в последние дни. [. ] Я однозначно планирую использовать его для всех ML сервисов моей команды в Microsoft. Некоторые из них интегрируются в Windows и некоторые продукты Office.»
Kabir Khan — Microsoft (ref)
«Если вы хотите выучить ещё один фреймворк для написания REST API, взгляните на FastAPI [. ] Он быстрый, прост в использовании и изучении. [. ]»
«Теперь мы используем FastAPI для наших API [. ] Я думаю он вам понравится! [. ]»
Ines Montani — Matthew Honnibal — Explosion AI founders — spaCy creators (ref) — (ref)
Минимальное API созданное с помощью FastAPI
Я постараюсь показать Вам как создать простое, но в то же время полезное API с документацией для разработчиков. Мы будем писать генератор случайных фраз!
Установка необходимых компонентов
Новый модуль!
Uvicorn — это ASGI-совместимый веб-сервер, который мы будем использовать для запуска нашего приложения.
Для начала создадим основу нашего приложения.
Это приложение уже работает и его можно запустить.
Пропишите данную команду в вашем терминале и откройте страничку в браузере по адресу http://127.0.0.1:8000/docs.
Но пока в нашем приложении не обозначено ни одного эндпоинта — давайте это исправим!
База данных
Создадим файл db.py и начнём писать код.
Импортируем необходимые модули:
После — обозначим две модели: входная фраза (та, которую нам будет отправлять пользователь) и «выходная» (та, которую мы будем отправлять пользователю).
После этого, создадим простой класс для работы с БД:
Теперь можно приступить к написанию самого API.
Создадим файл main.py и импортируем следующие модули:
Инициализируем наше приложение и базу данных:
И напишем простой метод получения случайной фразы!
Как Вы можете заметить, в декораторе я также указываю некоторые другие значения, нужные для генерации более красивой документации 🙂 В официальной документации Вы можете посмотреть на все возможные параметры.
В этом куске кода, мы пытаемся получить случайную фразу из базы данных, а если база данных пуста — возвращаем ошибку с кодом 404.
Аналогично пишем другие методы:
И всё! Наше маленькое, но полезное API — готово!
Теперь мы можем запустить приложение с помощью uvicorn, открыть интерактивную документацию (http://127.0.0.1/docs) и попробовать наше API!
Полезные материалы
Конечно, я не смог рассказать Вам о всех возможностях FastAPI, например таких как: умная DI система, middlewares, куки, стандартные методы аутентификация в API (jwt, oauth2, api-key) и многое другое!
Но целью этой статьи является не столько обзор всех возможностей этого фреймворка, а сколько толчок Вас изучить его самим. FastAPI имеет замечательную документацию с кучей примеров.
Почему стоит начать использовать FastAPI прямо сейчас
Привет, Хабровчане! В преддверии старта занятий в группах базового и продвинутого курсов «Разработчик Python», мы подготовили для вас еще один полезный перевод.
Python всегда был популярен для разработки легковесных веб-приложений благодаря потрясающим фреймворкам, таким как Flask, Django, Falcon и многим другим. Из-за лидирующей позиции Python как языка для машинного обучения, он особенно удобен для упаковки моделей и предоставления их в качестве сервиса.
В течение многих лет Flask был основным инструментом для таких задач, но, если вы еще не слышали, на его место появился новый претендент. FastAPI – это относительно новый фреймворк на Python, создание которого было вдохновлено его предшественниками. Он совершенствует их функционал и исправляет множество недостатков. FastAPI был построен на базе Starlette, и несет в себе кучу потрясающих функций.
В последнее время он приобрел сильную популярность, и после того, как последние 8 месяцев я работал с ним каждый день, с уверенностью могу сказать, что вся шумиха вокруг него вполне оправдана. Если вы еще его не пробовали, то я собрал для вас пять причин, почему вам все-таки стоит с ним познакомиться.
Прекрасный простой интерфейс
Все фреймворки вынуждены балансировать между функциональностью и предоставлением свободы разработчику. Django мощный, но слишком упрямый. С другой стороны, Flask достаточно высокоуровневый, чтобы обеспечить свободу действий, но многое остается за пользователем. FastAPI в этом плане ближе к Flask, но ему удается достичь еще более здорового баланса.
Для примера, давайте посмотрим, как в FastAPI определяется конечная точка.
Простой пример приложения с uvicorn :
Теперь приложение может принимать запросы. В этом случае запрос будет выглядеть следующим образом:
Вишенкой на торте будет автоматическая генерация документации в соответствии с OpenAPI с помощью интерактивного интерфейса Swagger.
Интерфейс Swagger для приложения на FastAPI
Async
Одним из самых больших недостатков веб-фреймворков Python WSGI по сравнению с аналогичными в Node.js или Go, была невозможность асинхронной обработки запросов. С момента появления ASGI – это больше не проблема, и FastAPI в полной мере реализует эту возможность. Все, что вам нужно сделать – это просто объявить конечные точки с помощью ключевого слова async следующим образом:
Внедрение зависимостей
В FastAPI есть действительно классный способ управления зависимостями. Несмотря на то, что разработчиков не заставляют насильно использовать встроенную систему внедрения для обработки зависимостей на конечных точках, такой способ работы настоятельно рекомендуется.
Для примера, давайте создадим конечную точку, где пользователи могут оставлять комментарии к определенным статьям.
FastAPI автоматически вычислит функцию get_database в рантайме при вызове конечной точки, поэтому вы сможете использовать возвращаемое значение на свое усмотрение. Для этого есть (по крайней мере) две веские причины.
Легкая интеграция с базами данных
Что бы вы ни выбрали, будь то SQL, MongoDB, Redis или что-нибудь другое, FastAPI не заставит вас строить приложение вокруг базы данных. Если вы когда-нибудь работали с MongoDB через Django, вы знаете, насколько это может быть болезненно. С FastAPI вам не нужно будет делать лишний крюк, поскольку добавление базы данных в стек пройдет максимально безболезненно. (Или, если быть точнее, объем работы будет определяться выбранной базой данных, а не сложностями, появившимися из-за использования какого-то конкретного фреймворка.)
Серьезно, посмотрите на эту красоту.
Вуаля! Уже вижу, как вы печатаете
в терминале на своем компьютере.
Поддержка GraphQL
Когда вы работаете со сложной моделью данных, REST может стать серьезной преградой. Очень не круто, когда малейшее изменение на фронте требует обновления схемы конечной точки. В таких случаях спасает GraphQL. Несмотря на то, что поддержка GraphQL – это не что-то новое для веб-фреймворков Python, Graphene и FastAPI хорошо работают вместе. Нет необходимости дополнительно ставить какие-либо расширения, например graphene_django для Django, все просто будет работать с самого начала.
+1: Отличная документация
Конечно же, фреймворк не может быть выдающимся, если у него плохая документация. Django, Flask и другие в этом преуспели, и FastAPI от них не отстает. Конечно, поскольку он гораздо моложе, о нем еще нет ни одной книги, но это лишь вопрос времени.
Если вы хотите увидеть FastAPI в действии, то у меня для вас припасено отличное руководство. Я написал подробную инструкцию, с помощью которой вы можете развернуть свою модель машинного обучения на Docker, Docker Compose и GitHub Actions!
Подводя итог, независимо от того ищите ли вы быстрый и легкий фреймворк для работы с вашей моделью глубокого обучения или же что-то более сложное, FastAPI – это ваш вариант. Я почти наверняка уверен, что он вам подойдет.
Знакомство с FastAPI
В нашей команде бытует хорошая практика фиксировать всё изменения, которые отправляются в продакшен в гитхабовских релизах. Однако, не вся наша команда имеет доступ в гитхаб, а о релизах хочется знать всем. Так сложилась традиция релиз из гитхаба дублировать в рабочем чате команды в телеграме. Что хорошо, гитхаб позволяет с помощь маркдауна красиво оформить релиз с разделением на секции и ссылками на задачи, которые отправляются на выкатку. Что плохо, простым copy/paste всю эту красоту в телеграм не перенесёшь и приходится тратить время на довольно нудную работу по повторному оформлению релиза, но уже в телеграме. Ну а посколько программисты народ ленивый, я решил этот процесс автоматизировать.
Исходные данные:
Соответственно, задача заключается в том, чтобы поднять HTTP API, который сможет принять POST запрос, проверить подпись, извлечь нужную информацию из тела запроса и передать её дальше по инстанции. Как тут не попробовать FastAPI, на который я давно глаз положил?
Кто такой FastAPI?
FastAPI — это фреймворк для создания лаконичных и довольно быстрых HTTP API-серверов со встроенными валидацией, сериализацией и асинхронностью,
что называется, из коробки. Стоит он на плечах двух других фреймворков: работой с web в FastAPI занимается Starlette, а за валидацию отвечает Pydantic.
Комбайн получился легким, неперегруженным и более, чем достаточным по функционалу.
Необходимый минимум
Для работы FastAPI необходим ASGI-сервер, по дефолту документация предлагает uvcorn, базирующийся на uvloop, однако FastAPI также может работать и с другими серверами, например, c hypercorn
Вот мои зависимости:
И этого более чем достаточно.
Для более тщательных читателей в конце статьи есть ссылка на репозиторий с ботом, там можно посмотреть на зависимости для разработки и тестирования.
Собираем API
Надо заметить, что подход к оформлению хэндлеров в FastAPI чрезвычайно напоминает такой же в Flask, Bottle, да тысячи их. Видимо, миллионы мух не могут-таки ошибаться.
В самом первом приближении мой роут для обработки релиза выглядел так:
Здесь прекрасно видно, как выглядят модели Pydantic. Их можно вкладывать, причем как сущностями, так и списками, к примеру так:
Ещё мы обязаны задать типы полям моделей и FastAPI будет мапить входящий запрос на переданную ему модель с учётом типов. В случае несовпадения он отдаст ошибку валидации. В случае, если поля во входящих данных нет и в модели не проставлено значение по-умолчанию — тоже.
Кроме базовых питоньих типов Pydantic предлагает ещё достаточно много своих собственных типов данных, в моём примере это тип HttpUrl, то есть входящая строка должна быть валидным URL со схемой и доменом первого уровня, в противном случае FastAPI отдаст ошибку валидации. Остальные типы Pydantic можно посмотреть здесь
Таким образом валидация и сериализация данных настраивается уже при задании модели данных.
Аутентификация
FastAPI поддерживает достаточно методов аутентификации по умолчанию, но, поскольку здесь используется гитхабовская подпись запроса, авторизацию пришлось колхозить самостоятельно,
ну да оно и к лучшему — больше интересного!
Я вынес роуты FastAPI в отдельный роутер, а в основном файле оставил авторизацию и управление документацией:
Обратите внимание, что request.body — это функция, причем асинхронная. В FastAPI(а на деле в Starlette) асинхронность везде, это надо обязательно помнить.
Что касается документации, то это ещё один большой плюс FastAPI — он автоматически генерит документацию в формате OpenAPI и отдаёт её в формате Swagger/ReDoc в зависимости от где вы смотрите, ваш_сайт/docs или ваш_сайт/redoc соответственно.
В моем случае я решил документацию в проде вообще убрать. Ну его.
Соответственно, файл с роутами превратился в это:
А всё
Это действительно весь код, который запускает быстрый HTTP API-сервер с аутентификацией, валидацией и документацией.
Итого
FastAPI — действительно отличный инструмент, если вам по душе лаконичность и, вместе с тем, понятность кода. Кроме того, он асинхронен(фу, вы что, в 2020-ом году пишете синхронный код?
я тоже), быстр и это не идёт в ущерб функциональности.
Так что если на горизонте маячит новый проект, для которого важны производительность, документация и валидация, то, вероятно, имеет смысл посмотреть в сторону FastAPI.
Вместо послесловия
Конечно, проект получился несколько больше, чем описанные мной три файла. Там их на самом деле шесть — собственно бот, описывать которого я не стал, ибо нерелевантно, а также утилиты и настройки, вынесенные в отдельные файлы для большего порядку.
Всё это, а также тесты, докерфайл и настройку github actions вы можете посмотреть в исходном коде проекта
Пишем веб сервис на Python с помощью FastAPI
Знаю, знаю, наверное вы сейчас думаете «что, опять?!».
Да, на Хабре уже неоднократно писали о фреймворке FastAPI. Но я предлагаю рассмотреть этот инструмент немного подробнее и написать API своего собственного мини Хабра без кармы и рейтингов, зато с блэкджеком и с тестами, аутентификацией, миграциями и асинхронной работой с БД.
Схема базы данных и миграции
Прежде всего, с помощью SQLAlchemy Expression Language, опишем схему базы данных. Создадим файл models/users.py:
И файл models/posts.py:
Чтобы автоматизировать миграции базы данных, установим alembic:
Для инициализации Alembic выполним:
Эта команда создаст в текущей директории файл alembic.ini и каталог migrations содержащий:
Формат %(variable_name)s позволяет нам устанавливать разные значения переменных в зависимости от среды окружения, переопределяя их в файле env.py например вот так:
Здесь мы берем значения DB_USER, DB_PASS, DB_NAME и DB_HOST из переменных окружения. Кроме этого, в файле env.py указываются метаданные нашей базы в атрибуте target_metadata, без этого Alembic не сможет определить какие изменения необходимо произвести в базе данных.
Все готово и мы можем сгенерировать миграции и обновить БД:
Запускаем приложение и подключаем БД
Создадим файл main.py:
И запустим приложение, выполнив команду:
Убедимся, что все работает как надо. Открываем в браузере http://127.0.0.1:8000/ и видим
Чтобы подключиться к базе данных, воспользуемся модулем databases, который позволяет выполнять запросы асинхронно.
Настроим startup и shutdhown события нашего сервиса, при которых будут происходить подключение и отключение от базы данных. Отредактируем файл main.py:
Открываем http://127.0.0.1:8000/ и если видим в ответе пустой список [], значит все прошло хорошо и можно двигаться дальше.
Валидация запроса и ответа
Реализуем возможность регистрации пользователей. Для этого нам понадобиться валидировать HTTP запросы и ответы. Для решения этой задачи воспользуемся библиотекой pydantic:
Создадим файл schemas/users.py и добавим модель, отвечающую за валидацию тела запроса:
Обратите внимание, что типы полей определяются с помощью аннотации типов. Помимо встроенных типов данных, таких как int и str, pydantic предлагает большое количество типов, обеспечивающих дополнительную проверку. Например, тип EmailStr проверяет, что полученное значение — корректный email. Для использования типа EmailStr необходимо установить модуль email-validator:
Тело ответа должно содержать свои собственные специфические поля, например id и access_token, поэтому добавим в файл schemas/users.py модели, отвечающие за формирование ответа:
Для каждого поля модели можно написать кастомный валидатор. Например, hexlify_token преобразует UUID значение в hex строку. Стоит отметить, что вы можете использовать класс Field, когда нужно переопределить стандартное поведение поля модели. Например, token: UUID4 = Field(. alias=«access_token») устанавливает псевдоним access_token для поля token. Для обозначения, что поле обязательно, в качестве первого параметра передается специальное значение — . (ellipsis).
Добавим файл utils/users.py, в котором создадим методы, необходимые для записи пользователя в БД:
Создадим файл routers/users.py и добавим sign-up роут, указав, что в запросе он ожидает модель CreateUser и возвращает модель User:
Осталось только подключить роуты из файла routers/users.py. Для этого добавим в main.py следующие строки:
Аутентификация и контроль доступа
Теперь, когда в нашей базе данных есть пользователи, все готово для того чтобы настроить аутентификацию приложения. Добавим эндпоинт, который принимает имя пользователя и пароль и возвращает токен. Обновим файл routers/users.py, добавив в него:
При этом, нам не нужно самостоятельно описывать модель запроса, Fastapi предоставляет специальный dependency класс OAuth2PasswordRequestForm, который заставляет роут ожидать два поля username и password.
Чтобы ограничить доступ к определенным роутам для неаутентифицированных пользователей, напишем метод-зависимость(dependency). Он проверит, что предоставленный токен принадлежит активному пользователю и вернет данные пользователя. Это позволит нам использовать информацию о пользователе во всех роутах, требующих аутентификации. Создадим файл utils/dependecies.py:
Обратите внимание, что зависимость может в свою очередь зависеть от другой зависимости. К пример OAuth2PasswordBearer — зависимость, которая дает понять FastAPI, что текущий роут требует аутентификации.
Чтобы проверить, что все работает как надо, добавим роут /users/me, возвращающий детали текущего пользователя. В файл routers/users.py добавим строки:
Теперь у нас есть роут /users/me к которому имеют доступ только аутентифицированные пользователи.
Все готово для того, чтобы наконец добавить возможность пользователям создавать и редактировать публикации:
Подключим новые роуты, добавив в main.py
Тестирование
Тесты мы будем писать на pytest:
Для тестирования эндпоинтов FastAPI предоставляет специальный инструмент TestClient.
Напишем тест для эндпоинта, который не требует подключения к базе данных:
Как видите, все достаточно просто. Необходимо инициализировать TestClient, и использовать его для тестирования HTTP запросов.
Для тестирования остальных эндпоинтов, необходимо создать тестовую БД. Отредактируем файл main.py, добавив в него конфигурацию тестовой базы:
Мы по-прежнему используем БД «async-blogs» для нашего приложения. Но если задано значение переменной окружение TESTING, тогда использовуется БД «async-blogs-temp-for-test».
Чтобы база «async-blogs-temp-for-test» автоматически создавалась при запуске тестов и удалялась после их выполнения, создадим фикстуру в файле tests/conftest.py:
Используя фикстуру temp_db в тестах, мы сможем протестировать все эндпоинты нашего приложения:
Учебное пособие по Python REST API: начало работы с FastAPI
REST API является архитектурным образцом для создания веб — сервисов. REST — это набор правил, в которых изложены лучшие практики обмена данными между клиентами и серверами. Они используют HTTP-запросы для управления данными и связи с веб-службами. API-интерфейсы REST не сохраняют состояние, кэшируются и согласованы. Они отлично подходят для создания универсальных и масштабируемых веб-приложений. Три основных фреймворка Python — это Django, Flask и FastAPI.
Сегодня мы собираемся изучить FastAPI, веб-фреймворк с открытым исходным кодом, используемый для создания API с помощью Python.
Что такое FastAPI?
Официальный веб-сайт FastAPI описывает FastAPI как современный и высокопроизводительный веб-фреймворк для создания API-интерфейсов с Python 3.6+ на основе стандартных подсказок типа Python. FastAPI работает очень быстро благодаря встроенной поддержке asyncфункции Python 3.6+.
FastAPI был выпущен в 2018 году и был создан Себастьяном Рамиресом. Рамирес был недоволен существующими фреймворками, такими как Flask и DRF, поэтому он создал свой собственный фреймворк, используя такие инструменты, как Starlette и Pydantic. Теперь многие крупные технологические компании, такие как Uber, Netflix и Microsoft, используют FastAPI для создания своих приложений.
Возможности FastAPI
FastAPI имеет много замечательных функций. Давайте посмотрим на них:
Flask против FastAPI
В этом разделе мы рассмотрим Flask и FastAPI. Обсудим их плюсы, минусы и варианты использования.
Flask
Flask — это микрофреймворк Python. Он поставляется с ORM, кешированием и аутентификацией. Он был разработан для создания веб-приложений с использованием Python. Он считается простым, быстрым и масштабируемым.
Плюсы
Минусы
Сценарии использования
Flask обычно используется для таких проектов, как:
FastAPI
FastAPI — это современный высокопроизводительный веб-фреймворк. Он используется для создания веб-API.
Плюсы
Минусы
Сценарии использования
FastAPI обычно используется для таких проектов, как:
FastAPI Привет, мир
Попрактикуемся с FastAPI! Мы рассмотрим простой Hello World!и разберем на части.