ಟೊರ್ನಾಡೊ ಡಾಕ್ಯುಮೆಂಟೇಶನ್: ವಿಶ್ವಾದ್ಯಂತ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ

ಟೊರ್ನಾಡೊ ಒಂದು ಪೈಥಾನ್ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಮತ್ತು ಅಸಿಂಕ್ರೊನಸ್ ನೆಟ್‌ವರ್ಕಿಂಗ್ ಲೈಬ್ರರಿಯಾಗಿದ್ದು, ಮೂಲತಃ ಫ್ರೆಂಡ್‌ಫೀಡ್‌ನಲ್ಲಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ. ಇದು ವಿಶೇಷವಾಗಿ ಲಾಂಗ್-ಪೋಲಿಂಗ್, ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳು, ಮತ್ತು ಪ್ರತಿ ಬಳಕೆದಾರರಿಗೆ ದೀರ್ಘಕಾಲದ ಸಂಪರ್ಕದ ಅಗತ್ಯವಿರುವ ಇತರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ. ಇದರ ನಾನ್-ಬ್ಲಾಕಿಂಗ್ ನೆಟ್‌ವರ್ಕ್ I/O ಇದನ್ನು ಅತ್ಯಂತ ಸ್ಕೇಲೆಬಲ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಉನ್ನತ-ಕಾರ್ಯಕ್ಷಮತೆಯ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಇದು ಒಂದು ಶಕ್ತಿಶಾಲಿ ಆಯ್ಕೆಯಾಗಿದೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ಟೊರ್ನಾಡೊದ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳ ಮೂಲಕ ನಿಮ್ಮನ್ನು ಕರೆದೊಯ್ಯುತ್ತದೆ ಮತ್ತು ನಿಮಗೆ ಪ್ರಾರಂಭಿಸಲು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಟೊರ್ನಾಡೊ ಎಂದರೇನು?

ಮೂಲಭೂತವಾಗಿ, ಟೊರ್ನಾಡೊ ಒಂದು ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಮತ್ತು ಅಸಿಂಕ್ರೊನಸ್ ನೆಟ್‌ವರ್ಕಿಂಗ್ ಲೈಬ್ರರಿಯಾಗಿದೆ. ಸಾಂಪ್ರದಾಯಿಕ ಸಿಂಕ್ರೊನಸ್ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, ಟೊರ್ನಾಡೊ ಸಿಂಗಲ್-ಥ್ರೆಡೆಡ್, ಈವೆಂಟ್-ಲೂಪ್ ಆಧಾರಿತ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಇದರರ್ಥ ಇದು ಪ್ರತಿ ಸಂಪರ್ಕಕ್ಕೆ ಒಂದು ಥ್ರೆಡ್ ಅಗತ್ಯವಿಲ್ಲದೇ ಅನೇಕ ಏಕಕಾಲೀನ ಸಂಪರ್ಕಗಳನ್ನು ನಿಭಾಯಿಸಬಲ್ಲದು, ಇದು ಹೆಚ್ಚು ದಕ್ಷ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಮಾಡುತ್ತದೆ.

ಟೊರ್ನಾಡೊದ ಪ್ರಮುಖ ವೈಶಿಷ್ಟ್ಯಗಳು:

• ಅಸಿಂಕ್ರೊನಸ್ ನೆಟ್‌ವರ್ಕಿಂಗ್: ಟೊರ್ನಾಡೊದ ತಿರುಳು ಅಸಿಂಕ್ರೊನಸ್ I/O ಸುತ್ತಲೂ ನಿರ್ಮಿಸಲ್ಪಟ್ಟಿದೆ, ಇದು ಸಾವಿರಾರು ಏಕಕಾಲೀನ ಸಂಪರ್ಕಗಳನ್ನು ದಕ್ಷತೆಯಿಂದ ನಿಭಾಯಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
• ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್: ಇದು ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು, ರೂಟಿಂಗ್, ಟೆಂಪ್ಲೇಟಿಂಗ್, ಮತ್ತು ದೃಢೀಕರಣದಂತಹ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದು ಒಂದು ಸಂಪೂರ್ಣ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದೆ.
• ವೆಬ್‌ಸಾಕೆಟ್ ಬೆಂಬಲ: ಟೊರ್ನಾಡೊ ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳಿಗೆ ಅತ್ಯುತ್ತಮ ಬೆಂಬಲವನ್ನು ನೀಡುತ್ತದೆ, ಸರ್ವರ್ ಮತ್ತು ಕ್ಲೈಂಟ್‌ಗಳ ನಡುವೆ ರಿಯಲ್-ಟೈಮ್ ಸಂವಹನವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
• ಹಗುರ ಮತ್ತು ವೇಗ: ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಟೊರ್ನಾಡೊ ಹಗುರ ಮತ್ತು ದಕ್ಷವಾಗಿದೆ, ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಥ್ರೋಪುಟ್ ಅನ್ನು ಗರಿಷ್ಠಗೊಳಿಸುತ್ತದೆ.
• ಬಳಸಲು ಸುಲಭ: ಅದರ ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳ ಹೊರತಾಗಿಯೂ, ಟೊರ್ನಾಡೊ ಸ್ಪಷ್ಟ ಮತ್ತು ಉತ್ತಮವಾಗಿ ದಾಖಲಿತ API ಯೊಂದಿಗೆ ಕಲಿಯಲು ಮತ್ತು ಬಳಸಲು ತುಲನಾತ್ಮಕವಾಗಿ ಸುಲಭವಾಗಿದೆ.

ನಿಮ್ಮ ಟೊರ್ನಾಡೊ ಪರಿಸರವನ್ನು ಸ್ಥಾಪಿಸುವುದು

ಟೊರ್ನಾಡೊ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಮುಳುಗುವ ಮೊದಲು, ನೀವು ನಿಮ್ಮ ಪರಿಸರವನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗುತ್ತದೆ. ಇಲ್ಲಿ ಹಂತ-ಹಂತದ ಮಾರ್ಗದರ್ಶಿಯಿದೆ:

1. ಪೈಥಾನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ: ನಿಮ್ಮಲ್ಲಿ ಪೈಥಾನ್ 3.6 ಅಥವಾ ಹೆಚ್ಚಿನ ಆವೃತ್ತಿ ಸ್ಥಾಪನೆಯಾಗಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ನೀವು ಇದನ್ನು ಅಧಿಕೃತ ಪೈಥಾನ್ ವೆಬ್‌ಸೈಟ್‌ನಿಂದ (python.org) ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು.
2. ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ರಚಿಸಿ (ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ): ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗಾಗಿ ಪ್ರತ್ಯೇಕ ಪರಿಸರವನ್ನು ರಚಿಸಲು venv ಅಥವಾ virtualenv ಬಳಸಿ:

               python3 -m venv myenv
   source myenv/bin/activate  # On Linux/macOS
   myenv\Scripts\activate  # On Windows
               
   
                 
                   Copy
                 
               
             

3. ಟೊರ್ನಾಡೊ ಸ್ಥಾಪಿಸಿ: pip ಬಳಸಿ ಟೊರ್ನಾಡೊ ಸ್ಥಾಪಿಸಿ:

               pip install tornado
               
   
                 
                   Copy
                 
               
             

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

ಟೊರ್ನಾಡೊದೊಂದಿಗೆ ಸರಳವಾದ "ಹಲೋ, ವರ್ಲ್ಡ್!" ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸೋಣ. 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()
            

              
                Copy
              
            
          

ಈಗ, ನಿಮ್ಮ ಟರ್ಮಿನಲ್‌ನಿಂದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಿ:

            python app.py
            

              
                Copy
              
            
          

ನಿಮ್ಮ ವೆಬ್ ಬ್ರೌಸರ್ ತೆರೆದು http://localhost:8888 ಗೆ ಹೋಗಿ. ನೀವು "Hello, World!" ಸಂದೇಶವನ್ನು ನೋಡಬೇಕು.

ವಿವರಣೆ:

• tornado.ioloop: ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿಭಾಯಿಸುವ ಪ್ರಮುಖ ಈವೆಂಟ್ ಲೂಪ್.
• tornado.web: ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಘಟಕಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು ಮತ್ತು ರೂಟಿಂಗ್.
• MainHandler: ಒಳಬರುವ HTTP ವಿನಂತಿಗಳನ್ನು ಹೇಗೆ ನಿಭಾಯಿಸಬೇಕು ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್. GET ವಿನಂತಿಗಳಿಗಾಗಿ get() ವಿಧಾನವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.
• tornado.web.Application: ಟೊರ್ನಾಡೊ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, URL ಮಾದರಿಗಳನ್ನು ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ.
• app.listen(8888): ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಪೋರ್ಟ್ 8888 ನಲ್ಲಿ ಒಳಬರುವ ಸಂಪರ್ಕಗಳನ್ನು ಆಲಿಸುತ್ತದೆ.
• tornado.ioloop.IOLoop.current().start(): ಈವೆಂಟ್ ಲೂಪ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಇದು ಒಳಬರುವ ವಿನಂತಿಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ.

ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು ಮತ್ತು ರೂಟಿಂಗ್

ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು ಟೊರ್ನಾಡೊ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಅಡಿಪಾಯ. 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}")
            

              
                Copy
              
            
          

ರೂಟಿಂಗ್:

tornado.web.Application ಅನ್ನು ರಚಿಸುವಾಗ ರೂಟಿಂಗ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗುತ್ತದೆ. ನೀವು ಟ್ಯೂಪಲ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಒದಗಿಸುತ್ತೀರಿ, ಅಲ್ಲಿ ಪ್ರತಿ ಟ್ಯೂಪಲ್ ಒಂದು URL ಮಾದರಿ ಮತ್ತು ಅದಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ.

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

              
                Copy
              
            
          

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),
])
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, /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>
            

              
                Copy
              
            
          

{{ 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)
            

              
                Copy
              
            
          

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ template_path ಸೆಟ್ಟಿಂಗ್ ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಆಗಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಟೊರ್ನಾಡೊ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಫೈಲ್ ಇರುವ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ templates ಎಂಬ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ಹುಡುಕುತ್ತದೆ.

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

              
                Copy
              
            
          

ಟೆಂಪ್ಲೇಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್:

ಟೊರ್ನಾಡೊ ಟೆಂಪ್ಲೇಟ್‌ಗಳು ವಿವಿಧ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆ, ಅವುಗಳೆಂದರೆ:

• ವೇರಿಯೇಬಲ್‌ಗಳು: {{ variable }}
• ಕಂಟ್ರೋಲ್ ಫ್ಲೋ: {% if condition %} ... {% else %} ... {% end %}, {% for item in items %} ... {% end %}
• ಫಂಕ್ಷನ್‌ಗಳು: {{ function(argument) }}
• ಇನ್‌ಕ್ಲೂಡ್‌ಗಳು: {% include "another_template.html" %}
• ಎಸ್ಕೇಪಿಂಗ್: ಕ್ರಾಸ್-ಸೈಟ್ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ (XSS) ದಾಳಿಗಳನ್ನು ತಡೆಯಲು ಟೊರ್ನಾಡೊ ಸ್ವಯಂಚಾಲಿತವಾಗಿ HTML ಎಂಟಿಟಿಗಳನ್ನು ಎಸ್ಕೇಪ್ ಮಾಡುತ್ತದೆ. {% raw variable %} ಬಳಸಿ ನೀವು ಎಸ್ಕೇಪಿಂಗ್ ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಬಹುದು.

ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು

ಟೊರ್ನಾಡೊದ ಶಕ್ತಿ ಅದರ ಅಸಿಂಕ್ರೊನಸ್ ಸಾಮರ್ಥ್ಯಗಳಲ್ಲಿದೆ. ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ನಾನ್-ಬ್ಲಾಕಿಂಗ್ 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'))
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, http_client.fetch() ಒಂದು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದ್ದು ಅದು Future ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. yield ಕೀವರ್ಡ್ Future ಪರಿಹಾರವಾಗುವವರೆಗೆ ಕೊರೂಟೀನ್‌ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಅಮಾನತುಗೊಳಿಸುತ್ತದೆ. Future ಪರಿಹಾರವಾದ ನಂತರ, ಕೊರೂಟೀನ್ ಪುನರಾರಂಭಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯ ದೇಹವನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಬರೆಯಲಾಗುತ್ತದೆ.

tornado.concurrent.Future:

ಒಂದು Future ಇನ್ನೂ ಲಭ್ಯವಿಲ್ಲದ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಯ ಫಲಿತಾಂಶವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಒಟ್ಟಿಗೆ ಜೋಡಿಸಲು ಮತ್ತು ದೋಷಗಳನ್ನು ನಿಭಾಯಿಸಲು ನೀವು Future ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

tornado.ioloop.IOLoop:

IOLoop ಟೊರ್ನಾಡೊದ ಅಸಿಂಕ್ರೊನಸ್ ಎಂಜಿನ್‌ನ ಹೃದಯವಾಗಿದೆ. ಇದು ಈವೆಂಟ್‌ಗಳಿಗಾಗಿ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳು ಮತ್ತು ಸಾಕೆಟ್‌ಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಸೂಕ್ತ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಿಗೆ ರವಾನಿಸುತ್ತದೆ. ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ನೇರವಾಗಿ IOLoop ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ಅಗತ್ಯವಿಲ್ಲ, ಆದರೆ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಅದರ ಪಾತ್ರವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.

ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳು

ಟೊರ್ನಾಡೊ ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳಿಗೆ ಅತ್ಯುತ್ತಮ ಬೆಂಬಲವನ್ನು ನೀಡುತ್ತದೆ, ಸರ್ವರ್ ಮತ್ತು ಕ್ಲೈಂಟ್‌ಗಳ ನಡುವೆ ರಿಯಲ್-ಟೈಮ್ ಸಂವಹನವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಚಾಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು, ಆನ್‌ಲೈನ್ ಆಟಗಳು ಮತ್ತು ರಿಯಲ್-ಟೈಮ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗಳಂತಹ ದ್ವಿಮುಖ, ಕಡಿಮೆ-ಲೇಟೆನ್ಸಿ ಸಂವಹನದ ಅಗತ್ಯವಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳು ಸೂಕ್ತವಾಗಿವೆ.

ವೆಬ್‌ಸಾಕೆಟ್ ಹ್ಯಾಂಡ್ಲರ್ ರಚಿಸುವುದು:

ವೆಬ್‌ಸಾಕೆಟ್ ಹ್ಯಾಂಡ್ಲರ್ ರಚಿಸಲು, tornado.websocket.WebSocketHandler ನ ಸಬ್‌ಕ್ಲಾಸ್ ಮಾಡಿ ಮತ್ತು ಕೆಳಗಿನ ವಿಧಾನಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ:

• open(): ಹೊಸ ವೆಬ್‌ಸಾಕೆಟ್ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸಿದಾಗ ಕರೆಯಲಾಗುತ್ತದೆ.
• on_message(message): ಕ್ಲೈಂಟ್‌ನಿಂದ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ ಕರೆಯಲಾಗುತ್ತದೆ.
• on_close(): ವೆಬ್‌ಸಾಕೆಟ್ ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚಿದಾಗ ಕರೆಯಲಾಗುತ್ತದೆ.

            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
            

              
                Copy
              
            
          

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು:

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ರೂಟಿಂಗ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗೆ ವೆಬ್‌ಸಾಕೆಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಸೇರಿಸಿ:

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

              
                Copy
              
            
          

ಕ್ಲೈಂಟ್-ಸೈಡ್ ಅನುಷ್ಠಾನ:

ಕ್ಲೈಂಟ್-ಸೈಡ್‌ನಲ್ಲಿ, ವೆಬ್‌ಸಾಕೆಟ್ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸಲು ಮತ್ತು ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಲು/ಸ್ವೀಕರಿಸಲು ನೀವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸಬಹುದು:

            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");
};
            

              
                Copy
              
            
          

ದೃಢೀಕರಣ ಮತ್ತು ಭದ್ರತೆ

ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಭದ್ರತೆ ಒಂದು ನಿರ್ಣಾಯಕ ಅಂಶವಾಗಿದೆ. ದೃಢೀಕರಣ, ಅಧಿಕಾರ, ಮತ್ತು ಸಾಮಾನ್ಯ ವೆಬ್ ದುರ್ಬಲತೆಗಳ ವಿರುದ್ಧ ರಕ್ಷಣೆ ಸೇರಿದಂತೆ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಸುರಕ್ಷಿತಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡಲು ಟೊರ್ನಾಡೊ ಹಲವಾರು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

ದೃಢೀಕರಣ:

ದೃಢೀಕರಣವು ಬಳಕೆದಾರರ ಗುರುತನ್ನು ಪರಿಶೀಲಿಸುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. ಟೊರ್ನಾಡೊ ವಿವಿಧ ದೃಢೀಕರಣ ಯೋಜನೆಗಳಿಗೆ ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅವುಗಳೆಂದರೆ:

• ಕುಕೀ-ಆಧಾರಿತ ದೃಢೀಕರಣ: ಕುಕೀಗಳಲ್ಲಿ ಬಳಕೆದಾರರ ರುಜುವಾತುಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ.
• ತೃತೀಯ ದೃಢೀಕರಣ (OAuth): ಗೂಗಲ್, ಫೇಸ್‌ಬುಕ್ ಮತ್ತು ಟ್ವಿಟರ್‌ನಂತಹ ಜನಪ್ರಿಯ ಸಾಮಾಜಿಕ ಮಾಧ್ಯಮ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ.
• API ಕೀಗಳು: API ವಿನಂತಿಗಳನ್ನು ದೃಢೀಕರಿಸಲು API ಕೀಗಳನ್ನು ಬಳಸಿ.

ಅಧಿಕಾರ:

ಅಧಿಕಾರವು ಬಳಕೆದಾರರಿಗೆ ನಿರ್ದಿಷ್ಟ ಸಂಪನ್ಮೂಲವನ್ನು ಪ್ರವೇಶಿಸಲು ಅನುಮತಿ ಇದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. ಬಳಕೆದಾರರ ಪಾತ್ರಗಳು ಅಥವಾ ಅನುಮತಿಗಳ ಆಧಾರದ ಮೇಲೆ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸಲು ನಿಮ್ಮ ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಲ್ಲಿ ಅಧಿಕಾರ ತರ್ಕವನ್ನು ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.

ಭದ್ರತೆಯ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು:

• ಕ್ರಾಸ್-ಸೈಟ್ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ (XSS) ರಕ್ಷಣೆ: XSS ದಾಳಿಗಳನ್ನು ತಡೆಯಲು ಟೊರ್ನಾಡೊ ಸ್ವಯಂಚಾಲಿತವಾಗಿ HTML ಎಂಟಿಟಿಗಳನ್ನು ಎಸ್ಕೇಪ್ ಮಾಡುತ್ತದೆ. ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ರೆಂಡರ್ ಮಾಡಲು ಯಾವಾಗಲೂ render() ವಿಧಾನವನ್ನು ಬಳಸಿ ಮತ್ತು ನಿಮ್ಮ ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಲ್ಲಿ ನೇರವಾಗಿ HTML ರಚಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ.
• ಕ್ರಾಸ್-ಸೈಟ್ ರಿಕ್ವೆಸ್ಟ್ ಫೋರ್ಜರಿ (CSRF) ರಕ್ಷಣೆ: CSRF ದಾಳಿಗಳನ್ನು ತಡೆಯಲು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ CSRF ರಕ್ಷಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ.
• HTTPS: ಸರ್ವರ್ ಮತ್ತು ಕ್ಲೈಂಟ್‌ಗಳ ನಡುವಿನ ಸಂವಹನವನ್ನು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಲು ಯಾವಾಗಲೂ HTTPS ಬಳಸಿ.
• ಇನ್‌ಪುಟ್ ಮೌಲ್ಯೀಕರಣ: ಇಂಜೆಕ್ಷನ್ ದಾಳಿಗಳು ಮತ್ತು ಇತರ ದುರ್ಬಲತೆಗಳನ್ನು ತಡೆಯಲು ಎಲ್ಲಾ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ.
• ನಿಯಮಿತ ಭದ್ರತಾ ಲೆಕ್ಕಪರಿಶೋಧನೆಗಳು: ಸಂಭಾವ್ಯ ದುರ್ಬಲತೆಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಪರಿಹರಿಸಲು ನಿಯಮಿತ ಭದ್ರತಾ ಲೆಕ್ಕಪರಿಶೋಧನೆಗಳನ್ನು ನಡೆಸಿ.

ನಿಯೋಜನೆ

ಟೊರ್ನಾಡೊ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸುವುದು ವೆಬ್ ಸರ್ವರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು, ಪ್ರೊಸೆಸ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು ಸೇರಿದಂತೆ ಹಲವಾರು ಹಂತಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

ವೆಬ್ ಸರ್ವರ್:

ನೀವು Nginx ಅಥವಾ Apache ನಂತಹ ವೆಬ್ ಸರ್ವರ್‌ನ ಹಿಂದೆ ಟೊರ್ನಾಡೊವನ್ನು ನಿಯೋಜಿಸಬಹುದು. ವೆಬ್ ಸರ್ವರ್ ರಿವರ್ಸ್ ಪ್ರಾಕ್ಸಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಒಳಬರುವ ವಿನಂತಿಗಳನ್ನು ಟೊರ್ನಾಡೊ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಫಾರ್ವರ್ಡ್ ಮಾಡುತ್ತದೆ.

ಪ್ರೊಸೆಸ್ ಮ್ಯಾನೇಜರ್:

Supervisor ಅಥವಾ systemd ನಂತಹ ಪ್ರೊಸೆಸ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಟೊರ್ನಾಡೊ ಪ್ರೊಸೆಸ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸಬಹುದು, ಅದು ಕ್ರ್ಯಾಶ್ ಆದರೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪುನರಾರಂಭಗೊಳ್ಳುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತದೆ.

ಕಾರ್ಯಕ್ಷಮತೆ ಆಪ್ಟಿಮೈಸೇಶನ್:

• ಉತ್ಪಾದನೆ-ಸಿದ್ಧ ಈವೆಂಟ್ ಲೂಪ್ ಬಳಸಿ: ಸುಧಾರಿತ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ uvloop ನಂತಹ ಉತ್ಪಾದನೆ-ಸಿದ್ಧ ಈವೆಂಟ್ ಲೂಪ್ ಬಳಸಿ.
• gzip ಕಂಪ್ರೆಷನ್ ಸಕ್ರಿಯಗೊಳಿಸಿ: HTTP ಪ್ರತಿಕ್ರಿಯೆಗಳ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು gzip ಕಂಪ್ರೆಷನ್ ಸಕ್ರಿಯಗೊಳಿಸಿ.
• ಸ್ಟಾಟಿಕ್ ಫೈಲ್‌ಗಳನ್ನು ಕ್ಯಾಶ್ ಮಾಡಿ: ಸರ್ವರ್ ಮೇಲಿನ ಲೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸ್ಟಾಟಿಕ್ ಫೈಲ್‌ಗಳನ್ನು ಕ್ಯಾಶ್ ಮಾಡಿ.
• ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ: New Relic ಅಥವಾ Prometheus ನಂತಹ ಸಾಧನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ.

ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (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
            

              
                Copy
              
            
          

2. **ಭಾಷಾಂತರಿಸಬಹುದಾದ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯಿರಿ:** ನಿಮ್ಮ ಪೈಥಾನ್ ಕೋಡ್‌ನಿಂದ ಭಾಷಾಂತರಿಸಬಹುದಾದ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು `.po` ಫೈಲ್‌ಗೆ (ಪೋರ್ಟಬಲ್ ಆಬ್ಜೆಕ್ಟ್) ಹೊರತೆಗೆಯಲು `xgettext` ನಂತಹ ಉಪಕರಣವನ್ನು ಬಳಸಿ. ಈ ಫೈಲ್ ಮೂಲ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಮತ್ತು ಅನುವಾದಗಳಿಗಾಗಿ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

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

              
                Copy
              
            
          

3. **ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಅನುವಾದಿಸಿ:** ಪ್ರತಿ ಭಾಷೆಗೆ `.po` ಫೈಲ್‌ಗಳಲ್ಲಿನ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಅನುವಾದಿಸಿ.

4. **ಅನುವಾದಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡಿ:** `.po` ಫೈಲ್‌ಗಳನ್ನು `.mo` ಫೈಲ್‌ಗಳಿಗೆ (ಮಷೀನ್ ಆಬ್ಜೆಕ್ಟ್) ಕಂಪೈಲ್ ಮಾಡಿ, ಇವುಗಳನ್ನು `gettext` ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಬಳಸುತ್ತದೆ.

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

              
                Copy
              
            
          

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)

            

              
                Copy
              
            
          

6. **ನಿಮ್ಮ ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ಮಾರ್ಪಡಿಸಿ:** ನಿಮ್ಮ ಟೆಂಪ್ಲೇಟ್‌ಗಳಲ್ಲಿ ಅನುವಾದಕ್ಕಾಗಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಗುರುತಿಸಲು `_()` ಫಂಕ್ಷನ್ ಬಳಸಿ (`gettext.gettext` ಗೆ ಬದ್ಧವಾಗಿದೆ).

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

            

              
                Copy
              
            
          

ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗೆ ಪ್ರಮುಖ ಪರಿಗಣನೆಗಳು:

• **ಅಕ್ಷರ ಎನ್‌ಕೋಡಿಂಗ್:** ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಅಕ್ಷರಗಳನ್ನು ಬೆಂಬಲಿಸಲು ಯಾವಾಗಲೂ UTF-8 ಎನ್‌ಕೋಡಿಂಗ್ ಬಳಸಿ.
• **ದಿನಾಂಕ ಮತ್ತು ಸಮಯ ಫಾರ್ಮ್ಯಾಟಿಂಗ್:** ಸ್ಥಳ-ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕ ಮತ್ತು ಸಮಯ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಬಳಸಿ. ಪೈಥಾನ್‌ನ `strftime` ಮತ್ತು `strptime` ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಲೋಕೇಲ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ ಬಳಸಬಹುದು.
• **ಸಂಖ್ಯೆ ಫಾರ್ಮ್ಯಾಟಿಂಗ್:** ಸ್ಥಳ-ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಬಳಸಿ (ಉದಾಹರಣೆಗೆ, ದಶಮಾಂಶ ವಿಭಜಕಗಳು, ಸಾವಿರಾರು ವಿಭಜಕಗಳು). `locale` ಮಾಡ್ಯೂಲ್ ಇದಕ್ಕಾಗಿ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
• **ಕರೆನ್ಸಿ ಫಾರ್ಮ್ಯಾಟಿಂಗ್:** ಸ್ಥಳ-ನಿರ್ದಿಷ್ಟ ಕರೆನ್ಸಿ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಬಳಸಿ. ಹೆಚ್ಚು ಮುಂದುವರಿದ ಕರೆನ್ಸಿ ನಿರ್ವಹಣೆಗಾಗಿ `Babel` ನಂತಹ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
• **ಬಲದಿಂದ-ಎಡಕ್ಕೆ (RTL) ಭಾಷೆಗಳು:** ಅರೇಬಿಕ್ ಮತ್ತು ಹೀಬ್ರೂನಂತಹ RTL ಭಾಷೆಗಳನ್ನು ಬೆಂಬಲಿಸಿ. ಇದು ನಿಮ್ಮ ವೆಬ್‌ಸೈಟ್‌ನ ಲೇಔಟ್ ಅನ್ನು ಪ್ರತಿಬಿಂಬಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರಬಹುದು.
• **ಅನುವಾದದ ಗುಣಮಟ್ಟ:** ನಿಖರ ಮತ್ತು ಸಾಂಸ್ಕೃತಿಕವಾಗಿ ಸೂಕ್ತವಾದ ಅನುವಾದಗಳನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ವೃತ್ತಿಪರ ಅನುವಾದಕರನ್ನು ಬಳಸಿ. ಯಂತ್ರ ಅನುವಾದ ಉತ್ತಮ ಆರಂಭಿಕ ಹಂತವಾಗಬಹುದು, ಆದರೆ ಅದಕ್ಕೆ ಮಾನವ ವಿಮರ್ಶೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ.
• **ಬಳಕೆದಾರರ ಲೋಕೇಲ್ ಪತ್ತೆ:** ಬಳಕೆದಾರರ ಆದ್ಯತೆಗಳು, ಬ್ರೌಸರ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು, ಅಥವಾ IP ವಿಳಾಸದ ಆಧಾರದ ಮೇಲೆ ದೃಢವಾದ ಲೋಕೇಲ್ ಪತ್ತೆಹಚ್ಚುವಿಕೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ. ಬಳಕೆದಾರರಿಗೆ ತಮ್ಮ ಆದ್ಯತೆಯ ಭಾಷೆಯನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಆಯ್ಕೆ ಮಾಡಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸಿ.
• **ಪರೀಕ್ಷೆ:** ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ಪ್ರದರ್ಶಿತವಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ವಿವಿಧ ಲೋಕೇಲ್‌ಗಳೊಂದಿಗೆ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ.

ಮುಂದುವರಿದ ವಿಷಯಗಳು

ಕಸ್ಟಮ್ ದೋಷ ಪುಟಗಳು:

ದೋಷ ಸಂಭವಿಸಿದಾಗ ಟೊರ್ನಾಡೊ ಪ್ರದರ್ಶಿಸುವ ದೋಷ ಪುಟಗಳನ್ನು ನೀವು ಕಸ್ಟಮೈಸ್ ಮಾಡಬಹುದು. ಇದು ನಿಮಗೆ ಹೆಚ್ಚು ಬಳಕೆದಾರ-ಸ್ನೇಹಿ ಅನುಭವವನ್ನು ಒದಗಿಸಲು ಮತ್ತು ಡೀಬಗ್ಗಿಂಗ್ ಮಾಹಿತಿಯನ್ನು ಸೇರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಕಸ್ಟಮ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು:

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ ನೀವು ಕಸ್ಟಮ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಮತ್ತು ನಿಮ್ಮ ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಲ್ಲಿ ಅವುಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಅಥವಾ API ಕೀಗಳಂತಹ ಅಪ್ಲಿಕೇಶನ್-ನಿರ್ದಿಷ್ಟ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಪರೀಕ್ಷೆ:

ನಿಮ್ಮ ಟೊರ್ನಾಡೊ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಸರಿಯಾಗಿ ಮತ್ತು ಸುರಕ್ಷಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿವೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅವುಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಒಳಗೊಳ್ಳಲು ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳು, ಇಂಟಿಗ್ರೇಷನ್ ಪರೀಕ್ಷೆಗಳು ಮತ್ತು ಎಂಡ್-ಟು-ಎಂಡ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಬಳಸಿ.

ತೀರ್ಮಾನ

ಟೊರ್ನಾಡೊ ಒಂದು ಶಕ್ತಿಯುತ ಮತ್ತು ಬಹುಮುಖ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದ್ದು, ಇದು ಸ್ಕೇಲೆಬಲ್, ಉನ್ನತ-ಕಾರ್ಯಕ್ಷಮತೆಯ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸೂಕ್ತವಾಗಿದೆ. ಅದರ ಅಸಿಂಕ್ರೊನಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್, ವೆಬ್‌ಸಾಕೆಟ್ ಬೆಂಬಲ, ಮತ್ತು ಬಳಸಲು ಸುಲಭವಾದ API ಇದನ್ನು ವಿಶ್ವಾದ್ಯಂತ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಜನಪ್ರಿಯ ಆಯ್ಕೆಯಾಗಿಸಿದೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿನ ಮಾರ್ಗಸೂಚಿಗಳು ಮತ್ತು ಉದಾಹರಣೆಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನೀವು ನಿಮ್ಮ ಸ್ವಂತ ಟೊರ್ನಾಡೊ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಪ್ರಾರಂಭಿಸಬಹುದು ಮತ್ತು ಅದರ ಅನೇಕ ವೈಶಿಷ್ಟ್ಯಗಳ ಲಾಭವನ್ನು ಪಡೆಯಬಹುದು.

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