Pada seri belajar Python Part 17, kita sudah berhasil menghubungkan Flask dengan database menggunakan Flask-SQLAlchemy. Namun, aplikasi yang dibuat masih bisa diakses oleh siapa saja tanpa proses login. Artinya, belum ada pembatasan akses untuk melindungi data atau halaman tertentu.
Agar aplikasi lebih aman, kita perlu menambahkan sistem autentikasi untuk mengenali pengguna yang sedang login. Pada seri belajar Python Part 18 ini, kita akan belajar membuat autentikasi user dengan Flask-Login, mulai dari proses registrasi, login, hingga membatasi akses ke halaman tertentu.
Konsep Dasar Autentikasi User dengan Flask-Login
Sebelum mulai menggunakan Flask-Login, ada dua istilah yang perlu kita pahami, yaitu autentikasi dan otorisasi. Keduanya sering digunakan dalam sistem login, tetapi memiliki fungsi yang berbeda.
Autentikasi digunakan untuk memastikan identitas pengguna, misalnya dengan meminta username dan password saat login. Sementara itu, otorisasi berfungsi untuk mengatur apa saja yang boleh dilakukan pengguna setelah berhasil login, seperti mengakses dashboard atau mengelola data tertentu.
Flask tidak menyediakan sistem login bawaan. Flask-Login mengisi celah ini dengan melakukan hal-hal berikut:
- menyimpan ID user yang sedang login di dalam session;
- memuat kembali objek user pada setiap request;
- menyediakan current_user yang bisa diakses di mana saja;
- menyediakan dekorator @login_required untuk memproteksi route;
- mengelola fitur “ingat saya” (remember me).
Perlu dicatat, Flask-Login tidak mengurus database, hashing password, maupun form. Bagian-bagian itu kita tangani sendiri dengan Flask-SQLAlchemy, Werkzeug, dan Flask-WTF.
Alur Kerja Autentikasi User
Adapun nantinya alur yang dilakukan autentikasi sebagai berikut.
- User mendaftar, lalu password disimpan dalam bentuk hash.
- User login dengan email dan password. Jika cocok, kita memanggil login_user().
- Flask-Login menyimpan ID User di session (cookie yang ditandatangani).
- Pada request berikutnya, Flask-Login memanggil fungsi user_loader untuk mengubah ID tadi menjadi objek User.
- Route yang diberi @login_required hanya bisa diakses jika user terautentikasi.
Persiapan Proyek Flask-Login
Untuk pembuatan dalam proyek ini perlu membuat virtual environment lalu pasang dependensi berikut:
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
pip install flask flask-login flask-sqlalchemy flask-wtf email-validatorPackage email-validator dibutuhkan oleh validator Email() pada WTForms.
Struktur folder yang kita gunakan:

Instalasi dan Inisialisasi Flask-Login
Agar tidak terjadi circular import, objek ekstensi dibuat terpisah di extensions.py:
# myapp/extensions.py
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_wtf.csrf import CSRFProtect
db = SQLAlchemy()
login_manager = LoginManager()
csrf = CSRFProtect()Lalu rakit semuanya di __init__.py dengan pola application factory:
# myapp/__init__.py
import os
from flask import Flask
from .extensions import db, login_manager, csrf
def create_app():
app = Flask(__name__)
app.config["SECRET_KEY"] = os.environ.get("SECRET_KEY", "dev-only-ganti-di-produksi")
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///app.db"
db.init_app(app)
csrf.init_app(app)
login_manager.init_app(app)
# Ke mana pengguna diarahkan jika belum login
login_manager.login_view = "auth.login"
login_manager.login_message = "Silakan login untuk mengakses halaman ini."
login_manager.login_message_category = "warning"
from .auth import bp as auth_bp
from .main import bp as main_bp
app.register_blueprint(auth_bp)
app.register_blueprint(main_bp)
with app.app_context():
db.create_all()
return appAda dua hal penting di sini. Pertama, SECRET_KEY dipakai untuk menandatangani cookie session, sehingga nilainya harus rahasia dan acak di lingkungan produksi. Kedua, login_view menentukan endpoint tujuan ketika pengguna anonim mencoba membuka halaman terproteksi.
File run.py:
# run.py
from myapp import create_app
app = create_app()
if __name__ == "__main__":
app.run(debug=True)Membuat Model User
Model user harus mewarisi UserMixin agar memiliki properti yang dibutuhkan Flask-Login: is_authenticated, is_active, is_anonymous, dan get_id().
# myapp/models.py
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from .extensions import db, login_manager
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password_hash = db.Column(db.String(256), nullable=False)
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)
def __repr__(self):
return f"<User {self.username}>"
@login_manager.user_loader
def load_user(user_id):
return db.session.get(User, int(user_id))Note:
Jangan pernah menyimpan password dalam bentuk teks asli. Kita hanya menyimpan hash. generate_password_hash menambahkan salt acak secara otomatis, sehingga dua pengguna dengan password yang sama tetap menghasilkan hash yang berbeda.
Fungsi load_user adalah callback yang dipanggil Flask-Login pada setiap request untuk memuat user berdasarkan ID di session. Fungsi ini harus mengembalikan None jika user tidak ditemukan.
Membuat Form Register dan Login
Kita memakai Flask-WTF agar validasi input rapi dan token CSRF otomatis tersedia.
# myapp/forms.py
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, BooleanField, SubmitField
from wtforms.validators import DataRequired, Email, Length, EqualTo, ValidationError
from .extensions import db
from .models import User
class RegisterForm(FlaskForm):
username = StringField("Username", validators=[DataRequired(), Length(3, 30)])
email = StringField("Email", validators=[DataRequired(), Email(), Length(max=120)])
password = PasswordField("Password", validators=[DataRequired(), Length(min=8)])
confirm = PasswordField(
"Konfirmasi Password",
validators=[DataRequired(), EqualTo("password", message="Password tidak sama.")],
)
submit = SubmitField("Daftar")
def validate_username(self, field):
if db.session.scalar(db.select(User).where(User.username == field.data)):
raise ValidationError("Username sudah dipakai.")
def validate_email(self, field):
email = field.data.lower()
if db.session.scalar(db.select(User).where(User.email == email)):
raise ValidationError("Email sudah terdaftar.")
class LoginForm(FlaskForm):
email = StringField("Email", validators=[DataRequired(), Email()])
password = PasswordField("Password", validators=[DataRequired()])
remember = BooleanField("Ingat saya")
submit = SubmitField("Masuk")Metode berawalan validate_<nama_field> otomatis dijalankan WTForms sebagai validator tambahan, cocok untuk memeriksa keunikan data di database.
Membuat Route Autentikasi
Semua route autentikasi kita kumpulkan dalam satu blueprint.
# myapp/auth.py
from urllib.parse import urlsplit
from flask import Blueprint, render_template, redirect, url_for, flash, request
from flask_login import login_user, logout_user, current_user
from .extensions import db
from .models import User
from .forms import RegisterForm, LoginForm
bp = Blueprint("auth", __name__)
def is_safe_url(target):
"""Hanya izinkan redirect ke path internal (mencegah open redirect)."""
if not target:
return False
parts = urlsplit(target)
return not parts.scheme and not parts.netloc and target.startswith("/") and not target.startswith("//")
@bp.route("/register", methods=["GET", "POST"])
def register():
if current_user.is_authenticated:
return redirect(url_for("main.dashboard"))
form = RegisterForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data.lower())
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash("Registrasi berhasil! Silakan login.", "success")
return redirect(url_for("auth.login"))
return render_template("register.html", form=form)
@bp.route("/login", methods=["GET", "POST"])
def login():
if current_user.is_authenticated:
return redirect(url_for("main.dashboard"))
form = LoginForm()
if form.validate_on_submit():
user = db.session.scalar(
db.select(User).where(User.email == form.email.data.lower())
)
if user is None or not user.check_password(form.password.data):
flash("Email atau password salah.", "danger")
return render_template("login.html", form=form)
login_user(user, remember=form.remember.data)
flash(f"Selamat datang, {user.username}!", "success")
next_page = request.args.get("next")
if not is_safe_url(next_page):
next_page = url_for("main.dashboard")
return redirect(next_page)
return render_template("login.html", form=form)
@bp.route("/logout", methods=["POST"])
def logout():
logout_user()
flash("Kamu sudah logout.", "info")
return redirect(url_for("main.index"))Beberapa poin yang layak diperhatikan:
- Pesan error yang seragam. Kita tidak memberi tahu apakah email atau password yang salah. Pesan generik mempersulit penyerang menebak email yang terdaftar.
- login_user(user, remember=…) mencatat pengguna ke session. Jika remember=True, Flask-Login juga membuat cookie tahan lama sehingga pengguna tetap login setelah browser ditutup.
- Parameter next. Ketika pengguna anonim membuka halaman terproteksi, Flask-Login mengarahkannya ke halaman login dengan ?next=/dashboard. Setelah login berhasil, kita mengembalikannya ke halaman tujuan. Fungsi is_safe_url memastikan next hanya berisi path internal, karena tanpa validasi ini penyerang dapat membuat tautan yang mengarahkan korban ke situs berbahaya (open redirect).
- Logout memakai POST. Dengan begitu, logout tidak bisa dipicu secara tidak sengaja lewat tautan atau gambar yang di-embed di situs lain, dan token CSRF ikut melindunginya.
Memproteksi Halaman dengan Login Required
Sekarang bagian yang paling ditunggu: membatasi halaman hanya untuk pengguna yang sudah login.
# myapp/main.py
from flask import Blueprint, render_template
from flask_login import login_required, current_user
bp = Blueprint("main", __name__)
@bp.route("/")
def index():
return render_template("index.html")
@bp.route("/dashboard")
@login_required
def dashboard():
return render_template("dashboard.html", user=current_user)Urutan dekorator penting: @bp.route(…) harus berada paling atas, lalu @login_required tepat di atas fungsi. Jika terbalik, route akan terdaftar tanpa proteksi.
Saat user anonim membuka /dashboard, Flask-Login otomatis mengarahkannya ke auth.login dan menampilkan pesan yang sudah kita atur di login_message.
Mengenal current_user
current_user adalah proxy ke objek user yang sedang login dan tersedia di route maupun template Jinja2:
current_user.is_authenticated # True jika sudah login
current_user.username # atribut model User
current_user.is_anonymous # True untuk pengunjung yang belum login
Membuat Template Register, Login, dan Dashboard
Berikut template-template minimal yang dapat digunaakn.
- Pertama, base.html yang menampilkan navigasi dinamis dan pesan flash.
<!-- templates/base.html -->
<!doctype html>
<html lang="id">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{% block title %}Aplikasi Saya{% endblock %}</title>
</head>
<body>
<nav>
<a href="{{ url_for('main.index') }}">Beranda</a>
{% if current_user.is_authenticated %}
<a href="{{ url_for('main.dashboard') }}">Dashboard</a>
<form action="{{ url_for('auth.logout') }}" method="post" style="display:inline">
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
<button type="submit">Logout ({{ current_user.username }})</button>
</form>
{% else %}
<a href="{{ url_for('auth.login') }}">Login</a>
<a href="{{ url_for('auth.register') }}">Daftar</a>
{% endif %}
</nav>
{% with messages = get_flashed_messages(with_categories=true) %}
{% for category, message in messages %}
<p class="flash {{ category }}">{{ message }}</p>
{% endfor %}
{% endwith %}
{% block content %}{% endblock %}
</body>
</html>- Kedua, register.html:
<!-- templates/register.html -->
{% extends "base.html" %}
{% block title %}Daftar{% endblock %}
{% block content %}
<h1>Buat Akun</h1>
<form method="post" novalidate>
{{ form.hidden_tag() }}
{% for field in [form.username, form.email, form.password, form.confirm] %}
<p>
{{ field.label }}<br>
{{ field() }}
{% for error in field.errors %}<br><small style="color:red">{{ error }}</small>{% endfor %}
</p>
{% endfor %}
{{ form.submit() }}
</form>
{% endblock %}- Ketiga, login.html:
<!-- templates/login.html -->
{% extends "base.html" %}
{% block title %}Login{% endblock %}
{% block content %}
<h1>Masuk</h1>
<form method="post" novalidate>
{{ form.hidden_tag() }}
<p>{{ form.email.label }}<br>{{ form.email() }}</p>
<p>{{ form.password.label }}<br>{{ form.password() }}</p>
<p>{{ form.remember() }} {{ form.remember.label }}</p>
{{ form.submit() }}
</form>
{% endblock %}- Terakhir, dashboard.html dan index.html:
<!-- templates/dashboard.html -->
{% extends "base.html" %}
{% block content %}
<h1>Dashboard</h1>
<p>Halo, <strong>{{ user.username }}</strong>! Halaman ini hanya bisa dilihat setelah login.</p>
{% endblock %}
<!-- templates/index.html -->
{% extends "base.html" %}
{% block content %}
<h1>Selamat Datang</h1>
<p>Ini halaman publik yang bisa dibuka siapa saja.</p>
{% endblock %}Menjalankan dan Menguji Autentikasi
Jalankan aplikasi:
python run.pyLalu uji skenario berikut secara berurutan:
Buka http://127.0.0.1:5000/dashboard atau melalui python anywhere tanpa login. Kamu seharusnya diarahkan ke /login?next=/dashboard beserta pesan peringatan.

Buka /register, daftarkan akun baru dengan password minimal 8 karakter.

Jika berhasil tampilannya sebagai berikut.

Coba daftar lagi dengan email yang sama dan pastikan muncul pesan “Email sudah terdaftar.”

Login dengan akun tersebut. Kamu seharusnya langsung dibawa ke /dashboard.

Klik Logout, lalu coba buka /dashboard lagi. Kamu harus kembali diarahkan ke halaman login.

Kesimpulan
Pada artikel belajar Python Part 18 ini, kita telah mempelajari cara membuat sistem autentikasi user menggunakan Flask-Login. Mulai dari membuat model User dengan password yang di-hash, menyiapkan form registrasi dan login, mengelola session pengguna, hingga membatasi akses halaman menggunakan decorator @login_required.
Dengan sistem autentikasi ini, aplikasi Flask dapat mengenali pengguna yang sedang login sekaligus melindungi halaman agar tidak bisa diakses sembarang orang. Ke depannya, sistem ini juga dapat dikembangkan dengan fitur tambahan, seperti pengaturan role pengguna, verifikasi email, hingga login menggunakan akun sosial melalui OAuth.
Selanjutnya, pada Belajar Python Part 19, kita akan membahas cara membangun REST API menggunakan Flask dan mengamankannya dengan autentikasi berbasis token (JWT). Sampai jumpa di seri berikutnya!


