«Погружение в FastAPI Полный гид для начинающих разработчиков»

Основы работы с FastAPI

Структура проекта

Для начала, создадим минимальную структуру проекта. Основной файл, с которого мы будем запускать сервер, назовем main.py. В этом файле мы создадим базовое приложение, которое будет обрабатывать HTTP-запросы.

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello World"}

Запустим сервер командой:

uvicorn main:app --reload

Теперь сервер запущен, и вы можете зайти по адресу http://127.0.0.1:8000, чтобы увидеть результат. Во-вторых, мы можем добавить пару маршрутов с различными методами запросов.

Работа с параметрами запросов

FastAPI позволяет легко работать с параметрами запросов и телом запроса. Рассмотрим примеры использования параметров в URL и JSON-данных.

from fastapi import FastAPI
app = FastAPI()
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}
@app.post("/items/")
def create_item(item: dict):
return item

В этом примере read_item использует параметр пути item_id и необязательный параметр строки запроса q. Метод create_item принимает тело запроса в виде JSON и возвращает его обратно.

Метод	Маршрут	Описание
GET	/items/{item_id}	Получение элемента по его ID
POST	/items/	Создание нового элемента

Используя такие простые методы, вы можете создавать полноценные API, обрабатывать ошибки и настраивать параметры запросов.

FastAPI автоматически генерирует документацию для вашего API в формате OpenAPI, которую можно увидеть, зайдя по адресу /docs. Эта функция позволяет вам легко тестировать и понимать структуру вашего API.

Итак, в этом разделе мы рассмотрели основные понятия и примеры работы с FastAPI. Далее мы углубимся в более сложные аспекты, такие как валидация данных и работа с базами данных.

Что такое FastAPI и его преимущества

Основные преимущества FastAPI

• Высокая производительность: FastAPI позволяет обрабатывать большое количество запросов с минимальными задержками благодаря использованию асинхронного программирования.
• Простота использования: Благодаря аннотациям типов и автодокументированию, создание и тестирование API становится интуитивно понятным процессом.
• Отличная документация: Автоматически генерируемая документация в формате Swagger и Redoc позволяет легко понять и использовать API.
• Поддержка асинхронности: Возможность использования async/await для написания асинхронного кода, что повышает производительность при работе с I/O операциями.

Особенности FastAPI

• Декораторы маршрутов: Легкость создания маршрутов с использованием декораторов, таких как @app.get("/items/").
• Автодокументирование: Документация генерируется автоматически на основе аннотаций типов и параметров запроса.
• Поддержка зависимостей: Встроенная система зависимостей позволяет эффективно управлять зависимостями в ваших приложениях.
• Типизация данных: Использование pydantic для валидации и сериализации данных, что улучшает надежность и удобство работы с данными.
• Dockerfile: Простота контейнеризации приложений с использованием Docker.

Преимущества использования FastAPI в реальных проектах

• Скорость разработки: Простота и удобство создания API сокращают время разработки и позволяют быстрее запускать проекты.
• Масштабируемость: Высокая производительность позволяет обрабатывать большие объемы данных и поддерживать высокие нагрузки.
• Гибкость: Возможность легко интегрировать с другими инструментами и технологиями.
• Безопасность: Встроенные механизмы аутентификации и авторизации обеспечивают высокий уровень безопасности приложений.

Сейчас мы посмотрим на примеры использования FastAPI и разберем основные функции, такие как @app.get, request_response, dependantbody_params, и get_dependant. Чуть позже мы создадим простого сервер и рассмотрим его работу в реальных условиях. Этот фреймворк наследуется от Starlette и Pydantic, позволяющая создавать расширенные и сложные приложения с минимальными усилиями.

Установка и настройка окружения

Шаг 1: Установка Python и создание виртуального окружения

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

python -m venv myenv

Активируем созданное виртуальное окружение:

source myenv/bin/activate  # для Linux и macOS
myenv\Scripts\activate  # для Windows

Шаг 2: Установка необходимых библиотек

Теперь установим необходимые библиотеки. В первую очередь, нам потребуется сам FastAPI и сервер для разработки, например, Uvicorn. Установим их с помощью следующей команды:

pip install fastapi uvicorn

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

pip install -r requirements.txt

Шаг 3: Создание первого маршрута

После установки всех зависимостей, создадим первый endpoint для нашего приложения. Создадим файл main.py и добавим в него следующий код:

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Hello World"}

Запустим сервер, чтобы убедиться, что все работает правильно:

uvicorn main:app --reload

Теперь ваше приложение доступно по адресу http://127.0.0.1:8000. Вы можете открыть этот URL в браузере и увидеть ответ от сервера. Это базовый пример, который можно расширять в зависимости от задач вашего проекта.

Примечание: для развертывания в продакшн-среде потребуется создать dockerfile и использовать такие инструменты, как Docker. Это позволит упростить развертывание и управление приложением на сервере.

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

Создание первого приложения

Шаг 1: Начальная настройка проекта

Итак, первым делом нам нужно создать проект и настроить его окружение. Для этого создаем новую директорию и инициализируем виртуальное окружение:

$ mkdir my_first_app
$ cd my_first_app
$ python3 -m venv env
$ source env/bin/activate

Далее устанавливаем необходимые пакеты:

$ pip install fastapi uvicorn

Теперь мы готовы к созданию первого файла приложения. Создаем файл main.py и добавляем следующий код:

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}

Шаг 2: Запуск сервера

Для того чтобы запустить сервер, используем команду:

$ uvicorn main:app --reload

Сервер будет запущен, и вы сможете перейти по адресу http://127.0.0.1:8000 в вашем браузере, чтобы увидеть результат.

Шаг 3: Работа с параметрами и валидация данных

Создаем endpoint с параметрами и добавляем валидацию данных. Для этого модифицируем файл main.py следующим образом:

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

Теперь при отправке POST-запроса с данными в формате JSON на /items/, сервер будет выполнять валидацию данных на основе модели Item, и возвращать результат запроса. В этом примере мы используем BaseModel из библиотеки pydantic, которая автоматически проверяет входящие данные.

Шаг 4: Расширенные возможности

В нашем проекте могут быть нужны более сложные маршруты (route) и зависимости. Используем декоратор @app.get для создания endpoint и Depends для обработки зависимостей:

from fastapi import Depends
def get_query_token(token: str):
if token != "fake-super-secret-token":
raise HTTPException(status_code=400, detail="Invalid token")
return token
@app.get("/items/")
def read_items(token: str = Depends(get_query_token)):
return {"token": token}

Теперь, при обращении к endpoint /items/ с параметром token, функция get_query_token будет вызываться автоматически для проверки значения токена.

Итак, мы рассмотрели основные шаги создания первого приложения: от настройки окружения до создания endpoint-ов и валидации данных. Используя эти знания, вы сможете разрабатывать мощные и эффективные веб-приложения с минимальными усилиями.

Функциональные возможности FastAPI

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

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

Давайте посмотрим на примеры использования различных методов FastAPI:

Функция	Описание
apirouteroutingrouter	Позволяет группировать маршруты и зависимости, что упрощает управление большими проектами.
get_dependant	Функция для извлечения зависимостей, которые будут использоваться в обработчиках запросов.
request_body_to_args	Преобразует тело запроса в аргументы функции, облегчая работу с данными пользователя.
dependantbody_params	Управляет параметрами тела запроса и зависимостями, что делает код более чистым и понятным.

Кроме того, FastAPI поддерживает создание мощных и гибких маршрутов с помощью apirouter и routingrouter, что особенно полезно при работе с большими проектами. Запускаем сервер с использованием простого uvicorn и можем тестировать наши endpoint-ы в режиме реального времени.

Еще одной важной особенностью является обработка ошибок. FastAPI автоматически проверяет path_errors и body_errors, что упрощает отладку и делает приложение более надежным. Для более сложных сценариев можно использовать assert и super__call__scope.

Теперь посмотрим на классический пример создания простейшего API с базовыми функциями:

from fastapi import FastAPI, APIRouter, Depends
app = FastAPI()
router = APIRouter()
@router.get("/")
async def read_root():
return {"message": "Hello World"}
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}
app.include_router(router)

В данном примере мы создаем маршруты для GET-запросов, которые могут быть использованы для получения данных. Заметьте, как легко добавлять зависимости и параметры запросов, используя Depends.

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

Обработка запросов и ответов

Итак, начнем с создания простейшего endpoint-а, который будет принимать запросы и возвращать ответы в формате JSON. Для этого нам потребуется создать функцию, которая будет обрабатывать запросы и формировать ответы.

Рассмотрим следующий пример:

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
app = FastAPI()
@app.get("/new_task")
async def new_task(request: Request):
return JSONResponse(content={"message": "New task created"})

В этом примере мы создали базовое приложение и endpoint, который по пути /new_task будет возвращать JSON-ответ с сообщением «New task created». Это простейший пример, который демонстрирует базовый принцип обработки запросов и формирования ответов.

Теперь рассмотрим обработку запросов с параметрами. Мы можем передавать параметры в URL, в теле запроса (body) или через строку запроса (query). Рассмотрим пример с query-параметрами:

@app.get("/items/")
async def read_item(item_id: int, query_param: str):
return JSONResponse(content={"item_id": item_id, "query_param": query_param})

Этот endpoint принимает два параметра: item_id и query_param, которые передаются в строке запроса. При обращении к этому пути, сервер вернет JSON-ответ с данными параметрами.

Для обработки данных, переданных в теле запроса (body), мы можем использовать следующий пример:

from pydantic import BaseModel
class Item(BaseModel):
name: str
description: str
@app.post("/items/")
async def create_item(item: Item):
return JSONResponse(content={"name": item.name, "description": item.description})

Здесь мы используем Pydantic для валидации данных. Класс Item определяет структуру ожидаемых данных, а функция create_item обрабатывает эти данные и возвращает ответ.

Теперь перейдем к обработке ошибок. Для этого мы можем использовать специальные обработчики ошибок. Рассмотрим пример:

from fastapi import HTTPException
@app.get("/path_errors/")
async def path_errors(item_id: int):
if item_id <= 0:
raise HTTPException(status_code=400, detail="Invalid item ID")
return JSONResponse(content={"item_id": item_id})

Этот endpoint проверяет значение параметра item_id и, если оно меньше или равно нулю, возвращает ошибку с кодом 400 и сообщением "Invalid item ID".

Теперь подведем итоги в виде таблицы, в которой покажем различные методы обработки запросов и ответов:

Метод	Описание	Пример
GET	Чтение данных	@app.get("/new_task")
POST	Создание данных	@app.post("/items/")
Обработка ошибок	Обработка и возврат ошибок	raise HTTPException(status_code=400, detail="Invalid item ID")

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

Маршрутизация и пути

Основные концепции маршрутизации

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

• Статические пути: такие пути фиксированы и не меняются. Например, путь /home всегда будет вести к одной и той же функции.
• Динамические пути: такие пути включают переменные, значения которых могут изменяться. Например, путь /items/{item_id} позволяет обработчику получать значение item_id из URL.

Создание маршрутов и использование параметров

Для создания маршрутов используются декораторы, такие как @app.get, @app.post и т.д. Эти декораторы связывают функцию с определённым HTTP методом и путем. Рассмотрим пример создания маршрута с параметром:

```python

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")

async def read_item(item_id: int):

return {"item_id": item_id}

В этом примере item_id является динамическим параметром, значение которого передается в функцию read_item. Параметры также могут быть опциональными и иметь значения по умолчанию:

pythonCopy code@app.get("/items/{item_id}")

async def read_item(item_id: int, query: str = None):

return {"item_id": item_id, "query": query}

Такой подход позволяет гибко настраивать обработку запросов в зависимости от параметров.

Организация маршрутов с помощью APIRouter

Для улучшения структуры приложения рекомендуется использовать APIRouter. Он помогает разбивать приложение на модули и делать код более организованным. Вот пример использования APIRouter:

pythonCopy codefrom fastapi import APIRouter

router = APIRouter()

@router.get("/users/{user_id}")

async def read_user(user_id: int):

return {"user_id": user_id}

app.include_router(router)

Использование APIRouter особенно полезно при работе с крупными проектами, так как позволяет отделять различные части приложения и легко управлять ими.

Тестирование маршрутов

Для тестирования маршрутов и их параметров можно использовать встроенные средства тестирования. Это важно для проверки корректности работы различных частей приложения и своевременного выявления ошибок. Рассмотрим простой пример тестирования маршрута:pythonCopy codefrom fastapi.testclient import TestClient

client = TestClient(app)

def test_read_item():

response = client.get("/items/42")

assert response.status_code == 200

assert response.json() == {"item_id": 42}

Такой подход позволяет автоматизировать проверку работоспособности маршрутов и гарантировать их стабильность при внесении изменений в код.

Итак, мы рассмотрели основные аспекты маршрутизации и работы с путями в вашем приложении. Этот подход обеспечивает гибкость и масштабируемость, что особенно важно при создании сложных и многофункциональных систем.

Видео:

УРОКИ FASTAPI НА БОЕВОМ СЕРВИСЕ 1. MVP, СОЗДАНИЕ ПОЛЬЗОВАТЕЛЯ, МИГРАЦИИ ALEMBIC + ASYNC SQLALCHEMY