Python Django Autentimine: Kohandatud Kasutajamudelite Valdamine Globaalseteks Rakendusteks

Django sisseehitatud autentimissüsteem on paljude veebirakenduste jaoks võimas alguspunkt. Kuid kui teie rakendus skaleerub ja muutub keerukamaks, eriti globaalsele publikule suunates, ei pruugi vaikimisi kasutajamudel olla piisav. Siin tulevad mängu kohandatud kasutajamudelid, pakkudes suuremat paindlikkust ja kontrolli kasutajaandmete ja autentimisprotsesside üle. See põhjalik juhend tutvustab teile Djangos kohandatud kasutajamudelite loomist ja juurutamist, tagades, et teie rakendus on hästi varustatud mitmekesiste kasutajanõuete ja turvalisuskaalutlustega toimetulekuks.

Miks kasutada kohandatud kasutajamudelit?

Django vaikimisi kasutajamudel on loodud tavaliste atribuutidega nagu kasutajanimi, parool, e-post, eesnimi ja perekonnanimi. Kuigi see sobib lihtsate rakenduste jaoks, jääb sellest sageli puudu, kui teil on vaja:

• Salvestada täiendavat kasutajateavet: Kujutage ette globaalset e-kaubanduse platvormi, mis peab salvestama kasutaja eelistusi, aadresse erinevates vormingutes, eelistatud valuutasid või keele seadeid. Need on vaikimisi mudeli ulatusest väljas.
• Muuta autentimisvälja: Võib-olla soovite autentida kasutajaid nende e-posti aadressi, mitte kasutajanime kaudu, või juurutada mitmefaktorilise autentimise, mis nõuab lisavälju.
• Integreerida olemasolevate andmebaasidega: Kui integreerite Django rakenduse olemasoleva andmebaasiga, millel on erinev kasutajaskeem, võimaldab kohandatud kasutajamudel teil oma mudelit olemasoleva andmestruktuuriga vastendada.
• Suurendada turvalisust: Kohandatud mudelid võimaldavad suuremat kontrolli parooli krüpteerimise, parooli lähtestamise mehhanismide ja muude turvalisusega seotud aspektide üle.
• Juurutada erinevaid kasutajarolle: Rollipõhise juurdepääsukontrolli (RBAC) andmete otsene salvestamine mudelisse (või sellele viitamine) pakub paindlikumat ja selgemat kontrolli kui üldised grupid ja õigused.

Kohandatud kasutajamudeli kasutamine pakub puhast ja hooldatavat viisi kasutajaprofiili laiendamiseks, muutmata otse Django põhiautentimissüsteemi. See on parim tava igas projektis, mis prognoosib tulevast kasvu või nõuab spetsialiseeritud kasutajaandmeid.

Millal juurutada kohandatud kasutajamudel?

Parim aeg kohandatud kasutajamudeli juurutamiseks on teie projekti alguses. Kasutajamudeli muutmine tootmiskeskkonnas võib olla keeruline ja potentsiaalselt andmeid kahjustav. Kui teie projekt on juba käimas, kaaluge hoolikalt tagajärgi ja looge enne muudatuste tegemist tugev migratsiooniplaan.

Siin on üldine juhis:

• Alustage kohandatud kasutajamudeliga: Kui näete ette vajadust laiendatud kasutajateabe või kohandatud autentimisloogika järele.
• Kaaluge migratsiooni hoolikalt: Kui teil on juba töötav Django projekt kasutajatega ja otsustate üle minna kohandatud mudelile. Varundage oma andmebaas ja mõistke migratsiooniprotsessi põhjalikult.

Kohandatud Kasutajamudeli Loomine

Djangos kohandatud kasutajamudeli loomiseks on kaks peamist lähenemist:

1. AbstractBaseUser: See lähenemine annab teile täieliku kontrolli kasutajamudeli üle. Te määratlete kõik väljad, sealhulgas kasutajanime, parooli, e-posti ja kõik vajalikud kohandatud väljad.
2. AbstractUser: See lähenemine pärib vaikimisi Django kasutajamudelilt ja võimaldab teil lisada või üle kirjutada olemasolevaid välju. See on lihtsam, kui teil on vaja lisada vaid mõned lisaväljad.

1. AbstractBaseUseri kasutamine (täielik kontroll)

See on kõige paindlikum valik, mis võimaldab teil kogu kasutajamudeli nullist määratleda. See pakub suurimat kontrolli kasutajaandmete struktuuri ja autentimisprotsessi üle. Siin on, kuidas:

Samm 1: Looge kohandatud kasutajamudel

Oma Django rakenduses (nt 'accounts') looge fail `models.py` ja määratlege oma kohandatud kasutajamudel, mis pärib `AbstractBaseUser` ja `PermissionsMixin` klassidelt:

            from django.db import models
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager

class CustomUserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError('The Email field must be set')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)
        extra_fields.setdefault('is_active', True)

        if extra_fields.get('is_staff') is not True:
            raise ValueError('Superuser must have is_staff=True.')
        if extra_fields.get('is_superuser') is not True:
            raise ValueError('Superuser must have is_superuser=True.')

        return self.create_user(email, password, **extra_fields)

class CustomUser(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField(unique=True, verbose_name='email address')
    first_name = models.CharField(max_length=150, blank=True)
    last_name = models.CharField(max_length=150, blank=True)
    is_staff = models.BooleanField(default=False)
    is_active = models.BooleanField(default=True)
    date_joined = models.DateTimeField(auto_now_add=True)

    # Custom fields (Example: preferred language, timezone, etc.)
    preferred_language = models.CharField(max_length=10, default='en', choices=[('en', 'English'), ('fr', 'French'), ('es', 'Spanish')])
    timezone = models.CharField(max_length=50, default='UTC')

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = [] # Required when creating a superuser

    objects = CustomUserManager()

    def __str__(self):
        return self.email

            

              
                Copy
              
            
          

Selgitus:

• CustomUserManager: See klass on vajalik teie kohandatud kasutajamudeli haldamiseks. See tegeleb kasutajate ja superkasutajate loomisega. `normalize_email` on oluline e-posti konsistentsuse tagamiseks erinevate lokaatide ja sisestusmeetodite vahel.
• CustomUser: See on teie kohandatud kasutajamudel.
• `email = models.EmailField(unique=True, verbose_name='email address')`: Määratleb e-posti välja kui kasutaja unikaalse identifikaatori. `unique=True` tagab, et igal kasutajal on unikaalne e-posti aadress. Üksikasjalik nimi parandab administraatoriliidest.
• `first_name`, `last_name`: Standardsed väljad kasutaja nime salvestamiseks. `blank=True` võimaldab neid välju tühjana jätta.
• `is_staff`, `is_active`: Standardsed väljad kasutaja juurdepääsu kontrollimiseks administraatoripaneelile ja konto aktiveerimiseks.
• `date_joined`: Salvestab kuupäeva, mil kasutajakonto loodi.
• `preferred_language`, `timezone`: Näidiskohandatud väljad kasutaja eelistuste salvestamiseks. `choices` argument piirab võimalikke keelevõimalusi. See on globaalse rakenduse jaoks ülioluline. Ajavöönd on samuti oluline lokaliseerimiseks.
• `USERNAME_FIELD = 'email'`: Määrab, et e-posti välja kasutatakse autentimiseks kasutajanimeks.
• `REQUIRED_FIELDS = []`: Määratleb väljad, mis on nõutavad superkasutaja loomisel `createsuperuser` käsu abil. Sel juhul pole lisavälju peale e-posti ja parooli vaja.
• `objects = CustomUserManager()`: Määrab kohandatud kasutajahalduri mudelile.
• `__str__(self)`: Määratleb, kuidas kasutajaobjekt on esitatud stringina (nt administraatoripaneelis).

Samm 2: Uuendage `settings.py`

Andke Djangole teada oma kohandatud kasutajamudeli kasutamisest, lisades järgmise rea faili `settings.py`:

            AUTH_USER_MODEL = 'accounts.CustomUser'
            

              
                Copy
              
            
          

Asendage `accounts` oma rakenduse nimega, kus määratlesite `CustomUser` mudeli.

Samm 3: Looge ja rakendage migratsioonid

Käivitage järgmised käsud migratsioonide loomiseks ja rakendamiseks:

            python manage.py makemigrations
python manage.py migrate
            

              
                Copy
              
            
          

See loob teie kohandatud kasutajamudeli jaoks uue andmebaasitabeli.

Samm 4: Kohandatud kasutajamudeli kasutamine

Nüüd saate oma kohandatud kasutajamudelit kasutada oma vaadetes, mallides ja muudes rakenduse osades. Näiteks uue kasutaja loomiseks:

            from accounts.models import CustomUser

user = CustomUser.objects.create_user(email='user@example.com', password='password123', first_name='John', last_name='Doe')
            

              
                Copy
              
            
          

2. AbstractUseri kasutamine (vaikimisi mudelile lisamine)

See lähenemine on lihtsam, kui teil on vaja lisada vaikimisi Django kasutajamudelile vaid mõned lisaväljad. See pärib kõik olemasolevad väljad ja meetodid `AbstractUser` klassilt. See võib olla lihtsam lihtsamaks kohandamiseks.

Samm 1: Looge kohandatud kasutajamudel

Oma Django rakenduse failis `models.py` määratlege oma kohandatud kasutajamudel, mis pärib `AbstractUser` klassilt:

            from django.contrib.auth.models import AbstractUser
from django.db import models

class CustomUser(AbstractUser):
    # Add extra fields here
    phone_number = models.CharField(max_length=20, blank=True, verbose_name='Phone Number')
    profile_picture = models.ImageField(upload_to='profile_pictures/', blank=True)
    # Custom fields (Example: preferred currency, address format, etc.)
    preferred_currency = models.CharField(max_length=3, default='USD', choices=[('USD', 'US Dollar'), ('EUR', 'Euro'), ('JPY', 'Japanese Yen')])
    address_format = models.CharField(max_length=50, blank=True, help_text='e.g., "Name, Street, City, Zip, Country"')

    def __str__(self):
        return self.username

            

              
                Copy
              
            
          

Selgitus:

• CustomUser: See on teie kohandatud kasutajamudel, mis pärib `AbstractUser` klassilt.
• `phone_number`, `profile_picture`: Näidisväljad, mida kasutajamudelile lisada. `upload_to` määrab, kuhu profiilipildid salvestatakse.
• `preferred_currency`, `address_format`: Näidiskohandatud väljad, mis on olulised globaalsete rakenduste jaoks. Erinevates riikides on aadresse drastiliselt erinevas vormingus.
• `__str__(self)`: Määratleb, kuidas kasutajaobjekt on esitatud stringina (nt administraatoripaneelis). Siin kasutatakse kasutajanime.

Samm 2: Uuendage `settings.py`

Sarnaselt eelnevale, andke Djangole teada oma kohandatud kasutajamudeli kasutamisest, lisades järgmise rea faili `settings.py`:

            AUTH_USER_MODEL = 'accounts.CustomUser'
            

              
                Copy
              
            
          

Samm 3: Looge ja rakendage migratsioonid

Käivitage järgmised käsud migratsioonide loomiseks ja rakendamiseks:

            python manage.py makemigrations
python manage.py migrate
            

              
                Copy
              
            
          

Samm 4: Kohandatud kasutajamudeli kasutamine

Nüüd pääsete juurde lisatud väljadele, kui töötate kasutajaobjektidega:

            from accounts.models import CustomUser

user = CustomUser.objects.create_user(username='johndoe', password='password123', email='john.doe@example.com')
user.phone_number = '+15551234567'
user.preferred_currency = 'EUR'
user.save()
            

              
                Copy
              
            
          

Parimad tavad kohandatud kasutajamudelite loomiseks globaalsetes rakendustes

Kohandatud kasutajamudelite juurutamisel globaalsele publikule suunatud rakenduste jaoks arvestage järgmiste parimate tavadega:

1. Rahvusvahelistamine ja lokaliseerimine (i18n & l10n)

Salvestage lokaalipõhiseid andmeid: Kujundage oma mudel nii, et see arvestaks erinevate kultuurinormide ja andmevormingutega. Salvestage kuupäevad, kellaajad, numbrid ja aadressid lokaaditeadlikul viisil.

Näide:

            from django.utils import timezone

class CustomUser(AbstractUser):
    #...
    date_of_birth = models.DateField(blank=True, null=True)

    def get_localized_date_of_birth(self, language_code):
        if self.date_of_birth:
            return timezone.localtime(timezone.make_aware(datetime.datetime.combine(self.date_of_birth, datetime.time.min))).strftime('%x')  # Format according to the locale
        return None
            

              
                Copy
              
            
          

2. Ajavööndi käsitlemine

Salvestage ja käsitlege ajavööndeid alati õigesti. Salvestage ajavööndi teave kasutajamudelisse ja kasutage seda kuupäevade ja kellaaegade kuvamiseks kasutaja kohalikus ajavööndis.

Näide:

            from django.utils import timezone

class CustomUser(AbstractUser):
    #...
    timezone = models.CharField(max_length=50, default='UTC')

    def get_localized_time(self, datetime_obj):
        user_timezone = pytz.timezone(self.timezone)
        return timezone.localtime(datetime_obj, user_timezone)
            

              
                Copy
              
            
          

3. Aadressi vormindamine

Aadressivormingud varieeruvad riigiti oluliselt. Juurutage paindlik aadressisüsteem, mis võimaldab kasutajatel sisestada oma aadressi oma asukoha jaoks õiges vormingus. Kaaluge kolmanda osapoole teegi või teenuse kasutamist aadressi valideerimiseks ja vormindamiseks.

Näide:

            class CustomUser(AbstractUser):
    #...
    country = models.CharField(max_length=50, blank=True)
    address_line_1 = models.CharField(max_length=255, blank=True)
    address_line_2 = models.CharField(max_length=255, blank=True)
    city = models.CharField(max_length=100, blank=True)
    postal_code = models.CharField(max_length=20, blank=True)

    def get_formatted_address(self):
        # Implement logic to format address based on country
        if self.country == 'US':
            return f'{self.address_line_1}\n{self.address_line_2}\n{self.city}, {self.postal_code}, {self.country}'
        elif self.country == 'GB':
            return f'{self.address_line_1}\n{self.address_line_2}\n{self.city}\n{self.postal_code}\n{self.country}'
        else:
            return 'Address format not supported'

            

              
                Copy
              
            
          

4. Valuuta käsitlemine

Kui teie rakendus hõlmab finantstehinguid, salvestage kasutaja eelistatud valuuta ja kasutage seda hindade ja summade kuvamiseks. Kasutage teeki nagu `babel` valuutaväärtuste vormindamiseks vastavalt kasutaja lokaadile.

Näide:

            from babel.numbers import format_currency

class CustomUser(AbstractUser):
    #...
    preferred_currency = models.CharField(max_length=3, default='USD')

    def get_formatted_price(self, amount):
        return format_currency(amount, self.preferred_currency, locale='en_US')  # Adjust locale as needed
            

              
                Copy
              
            
          

5. Andmete valideerimine

Juurutage tugev andmete valideerimine tagamaks, et kasutaja sisestus on kehtiv ja järjepidev. Kasutage Django sisseehitatud valideerijaid või looge kohandatud valideerijaid andmete terviklikkuse tagamiseks.

Näide:

            from django.core.validators import RegexValidator

class CustomUser(AbstractUser):
    #...
    phone_number = models.CharField(
        max_length=20,
        blank=True,
        validators=[
            RegexValidator(
                regex=r'^\+?\d{9,15}$',
                message="Phone number must be entered in the format: '+999999999'. Up to 15 digits allowed."
            ),
        ]
    )
            

              
                Copy
              
            
          

6. Turvalisuskaalutlused

Parooli krüpteerimine: Django autentimissüsteem kasutab vaikimisi tugevaid parooli krüpteerimise algoritme. Veenduge, et kasutate Django uusimat versiooni, et saada kasu uusimatest turvavärskendustest.

Kahefaktoriline autentimine (2FA): Juurutage 2FA, et lisada kasutajakontodele täiendav turvakiht. Selleks on saadaval erinevad Django paketid, näiteks `django-otp`. See on eriti oluline tundlike kasutajaandmete või finantstehingute käsitlemisel.

Andmekaitse: Järgige andmekaitse ja privaatsuse parimaid tavasid, eriti tundliku kasutajateabega tegelemisel. Järgige asjakohaseid andmekaitseregulatsioone, nagu GDPR ja CCPA. Kaaluge andmete krüpteerimist, anonüümimist ja tokeniseerimistehnikaid.

7. Testimine

Kirjutage põhjalikud ühikutestid ja integratsioonitestid tagamaks, et teie kohandatud kasutajamudel töötab ootuspäraselt ja teie autentimissüsteem on turvaline. Testige erinevaid stsenaariume, sealhulgas kehtivat ja kehtetut kasutaja sisestust, parooli lähtestamise töövooge ja õiguste kontrolle.

8. Dokumentatsioon

Dokumenteerige oma kohandatud kasutajamudel ja autentimissüsteem põhjalikult. See teeb teistel arendajatel teie koodi mõistmise ja hooldamise lihtsamaks. Lisage teave iga välja eesmärgi, autentimisvoo ja kõigi turvalisuskaalutluste kohta.

Arenenud tehnikad ja kaalutlused

1. Kohandatud kasutajahaldurid

Nagu näidatud `AbstractBaseUser` näites, on kohandatud kasutajahaldurid kasutajate loomiseks ja haldamiseks hädavajalikud. Need võimaldavad teil määratleda kohandatud loogika kasutajate loomiseks, näiteks teatud väljade vaikeväärtuste seadistamiseks või täiendava valideerimise teostamiseks.

2. Proksimudelid

Proksimudelid võimaldavad teil lisada kasutajamudelile meetodeid ilma andmebaasi skeemi muutmata. See võib olla kasulik kohandatud loogika või arvutuste lisamiseks, mis on spetsiifilised teie rakendusele.

3. Kasutajamudeli laiendamine profiilimudeliga

Selle asemel, et lisada palju välju otse kasutajamudelisse, võite luua eraldi profiilimudeli, millel on üks-ühele seos kasutajamudeliga. See aitab hoida teie kasutajamudeli puhta ja organiseerituna.

            from django.db import models
from django.conf import settings

class UserProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='profile')
    # Additional fields
    bio = models.TextField(blank=True)
    location = models.CharField(max_length=100, blank=True)

            

              
                Copy
              
            
          

Pidage meeles, et looge signaal, mis loob automaatselt UserProfile'i, kui kasutaja luuakse:

            from django.db.models.signals import post_save
from django.dispatch import receiver
from django.conf import settings
from .models import UserProfile

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def save_user_profile(sender, instance, **kwargs):
    instance.profile.save()

            

              
                Copy
              
            
          

4. Ühekordne sisselogimine (SSO)

Suuremate organisatsioonide või teiste teenustega integreerimist nõudvate rakenduste puhul kaaluge ühekordse sisselogimise (SSO) juurutamist, kasutades protokolle nagu OAuth 2.0 või SAML. Django pakub mitmeid pakette, mis lihtsustavad SSO integreerimist, näiteks `django-allauth`.

5. Auditeerimise logimine

Juurutage auditeerimise logimine, et jälgida kasutaja tegevust ja kasutajaandmete muudatusi. See võib olla kasulik turvalisuse jälgimiseks, vastavuse tagamiseks ja silumiseks. Paketid nagu `django-auditlog` võivad aidata seda protsessi automatiseerida.

Kokkuvõte

Djangos kohandatud kasutajamudelite loomine ja juurutamine pakub paindlikkust ja kontrolli, mida vajate tugevate ja skaleeritavate autentimissüsteemide loomiseks, eriti globaalsete rakenduste jaoks. Järgides käesolevas juhendis toodud parimaid tavasid, saate tagada, et teie rakendus on hästi varustatud mitmekesiste kasutajanõuete käsitlemiseks, andmete terviklikkuse säilitamiseks ja turvalise ning kasutajasõbraliku kogemuse pakkumiseks kasutajatele üle kogu maailma. Pidage meeles oma juurutamist hoolikalt planeerida, arvestada oma kasutajate vajadustega ja seada turvalisus esikohale protsessi igas etapis. Valik `AbstractBaseUser` ja `AbstractUser` vahel sõltub vajalikust kohandamise tasemest. Oluliste muudatuste korral pakub `AbstractBaseUser` suuremat kontrolli. Lihtsate laienduste jaoks pakub `AbstractUser` sujuvamat üleminekut. Põhjalik testimine on ülioluline tagamaks, et kohandatud kasutajamudel integreerub sujuvalt ülejäänud teie Django rakendusega ja vastab kõigile turvanõuetele. Rakendage parimaid tavasid rahvusvahelistamise, lokaliseerimise ja ajavööndi käsitlemiseks, et pakkuda tõeliselt globaalset kogemust. See aitab oluliselt kaasa teie rakenduse edule ja vastuvõtmisele erinevatel turgudel üle kogu maailma.