க்ரான் வேலைகளில் (Cron Jobs) நகல் பதிவுகளைத் தடுப்பது எப்படி

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

அமைப்பு (The Setup)

உங்கள் பயன்பாட்டில் உள்ள செயலில் உள்ள உருப்படிகளுக்கு பதிவுகளை உருவாக்கும் ஒரு இரவு நேர வேலை உங்களிடம் இருப்பதாக கற்பனை செய்து பாருங்கள். இந்த வேலை ஒரு நாளைக்கு ஒரு முறை இயங்கி, ஒவ்வொரு உருப்படிக்கும் ஒரு புதிய பதிவை உருவாக்க வேண்டும். சேவையக பக்க பயன்பாடுகளை உருவாக்குவதற்கான பிரபலமான கட்டமைப்பான NestJS ஐப் பயன்படுத்தும் ஒரு வழக்கமான அமைப்பில், நீங்கள் இதை பயன்படுத்தலாம் @Cron இந்த வேலையைத் திட்டமிட decorator ஐப் பயன்படுத்தலாம். அது எப்படி இருக்கும் என்பதன் எளிமைப்படுத்தப்பட்ட பதிப்பு இங்கே:

@Injectable()
export class WindowGenerationService {
    @Cron('0 8 * * *') // every day at 08:00
    async generateNextWindows() {
        const entities = await this.repo.findActiveEndingSoon();
        for (const entity of entities) {
            await this.repo.createNextWindow(entity);
        }
    }
}

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

பிரச்சனை (The Problem)

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

இது ஏன் முக்கியமானது (Why This Matters)

நகல் தரவு, தரவு ஒருமைப்பாடு (data integrity) சிக்கல்கள் மற்றும் வீணான வளங்கள் உட்பட பல்வேறு சிக்கல்களுக்கு வழிவகுக்கும். நீங்கள் தேவையற்ற பதிவுகளை உருவாக்குவது மட்டுமல்லாமல், ஒரே வேலையைச் செய்யும் மூன்று கொள்கலன்களின் (containers) கணினி வளங்களுக்கும் நீங்கள் பணம் செலுத்துகிறீர்கள்.

சாத்தியமான தீர்வுகள் (Possible Solutions)

சிக்கலை அடையாளம் கண்ட பிறகு, அதைத் தீர்க்க பல வழிகள் உள்ளன:

விருப்பம் 1: பகிர்ந்தளிக்கப்பட்ட பூட்டைப் (Distributed Lock) பயன்படுத்துதல்

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

விருப்பம் 2: ஐடெம்போடென்சியை (Idempotency) செயல்படுத்துதல்

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

விருப்பம் 3: திட்டமிடலை பயன்பாட்டிற்கு வெளியே நகர்த்துதல்

கண்டுபிடிக்கப்பட்டபடி, திட்டமிடலை பயன்பாட்டிலிருந்து வெளியே எடுப்பதே சிறந்த தீர்வாகும். வேலைகள் எப்போது இயங்கும் என்பதை ஆப்ஸ் நிர்வகிப்பதற்குப் பதிலாக, வெளிப்புறத் திட்டமிடுபவர் அதைக் கையாள அனுமதிக்கவும். இதன் மூலம், திட்டமிடப்பட்ட நேரத்தில் வெளிப்புறத் திட்டமிடுபவர் ஒருமுறை தூண்டும் (triggers) HTTP முனைப்புள்ளியை (endpoint) நீங்கள் உருவாக்கலாம். அது எப்படி இருக்கும் என்பது இங்கே:

@Post('jobs/run')
async runJob(@Body() body: RunJobDto) {
    this.assertValidSecret(body.secret);
    return this.jobs.run(body.jobKey);
}

இந்த அமைப்பின் மூலம், ஒரு நிகழ்வு மட்டுமே வேலை தூண்டுதலுக்கு (job trigger) பதிலளிக்கும், இது நகல் பதிவுகள் உருவாக்கப்படுவதைத் தடுக்கும். வேலை பல முறை தூண்டப்பட்டாலும், அது நகல்களை உருவாக்காது என்பதை உறுதிப்படுத்த, ஐடெம்போடென்சி சரிபார்ப்பு இடத்தில் உள்ளது.

இதற்கான செலவு என்ன (What It Costs)

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

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

பாடம் (The Lesson)

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

முடிவுரை (Conclusion)

சுருக்கமாக, மைக்ரோசர்வீஸ் கட்டமைப்பில் க்ரான் வேலைகளை நிர்வகிப்பதற்கு கவனமாக திட்டமிடல் தேவை. உங்கள் பயன்பாட்டிற்கு வெளியே திட்டமிடலை நகர்த்துவதன் மூலமும் சரியான சரிபார்ப்புகளை செயல்படுத்துவதன் மூலமும், நகல் பதிவுகள் போன்ற சிக்கல்களைத் தடுக்கலாம் மற்றும் உங்கள் சேவைகளின் செயல்திறனை மேம்படுத்தலாம்.

நன்மைகள் (Merits)

• தரவுத்தளத்தில் நகல் பதிவுகளைத் தடுக்கிறது.
• தேவையற்ற கணக்கீட்டு செலவுகளைக் குறைக்கிறது.
• திட்டமிடலை வெளிப்புறமாக்குவதன் மூலம் வேலை நிர்வாகத்தை எளிதாக்குகிறது.

தீமைகள் (Demerits)

• வெளிப்புற திட்டமிடுபவருக்கு கூடுதல் அமைப்பு தேவைப்படுகிறது.
• HTTP கோரிக்கைகள் மற்றும் பாதுகாப்பைக் கையாள்வதில் சிக்கலை அறிமுகப்படுத்துகிறது.

எச்சரிக்கை (Caution)

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

அடிக்கடி கேட்கப்படும் கேள்விகள் (Frequently asked questions)

• க்ரான் வேலை (cron job) என்றால் என்ன? — ஒரு க்ரான் வேலை என்பது ஒரு திட்டமிடப்பட்ட பணியாகும், இது குறிப்பிட்ட இடைவெளியில் தானாகவே இயங்கும்.
• எனது க்ரான் வேலை ஏன் பல முறை இயங்கியது? — உங்கள் பயன்பாட்டின் பல நிகழ்வுகளில் வேலை திட்டமிடப்பட்டிருந்தால் இது நிகழலாம்.
• தரவுத்தளத்தில் நகல் பதிவுகளை நான் எவ்வாறு தடுப்பது? — ஐடெம்போடென்சி சரிபார்ப்புகளைச் செயல்படுத்தவும் அல்லது திட்டமிடலை பயன்பாட்டிற்கு வெளியே நகர்த்தவும்.
• நிரலாக்கத்தில் ஐடெம்போடென்சி என்றால் என்ன? — ஐடெம்போடென்சி என்பது ஆரம்ப பயன்பாட்டிற்கு அப்பால் முடிவை மாற்றாமல் ஒரு செயல்பாட்டை பல முறை அழைக்கலாம் என்பதாகும்.
• NestJS என்றால் என்ன? — NestJS என்பது திறமையான, அளவிடக்கூடிய Node.js சேவையகப் பக்க பயன்பாடுகளை உருவாக்குவதற்கான ஒரு கட்டமைப்பாகும்.
• எனது HTTP முனைப்புள்ளிகளை நான் எவ்வாறு பாதுகாப்பது? — கோரிக்கைகளைச் சரிபார்க்க பகிரப்பட்ட ரகசியங்கள் (shared secrets) அல்லது டோக்கன்கள் (tokens) போன்ற அங்கீகார முறைகளைப் பயன்படுத்தவும்.

குறிச்சொற்கள் (Tags)

#cron #nestjs #microservices #scheduling #softwareengineering #dataintegrity #cloudcomputing #distributedsystems