Autentikasi Python Django: Menguasai Model Pengguna Kustom untuk Aplikasi Global

Sistem autentikasi bawaan Django adalah titik awal yang kuat untuk banyak aplikasi web. Namun, seiring dengan skala aplikasi Anda yang meningkat dan menjadi lebih kompleks, terutama untuk audiens global, model Pengguna default mungkin tidak cukup. Di sinilah model pengguna kustom berperan, menawarkan fleksibilitas dan kontrol yang lebih besar atas data pengguna dan proses autentikasi. Panduan komprehensif ini akan memandu Anda melalui proses pembuatan dan penerapan model pengguna kustom di Django, memastikan aplikasi Anda diperlengkapi dengan baik untuk menangani beragam kebutuhan pengguna dan pertimbangan keamanan.

Mengapa Menggunakan Model Pengguna Kustom?

Model Pengguna Django default dirancang dengan atribut umum seperti nama pengguna, kata sandi, email, nama depan, dan nama belakang. Meskipun cocok untuk aplikasi sederhana, sering kali tidak mencukupi ketika Anda perlu:

• Menyimpan informasi pengguna tambahan: Pertimbangkan platform e-commerce global yang perlu menyimpan preferensi pengguna, alamat dalam berbagai format, mata uang pilihan, atau pengaturan bahasa. Ini berada di luar cakupan model default.
• Mengubah bidang autentikasi: Mungkin Anda ingin mengautentikasi pengguna menggunakan alamat email mereka alih-alih nama pengguna, atau menerapkan autentikasi multi-faktor yang memerlukan bidang tambahan.
• Berintegrasi dengan database yang ada: Jika Anda mengintegrasikan aplikasi Django dengan database yang ada yang memiliki skema pengguna yang berbeda, model pengguna kustom memungkinkan Anda memetakan model Anda ke struktur data yang ada.
• Meningkatkan keamanan: Model kustom memungkinkan kontrol yang lebih besar atas hashing kata sandi, mekanisme pengaturan ulang kata sandi, dan aspek terkait keamanan lainnya.
• Menerapkan peran pengguna yang berbeda: Menyimpan data kontrol akses berbasis peran (RBAC) langsung di model (atau mereferensikannya) menawarkan kontrol yang lebih fleksibel dan eksplisit daripada grup dan izin generik.

Menggunakan model pengguna kustom menyediakan cara yang bersih dan mudah dipelihara untuk memperluas profil pengguna tanpa memodifikasi sistem autentikasi inti Django secara langsung. Ini adalah praktik terbaik untuk setiap proyek yang mengantisipasi pertumbuhan di masa mendatang atau memerlukan data pengguna khusus.

Kapan Menerapkan Model Pengguna Kustom?

Waktu terbaik untuk menerapkan model pengguna kustom adalah pada awal proyek Anda. Mengubah model pengguna di lingkungan produksi bisa jadi rumit dan berpotensi merusak data. Jika proyek Anda sudah berjalan, pertimbangkan dengan cermat implikasinya dan buat rencana migrasi yang kuat sebelum membuat perubahan apa pun.

Berikut adalah pedoman umum:

• Mulai dengan model pengguna kustom: Jika Anda meramalkan kebutuhan informasi pengguna yang diperluas atau logika autentikasi kustom.
• Pertimbangkan migrasi dengan hati-hati: Jika Anda sudah memiliki proyek Django yang berjalan dengan pengguna dan memutuskan untuk beralih ke model kustom. Cadangkan database Anda dan pahami proses migrasi secara menyeluruh.

Membuat Model Pengguna Kustom

Ada dua pendekatan utama untuk membuat model pengguna kustom di Django:

1. AbstractBaseUser: Pendekatan ini memberi Anda kontrol penuh atas model pengguna. Anda mendefinisikan semua bidang, termasuk nama pengguna, kata sandi, email, dan bidang kustom apa pun yang Anda butuhkan.
2. AbstractUser: Pendekatan ini mewarisi dari model Pengguna Django default dan memungkinkan Anda untuk menambahkan atau mengganti bidang yang ada. Ini lebih sederhana jika Anda hanya perlu menambahkan beberapa bidang tambahan.

1. Menggunakan AbstractBaseUser (Kontrol Penuh)

Ini adalah opsi paling fleksibel, memungkinkan Anda untuk mendefinisikan seluruh model pengguna dari awal. Ini memberikan kontrol terbesar atas struktur data pengguna dan proses autentikasi. Begini caranya:

Langkah 1: Membuat Model Pengguna Kustom

Di aplikasi Django Anda (misalnya, 'accounts'), buat file `models.py` dan definisikan model pengguna kustom Anda yang mewarisi dari `AbstractBaseUser` dan `PermissionsMixin`:

            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
              
            
          

Penjelasan:

• CustomUserManager: Kelas ini diperlukan untuk mengelola model pengguna kustom Anda. Ini menangani pembuatan pengguna dan superuser. `normalize_email` penting untuk memastikan konsistensi email di berbagai lokal dan metode input.
• CustomUser: Ini adalah model pengguna kustom Anda.
• `email = models.EmailField(unique=True, verbose_name='email address')`: Mendefinisikan bidang email sebagai pengidentifikasi unik untuk pengguna. Menggunakan `unique=True` memastikan bahwa setiap pengguna memiliki alamat email yang unik. Nama verbose meningkatkan antarmuka admin.
• `first_name`, `last_name`: Bidang standar untuk menyimpan nama pengguna. `blank=True` memungkinkan bidang-bidang ini kosong.
• `is_staff`, `is_active`: Bidang standar untuk mengontrol akses pengguna ke panel admin dan aktivasi akun.
• `date_joined`: Mencatat tanggal akun pengguna dibuat.
• `preferred_language`, `timezone`: Contoh bidang kustom untuk menyimpan preferensi pengguna. Argumen `choices` membatasi opsi bahasa yang mungkin. Ini sangat penting untuk aplikasi global. Zona waktu juga penting untuk pelokalan.
• `USERNAME_FIELD = 'email'`: Menentukan bahwa bidang email akan digunakan sebagai nama pengguna untuk autentikasi.
• `REQUIRED_FIELDS = []`: Menentukan bidang yang diperlukan saat membuat superuser menggunakan perintah `createsuperuser`. Dalam hal ini, tidak ada bidang tambahan yang diperlukan selain email dan kata sandi.
• `objects = CustomUserManager()`: Menetapkan pengelola pengguna kustom ke model.
• `__str__(self)`: Mendefinisikan bagaimana objek pengguna direpresentasikan sebagai string (misalnya, di panel admin).

Langkah 2: Memperbarui `settings.py`

Beri tahu Django untuk menggunakan model pengguna kustom Anda dengan menambahkan baris berikut ke file `settings.py` Anda:

            AUTH_USER_MODEL = 'accounts.CustomUser'
            

              
                Copy
              
            
          

Ganti `accounts` dengan nama aplikasi Anda tempat Anda mendefinisikan model `CustomUser`.

Langkah 3: Membuat dan Menerapkan Migrasi

Jalankan perintah berikut untuk membuat dan menerapkan migrasi:

            python manage.py makemigrations
python manage.py migrate
            

              
                Copy
              
            
          

Ini akan membuat tabel database baru untuk model pengguna kustom Anda.

Langkah 4: Menggunakan Model Pengguna Kustom

Sekarang Anda dapat menggunakan model pengguna kustom Anda di tampilan, templat, dan bagian lain dari aplikasi Anda. Misalnya, untuk membuat pengguna baru:

            from accounts.models import CustomUser

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

              
                Copy
              
            
          

2. Menggunakan AbstractUser (Menambahkan ke Model Default)

Pendekatan ini lebih sederhana jika Anda hanya perlu menambahkan beberapa bidang tambahan ke model Pengguna Django default. Ini mewarisi semua bidang dan metode yang ada dari `AbstractUser`. Ini bisa lebih mudah untuk penyesuaian yang lebih sederhana.

Langkah 1: Membuat Model Pengguna Kustom

Di file `models.py` aplikasi Django Anda, definisikan model pengguna kustom Anda yang mewarisi dari `AbstractUser`:

            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
              
            
          

Penjelasan:

• CustomUser: Ini adalah model pengguna kustom Anda, yang mewarisi dari `AbstractUser`.
• `phone_number`, `profile_picture`: Contoh bidang untuk ditambahkan ke model pengguna. `upload_to` menentukan di mana gambar profil akan disimpan.
• `preferred_currency`, `address_format`: Contoh bidang kustom yang relevan dengan aplikasi global. Negara yang berbeda memiliki format alamat yang sangat berbeda.
• `__str__(self)`: Mendefinisikan bagaimana objek pengguna direpresentasikan sebagai string (misalnya, di panel admin). Di sini ia menggunakan nama pengguna.

Langkah 2: Memperbarui `settings.py`

Sama seperti sebelumnya, beri tahu Django untuk menggunakan model pengguna kustom Anda dengan menambahkan baris berikut ke file `settings.py` Anda:

            AUTH_USER_MODEL = 'accounts.CustomUser'
            

              
                Copy
              
            
          

Langkah 3: Membuat dan Menerapkan Migrasi

Jalankan perintah berikut untuk membuat dan menerapkan migrasi:

            python manage.py makemigrations
python manage.py migrate
            

              
                Copy
              
            
          

Langkah 4: Menggunakan Model Pengguna Kustom

Sekarang Anda dapat mengakses bidang yang ditambahkan saat bekerja dengan objek pengguna:

            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
              
            
          

Praktik Terbaik untuk Model Pengguna Kustom di Aplikasi Global

Saat menerapkan model pengguna kustom untuk aplikasi yang menargetkan audiens global, pertimbangkan praktik terbaik berikut:

1. Internasionalisasi dan Pelokalan (i18n & l10n)

Simpan Data Khusus Lokal: Rancang model Anda untuk mengakomodasi norma budaya dan format data yang berbeda. Simpan tanggal, waktu, angka, dan alamat dengan cara yang sadar lokal.

Contoh:

            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. Penanganan Zona Waktu

Selalu simpan dan tangani zona waktu dengan benar. Simpan informasi zona waktu di model pengguna dan gunakan untuk menampilkan tanggal dan waktu di zona waktu lokal pengguna.

Contoh:

            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. Pemformatan Alamat

Format alamat sangat bervariasi di berbagai negara. Terapkan sistem alamat fleksibel yang memungkinkan pengguna memasukkan alamat mereka dalam format yang benar untuk lokasi mereka. Pertimbangkan untuk menggunakan pustaka atau layanan pihak ketiga untuk menangani validasi dan pemformatan alamat.

Contoh:

            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. Penanganan Mata Uang

Jika aplikasi Anda melibatkan transaksi keuangan, simpan mata uang pilihan pengguna dan gunakan untuk menampilkan harga dan jumlah. Gunakan pustaka seperti `babel` untuk memformat nilai mata uang sesuai dengan lokal pengguna.

Contoh:

            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. Validasi Data

Terapkan validasi data yang kuat untuk memastikan bahwa input pengguna valid dan konsisten. Gunakan validator bawaan Django atau buat validator kustom untuk memberlakukan integritas data.

Contoh:

            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. Pertimbangan Keamanan

Hashing Kata Sandi: Sistem autentikasi Django menggunakan algoritma hashing kata sandi yang kuat secara default. Pastikan bahwa Anda menggunakan versi Django terbaru untuk mendapatkan manfaat dari pembaruan keamanan terbaru.

Autentikasi Dua Faktor (2FA): Terapkan 2FA untuk menambahkan lapisan keamanan ekstra ke akun pengguna. Ada berbagai paket Django yang tersedia untuk ini, seperti `django-otp`. Ini sangat penting saat menangani data pengguna sensitif atau transaksi keuangan.

Perlindungan Data: Ikuti praktik terbaik untuk perlindungan dan privasi data, terutama saat berurusan dengan informasi pengguna sensitif. Patuhi peraturan perlindungan data yang relevan, seperti GDPR dan CCPA. Pertimbangkan teknik enkripsi data, anonimisasi, dan tokenisasi.

7. Pengujian

Tulis pengujian unit dan pengujian integrasi yang komprehensif untuk memastikan bahwa model pengguna kustom Anda berfungsi seperti yang diharapkan dan bahwa sistem autentikasi Anda aman. Uji skenario yang berbeda, termasuk input pengguna yang valid dan tidak valid, alur kerja pengaturan ulang kata sandi, dan pemeriksaan izin.

8. Dokumentasi

Dokumentasikan model pengguna kustom dan sistem autentikasi Anda secara menyeluruh. Ini akan memudahkan pengembang lain untuk memahami dan memelihara kode Anda. Sertakan informasi tentang tujuan setiap bidang, alur autentikasi, dan pertimbangan keamanan apa pun.

Teknik dan Pertimbangan Tingkat Lanjut

1. Pengelola Pengguna Kustom

Seperti yang ditunjukkan dalam contoh `AbstractBaseUser`, pengelola pengguna kustom sangat penting untuk membuat dan mengelola pengguna. Mereka memungkinkan Anda mendefinisikan logika kustom untuk membuat pengguna, seperti menetapkan nilai default untuk bidang tertentu atau melakukan validasi tambahan.

2. Model Proksi

Model proksi memungkinkan Anda menambahkan metode ke model pengguna tanpa mengubah skema database. Ini dapat berguna untuk menambahkan logika atau perhitungan kustom yang khusus untuk aplikasi Anda.

3. Memperluas Model Pengguna dengan Model Profil

Alih-alih menambahkan banyak bidang langsung ke model pengguna, Anda dapat membuat model profil terpisah yang memiliki hubungan satu-ke-satu dengan model pengguna. Ini dapat membantu menjaga model pengguna Anda tetap bersih dan terorganisir.

            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
              
            
          

Ingatlah untuk membuat sinyal untuk secara otomatis membuat UserProfile saat pengguna dibuat:

            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. Single Sign-On (SSO)

Untuk organisasi atau aplikasi yang lebih besar yang memerlukan integrasi dengan layanan lain, pertimbangkan untuk menerapkan Single Sign-On (SSO) menggunakan protokol seperti OAuth 2.0 atau SAML. Django menyediakan beberapa paket yang menyederhanakan integrasi SSO, seperti `django-allauth`.

5. Audit Logging

Terapkan audit logging untuk melacak aktivitas pengguna dan perubahan pada data pengguna. Ini dapat berguna untuk pemantauan keamanan, kepatuhan, dan debugging. Paket seperti `django-auditlog` dapat membantu mengotomatiskan proses ini.

Kesimpulan

Membuat dan menerapkan model pengguna kustom di Django memberikan fleksibilitas dan kontrol yang Anda butuhkan untuk membangun sistem autentikasi yang kuat dan dapat diskalakan, terutama untuk aplikasi global. Dengan mengikuti praktik terbaik yang diuraikan dalam panduan ini, Anda dapat memastikan bahwa aplikasi Anda diperlengkapi dengan baik untuk menangani beragam kebutuhan pengguna, menjaga integritas data, dan memberikan pengalaman yang aman dan ramah pengguna bagi pengguna di seluruh dunia. Ingatlah untuk merencanakan implementasi Anda dengan cermat, mempertimbangkan kebutuhan pengguna Anda, dan memprioritaskan keamanan di setiap tahap proses. Memilih antara `AbstractBaseUser` dan `AbstractUser` tergantung pada tingkat penyesuaian yang diperlukan. Untuk perubahan signifikan, `AbstractBaseUser` menawarkan lebih banyak kontrol. Untuk ekstensi sederhana, `AbstractUser` menyediakan transisi yang lebih mulus. Pengujian menyeluruh sangat penting untuk memastikan model pengguna kustom terintegrasi dengan mulus dengan seluruh aplikasi Django Anda dan memenuhi semua persyaratan keamanan. Terapkan praktik terbaik untuk internasionalisasi, pelokalan, dan penanganan zona waktu untuk memberikan pengalaman global yang sesungguhnya. Ini akan memberikan kontribusi signifikan terhadap keberhasilan dan adopsi aplikasi Anda di beragam pasar di seluruh dunia.