Fast api что это
Почему вам стоит выбрать фреймворк FastAPI для своего следующего проекта
Авторизуйтесь
Почему вам стоит выбрать фреймворк FastAPI для своего следующего проекта
Senior Python Developer в Akvelon
FastAPI — это фреймворк для создания лаконичных и довольно быстрых HTTP API-серверов со встроенными валидацией, сериализацией и асинхронностью. Стоит он на плечах двух других фреймворков. Работой с web в FastAPI занимается Starlette, за валидацию отвечает Pydantic.
Комбайн получился лёгким, не перегруженным и более чем достаточным по функционалу.
Starlette — новый, шустрый и классные фреймворк, реализующий подход ASGI. В нем всё заточено на асинхронность и новые фишки 3-й ветки Python. Кроме этого в Starlette есть ещё целая пачка серьёзных плюшек:
Асинхронное программирование — это потоковая обработка программного обеспечения /пользовательского пространства, где приложение, а не процессор, управляет потоками и переключением контекста. В асинхронном программировании контекст переключается только в заданных точках переключения, а не с периодичностью, определённой CPU.
Когда вы запускаете что-то асинхронно, это означает, что оно не блокируется, вы выполняете его, не дожидаясь завершения, и продолжаете выполнять другие вещи. Параллелизм означает выполнение нескольких задач одновременно, параллельно. Параллелизм хорошо работает, когда вы можете разделить задачи на независимые части работы.
Основные возможности FastAPI
FastAPI — это, по сути, нашлёпка на родные классы Starlette, добавляющая пачку новых фич к уже и так неплохому фреймворку.
Важные причины выбрать FastAPI:
Когда стоит использовать FastAPI
Если вы ответили на большую часть «нет», то вам стоит присмотреться к другим фреймворкам, либо использовать FastAPI. Выбор остаётся за вами.
Почему Вы должны попробовать 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
Это неофициальный перевод документации FastAPI. Если у вас есть время и знания, можете помочь с официальным переводом здесь.
Введение
Весь использованный код можно копировать и использовать без изменений (этот код представляет собой проверенные python-файлы).
Для запуска любого из примеров нужно скопировать код в файл main.py и запустить uvicorn с помощью следующей команды:
Крайне рекомендуется писать или копировать код и запускать локально. Использование его в редакторе показывает основные преимущества FastAPI. Можно видеть, насколько мало кода нужно писать: все проверки типов, автозаполнения и так далее.
Установка FastAPI
Первый шаг — установка FastAPI.
При первом знакомстве лучше установить его вместе со всеми опциональными зависимостями и возможностями:
… что также включает uvicorn, который может быть использован как сервер для запуска кода.
Можно также выполнить установку частями. Это может потребоваться при развертывании приложения:
pip install fastapi
Также нужно установить uvicorn, чтобы он работал как сервер:
pip install uvicorn
И так для каждой зависимости.
Первый запуск приложения
Простейший файл FastAPI может выглядеть вот так:
Скопируйте содержимое в файл main.py и запустите сервер:
В выводе есть такая строка:
Она показывает URL работы сервера на локальной машине.
Проверка работы
Перейдите в браузере по ссылке http://127.0.0.1:8000. Там отобразится ответ в формате JSON:
Автоматическая документация API
Теперь стоит перейти на http://127.0.0.1:8000/docs.
На этой странице находится интерактивная документация по API (предоставляемая Swagger UI):
Альтернативная документация API
Также можно попробовать http://127.0.0.1:8000/redoc.
Это альтернативный вариант автоматической документации (от ReDoc):
OpenAPI
FastAPI генерирует «схему» из API с помощью стандарта OpenAPI.
Схема
Схема (schema) — это определение или описание чего-либо. Не код, отвечающий за реализацию, а просто абстрактное описание.
API-схема
В этом случае OpenAPI — это спецификация, которая предписывает, как именно определять схему API. Определение включает пути, возможные принимаемые параметры и так далее.
Схема данных
Понятие «схема» может также указывать на форму некоторых данных: например, JSON-содержимое. В этом случае тут будут указываться JSON-атрибуты, использованные типы данных и другое.
OpenAPI и JSON Schema
OpenAPI определяет схему API для созданного API. А она, в свою очередь, включает определения отправленных или полученных через API данных с помощью JSON — стандарта схем данных JSON.
Проверка openapi.json
Если интересно узнать, как работает чистая схема OpenAPI, то FastAPI автоматически генерирует JSON-схему с описаниями API.
Их можно увидеть прямо на сайте: http://127.0.0.1:8000/openapi.json. Там будет показан JSON в таком формате:
Для чего нужен OpenAPI
Схема OpenAPI — это то, что отвечает за работу двух включенных интерактивных систем документации.
И есть десятки альтернатив, все из которых основаны на OpenAPI. Их можно запросто добавлять в приложение, построенное с помощью FastAPI.
Его также можно использовать для автоматической генерации кода, чтобы у клиентов была возможность взаимодействовать через API. Например, для фронтенда, мобильных или IoT-приложений.
Из чего состоит наше приложение
Шаг №1: импорт FastAPI
FastAPI — это класс Python, который предоставляет всю функциональность для API.
FastAPI
The current page still doesn’t have a translation for this language.
But you can help translating it: Contributing.
FastAPI framework, high performance, easy to learn, fast to code, ready for production
FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.
The key features are:
Fast: Very high performance, on par with NodeJS and Go (thanks to Starlette and Pydantic). One of the fastest Python frameworks available.
Fast to code: Increase the speed to develop features by about 200% to 300%. *
* estimation based on tests on an internal development team, building production applications.
Sponsors¶
Opinions¶
«[. ] 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.«
«We adopted the FastAPI library to spawn a REST server that can be queried to obtain predictions. [for Ludwig]«
«Netflix is pleased to announce the open-source release of our crisis management orchestration framework: Dispatch! [built with FastAPI]«
«I’m over the moon excited about FastAPI. It’s so fun!«
«If you’re looking to learn one modern framework for building REST APIs, check out FastAPI [. ] It’s fast, easy to use and easy to learn [. ]«
«We’ve switched over to FastAPI for our APIs [. ] I think you’ll like it [. ]«
Typer, the FastAPI of CLIs¶
Typer is FastAPI’s little sibling. And it’s intended to be the FastAPI of CLIs. ⌨️ 🚀
Requirements¶
FastAPI stands on the shoulders of giants:
Installation¶
You will also need an ASGI server, for production such as Uvicorn or Hypercorn.
Example¶
Create it¶
Note:
If you don’t know, check the «In a hurry?» section about async and await in the docs.
Run it¶
Run the server with:
The command uvicorn main:app refers to:
Check it¶
You will see the JSON response as:
You already created an API that:
Interactive API docs¶
You will see the automatic interactive API documentation (provided by Swagger UI):
Alternative API docs¶
You will see the alternative automatic documentation (provided by ReDoc):
Example upgrade¶
Now modify the file main.py to receive a body from a PUT request.
Declare the body using standard Python types, thanks to Pydantic.
Interactive API docs upgrade¶
Alternative API docs upgrade¶
Recap¶
In summary, you declare once the types of parameters, body, etc. as function parameters.
You do that with standard modern Python types.
You don’t have to learn a new syntax, the methods or classes of a specific library, etc.
Just standard Python 3.6+.
For example, for an int :
or for a more complex Item model:
. and with that single declaration you get:
Coming back to the previous code example, FastAPI will:
We just scratched the surface, but you already get the idea of how it all works.
Try changing the line with:
. and see how your editor will auto-complete the attributes and know their types:
Performance¶
Independent TechEmpower benchmarks show FastAPI applications running under Uvicorn as one of the fastest Python frameworks available, only below Starlette and Uvicorn themselves (used internally by FastAPI). (*)
To understand more about it, see the section Benchmarks.
Optional Dependencies¶
Used by FastAPI / Starlette:
License¶
This project is licensed under the terms of the MIT license.
Как начать работать с FastAPI на Python
Когда веб-фреймворки Python, такие как Flask и Django, впервые появились и начали приобретать популярность и известность, Python был несколько другим языком, чем сегодня. Многие элементы современного Python, такие как асинхронное выполнение и стандарт ASGI (Asynchronous Server Gateway Interface), на тот момент либо находились в зачаточном состоянии, либо еще не существовали. Поэтому не удивительно, что сейчас возникают новые фреймворки. Один из них — FastAPI. В этой статье мы разберем, как начать работать с FastAPI на Python.
FastAPI – это веб-фреймворк Python, который изначально создавался для использования современных функций Python. Он использует стандарт ASGI для асинхронного, конкурентного соединения с клиентами. При необходимости также может работать с WSGI. Асинхронные функции могут использоваться для маршрутов и конечных точек. Кроме того, FastAPI позволяет быстро и эффективно создавать веб-приложения с чистым, современным Python-кодом, с подсказками типов.
Как следует из названия, основным вариантом использования FastAPI является создание конечных точек API. Для этого нужно просто вернуть данные словаря Python в формате JSON или использовать стандарт OpenAPI, включая интерактивный Swagger UI.
Но FastAPI никоим образом не ограничивается API. С его помощью можно сделать практически все, что делают с использованием веб-фреймворков. От доставки простеньких старых веб-страниц с применением движка шаблонов Jinja2 до обслуживания приложений на базе WebSockets.
Установка FastAPI
FastAPI может устанавливать довольно много компонентов самостоятельно. Поэтому лучше начинать любой проект на FastAPI в новой чистой виртуальной среде.
Вам также потребуется установить сервер ASGI для локального тестирования.
Простой пример использования FastAPI
Простое приложение на FastAPI выглядит следующим образом:
Когда все заработает, перейдите по ссылке http:\\localhost:8000 (дефолтный адрес для тестового сервера Uvicorn на вашей локальной машине). В браузере вы увидите <"greeting": "Hello world">– валидный ответ JSON, сгенерированный из словаря.
Надеемся, этот пример даст вам представление о том, насколько легко FastAPI позволяет передавать JSON. Все, что нужно сделать, это создать маршрут и вернуть словарь Python, который будет автоматически сериализован в JSON.
Для сериализации сложных типов данных нужно предпринять дополнительные шаги, но о них мы поговорим позже.
Марк Лутц «Изучаем Python»
Скачивайте книгу у нас в телеграм
Общие принципы приложения FastAPI должны быть знакомы любому, кто работал с таким фреймворком, как Flask:
Но всё же у FastAPI есть свои особенности. Во-первых, функции маршрутизации могут быть асинхронными. Поэтому любые развертываемые асинхронные компоненты – например, соединение промежуточного программного обеспечения асинхронной базы данных – также могут работать в этих функциях.
Обратите внимание, что ничто не мешает вам использовать обычные функции синхронизации, если они нужны. Допустим, у вас есть операция, требующая больших вычислительных ресурсов (в отличие от операции, ожидающей ввода-вывода — что является лучшим вариантом использования асинхронного режима). В таком случае будет лучше использовать функцию синхронизации и позволить FastAPI разобраться с ней. В остальных случаях используйте асинхронность.
Типы маршрутов в FastAPI
Вы также можете поддерживать несколько методов на заданном маршруте. Для этого нужно просто обернуть несколько функций маршрутизации, например @app.get («/») для одной функции и @app.post («/») для другой.
Параметры путей, запросов и форм
Если вы хотите извлечь переменные из пути маршрута, это можно сделать, определив их при объявлении маршрута, а затем передав их в функцию маршрута.
Чтобы извлечь параметры запроса из URL-адреса, можно использовать типизированные объявления в функции маршрутизации, которые FastAPI обнаружит автоматически:
Обработка данных формы происходит немного сложнее. Во-первых, вам нужно установить дополнительную библиотеку python-multipart для анализа данных формы ( pip install python-multipart ). Затем вы сможете использовать синтаксис, аналогичный синтаксису параметров запроса, но с некоторыми изменениями:
Типы ответов в FastAPI
Типом ответа по умолчанию для FastAPI является JSON. Все примеры, которые мы видели до сих пор, возвращают данные, которые автоматически сериализуются как JSON. Но вы можете возвращать данные и в другом формате.
Модуль fastapi.responses поддерживает множество распространенных типов ответов:
Кроме того, вы можете использовать общий объект Response и предоставить собственный настраиваемый код состояния, заголовки, контент и тип мультимедиа.
Объект Response в FastAPI
Файлы cookie в FastAPI
Получение файлов cookie от клиента работает примерно так же, как обработка параметров запроса или формы:
Использование моделей Pydantic с FastAPI
Типы в Python, как правило, необязательны. Однако FastAPI больший «приверженец» использования типов, чем многие другие фреймворки Python. Для декларативной проверки отправленных данных он использует библиотеку Pydantic, так что вам не придется прописывать эту логику самостоятельно.
Вот пример того, как с помощью Pydantic можно проверить входящий JSON:
Если бы year был строкой, которую можно интерпретировать как целое число (например, «2018» ), он был бы автоматически преобразован в правильный тип данных. Но значение year, которое нельзя интерпретировать как целое число (к примеру, «год 21» ), было бы отклонено.
Использование Swagger/OpenAPI в FastAPI
OpenAPI (ранее известный как Swagger) представляет собой стандарт в формате JSON для описания конечных точек API. Клиент может прочитать определение OpenAPI для конечной точки и автоматически определить схемы для данных, отправляемых и получаемых API веб-сайта.
FastAPI автоматически генерирует определения OpenAPI для всех конечных точек вашего сайта. Если вы посетите /openapi.json в корне сайта FastAPI, вы получите файл JSON, описывающий каждую конечную точку и данные, которые она может получать и возвращать.
Еще одно удобство, предоставляемое FastAPI, – это автоматически генерируемые интерфейсы документации для ваших API, с которыми вы можете взаимодействовать через веб-интерфейс.
FastAPI также предоставляет хуки для расширения или изменения автоматически сгенерированной схемы, а также для ее условного создания или даже отключения.
Заключение
Итак, мы рассмотрели особенности фреймворка FastAPI и разобрали, как начать с ним работать на Python. Также мы привели несколько примеров использования FastAPI. Надеемся, теперь у вас есть понимание основ работы с данным фреймворком. Успехов в написании кода!