பேக்எண்ட் பயிற்சிகளில் உள்ள பொறி
பயிற்சிகள் உங்களுக்கு ஒரு எளிய செயல்முறையைக் காட்டுகின்றன. ஒரு webhook-ஐப் பெறுங்கள். தரவுத்தளத்தைப் (database) புதுப்பிக்கவும். 200 OK-வைத் திருப்பி அனுப்பவும்.
உங்கள் குறியீடு (code) சோதனையில் சரியாக வேலை செய்கிறது. அதை நீங்கள் தயாரிப்புச் சூழலுக்கு (production) கொண்டு செல்கிறீர்கள். பிறகு உங்கள் தரவுத்தளத்தில் நகல் பதிவுகளை (duplicate records) காண்கிறீர்கள். பயனர்களுக்கு இருமுறைத் தொகை வரவு வைக்கப்படுகிறது. தரவுப் பதிவுகள் குவிகின்றன.
நெட்வொர்க் தோல்வியின் யதார்த்தத்தை பயிற்சிகள் புறக்கணிக்கின்றன.
பிரச்சனை: நம்பகத்தன்மையற்ற நெட்வொர்க்குகள் நெட்வொர்க்குகள் செயலிழக்கக்கூடும். உங்கள் சர்வர் தரவை மெதுவாகச் செயலாக்கலாம். ஒரு DNS பிழை உங்கள் 200 OK பதிலானது அனுப்புநரைச் சென்றடைவதைத் தடுக்கலாம்.
ஒரு சேவை உங்கள் உறுதிப்படுத்தலைப் பெறாதபோது, அது மீண்டும் முயற்சிக்கும் (retry). அது அதே webhook-ஐ மீண்டும் அனுப்பும். உங்கள் குறியீடு ஒவ்வொரு கோரிக்கையையும் ஏற்றுக்கொண்டால், நீங்கள் நகல்களை உருவாக்குகிறீர்கள்.
தீர்வு: Idempotency Idempotency என்பது பலமுறை ஒரே மாதிரியான கோரிக்கைகளை அனுப்பினாலும், அது ஒருமுறை கோரிக்கை அனுப்புவதைப் போன்றே ஒரே விளைவை ஏற்படுத்துவதைக் குறிக்கிறது.
ஒரு லிஃப்ட் பட்டனைப் பற்றி யோசியுங்கள். 5-வது தளத்திற்கான பட்டனை ஒருமுறை அழுத்தினால், லிஃப்ட் எங்கு செல்ல வேண்டும் என்று அதற்குத் தெரியும். அதை பத்து முறை அழுத்தினாலும், அது லிஃப்ட்டை 50-வது தளத்திற்கு அனுப்பாது. முடிவு மாறாமல் அப்படியே இருக்கும்.
உங்கள் webhook அந்தப் பட்டனைப் போலவே செயல்பட வேண்டும்.
இதைச் சரிசெய்வது எப்படி பாதுகாப்பான webhooks-களை உருவாக்க இந்த வழிமுறைகளைப் பின்பற்றுங்கள்:
- நிகழ்வின் (event) தனித்துவமான ID-யைக் கண்டறியவும்.
- எதையும் செய்வதற்கு முன், உங்கள் தரவுத்தளத்தில் அந்த ID உள்ளதா என்று சரிபார்க்கவும்.
- ID ஏற்கனவே இருந்தால், நிறுத்திவிடவும். அனுப்புநர் மீண்டும் முயற்சி செய்வதைத் தவிர்க்க 200 OK-வை அனுப்பவும்.
- ID புதியது என்றால், தரவைச் செயலாக்கவும்.
- நிகழ்வின் ID-யை உடனடியாக உங்கள் தரவுத்தளத்தில் சேமிக்கவும்.
Node.js-இல் உதாரண லாஜிக்:
const eventId = req.body.event_id;
const existingEvent = await db.processedEvents.findUnique({ where: { id: eventId } });
if (existingEvent) { return res.status(200).send('Already processed'); }
await updateUserData(req.body.data); await db.processedEvents.create({ data: { id: eventId } });
return res.status(200).send('Success');
சரியான சூழல்களுக்காக அமைப்புகளை உருவாக்குவது எளிது. தோல்விகளைக் கையாளும் வகையில் அமைப்புகளை உருவாக்குவதே உண்மையான பொறியியல் (engineering) ஆகும்.
மீண்டும் முயற்சிப்பதால் (retries) ஏற்படும் நகல் தரவுகளைக் கையாண்டதுண்டா? நீங்கள் idempotency-யை எவ்வாறு கையாளுகிறீர்கள்?