તમારું Serverless સ્કેલિંગ વિશે તમને જૂઠું બોલી રહ્યું છે
Serverless કમ્પ્યુટિંગ અનંત સ્કેલ અને શૂન્ય ઓવરહેડનું વચન આપે છે. AWS Lambda અથવા Google Cloud Run જેવા પ્લેટફોર્મ તમારા કમ્પ્યુટ લેયર્સને તરત જ સ્કેલ કરે છે.
પરંતુ તમારું બેકએન્ડ હજુ પણ ક્રેશ થાય છે.
સમસ્યા તમારા કમ્પ્યુટમાં નથી. સમસ્યા તમારા ડેટાબેઝમાં છે.
જ્યારે તમારા ફંક્શન્સ સ્કેલ અપ થાય છે, ત્યારે તેઓ 'connection storm' પેદા કરે છે. દરેક નવું ફંક્શન ઇન્સ્ટન્સ તમારા ડેટાબેઝ સાથે નવું કનેક્શન ખોલવાનો પ્રયાસ કરે છે. જો તમારી પાસે 1,000 ફંક્શન્સ હોય, તો એકસાથે તમારા Postgres અથવા MySQL ઇન્સ્ટન્સ પર 1,000 કનેક્શન રિક્વેસ્ટ આવે છે.
રિલેશનલ ડેટાબેઝની ચોક્કસ મર્યાદાઓ (hard limits) હોય છે. એકવાર તમે તે મર્યાદા પર પહોંચી જાઓ, પછી નવા કનેક્શન્સ નિષ્ફળ જાય છે. આનાથી હાઈ લેટન્સી (high latency) અને 5xx એરર્સ આવે છે. તમારું કમ્પ્યુટ તૈયાર છે, પરંતુ તમારો ડેટાબેઝ દબાણ હેઠળ તૂટી રહ્યો છે.
તમે આ ત્રણ વ્યૂહરચનાઓ દ્વારા આ સમસ્યા ઠીક કરી શકો છો:
Use a Connection Proxy ફંક્શન્સને સીધા તમારા ડેટાબેઝ સાથે કનેક્ટ કરશો નહીં. AWS RDS Proxy અથવા Google Cloud SQL Proxy જેવા પ્રોક્સીનો ઉપયોગ કરો. આ લેયર તમારા ફંક્શન્સ અને તમારા ડેટાબેઝ વચ્ચે કામ કરે છે. તે પર્સિસ્ટન્ટ કનેક્શન્સના નાના પૂલનું સંચાલન કરે છે અને તેને તમારા ઘણા બધા ફંક્શન્સ વચ્ચે વહેંચે છે.
Implement Data Proxy Layers એડવાન્સ્ડ પ્રોક્સી માત્ર કનેક્શન્સનું સંચાલન કરવા કરતાં વધુ કામ કરી શકે છે. તેઓ કરી શકે છે:
- અલગ-અલગ ડેટાબેઝ ઇન્સ્ટન્સ પર reads અને writes ને વિભાજિત કરવું.
- ડેટાબેઝ લોડ ઘટાડવા માટે વારંવાર થતી ક્વેરીઝને કેશ (cache) કરવી.
- ડેટાબેઝ સુધી પહોંચતા પહેલા ક્વેરીઝને ઓપ્ટિમાઇઝ કરવી.
- Move to Asynchronous Writes દરેક યુઝર એક્શનને સિંક્રનસ (synchronous) ડેટાબેઝ રાઈટ બનાવવાનું બંધ કરો. ઘણા કાર્યો માટે ત્વરિત ક consistancy ની જરૂર હોતી નથી.
આના બદલે: User Action -> Function -> Sync DB Write -> Response
આ અજમાવો: User Action -> Function -> Push Event to Queue -> Fast Response
ત્યારબાદ એક અલગ ફંક્શન તે ઇવેન્ટને લઈ શકે છે અને પછીથી ડેટાબેઝમાં લખી શકે છે. આ તમારા ડેટાબેઝને અચાનક ટ્રાફિક સ્પાઇક્સથી બચાવે છે.
સાચી સ્કેલેબિલિટી માટે માત્ર કમ્પ્યુટ સ્કેલ કરવા કરતાં વધુની જરૂર છે. તમારે ઇલાસ્ટિક ડેટા એક્સેસ માટે ડિઝાઇન કરવું જોઈએ. સૈદ્ધાંતિક મહત્તમ (theoretical maximums) માટે પ્રોવિઝનિંગ કરવાનું બંધ કરો. તમારા બર્સ્ટિંગ ફંક્શન્સ અને તમારા ડેટા વચ્ચે બફર્સ (buffers) બનાવવાનું શરૂ કરો.
Source: https://dev.to/prabashanadev/your-serverless-is-lying-to-you-about-scale-4cga