Autoryzacja i użytkownicy w Django

Model użytkownika w Django

Django dostarcza gotowy model User, który znajdziesz w django.contrib.auth.models. Najważniejsze pola to:

• username — unikalna nazwa użytkownika
• email — adres e-mail użytkownika
• first_name, last_name — imię i nazwisko
• is_staff, is_superuser, is_active — flagi statusu użytkownika
• date_joined, last_login — daty rejestracji i ostatniego logowania

Przykład dostępu do modelu:

Python
Kopiuj
1
2
3
4
from django.contrib.auth.models import User

users = User.objects.all()
print(users[0].username)

Tworzenie niestandardowego modelu użytkownika

Jeśli potrzebujesz niestandardowych pól (np. phone_number), możesz stworzyć własny model użytkownika:

Python
Kopiuj
1
2
3
4
5
from django.contrib.auth.models import AbstractUser
from django.db import models

class CustomUser(AbstractUser):
phone_number = models.CharField(max_length=15, blank=True, null=True)

W settings.py:

Python
Kopiuj
1
AUTH_USER_MODEL = 'app.CustomUser'

To jedna z najważniejszych decyzji w projekcie — jeśli chcesz mieć customowy model, zrób to na początku projektu, przed wykonaniem pierwszej migracji. Zmiana AUTH_USER_MODEL po rozpoczęciu projektu może być bardzo skomplikowana.

Logowanie i wylogowanie użytkownika

Django ma gotowe widoki do logowania i wylogowania. Możesz z nich korzystać bez pisania dodatkowego kodu.

W urls.py:

Python
Kopiuj
1
2
3
4
5
6
7
from django.contrib.auth import views as auth_views
from django.urls import path

urlpatterns = [
path('login/', auth_views.LoginView.as_view(template_name='login.html'), name='login'),
path('logout/', auth_views.LogoutView.as_view(), name='logout'),
]

W settings.py możesz ustawić przekierowania po zalogowaniu/wylogowaniu:

Python
Kopiuj
1
2
LOGIN_REDIRECT_URL = '/'
LOGOUT_REDIRECT_URL = '/'

Dodatkowo możesz skonfigurować URL logowania, który będzie używany, gdy użytkownik próbuje uzyskać dostęp do chronionej strony bez zalogowania:

Python
Kopiuj
1
LOGIN_URL = '/login/'

Rejestracja użytkowników

Django nie dostarcza gotowego widoku rejestracji, ale możesz go dodać w kilku linijkach:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
from django.contrib.auth.forms import UserCreationForm
from django.shortcuts import render, redirect

def register(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
return redirect('login')
else:
form = UserCreationForm()
return render(request, 'register.html', {'form': form})

Formularz UserCreationForm automatycznie obsługuje walidację hasła (sprawdza, czy hasło jest wystarczająco silne i czy oba pola hasła się zgadzają). Możesz również rozszerzyć ten formularz o dodatkowe pola, dziedzicząc po UserCreationForm i dodając własne pola.

Uprawnienia i role

Każdy użytkownik ma zestaw uprawnień (permissions) i grup (groups), które definiują jego dostęp do zasobów. Django automatycznie tworzy uprawnienia dla każdego modelu: add_<model>, change_<model>, delete_<model> i view_<model>.

Przypisywanie uprawnień użytkownikowi

Przykład przypisania uprawnienia bezpośrednio do użytkownika:

Python
Kopiuj
1
2
3
4
5
6
from django.contrib.auth.models import Permission, User

user = User.objects.get(username='kacper')
permission = Permission.objects.get(codename='change_article')

user.user_permissions.add(permission)

Zarządzanie uprawnieniami przez grupy

Uprawnienia można też przypisywać przez grupy, co jest bardziej efektywne przy zarządzaniu większą liczbą użytkowników:

Python
Kopiuj
1
2
3
4
5
6
from django.contrib.auth.models import Group

editors = Group.objects.create(name='Editors')
editors.permissions.add(permission)

user.groups.add(editors)

Dzięki temu możesz tworzyć całe role użytkowników, np. Administrator, Redaktor, Klient. Każdy użytkownik dziedziczy uprawnienia z grup, do których należy.

Dekoratory i kontrola dostępu

Django pozwala w prosty sposób zabezpieczać widoki przed nieautoryzowanym dostępem.

Dekorator dla widoków funkcyjnych

Przykład dla funkcji:

Python
Kopiuj
1
2
3
4
5
from django.contrib.auth.decorators import login_required

@login_required
def dashboard(request):
return render(request, 'dashboard.html')

Dekorator @login_required przekieruje nieautoryzowanych użytkowników do strony logowania (zdefiniowanej w LOGIN_URL).

Mixiny dla widoków klasowych

Przykład dla widoków klasowych:

Python
Kopiuj
1
2
3
4
5
from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import TemplateView

class DashboardView(LoginRequiredMixin, TemplateView):
template_name = 'dashboard.html'

Możesz też użyć PermissionRequiredMixin, jeśli chcesz wymagać konkretnych uprawnień:

Python
Kopiuj
1
2
3
4
5
from django.contrib.auth.mixins import PermissionRequiredMixin

class EditArticleView(PermissionRequiredMixin, TemplateView):
permission_required = 'app.change_article'
template_name = 'edit_article.html'

JWT – nowoczesna autoryzacja tokenowa

Dla API najlepszym rozwiązaniem jest autoryzacja tokenami JWT (JSON Web Token). JWT to standardowy format tokenów, który pozwala na bezpieczne przekazywanie informacji między stronami bez konieczności przechowywania sesji na serwerze.

Instalacja i konfiguracja

Zainstaluj pakiet:

Bash
Kopiuj
1
pip install djangorestframework-simplejwt

W settings.py dodaj:

Python
Kopiuj
1
2
3
4
5
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': [
'rest_framework_simplejwt.authentication.JWTAuthentication',
]
}

Możesz również skonfigurować czas wygaśnięcia tokenów:

Python
Kopiuj
1
2
3
4
5
6
from datetime import timedelta

SIMPLE_JWT = {
'ACCESS_TOKEN_LIFETIME': timedelta(minutes=60),
'REFRESH_TOKEN_LIFETIME': timedelta(days=1),
}

Konfiguracja endpointów tokenów

W urls.py:

Python
Kopiuj
1
2
3
4
5
6
from rest_framework_simplejwt.views import TokenObtainPairView, TokenRefreshView

urlpatterns = [
path('api/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
path('api/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
]

Teraz możesz uzyskać token przez POST /api/token/ (wysyłając username i password) i autoryzować zapytania przez nagłówek:

Authorization: Bearer <token>

Token refresh pozwala na odświeżenie wygasłego tokena dostępu bez konieczności ponownego logowania.

Logowanie przez OAuth2 i social media

Django integruje się z zewnętrznymi usługami logowania (Google, GitHub, Facebook) za pomocą bibliotek takich jak django-allauth. To rozwiązanie pozwala użytkownikom logować się przez konta społecznościowe, co zwiększa wygodę użytkowania i zmniejsza liczbę zapomnianych haseł.

Instalacja django-allauth

Bash
Kopiuj
1
pip install django-allauth

Dodaj w settings.py:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
INSTALLED_APPS = [
'django.contrib.sites',
'allauth',
'allauth.account',
'allauth.socialaccount',
'allauth.socialaccount.providers.google',
# Możesz dodać więcej providerów: 'allauth.socialaccount.providers.github',
# 'allauth.socialaccount.providers.facebook', itd.
]

AUTHENTICATION_BACKENDS = [
'django.contrib.auth.backends.ModelBackend',
'allauth.account.auth_backends.AuthenticationBackend',
]

SITE_ID = 1

W urls.py:

Python
Kopiuj
1
2
3
urlpatterns += [
path('accounts/', include('allauth.urls')),
]

Dzięki django-allauth możesz w kilka minut dodać logowanie przez konta społecznościowe z obsługą e-maila, resetu hasła i weryfikacji konta. Biblioteka obsługuje wiele providerów OAuth2, w tym Google, GitHub, Facebook, Twitter, LinkedIn i wiele innych.

Custom Permissions – własne reguły dostępu

Django pozwala zdefiniować własne uprawnienia na poziomie modelu. To szczególnie przydatne, gdy potrzebujesz specyficznych uprawnień, które nie pasują do standardowych operacji CRUD.

Przykład definicji własnego uprawnienia:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
class Article(models.Model):
title = models.CharField(max_length=200)
content = models.TextField()
published = models.BooleanField(default=False)

class Meta:
permissions = [
("can_publish", "Can publish article"),
("can_moderate", "Can moderate comments"),
]

Teraz możesz używać tego uprawnienia w widoku:

Python
Kopiuj
1
2
3
4
5
6
from django.contrib.auth.decorators import permission_required

@permission_required('app.can_publish', raise_exception=True)
def publish_article(request):
# Logika publikacji artykułu
...

Alternatywnie, możesz użyć mixina w widoku klasowym:

Python
Kopiuj
1
2
3
4
5
from django.contrib.auth.mixins import PermissionRequiredMixin

class PublishArticleView(PermissionRequiredMixin, View):
permission_required = 'app.can_publish'
# Implementacja widoku

Po wykonaniu migracji (python manage.py migrate), Django automatycznie utworzy te uprawnienia w bazie danych, a następnie możesz je przypisywać do użytkowników i grup tak samo jak standardowe uprawnienia.

Podsumowanie

System autoryzacji w Django to kompletne, elastyczne i bezpieczne rozwiązanie, które sprawdza się zarówno w prostych blogach, jak i dużych aplikacjach SaaS. Zawiera gotowy model użytkownika, wbudowane logowanie, wylogowanie i rejestrację, zarządzanie grupami i uprawnieniami oraz wsparcie dla tokenów JWT i OAuth2. Jeśli dopiero zaczynasz budować aplikację z użytkownikami — nie musisz tworzyć nic od zera. Django daje Ci wszystko, czego potrzebujesz do zarządzania użytkownikami i zabezpieczenia aplikacji. Elastyczność systemu pozwala na łatwe dostosowanie go do konkretnych potrzeb projektu, a jednocześnie bezpieczeństwo jest zapewnione przez sprawdzone mechanizmy uwierzytelniania i autoryzacji.