~3m2:05:44
Tech With Tim

Learn Fast API With This ONE Project

30 окт. 2025 г.

Read: ~3m · You save: 123 min

Изучите 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).

  1. Инициализация проекта:

    uv init .
    

    Эта команда создает файл pyproject.toml для управления зависимостями проекта.

  2. Установка зависимостей:

    uv add fastapi uvicorn python-dotenv sqlalchemy fastapi-users imagekit-io aiosqlite
    
    • fastapi: Основной фреймворк.
    • uvicorn: ASGI-сервер для запуска FastAPI-приложений.
    • python-dotenv: Для загрузки переменных окружения из файла .env.
    • sqlalchemy: ORM для работы с базами данных.
    • fastapi-users: Библиотека для быстрой реализации аутентификации пользователей.
    • imagekit-io: SDK для интеграции с сервисом ImageKit для обработки медиафайлов.
    • aiosqlite: Асинхронный драйвер для работы с SQLite.
  3. Переменные окружения: Создайте файл .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 позволяет легко управлять медиафайлами.

  1. Инициализация ImageKit: В app/app.py импортируйте и инициализируйте клиент ImageKit, используя ключи из .env.

  2. Обработка загрузки: Эндпоинт /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

  1. Модели пользователей: Определите модель User в app/db.py, которая наследуется от SQLAlchemyUserTable и включает необходимые поля (email, пароль, роли).
  2. Схемы пользователей: Создайте схемы UserRead, UserCreate, UserUpdate в app/schemas.py.
  3. Менеджер пользователей и бэкенд аутентификации: Настройте UserManager, BearerTransport, JWTStrategy и AuthenticationBackend в app/app.py.
  4. Включение маршрутов: Используйте 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.

  1. Установка Streamlit:

    uv add streamlit
    
  2. Создание файла фронтенда: Создайте файл frontend.py с кодом, который взаимодействует с API (отправляет запросы на аутентификацию, загрузку файлов, получение ленты). Код фронтенда обычно включает:

    • Управление состоянием сессии (хранение JWT-токена).
    • Функции для отправки HTTP-запросов с токеном в заголовке.
    • Интерфейсы для регистрации, входа, загрузки файлов, отображения ленты.
  3. Запуск 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 для отображения изображений с трансформациями.