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

ನಿಮ್ಮ ಮೊದಲ ಟೊರ್ನಾಡೊ ಅಪ್ಲಿಕೇಶನ್

ಟೊರ್ನಾಡೊದೊಂದಿಗೆ ಸರಳವಾದ "ಹಲೋ, ವರ್ಲ್ಡ್!" ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸೋಣ. 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 ವಿನಂತಿಗಳನ್ನು ಹೇಗೆ ನಿಭಾಯಿಸಬೇಕು ಎಂಬುದನ್ನು ಅವು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತವೆ. ರೂಟಿಂಗ್ URL ಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ.

ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು:

ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ರಚಿಸಲು, 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 ನಂತಹ URL ಗಳೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ. ([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 ಇದನ್ನು ವಿಶ್ವಾದ್ಯಂತ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಜನಪ್ರಿಯ ಆಯ್ಕೆಯಾಗಿಸಿದೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿನ ಮಾರ್ಗಸೂಚಿಗಳು ಮತ್ತು ಉದಾಹರಣೆಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನೀವು ನಿಮ್ಮ ಸ್ವಂತ ಟೊರ್ನಾಡೊ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಪ್ರಾರಂಭಿಸಬಹುದು ಮತ್ತು ಅದರ ಅನೇಕ ವೈಶಿಷ್ಟ್ಯಗಳ ಲಾಭವನ್ನು ಪಡೆಯಬಹುದು.

ಅತ್ಯಂತ ನವೀಕೃತ ಮಾಹಿತಿ ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳಿಗಾಗಿ ಅಧಿಕೃತ ಟೊರ್ನಾಡೊ ದಸ್ತಾವೇಜನ್ನು ಸಂಪರ್ಕಿಸಲು ಮರೆಯದಿರಿ. ಸಂತೋಷದ ಕೋಡಿಂಗ್!