క్రాన్ జాబ్స్‌లో డూప్లికేట్ రికార్డ్స్‌ని నిరోధించడం ఎలా

సాఫ్ట్‌వేర్‌తో పనిచేస్తున్నప్పుడు, టాస్క్‌లు సాఫీగా మరియు డూప్లికేషన్ లేకుండా నడిచేలా చూసుకోవడం చాలా ముఖ్యం. డిస్ట్రిబ్యూటెడ్ సిస్టమ్స్‌లో ఒక సాధారణ సమస్యను ఇక్కడ చర్చిస్తున్నాము: ఒక ఇన్-ప్రాసెస్ షెడ్యూలర్ ఒక నైట్లీ జాబ్‌ని బహుళ సార్లు నడిచేలా చేయడం ద్వారా, మీ డేటాబేస్‌లో డూప్లికేట్ రికార్డ్స్‌కి ఎలా దారితీస్తుందో తెలుసుకుందాం. సర్వీస్‌లు హారిజాంటల్‌గా స్కేల్ అయ్యే మైక్రోసర్వీసెస్ ఆర్కిటెక్చర్‌ని ఎక్కువ కంపెనీలు అవలంబిస్తున్నందున ఈ అంశం చాలా ప్రసక్తమైనది.

సెటప్

మీ అప్లికేషన్‌లో యాక్టివ్ ఎంటిటీల కోసం రికార్డ్‌లను క్రియేట్ చేసే ఒక నైట్లీ జాబ్ మీ వద్ద ఉందనుకుందాం. ఈ జాబ్ రోజుకు ఒకసారి నడవాలి, ప్రతి ఎంటిటీ కోసం ఒక కొత్త రికార్డ్‌ను క్రియేట్ చేయాలి. సర్వర్-సైడ్ అప్లికేషన్‌లను నిర్మించడానికి ఒక ప్రసిద్ధ ఫ్రేమ్‌వర్క్ అయిన NestJSను ఉపయోగించే ఒక సాధారణ సెటప్‌లో, మీరు దీనిని ఉపయోగించవచ్చు @Cron ఈ జాబ్‌ను షెడ్యూల్ చేయడానికి డెకరేటర్. అది ఎలా ఉంటుందో ఇక్కడ సరళీకృత వెర్షన్ ఉంది:

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

మీరు నడుపుతున్న సర్వీస్ యొక్క సింగిల్ ఇన్‌స్టాన్స్ ఉన్నప్పుడు ఈ కోడ్ అద్భుతంగా పనిచేస్తుంది. అయితే, బహుళ ఇన్‌స్టాన్స్‌లను నడపడం ద్వారా మీ అప్లికేషన్‌ను హారిజాంటల్‌గా స్కేల్ చేసినప్పుడు, సమస్యలు తలెత్తవచ్చు.

సమస్య

స్కేల్ చేయబడిన సెటప్‌లో, మీ సర్వీస్ యొక్క మూడు ఇన్‌స్టాన్స్‌లు ఉంటే, ప్రతి ఇన్‌స్టాన్స్ షెడ్యూల్ చేసిన జాబ్ యొక్క దాని స్వంత కాపీని ఒకే సమయంలో నడుపుతుంది. కాబట్టి, 08:00 గంటలకు ఒక జాబ్ నడవడానికి బదులుగా, ఒకేసారి మూడు జాబ్స్ ఫైర్ అవుతాయి. ప్రతి ఇన్‌స్టాన్స్ అవి ఇప్పటికే ఉన్నాయో లేదో తనిఖీ చేయకుండా దాని స్వంత రికార్డ్స్‌ని క్రియేట్ చేస్తుంది. ఇది మీ డేటాబేస్‌లో డూప్లికేట్ ఎంట్రీలకు దారితీస్తుంది, ఇక్కడ ఒకే ఎంటిటీ కోసం రెండు ఒకేలాంటి రికార్డ్స్ సెకన్ల వ్యవధిలో క్రియేట్ అవుతాయి.

ఇది ఎందుకు ముఖ్యం

డూప్లికేట్ డేటా, డేటా సమగ్రత సమస్యలు మరియు వృధా అయిన వనరులతో సహా వివిధ సమస్యలకు దారితీస్తుంది. మీరు అనవసరమైన రికార్డ్స్‌ని క్రియేట్ చేయడమే కాకుండా, ఒకే పనిని చేస్తున్న మూడు కంటైనర్‌ల కంప్యూట్ రిసోర్సెస్ కోసం కూడా చెల్లిస్తున్నారు.

సాధ్యమైన పరిష్కారాలు

సమస్యను గుర్తించిన తర్వాత, దానిని పరిష్కరించడానికి అనేక మార్గాలు ఉన్నాయి:

ఆప్షన్ 1: డిస్ట్రిబ్యూటెడ్ లాక్‌ని ఉపయోగించండి

డిస్ట్రిబ్యూటెడ్ లాక్‌ని అమలు చేయడం ఒక పరిష్కారం కావచ్చు. ఇది లాక్ కోసం పోటీపడటానికి ఇన్‌స్టాన్స్‌లను అనుమతిస్తుంది, తద్వారా కేవలం ఒక ఇన్‌స్టాన్స్ మాత్రమే జాబ్‌ను నడుపుతుంది. అయితే, ఈ విధానంలో ప్రతికూలతలు ఉన్నాయి. లాక్ బ్యాకెండ్ విఫలమైతే లేదా లాక్‌ను పట్టుకున్న ఇన్‌స్టాన్స్ చనిపోతే, జాబ్ అసలు నడవకపోవచ్చు, ఇది మిస్డ్ ఎగ్జిక్యూషన్స్‌కు దారితీస్తుంది.

ఆప్షన్ 2: ఐడెంపోటెన్సీని అమలు చేయండి

మరొక ఎంపిక ఐడెంపోటెన్సీ చెక్‌ని జోడించడం. దీని అర్థం ఒకవేళ జాబ్ మళ్లీ నడిస్తే, రికార్డ్స్ ఇప్పటికే ఉంటే వాటిని క్రియేట్ చేయడాన్ని ఇది కేవలం స్కిప్ చేస్తుంది. ఇది చౌకైన పరిష్కారం అయినప్పటికీ, ఇది ఇప్పటికీ అన్ని ఇన్‌స్టాన్స్‌లను మేల్కొల్పుతుంది, ఇది పునరావృతమయ్యే పనికి దారితీస్తుంది.

ఆప్షన్ 3: షెడ్యూలింగ్‌ను యాప్ వెలుపలికి తరలించండి

కనుగొన్నట్లుగా, ఉత్తమ పరిష్కారం, అప్లికేషన్ నుండి షెడ్యూలింగ్‌ను బయటకు తీసుకోవడం. జాబ్స్ ఎప్పుడు నడవాలో యాప్ నిర్వహించే బదులు, ఒక ఎక్స్‌టర్నల్ షెడ్యూలర్‌ను దానిని నిర్వహించనివ్వండి. ఈ విధంగా, ఎక్స్‌టర్నల్ షెడ్యూలర్ షెడ్యూల్ చేసిన సమయంలో ఒకసారి ట్రిగ్గర్ చేసే HTTP ఎండ్‌పాయింట్‌ను మీరు క్రియేట్ చేయవచ్చు. అది ఎలా ఉంటుందో ఇక్కడ ఉంది:

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

ఈ సెటప్‌తో, కేవలం ఒక ఇన్‌స్టాన్స్ మాత్రమే జాబ్ ట్రిగ్గర్‌కు ప్రతిస్పందిస్తుంది, డూప్లికేట్ రికార్డ్స్ క్రియేట్ అవ్వడాన్ని నిరోధిస్తుంది. జాబ్ బహుళ సార్లు ట్రిగ్గర్ చేయబడినప్పటికీ, అది డూప్లికేట్‌లను క్రియేట్ చేయదని నిర్ధారించడానికి ఐడెంపోటెన్సీ చెక్ అలానే ఉంటుంది.

దీనికి ఎంత ఖర్చవుతుంది

మీరు ఒక జాబ్‌ని HTTP ఎండ్‌పాయింట్‌గా ఎక్స్‌పోజ్ చేసినప్పుడు, మీరు భద్రతను పరిగణనలోకి తీసుకోవాలి. ఈ ఎండ్‌పాయింట్‌ను కనుగొన్న ఎవరైనా దానిని ట్రిగ్గర్ చేయగలరు. అనధికారిక యాక్సెస్‌ను నిరోధించడానికి, రిక్వెస్ట్‌లను వాలిడేట్ చేయడానికి షేర్డ్ సీక్రెట్ ఉపయోగించబడుతుంది. కేవలం చట్టబద్ధమైన ట్రిగ్గర్‌లు మాత్రమే జాబ్‌ను ఎగ్జిక్యూట్ చేయగలవని ఇది నిర్ధారిస్తుంది.

మరొక పరిశీలన ఏమిటంటే షెడ్యూలింగ్ సమయం. వినియోగదారులందరికీ రోజు ప్రారంభమైన తర్వాత జాబ్ నడవాలి, బహుళ టైమ్ జోన్‌లతో వ్యవహరించేటప్పుడు ఇది కష్టంగా ఉంటుంది. ఒక నిర్దిష్ట UTC గంటను ఎంచుకోవడం వివిధ ప్రాంతాలలో దీనిని ప్రామాణీకరించడానికి సహాయపడుతుంది.

పాఠం

ఈ అనుభవం ఒక కీలకమైన పాఠాన్ని హైలైట్ చేస్తుంది: డిస్ట్రిబ్యూటెడ్ సిస్టమ్‌లో ఇన్-ప్రాసెస్ షెడ్యూలర్ ఊహించని ప్రవర్తనకు దారితీయవచ్చు. మీ అప్లికేషన్‌ను స్కేలింగ్ చేసేటప్పుడు, అప్లికేషన్ లాజిక్ నుండి షెడ్యూలింగ్ అంశాన్ని వేరు చేయడం చాలా ముఖ్యం. ఇలా చేయడం ద్వారా, మీరు డూప్లికేట్ రైట్స్ యొక్క సమస్యలను నివారించవచ్చు మరియు మీ జాబ్స్ ఉద్దేశించిన విధంగా నడుస్తాయని నిర్ధారించుకోవచ్చు.

ముగింపు

సారాంశంలో, మైక్రోసర్వీసెస్ ఆర్కిటెక్చర్‌లో క్రాన్ జాబ్స్‌ను నిర్వహించడానికి జాగ్రత్తగా ప్రణాళిక అవసరం. మీ అప్లికేషన్ వెలుపలికి షెడ్యూలింగ్‌ను తరలించడం మరియు సరైన తనిఖీలను అమలు చేయడం ద్వారా, మీరు డూప్లికేట్ రికార్డ్స్ వంటి సమస్యలను నివారించవచ్చు మరియు మీ సర్వీస్‌ల సామర్థ్యాన్ని మెరుగుపరచవచ్చు.

ప్రయోజనాలు

• డేటాబేస్‌లో డూప్లికేట్ రికార్డ్స్‌ను నిరోధిస్తుంది.
• అనవసరమైన కంప్యూట్ ఖర్చులను తగ్గిస్తుంది.
• షెడ్యూలింగ్‌ను ఎక్స్‌టర్నలైజ్ చేయడం ద్వారా జాబ్ మేనేజ్‌మెంట్‌ను సులభతరం చేస్తుంది.

ప్రతికూలతలు

• ఎక్స్‌టర్నల్ షెడ్యూలర్ కోసం అదనపు సెటప్ అవసరం.
• HTTP రిక్వెస్ట్‌లు మరియు భద్రతను నిర్వహించడంలో సంక్లిష్టతను పరిచయం చేస్తుంది.

హెచ్చరిక

ఈ ఆర్టికల్ ఒక విద్యాపరమైన స్థూల దృష్టిగా ఉపయోగపడుతుంది. దయచేసి ఏదైనా ప్లేస్‌హోల్డర్ వాల్యూస్‌ని మీ అసలైన కాన్ఫిగరేషన్‌లతో భర్తీ చేయండి మరియు వాటిపై ఆధారపడే ముందు అసలు సోర్స్‌కి వ్యతిరేకంగా క్లెయిమ్‌లను ధృవీకరించుకోండి.

తరచుగా అడిగే ప్రశ్నలు

• క్రాన్ జాబ్ అంటే ఏమిటి? — క్రాన్ జాబ్ అనేది పేర్కొన్న వ్యవధిలో స్వయంచాలకంగా నడిచే ఒక షెడ్యూల్ చేయబడిన టాస్క్.
• నా క్రాన్ జాబ్ బహుళ సార్లు ఎందుకు నడిచింది? — మీ అప్లికేషన్ యొక్క బహుళ ఇన్‌స్టాన్స్‌లలో జాబ్ షెడ్యూల్ చేయబడితే ఇది జరగవచ్చు.
• డేటాబేస్‌లో డూప్లికేట్ రికార్డ్స్‌ని నేను ఎలా నిరోధించగలను? — ఐడెంపోటెన్సీ తనిఖీలను అమలు చేయండి లేదా షెడ్యూలింగ్‌ను అప్లికేషన్ వెలుపలికి తరలించండి.
• ప్రోగ్రామింగ్‌లో ఐడెంపోటెన్సీ అంటే ఏమిటి? — ఐడెంపోటెన్సీ అంటే ప్రాథమిక అప్లికేషన్‌ను మించి ఫలితాన్ని మార్చకుండా ఫంక్షన్‌ని బహుళ సార్లు పిలవవచ్చు.
• NestJS అంటే ఏమిటి? — NestJS అనేది సమర్థవంతమైన, స్కేలబుల్ Node.js సర్వర్-సైడ్ అప్లికేషన్‌లను నిర్మించడానికి ఒక ఫ్రేమ్‌వర్క్.
• నా HTTP ఎండ్‌పాయింట్స్‌ను ఎలా సురక్షితం చేయాలి? — రిక్వెస్ట్‌లను వాలిడేట్ చేయడానికి షేర్డ్ సీక్రెట్స్ లేదా టోకెన్‌లు వంటి అథెంటికేషన్ పద్ధతులను ఉపయోగించండి.

ట్యాగ్‌లు

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