Kurs Python · Moduł 5: Flask i aplikacje webowe

Flask-Login - autentykacja użytkowników

7 min czytania ·
W tej lekcji12

Witaj ponownie! Darwin tutaj z ostatnią lekcją przed deployment - autentykacja użytkowników z Flask-Login!

Analogia Safari: Autentykacja to jak przepustki dla turystów - tylko osoby z ważnymi biletami mogą wejść do parku, obserwować zwierzęta, i korzystać z ekskluzywnych tras! Bez autentykacji każdy mógłby wejść i edytować Twoją bazę danych!

Po co autentykacja?

Problem: Bez autentykacji każdy może:

  • Dodawać/usuwać gatunki
  • Edytować dane
  • Dostęp do wrażliwych informacji
  • Brak personalizacji

Rozwiązanie: System logowania/rejestracji z Flask-Login!

Flask-Login - zarządzanie sesjami

Flask-Login to rozszerzenie zarządzające sesjami użytkowników:

Login/logout użytkowników Zapamiętywanie sesji (cookies) Ochrona routes (@login_required) Dostęp do current_user "Remember me" functionality

Instalacja

pip install Flask-Login

User Model - model użytkownika

Flask-Login wymaga klasy User z określonymi metodami. Najprościej użyć UserMixin:

# models.py
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash

class User(UserMixin):
    def __init__(self, id, username, email, password_hash):
        self.id = id
        self.username = username
        self.email = email
        self.password_hash = password_hash

    def set_password(self, password):
        """Hash hasła"""
        self.password_hash = generate_password_hash(password)

    def check_password(self, password):
        """Sprawdź hasło"""
        return check_password_hash(self.password_hash, password)

    def __repr__(self):
        return f'<User {self.username}>'

UserMixin dostarcza:

  • is_authenticated - czy zalogowany
  • is_active - czy aktywny
  • is_anonymous - czy anonimowy
  • get_id() - zwraca ID jako string

Konfiguracja Flask-Login

# app.py
from flask import Flask
from flask_login import LoginManager

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key-123'

# Inicjalizuj LoginManager
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'  # Przekierowanie dla niezalogowanych
login_manager.login_message = 'Zaloguj się, aby uzyskać dostęp.'

# Baza użytkowników (w produkcji: SQLite/PostgreSQL)
users_db = {}
next_user_id = 1

# User loader - wymagany przez Flask-Login
@login_manager.user_loader
def load_user(user_id):
    """Załaduj użytkownika po ID"""
    return users_db.get(int(user_id))

@login_manager.user_loader - Flask-Login wywołuje tę funkcję, aby załadować użytkownika z sesji.

Rejestracja użytkownika

forms.py - formularz rejestracji

from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email, EqualTo, Length

class RegistrationForm(FlaskForm):
    username = StringField('Username',
                          validators=[DataRequired(), Length(min=4, max=20)])

    email = StringField('Email',
                       validators=[DataRequired(), Email()])

    password = PasswordField('Hasło',
                            validators=[DataRequired(), Length(min=8)])

    confirm_password = PasswordField('Potwierdź hasło',
                                    validators=[DataRequired(),
                                               EqualTo('password', message='Hasła muszą być identyczne')])

    submit = SubmitField('Zarejestruj się')

app.py - route rejestracji

from flask import render_template, redirect, url_for, flash
from flask_login import login_user
from models import User
from forms import RegistrationForm

@app.route('/register', methods=['GET', 'POST'])
def register():
    form = RegistrationForm()

    if form.validate_on_submit():
        global next_user_id

        # Sprawdź, czy username/email już istnieje
        for user in users_db.values():
            if user.username == form.username.data:
                flash('Username już zajęty!', 'error')
                return render_template('register.html', form=form)

            if user.email == form.email.data:
                flash('Email już zarejestrowany!', 'error')
                return render_template('register.html', form=form)

        # Utwórz nowego użytkownika
        user = User(
            id=next_user_id,
            username=form.username.data,
            email=form.email.data,
            password_hash=None
        )
        user.set_password(form.password.data)  # Hash hasła

        users_db[next_user_id] = user
        next_user_id += 1

        flash(f'Konto {user.username} utworzone! Możesz się zalogować.', 'success')
        return redirect(url_for('login'))

    return render_template('register.html', form=form)

Logowanie użytkownika

forms.py - formularz logowania

class LoginForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired()])
    password = PasswordField('Hasło', validators=[DataRequired()])
    remember = BooleanField('Zapamiętaj mnie')
    submit = SubmitField('Zaloguj')

app.py - route logowania

from flask_login import login_user, current_user, logout_user

@app.route('/login', methods=['GET', 'POST'])
def login():
    # Jeśli już zalogowany, przekieruj
    if current_user.is_authenticated:
        return redirect(url_for('home'))

    form = LoginForm()

    if form.validate_on_submit():
        # Znajdź użytkownika
        user = None
        for u in users_db.values():
            if u.username == form.username.data:
                user = u
                break

        # Sprawdź hasło
        if user and user.check_password(form.password.data):
            login_user(user, remember=form.remember.data)
            flash(f'Witaj z powrotem, {user.username}!', 'success')

            # Przekieruj do next_page lub home
            next_page = request.args.get('next')
            return redirect(next_page) if next_page else redirect(url_for('home'))
        else:
            flash('Nieprawidłowy username lub hasło!', 'error')

    return render_template('login.html', form=form)

login_user(user, remember=True) - zaloguj użytkownika i stwórz sesję.

Wylogowanie

@app.route('/logout')
def logout():
    logout_user()
    flash('Zostałeś wylogowany.', 'info')
    return redirect(url_for('home'))

logout_user() - wyloguj użytkownika i usuń sesję.

@login_required - ochrona routes

Dekorator @login_required chroni routes przed niezalogowanymi użytkownikami:

from flask_login import login_required, current_user

@app.route('/species/add', methods=['GET', 'POST'])
@login_required  # Tylko zalogowani
def add_species():
    form = AddSpeciesForm()

    if form.validate_on_submit():
        # ... dodaj gatunek ...
        flash(f'Gatunek dodany przez {current_user.username}!', 'success')
        return redirect(url_for('list_species'))

    return render_template('add_species.html', form=form)

@app.route('/profile')
@login_required
def profile():
    return render_template('profile.html', user=current_user)

Jeśli niezalogowany użytkownik wejdzie na /species/add:

  1. Zostanie przekierowany na /login
  2. Po zalogowaniu wróci do /species/add

current_user - aktualny użytkownik

current_user to proxy do zalogowanego użytkownika:

from flask_login import current_user

@app.route('/')
def home():
    if current_user.is_authenticated:
        return render_template('home.html',
                             username=current_user.username,
                             species_count=len(species_db))
    else:
        return render_template('home.html',
                             username=None,
                             species_count=len(species_db))

W templates

{% if current_user.is_authenticated %}
    <p>Zalogowany jako: <strong>{{ current_user.username }}</strong></p>
    <a href="{{ url_for('logout') }}">Wyloguj</a>
{% else %}
    <a href="{{ url_for('login') }}">Zaloguj</a> |
    <a href="{{ url_for('register') }}">Zarejestruj się</a>
{% endif %}

Haszowanie haseł - bezpieczeństwo

NIGDY nie przechowuj haseł w plain text! Używaj haszowania:

from werkzeug.security import generate_password_hash, check_password_hash

# Rejestracja - hashuj hasło
password_hash = generate_password_hash('TajneHaslo123')
# Output: 'pbkdf2:sha256:260000$...'

# Logowanie - sprawdź hasło
is_correct = check_password_hash(password_hash, 'TajneHaslo123')
# Output: True

generate_password_hash() używa PBKDF2 z solą i wieloma iteracjami - bezpieczne!

Kompletna aplikacja z autentykacją

models.py

from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash

class User(UserMixin):
    def __init__(self, id, username, email, password_hash):
        self.id = id
        self.username = username
        self.email = email
        self.password_hash = password_hash

    def set_password(self, password):
        self.password_hash = generate_password_hash(password)

    def check_password(self, password):
        return check_password_hash(self.password_hash, password)

forms.py

from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, BooleanField, SubmitField
from wtforms.validators import DataRequired, Email, EqualTo, Length

class RegistrationForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired(), Length(min=4, max=20)])
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Hasło', validators=[DataRequired(), Length(min=8)])
    confirm_password = PasswordField('Potwierdź hasło',
                                    validators=[DataRequired(), EqualTo('password')])
    submit = SubmitField('Zarejestruj')

class LoginForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired()])
    password = PasswordField('Hasło', validators=[DataRequired()])
    remember = BooleanField('Zapamiętaj mnie')
    submit = SubmitField('Zaloguj')

app.py

from flask import Flask, render_template, redirect, url_for, flash, request
from flask_login import LoginManager, login_user, logout_user, login_required, current_user
from models import User
from forms import RegistrationForm, LoginForm, AddSpeciesForm

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key-123'

# Flask-Login
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'

# Bazy danych (in-memory)
users_db = {}
next_user_id = 1

species_db = {}
next_species_id = 1

@login_manager.user_loader
def load_user(user_id):
    return users_db.get(int(user_id))

@app.route('/')
def home():
    return render_template('home.html',
                         species_count=len(species_db))

@app.route('/register', methods=['GET', 'POST'])
def register():
    if current_user.is_authenticated:
        return redirect(url_for('home'))

    form = RegistrationForm()

    if form.validate_on_submit():
        global next_user_id

        # Sprawdź duplikaty
        for user in users_db.values():
            if user.username == form.username.data:
                flash('Username już zajęty!', 'error')
                return render_template('register.html', form=form)

        # Utwórz użytkownika
        user = User(next_user_id, form.username.data, form.email.data, None)
        user.set_password(form.password.data)
        users_db[next_user_id] = user
        next_user_id += 1

        flash(f'Konto utworzone! Zaloguj się.', 'success')
        return redirect(url_for('login'))

    return render_template('register.html', form=form)

@app.route('/login', methods=['GET', 'POST'])
def login():
    if current_user.is_authenticated:
        return redirect(url_for('home'))

    form = LoginForm()

    if form.validate_on_submit():
        user = None
        for u in users_db.values():
            if u.username == form.username.data:
                user = u
                break

        if user and user.check_password(form.password.data):
            login_user(user, remember=form.remember.data)
            flash(f'Witaj, {user.username}!', 'success')

            next_page = request.args.get('next')
            return redirect(next_page) if next_page else redirect(url_for('home'))
        else:
            flash('Nieprawidłowy username lub hasło!', 'error')

    return render_template('login.html', form=form)

@app.route('/logout')
@login_required
def logout():
    logout_user()
    flash('Wylogowano.', 'info')
    return redirect(url_for('home'))

@app.route('/species/add', methods=['GET', 'POST'])
@login_required
def add_species():
    form = AddSpeciesForm()

    if form.validate_on_submit():
        global next_species_id

        new_species = {
            'id': next_species_id,
            'name': form.name.data,
            'added_by': current_user.username
        }

        species_db[next_species_id] = new_species
        next_species_id += 1

        flash(f'Gatunek dodany przez {current_user.username}!', 'success')
        return redirect(url_for('list_species'))

    return render_template('add_species.html', form=form)

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

templates/base.html - nawigacja z auth

<nav>
    <a href="{{ url_for('home') }}">Home</a>
    <a href="{{ url_for('list_species') }}">Gatunki</a>

    {% if current_user.is_authenticated %}
        <a href="{{ url_for('add_species') }}">Dodaj gatunek</a>
        <a href="{{ url_for('profile') }}">Profil ({{ current_user.username }})</a>
        <a href="{{ url_for('logout') }}">Wyloguj</a>
    {% else %}
        <a href="{{ url_for('login') }}">Zaloguj</a>
        <a href="{{ url_for('register') }}">Zarejestruj</a>
    {% endif %}
</nav>

Podsumowanie

W tej lekcji nauczyłeś/aś się:

  • Po co autentykacja w aplikacjach webowych
  • Flask-Login - zarządzanie sesjami
  • User model z UserMixin
  • Rejestracja użytkowników
  • Logowanie/wylogowanie
  • @login_required - ochrona routes
  • current_user - dostęp do zalogowanego użytkownika
  • Haszowanie haseł (werkzeug.security)
  • Kompletna aplikacja Safari Database z auth

Analogia Safari finalna: Flask-Login to jak system przepustek safari - tylko turyści z ważnymi biletami (current_user.is_authenticated) mogą wejść do strefy chronionych tras (@login_required), a każdy turysta ma swój unikalny identyfikator (user.id) i hasło (haszowane)!

Następna lekcja: Darwin pokaże Ci deployment - publikowanie aplikacji Flask w internecie (Gunicorn, Render, Railway)!

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Co reprezentuje obiekt current_user w Flask-Login?

  2. 2. Jak zainstalować Flask-Login?

To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż definicję modelu User z Flask-Login:

  • Klikanie w kolejności

    Ułóż wywołanie funkcji login_user:

  • Edytor kodu

    Napisz widok /dashboard z dekoratorem @login_required wyświetlający powitanie dla current_user.

  1. Pytaniecurrent_user
  2. PytanieInstalacja Flask-Login
  3. Ułóż w kolejnościModel User
  4. PytanieUserMixin
  5. PytanieDekorator login_required
  6. Kliknij w kolejnościLogowanie użytkownika
  7. Zadanie z kodemWidok chroniony

Przydatne artykuły