"உங்கள் குறியீடு இயங்கும் மில்லி விநாடிகளுக்கு மட்டுமே நீங்கள் பணம் செலுத்த வேண்டும்" என்ற சர்வர்லெஸ் (serverless) மாயை, AWS Lambda-வில் ஒரு AI ஏஜென்ட்டை (AI agent) இயக்க முயற்சிக்கும்போது உடைந்துவிடுகிறது. நடைமுறையில், மிகப்பெரிய செலவுகள் Lambda-கணக்கீட்டு கட்டணம் (compute charge) அல்ல; மாறாக, கோல்ட்-ஸ்டார்ட் லேட்டன்சி (cold-start latency), மறுமுயற்சி சுழற்சிகள் (retry loops) மற்றும் அந்தச் சுழற்சிகள் உருவாக்கும் டோக்கன் பயன்பாடு (token usage) ஆகியவற்றாகும்.

வழக்கமான சர்வர்லெஸ் பார்வை ஏன் AI ஏஜென்ட்களைத் தவறாக வழிநடத்துகிறது

பெரும்பாலான டெவலப்பர்கள் ஒரு Lambda செயல்பாட்டை (function) ஒரு தூய கணக்கீட்டு சாண்ட்பாக்ஸ் (compute sandbox) போலக் கருதுகிறார்கள்: ஹேண்ட்லரை (handler) வேகமாக வைத்திருக்கவும், மிதமான மெமரி அளவை நிர்ணயிக்கவும், மற்றும் பில் (bill) நிலையாக இருப்பதை கவனிக்கவும் செய்கிறார்கள். இது எளிமையான HTTP எண்ட்பாயிண்ட்களுக்கு (endpoints) வேலை செய்யும், ஆனால் ஒரு மொழி மாதிரியை (language model) அழைத்து, அதன் பதிலை மதிப்பீடு செய்து, தேவைப்பட்டால் முழுச் சுழற்சியையும் மீண்டும் முயற்சிக்கும் ஒரு ஏஜென்ட், ஒரு ஒற்றை Lambda அழைப்பிற்கு (invocation) நேரடியாகப் பொருந்தாது. ஏஜென்ட்டின் உள் பணிப்பாய்வு (internal workflow) மாடல் அழைப்புகளின் எண்ணிக்கையைத் பெருக்கமடைகிறது, மேலும் ஒவ்வொரு கூடுதல் அழைப்பும் கணக்கீட்டு கட்டணத்தை விடப் பெரிய டோக்கன் செலவை ஏற்படுத்துகிறது.

கோல்ட் ஸ்டார்ட்ஸ் (Cold starts) என்பது மறைந்திருக்கும் விலைப்பட்டியல்

ஒரு Lambda கன்டெய்னர் (container) முதன்முதலில் ஒதுக்கப்பட்டால், அது டெப்ளாய்மென்ட் பேக்கேஜை (deployment package) அன்பேக் (unpack) செய்ய வேண்டும். சம்பந்தப்பட்ட ஏஜென்ட் ஒரு பெரிய அளவிலான Python லைப்ரரிகளைப் பயன்படுத்துவதால், அதன் இமேஜ் (image) அளவில் பெரியதாக இருக்கலாம். உள்ளூர் சோதனைக்கு மட்டுமே பயன்படுத்தப்படும் பிரவுசர் ஆட்டோமேஷன் லைப்ரரி போன்ற டெவலப்மென்ட்-மட்டும் பயன்படும் கருவிகளை நீக்குவது, இமேஜ் அளவைக் குறைக்கும், இது அன்பேக் நேரத்தைக் குறைக்கும். மெலிதான பேக்கேஜ் என்பது செயல்பாடு ஒரு கோரிக்கையை (request) விரைவாகக் கையாளத் தயாராவதைக் குறிக்கிறது, இது கன்டெய்னர் சூடாக (warm up) காத்திருக்கும் நேரத்தைக் குறைக்கிறது.

இரண்டாவது காரணி, தொடக்கக் குறியீடு (initialization code) எங்கு உள்ளது என்பதாகும். மாட்யூல் இம்போர்ட் (module import) நேரத்தில் ஏஜென்ட்டின் கிராஃபை (graph) உருவாக்குவதன் மூலம், ஒவ்வொரு கோரிக்கைக்கும் பதிலாக, கன்டெய்னர் தொடங்கும் போது ஒருமுறை மட்டுமே கடினமான வேலைகள் செய்யப்படுகின்றன. அதன் பிறகு வரும் 'வார்ம் இன்கோகேஷன்கள்' (warm invocations) அந்த வேலையைத் தவிர்க்கின்றன. இதன் சவாலாகச் சற்று நீண்ட கோல்ட் ஸ்டார்ட் இருக்கலாம், ஆனால் கன்டெய்னர் சூடான பிறகு, ஒவ்வொரு கோரிக்கைக்கும் தேவைப்படும் செட்டப் நேரம் கிட்டத்தட்ட பூஜ்ஜியமாக இருக்கும்.

மெமரி என்பது லேட்டன்சியைக் கட்டுப்படுத்தும் கருவியாகவும் செயல்படுகிறது

Lambda-வில் நீங்கள் ஒதுக்கும் மெமரியின் அளவு, அந்தச் செயல்பாடு பெறும் CPU அளவையும் தீர்மானிக்கிறது. செயல்பாட்டிற்கு 1 GB மெமரியை நிர்ணயிப்பது, அதற்கு ஒரு முழு விர்ச்சுவல் CPU கோரை (virtual CPU core) வழங்குகிறது. கூடுதல் CPU, லைப்ரரிகளை இம்போர்ட் செய்வதையும் ஏஜென்ட் கிராஃபை உருவாக்குவதையும் வேகப்படுத்துகிறது, இதனால் கோல்ட்-ஸ்டார்ட் மற்றும் வார்ம்-அப் லேட்டன்சி ஆகிய இரண்டும் குறைகின்றன.

சுழற்சிச் செலவு: மறுமுயற்சிகள் டோக்கன் செலவை அதிகரிக்கின்றன

ஏஜென்ட் ஒரு 'ஒர்க்கர்-எவாலியூட்டர்' (worker-evaluator) சுழற்சியைப் பின்பற்றுகிறது. ஒர்க்கர் ஒரு பதிலை உருவாக்குகிறது, எவாலியூட்டர் அதைச் சரிபார்க்கிறது, மற்றும் எவாலியூட்டர் ஒரு பிழையைக் கண்டறிந்தால், அந்தப் பணி மீண்டும் ஒர்க்கருக்கு அனுப்பப்படுகிறது. இந்தச் சுழற்சி கைவிடுவதற்கு முன்பு ஐந்து முறை வரை மீண்டும் நிகழலாம். இதன் பொருள் ஒரு ஒற்றை வெளிப்புறக் கோரிக்கை பின்வருவனவற்றைத் தூண்டலாம்:

  • ஒர்க்கர் மாடலுக்கு ஐந்து அழைப்புகள் வரை
  • எவாலியூட்டர் மாடலுக்கு ஐந்து அழைப்புகள் வரை
  • ஏஜென்ட் செய்யத் தீர்மானிக்கும் எத்தனை டூல் (tool) அழைப்புகள் வேண்டுமானாலும்

AWS மில்லி விநாடி செயல்பாட்டிற்காகக் கட்டணம் வசூலிப்பதால் Lambda பில் கணிக்கக்கூடியதாக இருக்கும், ஆனால் எத்தனை மறுமுயற்சிகள் தேவைப்படுகின்றன என்பதைப் பொறுத்து டோக்கன் பில் (token bill) கடுமையாக மாறக்கூடும்.

டைம்அவுட் பொறி: API Gateway vs. Lambda

API Gateway தான் முன்னிலைப்படுத்தும் HTTP கோரிக்கைக்கு 29 வினாடிகள் என்ற கடுமையான டைம்அவுட்டை (timeout) விதிக்கிறது. அடிப்படை Lambda செயல்பாடு ஐந்து நிமிட செயல்பாட்டு காலத்திற்கு (execution window) கட்டமைக்கப்பட்டிருந்தாலும் கூட, ஐந்து முறை சுழலும் ஏஜென்ட் லூப் அந்த வரம்பைத் தாண்டிவிடக்கூடும். Lambda Function URLs மூலம் API Gateway-ஐத் தவிர்ப்பது, 29 வினாடி உச்சவரம்பை நீக்குகிறது, இது செயல்பாடு அதன் சுழற்சியை இடையில் துண்டிக்கப்படாமல் முடிக்க அனுமதிக்கிறது.

டெவலப்பர்கள் எதற்காக பட்ஜெட் ஒதுக்க வேண்டும்

பாடம் எளிமையானது: ஒரு சர்வர்லெஸ் AI ஏஜென்ட்டிற்கான பட்ஜெட்டைத் திட்டமிடுவது என்பது Lambda ரன்டைமின் (runtime) மில்லி விநாடிகளைக் கூட்டுவதை விட மேலானது. நீங்கள் பின்வருவனவற்றைக் கணக்கில் கொள்ள வேண்டும்:

  • டெப்ளாய்மென்ட் பேக்கேஜின் அளவு மற்றும் அதன் விளைவாக ஏற்படும் கோல்ட்-ஸ்டார்ட் லேட்டன்சி
  • CPU மற்றும் அதன் மூலம் இம்போர்ட் வேகத்தைத் தீர்மானிக்கும் மெமரி செட்டிங்
  • ஒர்க்கர்-எவாலியூட்டர் சுழற்சியில் எதிர்பார்க்கப்படும் மறுமுயற்சிகளின் எண்ணிக்கை, இது நேரடியாக டோக்கன் பயன்பாட்டைத் தூண்டுகிறது
  • முன்கூட்டிய டைம்அவுட்களைத் தவிர்க்க முன்முனைத் தேர்வு (API Gateway vs. Function URL)

இந்த மாறிகளில் எதையும் புறக்கணிப்பது, நீங்கள் திட்டமிட்டதை விட முற்றிலும் மாறுபட்ட ஒரு பில்லை உங்களுக்குத் தரக்கூடும்.