Risoluzione degli errori di accesso al sottodominio Django-Tenant con i token Rest Framework

Gestione dei problemi di accesso al sottodominio nei tenant Django con query di schema ottimizzate

Soluzione backend che utilizza Django ORM con selezione esplicita dello schema e gestione degli errori.

# Import necessary libraries
from django.db import connection
from rest_framework.authtoken.models import Token
from django.contrib.auth import authenticate, login
from django.http import JsonResponse
from django_tenants.utils import schema_context
from django.views.decorators.csrf import csrf_exempt
@csrf_exempt
def dual_login_view(request):
    """Handle login for multi-tenant subdomains with correct schema."""
    if request.method == "POST":
        username = request.POST.get("login")
        password = request.POST.get("password")
        tenant_schema_name = connection.tenant.schema_name
        try:
            # Switch to the correct tenant schema
            with schema_context(tenant_schema_name):
                user = authenticate(request, username=username, password=password)
                if user is not None:
                    login(request, user)
                    # Generate or retrieve token
                    token, created = Token.objects.get_or_create(user=user)
                    return JsonResponse({"status": "success", "token": token.key})
                else:
                    return JsonResponse({"status": "error", "message": "Invalid credentials"}, status=400)
        except Exception as e:
            return JsonResponse({"status": "error", "message": str(e)}, status=500)
    return JsonResponse({"status": "error", "message": "Invalid request method"}, status=405)

Gestione esplicita dei token utilizzando schemi tenant-aware

Una vista API Django modularizzata e riutilizzabile per l'accesso in un'architettura multi-tenant.

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django.contrib.auth import authenticate
from rest_framework.authtoken.models import Token
from django_tenants.utils import schema_context
class TenantAwareLoginAPIView(APIView):
    """Login endpoint that ensures tenant-aware schema handling."""
    def post(self, request):
        username = request.data.get("username")
        password = request.data.get("password")
        tenant_schema_name = request.tenant.schema_name
        if not username or not password:
            return Response({"error": "Username and password required"}, status=status.HTTP_400_BAD_REQUEST)
        try:
            with schema_context(tenant_schema_name):
                user = authenticate(request, username=username, password=password)
                if user is None:
                    return Response({"error": "Invalid credentials"}, status=status.HTTP_401_UNAUTHORIZED)
                # Generate or retrieve token for the user
                token, created = Token.objects.get_or_create(user=user)
                return Response({"token": f"Token {token.key}"}, status=status.HTTP_200_OK)
        except Exception as e:
            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

Script frontend per la gestione delle richieste di accesso al sottodominio

Soluzione JavaScript per gestire l'invio di moduli ed elaborare l'accesso basato su token per i sottodomini del tenant.

<script>
document.querySelector('form').addEventListener('submit', function(event) {
    event.preventDefault();
    let form = event.target;
    let formData = new FormData(form);
    fetch("{% url 'tenant_aware_login' %}", {
        method: 'POST',
        body: JSON.stringify(Object.fromEntries(formData)),
        headers: {
            'Content-Type': 'application/json',
            'X-CSRFToken': formData.get('csrfmiddlewaretoken')
        }
    })
    .then(response => {
        if (!response.ok) throw new Error('Server Error');
        return response.json();
    })
    .then(data => {
        if (data.token) {
            localStorage.setItem('token', data.token);
            window.location.href = '/';
        } else {
            Swal.fire({
                icon: 'error',
                title: 'Login Failed',
                text: data.error || 'Invalid credentials'
            });
        }
    })
    .catch(error => {
        console.error('Error:', error);
    });
});
</script>

Test unitario per verificare l'autenticazione del token compatibile con lo schema

Test unitario in Python per garantire che l'API gestisca correttamente il cambio di schema.

from django.test import TestCase
from rest_framework.test import APIClient
from django_tenants.utils import schema_context
from django.contrib.auth.models import User
from rest_framework.authtoken.models import Token
class TenantLoginTest(TestCase):
    def setUp(self):
        self.client = APIClient()
        with schema_context('test_tenant'):  # Switch to tenant schema
            self.user = User.objects.create_user(username='testuser', password='testpass')
    def test_successful_login(self):
        with schema_context('test_tenant'):
            response = self.client.post('/api/login/', {
                'username': 'testuser',
                'password': 'testpass'
            })
            self.assertEqual(response.status_code, 200)
            self.assertIn('token', response.json())
    def test_invalid_login(self):
        with schema_context('test_tenant'):
            response = self.client.post('/api/login/', {
                'username': 'wronguser',
                'password': 'wrongpass'
            })
            self.assertEqual(response.status_code, 401)
            self.assertIn('error', response.json())

Domande comuni sui problemi di accesso Django multi-tenant

1. Cosa provoca a 500 Errore interno del server durante l'accesso?
2. L'errore si verifica perché Token.objects.get_or_create() interroga lo schema sbagliato, causando una mancata corrispondenza durante la ricerca dei record utente.
3. Come posso garantire che le query sui token puntino allo schema tenant corretto?
4. Utilizzo schema_context() dal inquilini django libreria per eseguire il wrapper dell'esecuzione della query e passare allo schema corretto.
5. Perché l'accesso dal pannello di amministrazione funziona ma l'accesso dell'utente non riesce?
6. L'amministratore di Django regola automaticamente i contesti dello schema, ma utilizza visualizzazioni personalizzate authenticate() O Token.objects potrebbe non essere possibile a meno che non sia esplicitamente configurato.
7. Come posso recuperare e archiviare un token di accesso sul frontend?
8. Utilizza l'API di recupero per inviare le credenziali, quindi archivia il token di risposta utilizzando localStorage.setItem() per l'autenticazione persistente.
9. Come posso visualizzare messaggi di errore migliori per gli accessi non riusciti?
10. Implementa avvisi frontend utilizzando librerie come SweetAlert2 per avvisare gli utenti di credenziali errate o problemi del server.

Garantire un accesso agevole tra i sottodomini del tenant

Per risolvere gli errori di accesso nelle app multi-tenant Django è necessario garantire che tutte le query del database funzionino nello schema corretto. Utilizzando in modo esplicito strumenti come il contesto dello schema, possiamo garantire che i token utente vengano recuperati dal database del tenant corretto, evitando conflitti di schema.

Immagina di lavorare su una piattaforma SaaS in cui gli utenti affrontano errori di accesso solo sui sottodomini. Con un corretto cambio di schema, questi problemi vengono risolti, garantendo un'autenticazione senza interruzioni. L'adozione di questa soluzione non solo migliora esperienza dell'utente ma garantisce anche un accesso sicuro ed efficiente ai dati per ciascun tenant. 🔧