AWS Lambda-യിലെ Amazon DynamoDB 503

Daniel Marino

2024, നവംബർ 7, വ്യാഴാഴ്‌ച 11:44:57 AM

സെർവർലെസ് ആപ്ലിക്കേഷനുകളിൽ നിഗൂഢമായ DynamoDB പിശകുകൾ കൈകാര്യം ചെയ്യുന്നു
ഇത് സങ്കൽപ്പിക്കുക: ഘടകങ്ങൾ തമ്മിലുള്ള സുഗമമായ ഡാറ്റാ ഇടപെടലുകൾ പ്രതീക്ഷിക്കുന്ന AWS Lambda ഫംഗ്‌ഷനുകൾ, API ഗേറ്റ്‌വേ, DynamoDB എന്നിവ ഉപയോഗിച്ച് നിങ്ങൾ ഒരു സെർവർലെസ് ആർക്കിടെക്ചർ നിർമ്മിച്ചു. എന്നാൽ പെട്ടെന്ന്, എ DynamoDB-ലേക്കുള്ള നിങ്ങളുടെ കോളുകളെ തടസ്സപ്പെടുത്തിക്കൊണ്ട് പ്രത്യക്ഷപ്പെടാൻ തുടങ്ങുന്നു. 😕
ഇത് സംഭവിക്കുമ്പോൾ ഇത് നിരാശാജനകമാണ്, പ്രത്യേകിച്ചും 503 പിശകുകൾ സാധാരണയായി താൽക്കാലിക ലഭ്യതയെ സൂചിപ്പിക്കുന്നു, എന്നിട്ടും നിങ്ങളുടെ CloudWatch ലോഗുകൾ കാണിച്ചേക്കാം വിജയകരമായി നടപ്പിലാക്കി. സമയപരിധി വർദ്ധിപ്പിക്കുന്നത് മുതൽ ഇഷ്‌ടാനുസൃത R/W പ്രൊവിഷനിംഗ് വരെ നിങ്ങൾ പരീക്ഷിച്ചിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾ ഒറ്റയ്ക്കല്ല.
ഇതുപോലുള്ള സാഹചര്യങ്ങളിൽ, പ്രശ്നം നിർണ്ണയിക്കുന്നത് പലപ്പോഴും ഒരു പ്രേതത്തെ പിന്തുടരുന്നതായി അനുഭവപ്പെടും, പ്രത്യേകിച്ചും അത് നിങ്ങളുടെ കോഡിൻ്റെ ഒരു പ്രത്യേക വിഭാഗത്തിൽ ഒതുങ്ങിനിൽക്കുന്നതായി തോന്നുമ്പോൾ. ഇത്തരത്തിലുള്ള പ്രശ്‌നങ്ങൾ ഉൽപ്പാദനക്ഷമതയെ തടസ്സപ്പെടുത്തും, പ്രത്യേകിച്ചും നിങ്ങളുടെ കോഡ് കുറ്റമറ്റതാണെങ്കിലും അപ്രതീക്ഷിതമായി പരാജയപ്പെടുമ്പോൾ.
ഈ അവ്യക്തതയ്ക്ക് കാരണമായേക്കാവുന്നതെന്താണെന്ന് ഈ ലേഖനത്തിൽ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും നിങ്ങളുടെ API ഗേറ്റ്‌വേയിലും അവ എങ്ങനെ ഫലപ്രദമായി പരിഹരിക്കാമെന്നും. റീട്രി ലോജിക് മുതൽ ത്രോട്ടിലിംഗ് അഡ്ജസ്റ്റ്‌മെൻ്റുകൾ വരെ, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ സുഗമമായി പ്രവർത്തിക്കുന്നതിന് ഞങ്ങൾ പ്രായോഗിക പരിഹാരങ്ങളിലൂടെ കടന്നുപോകും.

കമാൻഡ് ഉപയോഗത്തിൻ്റെ വിവരണവും ഉദാഹരണവും

dynamodb.get(params).promise() ഈ DynamoDB കമാൻഡ് പാരാമുകളിലെ നിർദ്ദിഷ്ട കീ പാരാമീറ്ററുകളെ അടിസ്ഥാനമാക്കി ഒരു ഇനം വീണ്ടെടുക്കുന്നു. എസിൻക്രണസ് ഫംഗ്‌ഷനുകളിൽ വെയ്‌റ്റിൻ്റെ ഉപയോഗം അനുവദിക്കുന്ന പ്രവർത്തനത്തെ അസമന്വിതമായി കൈകാര്യം ചെയ്യുന്നതിനായി .promise() രീതി ചേർത്തിരിക്കുന്നു. DynamoDB-ൽ നിന്ന് നേരിട്ട് കൃത്യമായ ഡാറ്റ വീണ്ടെടുക്കേണ്ട കേസുകൾക്ക് അത്യന്താപേക്ഷിതമാണ്.

delay(ms) എംഎസ് മില്ലിസെക്കൻഡുകൾക്ക് ശേഷം പരിഹരിക്കുന്ന ഒരു വാഗ്ദാനത്തെ തിരികെ നൽകിക്കൊണ്ട് കാലതാമസം സൃഷ്ടിക്കാൻ ഒരു സഹായി ഫംഗ്ഷൻ നിർവചിച്ചിരിക്കുന്നു. ഇത് എക്‌സ്‌പോണൻഷ്യൽ ബാക്ക്ഓഫ് ഉപയോഗിച്ച് വീണ്ടും പ്രവർത്തനക്ഷമത പ്രാപ്‌തമാക്കുന്നു, താൽക്കാലിക സേവന ലഭ്യതക്കുറവ് കാരണം 503 പിശകുകൾ ലഘൂകരിക്കാനുള്ള ഉപയോഗപ്രദമായ സമീപനമാണിത്.

await fetch() ഒരു API എൻഡ്‌പോയിൻ്റിൽ നിന്ന് ഡാറ്റ ലഭ്യമാക്കുന്നതിനുള്ള ഒരു അസിൻക്രണസ് കോളാണിത്. ഈ സാഹചര്യത്തിൽ, Lambda ഫംഗ്‌ഷൻ്റെ URL-ൽ നിന്ന് ഡാറ്റ ആക്‌സസ് ചെയ്യാൻ ഇത് ഉപയോഗിക്കുന്നു. കാത്തിരിപ്പ് ഉൾപ്പെടെ, തുടരുന്നതിന് മുമ്പ് ഫംഗ്‌ഷൻ പ്രതികരണത്തിനായി കാത്തിരിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു, ഇത് വീണ്ടും ശ്രമിക്കൽ പോലുള്ള തുടർച്ചയായ പ്രക്രിയകൾ കൈകാര്യം ചെയ്യുന്നതിന് നിർണായകമാണ്.

response.status ലഭ്യമാക്കാനുള്ള അഭ്യർത്ഥനയിൽ നിന്ന് HTTP പ്രതികരണ സ്റ്റാറ്റസ് കോഡ് പരിശോധിക്കാൻ ഉപയോഗിക്കുന്നു. ഇവിടെ, ഒരു 503 സ്റ്റാറ്റസ് തിരിച്ചറിയാൻ response.status പരിശോധിക്കുന്നു, അത് വീണ്ടും ശ്രമിക്കുന്നതിന് കാരണമാകുന്നു. സേവന ലഭ്യത പ്രശ്നങ്ങൾ തിരിച്ചറിയുന്നതിന് നിർണായകമായ ഒരു പ്രത്യേക പിശക് കൈകാര്യം ചെയ്യുന്ന സമീപനമാണിത്.

exports.handler ലാംഡ ഹാൻഡ്‌ലർ ഫംഗ്‌ഷൻ എക്‌സ്‌പോർട്ട് ചെയ്യാൻ ഈ വാക്യഘടന ഉപയോഗിക്കുന്നു, അതുവഴി AWS ലാംഡയ്ക്ക് അത് അഭ്യർത്ഥിക്കാൻ കഴിയും. AWS സേവനങ്ങളുമായി സംയോജിപ്പിക്കുന്നതിന് ആവശ്യമായ ലാംഡ ഫംഗ്‌ഷനിലേക്ക് അയച്ച ഇവൻ്റുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള പ്രധാന എൻട്രി പോയിൻ്റ് ഇത് നിർവചിക്കുന്നു.

JSON.parse(event.body) Lambda ഇവൻ്റിൻ്റെ സ്ട്രിംഗിഫൈഡ് ബോഡി ഒരു JavaScript ഒബ്‌ജക്റ്റിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. ലാംഡ ഒരു JSON സ്ട്രിംഗ് ആയി അഭ്യർത്ഥന ബോഡി കടന്നുപോകുന്നതിനാൽ ഇത് ആവശ്യമാണ്, അതിനാൽ ഫംഗ്‌ഷനിലെ അഭ്യർത്ഥന ഡാറ്റ ആക്‌സസ് ചെയ്യുന്നതിന് ഇത് പാഴ്‌സ് ചെയ്യുന്നത് നിർണായകമാണ്.

expect().toBe() ഒരു നിർദ്ദിഷ്ട മൂല്യം പ്രതീക്ഷിക്കുന്ന ഫലവുമായി പൊരുത്തപ്പെടുന്നുവെന്ന് ഉറപ്പിക്കാൻ ടെസ്റ്റിംഗിൽ ഉപയോഗിക്കുന്ന ഒരു ജെസ്റ്റ് കമാൻഡ്. ഉദാഹരണത്തിന്, പ്രതീക്ഷിക്കുക(response.statusCode).toBe(200) ലാംഡ ഫംഗ്‌ഷൻ 200 സ്റ്റാറ്റസ് കോഡ് നൽകുന്നു എന്ന് ഉറപ്പാക്കുന്നു. ഇത് ലാംഡ പ്രതീക്ഷിച്ച പോലെ പ്രവർത്തിക്കുന്നുവെന്ന് സാധൂകരിക്കാൻ സഹായിക്കുന്നു.

useEffect(() =>useEffect(() => {}, []) ഈ റിയാക്റ്റ് ഹുക്കിനെ ഘടകം മൗണ്ടിൽ വിളിക്കുന്നു. ഒരു ശൂന്യമായ ഡിപൻഡൻസി അറേ കടന്നുപോകുന്നതിലൂടെ, അത് ഒരിക്കൽ മാത്രം പ്രവർത്തിക്കുന്നു, ഘടകം ലോഡ് ചെയ്യുമ്പോൾ ഡാറ്റ ലഭ്യമാക്കുന്നതിന് ഇത് അനുയോജ്യമാക്കുന്നു. API കോളുകൾ പോലെ, ഇനിഷ്യലൈസേഷൻ ആവശ്യമുള്ള ഫ്രണ്ട്-എൻഡ് ഘടകങ്ങൾക്ക് അത്യന്താപേക്ഷിതമാണ്.

waitFor() ടെസ്റ്റുമായി മുന്നോട്ട് പോകുന്നതിന് മുമ്പ് ഒരു നിബന്ധന പാലിക്കുന്നത് വരെ കാത്തിരിക്കുന്ന ഒരു റിയാക്റ്റ് ടെസ്റ്റിംഗ് ലൈബ്രറി കമാൻഡ്. ഈ സാഹചര്യത്തിൽ, അസിൻക്രണസ് ഡാറ്റ റെൻഡറിംഗ് സ്ഥിരീകരിക്കുന്നതിന് നിർണ്ണായകമായ, ലഭിച്ച ഡാറ്റ കാണിക്കുന്ന ഘടകം ഉറപ്പാക്കാൻ ഇത് ഉപയോഗിക്കുന്നു.

കമാൻഡ്	ഉപയോഗത്തിൻ്റെ വിവരണവും ഉദാഹരണവും
dynamodb.get(params).promise()	ഈ DynamoDB കമാൻഡ് പാരാമുകളിലെ നിർദ്ദിഷ്ട കീ പാരാമീറ്ററുകളെ അടിസ്ഥാനമാക്കി ഒരു ഇനം വീണ്ടെടുക്കുന്നു. എസിൻക്രണസ് ഫംഗ്‌ഷനുകളിൽ വെയ്‌റ്റിൻ്റെ ഉപയോഗം അനുവദിക്കുന്ന പ്രവർത്തനത്തെ അസമന്വിതമായി കൈകാര്യം ചെയ്യുന്നതിനായി .promise() രീതി ചേർത്തിരിക്കുന്നു. DynamoDB-ൽ നിന്ന് നേരിട്ട് കൃത്യമായ ഡാറ്റ വീണ്ടെടുക്കേണ്ട കേസുകൾക്ക് അത്യന്താപേക്ഷിതമാണ്.
delay(ms)	എംഎസ് മില്ലിസെക്കൻഡുകൾക്ക് ശേഷം പരിഹരിക്കുന്ന ഒരു വാഗ്ദാനത്തെ തിരികെ നൽകിക്കൊണ്ട് കാലതാമസം സൃഷ്ടിക്കാൻ ഒരു സഹായി ഫംഗ്ഷൻ നിർവചിച്ചിരിക്കുന്നു. ഇത് എക്‌സ്‌പോണൻഷ്യൽ ബാക്ക്ഓഫ് ഉപയോഗിച്ച് വീണ്ടും പ്രവർത്തനക്ഷമത പ്രാപ്‌തമാക്കുന്നു, താൽക്കാലിക സേവന ലഭ്യതക്കുറവ് കാരണം 503 പിശകുകൾ ലഘൂകരിക്കാനുള്ള ഉപയോഗപ്രദമായ സമീപനമാണിത്.
await fetch()	ഒരു API എൻഡ്‌പോയിൻ്റിൽ നിന്ന് ഡാറ്റ ലഭ്യമാക്കുന്നതിനുള്ള ഒരു അസിൻക്രണസ് കോളാണിത്. ഈ സാഹചര്യത്തിൽ, Lambda ഫംഗ്‌ഷൻ്റെ URL-ൽ നിന്ന് ഡാറ്റ ആക്‌സസ് ചെയ്യാൻ ഇത് ഉപയോഗിക്കുന്നു. കാത്തിരിപ്പ് ഉൾപ്പെടെ, തുടരുന്നതിന് മുമ്പ് ഫംഗ്‌ഷൻ പ്രതികരണത്തിനായി കാത്തിരിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു, ഇത് വീണ്ടും ശ്രമിക്കൽ പോലുള്ള തുടർച്ചയായ പ്രക്രിയകൾ കൈകാര്യം ചെയ്യുന്നതിന് നിർണായകമാണ്.
response.status	ലഭ്യമാക്കാനുള്ള അഭ്യർത്ഥനയിൽ നിന്ന് HTTP പ്രതികരണ സ്റ്റാറ്റസ് കോഡ് പരിശോധിക്കാൻ ഉപയോഗിക്കുന്നു. ഇവിടെ, ഒരു 503 സ്റ്റാറ്റസ് തിരിച്ചറിയാൻ response.status പരിശോധിക്കുന്നു, അത് വീണ്ടും ശ്രമിക്കുന്നതിന് കാരണമാകുന്നു. സേവന ലഭ്യത പ്രശ്നങ്ങൾ തിരിച്ചറിയുന്നതിന് നിർണായകമായ ഒരു പ്രത്യേക പിശക് കൈകാര്യം ചെയ്യുന്ന സമീപനമാണിത്.
exports.handler	ലാംഡ ഹാൻഡ്‌ലർ ഫംഗ്‌ഷൻ എക്‌സ്‌പോർട്ട് ചെയ്യാൻ ഈ വാക്യഘടന ഉപയോഗിക്കുന്നു, അതുവഴി AWS ലാംഡയ്ക്ക് അത് അഭ്യർത്ഥിക്കാൻ കഴിയും. AWS സേവനങ്ങളുമായി സംയോജിപ്പിക്കുന്നതിന് ആവശ്യമായ ലാംഡ ഫംഗ്‌ഷനിലേക്ക് അയച്ച ഇവൻ്റുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള പ്രധാന എൻട്രി പോയിൻ്റ് ഇത് നിർവചിക്കുന്നു.
JSON.parse(event.body)	Lambda ഇവൻ്റിൻ്റെ സ്ട്രിംഗിഫൈഡ് ബോഡി ഒരു JavaScript ഒബ്‌ജക്റ്റിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. ലാംഡ ഒരു JSON സ്ട്രിംഗ് ആയി അഭ്യർത്ഥന ബോഡി കടന്നുപോകുന്നതിനാൽ ഇത് ആവശ്യമാണ്, അതിനാൽ ഫംഗ്‌ഷനിലെ അഭ്യർത്ഥന ഡാറ്റ ആക്‌സസ് ചെയ്യുന്നതിന് ഇത് പാഴ്‌സ് ചെയ്യുന്നത് നിർണായകമാണ്.
expect().toBe()	ഒരു നിർദ്ദിഷ്ട മൂല്യം പ്രതീക്ഷിക്കുന്ന ഫലവുമായി പൊരുത്തപ്പെടുന്നുവെന്ന് ഉറപ്പിക്കാൻ ടെസ്റ്റിംഗിൽ ഉപയോഗിക്കുന്ന ഒരു ജെസ്റ്റ് കമാൻഡ്. ഉദാഹരണത്തിന്, പ്രതീക്ഷിക്കുക(response.statusCode).toBe(200) ലാംഡ ഫംഗ്‌ഷൻ 200 സ്റ്റാറ്റസ് കോഡ് നൽകുന്നു എന്ന് ഉറപ്പാക്കുന്നു. ഇത് ലാംഡ പ്രതീക്ഷിച്ച പോലെ പ്രവർത്തിക്കുന്നുവെന്ന് സാധൂകരിക്കാൻ സഹായിക്കുന്നു.
useEffect(() =>useEffect(() => {}, [])	ഈ റിയാക്റ്റ് ഹുക്കിനെ ഘടകം മൗണ്ടിൽ വിളിക്കുന്നു. ഒരു ശൂന്യമായ ഡിപൻഡൻസി അറേ കടന്നുപോകുന്നതിലൂടെ, അത് ഒരിക്കൽ മാത്രം പ്രവർത്തിക്കുന്നു, ഘടകം ലോഡ് ചെയ്യുമ്പോൾ ഡാറ്റ ലഭ്യമാക്കുന്നതിന് ഇത് അനുയോജ്യമാക്കുന്നു. API കോളുകൾ പോലെ, ഇനിഷ്യലൈസേഷൻ ആവശ്യമുള്ള ഫ്രണ്ട്-എൻഡ് ഘടകങ്ങൾക്ക് അത്യന്താപേക്ഷിതമാണ്.
waitFor()	ടെസ്റ്റുമായി മുന്നോട്ട് പോകുന്നതിന് മുമ്പ് ഒരു നിബന്ധന പാലിക്കുന്നത് വരെ കാത്തിരിക്കുന്ന ഒരു റിയാക്റ്റ് ടെസ്റ്റിംഗ് ലൈബ്രറി കമാൻഡ്. ഈ സാഹചര്യത്തിൽ, അസിൻക്രണസ് ഡാറ്റ റെൻഡറിംഗ് സ്ഥിരീകരിക്കുന്നതിന് നിർണ്ണായകമായ, ലഭിച്ച ഡാറ്റ കാണിക്കുന്ന ഘടകം ഉറപ്പാക്കാൻ ഇത് ഉപയോഗിക്കുന്നു.

AWS Lambda, DynamoDB 503 പിശകുകൾ ഫലപ്രദമായ റീട്രി ലോജിക് ഉപയോഗിച്ച് പരിഹരിക്കുന്നു

ഒരു അഭ്യർത്ഥിക്കുമ്പോൾ പലപ്പോഴും നേരിടുന്ന വെല്ലുവിളി നിറഞ്ഞ 503 പിശക് കൈകാര്യം ചെയ്യുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്ന ഉദാഹരണ സ്ക്രിപ്റ്റുകൾ എയിൽ നിന്ന് വായിക്കാനുള്ള പ്രവർത്തനം മേശ. ലാംഡ, എപിഐ ഗേറ്റ്‌വേ ഇടപെടലുകൾക്ക് ചിലപ്പോൾ ട്രബിൾഷൂട്ടിംഗിൽ വ്യക്തതയില്ലാത്തതിനാൽ താൽക്കാലിക ലഭ്യതയെ സൂചിപ്പിക്കുന്ന ഈ പിശക് നിരാശാജനകമാണ്. പ്രാഥമിക ബാക്കെൻഡ് ഫംഗ്ഷൻ, , SKU ഐഡി വഴി DynamoDB-യെ അന്വേഷിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. സാധ്യതയുള്ള 503 പിശകുകൾ ഭംഗിയായി കൈകാര്യം ചെയ്യുന്നതിന്, ഒരു ഇഷ്‌ടാനുസൃതമായി നടപ്പിലാക്കിയ എക്‌സ്‌പോണൻഷ്യൽ ബാക്ക്ഓഫുള്ള ഒരു വീണ്ടും ശ്രമിക്കാനുള്ള സംവിധാനം ഇതിൽ ഉൾപ്പെടുന്നു. കാലതാമസം പ്രവർത്തനം. ഈ രീതിയിൽ, ഒരു അഭ്യർത്ഥന പരാജയപ്പെടുകയാണെങ്കിൽ, ഓരോ ശ്രമത്തിനും ഇടയിൽ സ്ക്രിപ്റ്റ് ക്രമേണ കൂടുതൽ സമയം കാത്തിരിക്കുന്നു. സെർവർ ഓവർലോഡ് കുറയ്ക്കുന്നതിനും ഉയർന്ന ട്രാഫിക്കുള്ള സാഹചര്യങ്ങളിൽ വീണ്ടും ശ്രമിക്കുന്നതിൻ്റെ ആവൃത്തി കുറയ്ക്കുന്നതിനും ഈ സമീപനം അത്യന്താപേക്ഷിതമാണ്.

സ്‌ക്രിപ്റ്റിൽ ഒരു ലാംഡ ഹാൻഡ്‌ലർ ഫംഗ്‌ഷനും ഉൾപ്പെടുന്നു, അത് കോൾ പൊതിയുന്നു കൂടാതെ API ഗേറ്റ്‌വേ അഭ്യർത്ഥന പേലോഡ് കൈകാര്യം ചെയ്യുന്നു. ഉപയോഗിച്ച് , ഇത് API ഗേറ്റ്‌വേയിൽ നിന്നുള്ള ഇൻകമിംഗ് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുകയും ഇഷ്‌ടാനുസൃത HTTP സ്റ്റാറ്റസ് കോഡുകൾ ഉപയോഗിച്ച് പിശക് കൈകാര്യം ചെയ്യൽ പ്രവർത്തനക്ഷമമാക്കുകയും ചെയ്യുന്നു. ഡാറ്റ വീണ്ടെടുക്കൽ വിജയകരമാണെങ്കിൽ മാത്രമേ API ഗേറ്റ്‌വേയ്ക്ക് 200 സ്റ്റാറ്റസ് ലഭിക്കൂ എന്ന് ഉറപ്പാക്കാൻ ഈ നിർദ്ദിഷ്ട സജ്ജീകരണം സഹായിക്കുന്നു. ചലനാത്മകത പോലെ തടസ്സങ്ങളില്ലാത്ത ഡാറ്റ വീണ്ടെടുക്കൽ അനിവാര്യമായ ആപ്ലിക്കേഷനുകൾക്കുള്ള ഒരു പ്രായോഗിക രീതിയാണിത് ഷിപ്പിംഗ് ഡാറ്റ തത്സമയം പ്രദർശിപ്പിക്കുന്നു. ഇവിടെ, പിശകുകൾ അല്ലെങ്കിൽ ഡാറ്റ ആക്‌സസിലെ കാലതാമസം എന്നിവ ഫ്രണ്ട് എൻഡ് വായിക്കാൻ കഴിയുന്ന സന്ദേശങ്ങളിലേക്ക് വിവർത്തനം ചെയ്യുന്നതിന് ഹാൻഡ്‌ലർ ഫംഗ്‌ഷൻ അത്യന്താപേക്ഷിതമാണ്, ഇത് ഉപയോക്താക്കൾക്ക് നിഗൂഢമായ പിശക് കോഡുകൾക്ക് പകരം വ്യക്തമായ പ്രതികരണങ്ങൾ നൽകുന്നു. 🚀

ക്ലയൻ്റ് ഭാഗത്ത്, ഞങ്ങൾ പിശക് കൈകാര്യം ചെയ്യുന്നത് വ്യത്യസ്തമായി കൈകാര്യം ചെയ്യുന്നു. ദി എച്ച്ടിടിപി സ്റ്റാറ്റസ് പ്രതികരണം പരിശോധിച്ചുകൊണ്ട് ഫംഗ്ഷൻ അതിൻ്റേതായ റീട്രി ലോജിക്ക് ഉൾക്കൊള്ളുന്നു. ഇത് 503 പിശക് കണ്ടെത്തിയാൽ, ഫംഗ്‌ഷൻ ഒരു പുരോഗമന കാലതാമസത്തോടെ വീണ്ടും ശ്രമിക്കാൻ പ്രേരിപ്പിക്കുന്നു, ഉപയോക്തൃ ഇൻ്റർഫേസ് പ്രതികരണശേഷി നിലനിർത്തുകയും ഉടനടി പിശകുകൾ ഒഴിവാക്കുകയും ചെയ്യുന്നു. ഈ സമീപനം നിർണായകമാണ് യൂസ് ഇഫക്റ്റ് ഹുക്കിൽ കാണുന്നത് പോലെ മൗണ്ടിൽ API കോളുകൾ ഉണ്ടാക്കുന്നു. ഒന്നിലധികം SKU-കൾക്കായി ഡാറ്റ ലഭ്യമാക്കുമ്പോൾ, സേവന ത്രോട്ടിലിംഗ് സാധ്യതയുണ്ടെങ്കിലും ഓരോ കോളിനും ആവശ്യമായ ഡാറ്റ ലഭിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ ഈ പുനഃശ്രമങ്ങൾ സഹായിക്കുന്നു. ഉപയോക്താക്കൾക്ക് ഇത് ഒരു പിശക് എന്നതിലുപരി ഹ്രസ്വമായ ലോഡിംഗ് ആനിമേഷനായി അനുഭവപ്പെടും, ഇത് സുഗമവും കൂടുതൽ പ്രൊഫഷണൽ അനുഭവവും സൃഷ്ടിക്കുന്നു.

വിശ്വാസ്യത സ്ഥിരീകരിക്കുന്നതിന്, ഉദാഹരണത്തിൽ ബാക്കെൻഡ്, ഫ്രണ്ട്എൻഡ് ഫംഗ്‌ഷനുകൾക്കുള്ള യൂണിറ്റ് ടെസ്റ്റുകൾ ഉൾപ്പെടുന്നു. ഉപയോഗിക്കുന്നത് ഒപ്പം , ഈ ടെസ്റ്റുകൾ ഓരോ ഫംഗ്ഷനും വ്യത്യസ്ത സാഹചര്യങ്ങളിൽ ശരിയായി പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു. ഉദാഹരണത്തിന്, ലാംഡ ഹാൻഡ്‌ലർ പ്രതീക്ഷിക്കുന്ന SKU ഡാറ്റ തിരികെ നൽകുന്നുവെന്നും അത് ഞങ്ങൾ പരിശോധിക്കുന്നു പ്രവർത്തനം ഭംഗിയായി പരാജയത്തിൽ വീണ്ടും ശ്രമിക്കുന്നു. ഈ പരിശോധനകൾ ഉപയോഗിച്ച്, സ്ക്രിപ്റ്റുകൾ യഥാർത്ഥ ലോക ഉപയോഗത്തിനായി തയ്യാറാക്കിയതാണെന്ന് അറിഞ്ഞുകൊണ്ട് നമുക്ക് ആത്മവിശ്വാസത്തോടെ വിന്യസിക്കാം. ഉൽപ്പാദനത്തിൽ, ഈ സജ്ജീകരണം Lambda, API ഗേറ്റ്‌വേ, DynamoDB എന്നിവയ്‌ക്കിടയിലുള്ള സുസ്ഥിരമായ ഇടപെടലുകൾ ഉറപ്പാക്കുന്നു. ഈ സജ്ജീകരണം 503 പിശക് പ്രശ്‌നം പരിഹരിക്കുക മാത്രമല്ല, പിശക് കൈകാര്യം ചെയ്യൽ, മോഡുലാർ കോഡിംഗ്, ടെസ്റ്റ്-ഡ്രൈവ് ഡെവലപ്‌മെൻ്റ് എന്നിവയിലെ മികച്ച രീതികളും ഇത് എടുത്തുകാണിക്കുന്നു. 😄

സമീപനം 1: API ഗേറ്റ്‌വേ ടൈംഔട്ടും ത്രോട്ടിലിംഗ് പരിധികളും കൈകാര്യം ചെയ്യുന്നതിലൂടെ 503 പിശക് പരിഹരിക്കുന്നു

Lambda ഇൻവോക്കേഷനും DynamoDB ക്വറി കൈകാര്യം ചെയ്യലും ഒപ്റ്റിമൈസ് ചെയ്യാൻ ബാക്കെൻഡ് സ്ക്രിപ്റ്റ് (Node.js)

// Import AWS SDK and initialize DynamoDB and API Gateway settings
const AWS = require('aws-sdk');
const dynamodb = new AWS.DynamoDB.DocumentClient();
// Function to fetch shipping data by SKU, with retry logic and exponential backoff
async function getShippingBySku(skuID) {
  let attempt = 0;
  const maxAttempts = 5;  // Limit retries to avoid endless loops
  const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
  while (attempt < maxAttempts) {
    try {
      const params = {
        TableName: 'ShippingDataTable',
        Key: { skuID: skuID }
      };
      const data = await dynamodb.get(params).promise();
      return data.Item;
    } catch (error) {
      if (error.statusCode === 503) {
        attempt++;
        await delay(200 * attempt);  // Exponential backoff
      } else {
        throw error;  // Non-retryable error, throw it
      }
    }
  }
  throw new Error('Failed to retrieve data after multiple attempts');
}
// Lambda handler function that calls getShippingBySku
exports.handler = async (event) => {
  try {
    const skuData = JSON.parse(event.body);
    const shippingData = await getShippingBySku(skuData.skuID);
    return {
      statusCode: 200,
      body: JSON.stringify(shippingData)
    };
  } catch (error) {
    return {
      statusCode: error.statusCode || 500,
      body: JSON.stringify({ message: error.message })
    };
  }
};

സമീപനം 2: API കോളുകളിലെ ക്ലയൻ്റ്-സൈഡ് ത്രോട്ടിംഗും പിശക് മാനേജ്മെൻ്റും

ഫ്രണ്ട്-എൻഡ് സ്ക്രിപ്റ്റ് (ജാവാസ്ക്രിപ്റ്റ്) കോംപോണൻ്റ് മൗണ്ടിൽ വീണ്ടും ശ്രമിക്കുന്നതിനുള്ള ലോജിക്കും പിശക് കൈകാര്യം ചെയ്യലും

// Client-side function to call the Lambda function with retry for 503 errors
async function fetchShippingData(skuID) {
  let attempt = 0;
  const maxAttempts = 5;
  const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
  while (attempt < maxAttempts) {
    try {
      const response = await fetch(`https://your-lambda-url.com?skuID=${skuID}`);
      if (response.status === 503) {
        throw new Error('Service Unavailable');
      }
      if (!response.ok) {
        throw new Error('Network response was not ok');
      }
      const data = await response.json();
      return data;
    } catch (error) {
      attempt++;
      if (attempt >= maxAttempts) {
        throw new Error('Failed to fetch data after multiple attempts');
      }
      await delay(200 * attempt);  // Exponential backoff
    }
  }
}
// React component that calls fetchShippingData on mount
useEffect(() => {
  async function getData() {
    try {
      const shippingData = await fetchShippingData(skuData.skuID);
      setShippingData(shippingData);
    } catch (error) {
      console.error('Error fetching shipping data:', error);
    }
  }
  getData();
}, [skuData.skuID]);

സമീപനം 3: ലാംഡ, ക്ലയൻ്റ്-സൈഡ് ഫംഗ്‌ഷനുകൾ എന്നിവ സാധൂകരിക്കുന്നതിനുള്ള യൂണിറ്റ് ടെസ്റ്റുകൾ എഴുതുന്നു

ലാംഡയ്‌ക്കായുള്ള ജെസ്റ്റിനൊപ്പം Node.js യൂണിറ്റ് ടെസ്റ്റുകളും റിയാക്റ്റ് ടെസ്റ്റിംഗ് ലൈബ്രറിയുമായുള്ള ഫ്രണ്ട്-എൻഡ് ടെസ്റ്റുകളും

// Jest unit test for Lambda function getShippingBySku
const { handler } = require('./lambdaFunction');
test('Lambda returns correct data on valid SKU ID', async () => {
  const event = { body: JSON.stringify({ skuID: '12345' }) };
  const response = await handler(event);
  expect(response.statusCode).toBe(200);
  expect(JSON.parse(response.body)).toHaveProperty('skuID', '12345');
});
// React Testing Library unit test for fetchShippingData
import { render, screen, waitFor } from '@testing-library/react';
import ShippingComponent from './ShippingComponent';
test('displays shipping data after fetching', async () => {
  render(<ShippingComponent skuID="12345" />);
  await waitFor(() => screen.getByText(/shipping info/i));
  expect(screen.getByText(/12345/i)).toBeInTheDocument();
});

API ഗേറ്റ്‌വേയും DynamoDB പിശകുകളും ലഘൂകരിക്കുന്നതിനുള്ള മികച്ച സമ്പ്രദായങ്ങൾ

സെർവർലെസ് ആർക്കിടെക്ചറുകളിൽ പ്രവർത്തിക്കുമ്പോൾ, ഡെവലപ്പർമാർ പലപ്പോഴും ഇടയ്ക്കിടെ കണ്ടുമുട്ടുന്നു AWS Lambda ഒരു API ഗേറ്റ്‌വേ വഴി DynamoDB-യുമായി സംവദിക്കുമ്പോൾ. API ഗേറ്റ്‌വേ അഭ്യർത്ഥന വോള്യങ്ങൾ കൈകാര്യം ചെയ്യുന്ന രീതിയാണ് ഒരു പ്രധാന സംഭാവന ഘടകം. അഭ്യർത്ഥനകളിൽ പെട്ടെന്നുള്ള വർദ്ധനവ് ഉണ്ടായാൽ, സ്ഥിരത നിലനിർത്താൻ AWS അവയെ ത്രോട്ടിൽ ചെയ്യുന്നു, ഇത് ഈ പിശകുകൾക്ക് കാരണമാകും. നിങ്ങളുടെ ലാംഡ ഫംഗ്‌ഷൻ്റെ നിരവധി സന്ദർഭങ്ങൾ ഒരേ സമയം ഒരേ ഡാറ്റ അന്വേഷിക്കുകയാണെങ്കിൽ, ഒരു ഫ്രണ്ട്-എൻഡ് ആപ്ലിക്കേഷനിലെ ഒരു ഘടക മൗണ്ടിൽ സംഭവിക്കാവുന്നതുപോലെ ഈ ത്രോട്ടിലിംഗ് പ്രത്യേകിച്ചും പ്രസക്തമാണ്.

ഈ പ്രശ്നങ്ങൾ ലഘൂകരിക്കുന്നതിന്, കോൺഫിഗറേഷൻ ക്രമീകരണങ്ങൾ ഒപ്റ്റിമൈസ് ചെയ്യേണ്ടത് അത്യാവശ്യമാണ് . ഉയർന്ന ട്രാഫിക് വോളിയം കൈകാര്യം ചെയ്യാൻ സഹായിക്കുന്ന നിങ്ങളുടെ API-യ്‌ക്കായുള്ള കൺകറൻ്റ് അഭ്യർത്ഥനകളുടെ ഡിഫോൾട്ട് പരിധി വർദ്ധിപ്പിക്കുക എന്നതാണ് ഒരു മാർഗ്ഗം. കൂടാതെ, API ഗേറ്റ്‌വേയിൽ കാഷിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നത് പരിഗണിക്കുക. ഇടയ്‌ക്കിടെ അഭ്യർത്ഥിച്ച ഡാറ്റ ഹ്രസ്വകാലത്തേക്ക് കാഷെ ചെയ്യുന്നത് നിങ്ങളുടെ ലാംഡ ഫംഗ്‌ഷൻ എത്ര തവണ അഭ്യർത്ഥിക്കണം എന്നതിൻ്റെ എണ്ണം കുറയ്ക്കുന്നു, ഇത് ലാംഡയിലും ഡൈനാമോഡിബിയിലും കുറച്ച് ലോഡ് ഒഴിവാക്കും. ഉദാഹരണത്തിന്, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ പലപ്പോഴും ഒരേ SKU ഡാറ്റയാണ് ആക്സസ് ചെയ്യുന്നതെങ്കിൽ, ഈ വിവരങ്ങൾ കാഷെ ചെയ്യുന്നത് ആവർത്തിച്ചുള്ള DynamoDB കോളുകളുടെ ആവശ്യകത കുറയ്ക്കുകയും സാധ്യതയുള്ള 503 പിശകുകൾ കുറയ്ക്കുകയും ചെയ്യും. 🚀

ട്രാഫിക്കിലെ പെട്ടെന്നുള്ള സ്പൈക്കുകൾ ഉൾക്കൊള്ളാൻ API ഗേറ്റ്‌വേയുടെ "ബർസ്റ്റ് ലിമിറ്റ്" ക്രമീകരണം ഉപയോഗിക്കുന്നതാണ് മറ്റൊരു സമീപനം. ഉയർന്ന അഭ്യർത്ഥന വോള്യങ്ങളുടെ ഹ്രസ്വമായ പൊട്ടിത്തെറികൾ അനുവദിക്കുന്നതിലൂടെ, നിങ്ങളുടെ സിസ്റ്റത്തെ അടിച്ചമർത്താതെ നിങ്ങൾക്ക് താൽക്കാലിക ട്രാഫിക് കുതിച്ചുചാട്ടം കൈകാര്യം ചെയ്യാൻ കഴിയും. കൂടാതെ, കൂടുതൽ ഗ്രാനുലാർ മോണിറ്ററിംഗ് സജ്ജീകരിക്കുന്നത് സഹായിക്കും. API ഗേറ്റ്‌വേ, DynamoDB എന്നിവയ്‌ക്കായുള്ള CloudWatch-ൽ “വിശദമായ നിരീക്ഷണം” പ്രവർത്തനക്ഷമമാക്കുന്നത് പിശകുകളുടെ പാറ്റേണുകളെക്കുറിച്ചുള്ള ഉൾക്കാഴ്ചകൾ നൽകുന്നു, മൂലകാരണങ്ങൾ കൂടുതൽ കാര്യക്ഷമമായി തിരിച്ചറിയാനും പരിഹരിക്കാനും നിങ്ങളെ സഹായിക്കുന്നു. ദീർഘകാലാടിസ്ഥാനത്തിൽ, ഈ തന്ത്രങ്ങൾ പിശകുകൾ തടയാൻ മാത്രമല്ല, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ മൊത്തത്തിലുള്ള പ്രകടനവും ഉപയോക്തൃ അനുഭവവും മെച്ചപ്പെടുത്താനും സഹായിക്കുന്നു.

എന്താണ് 503 പിശക്, എന്തുകൊണ്ട് AWS സേവനങ്ങളിൽ ഇത് സംഭവിക്കുന്നു?
ഒരു സേവനം താൽക്കാലികമായി ലഭ്യമല്ലെന്ന് 503 പിശക് സൂചിപ്പിക്കുന്നു. AWS-ൽ, ഉയർന്ന അഭ്യർത്ഥന വോളിയം മൂലമോ അല്ലെങ്കിൽ ഒന്നിൽ മതിയായ ശേഷി ഇല്ലാത്തതിനാലോ ഇത് പലപ്പോഴും സംഭവിക്കുന്നു അല്ലെങ്കിൽ , പ്രത്യേകിച്ച് പെട്ടെന്നുള്ള ട്രാഫിക് സ്പൈക്കുകളുടെ സമയത്ത്.
API ഗേറ്റ്‌വേയിലെ 503 പിശകുകൾ കുറയ്ക്കാൻ കാഷിംഗ് എങ്ങനെ സഹായിക്കും?
പ്രവർത്തനക്ഷമമാക്കുന്നു പതിവായി ആക്‌സസ് ചെയ്യപ്പെടുന്ന ഡാറ്റ താൽക്കാലികമായി സംഭരിക്കാൻ അനുവദിക്കുന്നു, ഇത് ആവർത്തിച്ചുള്ള അഭ്യർത്ഥനകളുടെ ആവശ്യകത കുറയ്ക്കുന്നു ഒപ്പം . ഈ സമീപനം നിങ്ങളുടെ ബാക്കെൻഡിലെ ലോഡ് കുറയ്ക്കുന്നു, 503 പിശകുകൾ തടയാൻ സഹായിക്കുന്നു.
DynamoDB വായന/എഴുത്ത് ശേഷി വർദ്ധിപ്പിക്കുന്നത് 503 പിശകുകൾ പരിഹരിക്കുമോ?
വർദ്ധിക്കുന്നു DynamoDB തലത്തിൽ ത്രോട്ടിലിംഗ് മൂലമാണ് പിശകുകൾ സംഭവിക്കുന്നതെങ്കിൽ സഹായിക്കാനാകും. എന്നിരുന്നാലും, 503 പിശക് ഉണ്ടായാൽ അല്ലെങ്കിൽ , DynamoDB ക്രമീകരണങ്ങൾ ക്രമീകരിക്കുന്നത് കൊണ്ട് മാത്രം അത് പൂർണ്ണമായി പരിഹരിച്ചേക്കില്ല.
ലോജിക് വീണ്ടും പരീക്ഷിക്കുന്നത് എങ്ങനെയാണ്, എന്തുകൊണ്ട് ഇത് ഫലപ്രദമാണ്?
503 പിശക് സംഭവിക്കുകയാണെങ്കിൽ, ഒരു ചെറിയ കാലതാമസത്തിന് ശേഷം ഒരു അഭ്യർത്ഥന വീണ്ടും പരീക്ഷിക്കുന്നത് റീട്രി ലോജിക്കിൽ ഉൾപ്പെടുന്നു. എക്‌സ്‌പോണൻഷ്യൽ ബാക്ക്ഓഫ് ഉപയോഗിക്കുന്നത് (ഓരോ വീണ്ടും ശ്രമിക്കുമ്പോഴും കാത്തിരിപ്പ് സമയം വർദ്ധിപ്പിക്കുന്നത്) സിസ്റ്റത്തിന് വീണ്ടെടുക്കാൻ സമയം നൽകും, സേവനത്തെ അമിതമാക്കാതെ തന്നെ വിജയസാധ്യത വർദ്ധിപ്പിക്കും.
503 പിശകുകൾ കണ്ടെത്തുന്നതിന് എന്ത് ക്ലൗഡ് വാച്ച് മെട്രിക്‌സ് ഉപയോഗപ്രദമാണ്?
API ഗേറ്റ്‌വേ, DynamoDB എന്നിവയ്‌ക്കായി അഭ്യർത്ഥന എണ്ണം, പിശക് നിരക്ക്, ലേറ്റൻസി എന്നിവ പോലുള്ള വിലയേറിയ അളവുകൾ വാഗ്ദാനം ചെയ്യുന്നു. ഈ മെട്രിക്കുകൾ വിശകലനം ചെയ്യുന്നത് ട്രാഫിക് പാറ്റേണുകൾ തിരിച്ചറിയാനും എപ്പോൾ, എന്തുകൊണ്ട് 503 പിശകുകൾ ട്രിഗർ ചെയ്യപ്പെടുന്നുവെന്ന് കൃത്യമായി കണ്ടെത്താനും നിങ്ങളെ സഹായിക്കുന്നു.

ചുരുക്കത്തിൽ, AWS Lambda, DynamoDB എന്നിവയെ ബന്ധിപ്പിക്കുന്ന സെർവർലെസ് ആപ്ലിക്കേഷനുകളിലെ 503 പിശകുകൾ, റീട്രി ലോജിക്, കാഷിംഗ്, ബാക്ക്ഓഫ് സ്ട്രാറ്റജികൾ തുടങ്ങിയ സാങ്കേതിക വിദ്യകൾ സംയോജിപ്പിച്ച് ഫലപ്രദമായി പരിഹരിക്കാനാകും. ഈ ഘട്ടങ്ങൾ നടപ്പിലാക്കുന്നത്, നിങ്ങളുടെ API വിവിധ വ്യവസ്ഥകളിൽ പ്രതിരോധശേഷിയുള്ളതും പ്രതികരണശേഷിയുള്ളതുമാണെന്ന് ഉറപ്പാക്കുന്നു.

നിങ്ങൾ ഉയർന്ന ട്രാഫിക്കുള്ള ഇ-കൊമേഴ്‌സ് പ്ലാറ്റ്‌ഫോം അല്ലെങ്കിൽ മറ്റൊരു ഡൈനാമിക് സേവനം നിർമ്മിക്കുകയാണെങ്കിലും, അപ്രതീക്ഷിതമായ കുതിച്ചുചാട്ടങ്ങൾ കൈകാര്യം ചെയ്യാൻ നിങ്ങളുടെ AWS ഇൻഫ്രാസ്ട്രക്ചർ കോൺഫിഗർ ചെയ്യുകയും വിശദമായ നിരീക്ഷണം പ്രയോഗിക്കുകയും ചെയ്യുന്നത് പ്രകടനം നിലനിർത്താനും സുഗമമായ ഉപയോക്തൃ അനുഭവം നൽകാനും സഹായിക്കുന്നു. 🚀

503 പിശക് കോഡ് ഉൾപ്പെടെയുള്ള AWS Lambda ഫംഗ്‌ഷൻ പിശകുകൾ, ട്രബിൾഷൂട്ടിംഗിനുള്ള മികച്ച രീതികൾ എന്നിവ വിശദീകരിക്കുന്നു. AWS ലാംഡ ട്രബിൾഷൂട്ടിംഗ്
API ഗേറ്റ്‌വേ കോൺഫിഗറേഷനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾ, ത്രോട്ടിലിംഗ് പരിധികൾ എങ്ങനെ കൈകാര്യം ചെയ്യാം, ആപ്ലിക്കേഷൻ റെസിലൻസ് മെച്ചപ്പെടുത്തുന്നതിന് കാഷിംഗ് എന്നിവ ഉൾപ്പെടുന്നു. API ഗേറ്റ്‌വേ ത്രോട്ടലിംഗ് ഡോക്യുമെൻ്റേഷൻ
DynamoDB കപ്പാസിറ്റി മാനേജ്‌മെൻ്റ്, ത്രോട്ടിലിംഗ് പിശകുകൾ ഒഴിവാക്കാൻ റീഡ്/റൈറ്റ് പ്രൊവിഷനിംഗ് എന്നിവയെക്കുറിച്ചുള്ള ഉൾക്കാഴ്ചകൾ നൽകുന്നു. DynamoDB കപ്പാസിറ്റി മോഡ് ഡോക്യുമെൻ്റേഷൻ
എക്‌സ്‌പോണൻഷ്യൽ ബാക്ക്ഓഫ് നടപ്പിലാക്കുന്നതിനെ കുറിച്ചും AWS സേവനങ്ങളിലെ ക്ഷണികമായ പിശകുകൾ കൈകാര്യം ചെയ്യുന്നതിനായി ലോജിക്ക് വീണ്ടും ശ്രമിക്കുന്നതും ചർച്ച ചെയ്യുന്നു. AWS ബ്ലോഗ്: എക്‌സ്‌പോണൻഷ്യൽ ബാക്ക്ഓഫും വിറയലും

AWS Lambda-യിലെ Amazon DynamoDB 503 പിശകുകൾ പരിഹരിക്കാൻ API ഗേറ്റ്‌വേ ഉപയോഗിക്കുന്നു

AWS Lambda, DynamoDB 503 പിശകുകൾ ഫലപ്രദമായ റീട്രി ലോജിക് ഉപയോഗിച്ച് പരിഹരിക്കുന്നു

സമീപനം 1: API ഗേറ്റ്‌വേ ടൈംഔട്ടും ത്രോട്ടിലിംഗ് പരിധികളും കൈകാര്യം ചെയ്യുന്നതിലൂടെ 503 പിശക് പരിഹരിക്കുന്നു

സമീപനം 2: API കോളുകളിലെ ക്ലയൻ്റ്-സൈഡ് ത്രോട്ടിംഗും പിശക് മാനേജ്മെൻ്റും

സമീപനം 3: ലാംഡ, ക്ലയൻ്റ്-സൈഡ് ഫംഗ്‌ഷനുകൾ എന്നിവ സാധൂകരിക്കുന്നതിനുള്ള യൂണിറ്റ് ടെസ്റ്റുകൾ എഴുതുന്നു

API ഗേറ്റ്‌വേയും DynamoDB പിശകുകളും ലഘൂകരിക്കുന്നതിനുള്ള മികച്ച സമ്പ്രദായങ്ങൾ