Как справится с увеличением потока пользователей на веб-приложение?

Как справиться с увеличением потока пользователей на веб-приложение

Рост числа пользователей — это благословение и проклятие. Нужно планировать масштабирование заранее, иначе приложение упадёт при популярности. Рассмотрим стратегии и инструменты.

1. Диагностика проблем (узкие места)

# Первый шаг — измерить где время тратится
import time
import django
from django.utils.decorators import decorator_from_middleware

class TimingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    
    def __call__(self, request):
        start = time.time()
        response = self.get_response(request)
        duration = time.time() - start
        
        print(f"{request.path}: {duration:.3f}s")
        return response

# Логирование медленных запросов
from django.db import connection
from django.test.utils import override_settings

@override_settings(DEBUG=True)
def analyze_queries():
    from django.db import reset_queries
    reset_queries()
    
    # Твой код
    results = Post.objects.filter(status='published')
    
    # Анализируем
    for query in connection.queries:
        print(f"Time: {query['time']}, SQL: {query['sql'][:100]}")

2. Оптимизация на уровне приложения

Проблема N+1:

# ❌ Плохо: 1 + N запросов
posts = Post.objects.all()
for post in posts:
    print(post.author.name)  # N запросов к БД

# ✓ Хорошо: 1 запрос
posts = Post.objects.select_related('author')
for post in posts:
    print(post.author.name)

Кэширование:

from django.views.decorators.cache import cache_page
import redis

cache = redis.Redis()

@cache_page(60 * 5)  # 5 минут
def popular_posts(request):
    posts = Post.objects.filter(views__gt=1000)
    return render(request, 'posts.html', {'posts': posts})

# Или ручное кэширование
def get_user_profile(user_id):
    key = f"user:{user_id}"
    cached = cache.get(key)
    if cached:
        return json.loads(cached)
    
    user = User.objects.get(id=user_id)
    cache.setex(key, 3600, json.dumps(user))
    return user

3. Горизонтальное масштабирование (Load Balancing)

Traf         ┌──────────────┐
  fic  ────→ │ Load Balancer│ (Nginx, HAProxy)
             └──────┬───────┘
                    │
        ┌───────────┼───────────┐
        ↓           ↓           ↓
    [App 1]    [App 2]    [App 3]
        └───────────┼───────────┘
                    ↓
            ┌──────────────┐
            │  Database    │
            └──────────────┘

# Nginx конфиг
upstream app {
    least_conn;  # или round_robin
    server app1.local:8000;
    server app2.local:8000;
    server app3.local:8000;
}

server {
    listen 80;
    server_name example.com;
    
    location / {
        proxy_pass http://app;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

4. Кэширование: Redis

import redis
from functools import wraps

cache = redis.Redis(host='localhost', port=6379, db=0)

def cached_result(ttl=3600):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # Генерируем ключ из аргументов
            key = f"{func.__name__}:{args}:{kwargs}"
            
            result = cache.get(key)
            if result:
                return json.loads(result)
            
            result = func(*args, **kwargs)
            cache.setex(key, ttl, json.dumps(result))
            return result
        return wrapper
    return decorator

@cached_result(ttl=600)
def get_trending_posts():
    return Post.objects.filter(trending=True)

5. Асинхронная обработка (Celery)

from celery import shared_task
import time

# Тяжёлая операция в отдельной задаче
@shared_task
def send_email_task(email, subject, body):
    time.sleep(5)  # Долгая операция
    send_email(email, subject, body)

# View возвращает сразу
def create_post(request):
    post = Post.objects.create(...)
    # Отправим email асинхронно
    send_email_task.delay(request.user.email, "New post", "...")
    return JsonResponse({'id': post.id})

6. CDN для статики

# settings.py
STATIC_URL = 'https://cdn.example.com/static/'
MEDIA_URL = 'https://cdn.example.com/media/'

# Django будет отдавать статику через CDN
# Пользователь получит файлы с ближайшего edge сервера

7. БД оптимизация

Индексы:

class Post(models.Model):
    author = models.ForeignKey(User, db_index=True)
    published_date = models.DateField(db_index=True)
    status = models.CharField(db_index=True)
    
    class Meta:
        indexes = [
            models.Index(fields=['author', 'status']),
        ]

Репликация:

DATABASES = {
    'default': {  # Master
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'myapp',
        'HOST': 'master.db.example.com',
    },
    'replica1': {  # Read-only replica
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'myapp',
        'HOST': 'replica1.db.example.com',
    },
}

# Использование
from django.db import connections

# Write
post = Post.objects.using('default').create(title="New")

# Read from replica
posts = Post.objects.using('replica1').all()

8. Мониторинг и алерты

# Установить инструменты мониторинга
pip install prometheus-client

# Django middleware для метрик
from prometheus_client import Counter, Histogram
import time

request_count = Counter(
    'http_requests_total',
    'Total HTTP requests',
    ['method', 'endpoint']
)

request_duration = Histogram(
    'http_request_duration_seconds',
    'HTTP request latency'
)

class PrometheusMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    
    def __call__(self, request):
        start = time.time()
        response = self.get_response(request)
        duration = time.time() - start
        
        request_count.labels(
            method=request.method,
            endpoint=request.path
        ).inc()
        
        request_duration.observe(duration)
        
        return response

9. Containerization и Kubernetes

# kubernetes deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3  # 3 инстанса
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 8000
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 10

10. Эластичное масштабирование

# Auto-scaling: при высокой нагрузке добавляются инстансы
# При низкой — удаляются

# Kubernetes Horizontal Pod Autoscaler
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: myapp-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Чеклист при росте пользователей

[ ] Профилирован код (узкие места найдены)
[ ] Оптимизированы запросы к БД (select_related, индексы)
[ ] Redis кэширование настроено
[ ] Статика на CDN
[ ] Асинхронные задачи (Celery) для долгих операций
[ ] Load balancer (Nginx/HAProxy)
[ ] БД репликация (read replicas)
[ ] Мониторинг и алерты
[ ] Containerization (Docker)
[ ] Auto-scaling configured
[ ] Database connection pooling
[ ] Rate limiting для API

Заключение

Масштабирование — это процесс, а не одноразовая задача. Начни с профилирования (find bottlenecks), потом оптимизируй (кэширование, индексы, async), затем масштабируй горизонтально (load balancing, replicas, Kubernetes). Помни про мониторинг — без метрик не будешь знать, где проблемы.