M

MLOG

मराठी

टोर्नेडो, एक पायथन वेब फ्रेमवर्क आणि असिंक्रोनस नेटवर्किंग लायब्ररीचा सखोल अभ्यास. तपशीलवार स्पष्टीकरण, उदाहरणे आणि सर्वोत्तम पद्धतींसह स्केलेबल, उच्च-कार्यक्षमता असलेले ॲप्लिकेशन्स कसे तयार करायचे ते शिका.

टोर्नेडो डॉक्युमेंटेशन: जगभरातील डेव्हलपर्ससाठी एक सर्वसमावेशक मार्गदर्शक

टोर्नेडो हे एक पायथन वेब फ्रेमवर्क आणि असिंक्रोनस नेटवर्किंग लायब्ररी आहे, जी मूळतः फ्रेंडफीड येथे विकसित केली गेली होती. हे विशेषतः लाँग-पोलिंग, वेबसॉकेट्स आणि इतर ॲप्लिकेशन्ससाठी योग्य आहे ज्यांना प्रत्येक वापरकर्त्यासाठी दीर्घकाळ चालणारे कनेक्शन आवश्यक असते. त्याचे नॉन-ब्लॉकिंग नेटवर्क I/O त्याला अत्यंत स्केलेबल बनवते आणि उच्च-कार्यक्षमता असलेले वेब ॲप्लिकेशन्स तयार करण्यासाठी एक शक्तिशाली पर्याय बनवते. हे सर्वसमावेशक मार्गदर्शक तुम्हाला टोर्नेडोच्या मुख्य संकल्पनांमधून घेऊन जाईल आणि तुम्हाला सुरुवात करण्यासाठी व्यावहारिक उदाहरणे देईल.

टोर्नेडो म्हणजे काय?

टोर्नेडो हे मुळात एक वेब फ्रेमवर्क आणि असिंक्रोनस नेटवर्किंग लायब्ररी आहे. पारंपरिक सिंक्रोनस वेब फ्रेमवर्कच्या विपरीत, टोर्नेडो सिंगल-थ्रेडेड, इव्हेंट-लूप-आधारित आर्किटेक्चर वापरते. याचा अर्थ असा आहे की ते प्रत्येक कनेक्शनसाठी थ्रेडची आवश्यकता न ठेवता अनेक समवर्ती कनेक्शन्स हाताळू शकते, ज्यामुळे ते अधिक कार्यक्षम आणि स्केलेबल बनते.

टोर्नेडोची प्रमुख वैशिष्ट्ये:

तुमचे टोर्नेडो एन्व्हायर्नमेंट सेट करणे

टोर्नेडो डेव्हलपमेंटमध्ये जाण्यापूर्वी, तुम्हाला तुमचे एन्व्हायर्नमेंट सेट करणे आवश्यक आहे. येथे एक चरण-दर-चरण मार्गदर्शक आहे:

  1. पायथन इंस्टॉल करा: तुमच्याकडे पायथन 3.6 किंवा उच्च आवृत्ती इंस्टॉल असल्याची खात्री करा. तुम्ही ते अधिकृत पायथन वेबसाइट (python.org) वरून डाउनलोड करू शकता.
  2. व्हर्च्युअल एन्व्हायर्नमेंट तयार करा (शिफारसीय): तुमच्या प्रोजेक्टसाठी एक वेगळे एन्व्हायर्नमेंट तयार करण्यासाठी venv किंवा virtualenv वापरा: 
    python3 -m venv myenv
source myenv/bin/activate  # On Linux/macOS
myenv\Scripts\activate  # On Windows
  3. टोर्नेडो इंस्टॉल करा: pip वापरून टोर्नेडो इंस्टॉल करा: 
    pip install tornado

तुमचे पहिले टोर्नेडो ॲप्लिकेशन

चला टोर्नेडोसह एक साधे "Hello, World!" ॲप्लिकेशन तयार करूया. app.py नावाची फाईल तयार करा आणि खालील कोड जोडा:

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("Hello, World!")

def make_app():
 return tornado.web.Application([
  (r"/", MainHandler),
 ])

if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()

आता, तुमच्या टर्मिनलवरून ॲप्लिकेशन चालवा:

python app.py

तुमचा वेब ब्राउझर उघडा आणि http://localhost:8888 वर नेव्हिगेट करा. तुम्हाला "Hello, World!" संदेश दिसेल.

स्पष्टीकरण:

रिक्वेस्ट हँडलर्स आणि राउटिंग

रिक्वेस्ट हँडलर्स हे टोर्नेडो वेब ॲप्लिकेशन्सचा पाया आहेत. ते URL च्या आधारावर येणाऱ्या HTTP रिक्वेस्ट्स कशा हाताळायच्या हे परिभाषित करतात. राउटिंग URLs ला विशिष्ट रिक्वेस्ट हँडलरशी मॅप करते.

रिक्वेस्ट हँडलर्स परिभाषित करणे:

रिक्वेस्ट हँडलर तयार करण्यासाठी, tornado.web.RequestHandler चा सबक्लास तयार करा आणि योग्य HTTP मेथड्स (get, post, put, delete, इत्यादी) लागू करा.

class MyHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("This is a GET request.")

 def post(self):
  data = self.request.body.decode('utf-8')
  self.write(f"Received POST data: {data}")

राउटिंग:

tornado.web.Application तयार करताना राउटिंग कॉन्फिगर केले जाते. तुम्ही टपल्सची एक सूची प्रदान करता, जिथे प्रत्येक टपलमध्ये एक URL पॅटर्न आणि संबंधित रिक्वेस्ट हँडलर असतो.

app = tornado.web.Application([
 (r"/", MainHandler),
 (r"/myhandler", MyHandler),
])

URL पॅटर्न्स:

URL पॅटर्न्स हे रेग्युलर एक्सप्रेशन्स असतात. तुम्ही URL चे भाग कॅप्चर करण्यासाठी आणि त्यांना रिक्वेस्ट हँडलर मेथड्सना आर्ग्युमेंट्स म्हणून पास करण्यासाठी रेग्युलर एक्सप्रेशन ग्रुप्स वापरू शकता.

class UserHandler(tornado.web.RequestHandler):
 def get(self, user_id):
  self.write(f"User ID: {user_id}")

app = tornado.web.Application([
 (r"/user/([0-9]+)", UserHandler),
])

या उदाहरणात, /user/([0-9]+) हे /user/123 सारख्या URLs शी जुळते. ([0-9]+) हा भाग एक किंवा अधिक अंक कॅप्चर करतो आणि त्यांना UserHandler च्या get मेथडला user_id आर्ग्युमेंट म्हणून पास करतो.

टेम्पलेटिंग

टोर्नेडोमध्ये एक साधे आणि कार्यक्षम टेम्पलेटिंग इंजिन समाविष्ट आहे. टेम्पलेट्सचा वापर डायनॅमिकली HTML तयार करण्यासाठी केला जातो, ज्यामुळे प्रेझेंटेशन लॉजिक ॲप्लिकेशन लॉजिकपासून वेगळे होते.

टेम्पलेट्स तयार करणे:

टेम्पलेट्स सामान्यतः वेगळ्या फाइल्समध्ये (उदा. index.html) संग्रहित केल्या जातात. येथे एक साधे उदाहरण आहे:

<!DOCTYPE html>
<html>
<head>
 <title>My Website</title>
</head>
<body>
 <h1>Welcome, {{ name }}!</h1>
 <p>Today is {{ today }}.</p>
</body>
</html>

{{ name }} आणि {{ today }} हे प्लेसहोल्डर्स आहेत जे टेम्पलेट रेंडर झाल्यावर वास्तविक मूल्यांनी बदलले जातील.

टेम्पलेट्स रेंडर करणे:

टेम्पलेट रेंडर करण्यासाठी, तुमच्या रिक्वेस्ट हँडलरमध्ये render() मेथड वापरा:

class TemplateHandler(tornado.web.RequestHandler):
 def get(self):
  name = "John Doe"
  today = "2023-10-27"
  self.render("index.html", name=name, today=today)

तुमच्या ॲप्लिकेशन सेटिंग्जमध्ये template_path सेटिंग योग्यरित्या कॉन्फिगर केले आहे याची खात्री करा. डीफॉल्टनुसार, टोर्नेडो तुमच्या ॲप्लिकेशन फाइलच्या डिरेक्टरीमध्ये templates नावाच्या डिरेक्टरीमध्ये टेम्पलेट्स शोधतो.

app = tornado.web.Application([
 (r"/template", TemplateHandler),
], template_path="templates")

टेम्पलेट सिंटॅक्स:

टोर्नेडो टेम्पलेट्स विविध वैशिष्ट्यांना सपोर्ट करतात, ज्यामध्ये समाविष्ट आहे:

असिंक्रोनस ऑपरेशन्स

टोर्नेडोची ताकद त्याच्या असिंक्रोनस क्षमतांमध्ये आहे. असिंक्रोनस ऑपरेशन्स तुमच्या ॲप्लिकेशनला नॉन-ब्लॉकिंग I/O करण्यास परवानगी देतात, ज्यामुळे कार्यक्षमता आणि स्केलेबिलिटी सुधारते. हे विशेषतः अशा कामांसाठी उपयुक्त आहे ज्यात बाह्य संसाधनांची प्रतीक्षा करणे समाविष्ट असते, जसे की डेटाबेस क्वेरी किंवा नेटवर्क रिक्वेस्ट्स.

@tornado.gen.coroutine:

@tornado.gen.coroutine डेकोरेटर तुम्हाला yield कीवर्ड वापरून असिंक्रोनस कोड लिहिण्याची परवानगी देतो. यामुळे असिंक्रोनस कोड सिंक्रोनस कोडसारखा दिसतो आणि वागतो, ज्यामुळे वाचनीयता आणि देखभालक्षमता सुधारते.

import tornado.gen
import tornado.httpclient

class AsyncHandler(tornado.web.RequestHandler):
 @tornado.gen.coroutine
 def get(self):
  http_client = tornado.httpclient.AsyncHTTPClient()
  response = yield http_client.fetch("http://example.com")
  self.write(response.body.decode('utf-8'))

या उदाहरणात, http_client.fetch() हे एक असिंक्रोनस ऑपरेशन आहे जे एक Future परत करते. yield कीवर्ड Future निराकरण होईपर्यंत कोरूटीनची अंमलबजावणी थांबवतो. एकदा Future निराकरण झाल्यावर, कोरूटीन पुन्हा सुरू होते आणि रिस्पॉन्स बॉडी क्लायंटला लिहिली जाते.

tornado.concurrent.Future:

एक Future एका असिंक्रोनस ऑपरेशनच्या परिणामाचे प्रतिनिधित्व करते जे अद्याप उपलब्ध नसेल. तुम्ही असिंक्रोनस ऑपरेशन्स एकत्र जोडण्यासाठी आणि त्रुटी हाताळण्यासाठी Future ऑब्जेक्ट्स वापरू शकता.

tornado.ioloop.IOLoop:

IOLoop हे टोर्नेडोच्या असिंक्रोनस इंजिनचे हृदय आहे. ते इव्हेंट्ससाठी फाइल डिस्क्रिप्टर्स आणि सॉकेट्सचे निरीक्षण करते आणि त्यांना योग्य हँडलर्सकडे पाठवते. तुम्हाला सामान्यतः IOLoop शी थेट संवाद साधण्याची आवश्यकता नसते, परंतु असिंक्रोनस ऑपरेशन्स हाताळण्यात त्याची भूमिका समजून घेणे महत्त्वाचे आहे.

वेबसॉकेट्स

टोर्नेडो वेबसॉकेट्ससाठी उत्कृष्ट सपोर्ट प्रदान करते, ज्यामुळे सर्व्हर आणि क्लायंटमध्ये रिअल-टाइम कम्युनिकेशन शक्य होते. वेबसॉकेट्स अशा ॲप्लिकेशन्ससाठी आदर्श आहेत ज्यांना द्विदिशात्मक, कमी-लेटेंसी कम्युनिकेशनची आवश्यकता असते, जसे की चॅट ॲप्लिकेशन्स, ऑनलाइन गेम्स आणि रिअल-टाइम डॅशबोर्ड.

वेबसॉकेट हँडलर तयार करणे:

वेबसॉकेट हँडलर तयार करण्यासाठी, tornado.websocket.WebSocketHandler चा सबक्लास तयार करा आणि खालील मेथड्स लागू करा:

import tornado.websocket

class WebSocketHandler(tornado.websocket.WebSocketHandler):
 def open(self):
  print("WebSocket opened")

 def on_message(self, message):
  self.write_message(f"You sent: {message}")

 def on_close(self):
  print("WebSocket closed")

 def check_origin(self, origin):
  return True # Enable cross-origin WebSocket connections

तुमच्या ॲप्लिकेशनमध्ये वेबसॉकेट्स समाकलित करणे:

तुमच्या ॲप्लिकेशनच्या राउटिंग कॉन्फिगरेशनमध्ये वेबसॉकेट हँडलर जोडा:

app = tornado.web.Application([
 (r"/ws", WebSocketHandler),
])

क्लायंट-साइड अंमलबजावणी:

क्लायंट-साइडला, तुम्ही वेबसॉकेट कनेक्शन स्थापित करण्यासाठी आणि संदेश पाठवण्यासाठी/प्राप्त करण्यासाठी JavaScript वापरू शकता:

const websocket = new WebSocket("ws://localhost:8888/ws");

websocket.onopen = () => {
 console.log("WebSocket connection established");
 websocket.send("Hello from the client!");
};

websocket.onmessage = (event) => {
 console.log("Received message:", event.data);
};

websocket.onclose = () => {
 console.log("WebSocket connection closed");
};

ऑथेंटिकेशन आणि सुरक्षा

सुरक्षितता हा वेब ॲप्लिकेशन डेव्हलपमेंटचा एक महत्त्वाचा पैलू आहे. टोर्नेडो तुम्हाला तुमचे ॲप्लिकेशन्स सुरक्षित करण्यात मदत करण्यासाठी अनेक वैशिष्ट्ये प्रदान करते, ज्यात ऑथेंटिकेशन, ऑथोरायझेशन आणि सामान्य वेब असुरक्षिततेपासून संरक्षण समाविष्ट आहे.

ऑथेंटिकेशन:

ऑथेंटिकेशन ही वापरकर्त्याची ओळख सत्यापित करण्याची प्रक्रिया आहे. टोर्नेडो विविध ऑथेंटिकेशन योजनांसाठी अंगभूत समर्थन प्रदान करते, ज्यात समाविष्ट आहे:

ऑथोरायझेशन:

ऑथोरायझेशन ही प्रक्रिया आहे ज्याद्वारे वापरकर्त्याला विशिष्ट संसाधनावर प्रवेश करण्याची परवानगी आहे की नाही हे ठरवले जाते. तुम्ही वापरकर्त्याच्या भूमिका किंवा परवानग्यांच्या आधारावर प्रवेश प्रतिबंधित करण्यासाठी तुमच्या रिक्वेस्ट हँडलरमध्ये ऑथोरायझेशन लॉजिक लागू करू शकता.

सुरक्षेसाठी सर्वोत्तम पद्धती:

डिप्लॉयमेंट

टोर्नेडो ॲप्लिकेशन डिप्लॉय करण्यामध्ये अनेक पायऱ्यांचा समावेश असतो, ज्यात वेब सर्व्हर कॉन्फिगर करणे, प्रोसेस मॅनेजर सेट करणे आणि कार्यक्षमता ऑप्टिमाइझ करणे समाविष्ट आहे.

वेब सर्व्हर:

तुम्ही Nginx किंवा Apache सारख्या वेब सर्व्हरच्या मागे टोर्नेडो डिप्लॉय करू शकता. वेब सर्व्हर एक रिव्हर्स प्रॉक्सी म्हणून काम करतो, येणाऱ्या रिक्वेस्ट्सना टोर्नेडो ॲप्लिकेशनकडे फॉरवर्ड करतो.

प्रोसेस मॅनेजर:

Supervisor किंवा systemd सारखा प्रोसेस मॅनेजर टोर्नेडो प्रोसेस व्यवस्थापित करण्यासाठी वापरला जाऊ शकतो, हे सुनिश्चित करतो की ती क्रॅश झाल्यास स्वयंचलितपणे रीस्टार्ट होईल.

कार्यक्षमता ऑप्टिमायझेशन:

आंतरराष्ट्रीयीकरण (i18n) आणि स्थानिकीकरण (l10n)

जागतिक प्रेक्षकांसाठी ॲप्लिकेशन्स तयार करताना, आंतरराष्ट्रीयीकरण (i18n) आणि स्थानिकीकरण (l10n) विचारात घेणे महत्त्वाचे आहे. i18n म्हणजे अभियांत्रिकी बदलांशिवाय विविध भाषा आणि प्रदेशांशी जुळवून घेता येईल अशा प्रकारे ॲप्लिकेशन डिझाइन करण्याची प्रक्रिया. l10n म्हणजे आंतरराष्ट्रीयीकृत ॲप्लिकेशनला विशिष्ट भाषा किंवा प्रदेशासाठी स्थानिक-विशिष्ट घटक जोडून आणि मजकूर भाषांतरित करून अनुकूल करण्याची प्रक्रिया.

टोर्नेडो आणि i18n/l10n

टोर्नेडोमध्ये अंगभूत i18n/l10n लायब्ररी नाहीत. तथापि, तुम्ही तुमच्या टोर्नेडो ॲप्लिकेशनमध्ये i18n/l10n हाताळण्यासाठी `gettext` सारख्या मानक पायथन लायब्ररी किंवा Babel सारख्या अधिक अत्याधुनिक फ्रेमवर्क सहजपणे समाकलित करू शकता.

`gettext` वापरून उदाहरण:

1. **तुमचे लोकेल सेट करा:** तुम्ही समर्थन करू इच्छित असलेल्या प्रत्येक भाषेसाठी डिरेक्टरी तयार करा, ज्यात संदेश कॅटलॉग (सामान्यतः `.mo` फाइल्स) असतील.

locales/
 en/LC_MESSAGES/messages.mo
 fr/LC_MESSAGES/messages.mo
 de/LC_MESSAGES/messages.mo

2. **भाषांतर करण्यायोग्य स्ट्रिंग्स काढा:** तुमच्या पायथन कोडमधून भाषांतर करण्यायोग्य स्ट्रिंग्स `.po` फाइलमध्ये (पोर्टेबल ऑब्जेक्ट) काढण्यासाठी `xgettext` सारखे साधन वापरा. या फाइलमध्ये मूळ स्ट्रिंग्स आणि भाषांतरांसाठी प्लेसहोल्डर असतील.

xgettext -d messages -o locales/messages.po your_tornado_app.py

3. **स्ट्रिंग्सचे भाषांतर करा:** प्रत्येक भाषेसाठी `.po` फाइल्समधील स्ट्रिंग्सचे भाषांतर करा.

4. **भाषांतरे कंपाईल करा:** `.po` फाइल्सना `.mo` फाइल्समध्ये (मशीन ऑब्जेक्ट) कंपाईल करा जे रनटाइमवर `gettext` द्वारे वापरले जातात.

msgfmt locales/fr/LC_MESSAGES/messages.po -o locales/fr/LC_MESSAGES/messages.mo

5. **तुमच्या टोर्नेडो ॲप्लिकेशनमध्ये समाकलित करा:**

import gettext
import locale
import os
import tornado.web

class BaseHandler(tornado.web.RequestHandler):
 def initialize(self):
  try:
  locale.setlocale(locale.LC_ALL, self.get_user_locale().code)
  except locale.Error:
  # Handle cases where the locale is not supported by the system
  print(f"Locale {self.get_user_locale().code} not supported")

  translation = gettext.translation('messages', 'locales', languages=[self.get_user_locale().code])
  translation.install()
  self._ = translation.gettext

 def get_current_user_locale(self):
  # Logic to determine user's locale (e.g., from Accept-Language header, user settings, etc.)
  # This is a simplified example - you'll need a more robust solution
  accept_language = self.request.headers.get('Accept-Language', 'en')
  return tornado.locale.get(accept_language.split(',')[0].split(';')[0])

class MainHandler(BaseHandler):
 def get(self):
  self.render("index.html", _=self._)

settings = {
 "template_path": os.path.join(os.path.dirname(__file__), "templates"),
}

app = tornado.web.Application([
 (r"/", MainHandler),
], **settings)

6. **तुमचे टेम्पलेट्स सुधारित करा:** तुमच्या टेम्पलेट्समध्ये भाषांतरासाठी स्ट्रिंग्स चिन्हांकित करण्यासाठी `_()` फंक्शन (`gettext.gettext` शी बांधील) वापरा.

<h1>{{ _("Welcome to our website!") }}</h1>
<p>{{ _("This is a translated paragraph.") }}</p>

जागतिक प्रेक्षकांसाठी महत्त्वाचे विचार:

प्रगत विषय

कस्टम एरर पेजेस:

त्रुटी आढळल्यास टोर्नेडोद्वारे प्रदर्शित होणारी एरर पेजेस तुम्ही कस्टमाइझ करू शकता. हे तुम्हाला अधिक वापरकर्ता-अनुकूल अनुभव प्रदान करण्यास आणि डीबगिंग माहिती समाविष्ट करण्यास अनुमती देते.

कस्टम सेटिंग्ज:

तुम्ही तुमच्या ॲप्लिकेशन कॉन्फिगरेशनमध्ये कस्टम सेटिंग्ज परिभाषित करू शकता आणि तुमच्या रिक्वेस्ट हँडलरमध्ये त्यामध्ये प्रवेश करू शकता. हे ॲप्लिकेशन-विशिष्ट पॅरामीटर्स संग्रहित करण्यासाठी उपयुक्त आहे, जसे की डेटाबेस कनेक्शन स्ट्रिंग्स किंवा API कीज.

चाचणी:

तुमचे टोर्नेडो ॲप्लिकेशन्स योग्यरित्या आणि सुरक्षितपणे कार्यरत आहेत याची खात्री करण्यासाठी त्यांची कसून चाचणी घ्या. तुमच्या ॲप्लिकेशनच्या सर्व पैलूंचा समावेश करण्यासाठी युनिट टेस्ट, इंटिग्रेशन टेस्ट आणि एंड-टू-एंड टेस्ट वापरा.

निष्कर्ष

टोर्नेडो एक शक्तिशाली आणि बहुमुखी वेब फ्रेमवर्क आहे जे स्केलेबल, उच्च-कार्यक्षमता असलेले वेब ॲप्लिकेशन्स तयार करण्यासाठी सुयोग्य आहे. त्याचे असिंक्रोनस आर्किटेक्चर, वेबसॉकेट सपोर्ट आणि वापरण्यास-सोपे API यामुळे ते जगभरातील डेव्हलपर्ससाठी एक लोकप्रिय पर्याय आहे. या सर्वसमावेशक मार्गदर्शकातील मार्गदर्शक तत्त्वे आणि उदाहरणांचे अनुसरण करून, तुम्ही तुमचे स्वतःचे टोर्नेडो ॲप्लिकेशन्स तयार करणे सुरू करू शकता आणि त्याच्या अनेक वैशिष्ट्यांचा लाभ घेऊ शकता.

सर्वात अद्ययावत माहिती आणि सर्वोत्तम पद्धतींसाठी अधिकृत टोर्नेडो डॉक्युमेंटेशनचा संदर्भ घ्यायला विसरू नका. हॅपी कोडिंग!

टोर्नेडो डॉक्युमेंटेशन: जगभरातील डेव्हलपर्ससाठी एक सर्वसमावेशक मार्गदर्शक | MLOG