Перейти к основному содержимому

Flask

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ
Разработчику Архитектору

Flask​

Flask — это веб-фреймворк для языка программирования Python. Он предоставляет инструменты и библиотеки, необходимые для создания веб-приложений любого масштаба — от простых демонстрационных сервисов до сложных распределённых систем. Flask принадлежит к категории так называемых микрофреймворков, что означает минимальный набор встроенных компонентов и максимальную гибкость в выборе сторонних решений. Эта характеристика делает Flask особенно подходящим для образовательных целей, прототипирования и проектов, где важна прозрачность архитектуры.

Исторический контекст и происхождение​

Flask был создан Армином Ронахером (Armin Ronacher) в 2010 году как экспериментальный проект внутри сообщества Pocoo — группы разработчиков, известной своими вкладами в экосистему Python. Первоначальная цель заключалась в создании альтернативы существующим фреймворкам, таким как Django, но с меньшим количеством предположений о структуре приложения и большей степенью контроля у разработчика. Flask быстро завоевал популярность благодаря своей простоте, читаемости кода и модульности.

Фреймворк основан на двух ключевых компонентах: Werkzeug и Jinja. Werkzeug — это WSGI-утилита (Web Server Gateway Interface), которая обеспечивает низкоуровневую обработку HTTP-запросов и ответов. Jinja — это шаблонизатор, позволяющий генерировать HTML-страницы динамически, подставляя данные из Python-кода. Оба компонента разработаны тем же автором и тесно интегрированы во Flask, но остаются независимыми проектами, которые можно использовать отдельно.

Философия проектирования​

Flask следует принципу "не навязывай, а предлагай". Он не диктует структуру проекта, не требует использования определённой базы данных, не включает ORM (Object-Relational Mapping) по умолчанию и не принуждает к применению конкретного способа аутентификации или управления сессиями. Вместо этого Flask предоставляет базовый каркас, на который разработчик самостоятельно "нанизывает" нужные компоненты.

Эта философия выражается в нескольких ключевых идеях:

  • Минимализм: ядро Flask содержит только то, что необходимо для маршрутизации запросов и формирования ответов.
  • Расширяемость — через систему расширений (Flask extensions) можно легко добавить поддержку баз данных, форм, почты, авторизации и других функций.
  • Явность конфигурации: поведение приложения определяется явными настройками, а не скрытыми соглашениями.
  • Согласованность с Python: Flask стремится сохранять идиоматический стиль языка Python, делая код интуитивно понятным даже новичкам.

Такой подход позволяет разработчику принимать осознанные архитектурные решения, а не следовать заранее заданному шаблону. Это особенно ценно в учебных проектах, где важно понимать, как устроены веб-приложения "под капотом".

Базовые концепции Flask​

Приложение (Application)​

В Flask каждое веб-приложение начинается с создания экземпляра класса Flask. Этот объект служит центральной точкой управления — он хранит маршруты, обработчики ошибок, конфигурацию и состояние приложения. Пример минимального приложения выглядит так:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Привет, мир!"

if __name__ == '__main__':
    app.run()

Разбор фрагмента:

  • Flask(__name__) создаёт объект приложения и помогает Flask найти ресурсы проекта.
  • @app.route('/') связывает корневой URL с функцией home.
  • return "Привет, мир!" формирует тело HTTP-ответа.
  • Блок if __name__ == '__main__': запускает локальный dev-сервер только при прямом запуске файла.

Здесь переменная app представляет собой само приложение. Декоратор @app.route связывает URL-путь с функцией-обработчиком. Когда пользователь обращается к корневому пути (/), вызывается функция home, и её возвращаемое значение отправляется клиенту в виде HTTP-ответа.

Маршрутизация (Routing)​

Маршрутизация — это механизм сопоставления URL-адресов с функциями, которые их обрабатывают. Flask использует декораторы для привязки маршрутов, что делает код наглядным и компактным. Помимо статических путей, Flask поддерживает динамические сегменты, называемые переменными пути. Например:

@app.route('/user/<username>')
def show_user_profile(username):
    return f'Профиль пользователя: {username}'

Разбор фрагмента:

  • <username> — динамический сегмент пути.
  • Значение из URL автоматически передаётся в аргумент функции username.
  • Возвращаемая f-строка позволяет сразу включить параметр в ответ.

В этом примере <username> — это переменная, значение которой извлекается из URL и передаётся в функцию как аргумент. Flask автоматически преобразует её в строку, но можно указать тип, например <int:user_id>, чтобы гарантировать числовое значение.

Маршрутизация в Flask основана на дереве путей и поддерживает методы HTTP (GET, POST, PUT, DELETE и другие). По умолчанию маршрут отвечает только на GET-запросы, но можно явно указать список допустимых методов:

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        # обработка формы входа
        pass
    else:
        # отображение формы
        pass

Разбор фрагмента:

  • methods=['GET', 'POST'] разрешает маршруту обрабатывать два HTTP-метода.
  • request.method определяет, какой сценарий выполнить: показать форму или обработать отправку.
  • Такой паттерн разделяет чтение страницы (GET) и изменение состояния (POST) в одной точке входа.

Контексты запроса и приложения​

Одна из важнейших, но часто упускаемых из виду особенностей Flask — это система контекстов. Поскольку веб-приложение одновременно обслуживает множество запросов, Flask должен обеспечивать изоляцию данных между ними. Для этого используются два типа контекстов:

  • Контекст запроса (Request Context) — содержит информацию о текущем HTTP-запросе — заголовки, тело, параметры, cookies и другие атрибуты. Объект request доступен только внутри этого контекста.
  • Контекст приложения (Application Context) — хранит глобальные данные, относящиеся ко всему приложению, такие как конфигурация или подключение к базе данных. Он существует дольше, чем контекст запроса, и может использоваться вне обработчиков, например в фоновых задачах.

Эти контексты управляются автоматически при запуске приложения через встроенный сервер или WSGI-сервер, но при тестировании или выполнении вне HTTP-цикла их нужно активировать вручную с помощью менеджеров контекста (with app.app_context():).

Шаблоны и рендеринг​

Flask включает в себя шаблонизатор Jinja, который позволяет отделять логику приложения от представления. Шаблоны — это HTML-файлы с встроенными элементами динамики — переменными, условиями, циклами и наследованием. Например:

<!-- templates/index.html -->
<!DOCTYPE html>
<html>
<head><title>{{ title }}</title></head>
<body>
    <h1>Добро пожаловать, {{ name }}!</h1>
</body>
</html>

Разбор фрагмента:

  • {{ title }} и {{ name }} вставляют значения переменных из Python-кода.
  • Jinja2 по умолчанию экранирует HTML, что снижает риск XSS.
  • Шаблон остаётся обычным HTML, но поддерживает динамическое наполнение.

В обработчике используется функция render_template, которая загружает шаблон и подставляет в него данные:

from flask import render_template

@app.route('/hello/<name>')
def hello(name):
    return render_template('index.html', title='Приветствие', name=name)

Разбор фрагмента:

  • render_template('index.html', ...) выбирает шаблон из папки templates.
  • Именованные аргументы (title, name) становятся переменными внутри Jinja-шаблона.
  • В результате Flask возвращает готовый HTML-документ клиенту.

Jinja обеспечивает автоматическое экранирование HTML по умолчанию, что защищает от XSS-атак. Также поддерживаются макросы, фильтры и наследование шаблонов, что позволяет строить сложные иерархии страниц с минимальным дублированием кода.

Обработка запросов и ответов​

Flask предоставляет объекты request и response, которые инкапсулируют входящие и исходящие данные HTTP-транзакции. Объект request содержит все сведения о запросе — метод, URL, заголовки, параметры строки запроса (?key=value), тело (например, данные формы или JSON), cookies и файлы. Доступ к этим данным осуществляется через атрибуты:

  • request.args — параметры из строки запроса,
  • request.form — данные, отправленные через HTML-форму методом POST,
  • request.json — тело запроса в формате JSON,
  • request.files — загруженные файлы,
  • request.cookies — cookies, присланные браузером.

Объект ответа формируется автоматически на основе возвращаемого значения обработчика. Если функция возвращает строку, Flask оборачивает её в объект Response с MIME-типом text/html. Можно явно создавать ответы с помощью функции make_response, чтобы установить статус-код, заголовки или cookies:

from flask import make_response

@app.route('/cookie')
def set_cookie():
    resp = make_response("Cookie установлен")
    resp.set_cookie('user_id', '12345')
    return resp

Разбор фрагмента:

  • make_response(...) создаёт объект ответа, который можно дополнительно настроить.
  • set_cookie('user_id', '12345') добавляет cookie в заголовки ответа.
  • Клиентский браузер сохранит cookie и отправит её в следующих запросах к тому же домену.

Также Flask поддерживает возврат кортежей вида (тело, статус, заголовки), что упрощает формирование нестандартных ответов без импорта дополнительных функций.

Сессии и состояние​

Веб-протокол HTTP по своей природе не сохраняет состояние между запросами. Чтобы преодолеть это ограничение, Flask реализует механизм сессий на основе подписанных cookies. Сессия — это словарь, который хранится на стороне клиента, но защищён криптографической подписью, чтобы предотвратить подделку. Для работы сессий необходимо задать секретный ключ приложения:

app.secret_key = 'секретный_ключ_для_подписи'

Разбор фрагмента:

  • secret_key используется для подписи сессионных cookie.
  • Без этого ключа Flask не сможет безопасно хранить данные сессии.

После этого можно использовать объект session как обычный словарь:

from flask import session

@app.route('/login', methods=['POST'])
def login():
    session['username'] = request.form['username']
    return "Вы вошли в систему"

@app.route('/profile')
def profile():
    if 'username' in session:
        return f"Профиль: {session['username']}"
    return "Пожалуйста, войдите"

Разбор фрагмента:

  • session['username'] = ... сохраняет признак авторизации между запросами.
  • Проверка 'username' in session реализует простую защиту закрытого маршрута.
  • session выглядит как словарь, но фактически сериализуется в подписанный cookie.

Сессии удобны для хранения небольших фрагментов данных, таких как идентификатор пользователя или настройки интерфейса. Для более объёмной информации рекомендуется использовать серверное хранилище (например, базу данных), а в сессии оставлять только идентификатор сессии.

Расширения и экосистема​

Одно из главных преимуществ Flask — его богатая экосистема расширений. Расширение — это пакет Python, который интегрируется с Flask и добавляет новую функциональность. Некоторые из самых популярных:

  • Flask-SQLAlchemy — интеграция с ORM SQLAlchemy для работы с реляционными базами данных.
  • Flask-WTF — поддержка форм с валидацией и защитой от CSRF-атак.
  • Flask-Login — управление аутентификацией пользователей.
  • Flask-Mail — отправка электронной почты.
  • Flask-Migrate — миграции базы данных через Alembic.
  • Flask-CORS — поддержка Cross-Origin Resource Sharing для API.

Расширения следуют единому соглашению: они принимают объект приложения в качестве аргумента и регистрируют свои компоненты в его контексте. Многие расширения также поддерживают отложенную инициализацию через метод init_app, что позволяет использовать их в модульных приложениях и при тестировании.

Организация проекта​

Flask не навязывает структуру каталогов, но существуют общепринятые практики. Для небольших приложений достаточно одного файла (app.py). По мере роста проекта применяют один из двух подходов:

  • Модульный стиль: код разбивается на несколько Python-модулей (например, models.py, views.py, forms.py), но всё ещё находится в одном каталоге.
  • Пакетный стиль (Application Factory): приложение создаётся внутри функции, что позволяет гибко управлять конфигурацией и избегать циклических импортов. Этот подход особенно важен при написании тестов и развёртывании в разных окружениях (разработка, тестирование, продакшен).

Пример структуры пакетного проекта:

myproject/
├── app/
│   ├── __init__.py          # фабрика приложения
│   ├── models.py            # модели данных
│   ├── routes.py            # маршруты
│   ├── templates/           # шаблоны
│   └── static/              # статические файлы (CSS, JS, изображения)
├── config.py                # конфигурация
├── run.py                   # точка запуска
└── requirements.txt         # зависимости

Файл __init__.py содержит функцию create_app, которая инициализирует Flask и регистрирует все компоненты:

# app/__init__.py
from flask import Flask

def create_app():
    app = Flask(__name__)
    app.config.from_object('config.DevelopmentConfig')

    from .routes import main as main_blueprint
    app.register_blueprint(main_blueprint)

    return app

Этот подход обеспечивает чистоту архитектуры и совместимость с современными инструментами развёртывания, такими как Gunicorn или uWSGI.

Тестирование​

Flask включает встроенные средства для модульного тестирования. Клиент тестирования (test_client) имитирует HTTP-запросы без запуска реального сервера, что позволяет быстро проверять логику маршрутов, обработку форм и работу с базой данных. Пример простого теста:

Код ITЗагрузка примера кода…

Для изоляции тестов часто используют временные базы данных в памяти (например, SQLite) и фикстуры, которые подготавливают начальное состояние перед каждым тестом.

Конфигурация приложения​

Конфигурация — это механизм управления параметрами приложения в зависимости от окружения — разработка, тестирование, производственная эксплуатация. Flask хранит все настройки в атрибуте app.config, который представляет собой словарь с дополнительными методами загрузки. Существует несколько способов задать конфигурацию:

  • Прямое присваивание:
  app.config['DEBUG'] = True
  app.config['SECRET_KEY'] = 'ключ'
  • Загрузка из Python-класса:
  class Config:
      SECRET_KEY = 'ключ'
      SQLALCHEMY_DATABASE_URI = 'sqlite:///app.db'

  class ProductionConfig(Config):
      DEBUG = False

  app.config.from_object(ProductionConfig)
  • Загрузка из файла:
  app.config.from_pyfile('config.py')
  • Загрузка из переменных окружения:
  app.config.from_envvar('FLASK_CONFIG')

Использование классов позволяет создавать иерархию конфигураций с наследованием общих параметров. Это особенно полезно, когда нужно поддерживать разные настройки для локальной машины, CI-сервера и облачного хостинга. Важно никогда не хранить секретные данные (пароли, ключи API) в коде репозитория — они должны передаваться через переменные окружения или защищённые файлы, исключённые из системы контроля версий.

Обработка ошибок​

Flask предоставляет гибкие инструменты для перехвата и обработки HTTP-ошибок и исключений. Можно зарегистрировать функцию-обработчик для конкретного статус-кода с помощью декоратора @app.errorhandler:

@app.errorhandler(404)
def page_not_found(e):
    return render_template('404.html'), 404

Аналогично можно обрабатывать любые исключения Python:

@app.errorhandler(ValueError)
def handle_value_error(e):
    return "Некорректные данные", 400

Обработчики ошибок могут возвращать HTML-страницы, JSON-ответы или перенаправления, что делает их универсальными для веб-сайтов и API. При разработке полезно включать режим отладки (DEBUG = True), который показывает подробный трейсбэк ошибки прямо в браузере. В продакшене этот режим обязательно отключают, чтобы не раскрывать внутреннюю структуру приложения.

Работа со статическими файлами​

Статические файлы — это CSS, JavaScript, изображения, шрифты и другие ресурсы, которые не генерируются динамически. Flask автоматически обслуживает такие файлы из каталога static в корне проекта. Например, файл static/style.css будет доступен по адресу /static/style.css. В шаблонах используется функция url_for для генерации правильных путей:

<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">

Этот подход обеспечивает устойчивость к изменениям структуры URL и поддерживает кэширование. Для больших проектов часто подключают внешние CDN или используют сборщики (например, Webpack), но Flask остаётся нейтральным к выбору инструментов фронтенда.

Разработка RESTful API​

Хотя Flask изначально создавался для веб-сайтов, он отлично подходит для построения RESTful API. Для этого достаточно возвращать данные в формате JSON вместо HTML. Flask предоставляет функцию jsonify, которая преобразует словарь Python в JSON-ответ с правильным MIME-типом:

from flask import jsonify

@app.route('/api/users/<int:user_id>')
def get_user(user_id):
    user = {'id': user_id, 'name': 'Иван'}
    return jsonify(user)

При построении полноценного API рекомендуется использовать расширение Flask-RESTful или Flask-API, которые упрощают сериализацию, валидацию и документирование. Однако даже без них Flask позволяет создавать чистые, соответствующие стандартам интерфейсы благодаря своей гибкости и минимализму.

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

Безопасность веб-приложений — это многоуровневая задача, и Flask предоставляет базовые средства защиты:

  • Защита от CSRF — через расширение Flask-WTF, которое генерирует и проверяет токены в формах.
  • Экранирование вывода — Jinja автоматически экранирует переменные в шаблонах, предотвращая XSS.
  • Безопасные cookies — сессии подписываются секретным ключом, а опционально можно включить флаги HttpOnly и Secure.
  • Заголовки безопасности — через middleware или расширения можно добавлять заголовки Content-Security-Policy, X-Frame-Options, Strict-Transport-Security.

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

Производительность и масштабируемость​

Встроенный сервер Flask (app.run()) предназначен только для разработки. Он однопоточный и не выдерживает высокой нагрузки. Для продакшена приложение развёртывают через WSGI-сервер, такой как Gunicorn, uWSGI или mod_wsgi (для Apache). Эти серверы поддерживают многопроцессность, балансировку и интеграцию с обратными прокси (Nginx, Apache).

Масштабируемость Flask-приложений достигается за счёт:

  • горизонтального масштабирования (запуск нескольких экземпляров),
  • кэширования (через Redis или Memcached),
  • асинхронной обработки тяжёлых задач (через Celery или RQ),
  • оптимизации базы данных и запросов.

Flask не накладывает ограничений на архитектуру, поэтому его можно интегрировать в микросервисные системы, serverless-платформы (AWS Lambda, Google Cloud Functions) и контейнерные среды (Docker, Kubernetes).

Практика и справочник​

Когда Flask выбирают осознанно​

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

Практический маршрут изучения Flask​

Такой порядок даёт плавный вход и помогает увидеть место Flask среди других Python-фреймворков.

Основа по протоколу

Базовый разбор HTTP и HTTPS находится в отдельной статье — HTTP как основа веб-интеграций.

Содержание