બેકએન્ડ ટ્યુટોરિયલ્સમાં રહેલો પડકાર
ટ્યુટોરિયલ્સ તમને એક સરળ પ્રક્રિયા બતાવે છે. એક webhook મેળવો. ડેટાબેઝ અપડેટ કરો. 200 OK રિટર્ન કરો.
તમારો કોડ ટેસ્ટિંગમાં કામ કરે છે. તમે તેને પ્રોડક્શનમાં પush કરો છો. પછી તમે તમારા ડેટાબેઝમાં ડુપ્લીકેટ રેકોર્ડ્સ જુઓ છો. યુઝર્સના ખાતામાં બે વાર ક્રેડિટ થઈ જાય છે. ડેટા એન્ટ્રીઓનો ઢગલો થઈ જાય છે.
ટ્યુટોરિયલ્સ નેટવર્ક નિષ્ફળતાની વાસ્તવિકતાને અવગણે છે.
સમસ્યા: અવિશ્વસનીય નેટવર્ક (Unreliable Networks) નેટવર્ક નિષ્ફળ જાય છે. તમારું સર્વર ડેટા પ્રોસેસ કરવામાં ધીમું હોઈ શકે છે. DNS ભૂલને કારણે તમારો 200 OK પ્રતિસાદ (response) મોકલનાર સુધી પહોંચતો અટકી શકે છે.
જ્યારે કોઈ સર્વિસને તમારો કન્ફર્મેશન મળતો નથી, ત્યારે તે ફરીથી પ્રયાસ (retry) કરે છે. તે ફરીથી એ જ webhook મોકલે છે. જો તમારો કોડ દરેક રિક્વેસ્ટ સ્વીકારી લેશે, તો તમે ડુપ્લીકેટ ડેટા બનાવશો.
ઉકેલ: Idempotency Idempotency નો અર્થ એ છે કે એકસરખી અને વારંવાર કરવામાં આવેલી રિક્વેસ્ટનો પરિણામ એક જ રિક્વેસ્ટ જેટલું જ રહે.
લિફ્ટના બટન વિશે વિચારો. 5મા માળ માટેનું બટન એકવાર દબાવવાથી લિફ્ટને ખબર પડે છે કે ક્યાં જવું છે. તેને દસ વાર દબાવવાથી લિફ્ટ 50મા માળે નથી જતી. પરિણામ સમાન રહે છે.
તમારું webhook પણ તે બટનની જેમ કામ કરવું જોઈએ.
તેને કેવી રીતે સુધારવું સુરક્ષિત webhooks બનાવવા માટે આ સ્ટેપ્સ અનુસરો:
- ઇવેન્ટની યુનિક ID શોધો.
- કંઈપણ કરતા પહેલા તમારા ડેટાબેઝમાં તે ID તપાસો.
- જો ID અસ્તિત્વમાં હોય, તો અટકી જાઓ. 200 OK રિટર્ન કરો જેથી મોકલનાર ફરીથી પ્રયાસ કરવાનું બંધ કરી દે.
- જો ID નવું હોય, તો ડેટા પ્રોસેસ કરો.
- ઇવેન્ટ ID ને તરત જ તમારા ડેટાબેઝમાં સેવ કરો.
Example Logic in 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');
આદર્શ પરિસ્થિતિઓ માટે સિસ્ટમ બનાવવી સરળ છે. નિષ્ફળતા (failure) ને ધ્યાનમાં રાખીને સિસ્ટમ બનાવવી એ સાચી એન્જિનિયરિંગ છે.
શું તમે રિટ્રાયઝ (retries) ને કારણે ડુપ્લીકેટ ડેટાનો સામનો કર્યો છે? તમે Idempotency ને કેવી રીતે હેન્ડલ કરો છો?