One place for hosting & domains

      Добавление

      Добавление аутентификации в ваше приложение с помощью Flask-Login


      Введение

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

      Анимированный файл gif с изображением приложения Flask и поля входа

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

      В этой статье мы затронем следующие вопросы:

      • Использование библиотеки Flask-Login для управления сеансами
      • Использование встроенной утилиты Flask для хэширования паролей
      • Добавление в приложение защищенных страниц для пользователей, не выполнивших вход
      • Использование Flask-SQLAlchemy для создания пользовательской модели
      • Создание форм регистрации и входа для создания учетных записей пользователей и входа
      • Вывод пользователям сообщений об ошибках, если что-то идет не так
      • Использование информации учетной записи пользователя для отображения на странице профиля

      Исходный код этого проекта доступен на GitHub.

      Предварительные требования

      Для этого обучающего модуля вам потребуется следующее:

      Наше приложение будет использовать шаблон фабрики приложений Flask с готовыми проектами. У нас будет один проект, отвечающий за все связанное с аутентификацией, и еще один проект для обычных маршрутов, включая указатель и страницу защищенного профиля. В реальном приложении функции можно распределять любым удобным образом, однако описанное здесь решение хорошо подходит для этого учебного модуля.

      Здесь имеется схема, которая поможет понять, как будет выглядеть структура файлов проекта после завершения прохождения учебного модуля:

      .
      └── flask_auth_app
          └── project
              ├── __init__.py       # setup our app
              ├── auth.py           # the auth routes for our app
              ├── db.sqlite         # our database
              ├── main.py           # the non-auth routes for our app
              ├── models.py         # our user model
              └── templates
                  ├── base.html     # contains common layout and links
                  ├── index.html    # show the home page
                  ├── login.html    # show the login form
                  ├── profile.html  # show the profile page
                  └── signup.html   # show the signup form
      

      По мере выполнения этого учебного модуля мы будем создавать эти каталоги и файлы.

      Шаг 1 — Установка пакетов

      Для нашего проекта нам потребуется три основных проекта:

      • Flask
      • Flask-Login: для обработки пользовательских сеансов после аутентификации
      • Flask-SQLAlchemy: для представления пользовательской модели и интерфейса с нашей базой данных

      Мы будем использовать SQLite, чтобы не устанавливать дополнительные зависимости для базы данных.

      Для начала мы создадим каталог проекта:

      Затем нам нужно будет перейти в каталог проекта:

      Если у нас нет среды Python, нам нужно будет ее создать. В зависимости от способа установки Python на вашем компьютере команды будут выглядеть примерно так:

      • python3 -m venv auth
      • source auth/bin/activate

      Примечание. Вы можете использовать учебный модуль по вашей локальной среде для получения информации по настройке venv.

      Выполните в своей виртуальной среде следующие команды для установки необходимых пакетов:

      • pip install flask flask-sqlalchemy flask-login

      Мы установили пакеты и теперь можем создать основной файл приложения.

      Шаг 2 — Создание главного файла приложения

      Для начала мы создадим каталог проекта:

      В первую очередь мы начнем работать над файлом __init__.py для нашего проекта:

      Этот файл будет содержать функцию создания нашего приложения, которая инициализирует базу данных и зарегистрирует наши проекты. На данный момент мы не увидим изменений, но это потребуется для создания остальных частей приложения. Нам нужно будет инициализировать SQLAlchemy, настроить определенные значения конфигурации и зарегистрировать здесь наши проекты.

      project/__init__.py

      from flask import Flask
      from flask_sqlalchemy import SQLAlchemy
      
      # init SQLAlchemy so we can use it later in our models
      db = SQLAlchemy()
      
      def create_app():
          app = Flask(__name__)
      
          app.config['SECRET_KEY'] = 'secret-key-goes-here'
          app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite'
      
          db.init_app(app)
      
          # blueprint for auth routes in our app
          from .auth import auth as auth_blueprint
          app.register_blueprint(auth_blueprint)
      
          # blueprint for non-auth parts of app
          from .main import main as main_blueprint
          app.register_blueprint(main_blueprint)
      
          return app
      

      Теперь у нас готов основной файл приложения, и мы можем начать добавление маршрутов.

      Шаг 3 — Добавление маршрутов

      Для наших маршрутов мы будем использовать два проекта. В основном проекте у нас будет главная страница (/) и страница профиля (/profile), открываемая после входа. Если пользователь попытается получить доступ к странице профиля без входа в систему, он будет направлен на маршрут входа.

      В нашем проекте auth у нас будут маршруты для получения страницы входа (/login) и страницы регистрации (/sign-up). Также у нас имеются маршруты для обработки запросов POST от обоих этих маршрутов. Наконец, у нас имеется маршрут выхода (/logout) для выхода активного пользователя из системы.

      Пока что мы определим login, signup и logout простыми возвратами. Мы вернемся к ним немного позднее и обновим их, добавив желаемые функции.

      Вначале создайте файл main.py для main_blueprint:

      project/main.py

      from flask import Blueprint
      from . import db
      
      main = Blueprint('main', __name__)
      
      @main.route('/')
      def index():
          return 'Index'
      
      @main.route('/profile')
      def profile():
          return 'Profile'
      

      Затем создайте файл auth.py для auth_blueprint:

      project/auth.py

      from flask import Blueprint
      from . import db
      
      auth = Blueprint('auth', __name__)
      
      @auth.route('/login')
      def login():
          return 'Login'
      
      @auth.route('/signup')
      def signup():
          return 'Signup'
      
      @auth.route('/logout')
      def logout():
          return 'Logout'
      

      В терминале вы можете задать значения FLASK_APP и FLASK_DEBUG:

      • export FLASK_APP=project
      • export FLASK_DEBUG=1

      Переменная среды FLASK_APP сообщает Flask, как загружать приложение. Она должна указывать на место создания create_app. Для наших целей мы будем использовать указатели на каталог project.

      Переменная среды FLASK_DEBUG активируется посредством присвоения ей значения 1. Это активирует отладчик, который будет отображать в браузере ошибки приложения.

      Убедитесь, что вы находитесь в каталоге flask_auth_app и запустите проект:

      Теперь у вас должна появиться возможность открыть в браузере пять возможных URL-адресов и увидеть возвращаемый текст, определенный в файлах auth.py и main.py.

      Например, если открыть адрес localhost:5000/profile, появится: Profile:

      Снимок экрана проекта с открытым адресом localhost:5000 в браузере

      Мы проверили поведение наших маршрутов и можем перейти к созданию шаблонов.

      Шаг 4 — Создание шаблонов

      Давайте продолжим и создадим шаблоны, которые используются в нашем приложении. Это будет первый шаг, прежде чем мы сможем реализовать реальную функцию входа. Наше приложение будет использовать четыре шаблона:

      • index.html
      • profile.html
      • login.html
      • signup.html

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

      Для начала создайте каталог templates в каталоге project:

      • mkdir -p project/templates

      Затем создайте base.html:

      • nano project/templates/base.html

      Добавьте следующий код в файл base.html:

      project/templates/base.html

      <!DOCTYPE html>
      <html>
      
      <head>
          <meta charset="utf-8">
          <meta http-equiv="X-UA-Compatible" content="IE=edge">
          <meta name="viewport" content="width=device-width, initial-scale=1">
          <title>Flask Auth Example</title>
          <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bulma/0.7.2/css/bulma.min.css" />
      </head>
      
      <body>
          <section class="hero is-primary is-fullheight">
      
              <div class="hero-head">
                  <nav class="navbar">
                      <div class="container">
      
                          <div id="navbarMenuHeroA" class="navbar-menu">
                              <div class="navbar-end">
                                  <a href="https://www.digitalocean.com/community/tutorials/{{ url_for("main.index') }}" class="navbar-item">
                                      Home
                                  </a>
                                  <a href="https://www.digitalocean.com/community/tutorials/{{ url_for("main.profile') }}" class="navbar-item">
                                      Profile
                                  </a>
                                  <a href="https://www.digitalocean.com/community/tutorials/{{ url_for("auth.login') }}" class="navbar-item">
                                      Login
                                  </a>
                                  <a href="https://www.digitalocean.com/community/tutorials/{{ url_for("auth.signup') }}" class="navbar-item">
                                      Sign Up
                                  </a>
                                  <a href="https://www.digitalocean.com/community/tutorials/{{ url_for("auth.logout') }}" class="navbar-item">
                                      Logout
                                  </a>
                              </div>
                          </div>
                      </div>
                  </nav>
              </div>
      
              <div class="hero-body">
                  <div class="container has-text-centered">
                     {% block content %}
                     {% endblock %}
                  </div>
              </div>
          </section>
      </body>
      
      </html>
      

      Этот код создаст серию ссылок меню на каждую страницу приложения, а также область, где будет отображаться контент.

      Примечание. За кулисами мы используем Bulma для работы со стилями и макетом. Чтобы узнать больше о Bulma, ознакомьтесь с официальной документацией Bulma.

      Затем создайте файл templates/index.html:

      • nano project/templates/index.html

      Добавьте в созданный файл следующий код, чтобы заполнить страницу содержанием:

      project/templates/index.html

      {% extends "base.html" %}
      
      {% block content %}
      <h1 class="title">
        Flask Login Example
      </h1>
      <h2 class="subtitle">
        Easy authentication and authorization in Flask.
      </h2>
      {% endblock %}
      

      Этот код создаст базовую страницу указателя с заголовком и подзаголовком.

      Затем создайте страницу templates/login.html:

      • nano project/templates/login.html

      Этот код генерирует страницу входа с полями Email и Password. Также имеется поле для отметки запоминания сеанса входа.

      project/templates/login.html

      {% extends "base.html" %}
      
      {% block content %}
      <div class="column is-4 is-offset-4">
          <h3 class="title">Login</h3>
          <div class="box">
              <form method="POST" action="/login">
                  <div class="field">
                      <div class="control">
                          <input class="input is-large" type="email" name="email" placeholder="Your Email" autofocus="">
                      </div>
                  </div>
      
                  <div class="field">
                      <div class="control">
                          <input class="input is-large" type="password" name="password" placeholder="Your Password">
                      </div>
                  </div>
                  <div class="field">
                      <label class="checkbox">
                          <input type="checkbox">
                          Remember me
                      </label>
                  </div>
                  <button class="button is-block is-info is-large is-fullwidth">Login</button>
              </form>
          </div>
      </div>
      {% endblock %}
      

      Создайте шаблон templates/signup.html:

      • nano project/templates/signup.html

      Добавьте в файл следующий код, чтобы создать страницу регистрации с полями адреса электронной почты, имени и пароля:

      project/templates/signup.html

      {% extends "base.html" %}
      
      {% block content %}
      <div class="column is-4 is-offset-4">
          <h3 class="title">Sign Up</h3>
          <div class="box">
              <form method="POST" action="/signup">
                  <div class="field">
                      <div class="control">
                          <input class="input is-large" type="email" name="email" placeholder="Email" autofocus="">
                      </div>
                  </div>
      
                  <div class="field">
                      <div class="control">
                          <input class="input is-large" type="text" name="name" placeholder="Name" autofocus="">
                      </div>
                  </div>
      
                  <div class="field">
                      <div class="control">
                          <input class="input is-large" type="password" name="password" placeholder="Password">
                      </div>
                  </div>
      
                  <button class="button is-block is-info is-large is-fullwidth">Sign Up</button>
              </form>
          </div>
      </div>
      {% endblock %}
      

      Затем создайте шаблон templates/profile.html:

      • nano project/templates/profile.html

      Добавьте этот код, чтобы создать простую страницу с закодированным заголовком, welcome Anthony:

      project/templates/profile.html

      {% extends "base.html" %}
      
      {% block content %}
      <h1 class="title">
        Welcome, Anthony!
      </h1>
      {% endblock %}
      

      Позднее мы добавим код для динамического приветствия пользователя.

      После добавления шаблонов мы можем обновить выражения возврата в каждом из маршрутов, чтобы вместо текста возвращались шаблоны.

      Обновите файл main.py, изменив строку импорта и маршруты index и profile:

      project/main.py

      from flask import Blueprint, render_template
      ...
      @main.route('/')
      def index():
          return render_template('index.html')
      
      @main.route('/profile')
      def profile():
          return render_template('profile.html')
      

      Теперь мы обновим auth.py, изменив строку импорта и маршруты login и signup:

      project/auth.py

      from flask import Blueprint, render_template
      ...
      @auth.route('/login')
      def login():
          return render_template('login.html')
      
      @auth.route('/signup')
      def signup():
          return render_template('signup.html')
      

      После внесения этих изменений страница регистрации будет следующим образом при переходе в /sign-up:

      Страница регистрации в /signup

      Теперь вы должны видеть страницы /, /login и /profile.

      Пока что мы оставим /logout отдельно, потому что эта страница не отображает шаблон.

      Шаг 5 — Создание пользовательской модели

      Наша пользовательская модель отражает, что означает наличие пользователя для нашего приложения. У нас есть поля адреса эл. почты, пароля и имени. В приложении вы можете указать, хотите ли хранить больше информации для каждого пользователя. Вы можете добавлять такие вещи как день рождения, изображение профиля или предпочтения пользователя.

      Модели, созданные в Flask-SQLAlchemy, представляются классами, которые преобразуются в таблицу в базе данных. Атрибуты этих классов превратятся в столбцы этих таблиц.

      Давайте вместе создадим эту пользовательскую модель:

      Этот код создает пользовательскую модель со столбцами id, email, password и name:

      project/models.py

      from . import db
      
      class User(db.Model):
          id = db.Column(db.Integer, primary_key=True) # primary keys are required by SQLAlchemy
          email = db.Column(db.String(100), unique=True)
          password = db.Column(db.String(100))
          name = db.Column(db.String(1000))
      

      Мы создали пользовательскую модель и теперь можем перейти к настройке базы данных.

      Шаг 6 — Настройка базы данных

      Как указано в разделе «Предварительные требования», мы будем использовать базу данных SQLite. Мы можем создать базу данных SQLite самостоятельно, но сейчас используем для этого Flask-SQLAlchemy. Мы уже указали путь к базе данных в файле __init__.py, так что нам нужно просто указать Flask-SQLAlchemy создать базу данных на Python REPL.

      Если вы остановите приложение и откроете Python REPL, мы сможем создать базу данных, используя метод create_all для объекта db. Убедитесь, что вы все еще находитесь в виртуальной среде и в каталоге flask_auth_app.

      • from project import db, create_app
      • db.create_all(app=create_app()) # pass the create_app result so Flask-SQLAlchemy gets the configuration.

      Примечание. Если вы незнакомы с использованием интерпретатора Python, вы можете проконсультироваться с официальной документацией.

      Теперь вы видите файл db.sqlite в каталоге проекта. В этой базе данных будет наша пользовательская таблица.

      Шаг 7 — Настройка функции авторизации

      Для нашей функции регистрации мы возьмем данные, вводимые пользователем в форму, и добавим их в нашу базу данных. Прежде чем добавить это, нам нужно убедиться, что пользователя еще нет в базе данных. Если его нет, нам нужно хэшировать пароль, прежде чем поместить его в базу данных, потому что мы не хотим хранить пароли в формате обычного текста.

      Для начала давайте добавим вторую функцию для обработки данных формы POST. В этой функции мы вначале соберем данные, которые были переданы пользователем.

      Создайте функцию и добавьте в ее конец переадресацию. В результате после успешной регистрации пользователь будет переадресован на страницу входа.

      Обновите файл auth.py, изменив строку import и реализовав signup_post:

      project/auth.py

      from flask import Blueprint, render_template, redirect, url_for
      ...
      @auth.route('/signup', methods=['POST'])
      def signup_post():
          # code to validate and add user to database goes here
          return redirect(url_for('auth.login'))
      

      Теперь добавим остальной код, необходимый для регистрации пользователя.

      Для начала нам нужно будет использовать объект запроса для получения данных формы.

      Продолжим обновлять файл auth.py, добавляя элементы импорта и реализуя signup_post:

      auth.py

      from flask import Blueprint, render_template, redirect, url_for, request
      from werkzeug.security import generate_password_hash, check_password_hash
      from .models import User
      from . import db
      ...
      @auth.route('/signup', methods=['POST'])
      def signup_post():
          email = request.form.get('email')
          name = request.form.get('name')
          password = request.form.get('password')
      
          user = User.query.filter_by(email=email).first() # if this returns a user, then the email already exists in database
      
          if user: # if a user is found, we want to redirect back to signup page so user can try again
              return redirect(url_for('auth.signup'))
      
          # create a new user with the form data. Hash the password so the plaintext version isn't saved.
          new_user = User(email=email, name=name, password=generate_password_hash(password, method='sha256'))
      
          # add the new user to the database
          db.session.add(new_user)
          db.session.commit()
      
          return redirect(url_for('auth.login'))
      

      Примечание. Хранение паролей в формате обычного текста считается плохой практикой с точки зрения безопасности. Обычно для защиты паролей нужно использовать сложный алгоритм хэширования и шифрование паролей.

      Шаг 8 — Тестирование метода регистрации

      У нас готов метод регистрации, и теперь мы можем создать нового пользователя. Используйте форму для создания пользователя.

      Существует два способа проверить регистрацию: использовать инструмент просмотра БД для поиска строки, добавленную в таблицу, или попробовать зарегистрироваться с тем же адресом электронной почты, и если вы получите сообщение об ошибке, это будет означать, что первый адрес электронной почты был сохранен правильно. Используем этот подход.

      Мы можем добавить код, чтобы сообщить пользователю, что адрес электронной почты уже существует, а затем отправить пользователя на страницу входа. Вызывая функцию flash, мы отправим сообщение для следующего запроса, в данном случае это запрос переадресации. На итоговой странице мы получим доступ к этому сообщение в шаблоне.

      Вначале мы добавим элемент flash, выводимый до возврата на страницу регистрации.

      project/auth.py

      from flask import Blueprint, render_template, redirect, url_for, request, flash
      ...
      @auth.route('/signup', methods=['POST'])
      def signup_post():
          ...
          if user: # if a user is found, we want to redirect back to signup page so user can try again
              flash('Email address already exists')
              return redirect(url_for('auth.signup'))
      

      Чтобы добавить в шаблон мигающее сообщение, нужно добавить над формой этот код. Так сообщение будет выводиться непосредственно над формой.

      project/templates/signup.html

      ...
      {% with messages = get_flashed_messages() %}
      {% if messages %}
          <div class="notification is-danger">
              {{ messages[0] }}. Go to <a href="https://www.digitalocean.com/community/tutorials/{{ url_for("auth.login') }}">login page</a>.
          </div>
      {% endif %}
      {% endwith %}
      <form method="POST" action="/signup">
      

      Поле регистрации с сообщением «Email address already exists. Go to login page» в темно-розовом поле

      Шаг 9 — Добавление метода входа

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

      После успешной проверки пароля мы знаем, что учетные данные пользователя верны, и мы можем разрешить ему вход в систему, используя Flask-Login. Вызывая login_user, Flask-Login создает сеанс этого пользователя, который сохраняется все время, пока пользователь остается в системе, и позволяет пользователю просматривать защищенные страницы.

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

      project/auth.py

      ...
      @auth.route('/login', methods=['POST'])
      def login_post():
          # login code goes here
          return redirect(url_for('main.profile'))
      

      Теперь нам нужно убедиться, что учетные данные пользователя введены верно:

      project/auth.py

      ...
      @auth.route('/login', methods=['POST'])
      def login_post():
          email = request.form.get('email')
          password = request.form.get('password')
          remember = True if request.form.get('remember') else False
      
          user = User.query.filter_by(email=email).first()
      
          # check if the user actually exists
          # take the user-supplied password, hash it, and compare it to the hashed password in the database
          if not user or not check_password_hash(user.password, password):
              flash('Please check your login details and try again.')
              return redirect(url_for('auth.login')) # if the user doesn't exist or password is wrong, reload the page
      
          # if the above check passes, then we know the user has the right credentials
          return redirect(url_for('main.profile'))
      

      Добавим в шаблон блок, чтобы пользователь мог видеть мигающее сообщение. Как и в случае с формой регистрации, добавим потенциальное сообщение об ошибке непосредственно над формой:

      project/templates/login.html

      ...
      {% with messages = get_flashed_messages() %}
      {% if messages %}
          <div class="notification is-danger">
              {{ messages[0] }}
          </div>
      {% endif %}
      {% endwith %}
      <form method="POST" action="/login">
      

      Теперь мы можем указать, что пользователь успешно выполнил вход, но пользователю пока некуда входить. На этом этапе мы используем Flask-Login для управления сеансами пользователя.

      Прежде чем начать, нам потребуется несколько вещей для работы Flask-Login. Для начала добавьте UserMixin в пользовательскую модель. UserMixin добавит в модель атрибуты Flask-Login, чтобы Flask-Login мог с ней работать.

      models.py

      from flask_login import UserMixin
      from . import db
      
      class User(UserMixin, db.Model):
          id = db.Column(db.Integer, primary_key=True) # primary keys are required by SQLAlchemy
          email = db.Column(db.String(100), unique=True)
          password = db.Column(db.String(100))
          name = db.Column(db.String(1000))
      

      Затем нам нужно указать загрузчик пользователя. Загрузчик пользователя сообщает Flask-Login, как найти определенного пользователя по идентификатору, сохраненному в файле cookie сеанса. Мы можем добавить его в функцию create_app вместе с кодом init для Flask-Login:

      project/__init__.py

      ...
      from flask_login import LoginManager
      ...
      def create_app():
          ...
          db.init_app(app)
      
          login_manager = LoginManager()
          login_manager.login_view = 'auth.login'
          login_manager.init_app(app)
      
          from .models import User
      
          @login_manager.user_loader
          def load_user(user_id):
              # since the user_id is just the primary key of our user table, use it in the query for the user
              return User.query.get(int(user_id))
      

      В заключение мы можем добавить функцию login_user перед переадресацией на страницу профиля для создания сеанса:

      project/auth.py

      from flask_login import login_user
      from .models import User
      ...
      @auth.route('/login', methods=['POST'])
      def login_post():
          ...
          # if the above check passes, then we know the user has the right credentials
          login_user(user, remember=remember)
          return redirect(url_for('main.profile'))
      

      С помощью Flask-Login мы можем использовать маршрут /login. Когда все размещено правильно, вы увидите страницу профиля.

      Страница профиля с текстом «Welcome, Anthony!»

      Шаг 10 — Защита страниц

      Если ваше имя не Anthony, вы увидите, что ваше имя указано неправильно. Нам нужно, чтобы профиль отображал имя в базе данных. Вначале следует защитить страницу, а затем получить доступ к данным пользователя для получения его имени.

      Чтобы защитить страницу при использовании Flask-Login, мы добавим декоратор @login_requried между маршрутом и функцией. Это не даст пользователю, не выполнившему вход в систему, увидеть этот маршрут. Если пользователь не выполнил вход, он будет переадресован на страницу входа согласно конфигурации Flask-Login.

      Используя маршруты с декоратором @login_required, мы можем использовать объект current_user внутри функций. Этот объект current_user представляет пользователя из базы данных, и мы можем получить доступ ко всем атрибутам этого пользователя, используя точечную нотацию. Например, current_user.email, current_user.password, current_user.name и current_user.id будут возвращать реальные значения, хранящиеся в базе данных для пользователя, который выполнил вход в систему.

      Давайте используем имя текущего пользователя и отправим его в шаблон. Затем мы используем это имя и выведем его значение.

      project/main.py

      from flask_login import login_required, current_user
      ...
      @main.route('/profile')
      @login_required
      def profile():
          return render_template('profile.html', name=current_user.name)
      

      Затем в файле profile.html мы обновим страницу для отображения значения name:

      project/templates/profile.html

      ...
      <h1 class="title">
        Welcome, {{ name }}!
      </h1>
      

      Когда мы перейдем на страницу профиля, мы увидим, что там отображается имя пользователя.

      Страница приветствия пользователя с именем пользователя, выполнившего вход в систему

      В заключение мы можем обновить представление выхода из системы. Мы можем вызвать функцию logout_user в маршруте выхода. Мы используем декоратор @login_required, потому что не имеет смысла выполнять выход для пользователя, который не выполнил вход.

      project/auth.py

      from flask_login import login_user, logout_user, login_required
      ...
      @auth.route('/logout')
      @login_required
      def logout():
          logout_user()
          return redirect(url_for('main.index'))
      

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

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

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

      templates/base.html

      ...
      <div class="navbar-end">
          <a href="https://www.digitalocean.com/community/tutorials/{{ url_for("main.index') }}" class="navbar-item">
              Home
          </a>
          {% if current_user.is_authenticated %}
          <a href="https://www.digitalocean.com/community/tutorials/{{ url_for("main.profile') }}" class="navbar-item">
              Profile
          </a>
          {% endif %}
          {% if not current_user.is_authenticated %}
          <a href="https://www.digitalocean.com/community/tutorials/{{ url_for("auth.login') }}" class="navbar-item">
              Login
          </a>
          <a href="https://www.digitalocean.com/community/tutorials/{{ url_for("auth.signup') }}" class="navbar-item">
              Sign Up
          </a>
          {% endif %}
          {% if current_user.is_authenticated %}
          <a href="https://www.digitalocean.com/community/tutorials/{{ url_for("auth.logout') }}" class="navbar-item">
              Logout
          </a>
          {% endif %}
      </div>
      

      Главная страница с элементами навигации Home (Главная), Login (Вход) и Sign Up (Регистрация) в верхней части экрана

      Мы успешно создали приложение с аутентификацией.

      Заключение

      Мы использовали Flask-Login и Flask-SQLAlchemy для создания системы входа в наше приложение. Мы рассказали о том, как организовать аутентификацию пользователей посредством создания пользовательской модели и сохранения данных пользователя. Затем нам нужно было проверить правильность пароля пользователя, выполнив хэширование пароля из формы, и сравнив его с сохраненным в базе данных. В заключение мы добавили в приложение авторизацию, используя декоратор @login_required на странице профиля, чтобы пользователи могли видеть ее только после входа.

      Того, что мы создали в этом учебном модуле, будет достаточно для небольших приложений, но если вы хотите с самого начала использовать больше функций, подумайте об использовании библиотек Flask-User или Flask-Security, которые построены на базе библиотеки Flask-Login.



      Source link

      Добавление области подкачки на Ubuntu 20.04


      Введение

      Одним из способов защиты от ошибок, связанных с недостатком памяти в приложениях, является добавление области подкачки на вашем сервере. В этом руководстве мы расскажем, как добавить файл подкачки на сервер Ubuntu 20.04.

      ​​[warning]
      Предупреждение. Хотя подкачка в целом рекомендуется для систем с использованием традиционных жестких дисков, ее использование с SSD-накопителями может со временем вызывать ухудшение работоспособности аппаратного обеспечения. В связи с этим мы не рекомендуем активировать подкачку при использовании услуг DigitalOcean или любого другого провайдера, применяющего SSD-накопители.

      Что такое подкачка?

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

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

      Шаг 1 — Проверка информации о подкачке в системе

      Сначала мы можем посмотреть, есть ли уже в системе область подкачки. Можно иметь несколько файлов или разделов подкачки, но обычно одного достаточно.

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

      Если после этой команды ничего не появляется, в системе сейчас нет области подкачки.

      Можно убедиться в отсутствии активной подкачки при помощи утилиты free:

      Output

      total used free shared buff/cache available Mem: 981Mi 122Mi 647Mi 0.0Ki 211Mi 714Mi Swap: 0B 0B 0B

      В строке ​​​Swap видно​​​, что в системе отсутствует активная подкачка.

      Шаг 2 — Проверка свободного пространства в разделе жесткого диска

      Перед созданием файла подкачки проверим текущее состояние диска, чтобы убедиться, что у нас достаточно места. Вводим:

      Output

      Filesystem Size Used Avail Use% Mounted on udev 474M 0 474M 0% /dev tmpfs 99M 932K 98M 1% /run /dev/vda1 25G 1.4G 23G 7% / tmpfs 491M 0 491M 0% /dev/shm tmpfs 5.0M 0 5.0M 0% /run/lock tmpfs 491M 0 491M 0% /sys/fs/cgroup /dev/vda15 105M 3.9M 101M 4% /boot/efi /dev/loop0 55M 55M 0 100% /snap/core18/1705 /dev/loop1 69M 69M 0 100% /snap/lxd/14804 /dev/loop2 28M 28M 0 100% /snap/snapd/7264 tmpfs 99M 0 99M 0% /run/user/1000

      В данном случае устройство с / в столбце ​​​​​​Mounted on​​​ — наш диск. В данном примере у нас достаточно места (использовано только 1,4 Гбайт). Ваше использование, вероятно, будет другим.

      Хотя существует много мнений относительно правильного размера области подкачки, на самом деле он зависит от ваших личных предпочтений и требований приложений. Обычно можно начать с объема, равного объему оперативной памяти в системе, или в два раза большего. Еще одно полезное общее правило — любое превышение 4 Гбайт для области подкачки, скорее всего, не нужно, если вы используете ее только для резервирования оперативной памяти.

      Шаг 3 — Создание файла подкачки

      Теперь, когда известно свободное место на жестком диске, можно создать файл подкачки в нашей файловой системе. Мы добавим файл необходимого размера под названием swapfile в корневую (/) директорию.

      Лучше всего создавать файл подкачки при помощи программы fallocate. Эта команда мгновенно создает файл указанного размера.

      Поскольку на сервере в нашем случае 1 Гбайт оперативной памяти, в этом руководстве создадим файл размером 1 Гбайт. Скорректируйте с учетом необходимости на вашем сервере:

      • sudo fallocate -l 1G /swapfile

      Чтобы проверить правильность выделенного объема памяти, введите:

      • -rw-r--r-- 1 root root 1.0G Apr 25 11:14 /swapfile

      Файл создан с правильным выделенным объемом памяти.

      Шаг 4 — Активация файла подкачки

      Теперь, когда у нас есть файл правильного размера, нам нужно превратить его в пространство подкачки.

      Сначала нужно изменить права доступа к файлу, чтобы только пользователи с правами root могли читать его содержимое. Это предотвращает доступ обычных пользователей к файлу — такой доступ может существенно влиять на безопасность.

      Чтобы передать все права доступа пользователям root, введите:

      Проверьте изменение прав доступа, введя следующее:

      Output

      -rw------- 1 root root 1.0G Apr 25 11:14 /swapfile

      Теперь только у пользователя с правами root отмечены флажки чтения и записи.

      Теперь можем отметить файл как пространство подкачки, введя следующее:

      Output

      Setting up swapspace version 1, size = 1024 MiB (1073737728 bytes) no label, UUID=6e965805-2ab9-450f-aed6-577e74089dbf

      После этого мы можем активировать файл подкачки, чтобы система могла его использовать:

      Убедитесь, что пространство подкачки активировано, введя следующее:

      Output

      NAME TYPE SIZE USED PRIO /swapfile file 1024M 0B -2

      Чтобы подтвердить наши выводы, можем снова проверить ответ утилиты free:

      Output

      total used free shared buff/cache available Mem: 981Mi 123Mi 644Mi 0.0Ki 213Mi 714Mi Swap: 1.0Gi 0B 1.0Gi

      Подкачка успешно настроена, и операционная система начнет использовать ее по мере необходимости.

      Шаг 5 — Сделать файл подкачки постоянным

      В результате внесенных нами изменений файл подкачки активирован для текущей сессии. После перезагрузки сервер не сохранит настройки подкачки автоматически. Мы можем изменить это, добавив файл подкачки к файлу /etc/fstab.

      Сделайте резервную копию файла /etc/fstab на случай если что-то пойдет не так:

      • sudo cp /etc/fstab /etc/fstab.bak

      Добавьте информацию о файле подкачки в конец файла /etc/fstab, введя следующее:

      • echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

      Далее рассмотрим некоторые настройки, которые мы сможем обновить, чтобы настроить пространство подкачки.

      Шаг 6 — Изменение настроек подкачки

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

      Настройка параметра Swappiness

      Параметр swappiness определяет, как часто система выгружает данные из оперативной памяти в пространство подкачки. Его значение выражается числом от 0 до 100 процентов.

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

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

      Можем увидеть текущее значение фактора swappiness, введя следующее:

      • cat /proc/sys/vm/swappiness

      Output

      60

      Для настольного компьютера неплохое значение swappiness — 60. Для сервера, возможно, вы захотите приблизить его к 0.

      Можно задать другое значение swappiness при помощи команды sysctl.

      Например, чтобы установить значение swappiness 10, можно ввести следующее:

      • sudo sysctl vm.swappiness=10

      Output

      vm.swappiness = 10

      Эта настройка будет сохраняться до следующей перезагрузки. Можно автоматически задать это значение при перезагрузке, добавив строку в файл /etc/sysctl.conf:

      • sudo nano /etc/sysctl.conf

      Внизу можно ввести следующее:

      /etc/sysctl.conf

      vm.swappiness=10
      

      Сохраните файл и закройте его после завершения.

      Изменение настроек нагрузки кэш-памяти

      Еще одно связанное значение, которое вы, возможно, захотите изменить — vfs_cache_pressure. Эта настройка определяет, насколько система будет кэшировать данные inode и dentry по сравнению с другими данными.

      По сути, это данные доступа к файловой системе. Как правило, искать их довольно сложно, а запрашиваются они часто, так что кэш-память в этом случае весьма полезна. Чтобы узнать текущее значение этого параметра, можно еще раз запросить файловую систему proc:

      • cat /proc/sys/vm/vfs_cache_pressure

      Output

      100

      Согласно текущим настройкам, система удаляет данные инодов из кэша слишком быстро. Можно задать более консервативное значение, например 50, введя следующее:

      • sudo sysctl vm.vfs_cache_pressure=50

      Output

      vm.vfs_cache_pressure = 50

      Опять-таки, это значение действительно только для текущей сессии. Чтобы сделать его постоянным, нужно (как и в случае со swappiness) изменить файл конфигурации:

      • sudo nano /etc/sysctl.conf

      Внизу добавьте строку с новым значением:

      /etc/sysctl.conf

      vm.vfs_cache_pressure=50
      

      Сохраните и закройте файл после завершения.

      Заключение

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

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



      Source link

      Добавление юнит-тестирования в проект Django


      Автор выбрал фонд Open Internet/Free Speech для получения пожертвования в рамках программы Write for DOnations.

      Введение

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

      Тестирование веб-сайта может стать сложной задачей, поскольку он включает несколько слоев логики, например обработку HTTP-запросов, валидацию форм и отрисовку шаблонов. Однако Django предоставляет набор инструментов, которые избавляют от множества проблем при тестировании веб-приложений. В Django предпочтительным способом написания тестов является использование модуля unittest Python, хотя вы можете использовать другие фреймворки для тестирования.

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

      Предварительные требования

      Прежде чем начать выполнение этого руководства, вам потребуется следующее:

      Шаг 1 — Добавление набора тестов для вашего приложения Django

      Набор тестов в Django — это все тест-кейсы для всех приложений в вашем проекте. Чтобы утилита тестирования Django могла обнаружить все имеющиеся тест-кейсы, вы должны записать тест-кейсы в скрипт, название которого начинается с test. На этом шаге вы должны будете создать структуру каталогов и файлов для вашего набора тестов и создать внутри пустой тест-кейс.

      Если вы ознакомились с серией обучающих материалов по разработке Django, у вас в распоряжении должно быть приложение Django с именем blogsite​​​.

      Давайте создадим папку для хранения всех наших скриптов тестов. Вначале необходимо активировать виртуальную среду:

      • cd ~/my_blog_app
      • . env/bin/activate

      Затем перейдите в каталог приложения blogsite, в папку, которая содержит файлы models.py и views.py​​​, а затем создайте новую папку с именем tests:

      • cd ~/my_blog_app/blog/blogsite
      • mkdir tests

      Далее необходимо превратить эту папку в пакет Python, добавив файл __init__.py:

      • cd ~/my_blog_app/blog/blogsite/tests
      • touch __init__.py

      Теперь вы должны добавить файл для тестирования ваших моделей и другой файл для тестирования представлений:

      • touch test_models.py
      • touch test_views.py

      В заключение вы создадите пустой тест-кейс в файле test_models.py: Вам нужно будет импортировать класс TestCase Django и сделать его родительским классом для вашего класса тест-кейса. В дальнейшем вы сможете добавить в этот тест-кейс методы для тестирования логики в ваших моделях. Откройте файл test_models.py:

      Теперь добавьте в файл следующий код:

      ~/my_blog_app/blog/blogsite/tests/test_models.py

      from django.test import TestCase
      
      class ModelsTestCase(TestCase):
          pass
      

      Вы успешно добавили набор тестов в приложение blogsite. Далее вам необходимо заполнить данные для пустого тест-кейса модели, которую вы создали.

      Шаг 2 — Тестирование кода Python

      На этом шаге вы протестируете логику кода в файле models.py. В частности, вы должны будете протестировать метод save модели Post, чтобы убедиться, что при вызове он создает корректный слаг для тайтла поста.

      Давайте начнем с изучения кода, который уже находится в файле models.py для метода save модели Post:

      • cd ~/my_blog_app/blog/blogsite
      • nano models.py

      Вы увидите следующее:

      ~/my_blog_app/blog/blogsite/models.py

      class Post(models.Model):
          ...
          def save(self, *args, **kwargs):
              if not self.slug:
                  self.slug = slugify(self.title)
              super(Post, self).save(*args, **kwargs)
          ...
      

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

      Закройте файл.

      Чтобы протестировать это, вернитесь к файлу test_models.py:

      Затем обновите его содержимое, добавив код в выделенные части:

      ~/my_blog_app/blog/blogsite/tests/test_models.py

      from django.test import TestCase
      from django.template.defaultfilters import slugify
      from blogsite.models import Post
      
      
      class ModelsTestCase(TestCase):
          def test_post_has_slug(self):
              """Posts are given slugs correctly when saving"""
              post = Post.objects.create(title="My first post")
      
              post.author = "John Doe"
              post.save()
              self.assertEqual(post.slug, slugify(post.title))
      

      Этот новый метод test_post_has_slug создает новый пост с именем "My first post", а затем указывает для поста автора и сохраняет пост. После этого, используя метод assertEqual из модуля unittest Python, он проверяет корректность слага для поста. Метод assertEqual проверяет, равны ли два переданных ему аргумента, что определяется оператором "==", и генерирует ошибку в противном случае.

      Сохраните и закройте test_models.py.

      Это пример того, что можно протестировать. Чем больше логики вы будете добавлять в ваш проект, тем больше тестов вам потребуется. Если вы добавите в метод save дополнительную логику или создадите новые методы для модели Post, вам нужно будет добавить сюда дополнительные тесты. Вы можете добавить их в метод test_post_has_slug или создать новые методы тестирования, но их имена должны начинаться с test.

      Вы успешно создали тест-кейс для модели Post, где вы проверяли, что слаги создаются корректно после сохранения. На следующем шаге вы должны будете написать тест-кейс для тестирования представлений.

      Шаг 3 — Использование тестового клиента Django

      На этом шаге вы напишете тест-кейс, который тестирует представление с помощью тестового клиента Django. Тестовый клиент — это класс Python, который действует как шаблонный браузер, позволяя вам тестировать ваши представления и взаимодействовать с приложением Django таким же образом, как это делал бы пользователь. Вы можете получить доступ к тестовому клиенту, сославшись на self.client в ваших тестовых методах. Давайте, например, создадим тест-кейс в test_views.py. Откройте файл test_views.py​​​:

      Затем добавьте следующее:

      ~/my_blog_app/blog/blogsite/tests/test_views.py

      from django.test import TestCase
      
      
      class ViewsTestCase(TestCase):
          def test_index_loads_properly(self):
              """The index page loads properly"""
              response = self.client.get('your_server_ip:8000')
              self.assertEqual(response.status_code, 200)
      

      ViewsTestCase содержит метод test_index_loads_properly, который использует тестовый клиент Django для посещения стартовой страницы веб-сайта (http://your_server_ip:8000, где your_server_ip — это IP-адрес сервера, который вы используете). Затем тестовый метод проверяет, содержит ли ответ код состояния 200, который означает, что страница отправляет ответ без ошибок. В результате вы можете быть уверены, что при посещении страницы пользователем она также не будет генерировать ошибки.

      Помимо кода состояния вы можете узнать о других свойствах ответа тестового клиента, которые вы можете протестировать, на странице тестирования ответов документации Django.

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

      Шаг 4 — Запуск тестов

      Теперь, когда вы завершили сборку набора тестов для проекта, пришло время запустить эти тесты и посмотреть их результаты. Чтобы запустить тесты, перейдите в папку blog (содержащую файл manage.py приложения):

      Запустите их с помощью следующей команды:

      Вы увидите примерно следующий вывод в вашем терминале:

      Output

      Creating test database for alias 'default'... System check identified no issues (0 silenced). .. ---------------------------------------------------------------------- Ran 2 tests in 0.007s OK Destroying test database for alias 'default'...

      Этот вывод содержит две точки .., каждая из которых отображает выполненный тест-кейс. Теперь вы можете изменить test_views.py, чтобы вызвать падение теста. Сначала откройте файл с помощью следующей команды:

      Затем измените выделенный код на следующий:

      ~/my_blog_app/blog/blogsite/tests/test_views.py

      from django.test import TestCase
      
      
      class ViewsTestCase(TestCase):
          def test_index_loads_properly(self):
              """The index page loads properly"""
              response = self.client.get('your_server_ip:8000')
              self.assertEqual(response.status_code, 404)
      

      Здесь вы изменили код состояния с 200 на 404. Теперь снова запустите тест из каталога с файлом manage.py:

      Вывод должен выглядеть так:

      Output

      Creating test database for alias 'default'... System check identified no issues (0 silenced). .F ====================================================================== FAIL: test_index_loads_properly (blogsite.tests.test_views.ViewsTestCase) The index page loads properly ---------------------------------------------------------------------- Traceback (most recent call last): File "~/my_blog_app/blog/blogsite/tests/test_views.py", line 8, in test_index_loads_properly self.assertEqual(response.status_code, 404) AssertionError: 200 != 404 ---------------------------------------------------------------------- Ran 2 tests in 0.007s FAILED (failures=1) Destroying test database for alias 'default'...

      Вы увидите сообщение, содержащее описание ошибки, указывающее скрипт, тест-кейс и метод, который не был выполнен. Также оно сообщает причину ошибки, в данном случае код состояния не равен 404, в форме сообщения AssertionError: 200 ! = 404. AssertionError здесь возникает в выделенной строке кода в файле test_views.py:

      ~/my_blog_app/blog/blogsite/tests/test_views.py

      from django.test import TestCase
      
      
      class ViewsTestCase(TestCase):
          def test_index_loads_properly(self):
              """The index page loads properly"""
              response = self.client.get('your_server_ip:8000')
              self.assertEqual(response.status_code, 404)
      

      Она указывает, что утверждение является ложным, т. е. код состояния ответа (200) не соответсвует ожидаемому результату (404). Теперь вы можете видеть, что две точки .., идущие перед сообщением об ошибке, теперь превратились в . F, что говорит о том, что первый тест-кейс был пройден успешно, а второй — нет.

      Заключение

      В этом руководстве вы создали набор тестов в вашем проекте Django, добавили тест-кейсы для тестирования логики модели и представления,узнали, как запускать тесты, и проанализировали вывод теста. В качестве следующего шага вы можете создать новые тестовые скрипты для кода Python в других файлах помимо models.py и views.py.

      Ниже представлено несколько статей, которые могут оказаться полезными при создании и тестировании сайтов с помощью Django:

      Также вы можете найти на нашей странице материалов по теме Django другие руководства и проекты.



      Source link