Что такое media files?

Media Files в веб-приложениях

Определение

Media Files (медиа-файлы) — это пользовательские файлы, которые загружаются на сервер и хранятся отдельно от исходного кода приложения. К ним относятся изображения, видео, аудио, документы и другие файлы, загруженные пользователями.

В контексте Django и веб-приложений, media files — это файлы, обслуживаемые сервером по запросу пользователей (не статические файлы приложения).

Отличие Media Files от Static Files

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

my_project/
├── manage.py
├── my_project/
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── app/
│   ├── models.py
│   ├── views.py
│   └── uploads/
├── static/
└── media/
    ├── images/
    ├── videos/
    └── documents/

Конфигурация Django для Media Files

# settings.py
import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent

# Директория для media files
MEDIA_URL = "/media/"
MEDIA_ROOT = os.path.join(BASE_DIR, "media")

# Директория для static files
STATIC_URL = "/static/"
STATIC_ROOT = os.path.join(BASE_DIR, "static")

Обслуживание Media Files в Django

Для разработки (DEBUG=True)

# urls.py
from django.conf import settings
from django.conf.urls.static import static
from django.contrib import admin
from django.urls import path

from app.views import upload_view

urlpatterns = [
    path("admin/", admin.site.urls),
    path("upload/", upload_view, name="upload"),
]

if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Для production (обслуживание через web-сервер)

server {
    listen 80;
    server_name example.com;
    
    location /static/ {
        alias /var/www/myapp/static/;
        expires 30d;
    }
    
    location /media/ {
        alias /var/www/myapp/media/;
    }
    
    location / {
        proxy_pass http://127.0.0.1:8000;
    }
}

Модель Django для загрузки файлов

from django.db import models
from django.core.validators import FileExtensionValidator

class UserProfile(models.Model):
    user = models.OneToOneField("auth.User", on_delete=models.CASCADE)
    
    avatar = models.ImageField(
        upload_to="avatars/%Y/%m/%d/",
        default="avatars/default.png",
        null=True,
        blank=True
    )
    
    resume = models.FileField(
        upload_to="resumes/%Y/%m/",
        validators=[FileExtensionValidator(["pdf", "doc", "docx"])],
        null=True,
        blank=True
    )
    
    class Meta:
        db_table = "user_profiles"
    
    def __str__(self):
        return f"{self.user.username} profile"

Загрузка файлов в view

from django.shortcuts import render, redirect
from django.views.decorators.http import require_http_methods
from .models import UserProfile
from .forms import AvatarUploadForm

@require_http_methods(["GET", "POST"])
def upload_avatar(request):
    user_profile = request.user.userprofile
    
    if request.method == "POST":
        form = AvatarUploadForm(request.POST, request.FILES)
        if form.is_valid():
            uploaded_file = request.FILES["avatar"]
            user_profile.avatar = uploaded_file
            user_profile.save()
            return redirect("profile")
    else:
        form = AvatarUploadForm()
    
    return render(request, "upload_avatar.html", {"form": form})

Форма для загрузки файлов

from django import forms
from .models import UserProfile

class AvatarUploadForm(forms.ModelForm):
    avatar = forms.ImageField(
        label="Выберите аватар",
        widget=forms.FileInput(attrs={"accept": "image/*"}),
    )
    
    class Meta:
        model = UserProfile
        fields = ["avatar"]

HTML форма для загрузки

<form method="post" enctype="multipart/form-data">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Загрузить</button>
</form>

Обработка файлов в Python

from django.core.files.storage import default_storage
from django.core.files.base import ContentFile
from PIL import Image
import io

def compress_image(uploaded_file, quality=85):
    image = Image.open(uploaded_file)
    
    if image.mode == "RGBA":
        image = image.convert("RGB")
    
    buffer = io.BytesIO()
    image.save(buffer, format="JPEG", quality=quality)
    buffer.seek(0)
    
    return ContentFile(buffer.read())

def save_compressed_avatar(user_profile, uploaded_file):
    compressed = compress_image(uploaded_file)
    user_profile.avatar.save(
        f"{user_profile.user.id}_avatar.jpg",
        compressed,
        save=True
    )

Работа с S3 (AWS) для storage media

# settings.py
if not DEBUG:
    AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
    AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
    AWS_STORAGE_BUCKET_NAME = "my-bucket"
    AWS_S3_REGION_NAME = "eu-west-1"
    
    STORAGES = {
        "default": {
            "BACKEND": "storages.backends.s3boto3.S3Boto3Storage",
            "OPTIONS": {
                "bucket_name": AWS_STORAGE_BUCKET_NAME,
            },
        },
    }
    
    MEDIA_URL = f"https://{AWS_STORAGE_BUCKET_NAME}.s3.amazonaws.com/media/"

Безопасность при работе с Media Files

from django.core.exceptions import ValidationError

def validate_file_type(file):
    import magic
    
    mime = magic.from_buffer(file.read(1024), mime=True)
    allowed_types = ["image/jpeg", "image/png", "application/pdf"]
    
    if mime not in allowed_types:
        raise ValidationError(f"File type {mime} not allowed")

class AvatarUploadForm(forms.ModelForm):
    avatar = forms.ImageField()
    
    def clean_avatar(self):
        file = self.cleaned_data["avatar"]
        max_size = 5 * 1024 * 1024
        
        if file.size > max_size:
            raise ValidationError("File size exceeds 5 MB")
        
        return file

Удаление старых media files

from django.core.management.base import BaseCommand
from django.core.files.storage import default_storage

class Command(BaseCommand):
    def handle(self, *args, **options):
        from app.models import UserProfile
        
        used_files = set()
        for profile in UserProfile.objects.all():
            if profile.avatar:
                used_files.add(profile.avatar.name)
        
        for file_path in default_storage.listdir("avatars")[1]:
            full_path = f"avatars/{file_path}"
            if full_path not in used_files:
                default_storage.delete(full_path)
                self.stdout.write(f"Deleted: {full_path}")

Итоговая схема

Media Files — это пользовательские загруженные файлы, которые хранятся отдельно от статических файлов приложения. Django предоставляет удобный механизм управления (FileField, ImageField), а для production нужно правильно конфигурировать web-сервер или использовать облачное хранилище (S3).