Полное руководство по FastAPI для новичков и профессионалов

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

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

Примеры использования FastAPI варьируются от простого получения данных до создания сложных серверных решений. Мы рассмотрим, как настроить API, используя APIRouter и router, а также как правильно обрабатывать запросы и ответы с помощью jsonresponse и raw_response. Вам станет ясно, как управлять параметрами, файлами и данными в различных сценариях.

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

Сейчас мы познакомим вас с практическими примерами и сигнатурами функций, чтобы вы могли увидеть, как легко и быстро создать работающее приложение. Рассмотрим, как правильно настроить роутинг с помощью apirouter, и какие параметры надо учитывать при создании endpoint-ов. Мы покажем, как использовать callablecallable и must для более гибкой настройки маршрутизации и управления запросами.

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

Основы FastAPI

Итак, начнем с установки FastAPI и необходимых зависимостей. Для начала вам понадобится Python 3.7 и выше. Для установки используйте команду:

pip install fastapi uvicorn

Uvicorn — это сервер, который будет обрабатывать запросы к вашему приложению. Создайте файл main.py и добавьте следующий код:

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

Этот простой пример создаст базовый сервер с единственным endpoint, который возвращает JSON с приветственным сообщением. Чтобы запустить сервер, выполните команду:

uvicorn main:app --reload

Теперь перейдем к работе с методами и маршрутизацией. Создадим новый endpoint, который будет принимать параметры через запрос:

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

Здесь мы используем аннотацию типа Optional[str] для необязательного параметра q, который может быть включен в запрос. Параметр item_id является обязательным и должен быть числом.

Теперь давайте посмотрим, как работать с запросами типа POST. Создадим модель данных с помощью BaseModel из библиотеки Pydantic:

from pydantic import BaseModel
class Item(BaseModel):
name: str
description: Optional[str] = None
price: float
tax: Optional[float] = None
@app.post("/items/")
def create_item(item: Item):
return item

Здесь мы создали модель Item, которая будет использоваться для валидации и обработки данных, полученных через тело запроса. Создав endpoint, принимающий объект Item, мы можем обрабатывать и возвращать полученные данные.

FastAPI автоматически генерирует документацию для вашего API, доступную по адресу /docs. Эта документация позволяет не только просматривать доступные endpoint и их параметры, но и тестировать запросы напрямую из браузера.

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

from fastapi import APIRouter
router = APIRouter()
@router.get("/users/")
def read_users():
return [{"username": "john"}, {"username": "jane"}]
app.include_router(router)

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

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

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

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

Одним из основных достоинств FastAPI является простота установки. Весь процесс занимает лишь несколько минут, а установка происходит через стандартные инструменты, такие как pip. После этого можно создать файл main.py, в котором описываются маршруты и функции приложения.

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

FastAPI также использует Pydantic для валидации данных, что облегчает работу с типами данных и структурирование запросов. Это особенно полезно при работе с такими элементами, как request_body_to_args и dependantbody_params, где важно корректно обрабатывать данные на этапе их получения.

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

FastAPI поддерживает работу с куки и заголовками, что дает возможность удобно хранить и передавать данные между клиентом и сервером. Например, для обработки параметров запроса и тела запроса можно использовать различные методы и декораторы, такие как @app.get и @app.post. Это позволяет легко создавать сложные маршруты и обрабатывать данные в различных форматах.

Для отслеживания ошибок и управления исключениями FastAPI предоставляет удобные инструменты. Например, ошибки валидации запросов можно увидеть через query_errors и body_errors. Также библиотека поддерживает кастомные обработчики ошибок, что позволяет разработчикам создавать более надежные приложения.

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

Глубже в FastAPI: Расширенные возможности

Одной из важных функций является использование зависимостей (get_dependant). С их помощью можно повторно использовать код, управлять доступом к ресурсам и упростить тестирование. Рассмотрим, как это делает FastAPI на практике.

Для начала, создадим файл main.py, где будем описывать наш endpoint:

from fastapi import FastAPI, Depends
app = FastAPI()
def common_parameters(q: str = None, skip: int = 0, limit: int = 10):
return {"q": q, "skip": skip, "limit": limit}
@app.get("/items/")
async def read_items(commons: dict = Depends(common_parameters)):
return commons

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

Теперь посмотрим на работу с куки. FastAPI позволяет легко получать и устанавливать куки. Например, можно использовать Response для установки куки:

from fastapi import FastAPI, Response, Cookie
app = FastAPI()
@app.get("/set-cookie/")
async def set_cookie(response: Response):
response.set_cookie(key="fave-cookie", value="chocolate-chip")
return {"message": "Cookie set"}
@app.get("/read-cookie/")
async def read_cookie(fave_cookie: str = Cookie(None)):
return {"fave_cookie": fave_cookie}

Обработка данных тела запроса (received_body) — еще одна мощная возможность FastAPI. Используя модели Pydantic, можно легко валидировать входные данные:

from pydantic import BaseModel
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = None
@app.post("/items/")
async def create_item(item: Item):
return item

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

@app.get("/users/{user_id}")
async def read_user(user_id: int):
return {"user_id": user_id}

Еще одной полезной функцией является возможность использования APIRouter для организации кода. Это помогает разделить маршруты по логическим блокам:

from fastapi import APIRouter
router = APIRouter()
@router.get("/users/", tags=["users"])
async def get_users():
return [{"username": "johndoe"}]
app.include_router(router)

Не забудем и про события старта и завершения (startup). Эти функции полезны для выполнения кода при запуске и остановке сервера:

@app.on_event("startup")
async def startup_event():
# код, выполняемый при старте
pass
@app.on_event("shutdown")
async def shutdown_event():
# код, выполняемый при остановке
pass

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

Теперь, когда вы узнали о расширенных возможностях FastAPI, настало время применить эти знания на практике и создавать еще более эффективные и производительные приложения!

Работа с базами данных в FastAPI

Следующим шагом будет настройка подключения к базе данных. Важно выбрать подходящий драйвер и ORM (Object-Relational Mapping) для работы с конкретной базой данных. Например, для SQLite или PostgreSQL можно использовать SQLAlchemy и Pydantic для валидации данных.

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

pip install sqlalchemy databases

После установки, создайте файл database.py, где будет храниться конфигурация подключения:

from sqlalchemy import create_engine, MetaData
DATABASE_URL = "sqlite:///./test.db"
database = databases.Database(DATABASE_URL)
metadata = MetaData()
engine = create_engine(
DATABASE_URL
)

Теперь, когда подключение настроено, создадим модель данных. В файле models.py определим схему таблицы с помощью SQLAlchemy:

from sqlalchemy import Table, Column, Integer, String
from .database import metadata
items = Table(
"items",
metadata,
Column("id", Integer, primary_key=True),
Column("name", String, unique=True),
Column("description", String)
)

Далее, важно создать маршрут для взаимодействия с базой данных. В файле main.py напишем endpoint для создания нового элемента:

from fastapi import FastAPI, HTTPException, Depends
from sqlalchemy.orm import Session
from . import models, schemas, crud
from .database import engine, database
models.metadata.create_all(bind=engine)
app = FastAPI()
@app.on_event("startup")
async def startup():
await database.connect()
@app.on_event("shutdown")
async def shutdown():
await database.disconnect()
@app.post("/items/", response_model=schemas.Item)
async def create_item(item: schemas.ItemCreate, db: Session = Depends(get_db)):
db_item = await crud.get_item_by_name(db, name=item.name)
if db_item:
raise HTTPException(status_code=400, detail="Item already exists")
return await crud.create_item(db=db, item=item)

Для завершения настройки создадим файл crud.py, где определим функции для взаимодействия с базой данных:

from sqlalchemy.orm import Session
from . import models, schemas
async def get_item_by_name(db: Session, name: str):
return db.query(models.Item).filter(models.Item.name == name).first()
async def create_item(db: Session, item: schemas.ItemCreate):
db_item = models.Item(name=item.name, description=item.description)
db.add(db_item)
db.commit()
db.refresh(db_item)
return db_item

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

Аутентификация и авторизация в FastAPI

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

Настройка аутентификации

Для начала, давайте установим необходимые зависимости и создадим структуру проекта.

pip install fastapi uvicorn pydantic

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

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from pydantic import BaseModel
app = FastAPI()
class User(BaseModel):
username: str
password: str
# Фиктивная база данных пользователей
fake_users_db = {
"user1": {
"username": "user1",
"password": "password1"
}
}
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
def fake_hash_password(password: str):
return "fakehashed" + password
@app.post("/token")
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
user_dict = fake_users_db.get(form_data.username)
if not user_dict:
raise HTTPException(status_code=400, detail="Неправильное имя пользователя или пароль")
hashed_password = fake_hash_password(form_data.password)
if not hashed_password == user_dict["password"]:
raise HTTPException(status_code=400, detail="Неправильное имя пользователя или пароль")
return {"access_token": form_data.username, "token_type": "bearer"}
@app.get("/users/me")
async def read_users_me(token: str = Depends(oauth2_scheme)):
user = fake_users_db.get(token)
if user is None:
raise HTTPException(status_code=400, detail="Неправильные учетные данные")
return user

В этом примере мы используем OAuth2 для аутентификации. Пользователь отправляет свои учетные данные на endpoint /token, после чего сервер возвращает токен доступа. Токен затем используется для доступа к защищенным ресурсам, таким как /users/me.

Авторизация пользователей

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

def get_current_user(token: str = Depends(oauth2_scheme)):
user = fake_users_db.get(token)
if user is None:
raise HTTPException(status_code=401, detail="Неверные учетные данные")
return user
@app.get("/items/")
async def read_items(user: User = Depends(get_current_user)):
return [{"item_name": "item1"}, {"item_name": "item2"}]

В этом примере функция get_current_user проверяет токен пользователя и возвращает его данные. Если токен недействителен, возвращается ошибка. Маршрут /items/ доступен только аутентифицированным пользователям.

Использование куки для хранения токенов

Токены можно хранить в куки для упрощения работы с ними на стороне клиента. Рассмотрим, как это можно сделать:

from fastapi.responses import JSONResponse
@app.post("/token")
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
user_dict = fake_users_db.get(form_data.username)
if not user_dict:
raise HTTPException(status_code=400, detail="Неправильное имя пользователя или пароль")
hashed_password = fake_hash_password(form_data.password)
if not hashed_password == user_dict["password"]:
raise HTTPException(status_code=400, detail="Неправильное имя пользователя или пароль")
response = JSONResponse(content={"message": "Успешный вход"})
response.set_cookie(key="access_token", value=form_data.username, httponly=True)
return response

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

Заключение

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

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

Интерактивное обновление документации API

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

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

pythonCopy codefrom fastapi import FastAPI

app = FastAPI()

@app.get(«/items/{item_id}»)

def read_item(item_id: int, item_name: str = None):

return {«item_id»: item_id, «item_name»: item_name}

Теперь, когда наше приложение запущено с помощью команды uvicorn main:app --reload, мы можем перейти по адресу http://127.0.0.1:8000/docs и увидеть автоматически сгенерированную документацию.

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

Рассмотрим, как можно обновить и расширить документацию. Добавим новый endpoint в наше приложение:pythonCopy code@app.post(«/items/»)

def create_item(item: dict):

return {«item_name»: item[«name»], «item_description»: item.get(«description»)}

После добавления этого endpoint нам снова надо запустить приложение. Помните, что интерактивное обновление документации происходит автоматически благодаря uvicorn --reload. Теперь в документации появится новый раздел для метода POST с endpoint /items/.

Тип метода	Endpoint	Описание
GET	/items/{item_id}	Получить информацию о предмете по его ID
POST	/items/	Создать новый предмет

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

Важно отметить, что помимо основного функционала, FastAPI поддерживает расширенные возможности, такие как обработка ошибок, валидация данных и многое другое. Например, вы можете определить пользовательские ошибки и добавить их в документацию, чтобы упростить процесс отладки:pythonCopy codefrom fastapi import HTTPException

@app.post(«/items/»)

def create_item(item: dict):

if «name» not in item:

raise HTTPException(status_code=400, detail=»Item name is required»)

return {«item_name»: item[«name»], «item_description»: item.get(«description»)}

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

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