flask время жизни сессии
Порядок работы с сессиями (session)
На этом занятии мы поближе познакомимся с механизмом сессий, который уже затрагивали, когда говорили о мгновенных сообщениях. Так вот, сессии работают по похожему с cookies принципу: они также хранятся в браузере в виде особых кук сессий, но дополнительно шифруются с помощью ключа, который можно задать в WSGI-приложении, следующим образом:
Для надежности этот ключ должен содержать самые разные символы и один из хороших способов его сгенерировать – это воспользоваться следующей командой пакета os:
То есть, мы можем ее выполнить, например, в консоли Python и результат вставить в секретный ключ. Соответственно, не зная этот ключ, пользователь не сможет понять и изменить сессионную информацию в браузере. Фактически, только этим сессии и отличаются от cookies, о которых мы говорили на предыдущем занятии. Во всем остальном они практически не отличимы: также передаются в запросах браузеру и обратно – из браузера к серверу. Имеют ограничение в 4 Кб хранимой информации и перестают работать, если пользователь отключит cookies в своем браузере. Но, вместе с тем, почти ни один серьезный сайт без них не обходится.
Объект session
Для работы с сессиями во Flask имеется специальный объект
который доступен и в приложении и в шаблонах. Данный объект работает по подобию словаря, следующим образом:
Смотрите, мы здесь обращаемся к данным сессии по ключу ‘visits’, если они там есть. Иначе, создаем этот ключ со значением 1. Далее, при каждом обновлении страницы значение ‘visits’ будет увеличиваться на 1 и мы увидим увеличение числа просмотров главной страницы сайта. Это лишь простой пример, демонстрирующий порядок работы с объектом session во Flask. Шифрование, передача и прием данных через запросы скрыта и происходит в автоматическом режиме, что очень удобно.
Но при работе с сессиями есть одна существенная особенность, которую следует знать и хорошо понимать: передача сессионных данных браузеру происходит только при изменении состояния объекта session. Чтобы лучше понять о чем речь, рассмотрим такой отвлеченный, но простой пример:
Мы здесь при первом запросе формируем поле data, которое ссылается на список data. А при последующих запросах происходит увеличение второго элемента этого списка на 1. По идее, при обновлении страницы, мы должны видеть постоянное увеличение второго значения на 1. Давайте посмотрим, обновляем, но ничего не происходит. Почему? Как раз по той причине, что объект session в этом случае никак не меняется: он как ссылался на список, так и ссылается (адрес списка остается прежним). Меняется лишь элемент в самом списке и это изменение не влияет на изменение session. А раз так, то Flask решает, что сессия не поменялась и нет смысла нагружать канал связи и дополнительно ее отправлять браузеру.
Но это можно поправить, прописав следующую строчку:
Этим мы явно указываем Flask, что состояние сессии изменилось и ее нужно обновить в браузере. Теперь, при обновлении страницы, второй элемент списка будет увеличиваться каждый раз на единицу.
Время жизни сессии
По умолчанию куки сессии существуют, пока пользователь не закроет браузер. Но это поведение можно изменить и явно указать время жизни сессий в куках. Для этого в функции представления нужно указать:
Тогда время жизни сессии устанавливается равным параметру
который по умолчанию составляет 31 день. Но, можно определить любое другое значение, например, так:
Теперь сессии будут максимум храниться 10 дней в браузере клиента. Давайте посмотрим на работу этого функционала. Если сейчас произвести обновления страницы
то увидим увеличение второго значения списка. Выйдем из браузера, снова зайдем и увидим последнее установленное значения, т.е. сессия сохраняется в браузере. Далее, изменим значение:
также обновим страницу, выйдем из браузера и при возвращении увидим начальные значения списка 1, 2, 3, 4, т.е. сессия пропала при закрытии окна браузера. Вот так это работает.
Видео по теме
Flask #1: Что это такое? Простое WSGI-приложение
Flask #2: Использование шаблонов страниц сайта
Flask #3: Контекст приложения и контекст запроса
Flask #4: Функция url_for и переменные URL-адреса
Flask #5: Подключение внешних ресурсов и работа с формами
Flask #7: Декоратор errorhandler, функции redirect и abort
Flask #8: Создание БД, установление и разрыв соединения при запросах
Flask #9: Добавление и отображение статей из БД
Flask #10: Способ представления полноценных HTML-страниц на сервере
Flask #11: Формирование ответа сервера, декораторы перехвата запроса
Flask #12: Порядок работы с cookies (куками)
Flask #13: Порядок работы с сессиями (session)
Flask #14: Регистрация пользователей и шифрование паролей
Flask #15: Авторизация пользователей на сайте через Flask-Login
Flask #16: Улучшение процесса авторизации (Flask-Login)
Flask #17: Загрузка файлов на сервер и сохранение в БД
Flask #18: Применение WTForms для работы с формами сайта
Flask #19: Обработка ошибок во Flask-WTF
Flask #23: Операции с таблицами через Flask-SQLAlchemy
© 2021 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Мега-Учебник Flask, Часть 5: Вход пользователей
Предисловие от переводчика.
Переводом предыдущих частей этого руководства занимался wiygn. С его согласия я продолжаю это дело.
Это пятая статья в серии, где я описываю свой опыт написания веб-приложения на Python с использованием микрофреймворка Flask.
Цель данного руководства — разработать довольно функциональное приложение-микроблог, которое я за полным отсутствием оригинальности решил назвать microblog.
Краткое повторение
В предыдущей части мы создали базу данных и научились заполнять её пользователями и постами, однако этот функционал еще не реализован в нашем приложении. Две главы назад мы узнали, как создавать веб-формы и создали форму для авторизации.
В этой статье мы объединим наши знания о веб-формах и базах данных и напишем свою систему для входа пользователей. В конце данного руководства наше небольшое приложение будет регистрировать новых пользователей и проводить их авторизацию.
Для работы с этой главой ваше приложение должно быть таким, каким мы оставили его в конце предыдущей главы. Пожалуйста, убедитесь, что приложение установлено и работает.
Конфигурация
Как и в предыдущих главах, мы начнём с настройки расширений, которые будем использовать. Для авторизации нам понадобятся два расширения — Flask-Login и Flask-OpenID. Настроим их следующим образом (файл app/__init__.py ):
Функция представления авторизации
Давайте обновим нашу функцию представления (файл app/views.py ):
Обратите внимание, мы импортировали несколько новых модулей, некоторые из которых будут использованы позднее.
Отличий от предыдущей версии немного. Мы добавили новый декоратор для функции отображения. Благодаря oid.loginhandler Flask-OpenID теперь знает, что это — функция для авторизации.
Мы также обновили код, обрабатывающий данные полученные из формы авторизации. Здесь мы делаем две вещи. Во-первых, мы сохраняем значение поля remember_me в сессии Flask (не путайте с db.session — сессией, предоставленной расширением Flask-SQLAlchemy). Как было сказано выше, объект flask.g может хранить данные только во время жизни запроса. В то время как flask.session является более сложным хранилищем. Данные, сохраненные в сессии, будут также доступны во время всех последующих запросов от одного клиента. Информация хранится до тех пор, пока не будет явно удалена. Такое поведение возможно благодаря тому, что Flask хранит отдельные сессии для каждого клиента.
Обработка ответа от провайдера OpenID
Так выглядит реализация функции after_login (файл app/views.py ):
Затем мы вызываем функцию login_user из модуля Flask-Login, чтобы наконец авторизовать пользователя в нашем приложении.
Для того, чтобы Flask-Login знал куда отправлять пользователей для авторизации, мы должны сообщить ему об этом при инициализации (файл app/__init__.py ):
Глобальный объект g.user
Отображение главной страницы
В предыдущей главе мы использовали в функции index объекты-заглушки, так как у нас еще не было настоящих пользователей и постов. Теперь у нас есть пользователи, самое время это использовать:
Во-вторых, мы передаём в шаблон непосредственно объект g.user вместо заглушки, используемой ранее.
Самое время запустить приложение.
В процессе авторизации вы будете перенаправлены на сайт провайдера, на котором будет необходимо войти в систему и дать своё разрешение на передачу некоторой информации вашему приложению. При этом будут переданы только те параметры, которые мы запросили, т.е. адрес почты и ник. Никакую приватную информацию, включая пароли, провайдеры OpenID не сообщают.
После этого вы окажетесь на главной странице, теперь уже в качестве авторизованного пользователя.
Выход из системы
Мы реализовали вход, самое время добавить возможность выхода из системы. Это делается очень просто (файл app/views.py ):
Помимо этого нам необходимо добавить соответствующую ссылку в шаблон. Расположим её вверху страницы, рядом с другими навигационными ссылками (файл app/templates/base.html ):
Заключительные слова
Теперь у нас есть полноценная система для авторизации пользователей. В следующей главе мы создадим страницу профиля пользователя, и добавим возможность использования аватаров.
Для экономии времени вы можете воспользоваться ссылкой и скачать код приложения, включающий в себя все изменения из данной статьи:
Скачать microblog-0.5.zip
Сессии во Flask
Flask – это функциональный фреймворк, позволяющий создавать веб-приложения. Его преимущества: гибкость, функциональность, расширяемость и компактность.
Представить веб-приложение без куки невозможно. Они играют очень важную роль для его функционирования. Тем не менее, куки имеют ряд ограничений. В частности, их содержимое можно изменять. И это открывает дополнительные возможности для тех, кто хочет сделать жизнь пользователей более тяжелой.
Сессии чем-то похожи на куки, но имеют ряд существенных отличий. Давайте подробнее рассмотрим их особенности и то, чем они отличаются от куки, а также от сессий PHP. Также рассмотрим, как добавлять, редактировать и удалять данные сессий, устанавливать их продолжительность, и ряд других важных аспектов.
Что такое сессии во Flask?
С помощью сессий во Flask пользователь также может сохранять данные конкретных пользователей между запросами. Они работают по принципу, который похож на куки, персонализируя посещение сайтов. Чтобы использовать сессию во Flask, необходимо сначала выполнить настройку специального ключа. Он необходим для того, чтобы защитить данные сессии от редактирования.
Во время использования сессий в фреймворке Flask для Python хранение данных в браузере осуществляется в виде куки. Те куки, которые используются для хранения данных сессии – это куки сессии. Но, в отличие от обычных куки, куки сессии отмечаются криптографически. Это означает, что каждый пользователь может видеть их содержимое, но при этом не может изменять без соответствующего секретного ключа.
После того, как будет осуществлена настройка куки для определенной сессии в браузере, необходимо подтвердить подлинность с использованием секретного ключа. Если этого не получается, тогда контент отклоняется, а браузером получаются новые куки для этой сессии.
Отличия сессий PHP и Flask
Те, кто знает сессии из языка PHP, скажут: сессии во Flask несколько отличаются от него. Так и есть. В PHP куки не хранят данные, а лишь идентификатор, который являет собой уникальную строку, используемую для связи данных сессии с куки. Хранение этих сведений осуществляется на сервере в виде файла. Когда пользователь PHP получает запрос, id используется для того, чтобы найти данные и использовать их для отрисовки страницы. Этот тип сессий называется серверным.
Те же сессии, которые используются во Flask, называются клиентскими, поскольку исполняются на уровне компьютера пользователя. Чаще всего клиентом здесь выступает браузер, но в некоторых случаях отдельные HTML-элементы могут использоваться другими приложениями.
Отличие сессий Flask и куки
Что касается отличий между куки и клиентскими сессиями во Flask, то они не настолько сильно выражены. Например, недостатки те же самые, что и у куки:
Тем не менее, отличие между куки и клиентскими сессиями есть. Flask гарантирует, что это содержимое будет защищено от редактирования при условии, что у пользователя отсутствует секретный ключ.
Чтобы использовать клиентские сессии во Flask, необходимо либо написать собственный интерфейс сессии, либо пользоваться специализированными расширениями. К ним относится, например, Flask-Session.
Работа с данными сессии
Запустите сервер и зайдите на https://localhost:5000/visits-counter/. На странице отобразится счетчик посещений. 
Для увеличения счетчика, необходимо обновить страницу несколько раз. 
Если после этого перейти к странице со счетчиком посещений, то отобразится число 1. Это означает, что сервер считает, что человек зашел впервые на этот ресурс.
Получить доступ к объекту sessions можно через шаблоны.
Редактирование информации, связанной с сессией
Внимание! Перед выполнением описанных ниже действий удалите установленные локальным хостом куки.
При перезагрузке страницы, в словаре session уже будет «10 ананасов». 
А если выполнить еще один раз перезагрузку страницы, то увидим следующее: словарь session содержит 100 ананасов, а не 10.
Выводы
#13 Сессии во Flask
Сессии — еще один способ хранить данные конкретных пользователей между запросами. Они работают по похожему на куки принципу. Для использования сессии нужно сперва настроить секретный ключ. Объект session из пакета flask используется для настройки и получения данных сессии. Объект session работает как словарь, но он также может отслеживать изменения.
При использовании сессий данные хранятся в браузере как куки. Куки, используемые для хранения данных сессии — это куки сессии. Тем не менее в отличие от обычных куки Flask криптографически отмечает куки сессии. Это значит, что каждый может видеть содержимое куки, но не может их менять, не имея секретного ключа для подписи. Как только куки сессии настроены, каждый последующий запрос к серверу подтверждает подлинность куки с помощью такого же секретного ключа. Если Flask не удается это сделать, тогда его контент отклоняется, а браузер получает новые куки сессии.
Знакомые с сессиями из языка PHP заметят, что сессии во Flask немного отличаются. В PHP куки сессии не хранят данные о сессии, а только id сессии. Это уникальная строка, которую PHP создает для ассоциации данных сессии с куки. Данные сессии хранятся на сервере в виде файла. При получении запроса от пользователя PHP использует id сессии, чтобы найти данные сессии и отобразить их в коде. Такой тип сессий известен как серверный, а те, которые используются во Flask, называется клиентскими.
По умолчанию различий между куки и клиентскими сессиями во Flask не так много. В итоге клиентские сессии страдают от тех же недостатков, что и обычные куки:
Единственное реальное различие между куки и клиентскими сессиями — Flask гарантирует, что содержимое куки сессии не может быть изменено пользователям (только если у него нет секретного ключа).
Для использования клиентских сессий во Flask можно или написать собственный интерфейс сессии или использовать расширения, такие как Flask-Session или Flask-KVSession.
Как читать, записывать и удалять данные сессии
Чтобы увеличить его, нужно несколько раз обновить страницу.
Изменение данных сессии
Примечание: перед тем как следовать инструкции, нужно удалить куки, установленные локальным хостом.
Если страницу перезагрузить, в словаре session будет уже «10 ананасов»:
Перезагрузив страницу в третий раз, можно увидеть, что словарь session имеет значение «ананасов» равное 100, а не 10:
Это все, что нужно знать о сессиях во Flask. И важно не забывать, что по умолчанию сессии во Flask являются клиентскими.
Контекст веб-приложения на Flask в Python.
Такое поведение похоже на контекст запроса, который отслеживает данные уровня запроса во время самого запроса к веб-приложению. Соответствующий контекст веб-приложения передается при передаче контекста запроса.
Содержание:
Цель контекста приложения Flask.
Время жизни контекста приложения Flask.
Контекст приложения создается и уничтожается по мере необходимости. Когда приложение Flask начинает обрабатывать запрос, то оно проталкивает контекст приложения и контекст запроса. Когда запрос завершается, появляется контекст запроса, а затем контекст приложения. Обычно у контекста приложения такое же время жизни, как у запроса.
Для получения дополнительной информации о том, как работают контексты и полный жизненный цикл запроса смотрите материал «Контекст запроса веб-приложения на Flask».
Проталкивание контекста вручную.
Если попытаться получить доступ к current_app или чему-либо, что его использует вне контекста приложения, то появляется следующее сообщение об ошибке:
Если эта ошибка появляется где-то еще в коде, не связанном с настройкой приложения, то это, скорее всего, указывает на то, что этот код необходимо переместить в функцию-представление или команду CLI.
Хранение общих данных во время запроса.
Примечание. Имя g означает «глобальный«, но это относится к данным, которые являются глобальными в контексте. Данные в g теряются после завершения контекста, и это не подходящее место для хранения данных, которые передаются от запроса к запросу. Для передачи данных между запросами необходимо использовать сессии/сеансы или базу данных.
Обычно flask.g используется для управления ресурсами во время запроса.
Например, можно управлять подключением к базе данных, используя этот шаблон:
Во время запроса каждый вызов get_db() будет возвращать одно и то же соединение, и оно будет автоматически закрыто в конце запроса.