Изучите FastAPI на одном проекте
Создайте полноценное веб-приложение с FastAPI! От основ до аутентификации, баз данных и загрузки медиафайлов. Пошаговое руководство на реальном проекте.
Данная статья описывает процесс разработки серверной части (backend) приложения для обмена фото и видео, используя фреймворк FastAPI. Проект охватывает полный цикл создания API, включая базовые операции с данными, подключение к базе данных, обработку загрузки файлов и реализацию аутентификации пользователей. Предполагается наличие базового опыта работы с языком Python.
Введение
Цель проекта — создание полнофункционального API для приложения, позволяющего пользователям загружать и просматривать фото и видео. В рамках разработки будут рассмотрены ключевые концепции веб-приложений и API, а также практические аспекты реализации с использованием современных инструментов.
Основные концепции веб-приложений и API
URL, Пути и Эндпоинты
URL (Uniform Resource Locator) — это адрес ресурса в сети. Он состоит из нескольких компонентов:
- Схема: Протокол передачи данных (например,
http,https). - Домен: Имя сервера или IP-адрес (например,
example.com). - Путь (Path): Указывает на конкретный ресурс или страницу на сервере (например,
/users/profile). Путь определяет эндпоинт — точку входа API, к которой обращается клиент.
Параметры запроса (Query Parameters)
Параметры запроса добавляются к URL после знака вопроса (?) и используются для фильтрации или уточнения данных. Они представляют собой пары ключ-значение, разделенные амперсандом (&).
Пример: /posts?category=technology&sort=date
Структура Запроса и Ответа
Взаимодействие между клиентом (например, веб-браузер или мобильное приложение) и сервером происходит через запросы и ответы.
Запрос (Request):
- Метод (HTTP Method): Определяет действие, которое клиент хочет выполнить над ресурсом. Основные методы:
GET: Получение данных.POST: Создание нового ресурса.PUT/PATCH: Обновление существующего ресурса.DELETE: Удаление ресурса.
- Путь (Path): Эндпоинт API.
- Заголовок (Headers): Содержит метаданные запроса, такие как тип контента, информация об аутентификации (например, JWT-токен).
- Тело (Body): Содержит данные, отправляемые на сервер (например, данные формы, JSON-объект). Используется с методами
POST,PUT,PATCH.
Ответ (Response):
- Код состояния (Status Code): Трехзначное число, указывающее на результат обработки запроса. Наиболее распространенные:
200 OK: Успешный запрос.201 Created: Ресурс успешно создан.204 No Content: Успешный запрос, но нет тела ответа.400 Bad Request: Некорректный запрос клиента.401 Unauthorized: Требуется аутентификация.403 Forbidden: Доступ запрещен.404 Not Found: Ресурс не найден.500 Internal Server Error: Ошибка на стороне сервера.
- Заголовок (Headers): Метаданные ответа, например, тип контента.
- Тело (Body): Данные, возвращаемые сервером (часто в формате JSON).
Настройка проекта и установка зависимостей
Для начала работы необходимо инициализировать проект и установить необходимые библиотеки. Рекомендуется использовать менеджер пакетов uv (или pip).
-
Инициализация проекта:
uv init .Эта команда создает файл
pyproject.tomlдля управления зависимостями проекта. -
Установка зависимостей:
uv add fastapi uvicorn python-dotenv sqlalchemy fastapi-users imagekit-io aiosqlitefastapi: Основной фреймворк.uvicorn: ASGI-сервер для запуска FastAPI-приложений.python-dotenv: Для загрузки переменных окружения из файла.env.sqlalchemy: ORM для работы с базами данных.fastapi-users: Библиотека для быстрой реализации аутентификации пользователей.imagekit-io: SDK для интеграции с сервисом ImageKit для обработки медиафайлов.aiosqlite: Асинхронный драйвер для работы с SQLite.
-
Переменные окружения: Создайте файл
.envв корне проекта для хранения конфиденциальных данных, таких как ключи API ImageKit.IMAGEKIT_PRIVATE_KEY=your_private_key IMAGEKIT_PUBLIC_KEY=your_public_key IMAGEKIT_URL_ENDPOINT=your_url_endpointНеобходимо зарегистрироваться на ImageKit и получить соответствующие ключи.
Основы FastAPI
Создание экземпляра приложения
Основной файл приложения (например, app/main.py или app/app.py) начинается с импорта FastAPI и создания экземпляра приложения.
# app/app.py
from fastapi import FastAPI
app = FastAPI()
Определение эндпоинтов
Эндпоинты определяются с помощью декораторов, соответствующих HTTP-методам.
# app/app.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Hello, World!"}
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
return {"item_id": item_id, "q": q}
@app.get("/"): Определяет GET-эндпоинт по корневому пути.@app.get("/items/{item_id}"): Определяет GET-эндпоинт с параметром путиitem_id. FastAPI автоматически преобразуетitem_idвintи выполняет валидацию.q: str | None = None: Определяет необязательный параметр запросаqтипаstr.
Запуск приложения
Приложение запускается с помощью ASGI-сервера uvicorn. Создайте файл main.py для запуска сервера.
# main.py
import uvicorn
from app.app import app # Импортируем экземпляр FastAPI из app/app.py
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)
Запуск:
uvicorn main:app --reload
или
uv run main.py
Автоматическая документация
FastAPI автоматически генерирует интерактивную документацию API на основе кода.
- Swagger UI:
/docs - ReDoc:
/redoc
Создание API: Основной функционал
Модели данных и Схемы (Pydantic)
Pydantic используется для определения схем данных, которые обеспечивают валидацию входящих и исходящих данных.
# app/schemas.py
from pydantic import BaseModel
from typing import Optional
class PostBase(BaseModel):
title: str
content: str
class PostCreate(PostBase):
pass
class Post(PostBase):
id: int # Или UUID, если используется
class Config:
orm_mode = True # Для работы с SQLAlchemy моделями
Параметры пути и запроса
- Параметры пути: Динамические сегменты URL.
@app.get("/posts/{post_id}") async def get_post(post_id: int): # Логика получения поста по ID return {"post_id": post_id} - Параметры запроса: Необязательные или обязательные параметры после
?.@app.get("/posts") async def get_posts(limit: int = 10, skip: int = 0): # Логика получения списка постов с фильтрацией return {"limit": limit, "skip": skip}
Тело запроса (Request Body)
Для отправки данных в теле запроса (например, при создании поста) используется схема Pydantic.
# app/app.py
from fastapi import FastAPI
from app.schemas import PostCreate, Post
from typing import List
app = FastAPI()
# Временное хранилище данных (заменится базой данных)
posts_db = {}
post_id_counter = 1
@app.post("/posts", response_model=Post)
async def create_post(post: PostCreate):
global post_id_counter
new_post = Post(id=post_id_counter, title=post.title, content=post.content)
posts_db[post_id_counter] = new_post
post_id_counter += 1
return new_post
Типизация выходных данных
Указание типа возвращаемого значения улучшает документацию и валидацию.
# app/app.py
from app.schemas import PostCreate, Post
from typing import List
# ... (предыдущий код)
@app.post("/posts", response_model=Post)
async def create_post(post: PostCreate):
# ... (логика создания поста)
return new_post
@app.get("/posts", response_model=List[Post])
async def get_all_posts():
return list(posts_db.values())
Интеграция с базой данных (SQLAlchemy & AsyncIO)
Для постоянного хранения данных используется база данных SQLite с асинхронным доступом.
Настройка базы данных
Создайте файл app/db.py для настройки подключения и моделей данных.
# app/db.py
from sqlalchemy import create_engine, Column, Integer, String, Text, DateTime, ForeignKey
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.ext.asyncio import async_sessionmaker
from datetime import datetime
import uuid
DATABASE_URL = "sqlite+aiosqlite:///./test.db"
# Создание асинхронного движка
engine = create_async_engine(DATABASE_URL, echo=True)
# Создание фабрики асинхронных сессий
AsyncSessionLocal = async_sessionmaker(
autocommit=False,
autoflush=False,
class_=AsyncSession
)
# Базовый класс для декларативных моделей
Base = declarative_base()
# Модель данных для поста
class Post(Base):
__tablename__ = "posts"
id = Column(Integer, primary_key=True, index=True) # Или UUID
title = Column(String, index=True)
content = Column(Text)
created_at = Column(DateTime, default=datetime.utcnow)
user_id = Column(Integer, ForeignKey("users.id")) # Связь с пользователем
user = relationship("User", back_populates="posts")
# Модель данных для пользователя (для FastAPI-Users)
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True) # Или UUID
email = Column(String, unique=True, index=True)
hashed_password = Column(String)
is_active = Column(Boolean, default=True)
is_superuser = Column(Boolean, default=False)
is_verified = Column(Boolean, default=False)
posts = relationship("Post", back_populates="user")
# Функция для получения асинхронной сессии
async def get_async_session() -> AsyncSession:
async with AsyncSessionLocal() as session:
yield session
# Функция для создания таблиц
async def create_db_tables():
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
# Для FastAPI-Users
async def get_user_db(session: AsyncSession = Depends(get_async_session)):
yield SQLAlchemyUserDatabase(session, User)
Интеграция с FastAPI
Используйте lifespan для автоматического создания таблиц при запуске приложения.
# app/app.py
from fastapi import FastAPI, Depends, HTTPException, File, UploadFile, Form
from app.schemas import PostCreate, Post, UserCreate, UserRead, UserUpdate # Импортируем схемы пользователей
from app.db import Post as PostModel, User as UserModel, get_async_session, create_db_tables, get_user_db # Импортируем модели БД
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import Session
from sqlalchemy import select
from contextlib import asynccontextmanager
from typing import List, Optional
import shutil
import os
import uuid
# Импорт для ImageKit
from imagekitio import ImageKit
from imagekitio.models.models import UploadFileRequestOptions
from dotenv import load_dotenv
load_dotenv() # Загружаем переменные окружения
# Инициализация ImageKit
imagekit = ImageKit(
private_key=os.getenv("IMAGEKIT_PRIVATE_KEY"),
public_key=os.getenv("IMAGEKIT_PUBLIC_KEY"),
url_endpoint=os.getenv("IMAGEKIT_URL_ENDPOINT")
)
# --- Аутентификация пользователей (FastAPI-Users) ---
from fastapi_users import FastAPIUsers, BaseUserManager, UUID_ID
from fastapi_users.authentication import (
AuthenticationBackend,
BearerTransport,
JWTStrategy,
)
from fastapi_users.db import SQLAlchemyUserDatabase
# Секретный ключ для JWT (должен быть надежным и храниться в .env)
SECRET = os.getenv("JWT_SECRET_KEY", "your_super_secret_key_here") # Рекомендуется генерировать случайный ключ
# Менеджер пользователей
class UserManager(BaseUserManager[UUID_ID, UserModel]):
reset_password_token_secret = SECRET
verification_token_secret = SECRET
async def get_user_manager(user_db: SQLAlchemyUserDatabase = Depends(get_user_db)):
yield UserManager(user_db)
# Транспорт для токенов (Bearer Token)
bearer_transport = BearerTransport(tokenUrl="auth/jwt/login")
# Стратегия JWT
def get_jwt_strategy() -> JWTStrategy:
return JWTStrategy(secret=SECRET, lifetime_seconds=3600) # Токен действителен 1 час
# Бэкенд аутентификации
auth_backend = AuthenticationBackend(
name="jwt",
transport=bearer_transport,
get_strategy=get_jwt_strategy,
)
fastapi_users = FastAPIUsers[UserModel, UUID_ID](
get_user_manager, auth_backend
)
# Получение текущего активного пользователя
current_active_user = fastapi_users.current_user(active=True)
# --- Контекстный менеджер для жизненного цикла приложения ---
@asynccontextmanager
async def lifespan(app: FastAPI):
await create_db_tables() # Создаем таблицы при старте
yield
app = FastAPI(lifespan=lifespan)
# --- Включение маршрутов аутентификации ---
app.include_router(
fastapi_users.get_auth_router(auth_backend), prefix="/auth/jwt", tags=["auth"]
)
app.include_router(
fastapi_users.get_register_router(UserRead, UserCreate), prefix="/auth", tags=["auth"]
)
app.include_router(
fastapi_users.get_reset_password_router(), prefix="/auth", tags=["auth"]
)
app.include_router(
fastapi_users.get_verify_router(), prefix="/auth", tags=["auth"]
)
app.include_router(
fastapi_users.get_users_router(), prefix="/users", tags=["users"]
)
# --- API Эндпоинты ---
# Получение текущего пользователя (защищенный эндпоинт)
@app.get("/users/me", response_model=UserRead)
async def read_users_me(current_user: UserModel = Depends(current_active_user)):
return current_user
# Получение всех постов (защищенный эндпоинт)
@app.get("/feed", response_model=List[Post])
async def get_feed(
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user) # Требуется аутентификация
):
# Запрос постов с информацией о пользователе
stmt = select(PostModel).order_by(PostModel.created_at.desc())
result = await session.execute(stmt)
posts = result.scalars().all()
# Формирование ответа с информацией о пользователе и статусе владельца
posts_data = []
for post in posts:
is_owner = (post.user_id == current_user.id)
posts_data.append({
"id": post.id,
"title": post.title,
"content": post.content,
"created_at": post.created_at,
"user_id": post.user_id,
"file_url": post.file_url,
"file_type": post.file_type,
"file_name": post.file_name,
"is_owner": is_owner,
"user_email": post.user.email if post.user else "Unknown"
})
return posts_data
# Загрузка файла (фото/видео) и создание поста (защищенный эндпоинт)
@app.post("/upload", response_model=Post)
async def upload_file(
file: UploadFile = File(...),
caption: str = Form(...),
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user) # Требуется аутентификация
):
# Генерация уникального имени файла
file_extension = os.path.splitext(file.filename)[1]
unique_filename = f"{uuid.uuid4()}{file_extension}"
# Загрузка файла в ImageKit
try:
upload_result = imagekit.upload_file(
file=file.file,
file_name=unique_filename,
options=UploadFileRequestOptions(
use_unique_file_name=True,
tags=["backend_upload"],
folder="uploads" # Опционально: папка в ImageKit
)
)
file_url = upload_result.url
file_type = "video" if file.content_type.startswith("video/") else "image"
file_name = upload_result.name
# Создание нового поста в базе данных
new_post = PostModel(
title=caption, # Используем caption как заголовок
content=caption, # Или можно добавить отдельное поле для контента
user_id=current_user.id,
file_url=file_url,
file_type=file_type,
file_name=file_name
)
session.add(new_post)
await session.commit()
await session.refresh(new_post)
# Возвращаем данные поста, включая URL и информацию о пользователе
return {
"id": new_post.id,
"title": new_post.title,
"content": new_post.content,
"created_at": new_post.created_at,
"user_id": new_post.user_id,
"file_url": new_post.file_url,
"file_type": new_post.file_type,
"file_name": new_post.file_name,
"user_email": current_user.email # Добавляем email текущего пользователя
}
except Exception as e:
raise HTTPException(status_code=500, detail=f"File upload failed: {e}")
# Удаление поста (защищенный эндпоинт)
@app.delete("/posts/{post_id}", response_model=dict)
async def delete_post(
post_id: int,
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user) # Требуется аутентификация
):
# Получаем пост из базы данных
stmt = select(PostModel).where(PostModel.id == post_id)
result = await session.execute(stmt)
post = result.scalars().first()
if not post:
raise HTTPException(status_code=404, detail="Post not found")
# Проверка прав доступа: только автор поста может его удалить
if post.user_id != current_user.id:
raise HTTPException(status_code=403, detail="You do not have permission to delete this post")
# Удаление поста из базы данных
await session.delete(post)
await session.commit()
return {"message": "Post deleted successfully"}
# --- Дополнительные схемы для пользователей ---
# Эти схемы наследуются от стандартных схем FastAPI-Users,
# но могут быть расширены при необходимости.
from fastapi_users import schemas
class UserRead(schemas.BaseUser[uuid.UUID]):
email: str
is_active: bool = True
is_superuser: bool = False
is_verified: bool = False
id: uuid.UUID # Убедитесь, что ID соответствует типу в модели БД
class UserCreate(schemas.BaseUserCreate):
password: str
email: str
is_active: bool = True
is_superuser: bool = False
is_verified: bool = False
class UserUpdate(schemas.BaseUserUpdate):
password: Optional[str] = None
email: Optional[str] = None
is_active: Optional[bool] = None
is_superuser: Optional[bool] = None
is_verified: Optional[bool] = None
# Обновление модели Post для включения информации о пользователе и статусе владельца
class PostWithUser(Post):
user_id: Optional[int] # Или UUID
file_url: str
file_type: str
file_name: str
is_owner: bool
user_email: str
# Обновление эндпоинта get_feed для возврата PostWithUser
@app.get("/feed", response_model=List[PostWithUser])
async def get_feed(
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user)
):
stmt = select(PostModel).order_by(PostModel.created_at.desc())
result = await session.execute(stmt)
posts = result.scalars().all()
posts_data = []
for post in posts:
is_owner = (post.user_id == current_user.id)
posts_data.append(PostWithUser(
id=post.id,
title=post.title,
content=post.content,
created_at=post.created_at,
user_id=post.user_id,
file_url=post.file_url,
file_type=post.file_type,
file_name=post.file_name,
is_owner=is_owner,
user_email=post.user.email if post.user else "Unknown"
))
return posts_data
# Обновление эндпоинта upload_file для возврата PostWithUser
@app.post("/upload", response_model=PostWithUser)
async def upload_file(
file: UploadFile = File(...),
caption: str = Form(...),
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user)
):
file_extension = os.path.splitext(file.filename)[1]
unique_filename = f"{uuid.uuid4()}{file_extension}"
try:
upload_result = imagekit.upload_file(
file=file.file,
file_name=unique_filename,
options=UploadFileRequestOptions(
use_unique_file_name=True,
tags=["backend_upload"],
folder="uploads"
)
)
file_url = upload_result.url
file_type = "video" if file.content_type.startswith("video/") else "image"
file_name = upload_result.name
new_post = PostModel(
title=caption,
content=caption,
user_id=current_user.id,
file_url=file_url,
file_type=file_type,
file_name=file_name
)
session.add(new_post)
await session.commit()
await session.refresh(new_post)
return PostWithUser(
id=new_post.id,
title=new_post.title,
content=new_post.content,
created_at=new_post.created_at,
user_id=new_post.user_id,
file_url=new_post.file_url,
file_type=new_post.file_type,
file_name=new_post.file_name,
is_owner=True, # Новый пост всегда принадлежит текущему пользователю
user_email=current_user.email
)
except Exception as e:
raise HTTPException(status_code=500, detail=f"File upload failed: {e}")
# Обновление модели Post для включения ForeignKey и relationship
# В app/db.py:
# Добавить в класс Post:
# user_id = Column(Integer, ForeignKey("users.id"))
# user = relationship("User", back_populates="posts")
# Добавить в класс User:
# posts = relationship("Post", back_populates="user")
# Убедиться, что User и Post наследуются от Base и имеют соответствующие поля.
# Также необходимо обновить схемы Pydantic (PostCreate, Post, UserRead, UserCreate, UserUpdate)
# и убедиться, что они соответствуют моделям SQLAlchemy.
Загрузка файлов с ImageKit
Интеграция с ImageKit позволяет легко управлять медиафайлами.
-
Инициализация ImageKit: В
app/app.pyимпортируйте и инициализируйте клиент ImageKit, используя ключи из.env. -
Обработка загрузки: Эндпоинт
/uploadпринимаетUploadFileиcaptionиз формы. Файл загружается в ImageKit, а полученный URL сохраняется в базе данных вместе с информацией о посте и пользователе.# В app/app.py from fastapi import File, UploadFile, Form # ... (другие импорты) @app.post("/upload", response_model=PostWithUser) async def upload_file( file: UploadFile = File(...), caption: str = Form(...), session: AsyncSession = Depends(get_async_session), current_user: UserModel = Depends(current_active_user) ): # ... (логика загрузки в ImageKit и сохранения в БД) pass
Трансформации медиафайлов
ImageKit позволяет применять трансформации к изображениям и видео прямо через URL. Например, изменение размера, добавление текста, применение эффектов.
Пример URL с трансформациями:
https://ik.imagekit.io/your_public_key/your_file_name.jpg?tr=w-300,h-200,fo-auto
Аутентификация и Авторизация (FastAPI-Users)
FastAPI-Users упрощает реализацию аутентификации пользователей с использованием JWT (JSON Web Tokens).
Концепция JWT
JWT — это стандарт для безопасной передачи информации между сторонами в виде JSON-объекта. Он состоит из трех частей: заголовка, полезной нагрузки и подписи. Токен подписывается секретным ключом сервера, что позволяет проверить его подлинность.
Настройка FastAPI-Users
- Модели пользователей: Определите модель
Userвapp/db.py, которая наследуется отSQLAlchemyUserTableи включает необходимые поля (email, пароль, роли). - Схемы пользователей: Создайте схемы
UserRead,UserCreate,UserUpdateвapp/schemas.py. - Менеджер пользователей и бэкенд аутентификации: Настройте
UserManager,BearerTransport,JWTStrategyиAuthenticationBackendвapp/app.py. - Включение маршрутов: Используйте
app.include_router()для добавления стандартных маршрутов аутентификации (регистрация, вход, сброс пароля).
Защита эндпоинтов
Для защиты эндпоинтов добавьте зависимость Depends(current_active_user) к функциям эндпоинтов. Если пользователь не аутентифицирован, запрос будет отклонен.
# app/app.py
from fastapi_users import FastAPIUsers, BaseUserManager, UUID_ID
from fastapi_users.authentication import (
AuthenticationBackend,
BearerTransport,
JWTStrategy,
)
from fastapi_users.db import SQLAlchemyUserDatabase
# ... (определение моделей и схем)
# Получение текущего активного пользователя
current_active_user = fastapi_users.current_user(active=True)
@app.get("/protected-route")
async def protected_route(current_user: UserModel = Depends(current_active_user)):
return {"message": f"Hello, {current_user.email}!"}
Авторизация (Проверка прав доступа)
При удалении поста необходимо убедиться, что текущий пользователь является автором поста.
# app/app.py
@app.delete("/posts/{post_id}", response_model=dict)
async def delete_post(
post_id: int,
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user)
):
# ... (получение поста)
if post.user_id != current_user.id:
raise HTTPException(status_code=403, detail="You do not have permission to delete this post")
# ... (удаление поста)
Фронтенд (Streamlit)
Для демонстрации работы API может быть создан простой фронтенд с использованием библиотеки Streamlit. Streamlit позволяет быстро создавать интерактивные веб-приложения на Python.
-
Установка Streamlit:
uv add streamlit -
Создание файла фронтенда: Создайте файл
frontend.pyс кодом, который взаимодействует с API (отправляет запросы на аутентификацию, загрузку файлов, получение ленты). Код фронтенда обычно включает:- Управление состоянием сессии (хранение JWT-токена).
- Функции для отправки HTTP-запросов с токеном в заголовке.
- Интерфейсы для регистрации, входа, загрузки файлов, отображения ленты.
-
Запуск Streamlit:
uv run streamlit run frontend.py
Заключение
Разработанное приложение демонстрирует комплексный подход к созданию современного веб-API с использованием FastAPI. Оно включает в себя обработку запросов, взаимодействие с базой данных, безопасную аутентификацию пользователей и интеграцию с внешними сервисами для обработки медиафайлов. Полученный API является основой для создания масштабируемых и надежных веб-приложений.
Обзор видео
Обзор видео и демонстрация готового проекта.
- Демонстрация фото/видео приложения.
- Возможность входа, просмотра ленты, загрузки контента.
- Использование Streamlit для фронтенда.
Веб-приложение Архитектура и Теория
Объяснение архитектуры веб-приложения и основных теоретических концепций.
- Понятия URL, домена, пути (endpoint).
- Роль query parameters.
- Структура запроса (request) и ответа (response).
- HTTP методы: GET, POST, PUT, DELETE.
- HTTP статусы (200, 404 и др.).
Настройка проекта и установка
Настройка окружения разработки и установка необходимых зависимостей.
- Использование
uvдля управления зависимостями. - Установка
fastapi,python-dotenv,fastapi-users,sqlalchemy,imagekitio,uvicorn. - Создание файла
.envдля хранения ключей.
Настройка FastAPI и основы
Базовое создание приложения FastAPI и настройка первого эндпоинта.
- Создание экземпляра
FastAPI. - Определение эндпоинта
/hello-worldс методом GET. - Возврат JSON-ответа.
- Запуск сервера с помощью
uvicorn. - Использование
/docsдля автоматической документации.
GET и получение постов
Работа с эндпоинтами для получения данных, включая параметры пути и запроса.
- Создание эндпоинта
/postsдля получения всех постов. - Использование path parameters (например,
/post/{id}) для получения конкретного поста. - Обработка ошибок (HTTPException 404).
- Использование query parameters (например,
limit) для фильтрации.
Request Body и POST
Реализация эндпоинта POST для создания новых записей с использованием Pydantic моделей.
- Определение схемы данных с помощью Pydantic (
PostCreate). - Прием данных через request body.
- Автоматическая валидация данных FastAPI.
- Создание нового поста и возврат его.
Подключение к базе данных
Подключение к базе данных SQLite и определение моделей данных.
- Использование SQLAlchemy для ORM.
- Настройка асинхронного движка
create_async_engine. - Определение модели
Postс полямиid,caption,url,file_type,file_name,created_at. - Настройка жизненного цикла приложения (
lifespan) для создания таблиц.
Загрузка изображений и видео (ImageKit)
Реализация загрузки файлов (изображений и видео) с использованием ImageKit.
- Интеграция с ImageKit для хранения и обработки медиа.
- Создание временных файлов для загрузки.
- Использование
upload_fileизimagekitio. - Сохранение URL файла и метаданных в базе данных.
- Обработка ошибок загрузки.
Удаление постов
Реализация функционала удаления записей из базы данных.
- Создание эндпоинта DELETE
/post/{post_id}. - Получение ID поста из path parameter.
- Поиск поста в базе данных.
- Удаление поста и подтверждение операции.
Аутентификация пользователей и JWT токены
Настройка аутентификации пользователей с использованием JWT и FastAPI Users.
- Использование
fastapi-usersдля управления пользователями. - Настройка JWT стратегии и аутентификационного бэкенда.
- Определение моделей
Userи связей сPost. - Создание эндпоинтов для регистрации, входа, выхода.
Защита эндпоинтов
Защита эндпоинтов API, чтобы доступ имели только аутентифицированные пользователи.
- Использование
Depends(current_active_user)для защиты эндпоинтов. - Проверка прав доступа при удалении поста.
- Отображение информации о пользователе в ленте.
- Использование Streamlit для фронтенда.
Streamlit Frontend
Создание простого пользовательского интерфейса с помощью Streamlit для взаимодействия с API.
- Использование Streamlit для создания UI.
- Управление JWT токеном в сессии.
- Реализация логики входа, регистрации, загрузки файлов и отображения ленты.
- Применение ImageKit для отображения изображений с трансформациями.
