В чём разница между static files и media files?

Разница между static files и media files

Основные определения

• Static files — файлы, созданные разработчиком и поставляемые с приложением (CSS, JS, изображения логотипов, шрифты)
• Media files — файлы, загруженные пользователями (аватары, документы, фотографии)

Структура проекта Django:
project/
├── static/          <- Статичные файлы (разработчик создал)
│   ├── css/
│   ├── js/
│   └── images/
├── media/           <- Медиа файлы (пользователи загрузили)
│   ├── avatars/
│   ├── documents/
│   └── uploads/
└── manage.py

Практические примеры

Static files

# settings.py (Django)
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')  # Для продакшена

# В шаблоне
{% load static %}
<link rel="stylesheet" href="{% static 'css/style.css' %}">
<script src="{% static 'js/app.js' %}"></script>
<img src="{% static 'images/logo.png' %}">

# Содержимое static/css/style.css
body {
    font-family: Arial, sans-serif;
    background-color: #f5f5f5;
}

Media files

# models.py (Django)
from django.db import models

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    avatar = models.ImageField(upload_to='avatars/')  # В media/
    bio_document = models.FileField(upload_to='documents/')  # В media/

# settings.py
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')  # Где хранить

# urls.py (для локальной разработки)
from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [...]

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

# В шаблоне
<img src="{{ user.profile.avatar.url }}">
<!-- Результат: <img src="/media/avatars/user123_avatar.jpg"> -->

<a href="{{ user.profile.bio_document.url }}">Download Bio</a>
<!-- Результат: <a href="/media/documents/resume_2024.pdf">Download Bio</a> -->

Сравнительная таблица

Инициализация файлов

Static files — фиксированные

# project/static/css/style.css создан один раз
/* Будет одинаковым для всех пользователей */
body {
    background: white;
    font-family: Arial;
}

# Версионирование через Django
# settings.py
STATIC_URL = '/static/'
STATIC_VERSION = '1.2.3'  # Для кэширования браузером

# Шаблон
<link rel="stylesheet" href="{% static 'css/style.css' %}?v={{ STATIC_VERSION }}">

Media files — динамические

# model upload_to parameter
class BlogPost(models.Model):
    image = models.ImageField(upload_to='blog_images/%Y/%m/%d/')
    # Сохранится как: media/blog_images/2024/03/22/image.jpg

# В views
if request.method == 'POST':
    image = request.FILES['image']
    post = BlogPost.objects.create(
        image=image
    )
    # Django автоматически сохраняет в media/

Обслуживание файлов в продакшене

Static files — через веб-сервер

# 1. Собираем все static файлы
python manage.py collectstatic
# Копирует из app/static в STATIC_ROOT

# 2. Nginx конфиг
location /static/ {
    alias /home/app/staticfiles/;  # Прямая отдача файлов
    expires 30d;  # Кэширование на 30 дней
}

# Результат: очень быстро, не нагружает Django

Media files — проблематично

# Вариант 1: Через Nginx (если доверяешь загрузчикам)
location /media/ {
    alias /home/app/media/;  # Риск безопасности!
    # Пользователь может загрузить .php и выполнить код
}

# Вариант 2: Через Django (безопасно, медленно)
location /media/ {
    proxy_pass http://127.0.0.1:8000;  # Через Django
}
# Django может проверить права доступа

# Вариант 3: Через облако (лучше)
# AWS S3, Google Cloud Storage, etc.
DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'

Контроль доступа

Static files — всем доступны

# Все пользователи видят одинаковые файлы
<img src="/static/images/logo.png">  # Доступно всем
<script src="/static/js/app.js"></script>  # Доступно всем

Media files — нужна проверка прав

# views.py
from django.views.static import serve
from django.http import Http404
import os

def serve_media(request, file_path):
    # Проверяем права доступа
    obj = MyModel.objects.get(file_path=file_path)
    
    if not obj.is_accessible_by(request.user):
        raise Http404("File not found")
    
    return serve(
        request,
        file_path,
        document_root=settings.MEDIA_ROOT
    )

# urls.py
urlpatterns = [
    path('media/<path:file_path>', serve_media),
]

# Только авторизованные пользователи видят свои файлы

Безопасность

Static files — безопасны

# Разработчик контролирует содержимое
# Нет риска выполнения вредоносного кода
# Можно безопасно отдавать через Nginx

Media files — уязвимы

# Опасность 1: Загрузка вредоносного файла
file = request.FILES['image']
# Пользователь загружает malicious.php

# Защита: валидируем типы файлов
from django.core.validators import FileExtensionValidator

class Document(models.Model):
    file = models.FileField(
        upload_to='documents/',
        validators=[FileExtensionValidator(
            allowed_extensions=['pdf', 'doc', 'docx']
        )]
    )

# Опасность 2: Path traversal
# Пользователь пытается скачать чужой файл
file_path = request.GET['file']  # ../../admin_secret.pdf

# Защита: используй models с правами доступа
obj = Document.objects.get(id=file_id)
if not obj.is_owned_by(request.user):
    raise Http404()

# Опасность 3: Исполнение кода
# Если файл .php находится в веб-доступной папке

# Защита: отдавай файлы через Django или облако
# Не отдавай напрямую через Nginx

Реальные примеры

Полная настройка Django

# settings.py
import os
from pathlib import Path

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

# Static files
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, 'static'),
]

# Media files
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

# urls.py
from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
    # ... ваши URLs
]

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

# Production: Nginx обслуживает static, Django обслуживает media

Загрузка файла с валидацией

# models.py
from django.core.files.uploadhandlers import TemporaryFileUploadHandler

class UserAvatar(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    image = models.ImageField(
        upload_to='avatars/%Y/%m/%d/',
        validators=[
            FileExtensionValidator(
                allowed_extensions=['jpg', 'jpeg', 'png']
            )
        ]
    )
    
    def clean(self):
        # Проверяем размер
        if self.image.size > 5 * 1024 * 1024:  # 5MB
            raise ValidationError("Image too large")
        
        # Проверяем размеры изображения
        img = Image.open(self.image)
        if img.width < 100 or img.height < 100:
            raise ValidationError("Image too small")

# views.py
def upload_avatar(request):
    if request.method == 'POST':
        avatar = UserAvatar(
            user=request.user,
            image=request.FILES['avatar']
        )
        avatar.full_clean()  # Валидируем
        avatar.save()  # Сохраняем
        return redirect('profile')

Best Practice

# 1. Static files — только в разработке
# Production: через Nginx с expires header
location /static/ {
    alias /staticfiles/;
    expires 30d;
    add_header Cache-Control "public, immutable";
}

# 2. Media files — через облако
DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'

# 3. Валидируй всё
from django.core.validators import FileExtensionValidator

# 4. Отдавай через Django если нужны права доступа
# Отдавай через Nginx если публичные

# 5. Используй CDN для static
# CloudFront, Cloudflare, etc.

# 6. Регулярно чисти media
# Удаляй старые загрузки, проверяй квоту