Création d'un système d'authentification sécurisé pour CollabSphere, partie A, plate-forme de communication en temps réel

La création d'un système d'authentification sécurisé et évolutif est cruciale pour toute plate-forme de communication en temps réel dans le paysage numérique actuel. Dans cet article, je vais vous expliquer comment j'ai construit le système d'authentification pour CollabSphere, une plateforme de collaboration moderne en temps réel, à l'aide de Django et Django REST Framework.

Présentation du système

Le système d'authentification de CollabSphere est conçu en tenant compte des exigences clés suivantes :

• Authentification par e-mail
• Contrôle d'accès basé sur les rôles
• Suivi du statut des utilisateurs en temps réel
• Support multi-appareils
• Gestion sécurisée des mots de passe
• Vérification de l'e-mail

Composants de base

Modèle utilisateur personnalisé
Au cœur de ce système se trouve un modèle utilisateur personnalisé qui étend AbstractBaseUser de Django :

class CustomUser(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField(unique=True)
    username = models.CharField(max_length=50, unique=True)
    full_name = models.CharField(max_length=255)

    # Profile fields
    avatar = models.ImageField(upload_to='avatars/', null=True)
    bio = models.TextField(max_length=500, blank=True)

    # Status tracking
    is_online = models.BooleanField(default=False)
    last_seen = models.DateTimeField(null=True)
    #...

Contrôle d'accès basé sur les rôles
J'ai mis en place un système de rôles flexible pour gérer les autorisations des utilisateurs :

class Role(models.Model):
    name = models.CharField(max_length=50, unique=True)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    priority = models.IntegerField(default=0)  
    custom_permissions = models.JSONField(default=dict) 

    # Define permissions for each role
    can_moderate = models.BooleanField(default=False)
    can_manage_users = models.BooleanField(default=False)
    can_manage_roles = models.BooleanField(default=False)
    can_delete_messages = models.BooleanField(default=False)
    can_ban_users = models.BooleanField(default=False)

    class Meta:
        verbose_name = _('role')
        verbose_name_plural = _('roles')
        ordering = ['-priority'] 

    def __str__(self):
        return self.name

Flux d'authentification

Processus d'inscription

Client -> RegisterView -> UserRegistrationSerializer -> CustomUserManager.create_user() -> Database
                      -> Send verification email
                      -> Assign default role
                      -> Generate JWT tokens

Lorsqu'un nouvel utilisateur s'inscrit :

1. L'utilisateur soumet son e-mail, son nom d'utilisateur et son mot de passe
2. Le système valide les données
3. Crée un compte utilisateur
4. Envoie un e-mail de vérification
5. Attribuer un rôle par défaut
6. Renvoie les jetons JWT

Exemple de point de terminaison d'enregistrement :

class RegisterView(generics.CreateAPIView):
    def create(self, request):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        user = serializer.save()

        # Send verification email
        user.send_verification_email()

        # Generate tokens
        refresh = RefreshToken.for_user(user)
        return Response({
            'user': UserSerializer(user).data,
            'tokens': {
                'refresh': str(refresh),
                'access': str(refresh.access_token),
            }
        })

Processus de connexion

Client -> LoginView -> UserLoginSerializer -> authenticate() -> JWT tokens
                   -> Update online status
                   -> Store device tokens
                   -> Return user permissions

Le flux de connexion comprend :

1. Validation email et mot de passe
2. Contrôle de vérification
3. Mise à jour du statut en ligne
4. Gestion des jetons d'appareil
5. Génération de jetons JWT

Gestion du statut en temps réel

Le système suit le statut des utilisateurs en temps réel :

def update_online_status(self, status):
    self.is_online = status
    self.last_seen = timezone.now()
    self.save(update_fields=['is_online', 'last_seen'])

Fonctionnalités de sécurité

Sécurité par mot de passe

• Validation du mot de passe personnalisé
• Hachage sécurisé du mot de passe
• Vérification du changement de mot de passe

Vérification par e-mail

def send_verification_email(self):
    token = self.generate_verification_token()
    verification_url = f"{settings.FRONTEND_URL}/verify-email/{token}"

    send_mail(
        'Verify your email address',
        render_to_string('users/verify_email.html', {
            'user': self,
            'verification_url': verification_url
        }),
        settings.DEFAULT_FROM_EMAIL,
        [self.email]
    )

Authentification JWT

Le système utilise des jetons JWT pour un accès sécurisé à l'API :

refresh = RefreshToken.for_user(user)
return {
    'refresh': str(refresh),
    'access': str(refresh.access_token)
}

Prise en charge de plusieurs appareils

Le système prend en charge plusieurs appareils par utilisateur :

device_tokens = models.JSONField(default=dict)

Cela permet :

• Notifications push spécifiques à l'appareil
• Gestion des sessions
• Suivi du dernier appareil actif

Meilleures pratiques mises en œuvre

Séparation des préoccupations

• Modèles pour la structure des données
• Sérialiseurs pour validation
• Vues pour la logique métier

Mesures de sécurité

• Vérification de l'e-mail
• Authentification basée sur des jetons
• Validation du mot de passe
• Contrôle d'accès basé sur les rôles

Optimisation des performances

• Requêtes de base de données efficaces
• Mises à jour sélectives des champs
• Une bonne indexation

Tester le système

Voici comment tester le flux d'authentification :

class CustomUser(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField(unique=True)
    username = models.CharField(max_length=50, unique=True)
    full_name = models.CharField(max_length=255)

    # Profile fields
    avatar = models.ImageField(upload_to='avatars/', null=True)
    bio = models.TextField(max_length=500, blank=True)

    # Status tracking
    is_online = models.BooleanField(default=False)
    last_seen = models.DateTimeField(null=True)
    #...

Conclusion

La création d'un système d'authentification sécurisé nécessite une planification et une mise en œuvre minutieuses. En suivant les meilleures pratiques de Django et en mettant en œuvre des mesures de sécurité appropriées, nous avons créé un système robuste pour CollabSphere qui gère efficacement l'authentification des utilisateurs, l'autorisation et la gestion du statut en temps réel.

Le code complet de cette implémentation est disponible sur le référentiel GitHub.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!