டொர்னாடோ ஆவணப்படுத்தல்: உலகளாவிய டெவலப்பர்களுக்கான ஒரு விரிவான வழிகாட்டி

டொர்னாடோ என்பது ஒரு பைத்தான் வலைக் கட்டமைப்பு மற்றும் ஒத்திசைவற்ற நெட்வொர்க்கிங் நூலகமாகும், இது முதலில் FriendFeed-ல் உருவாக்கப்பட்டது. இது நீண்ட நேர வாக்கெடுப்பு (long-polling), வெப்சாக்கெட்டுகள் மற்றும் ஒவ்வொரு பயனருக்கும் நீண்டகால இணைப்பு தேவைப்படும் பிற பயன்பாடுகளுக்கு மிகவும் பொருத்தமானது. அதன் தடையற்ற நெட்வொர்க் 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

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!" செய்தியைக் காண வேண்டும்.

விளக்கம்:

• tornado.ioloop: ஒத்திசைவற்ற செயல்பாடுகளைக் கையாளும் முக்கிய நிகழ்வு வளையம்.
• tornado.web: கோரிக்கை கையாளுபவர்கள் மற்றும் வழித்தடங்கள் போன்ற வலைக் கட்டமைப்பு கூறுகளை வழங்குகிறது.
• MainHandler: உள்வரும் HTTP கோரிக்கைகளை எவ்வாறு கையாள்வது என்பதை வரையறுக்கும் ஒரு கோரிக்கை கையாளுபவர். GET கோரிக்கைகளுக்கு get() முறை அழைக்கப்படுகிறது.
• tornado.web.Application: URL வடிவங்களை கோரிக்கை கையாளுபவர்களுடன் பொருத்தி, டொர்னாடோ பயன்பாட்டை உருவாக்குகிறது.
• app.listen(8888): போர்ட் 8888-ல் உள்வரும் இணைப்புகளைக் கேட்டு, சேவையகத்தைத் தொடங்குகிறது.
• tornado.ioloop.IOLoop.current().start(): நிகழ்வு வளையத்தைத் தொடங்குகிறது, இது உள்வரும் கோரிக்கைகளைச் செயல்படுத்தி, ஒத்திசைவற்ற செயல்பாடுகளைக் கையாளுகிறது.

கோரிக்கை கையாளுபவர்கள் மற்றும் வழித்தடங்கள்

கோரிக்கை கையாளுபவர்கள் டொர்னாடோ வலைப் பயன்பாடுகளின் அடித்தளமாகும். URL-ஐ அடிப்படையாகக் கொண்டு உள்வரும் HTTP கோரிக்கைகளை எவ்வாறு கையாள்வது என்பதை அவை வரையறுக்கின்றன. வழித்தடங்கள் (Routing) 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")

டெம்ப்ளேட் தொடரியல்:

டொர்னாடோ டெம்ப்ளேட்டுகள் பல்வேறு அம்சங்களை ஆதரிக்கின்றன, அவற்றுள்:

• மாறிகள்: {{ variable }}
• கட்டுப்பாட்டு ஓட்டம்: {% if condition %} ... {% else %} ... {% end %}, {% for item in items %} ... {% end %}
• செயல்பாடுகள்: {{ function(argument) }}
• சேர்த்தல்கள்: {% include "another_template.html" %}
• தப்பித்தல் (Escaping): டொர்னாடோ தானாகவே கிராஸ்-சைட் ஸ்கிரிப்டிங் (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'))

இந்த எடுத்துக்காட்டில், 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

உங்கள் பயன்பாட்டில் வெப்சாக்கெட்டுகளை ஒருங்கிணைத்தல்:

உங்கள் பயன்பாட்டின் வழித்தட உள்ளமைப்பில் வெப்சாக்கெட் கையாளுபவரைச் சேர்க்கவும்:

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

அங்கீகாரம் மற்றும் பாதுகாப்பு

பாதுகாப்பு என்பது வலைப் பயன்பாட்டு மேம்பாட்டின் ஒரு முக்கியமான அம்சமாகும். டொர்னாடோ உங்கள் பயன்பாடுகளைப் பாதுகாக்க உதவும் பல அம்சங்களை வழங்குகிறது, அவற்றுள் அங்கீகாரம், அதிகாரமளித்தல் மற்றும் பொதுவான வலை பாதிப்புகளுக்கு எதிரான பாதுகாப்பு ஆகியவை அடங்கும்.

அங்கீகாரம்:

அங்கீகாரம் என்பது ஒரு பயனரின் அடையாளத்தைச் சரிபார்க்கும் செயல்முறையாகும். டொர்னாடோ பல்வேறு அங்கீகாரத் திட்டங்களுக்கு உள்ளமைக்கப்பட்ட ஆதரவை வழங்குகிறது, அவற்றுள்:

• குக்கீ அடிப்படையிலான அங்கீகாரம்: பயனர் சான்றுகளை குக்கீகளில் சேமிக்கவும்.
• மூன்றாம் தரப்பு அங்கீகாரம் (OAuth): கூகிள், பேஸ்புக் மற்றும் ட்விட்டர் போன்ற பிரபலமான சமூக ஊடக தளங்களுடன் ஒருங்கிணைக்கவும்.
• API விசைகள்: API கோரிக்கைகளை அங்கீகரிக்க API விசைகளைப் பயன்படுத்தவும்.

அதிகாரமளித்தல்:

அதிகாரமளித்தல் என்பது ஒரு பயனர் ஒரு குறிப்பிட்ட வளத்தை அணுக அனுமதி உள்ளதா என்பதைத் தீர்மானிக்கும் செயல்முறையாகும். பயனர் பாத்திரங்கள் அல்லது அனுமதிகளின் அடிப்படையில் அணுகலைக் கட்டுப்படுத்த உங்கள் கோரிக்கை கையாளுபவர்களில் அதிகாரமளித்தல் தர்க்கத்தைச் செயல்படுத்தலாம்.

பாதுகாப்பு சிறந்த நடைமுறைகள்:

• கிராஸ்-சைட் ஸ்கிரிப்டிங் (XSS) பாதுகாப்பு: டொர்னாடோ தானாகவே XSS தாக்குதல்களைத் தடுக்க HTML உள்ளீடுகளை தப்பிக்கிறது. டெம்ப்ளேட்டுகளை ரெண்டர் செய்ய எப்போதும் render() முறையைப் பயன்படுத்தவும் மற்றும் உங்கள் கோரிக்கை கையாளுபவர்களில் நேரடியாக HTML-ஐ உருவாக்குவதைத் தவிர்க்கவும்.
• கிராஸ்-சைட் கோரிக்கை மோசடி (CSRF) பாதுகாப்பு: CSRF தாக்குதல்களைத் தடுக்க உங்கள் பயன்பாட்டு அமைப்புகளில் CSRF பாதுகாப்பை இயக்கவும்.
• HTTPS: சேவையகம் மற்றும் வாடிக்கையாளர்களுக்கு இடையேயான தகவல்தொடர்பை குறியாக்கம் செய்ய எப்போதும் HTTPS-ஐப் பயன்படுத்தவும்.
• உள்ளீட்டு சரிபார்ப்பு: ஊடுருவல் தாக்குதல்கள் மற்றும் பிற பாதிப்புகளைத் தடுக்க அனைத்து பயனர் உள்ளீடுகளையும் சரிபார்க்கவும்.
• வழக்கமான பாதுகாப்பு தணிக்கைகள்: சாத்தியமான பாதிப்புகளைக் கண்டறிந்து சரிசெய்ய வழக்கமான பாதுகாப்பு தணிக்கைகளை நடத்தவும்.

செயலமர்த்தல் (Deployment)

ஒரு டொர்னாடோ பயன்பாட்டைச் செயலமர்த்துவது, ஒரு வலை சேவையகத்தை உள்ளமைப்பது, ஒரு செயல்முறை மேலாளரை அமைப்பது மற்றும் செயல்திறனை மேம்படுத்துவது உள்ளிட்ட பல படிகளை உள்ளடக்கியது.

வலை சேவையகம்:

நீங்கள் 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

2. **மொழிபெயர்க்கக்கூடிய சரங்களைப் பிரித்தெடுக்கவும்:** உங்கள் பைத்தான் குறியீட்டிலிருந்து மொழிபெயர்க்கக்கூடிய சரங்களை ஒரு `.po` கோப்பிற்கு (Portable Object) பிரித்தெடுக்க `xgettext` போன்ற ஒரு கருவியைப் பயன்படுத்தவும். இந்த கோப்பில் அசல் சரங்கள் மற்றும் மொழிபெயர்ப்புகளுக்கான இடப்பிடிப்பான்கள் இருக்கும்.

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

3. **சரங்களை மொழிபெயர்க்கவும்:** ஒவ்வொரு மொழிக்கும் `.po` கோப்புகளில் உள்ள சரங்களை மொழிபெயர்க்கவும்.

4. **மொழிபெயர்ப்புகளைத் தொகுக்கவும்:** `.po` கோப்புகளை `.mo` கோப்புகளாக (Machine Object) தொகுக்கவும், அவை இயக்க நேரத்தில் `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>

உலகளாவிய பார்வையாளர்களுக்கான முக்கியக் கருத்தாய்வுகள்:

• **எழுத்துரு குறியாக்கம்:** பரந்த அளவிலான எழுத்துக்களை ஆதரிக்க எப்போதும் UTF-8 குறியாக்கத்தைப் பயன்படுத்தவும்.
• **தேதி மற்றும் நேர வடிவமைப்பு:** மொழி சார்ந்த தேதி மற்றும் நேர வடிவமைப்பைப் பயன்படுத்தவும். பைத்தானின் `strftime` மற்றும் `strptime` செயல்பாடுகளை மொழி அமைப்புகளுடன் பயன்படுத்தலாம்.
• **எண் வடிவமைப்பு:** மொழி சார்ந்த எண் வடிவமைப்பைப் பயன்படுத்தவும் (எ.கா., தசம பிரிப்பான்கள், ஆயிரக்கணக்கான பிரிப்பான்கள்). `locale` தொகுதி இதற்கான செயல்பாடுகளை வழங்குகிறது.
• **நாணய வடிவமைப்பு:** மொழி சார்ந்த நாணய வடிவமைப்பைப் பயன்படுத்தவும். மேலும் மேம்பட்ட நாணயக் கையாளுதலுக்கு `Babel` போன்ற ஒரு நூலகத்தைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளவும்.
• **வலமிருந்து இடமாக (RTL) மொழிகள்:** அரபு மற்றும் ஹீப்ரு போன்ற RTL மொழிகளை ஆதரிக்கவும். இது உங்கள் வலைத்தளத்தின் தளவமைப்பைப் பிரதிபலிப்பதை உள்ளடக்கியிருக்கலாம்.
• **மொழிபெயர்ப்புத் தரம்:** துல்லியமான மற்றும் கலாச்சார ரீதியாகப் பொருத்தமான மொழிபெயர்ப்புகளை உறுதிப்படுத்த தொழில்முறை மொழிபெயர்ப்பாளர்களைப் பயன்படுத்தவும். இயந்திர மொழிபெயர்ப்பு ஒரு நல்ல தொடக்கப் புள்ளியாக இருக்கலாம், ஆனால் அதற்கு பெரும்பாலும் மனித ஆய்வு தேவைப்படுகிறது.
• **பயனர் மொழி கண்டறிதல்:** பயனர் விருப்பத்தேர்வுகள், உலாவி அமைப்புகள் அல்லது IP முகவரியின் அடிப்படையில் வலுவான மொழி கண்டறிதலைச் செயல்படுத்தவும். பயனர்கள் தங்களுக்கு விருப்பமான மொழியை கைமுறையாகத் தேர்ந்தெடுக்க ஒரு வழியை வழங்கவும்.
• **சோதனை:** எல்லாம் சரியாகக் காட்டப்படுவதை உறுதிப்படுத்த உங்கள் பயன்பாட்டை வெவ்வேறு மொழிகளுடன் முழுமையாகச் சோதிக்கவும்.

மேம்பட்ட தலைப்புகள்

தனிப்பயன் பிழை பக்கங்கள்:

ஒரு பிழை ஏற்படும்போது டொர்னாடோ காட்டும் பிழைப் பக்கங்களைத் தனிப்பயனாக்கலாம். இது மிகவும் பயனர் நட்பு அனுபவத்தை வழங்கவும், பிழைத்திருத்தத் தகவல்களைச் சேர்க்கவும் உங்களை அனுமதிக்கிறது.

தனிப்பயன் அமைப்புகள்:

உங்கள் பயன்பாட்டு உள்ளமைவில் தனிப்பயன் அமைப்புகளை வரையறுத்து, அவற்றை உங்கள் கோரிக்கை கையாளுபவர்களில் அணுகலாம். தரவுத்தள இணைப்பு சரங்கள் அல்லது API விசைகள் போன்ற பயன்பாடு சார்ந்த அளவுருக்களைச் சேமிக்க இது பயனுள்ளதாக இருக்கும்.

சோதனை:

உங்கள் டொர்னாடோ பயன்பாடுகள் சரியாக மற்றும் பாதுகாப்பாக செயல்படுகின்றனவா என்பதை உறுதிப்படுத்த அவற்றை முழுமையாகச் சோதிக்கவும். உங்கள் பயன்பாட்டின் அனைத்து அம்சங்களையும் உள்ளடக்க யூனிட் சோதனைகள், ஒருங்கிணைப்பு சோதனைகள் மற்றும் எண்ட்-டு-எண்ட் சோதனைகளைப் பயன்படுத்தவும்.

முடிவுரை

டொர்னாடோ ஒரு சக்திவாய்ந்த மற்றும் பல்துறை வலைக் கட்டமைப்பாகும், இது அளவிடக்கூடிய, உயர் செயல்திறன் கொண்ட வலைப் பயன்பாடுகளை உருவாக்க மிகவும் பொருத்தமானது. அதன் ஒத்திசைவற்ற கட்டமைப்பு, வெப்சாக்கெட் ஆதரவு மற்றும் பயன்படுத்த எளிதான API ஆகியவை உலகளாவிய டெவலப்பர்களிடையே பிரபலமான தேர்வாக ஆக்குகின்றன. இந்த விரிவான வழிகாட்டியில் உள்ள வழிகாட்டுதல்கள் மற்றும் எடுத்துக்காட்டுகளைப் பின்பற்றுவதன் மூலம், நீங்கள் உங்கள் சொந்த டொர்னாடோ பயன்பாடுகளை உருவாக்கத் தொடங்கலாம் மற்றும் அதன் பல அம்சங்களைப் பயன்படுத்திக் கொள்ளலாம்.

மிகவும் புதுப்பித்த தகவல்கள் மற்றும் சிறந்த நடைமுறைகளுக்கு அதிகாரப்பூர்வ டொர்னாடோ ஆவணங்களைப் பார்க்க நினைவில் கொள்ளுங்கள். மகிழ்ச்சியான குறியீட்டு முறை!