Что такое Stateful приложения?

Stateful приложения в архитектуре систем

Stateful приложение — это приложение, которое сохраняет и помнит состояние своих пользователей, сессий и данных между запросами. Это ключевое понятие в веб-разработке, облачных вычислениях и микросервисной архитектуре.

Определение

Stateful приложение имеет память о предыдущих взаимодействиях. Оно хранит информацию о пользователях, их сессиях, рабочих данных в памяти процесса или локальных хранилищах.

Как работает Stateful приложение

from flask import Flask, session
from flask_session import Session

app = Flask(__name__)
app.config['SESSION_TYPE'] = 'filesystem'  # Сохранять состояние на диск
Session(app)

# Переменная состояния в памяти процесса
user_sessions = {}  # Это проблематично в масштабируемой системе!

@app.route('/login', methods=['POST'])
def login():
    username = request.json['username']
    # Сохраняем информацию о пользователе в состояние приложения
    session['user'] = username
    user_sessions[username] = {
        'logged_in_at': datetime.now(),
        'requests_count': 0
    }
    return {'status': 'logged in'}

@app.route('/profile')
def profile():
    # Приложение помнит, кто залогирован
    if 'user' in session:
        user = session['user']
        # Доступ к состоянию
        user_sessions[user]['requests_count'] += 1
        return {'user': user, 'requests': user_sessions[user]['requests_count']}
    return {'error': 'not logged in'}, 401

Проблемы Stateful приложений

1. Масштабируемость

Если у вас несколько инстансов приложения, состояние на одном сервере недоступно другим:

Запрос 1 → Server A (состояние сохраняется в Server A)
Запрос 2 → Server B (состояние НЕ найдено, пользователь вынужден логиниться заново)

2. Сеансы и балансировка нагрузки

# Проблематично с несколькими серверами
user_shopping_cart = {}  # На каком сервере это живёт?

@app.route('/add-to-cart')
def add_to_cart(item_id):
    user_id = session.get('user_id')
    if user_id not in user_shopping_cart:
        user_shopping_cart[user_id] = []
    user_shopping_cart[user_id].append(item_id)
    return {'cart': user_shopping_cart[user_id]}

3. Восстановление после сбоя

Если приложение упадёт, все состояние в памяти потеряется.

Примеры Stateful приложений

1. Традиционные веб-приложения с сессиями
2. Игровые серверы (помнят состояние игры)
3. Чат-приложения (помнят активные соединения)
4. WebSocket приложения (долгоживущие соединения)
5. Real-time приложения (Slack, Discord)

Статичные данные в памяти (плохая практика)

# ❌ Плохо: состояние в памяти процесса
active_users = {}  # Потеряется при перезагрузке
user_preferences = {}  # Несинхронизировано между инстансами

app.stateful_data = {}  # Не масштабируется

Решение: Externalizing State

Современный подход — сохранять состояние вне приложения:

1. Redis для сессий и кэша

from flask import Flask, session
from flask_session import Session
import redis

app = Flask(__name__)

# Используем Redis вместо памяти процесса
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = redis.from_url('redis://localhost:6379')
Session(app)

@app.route('/login', methods=['POST'])
def login():
    username = request.json['username']
    session['user'] = username  # Сохраняется в Redis
    return {'status': 'logged in'}

# Работает одинаково на всех инстансах приложения

2. PostgreSQL для персистентного состояния

from sqlalchemy import Column, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from datetime import datetime

Base = declarative_base()

class UserSession(Base):
    __tablename__ = 'user_sessions'
    
    session_id = Column(String, primary_key=True)
    user_id = Column(String, nullable=False)
    data = Column(JSON)  # Храним состояние
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

# Теперь состояние в БД, доступно всем инстансам

3. WebSocket с Redis Pub/Sub для real-time

import asyncio
import aioredis
from fastapi import FastAPI, WebSocket

app = FastAPI()
redis = None

@app.on_event('startup')
async def startup():
    global redis
    redis = await aioredis.create_redis_pool('redis://localhost')

@app.websocket('/ws/{user_id}')
async def websocket_endpoint(websocket: WebSocket, user_id: str):
    await websocket.accept()
    
    # Подписываемся на обновления для этого пользователя
    channel = await redis.subscribe(f'user:{user_id}')
    
    try:
        while True:
            # Получаем сообщение из Redis (а не из памяти процесса)
            msg = await channel[0].get()
            await websocket.send_json(msg)
    finally:
        await redis.unsubscribe(f'user:{user_id}')

Stateless vs Stateful

Когда Stateful необходимо

1. WebSocket соединения — долгоживущие соединения
2. Real-time приложения — онлайн игры, чаты
3. Streaming — видео стриминг, live events
4. Компактные команды — один сервер в локальной сети

Лучшие практики

1. Используйте сессионные хранилища вне приложения

# ✓ Хорошо
app.config['SESSION_TYPE'] = 'redis'  # Или другое экстернальное хранилище

2. Разделяйте состояние сессии и состояние приложения

# Состояние сессии (в Redis)
user_session_data = {'user_id': 123, 'logged_in': True}

# Состояние приложения (кэш, конфиг)
app_config = load_config()  # Статично

3. Используйте sticky sessions для балансировки

# NGINX конфиг для привязки к серверу
upstream backend {
    server server1.example.com;
    server server2.example.com;
}

server {
    location / {
        # Привязать сессию к одному серверу
        proxy_pass http://backend;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_cookie_path / "/";
    }
}

4. Испольуйте distributed caching

from cachetools import TTLCache
from distributed import Client  # Dask для распределённого кэша

client = Client()  # Подключаемся к кластеру Dask
cache = client.submit(TTLCache, maxsize=1000, ttl=3600)

Архитектура современных масштабируемых систем

Client → Load Balancer → Stateless Server 1
                      → Stateless Server 2
                      → Stateless Server 3
                      
         Shared Storage: Redis/PostgreSQL

Ключевое различие: состояние хранится в отдельных системах (Redis, PostgreSQL), а не в памяти приложения.

Модель Stateful была стандартом в традиционной веб-разработке, но в облачных и масштабируемых архитектурах (Kubernetes, микросервисы) предпочитают Stateless приложения с экстернальными хранилищами состояния.