Flask
प्राधिकरण और प्रमाणीकरण

फ्लास्क-लॉगिन एक्सटेंशन का उपयोग करना

प्राधिकरण प्रणाली को लागू करने के सरल तरीकों में से एक फ्लास्क-लॉगिन एक्सटेंशन का उपयोग कर रहा है। परियोजना की वेबसाइट में एक विस्तृत और अच्छी तरह से लिखित क्विकस्टार्ट है, जिसका एक छोटा संस्करण इस उदाहरण में उपलब्ध है।

सामान्य विचार

एक्सटेंशन के लिए उपयोग किए जाने वाले कार्यों का एक समूह उजागर करता है:

• उपयोगकर्ताओं को लॉग इन करना
• उपयोगकर्ताओं को लॉग आउट करना
• यह जाँचना कि कोई उपयोगकर्ता लॉग इन है या नहीं और यह पता कर रहा है कि वह कौन सा उपयोगकर्ता है

यह क्या नहीं करता है और आपको अपने दम पर क्या करना है:

• डेटाबेस में उदाहरण के लिए, उपयोगकर्ताओं को संग्रहीत करने का एक तरीका प्रदान नहीं करता है
• उपयोगकर्ता के क्रेडेंशियल्स की जाँच करने का एक तरीका प्रदान नहीं करता है, उदाहरण के लिए उपयोगकर्ता नाम और पासवर्ड

नीचे सब कुछ काम करने के लिए आवश्यक चरणों का एक न्यूनतम सेट है।

मैं सभी अलग-अलग संबंधित कोड को अलग मॉड्यूल या पैकेज में रखने की auth.py , उदाहरण के लिए auth.py इस तरह आप आवश्यक कक्षाएं, ऑब्जेक्ट या कस्टम फ़ंक्शन अलग से बना सकते हैं।

एक LoginManager बनाएँ

एक्सटेंशन एक LoginManager वर्ग का उपयोग करता है जिसे आपके Flask एप्लिकेशन ऑब्जेक्ट पर पंजीकृत होना चाहिए।

from flask_login import LoginManager
login_manager = LoginManager()
login_manager.init_app(app) # app is a Flask object

जैसा कि पहले उल्लेख किया गया है, उदाहरण के लिए LoginManager एक अलग फ़ाइल या पैकेज में एक वैश्विक चर हो सकता है। फिर इसे उस फ़ाइल में आयात किया जा सकता है जिसमें Flask ऑब्जेक्ट बनाया गया है या आपके एप्लिकेशन फैक्ट्री फ़ंक्शन और इनिशियलाइज़ किया गया है।

उपयोगकर्ताओं को लोड करने के लिए उपयोग की जाने वाली कॉलबैक निर्दिष्ट करें

एक उपयोगकर्ता आम तौर पर एक डेटाबेस से लोड किया जाएगा। कॉलबैक में एक ऑब्जेक्ट वापस करना चाहिए जो प्रदान की गई आईडी के अनुरूप उपयोगकर्ता का प्रतिनिधित्व करता है। यदि आईडी मान्य None तो इसे वापस करना चाहिए।

@login_manager.user_loader
def load_user(user_id):
    return User.get(user_id) # Fetch the user from the database

यह सीधे आपके LoginManager बनाने के नीचे किया जा सकता है।

आपके उपयोगकर्ता का प्रतिनिधित्व करने वाला एक वर्ग

जैसा कि उल्लेख किया गया है user_loader कॉलबैक में एक ऑब्जेक्ट को वापस करना है जो एक उपयोगकर्ता का प्रतिनिधित्व करता है। इसका सबसे सही मतलब क्या है? उदाहरण के लिए वह वस्तु आपके डेटाबेस में संग्रहीत उपयोगकर्ता वस्तुओं के चारों ओर एक आवरण हो सकती है या सीधे आपके डेटाबेस से एक मॉडल हो सकती है। उस वस्तु को निम्नलिखित विधियों और गुणों को लागू करना होगा। इसका मतलब है कि यदि कॉलबैक आपके डेटाबेस मॉडल को वापस करता है, तो आपको यह सुनिश्चित करने की आवश्यकता है कि आपके मॉडल में उल्लिखित गुण और विधियां जोड़ी गई हैं।

• is_authenticated

  यदि उपयोगकर्ता प्रमाणित है, तो उन्हें यह गुण True होना चाहिए, अर्थात उन्होंने वैध क्रेडेंशियल्स प्रदान किए हैं। आप यह सुनिश्चित करना चाहेंगे कि जो ऑब्जेक्ट आपके उपयोगकर्ताओं का प्रतिनिधित्व करते हैं, जो user_loader कॉलबैक द्वारा लौटाए गए हैं, उस पद्धति के लिए True ।

• is_active

  यदि यह एक सक्रिय उपयोगकर्ता है - तो यह संपत्ति सही वापस आनी चाहिए - प्रमाणित होने के अलावा, उन्होंने अपना खाता भी सक्रिय कर दिया है, निलंबित नहीं किया गया है, या आपके आवेदन को किसी भी स्थिति में किसी खाते को अस्वीकार करने के लिए है। निष्क्रिय खाते लॉग इन नहीं कर सकते हैं। यदि आपके पास ऐसा कोई तंत्र मौजूद नहीं है तो इस पद्धति से True लौटें।

• is_anonymous

  यदि यह अनाम उपयोगकर्ता है, तो यह गुण सही होना चाहिए। इसका अर्थ है कि user_loader कॉलबैक द्वारा लौटाया गया आपका उपयोगकर्ता ऑब्जेक्ट True लौटना चाहिए।

• get_id()

  इस पद्धति को एक यूनिकोड वापस करना होगा जो विशिष्ट रूप से इस उपयोगकर्ता की पहचान करता है, और इसका उपयोग उपयोगकर्ता को लोड करने के लिए किया जा सकता है user_loader callback। ध्यान दें कि यह एक यूनिकोड होना चाहिए - यदि आईडी मूल रूप से एक इंट या कुछ अन्य प्रकार है, तो आपको इसे यूनीकोड में बदलने की आवश्यकता होगी। यदि user_loader callback डेटाबेस से ऑब्जेक्ट्स को लौटाता है, तो यह विधि इस विशेष उपयोगकर्ता के डेटाबेस ID को वापस करने की सबसे अधिक संभावना है। एक ही आईडी को निश्चित रूप से user_loader कॉलबैक के कारण उसी उपयोगकर्ता को बाद में वापस करना चाहिए।

यदि आप अपने लिए चीजों को आसान बनाना चाहते हैं (** यह वास्तव में अनुशंसित है) तो आप UserMixin से वापस ले सकते हैं जो user_loader callback (संभवतः एक डेटाबेस मॉडल) द्वारा दी गई वस्तु में है। आप देख सकते हैं कि कैसे उन तरीकों और गुणों को इस मिक्सिन में डिफ़ॉल्ट रूप से लागू किया गया है ।

उपयोगकर्ताओं को लॉग इन कर रहा है

एक्सटेंशन उपयोगकर्ता द्वारा आपके लिए दर्ज उपयोगकर्ता नाम और पासवर्ड की मान्यता को छोड़ देता है। यदि आप एक उपयोगकर्ता नाम और पासवर्ड कॉम्बो या अन्य तंत्र का उपयोग करते हैं तो वास्तव में विस्तार का ध्यान नहीं है। यह उपयोगकर्ता नाम और पासवर्ड का उपयोग करने के लिए लॉग इन करने के लिए एक उदाहरण है।

@app.route('/login', methods=['GET', 'POST'])
def login():
    # Here we use a class of some kind to represent and validate our
    # client-side form data. For example, WTForms is a library that will
    # handle this for us, and we use a custom LoginForm to validate.
    form = LoginForm()
    if form.validate_on_submit():
        # Login and validate the user.
        # user should be an instance of your `User` class
        login_user(user)

        flask.flash('Logged in successfully.')

        next = flask.request.args.get('next')
        # is_safe_url should check if the url is safe for redirects.
        # See http://flask.pocoo.org/snippets/62/ for an example.
        if not is_safe_url(next):
            return flask.abort(400)

        return flask.redirect(next or flask.url_for('index'))
    return flask.render_template('login.html', form=form)

सामान्य लॉगिंग उपयोगकर्ताओं में, login_user को कॉल करके पूरा किया जाता है और किसी वस्तु का उदाहरण दिया जाता है, जो आपके उपयोगकर्ता द्वारा पहले उल्लेखित है। जैसा कि दिखाया गया है यह आमतौर पर उपयोगकर्ता को डेटाबेस से पुनर्प्राप्त करने और उसकी साख को मान्य करने के बाद होगा, हालांकि उपयोगकर्ता ऑब्जेक्ट सिर्फ जादुई रूप से इस उदाहरण में दिखाई देता है।

मैंने एक उपयोगकर्ता में लॉग इन किया है, अब क्या है?

user_loader कॉलबैक द्वारा लौटाए गए ऑब्जेक्ट को कई तरीकों से एक्सेस किया जा सकता है।

• टेम्प्लेट में:

  एक्सटेंशन स्वतः ही टेम्पलेट संदर्भ प्रोसेसर का उपयोग करके current_user नाम के तहत इसे इंजेक्ट करता है। उस व्यवहार को अक्षम करने और अपने कस्टम प्रोसेसर का उपयोग करने के लिए add_context_processor=False अपने LoginManager कंस्ट्रक्टर में add_context_processor=False ।

    {% if current_user.is_authenticated %}
      Hi {{ current_user.name }}!
    {% endif %}
  

• पायथन कोड में:

  एक्सटेंशन एक अनुरोध-बाध्य ऑब्जेक्ट प्रदान करता है जिसे current_user कहा जाता है।

    from flask_login import current_user    
  
    @app.route("/hello")
    def hello():
        # Assuming that there is a name property on your user object
        # returned by the callback
        if current_user.is_authenticated:
            return 'Hello %s!' % current_user.name 
        else:
            return 'You are not logged in!'
  

• डेकोरेटर का उपयोग करते हुए पहुंच को जल्दी से सीमित करना एक login_required डेकोरेटर का उपयोग एक्सेस को जल्दी से सीमित करने के लिए किया जा सकता है।

    from flask_login import login_required
  
    @app.route("/settings")
    @login_required
    def settings():
        pass
  

उपयोगकर्ताओं को लॉग आउट करना

logout_user() कॉल करके उपयोगकर्ताओं को लॉग आउट किया जा सकता है। ऐसा प्रतीत होता है कि ऐसा करना सुरक्षित है, भले ही उपयोगकर्ता लॉग इन न हो लेकिन @login_required डेकोरेटर को सबसे अधिक पसंद किया जा सकता है।

@app.route("/logout")
@login_required
def logout():
    logout_user()
    return redirect(somewhere)

यदि उपयोगकर्ता लॉग इन नहीं होता है और मैं current_user ऑब्जेक्ट एक्सेस करता हूं तो क्या होगा?

डिफॉल्ट करके एक अनाम उपयोगकर्ता नाम वापस कर दिया गया है:

• is_active और is_authenticated False
• is_anonymous True
• get_id() None लौटाता है

अनाम उपयोगकर्ताओं के लिए किसी भिन्न ऑब्जेक्ट का उपयोग करने के लिए एक LoginManager करने योग्य (या तो एक वर्ग या कारखाना फ़ंक्शन) प्रदान करें जो आपके LoginManager साथ अनाम उपयोगकर्ता बनाता है:

login_manager.anonymous_user = MyAnonymousUser

आगे क्या?

यह विस्तार के लिए मूल परिचय का निष्कर्ष निकालता है। कॉन्फ़िगरेशन और अतिरिक्त विकल्पों के बारे में अधिक जानने के लिए यह आधिकारिक मार्गदर्शिका पढ़ने के लिए अत्यधिक अनुशंसित है।

लॉगिन सत्र समाप्त करना

विशिष्ट समय के बाद सत्र में लॉग आउट करने के लिए इसका अच्छा अभ्यास, आप फ्लास्क-लॉगिन के साथ इसे प्राप्त कर सकते हैं।

from flask import Flask, session
from datetime import timedelta
from flask_login import LoginManager, login_require, login_user, logout_user

# Create Flask application

app = Flask(__name__) 

# Define Flask-login configuration 

login_mgr = LoginManager(app)
login_mgr.login_view = 'login'
login_mgr.refresh_view = 'relogin'
login_mgr.needs_refresh_message = (u"Session timedout, please re-login")
login_mgr.needs_refresh_message_category = "info"


@app.before_request
def before_request():
    session.permanent = True
    app.permanent_session_lifetime = timedelta(minutes=5)

डिफ़ॉल्ट सत्र जीवनकाल 31 दिन है, उपयोगकर्ता को टाइमआउट के मामले में लॉगिन ताज़ा दृश्य को निर्दिष्ट करने की आवश्यकता है।

app.permanent_session_lifetime = timedelta(minutes=5)

उपरोक्त पंक्ति उपयोगकर्ता को हर 5 मिनट में पुनः लॉगिन करने के लिए बाध्य करेगी।