സിംഗിൾ-ഫ്ലൈറ്റ് കാഷിംഗ്: ഒരു ഹോട്ട് കീ ഡാറ്റാബേസ് തകരാറിലാക്കുന്നത് എങ്ങനെ തടയാം

ഒരു വെബ്‌സൈറ്റിൽ ഉയർന്ന ട്രാഫിക് ഉണ്ടാകുമ്പോൾ, അത് പെർഫോമൻസ് പ്രശ്നങ്ങൾക്ക് കാരണമായേക്കാം, പ്രത്യേകിച്ചും ഡാറ്റ വീണ്ടെടുക്കുന്നതിനായി അത് ഒരു ഡാറ്റാബേസിനെ ആശ്രയിക്കുകയാണെങ്കിൽ. നിരവധി ആപ്ലിക്കേഷനുകൾ നേരിടുന്ന ഒരു സാധാരണ പ്രശ്നത്തിനുള്ള പരിഹാരമാണ് നമ്മൾ ഇവിടെ ചർച്ച ചെയ്യുന്നത്: ഡാറ്റാബേസിന് അമിതഭാരം നൽകാതെ കാഷ് കാലാവധി കഴിയുന്നത് എങ്ങനെ കൈകാര്യം ചെയ്യാം.

പ്രശ്നം മനസ്സിലാക്കാം

podbor-minuta.ru എന്ന വെബ്‌സൈറ്റിൽ, ചില ഡാറ്റാബേസ് ക്വറികൾ വളരെ ഭാരമേറിയതാണ്. കാര്യങ്ങൾ വേഗത്തിലാക്കാൻ, അവർ ഫലങ്ങൾ കാഷിൽ സൂക്ഷിക്കുന്നു. ഉദാഹരണത്തിന്, ലിസ്റ്റിംഗ് പേജുകൾക്കായുള്ള അപ്പാർട്ട്മെന്റ് ലിസ്റ്റുകളും ആകെ കണക്കുകളും അവർ കാഷ് ചെയ്യുന്നു. കാഷ് സാധുവായിരിക്കുമ്പോൾ, എല്ലാം സുഗമമായി പ്രവർത്തിക്കുന്നു. എന്നാൽ, കാഷിന്റെ കാലാവധി കഴിയുമ്പോഴാണ് പ്രശ്നം തുടങ്ങുന്നത്.

ഒരു ദിവസം, ഉയർന്ന ലോഡ് ഉള്ള സമയത്ത്, സൈറ്റിന് ഗുരുതരമായ ഒരു പ്രശ്നം നേരിടേണ്ടി വന്നു. 500 റെസ്‌പോൺസുകളുടെ ഒരു ബാച്ച് ടൈംഔട്ടായി. ഡാറ്റാബേസ് ഇപ്പോഴും പ്രവർത്തിക്കുന്നുണ്ടായിരുന്നിട്ടും, ക്വറികൾ ക്യൂവിൽ കുമിഞ്ഞുകൂടാൻ തുടങ്ങി. ഒരേ സമയം ഒന്നിലധികം റിക്വസ്റ്റുകൾ ഒരേ ഡാറ്റ ആക്സസ് ചെയ്യാൻ ശ്രമിച്ചതിനാലാണ് ഈ സാഹചര്യം ഉണ്ടായത്, ഇത് ഒരു തടസ്സത്തിലേക്ക് (bottleneck) നയിച്ചു.

എന്താണ് കാഷ് സ്റ്റാമ്പീഡ്?

പ്രാരംഭ കാഷിംഗ് ലോജിക് വളരെ ലളിതമായിരുന്നു: കാഷിൽ ഒരു മൂല്യം ഇല്ലെങ്കിൽ, അത് കണക്കുകൂട്ടാൻ ആപ്ലിക്കേഷൻ ഡാറ്റാബേസിൽ ക്വറി നടത്തുകയും, തുടർന്ന് ആ മൂല്യം തിരികെ കാഷിൽ സൂക്ഷിക്കുകയും ചെയ്യുന്നു. ഒരൊറ്റ റിക്വസ്റ്റിന് ഇത് നന്നായി പ്രവർത്തിക്കും. എന്നാൽ കാഷിന്റെ കാലാവധി കഴിയുകയും ഒരേ ഡാറ്റയ്ക്കായി പെട്ടെന്ന് ഇരുനൂറ് റിക്വസ്റ്റുകൾ വരികയും ചെയ്യുന്നത് സങ്കൽപ്പിക്കുക. ഓരോ റിക്വസ്റ്റും കാഷ് ശൂന്യമാണെന്ന് കാണുകയും ഓരോന്നും ഒരേസമയം ഡാറ്റാബേസിൽ ക്വറി നടത്തുകയും ചെയ്യുന്നു. ഈ സാഹചര്യം അറിയപ്പെടുന്നത് ഒരു കാഷ് സ്റ്റാമ്പീഡ്.

ഒരു കാഷ് സ്റ്റാമ്പീഡ് ഉണ്ടാകുമ്പോൾ, ഒരേപോലെയുള്ള ഭാരമേറിയ ക്വറികൾ കാരണം ഡാറ്റാബേസ് അമിതഭാരത്തിലാവുകയും കണക്ഷൻ പരിധികൾ മറികടക്കുകയും ചെയ്യുന്നു. തൽഫലമായി, ടൈംഔട്ടുകൾ കാരണം ചില റിക്വസ്റ്റുകൾ നഷ്ടപ്പെടുന്നു.

സിംഗിൾ-ഫ്ലൈറ്റ് കാഷിംഗ് നടപ്പിലാക്കൽ

ഈ പ്രശ്നം പരിഹരിക്കുന്നതിനായി, ടീം നടപ്പിലാക്കിയ ഒരു സാങ്കേതികതയാണ് സിംഗിൾ-ഫ്ലൈറ്റ് കാഷിംഗ്. ഒരു നിർദ്ദിഷ്ട കീയ്ക്കായുള്ള കണക്കുകൂട്ടൽ ഇതിനകം പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ, അതേ കീയ്ക്കായുള്ള മറ്റേതെങ്കിലും റിക്വസ്റ്റുകൾ സ്വന്തമായി ഡാറ്റാബേസ് ക്വറി ആരംഭിക്കുന്നതിന് പകരം ആ ഫലത്തിനായി കാത്തിരിക്കുന്നു എന്ന് ഈ രീതി ഉറപ്പാക്കുന്നു. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഇവിടെ കാണാം:

ഘട്ടം 1: കാഷ് പരിശോധിക്കുക

ആദ്യം, മൂല്യം ഇതിനകം കാഷിൽ ഉണ്ടോ എന്ന് ആപ്ലിക്കേഷൻ പരിശോധിക്കുന്നു. ഉണ്ടെങ്കിൽ, അത് ആ മൂല്യം ഉടനടി തിരികെ നൽകുന്നു.

ഘട്ടം 2: കാഷ് മിസ്സുകൾ കൈകാര്യം ചെയ്യുക

മൂല്യം കാഷിൽ ഇല്ലെങ്കിൽ, ആ കീയ്ക്കായുള്ള കണക്കുകൂട്ടൽ ഇതിനകം പുരോഗതിയിലാണോ എന്ന് ഇത് പരിശോധിക്കുന്നു. അങ്ങനെയാണെങ്കിൽ, ആ കണക്കുകൂട്ടൽ പൂർത്തിയാകുന്നതുവരെ ആപ്ലിക്കേഷൻ കാത്തിരിക്കുകയും ഫലം നൽകുകയും ചെയ്യും.

ഘട്ടം 3: ഒരു പ്രോമിസ് നിർമ്മിക്കുക

കണക്കുകൂട്ടലുകളൊന്നും പുരോഗതിയിലല്ലെങ്കിൽ, ആപ്ലിക്കേഷൻ പുതിയതൊന്ന് ആരംഭിക്കുന്നു. ഇത് കണക്കുകൂട്ടലിനായി ഒരു പ്രോമിസ് നിർമ്മിക്കുകയും കീ ഉപയോഗിച്ച് അത് ഒരു മാപ്പിൽ സൂക്ഷിക്കുകയും ചെയ്യുന്നു. ഈ രീതിയിൽ, മറ്റ് റിക്വസ്റ്റുകൾക്ക് പുതിയ ഡാറ്റാബേസ് ക്വറി ആരംഭിക്കുന്നതിന് പകരം അതേ പ്രോമിസ് ആക്സസ് ചെയ്യാൻ കഴിയും.

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ലളിതമായ ഒരു കോഡ് ഉദാഹരണം ഇതാ:

const inFlight = new Map<string, Promise<unknown>>();

async function getOrSet<T>(key: string, compute: () => Promise<T>): Promise<T> {
    const cached = cache.get(key);
    if (cached !== undefined) return cached as T;

    const running = inFlight.get(key);
    if (running) return running as Promise<T>;

    const promise = compute().then((value) => {
        cache.set(key, value);
        return value;
    }).finally(() => {
        inFlight.delete(key);
    });

    inFlight.set(key, promise);
    return promise;
}

സിംഗിൾ-ഫ്ലൈറ്റ് കാഷിംഗിന്റെ നേട്ടങ്ങൾ

സിംഗിൾ-ഫ്ലൈറ്റ് കാഷിംഗ് നടപ്പിലാക്കിയത് നിരവധി നേട്ടങ്ങൾ നൽകി:

• ഡാറ്റാബേസിലെ ലോഡ് കുറയ്ക്കുന്നു: ഇരുനൂറ് സമാനമായ ക്വറികൾക്ക് പകരം, ഒരു ക്വറി മാത്രമേ ഡാറ്റാബേസിലേക്ക് എത്തുന്നുള്ളൂ, ഇത് ലോഡ് ഗണ്യമായി കുറയ്ക്കുന്നു.
• മെച്ചപ്പെട്ട പെർഫോമൻസ്: കണക്ഷൻ പൂൾ ഇനി അനാവശ്യമായി ചോർന്നുപോകില്ല, ഇത് ഉയർന്ന ട്രാഫിക് ഉള്ള സമയത്ത് കൂടുതൽ സുഗമമായ പെർഫോമൻസ് സാധ്യമാക്കുന്നു.
• കാര്യക്ഷമത: കാഷിൽ ഡാറ്റ കണ്ടെത്തുന്ന റിക്വസ്റ്റുകൾക്ക് അധിക ഭാരമൊന്നുമില്ലാതെ, കാഷ്-ഹിറ്റ് പാത്ത് വേഗത്തിൽ നിലനിൽക്കുന്നു.

ഉപസംഹാരം

പീക്ക് സമയങ്ങളിൽ, പ്രത്യേകിച്ച് കാഷ് കാലാവധി കഴിയുമ്പോൾ ഡാറ്റാബേസ് ലോഡ് കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഫലപ്രദമായ ഒരു തന്ത്രമാണ് സിംഗിൾ-ഫ്ലൈറ്റ് കാഷിംഗ്. ഒരേ സമയം ഒരു റിക്വസ്റ്റ് മാത്രം ഭാരമേറിയ ക്വറി പ്രോസസ്സ് ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുന്നതിലൂടെ, ആപ്ലിക്കേഷനുകൾക്ക് പെർഫോമൻസ് നിലനിർത്താനും സെർവർ ക്രാഷുകൾ തടയാനും കഴിയും.

നേട്ടങ്ങൾ

• കാഷ് കാലാവധി കഴിയുമ്പോൾ ഡാറ്റാബേസ് ഓവർലോഡ് തടയുന്നു.
• കാഷ് ചെയ്ത ഡാറ്റയ്ക്ക് വേഗത്തിലുള്ള റെസ്‌പോൺസ് സമയം നിലനിർത്തുന്നു.
• ഡ്യൂപ്ലിക്കേറ്റ് ഡാറ്റാബേസ് ക്വറികളുടെ എണ്ണം കുറയ്ക്കുന്നു.

പോരായ്മകൾ

• ഇൻ-ഫ്ലൈറ്റ് റിക്വസ്റ്റുകൾ കൈകാര്യം ചെയ്യാൻ അധിക ലോജിക് ആവശ്യമാണ്.
• കൂടുതൽ കർശനമായ എൻവയോൺമെന്റുകൾക്കായി ഒരു ഷെയർഡ് ലോക്ക് ആവശ്യമായി വന്നേക്കാം, ഇത് സങ്കീർണ്ണത വർദ്ധിപ്പിക്കുന്നു.

മുന്നറിയിപ്പ്

ഈ ലേഖനം വിദ്യാഭ്യാസ ആവശ്യങ്ങൾക്കായി ഉദ്ദേശിച്ചുള്ളതാണ്. നിങ്ങൾ എന്തെങ്കിലും കാഷിംഗ് തന്ത്രങ്ങൾ നടപ്പിലാക്കുകയാണെങ്കിൽ, പ്ലേസ്‌ഹോൾഡർ മൂല്യങ്ങൾക്ക് പകരം നിങ്ങളുടെ യഥാർത്ഥ ഡാറ്റ നൽകാനും അവയെ ആശ്രയിക്കുന്നതിന് മുൻപ് യഥാർത്ഥ സ്രോതസ്സുകളുമായി പരിശോധിച്ച് ഉറപ്പുവരുത്താനും ശ്രദ്ധിക്കുക.

പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ

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

ടാഗുകൾ

#caching #database #performance #webdev #architecture #softwaredevelopment #programming #tech