Django REST Framework – tworzenie API

Instalacja i konfiguracja Django REST Framework

Zacznij od instalacji pakietu:

Bash
Kopiuj
1
pip install djangorestframework

Następnie dodaj rest_framework do sekcji INSTALLED_APPS w pliku settings.py:

Python
Kopiuj
1
2
3
4
5
6
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'rest_framework',
    'app',
]

Możesz też skonfigurować podstawowe ustawienia DRF:

Python
Kopiuj
1
2
3
4
5
6
7
8
REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticatedOrReadOnly'
    ],
    'DEFAULT_RENDERER_CLASSES': [
        'rest_framework.renderers.JSONRenderer',
    ]
}

Serializatory – przekształcanie danych w JSON

Serializatory to serce DRF. To one decydują, jak Twoje dane są konwertowane z modeli Django do formatu JSON (lub odwrotnie). Serializator działa podobnie jak formularze Django – waliduje dane i definiuje, które pola są dostępne w API.

Przykład prostego serializatora

Python
Kopiuj
1
2
3
4
5
6
7
from rest_framework import serializers
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article
        fields = ['id', 'title', 'content', 'created_at']

ModelSerializer automatycznie generuje pola na podstawie modelu Django, co znacznie upraszcza tworzenie serializatorów. Możesz również zdefiniować własne pola lub nadpisać automatycznie wygenerowane pola, dodając dodatkową logikę walidacji czy przekształcania danych.

Widoki i logika API

Widoki DRF pozwalają zdefiniować, jak API reaguje na różne żądania HTTP (GET, POST, PUT, DELETE). Najprostszy sposób to użycie klas opartych na widokach:

Python
Kopiuj
1
2
3
4
5
6
7
from rest_framework import generics
from .models import Article
from .serializers import ArticleSerializer

class ArticleListCreateView(generics.ListCreateAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

Ten widok obsługuje:

• GET /articles/ → zwraca listę artykułów
• POST /articles/ → tworzy nowy artykuł

DRF automatycznie mapuje te akcje do metod HTTP. ListCreateAPIView łączy funkcjonalność listowania i tworzenia w jednej klasie. Inne przydatne widoki to RetrieveUpdateDestroyAPIView (dla operacji CRUD na pojedynczym obiekcie) czy ListAPIView (tylko do odczytu).

Routing – mapowanie endpointów

Aby Twój widok działał, musisz zarejestrować go w pliku urls.py:

Python
Kopiuj
1
2
3
4
5
6
from django.urls import path
from .views import ArticleListCreateView

urlpatterns = [
    path('articles/', ArticleListCreateView.as_view(), name='articles'),
]

W przypadku większych projektów możesz użyć routerów, które automatycznie generują pełny zestaw ścieżek dla widoków opartych na ViewSet:

Python
Kopiuj
1
2
3
4
5
6
7
from rest_framework.routers import DefaultRouter
from .views import ArticleViewSet

router = DefaultRouter()
router.register(r'articles', ArticleViewSet, basename='article')

urlpatterns = router.urls

Routery automatycznie generują ścieżki i metody dla CRUD (Create, Read, Update, Delete), co znacznie zmniejsza ilość kodu potrzebnego do utworzenia pełnego API.

Autoryzacja i uwierzytelnianie

DRF oferuje gotowe mechanizmy do zabezpieczenia API:

• Token Authentication
• Session Authentication
• JWT (JSON Web Tokens)
• OAuth2 (np. z biblioteką django-oauth-toolkit)

Przykład prostej autoryzacji tokenem JWT

Zainstaluj bibliotekę:

Bash
Kopiuj
1
pip install djangorestframework-simplejwt

W settings.py:

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

Teraz możesz generować i weryfikować tokeny JWT. Każde żądanie z tokenem w nagłówku Authorization: Bearer <token> będzie autoryzowane. JWT to nowoczesny standard autoryzacji, który pozwala na bezpieczne przekazywanie informacji o użytkowniku bez konieczności przechowywania sesji na serwerze.

Automatyczna dokumentacja (Swagger / OpenAPI)

Django REST Framework pozwala automatycznie wygenerować dokumentację Twojego API. Zainstaluj pakiet:

Bash
Kopiuj
1
pip install drf-yasg

Dodaj konfigurację w urls.py:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
from rest_framework import permissions
from drf_yasg.views import get_schema_view
from drf_yasg import openapi

schema_view = get_schema_view(
    openapi.Info(
        title="Blog API",
        default_version='v1',
        description="Dokumentacja API bloga",
    ),
    public=True,
    permission_classes=(permissions.AllowAny,),
)

Następnie dodaj ścieżkę do dokumentacji:

Python
Kopiuj
1
2
3
urlpatterns += [
    path('swagger/', schema_view.with_ui('swagger', cache_timeout=0), name='schema-swagger-ui'),
]

Teraz masz interaktywną dokumentację dostępną pod adresem /swagger/. Dokumentacja jest automatycznie generowana na podstawie serializerów, widoków i routingu, więc zawsze pozostaje aktualna wraz ze zmianami w kodzie.

Najczęstsze problemy i dobre praktyki

Przy pracy z Django REST Framework warto pamiętać o kilku kluczowych zasadach:

1. Walidacja danych – zawsze używaj serializer.is_valid() przed zapisaniem obiektu. DRF automatycznie waliduje dane zgodnie z definicją serializatora, ale warto obsługiwać błędy walidacji w odpowiedni sposób.

2. Paginate wyniki – duże listy spowalniają API. Używaj PageNumberPagination lub LimitOffsetPagination, aby ograniczyć liczbę zwracanych wyników:

Python
Kopiuj
1
2
3
4
REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 20
}

3. Stosuj widoki klasowe zamiast funkcji – są bardziej rozszerzalne i oferują więcej możliwości konfiguracji. Widoki klasowe w DRF są zbudowane w taki sposób, aby maksymalnie uprościć tworzenie API.

4. Ogranicz dostęp – używaj permissions i throttling, aby kontrolować, kto ma dostęp do API i jak często może z niego korzystać. DRF oferuje wiele gotowych klas uprawnień, takich jak IsAuthenticated, IsAdminUser czy AllowAny.

5. Testuj API – DRF ma wbudowany APITestCase do testów integracyjnych, który znacznie upraszcza testowanie endpointów API:

Python
Kopiuj
1
2
3
4
5
6
from rest_framework.test import APITestCase

class ArticleAPITestCase(APITestCase):
    def test_list_articles(self):
        response = self.client.get('/articles/')
        self.assertEqual(response.status_code, 200)

Przykład pełnego endpointu

Oto przykład kompletnego endpointu do obsługi artykułów:

serializers.py

Python
Kopiuj
1
2
3
4
5
6
7
from rest_framework import serializers
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article
        fields = '__all__'

views.py

Python
Kopiuj
1
2
3
4
5
6
7
from rest_framework import viewsets
from .models import Article
from .serializers import ArticleSerializer

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

urls.py

Python
Kopiuj
1
2
3
4
5
6
7
from rest_framework.routers import DefaultRouter
from .views import ArticleViewSet

router = DefaultRouter()
router.register('articles', ArticleViewSet)

urlpatterns = router.urls

Efekt:

• GET /articles/ → lista artykułów
• POST /articles/ → tworzy artykuł
• GET /articles/1/ → szczegóły artykułu
• PUT /articles/1/ → edycja artykułu
• DELETE /articles/1/ → usunięcie artykułu

ModelViewSet automatycznie implementuje wszystkie standardowe operacje CRUD, co pozwala na stworzenie pełnofunkcjonalnego API w zaledwie kilku linijkach kodu.

Podsumowanie

Django REST Framework to najbardziej kompletne rozwiązanie do tworzenia API w Pythonie. Daje pełną kontrolę nad strukturą, autoryzacją i wydajnością, a jednocześnie pozwala szybko tworzyć prototypy. Jeśli chcesz budować nowoczesne backendy, DRF to standard de facto w świecie Django. Dzięki serializatorom, widokom klasowym, routerom i automatycznej dokumentacji, tworzenie profesjonalnych API staje się szybkie i przyjemne, a jednocześnie zachowujesz pełną kontrolę nad każdym aspektem działania API.