Django இன் அங்கீகாரம் அமைப்பு எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

Django ஒரு முழுமையான, உள்ளமைக்கப்பட்ட **அங்கீகாரம் அமைப்பு** (`django.contrib.auth`) உள்ளடக்கியுள்ளது, இது **பயனர்கள்**, **கடவுச்சொற்கள்**, **அமர்வுகள்/உள்நுழைவு**, மற்றும் **அனுமதிகள்** ஐ கையாள்கிறது — மற்றொரு "பேட்டரிகள் உள்ளடக்கிய" அம்சம் இது உங்களை இந்த பாதுகாப்பு-முக்கியமான செயல்பாட்டை உருவாக்குவதில் (மற்றும் தவறுவதில்) சேமிக்கிறது.

## பயனர் மாதிரி மற்றும் பயனர்களை உருவாக்குதல்

```python
from django.contrib.auth.models import User

# passwords are HASHED automatically — never store plaintext
user = User.objects.create_user(username="ann", email="a@x.com", password="secret")
user.set_password("newpassword")        # always use set_password (it hashes)
user.check_password("secret")            # verify a password (constant-time)
```

உள்ளமைக்கப்பட்ட `User` மாதிரி பாதுகாப்பான **கடவுச்சொல் hash செய்தல்** தானாக கையாளுகிறது (PBKDF2 போன்ற வலிமையான வழிமுறைகளைப் பயன்படுத்தி) — நீங்கள் ஒருபோதும் சாதாரண நூல் கடவுச்சொற்களைச் சேமிக்க அல்லது ஒப்பிட வேண்டியதில்லை, இது ஒரு பெரிய பாதுகாப்பு ঝுறை நீக்குகிறது.

## அங்கீகரித்தல் மற்றும் உள்நுழைதல்

```python
from django.contrib.auth import authenticate, login, logout

def login_view(request):
    user = authenticate(request, username=username, password=password)  # verify credentials
    if user is not None:
        login(request, user)             # establish a SESSION (sets request.user)
        return redirect("home")
    # else: invalid credentials

def logout_view(request):
    logout(request)                       # clear the session
```

`authenticate()` நற்சான்றுகளை சரிபார்க்கிறது, மற்றும் `login()` ஒரு அமர்வை நிறுவுகிறது — அதன் பிறகு `request.user` ஒவ்வொரு கோரிக்கையிலும் உள்நுழைந்த பயனர் ஆகிறது (அங்கீகாரம் middleware வழியாக).

## views ஐ பாதுகாத்தல் (உள்நுழைவு தேவை)

```python
from django.contrib.auth.decorators import login_required

@login_required                          # redirect to login if not authenticated
def dashboard(request):
    return render(request, "dashboard.html", {"user": request.user})

# for class-based views:
from django.contrib.auth.mixins import LoginRequiredMixin
class DashboardView(LoginRequiredMixin, ListView): ...
```

## அனுமதிகள் மற்றும் அங்கீகாரம்

```python
# checking permissions
request.user.is_authenticated            # is someone logged in?
request.user.is_staff / is_superuser     # role flags
request.user.has_perm("blog.add_article")# a specific permission
request.user.groups.all()                 # group membership (role-based access)

@permission_required("blog.add_article")
def create_article(request): ...
```

Django **அங்கீகாரம்** (நீ யார் — உள்நுழைவு) ஐ **அங்கீகாரம்** (நீ என்ன செய்யலாம் — அனுமதிகள்) ஐ வேறுபடுத்துகிறது. இது per-model அனுமதிகளை (add/change/delete/view), பங்கு-அடிப்படையிலான அணுக்க வசதிக்கான குழுக்களை, மற்றும் அவற்றை இயக்க decorators/mixins ஐ வழங்குகிறது.

## உள்ளமைக்கப்பட்ட auth views மற்றும் தனிப்பயன்

```text
✓ Ready-made views/URLs for login, logout, password change/reset (django.contrib.auth.urls)
✓ Customizable: a CUSTOM USER MODEL (recommended from the start) to add fields,
  custom backends (e.g. authenticate via email or OAuth), password validators
```

## இது ஏன் முக்கியமானது

Django இன் உள்ளமைக்கப்பட்ட அங்கீகாரம் அமைப்பு ஒரு முக்கிய, பாதுகாப்பு-முக்கியமான அம்சம் ஆகும், இது ஒரு வலை பயன்பாட்டின் மிகவும் பிழை-போக்கான மற்றும் ஆபத்தான பகுதிகளை உருவாக்குவதில் இருந்து உங்களை சேமிக்கிறது.

இதைப் புரிந்துகொள்ள வேண்டியது அவசியம் ஏனெனில் கிட்டத்தட்ட ஒவ்வொரு உண்மையான பயன்பாட்டிற்கு பயனர் கணக்குகள், உள்நுழைவு, மற்றும் அணுக்க கட்டுப்பாடு தேவை — மற்றும் அங்கீகாரம் **தவறாக உருவாக்க தீவிர பாதுகாப்பு பாதிப்புகளை உருவாக்குகிறது** (சாதாரண கடவுச்சொற்கள், பலவீனமான hashing, அமர்வு குறைபாடுகள்).

Django இன் அமைப்பு இவை சரியாக அப்படியே கையாளுகிறது: இது **கடவுச்சொற்களை பாதுகாப்பாக hash செய்கிறது** (வலிமையான வழிமுறைகள், ஒருபோதும் சாதாரணம் இல்லை — நீங்கள் `create_user`/`set_password`/`check_password` ஐ பயன்படுத்துகிறீர்கள் கடவுச்சொற்களை கைமுறையாக கையாளுவதற்கு பதிலாக), அமர்வுகள் மற்றும் உள்நுழைவை நிர்வகிக்கிறது (`authenticate`/`login`, middleware வழியாக எங்கும் `request.user` கிடைக்கிறது), மற்றும் ஒரு முழுமையான **அனுமதிகள் மற்றும் குழுக்கள் அமைப்பு** வழியாக அங்கீகாரத்தை வழங்குகிறது.

பயனர்களை உருவாக்குவது மற்றும் அங்கீகரிப்பது, views ஐ பாதுகாப்பது (`@login_required`, `LoginRequiredMixin`), மற்றும் அனுமதிகள் மற்றும் குழுக்கள் மூலம் **அங்கீகாரம்** இயக்குவது (அங்கீகாரம் — நீ யார் — மற்றும் அங்கீகாரம் — நீ என்ன செய்ய அனுமதிக்கப்பட்டுள்ளாய் என்பதை வேறுபடுத்துதல்) பாதுகாப்பான பயன்பாடுகளை உருவாக்குவதற்கு அடிப்படையாகும்.

অமைப்பின் விரிவாக்கம் — குறிப்பாக ஒரு **தனிப்பயன் பயனர் மாதிரி** ஐ பயன்படுத்துதல் (திட்டத்தின் தொடக்கத்திலிருந்து வலுவாக பரிந்துரைக்கப்படுகிறது) புலங்களைச் சேர்க்க, மற்றும் மின்னஞ்சல்/OAuth உள்நுழைவுக்கான தனிப்பயன் backends — முக்கியமான நடைமுறை ஞ்ஞ்ানமாகும்.

அங்கீகாரம் பரவலாக இருப்பதாலும், பாதுகாப்பு-முக்கியமாக இருப்பதாலும், மற்றும் Django ஒரு வலுவான, சரியான, பேட்டரிகள் உள்ளடக்கிய தீர்வை வழங்குவதாலும், அதன் auth அமைப்பை தேர்ச்சி பெறுவது மூல ஞ்ஞ்ானம் ஆகும் இது உங்களை இந்த அடிப்படை செயல்பாட்டை மீண்டும் உருவாக்குதல் (மற்றும் ஆபத்து) இல்லாமல் பாதுகாப்பான பயனர்-எதிர்முகமான பயன்பாடுகளை உருவாக்க அனுமதிக்கிறது.