M

MLOG

हिन्दी

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

टॉरनेडो दस्तावेज़ीकरण: दुनिया भर के डेवलपर्स के लिए एक व्यापक गाइड

टॉरनेडो एक पायथन वेब फ्रेमवर्क और एसिंक्रोनस नेटवर्किंग लाइब्रेरी है, जिसे मूल रूप से FriendFeed में विकसित किया गया था। यह विशेष रूप से लॉन्ग-पोलिंग, वेबसॉकेट, और अन्य एप्लिकेशनों के लिए उपयुक्त है जिनके लिए प्रत्येक उपयोगकर्ता के साथ एक लंबे समय तक चलने वाले कनेक्शन की आवश्यकता होती है। इसका नॉन-ब्लॉकिंग नेटवर्क 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),
])

क्लाइंट-साइड कार्यान्वयन:

क्लाइंट-साइड पर, आप एक वेबसॉकेट कनेक्शन स्थापित करने और संदेश भेजने/प्राप्त करने के लिए जावास्क्रिप्ट का उपयोग कर सकते हैं:

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 इसे दुनिया भर के डेवलपर्स के लिए एक लोकप्रिय विकल्प बनाते हैं। इस व्यापक गाइड में दिए गए दिशानिर्देशों और उदाहरणों का पालन करके, आप अपने स्वयं के टॉरनेडो एप्लिकेशन बनाना शुरू कर सकते हैं और इसकी कई विशेषताओं का लाभ उठा सकते हैं।

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