Cron Jobs ରେ ଡୁପ୍ଲିକେଟ୍ ରେକର୍ଡଗୁଡ଼ିକୁ କିପରି ରୋକିବେ

ସଫ୍ଟୱେର୍ ସହିତ କାମ କରିବା ସମୟରେ, କାର୍ଯ୍ୟଗୁଡ଼ିକ ଯେପରି ସୁରୁଖୁରୁରେ ଏବଂ ଡୁପ୍ଲିକେସନ୍ ବିନା ଚାଲେ ତାହା ନିଶ୍ଚିତ କରିବା ଅତ୍ୟନ୍ତ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ। ଆମେ ଡିଷ୍ଟ୍ରିବ୍ୟୁଟେଡ୍ ସିଷ୍ଟମଗୁଡ଼ିକର ଏକ ସାଧାରଣ ତ୍ରୁଟି ଉପରେ ଆଲୋଚନା କରୁଛୁ: କିପରି ଏକ in-process scheduler ଏକ nightly job କୁ ଏକାଧିକ ଥର ଚଲାଇପାରେ, ଯାହା ଆପଣଙ୍କ ଡାଟାବେସ୍‌ରେ ଡୁପ୍ଲିକେଟ୍ ରେକର୍ଡ ସୃଷ୍ଟି କରେ। ଏହି ବିଷୟଟି ବିଶେଷ ଭାବରେ ପ୍ରାସଙ୍ଗିକ କାରଣ ଅଧିକରୁ ଅଧିକ କମ୍ପାନୀ microservices architecture ଆପଣାଉଛନ୍ତି, ଯେଉଁଠାରେ ସର୍ଭିସ୍‌ଗୁଡ଼ିକ horizontally scale ହୁଏ।

ସେଟଅପ୍

କଳ୍ପନା କରନ୍ତୁ ଯେ ଆପଣଙ୍କ ପାଖରେ ଏକ nightly job ଅଛି ଯାହା ଆପଣଙ୍କ ଆପ୍ଲିକେସନ୍‌ରେ ସକ୍ରିୟ entity ଗୁଡ଼ିକ ପାଇଁ ରେକର୍ଡ ତିଆରି କରେ। ଏହି job ଦିନକୁ ଥରେ ଚାଲିବା କଥା, ଯାହା ପ୍ରତ୍ୟେକ entity ପାଇଁ ଗୋଟିଏ ନୂଆ ରେକର୍ଡ ସୃଷ୍ଟି କରେ। ସର୍ଭର-ସାଇଡ୍ ଆପ୍ଲିକେସନ୍ ନିର୍ମାଣ ପାଇଁ ଏକ ଲୋକପ୍ରିୟ ଫ୍ରେମୱାର୍କ NestJS ବ୍ୟବହାର କରୁଥିବା ଏକ ସାଧାରଣ ସେଟଅପ୍‌ରେ, ଆପଣ ହୁଏତ @Cron ଏହି job କୁ schedule କରିବା ପାଇଁ 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);
        }
    }
}

ଆପଣଙ୍କ ସର୍ଭିସ୍‌ର ଏକ ସିଙ୍ଗଲ୍ ଇନଷ୍ଟାନ୍ସ ଚାଲୁଥିବା ସମୟରେ ଏହି କୋଡ୍ ସମ୍ପୂର୍ଣ୍ଣ ସଠିକ୍ ଭାବରେ କାମ କରେ। ତଥାପି, ଯେତେବେଳେ ଆପଣ ଏକାଧିକ ଇନଷ୍ଟାନ୍ସ ଚଲାଇ ଆପଣଙ୍କ ଆପ୍ଲିକେସନ୍‌କୁ horizontally scale କରନ୍ତି, ସେତେବେଳେ ସମସ୍ୟା ଦେଖାଦେଇପାରେ।

ସମସ୍ୟା

ଏକ scaled ସେଟଅପ୍‌ରେ, ଯଦି ଆପଣଙ୍କ ସର୍ଭିସ୍‌ର ତିନୋଟି ଇନଷ୍ଟାନ୍ସ ଥାଏ, ତେବେ ପ୍ରତ୍ୟେକ ଇନଷ୍ଟାନ୍ସ ଏକ ସମୟରେ ନିର୍ଦ୍ଧାରିତ job ର ନିଜସ୍ୱ କପି ଚଲାଇବ। ତେଣୁ, 08:00 ରେ ଗୋଟିଏ job ଚାଲିବା ପରିବର୍ତ୍ତେ, ଆପଣ ଏକାସାଙ୍ଗରେ ତିନୋଟି job ଚାଲୁଥିବାର ଦେଖିବେ। ପ୍ରତ୍ୟେକ ଇନଷ୍ଟାନ୍ସ ରେକର୍ଡଗୁଡ଼ିକ ପୂର୍ବରୁ ଅଛି କି ନାହିଁ ତାହା ଯାଞ୍ଚ ନକରି ନିଜର ରେକର୍ଡ ତିଆରି କରେ। ଏହାର ଫଳସ୍ୱରୂପ ଆପଣଙ୍କ ଡାଟାବେସ୍‌ରେ ଡୁପ୍ଲିକେଟ୍ ଏଣ୍ଟ୍ରି ସୃଷ୍ଟି ହୁଏ, ଯେଉଁଠାରେ ସମାନ entity ପାଇଁ କିଛି ସେକେଣ୍ଡ ବ୍ୟବଧାନରେ ଦୁଇଟି ସମାନ ରେକର୍ଡ ସୃଷ୍ଟି ହୋଇଯାଏ।

ଏହା କାହିଁକି ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ

ଡୁପ୍ଲିକେଟ୍ ଡାଟା ବିଭିନ୍ନ ସମସ୍ୟା ସୃଷ୍ଟି କରିପାରେ, ଯେଉଁଥିରେ data integrity ସମସ୍ୟା ଏବଂ ରିସୋର୍ସର ଅପଚୟ ଅନ୍ତର୍ଭୁକ୍ତ। ଆପଣ କେବଳ ଅନାବଶ୍ୟକ ରେକର୍ଡ ତିଆରି କରୁନାହାଁନ୍ତି, ବରଂ ସମାନ କାମ କରୁଥିବା ତିନୋଟି containers ର compute resources ପାଇଁ ମଧ୍ୟ ଦେୟ ଦେଉଛନ୍ତି।

ସମ୍ଭାବ୍ୟ ସମାଧାନ

ସମସ୍ୟା ଚିହ୍ନଟ କରିବା ପରେ, ଏହାର ସମାଧାନ କରିବା ପାଇଁ ଅନେକ ଉପାୟ ଅଛି:

ବିକଳ୍ପ ୧: ଏକ Distributed Lock ବ୍ୟବହାର କରନ୍ତୁ

ଗୋଟିଏ ସମାଧାନ ହୋଇପାରେ ଏକ distributed lock କାର୍ଯ୍ୟକାରୀ କରିବା। ଏହା ଇନଷ୍ଟାନ୍ସଗୁଡ଼ିକୁ ଏକ lock ପାଇଁ ପ୍ରତିଯୋଗିତା କରିବାକୁ ଅନୁମତି ଦେବ, ଯାହା ଫଳରେ କେବଳ ଗୋଟିଏ ଇନଷ୍ଟାନ୍ସ job କୁ ଚଲାଇପାରିବ। ତଥାପି, ଏହି ଉପାୟର କିଛି ନକାରାତ୍ମକ ଦିଗ ରହିଛି। ଯଦି lock backend ବିଫଳ ହୁଏ କିମ୍ବା lock ଧରିଥିବା ଅବସ୍ଥାରେ ଏକ ଇନଷ୍ଟାନ୍ସ ବନ୍ଦ ହୋଇଯାଏ, ତେବେ job ଆଦୌ ନ ଚାଲିପାରେ, ଯାହା missed executions ର କାରଣ ହୋଇପାରେ।

ବିକଳ୍ପ ୨: Idempotency କାର୍ଯ୍ୟକାରୀ କରନ୍ତୁ

ଅନ୍ୟ ଏକ ବିକଳ୍ପ ହେଉଛି ଏକ idempotency check ଯୋଡ଼ିବା। ଏହାର ଅର୍ଥ ହେଉଛି ଯଦି job ପୁଣି ଥରେ ଚାଲେ, ତେବେ ରେକର୍ଡଗୁଡ଼ିକ ପୂର୍ବରୁ ବିଦ୍ୟମାନ ଥିଲେ ଏହା ସେଗୁଡ଼ିକୁ ତିଆରି ନକରି କେବଳ skip କରିଦେବ। ଯଦିଓ ଏହା ଏକ କମ୍ ଖର୍ଚ୍ଚବହୁଳ ସମାଧାନ, ତଥାପି ଏହା ସମସ୍ତ ଇନଷ୍ଟାନ୍ସକୁ wake up କରାଏ, ଯାହା ଅନାବଶ୍ୟକ କାର୍ଯ୍ୟର କାରଣ ହୁଏ।

ବିକଳ୍ପ ୩: App ବାହାରକୁ Scheduling ସ୍ଥାନାନ୍ତର କରନ୍ତୁ

ଯେପରି ଜଣାପଡିଛି, ସର୍ବୋତ୍ତମ ସମାଧାନ ହେଉଛି ଆପ୍ଲିକେସନ୍ ବାହାରକୁ scheduling ନେଇଯିବା। Jobs କେବେ ଚାଲିବ ତାହା app ପରିଚାଳନା କରିବା ପରିବର୍ତ୍ତେ, ଏକ external scheduler କୁ ଏହା ସମ୍ଭାଳିବାକୁ ଦିଅନ୍ତୁ। ଏହି ଉପାୟରେ, ଆପଣ ଏକ HTTP endpoint ତିଆରି କରିପାରିବେ ଯାହାକୁ external scheduler ନିର୍ଦ୍ଧାରିତ ସମୟରେ ଥରେ trigger କରେ। ଏହା କିପରି ଦେଖାଯାଇପାରେ ତାହା ଏଠାରେ ଦିଆଗଲା:

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

ଏହି ସେଟଅପ୍ ସହିତ, କେବଳ ଗୋଟିଏ ଇନଷ୍ଟାନ୍ସ job trigger ର ଉତ୍ତର ଦେବ, ଯାହା ଡୁପ୍ଲିକେଟ୍ ରେକର୍ଡ ସୃଷ୍ଟି ହେବାକୁ ରୋକିବ। Idempotency check ବଜାୟ ରହିଥାଏ ଯାହା ନିଶ୍ଚିତ କରେ ଯେ ଯଦିଓ job ଏକାଧିକ ଥର trigger ହୁଏ, ତଥାପି ଏହା duplicates ସୃଷ୍ଟି କରିବ ନାହିଁ।

ଏହାର ଖର୍ଚ୍ଚ କ’ଣ

ଯେତେବେଳେ ଆପଣ ଏକ job କୁ HTTP endpoint ଭାବରେ expose କରନ୍ତି, ସେତେବେଳେ ଆପଣଙ୍କୁ ସୁରକ୍ଷା ବିଷୟରେ ବିଚାର କରିବାକୁ ପଡ଼ିବ। ଯେକେହି ଏହି endpoint ପାଇଲେ ସମ୍ଭାବ୍ୟ ଭାବରେ ଏହାକୁ trigger କରିପାରନ୍ତି। ଅନଧିକୃତ ପ୍ରବେଶକୁ ରୋକିବା ପାଇଁ, ଅନୁରୋଧଗୁଡ଼ିକୁ validate କରିବା ପାଇଁ ଏକ shared secret ବ୍ୟବହାର କରାଯାଏ। ଏହା ନିଶ୍ଚିତ କରେ ଯେ କେବଳ ବୈଧ triggers ହିଁ job କୁ execute କରିପାରିବେ।

ଅନ୍ୟ ଏକ ବିଚାର୍ଯ୍ୟ ବିଷୟ ହେଉଛି scheduling ସମୟ। ସମସ୍ତ ବ୍ୟବହାରକାରୀଙ୍କ ପାଇଁ ଦିନ ଆରମ୍ଭ ହେବା ପରେ job ଚାଲିବା ଉଚିତ, ଯାହା ଏକାଧିକ time zones ସହିତ କାର୍ଯ୍ୟ କରିବା ସମୟରେ ଜଟିଳ ହୋଇପାରେ। ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ UTC ଘଣ୍ଟା ବାଛିବା ବିଭିନ୍ନ ଅଞ୍ଚଳରେ ଏହାକୁ standardize କରିବାରେ ସାହାଯ୍ୟ କରିପାରିବ।

ଶିକ୍ଷା

ଏହି ଅଭିଜ୍ଞତା ଏକ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ ଶିକ୍ଷା ଉପରେ ଆଲୋକପାତ କରେ: ଏକ distributed system ରେ in-process scheduler ଅପ୍ରତ୍ୟାଶିତ ଆଚରଣ ସୃଷ୍ଟି କରିପାରେ। ଆପଣଙ୍କ ଆପ୍ଲିକେସନ୍‌କୁ scale କରିବା ସମୟରେ, application logic ରୁ scheduling concern କୁ ଅଲଗା କରିବା ଅତ୍ୟନ୍ତ ଆବଶ୍ୟକ। ଏପରି କରିବା ଦ୍ୱାରା, ଆପଣ duplicate writes ର ସମସ୍ୟାକୁ ଏଡାଇ ପାରିବେ ଏବଂ ନିଶ୍ଚିତ କରିପାରିବେ ଯେ ଆପଣଙ୍କ jobs ଉଦ୍ଦିଷ୍ଟ ଭାବରେ ଚାଲୁଛି।

ଉପସଂହାର

ସଂକ୍ଷେପରେ, ଏକ microservices architecture ରେ cron jobs ପରିଚାଳନା କରିବା ପାଇଁ ସତର୍କ ଯୋଜନା ଆବଶ୍ୟକ। ଆପଣଙ୍କ application ବାହାରକୁ scheduling ସ୍ଥାନାନ୍ତର କରି ଏବଂ ଉପଯୁକ୍ତ ଯାଞ୍ଚ କାର୍ଯ୍ୟକାରୀ କରି, ଆପଣ duplicate records ଭଳି ସମସ୍ୟାକୁ ରୋକିପାରିବେ ଏବଂ ଆପଣଙ୍କ ସର୍ଭିସ୍‌ଗୁଡ଼ିକର ଦକ୍ଷତା ବୃଦ୍ଧି କରିପାରିବେ।

ସୁବିଧାଗୁଡ଼ିକ

• ଡାଟାବେସ୍‌ରେ ଡୁପ୍ଲିକେଟ୍ ରେକର୍ଡକୁ ରୋକିଥାଏ।
• ଅନାବଶ୍ୟକ compute ଖର୍ଚ୍ଚ ହ୍ରାସ କରେ।
• Scheduling କୁ externalize କରି job management କୁ ସରଳ କରେ।

ଅସୁବିଧାଗୁଡ଼ିକ

• ଏକ external scheduler ପାଇଁ ଅତିରିକ୍ତ setup ଆବଶ୍ୟକ କରେ।
• HTTP requests ଏବଂ security ପରିଚାଳନାରେ ଜଟିଳତା ଆଣିଥାଏ।

ସତର୍କତା

ଏହି ଆର୍ଟିକିଲ୍ ଏକ ଶିକ୍ଷଣୀୟ ସମୀକ୍ଷା ଭାବରେ କାର୍ଯ୍ୟ କରେ। କୌଣସି placeholder values କୁ ଆପଣଙ୍କ ପ୍ରକୃତ configurations ସହିତ ବଦଳାଇବାକୁ ନିଶ୍ଚିତ କରନ୍ତୁ ଏବଂ ସେଗୁଡ଼ିକ ଉପରେ ନିର୍ଭର କରିବା ପୂର୍ବରୁ ମୂଳ ଉତ୍ସ ସହିତ ଦାବିଗୁଡ଼ିକୁ ଯାଞ୍ଚ କରନ୍ତୁ।

ବାରମ୍ବାର ପଚରାଯାଉଥିବା ପ୍ରଶ୍ନଗୁଡ଼ିକ

• ଏକ cron job କ’ଣ? — ଏକ cron job ହେଉଛି ଏକ scheduled task ଯାହା ନିର୍ଦ୍ଦିଷ୍ଟ ବ୍ୟବଧାନରେ ସ୍ୱୟଂଚାଳିତ ଭାବରେ ଚାଲେ।
• ମୋର cron job ଏକାଧିକ ଥର କାହିଁକି ଚାଲିଲା? — ଯଦି job ଆପଣଙ୍କ application ର ଏକାଧିକ instances ରେ schedule ହୋଇଥାଏ, ତେବେ ଏହା ଘଟିପାରେ।
• ମୁଁ ଏକ ଡାଟାବେସ୍‌ରେ duplicate records କୁ କିପରି ରୋକିପାରିବି? — Idempotency checks କାର୍ଯ୍ୟକାରୀ କରନ୍ତୁ କିମ୍ବା scheduling କୁ application ବାହାରକୁ ନେଇଯାଆନ୍ତୁ।
• ପ୍ରୋଗ୍ରାମିଂରେ idempotency କ’ଣ? — Idempotency ର ଅର୍ଥ ହେଉଛି ଏକ function ପ୍ରାରମ୍ଭିକ ପ୍ରୟୋଗ ବ୍ୟତୀତ ଫଳାଫଳକୁ ପରିବର୍ତ୍ତନ ନକରି ଏକାଧିକ ଥର call କରାଯାଇପାରିବ।
• NestJS କ’ଣ? — NestJS ହେଉଛି ଦକ୍ଷ, scalable Node.js server-side applications ନିର୍ମାଣ ପାଇଁ ଏକ framework।
• ମୁଁ ମୋର HTTP endpoints କୁ କିପରି ସୁରକ୍ଷିତ କରିବି? — Requests validate କରିବା ପାଇଁ shared secrets କିମ୍ବା tokens ଭଳି authentication methods ବ୍ୟବହାର କରନ୍ତୁ।

ଟ୍ୟାଗ୍‌ଗୁଡ଼ିକ

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