ടാരന്റൂളിൽ, അവയ്‌ക്കൊപ്പം പ്രവർത്തിക്കാൻ നിങ്ങൾക്ക് ഒരു സൂപ്പർ ഫാസ്റ്റ് ഡാറ്റാബേസും ഒരു ആപ്ലിക്കേഷനും സംയോജിപ്പിക്കാനാകും. ഇത് ചെയ്യുന്നത് എത്ര എളുപ്പമാണെന്ന് ഇതാ

അഞ്ച് വർഷം മുമ്പ് ഞാൻ ടാരന്റൂളിൽ പ്രവർത്തിക്കാൻ ശ്രമിച്ചു, പക്ഷേ അത് എനിക്ക് വേണ്ടി പ്രവർത്തിച്ചില്ല. എന്നാൽ അടുത്തിടെ ഞാൻ ഒരു വെബിനാർ നടത്തി, അവിടെ ഹഡൂപ്പിനെ കുറിച്ചും MapReduce എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെ കുറിച്ചും സംസാരിച്ചു. അവിടെ അവർ എന്നോട് ഒരു ചോദ്യം ചോദിച്ചു: "എന്തുകൊണ്ടാണ് ഈ ടാസ്ക്കിനായി ടാരന്റൂൾ ഉപയോഗിക്കരുത്?"

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

എന്താണ് ടാരന്തൂൾ

ടാരന്റൂൾ സ്വയം ഒരു അൾട്രാ ഫാസ്റ്റ് ഡാറ്റാബേസ് ആയി നിലകൊള്ളുന്നു. നിങ്ങൾക്ക് ആവശ്യമുള്ള ഏത് ഡാറ്റയും അവിടെ നൽകാം. കൂടാതെ, അവ ആവർത്തിക്കുക, ഷാർഡ് - അതായത്, നിരവധി സെർവറുകളിലുടനീളം വലിയ അളവിലുള്ള ഡാറ്റ വിഭജിക്കുകയും അവയിൽ നിന്നുള്ള ഫലങ്ങൾ സംയോജിപ്പിക്കുകയും ചെയ്യുക - തെറ്റ്-സഹിഷ്ണുതയുള്ള മാസ്റ്റർ-മാസ്റ്റർ കണക്ഷനുകൾ ഉണ്ടാക്കുക.

രണ്ടാമതായി, ഇതൊരു ആപ്ലിക്കേഷൻ സെർവറാണ്. നിങ്ങൾക്ക് അതിൽ നിങ്ങളുടെ ആപ്ലിക്കേഷനുകൾ എഴുതാനും ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിക്കാനും കഴിയും, ഉദാഹരണത്തിന്, ചില നിയമങ്ങൾ അനുസരിച്ച് പശ്ചാത്തലത്തിൽ പഴയ റെക്കോർഡുകൾ ഇല്ലാതാക്കുക. നിങ്ങൾക്ക് ടാരാന്റുലയിൽ നേരിട്ട് ഒരു Http സെർവർ എഴുതാം, അത് ഡാറ്റയുമായി പ്രവർത്തിക്കും: അവയുടെ അളവ് നൽകുക, അവിടെ പുതിയ ഡാറ്റ എഴുതുക, എല്ലാം മാസ്റ്ററിന് കുറയ്ക്കുക.

ആൺകുട്ടികൾ 300 വരികളുടെ ഒരു സന്ദേശ ക്യൂ ഉണ്ടാക്കിയതെങ്ങനെ എന്നതിനെക്കുറിച്ചുള്ള ഒരു ലേഖനം ഞാൻ വായിച്ചു, അത് പൊട്ടിത്തെറിക്കുകയും കുതിക്കുകയും ചെയ്യുന്നു - അവർക്ക് സെക്കൻഡിൽ 20 സന്ദേശങ്ങളുടെ പ്രകടനമുണ്ട്. ഇവിടെ നിങ്ങൾക്ക് ശരിക്കും തിരിയാനും വളരെ വലിയ ഒരു ആപ്ലിക്കേഷൻ എഴുതാനും കഴിയും, അത് PostgreS ലെ പോലെ സ്റ്റോറേജ് ആയിരിക്കില്ല.

ഈ ലേഖനത്തിൽ ഈ സെർവർ പോലെയുള്ള ഒന്ന് വിവരിക്കാൻ ഞാൻ ശ്രമിക്കും, ലളിതമായി മാത്രം.

ഇൻസ്റ്റലേഷൻ

ടെസ്റ്റിനായി, ഞാൻ മൂന്ന് സ്റ്റാൻഡേർഡ് വെർച്വൽ മെഷീനുകൾ ആരംഭിച്ചു - ഒരു 20 GB ഹാർഡ് ഡ്രൈവ്, ഉബുണ്ടു 18.04. 2 വെർച്വൽ സിപിയുകളും 4 ഗിഗ് മെമ്മറിയും.

ഞങ്ങൾ Tarantool ഇൻസ്‌റ്റാൾ ചെയ്യുന്നു - ബാഷ് സ്‌ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുക അല്ലെങ്കിൽ ഒരു ശേഖരം ചേർക്കുക, തുടർന്ന് Tarantool ഇൻസ്റ്റാൾ ചെയ്യുക. സ്ക്രിപ്റ്റിലേക്കുള്ള ലിങ്ക് - (ചുരുൾ -L https://tarantool.io/installer.sh | VER=2.4 സുഡോ -ഇ ബാഷ്). ഞങ്ങൾക്ക് ഇതുപോലുള്ള കമാൻഡുകൾ ഉണ്ട്:

tarantoolctl - ടരാന്റുല സംഭവങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള പ്രധാന കമാൻഡ്.
/etc/tarantool - മുഴുവൻ കോൺഫിഗറേഷനും ഇതാ.
var/log/tarantool - രേഖകൾ ഇതാ.
var/lib/tarantool — ഡാറ്റ ഇവിടെയുണ്ട്, തുടർന്ന് അത് ഉദാഹരണങ്ങളായി തിരിച്ചിരിക്കുന്നു.

ഫോൾഡറുകൾ ഇൻസ്‌റ്റൻസ്-ലഭ്യവും ഇൻസ്‌റ്റൻസ്-പ്രാപ്‌തമാക്കലും ഉണ്ട് - അതിൽ ലോഞ്ച് ചെയ്യുന്നവ അടങ്ങിയിരിക്കുന്നു - ലുവാ കോഡുള്ള ഒരു ഇൻസ്റ്റൻസ് കോൺഫിഗറേഷൻ ഫയൽ, അത് ഏത് പോർട്ടുകളാണ് കേൾക്കുന്നത്, ഏത് മെമ്മറി ഇതിന് ലഭ്യമാണ്, വിനൈൽ എഞ്ചിൻ ക്രമീകരണങ്ങൾ, സ്റ്റാർട്ടപ്പിൽ പ്രവർത്തിക്കുന്ന കോഡ് എന്നിവ വിവരിക്കുന്നു. സെർവറുകൾ, ഷാർഡിംഗ്, ക്യൂകൾ, കാലഹരണപ്പെട്ട ഡാറ്റ ഇല്ലാതാക്കൽ തുടങ്ങിയവ.

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

ഇൻസ്റ്റൻസ് മാനേജ്മെന്റ്

ഞങ്ങൾക്ക് tarantoolctl കമാൻഡ് ഉണ്ട്, ഇത് Tarantula സംഭവങ്ങൾ നിയന്ത്രിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, tarantoolctl ചെക്ക് ഉദാഹരണം കോൺഫിഗറേഷൻ ഫയൽ പരിശോധിച്ച് പറയും - അവിടെ വാക്യഘടന പിശകുകൾ ഇല്ലെങ്കിൽ ഫയൽ ശരിയാണ്.

നിങ്ങൾക്ക് ഉദാഹരണത്തിന്റെ നില കാണാൻ കഴിയും - tarantoolctl സ്റ്റാറ്റസ് ഉദാഹരണം. അതുപോലെ, നിങ്ങൾക്ക് ആരംഭിക്കുക, നിർത്തുക, പുനരാരംഭിക്കുക.

ഉദാഹരണം പ്രവർത്തിപ്പിച്ചുകഴിഞ്ഞാൽ, നിങ്ങൾക്ക് രണ്ട് തരത്തിൽ ഇതിലേക്ക് കണക്റ്റുചെയ്യാനാകും.

1. അഡ്മിനിസ്ട്രേറ്റീവ് കൺസോൾ

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

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

ഭരണപരമായ കാര്യങ്ങൾക്ക് ഈ രീതി ആവശ്യമാണ്. ഡാറ്റയുമായി പ്രവർത്തിക്കാൻ, രണ്ടാമത്തെ രീതി ഉപയോഗിക്കുക - ബൈനറി പ്രോട്ടോക്കോൾ.

2. ബൈനറി പ്രോട്ടോക്കോൾ ഉപയോഗിച്ച് ഒരു നിർദ്ദിഷ്ട പോർട്ടിലേക്ക് കണക്റ്റുചെയ്യുന്നു

കോൺഫിഗറേഷനിൽ കേൾക്കാനുള്ള നിർദ്ദേശം അടങ്ങിയിരിക്കുന്നു, അത് ബാഹ്യ ആശയവിനിമയങ്ങൾക്കായി ഒരു പോർട്ട് തുറക്കുന്നു. ഈ പോർട്ട് ബൈനറി പ്രോട്ടോക്കോളിനൊപ്പം ഉപയോഗിക്കുകയും പ്രാമാണീകരണം അവിടെ പ്രാപ്തമാക്കുകയും ചെയ്യുന്നു.

ഈ കണക്ഷനായി, tarantoolctl കണക്ട് ടു പോർട്ട് നമ്പറാണ് ഉപയോഗിക്കുന്നത്. ഇത് ഉപയോഗിച്ച്, നിങ്ങൾക്ക് വിദൂര സെർവറുകളിലേക്ക് കണക്റ്റുചെയ്യാനും പ്രാമാണീകരണം ഉപയോഗിക്കാനും വിവിധ ആക്സസ് അവകാശങ്ങൾ നൽകാനും കഴിയും.

ഡാറ്റ റെക്കോർഡിംഗും ബോക്സ് മൊഡ്യൂളും

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

റെക്കോർഡിംഗ്

ഉദാഹരണത്തിന്, ഞങ്ങൾ ബോക്സ് മൊഡ്യൂളിലേക്ക് പോയി box.once ഫംഗ്ഷൻ എന്ന് വിളിക്കുന്നു. സെർവർ ആരംഭിക്കുമ്പോൾ ഞങ്ങളുടെ കോഡ് പ്രവർത്തിപ്പിക്കാൻ ഇത് Tarantool-നെ നിർബന്ധിക്കും. ഞങ്ങളുടെ ഡാറ്റ സംഭരിക്കുന്ന ഒരു ഇടം ഞങ്ങൾ സൃഷ്ടിക്കുന്നു.

local function bootstrap()
    local space = box.schema.create_space('example')
    space:create_index('primary')
    box.schema.user.grant('guest', 'read,write,execute', 'universe')

    -- Keep things safe by default
    --  box.schema.user.create('example', { password = 'secret' })
    --  box.schema.user.grant('example', 'replication')
    --  box.schema.user.grant('example', 'read,write,execute', 'space', 'example')
end

ഇതിനുശേഷം, ഞങ്ങൾ ഒരു പ്രാഥമിക സൂചിക സൃഷ്ടിക്കുന്നു - പ്രൈമറി - അതിലൂടെ നമുക്ക് ഡാറ്റ തിരയാൻ കഴിയും. സ്ഥിരസ്ഥിതിയായി, നിങ്ങൾ പാരാമീറ്ററുകളൊന്നും വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, ഓരോ റെക്കോർഡിലെയും ആദ്യ ഫീൽഡ് പ്രാഥമിക സൂചികയ്ക്കായി ഉപയോഗിക്കും.

തുടർന്ന് ഞങ്ങൾ അതിഥി ഉപയോക്താവിന് ഒരു ഗ്രാന്റ് നൽകുന്നു, അതിന് കീഴിൽ ഞങ്ങൾ ബൈനറി പ്രോട്ടോക്കോൾ വഴി ബന്ധിപ്പിക്കുന്നു. മുഴുവൻ സന്ദർഭത്തിലും വായിക്കാനും എഴുതാനും നടപ്പിലാക്കാനും ഞങ്ങൾ അനുവദിക്കുന്നു.

പരമ്പരാഗത ഡാറ്റാബേസുകളുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, ഇവിടെ എല്ലാം വളരെ ലളിതമാണ്. ഞങ്ങൾക്ക് സ്ഥലമുണ്ട് - ഞങ്ങളുടെ ഡാറ്റ ലളിതമായി സംഭരിച്ചിരിക്കുന്ന ഒരു മേഖല. ഓരോ റെക്കോർഡിനെയും ഒരു ട്യൂപ്പിൾ എന്ന് വിളിക്കുന്നു. ഇത് മെസേജ്പാക്കിലാണ് പാക്കേജ് ചെയ്തിരിക്കുന്നത്. ഇത് വളരെ രസകരമായ ഒരു ഫോർമാറ്റാണ് - ഇത് ബൈനറി ആണ്, കൂടാതെ കുറച്ച് സ്ഥലം എടുക്കുന്നു - 18 ബൈറ്റുകളും 27 ഉം.

അവനോടൊപ്പം പ്രവർത്തിക്കുന്നത് തികച്ചും സൗകര്യപ്രദമാണ്. മിക്കവാറും എല്ലാ വരികൾക്കും, എല്ലാ ഡാറ്റ റെക്കോർഡിനും തികച്ചും വ്യത്യസ്തമായ നിരകൾ ഉണ്ടാകാം.

Box.space കമാൻഡ് ഉപയോഗിച്ച് നമുക്ക് എല്ലാ സ്പെയ്സുകളും കാണാൻ കഴിയും. ഒരു നിർദ്ദിഷ്ട ഉദാഹരണം തിരഞ്ഞെടുക്കുന്നതിന്, box.space ഉദാഹരണം എഴുതുക, അതിനെക്കുറിച്ചുള്ള പൂർണ്ണമായ വിവരങ്ങൾ നേടുക.

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

വിനൈൽ ഞങ്ങൾക്ക് കൂടുതൽ പരിചിതമായ ഒരു രൂപത്തിൽ ഡിസ്കിൽ ഡാറ്റ സംഭരിക്കുന്നു - അതായത്, ഞങ്ങൾക്ക് മെമ്മറി ഉള്ളതിനേക്കാൾ കൂടുതൽ ഡാറ്റ നിങ്ങൾക്ക് സംഭരിക്കാൻ കഴിയും, കൂടാതെ ടരാന്റുല അത് ഡിസ്കിൽ നിന്ന് വായിക്കും.

ഇപ്പോൾ നമ്മൾ മെമ്മറി ഉപയോഗിക്കും.

unix/:/var/run/tarantool/example.control> box.space.example
---
- engine: memtx
  before_replace: 'function: 0x41eb02c8'
  on_replace: 'function: 0x41eb0568'
  ck_constraint: []
  field_count: 0
  temporary: false
  index:
    0: &0
      unique: true
      parts:
      - type: unsigned
        is_nullable: false
        fieldno: 1
      id: 0
      space_id: 512
      type: TREE
      name: primary
    primary: *0
  is_local: false
  enabled: true
  name: example
  id: 512
...

unix/:/var/run/tarantool/example.control>

സൂചിക:

ഏത് സ്ഥലത്തിനും ഒരു പ്രാഥമിക സൂചിക സൃഷ്ടിക്കേണ്ടതുണ്ട്, കാരണം അതില്ലാതെ ഒന്നും പ്രവർത്തിക്കില്ല. ഏതൊരു ഡാറ്റാബേസിലെയും പോലെ, ഞങ്ങൾ ആദ്യ ഫീൽഡ് സൃഷ്ടിക്കുന്നു - റെക്കോർഡ് ഐഡി.

ഭാഗങ്ങൾ:

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

അപ്പോൾ നമുക്ക് ഇൻസേർട്ട് കമാൻഡ് ഉപയോഗിച്ച് ഡാറ്റ ചേർക്കാം.

unix/:/var/run/tarantool/example.control> box.space.example:insert{1, 'test1', 'test2'}
---
- [1, 'test1', 'test2']
...

unix/:/var/run/tarantool/example.control> box.space.example:insert{2, 'test2', 'test3', 'test4'}
---
- [2, 'test2', 'test3', 'test4']
...

unix/:/var/run/tarantool/example.control> box.space.example:insert{3, 'test3'}
---
- [3, 'test3']
...

unix/:/var/run/tarantool/example.control> box.space.example:insert{4, 'test4'}
---
- [4, 'test4']
...

unix/:/var/run/tarantool/example.control>

ആദ്യ ഫീൽഡ് പ്രാഥമിക കീ ആയി ഉപയോഗിക്കുന്നു, അതിനാൽ അത് അദ്വിതീയമായിരിക്കണം. നിരകളുടെ എണ്ണത്തിൽ ഞങ്ങൾ പരിമിതപ്പെടുത്തിയിട്ടില്ല, അതിനാൽ ഞങ്ങൾക്ക് ആവശ്യമുള്ളത്ര ഡാറ്റ അവിടെ ചേർക്കാം. ഞാൻ മുകളിൽ വിവരിച്ച മെസേജ്പാക്ക് ഫോർമാറ്റിലാണ് അവ വ്യക്തമാക്കിയിരിക്കുന്നത്.

ഡാറ്റ ഔട്ട്പുട്ട്

അപ്പോൾ നമുക്ക് സെലക്ട് കമാൻഡ് ഉപയോഗിച്ച് ഡാറ്റ പ്രദർശിപ്പിക്കാം.

{1} കീ ഉപയോഗിച്ച് Box.example.select ആവശ്യമുള്ള എൻട്രി പ്രദർശിപ്പിക്കും. താക്കോൽ താഴ്ത്തിയാൽ, നമ്മുടെ കൈവശമുള്ള എല്ലാ രേഖകളും കാണാം. അവയെല്ലാം നിരകളുടെ എണ്ണത്തിൽ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു, എന്നാൽ ഇവിടെ, തത്ത്വത്തിൽ, നിരകളുടെ ആശയം ഇല്ല - ഫീൽഡ് നമ്പറുകൾ ഉണ്ട്.

തികച്ചും ഏത് അളവിലും ഡാറ്റ ഉണ്ടായിരിക്കാം. ഉദാഹരണത്തിന്, രണ്ടാമത്തെ ഫീൽഡ് ഉപയോഗിച്ച് നമ്മൾ അവരെ തിരയേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ ഒരു പുതിയ ദ്വിതീയ സൂചിക സൃഷ്ടിക്കുന്നു.

box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }}) 

ഞങ്ങൾ Create_index കമാൻഡ് ഉപയോഗിക്കുന്നു.
നമുക്ക് അതിനെ സെക്കൻഡറി എന്ന് വിളിക്കാം.

ഇതിനുശേഷം നിങ്ങൾ പാരാമീറ്ററുകൾ വ്യക്തമാക്കേണ്ടതുണ്ട്. സൂചിക തരം TREE ആണ്. ഇത് അദ്വിതീയമായിരിക്കില്ല, അതിനാൽ Unique = false എന്ന് നൽകുക.

അപ്പോൾ നമ്മുടെ സൂചികയിൽ അടങ്ങിയിരിക്കുന്ന ഭാഗങ്ങൾ ഞങ്ങൾ സൂചിപ്പിക്കുന്നു. ഫീൽഡ് എന്നത് നമ്മൾ സൂചിക ബന്ധിപ്പിക്കുന്ന ഫീൽഡിന്റെ സംഖ്യയാണ്, കൂടാതെ സ്ട്രിംഗ് തരം വ്യക്തമാക്കുക. അങ്ങനെ അത് സൃഷ്ടിക്കപ്പെട്ടു.

unix/:/var/run/tarantool/example.control> box.space.example:create_index('secondary', { type = 'TREE', unique = false, parts = {{field = 2, type = 'string'}}})
---
- unique: false
  parts:
  - type: string
    is_nullable: false
    fieldno: 2
  id: 1
  space_id: 512
  type: TREE
  name: secondary
...

unix/:/var/run/tarantool/example.control>

ഇപ്പോൾ നമുക്ക് ഇതിനെ ഇങ്ങനെ വിളിക്കാം:

unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...

സംരക്ഷണം

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

ഓരോ സെക്കൻഡും സംരക്ഷിക്കാൻ ഇത് പ്രവർത്തിക്കില്ല, കാരണം ഡിസ്കിലേക്ക് നിരന്തരം 20 GB ഇടുന്നത് നല്ല ആശയമല്ല.

ഈ ആവശ്യത്തിനായി, റൈറ്റ്-എഹെഡ് ലോഗ് എന്ന ആശയം കണ്ടുപിടിക്കുകയും നടപ്പിലാക്കുകയും ചെയ്തു. അതിന്റെ സഹായത്തോടെ, ഡാറ്റയിലെ ഓരോ മാറ്റത്തിനും, ഒരു ചെറിയ റൈറ്റ്-എഹെഡ് ലോഗ് ഫയലിൽ ഒരു എൻട്രി സൃഷ്ടിക്കപ്പെടുന്നു.

ചെക്ക് പോയിന്റ് വരെയുള്ള ഓരോ എൻട്രിയും അവയിൽ സൂക്ഷിച്ചിരിക്കുന്നു. ഈ ഫയലുകൾക്കായി ഞങ്ങൾ വലുപ്പം സജ്ജമാക്കി - ഉദാഹരണത്തിന്, 64 MB. അത് നിറയുമ്പോൾ, റെക്കോർഡിംഗ് രണ്ടാമത്തെ ഫയലിലേക്ക് പോകാൻ തുടങ്ങുന്നു. പുനരാരംഭിച്ചതിന് ശേഷം, അവസാന ചെക്ക് പോയിന്റിൽ നിന്ന് Tarantool പുനഃസ്ഥാപിക്കുകയും അത് നിർത്തുന്നത് വരെ പിന്നീടുള്ള എല്ലാ ഇടപാടുകളും റോൾ ചെയ്യുകയും ചെയ്യുന്നു.

അത്തരം റെക്കോർഡിംഗ് നടപ്പിലാക്കാൻ, നിങ്ങൾ box.cfg ക്രമീകരണങ്ങളിൽ (example.lua ഫയലിൽ) ഓപ്ഷൻ വ്യക്തമാക്കേണ്ടതുണ്ട്:

wal_mode = “write”;

ഡാറ്റ ഉപയോഗം

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

ഒരു അപേക്ഷ എഴുതുന്നു

ഉദാഹരണത്തിന്, ടരാന്റുലയ്ക്കായി ഇനിപ്പറയുന്ന ആപ്ലിക്കേഷൻ എഴുതാം

സ്‌പോയിലറിന് കീഴിലുള്ള ആപ്ലിക്കേഷൻ കാണുക

box.cfg {
    listen = '0.0.0.0:3301';
    io_collect_interval = nil;
    readahead = 16320;
    memtx_memory = 128 * 1024 * 1024; -- 128Mb
    memtx_min_tuple_size = 16;
    memtx_max_tuple_size = 128 * 1024 * 1024; -- 128Mb
    vinyl_memory = 128 * 1024 * 1024; -- 128Mb
    vinyl_cache = 128 * 1024 * 1024; -- 128Mb
    vinyl_max_tuple_size = 128 * 1024 * 1024; -- 128Mb
    vinyl_write_threads = 2;
    wal_mode = "write";
    wal_max_size = 256 * 1024 * 1024;
    checkpoint_interval = 60 * 60; -- one hour
    checkpoint_count = 6;
    force_recovery = true;
    log_level = 5;
    log_nonblock = false;
    too_long_threshold = 0.5;
    read_only   = false
}

local function bootstrap()
    local space = box.schema.create_space('example')
    space:create_index('primary')

    box.schema.user.create('example', { password = 'secret' })
    box.schema.user.grant('example', 'read,write,execute', 'space', 'example')

    box.schema.user.create('repl', { password = 'replication' })
    box.schema.user.grant('repl', 'replication')
end

-- for first run create a space and add set up grants
box.once('replica', bootstrap)

-- enabling console access
console = require('console')
console.listen('127.0.0.1:3302')

-- http config
local charset = {}  do -- [0-9a-zA-Z]
    for c = 48, 57  do table.insert(charset, string.char(c)) end
    for c = 65, 90  do table.insert(charset, string.char(c)) end
    for c = 97, 122 do table.insert(charset, string.char(c)) end
end

local function randomString(length)
    if not length or length <= 0 then return '' end
    math.randomseed(os.clock()^5)
    return randomString(length - 1) .. charset[math.random(1, #charset)]
end

local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')

local httpd = http_server.new('0.0.0.0', 8080, {
    log_requests = true,
    log_errors = true
})

local router = http_router.new()

local function get_count()
 local cnt = box.space.example:len()
 return cnt
end

router:route({method = 'GET', path = '/count'}, function()
    return {status = 200, body = json.encode({count = get_count()})}
end)

router:route({method = 'GET', path = '/token'}, function()
    local token = randomString(32)
    local last = box.space.example:len()
    box.space.example:insert{ last + 1, token }
    return {status = 200, body = json.encode({token = token})}
end)

prometheus = require('prometheus')

fiber = require('fiber')
tokens_count = prometheus.gauge("tarantool_tokens_count",
                              "API Tokens Count")

function monitor_tokens_count()
  while true do
    tokens_count:set(get_count())
    fiber.sleep(5)
  end
end
fiber.create(monitor_tokens_count)

router:route( { method = 'GET', path = '/metrics' }, prometheus.collect_http)

httpd:set_router(router)
httpd:start()

പ്രതീകങ്ങളെ നിർവചിക്കുന്ന ചില പട്ടിക ഞങ്ങൾ ലുവയിൽ പ്രഖ്യാപിക്കുന്നു. ക്രമരഹിതമായ ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കാൻ ഈ പ്ലേറ്റ് ആവശ്യമാണ്.

local charset = {}  do -- [0-9a-zA-Z]
    for c = 48, 57  do table.insert(charset, string.char(c)) end
    for c = 65, 90  do table.insert(charset, string.char(c)) end
    for c = 97, 122 do table.insert(charset, string.char(c)) end
end

അതിനുശേഷം, ഞങ്ങൾ ഫംഗ്ഷൻ - randomString പ്രഖ്യാപിക്കുകയും പരാൻതീസിസിൽ ദൈർഘ്യ മൂല്യം നൽകുകയും ചെയ്യുന്നു.

local function randomString(length)
    if not length or length <= 0 then return '' end
    math.randomseed(os.clock()^5)
    return randomString(length - 1) .. charset[math.random(1, #charset)]
end

തുടർന്ന് ഞങ്ങൾ http റൂട്ടറും http സെർവറും ഞങ്ങളുടെ Tarantula സെർവറായ JSON-ലേക്ക് ബന്ധിപ്പിക്കുന്നു, അത് ഞങ്ങൾ ക്ലയന്റിലേക്ക് അയയ്ക്കും.

local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')

ഇതിനുശേഷം, എല്ലാ http സെർവർ ഇന്റർഫേസുകളിലും ഞങ്ങൾ പോർട്ട് 8080-ൽ ആരംഭിക്കുന്നു, അത് എല്ലാ അഭ്യർത്ഥനകളും പിശകുകളും ലോഗ് ചെയ്യും.

local httpd = http_server.new('0.0.0.0', 8080, {
    log_requests = true,
    log_errors = true
})

അടുത്തതായി, ഞങ്ങൾ റൂട്ട് പ്രഖ്യാപിക്കുന്നു, അങ്ങനെ GET രീതിയിലുള്ള ഒരു അഭ്യർത്ഥന പോർട്ട് 8080 /count-ൽ എത്തിയാൽ, ഞങ്ങൾ ഒരു വരിയിൽ നിന്ന് ഫംഗ്ഷനെ വിളിക്കുന്നു. ഇത് സ്റ്റാറ്റസ് നൽകുന്നു - 200, 404, 403 അല്ലെങ്കിൽ ഞങ്ങൾ വ്യക്തമാക്കുന്ന മറ്റേതെങ്കിലും.

router:route({method = 'GET', path = '/count'}, function()
    return {status = 200, body = json.encode({count = get_count()})}
end)

ബോഡിയിൽ നമ്മൾ json.encode നൽകുന്നു, അതിൽ ഞങ്ങൾ കൗണ്ട്, ഗെറ്റ്കൗണ്ട് എന്നിവ സൂചിപ്പിക്കുന്നു, അതിനെ വിളിക്കുകയും ഞങ്ങളുടെ ഡാറ്റാബേസിലെ റെക്കോർഡുകളുടെ എണ്ണം കാണിക്കുകയും ചെയ്യുന്നു.

രണ്ടാമത്തെ രീതി

router:route({method = 'GET', path = '/token'}, function() 
    local token = randomString(32) 
    local last = box.space.example:len() 
    box.space.example:insert{ last + 1, token } 
    return {status = 200, body = json.encode({token = token})}
end)

വരിയിൽ എവിടെ റൂട്ടർ: റൂട്ട്({രീതി = 'GET', പാത്ത് = '/ടോക്കൺ'}, ഫംഗ്‌ഷൻ() ഞങ്ങൾ ഫംഗ്‌ഷനെ വിളിക്കുകയും ഒരു ടോക്കൺ സൃഷ്ടിക്കുകയും ചെയ്യുന്നു.

സ്ട്രിംഗ് പ്രാദേശിക ടോക്കൺ = റാൻഡംസ്ട്രിംഗ്(32) 32 പ്രതീകങ്ങളുടെ ക്രമരഹിതമായ സ്ട്രിംഗ് ആണ്.
ഇൻ ലൈൻ ലോക്കൽ ലാസ്റ്റ് = box.space.example:len() ഞങ്ങൾ അവസാന ഘടകം പുറത്തെടുക്കുന്നു.
ഒപ്പം വരിയിലും box.space.example:insert{ last + 1, token } ഞങ്ങളുടെ ഡാറ്റാബേസിലേക്ക് ഞങ്ങൾ ഡാറ്റ എഴുതുന്നു, അതായത്, ഞങ്ങൾ ഐഡി 1 കൊണ്ട് വർദ്ധിപ്പിക്കുന്നു. ഇത് ഈ വിചിത്രമായ രീതിയിൽ മാത്രമല്ല, വഴിയിൽ ചെയ്യാം. ടരാന്റുലയിൽ ഇതിനുള്ള സീക്വൻസുകൾ ഉണ്ട്.

ഞങ്ങൾ അവിടെ ടോക്കൺ എഴുതുന്നു.

അങ്ങനെ, ഞങ്ങൾ ഒരു ഫയലിൽ ആപ്ലിക്കേഷൻ എഴുതി. നിങ്ങൾക്ക് അവിടെ ഡാറ്റ നേരിട്ട് കൈകാര്യം ചെയ്യാൻ കഴിയും, കൂടാതെ ബോക്സ് മൊഡ്യൂൾ നിങ്ങൾക്കായി എല്ലാ വൃത്തികെട്ട ജോലികളും ചെയ്യും.

ഇത് http കേൾക്കുകയും ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിക്കുകയും ചെയ്യുന്നു, എല്ലാം ഒരൊറ്റ സന്ദർഭത്തിലാണ് - ആപ്ലിക്കേഷനും ഡാറ്റയും. അതിനാൽ, എല്ലാം വളരെ വേഗത്തിൽ സംഭവിക്കുന്നു.

ആരംഭിക്കുന്നതിന്, ഞങ്ങൾ http മൊഡ്യൂൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു:

ഞങ്ങൾ ഇത് എങ്ങനെ ചെയ്യുന്നു, സ്‌പോയിലറിന് കീഴിൽ നോക്കുക

root@test2:/# tarantoolctl rocks install http
Installing http://rocks.tarantool.org/http-scm-1.src.rock
Missing dependencies for http scm-1:
   checks >= 3.0.1 (not installed)

http scm-1 depends on checks >= 3.0.1 (not installed)
Installing http://rocks.tarantool.org/checks-3.0.1-1.rockspec

Cloning into 'checks'...
remote: Enumerating objects: 28, done.
remote: Counting objects: 100% (28/28), done.
remote: Compressing objects: 100% (19/19), done.
remote: Total 28 (delta 1), reused 16 (delta 1), pack-reused 0
Receiving objects: 100% (28/28), 12.69 KiB | 12.69 MiB/s, done.
Resolving deltas: 100% (1/1), done.
Note: checking out '580388773ef11085015b5a06fe52d61acf16b201'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b <new-branch-name>

No existing manifest. Attempting to rebuild...
checks 3.0.1-1 is now installed in /.rocks (license: BSD)

-- The C compiler identification is GNU 7.5.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Found TARANTOOL: /usr/include (found version "2.4.2-80-g18f2bc82d")
-- Tarantool LUADIR is /.rocks/share/tarantool/rocks/http/scm-1/lua
-- Tarantool LIBDIR is /.rocks/share/tarantool/rocks/http/scm-1/lib
-- Configuring done
-- Generating done
CMake Warning:
  Manually-specified variables were not used by the project:

    version


-- Build files have been written to: /tmp/luarocks_http-scm-1-V4P9SM/http/build.luarocks
Scanning dependencies of target httpd
[ 50%] Building C object http/CMakeFiles/httpd.dir/lib.c.o
In file included from /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:32:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c: In function ‘tpl_term’:
/usr/include/tarantool/lauxlib.h:144:15: warning: this statement may fall through [-Wimplicit-fallthrough=]
    (*(B)->p++ = (char)(c)))
    ~~~~~~~~~~~^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:62:7: note: in expansion of macro ‘luaL_addchar’
       luaL_addchar(b, '\');
       ^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:63:6: note: here
      default:
      ^~~~~~~
In file included from /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:39:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h: In function ‘tpe_parse’:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:147:9: warning: this statement may fall through [-Wimplicit-fallthrough=]
    type = TPE_TEXT;
    ~~~~~^~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:149:3: note: here
   case TPE_LINECODE:
   ^~~~
In file included from /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:40:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h: In function ‘httpfast_parse’:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:372:22: warning: this statement may fall through [-Wimplicit-fallthrough=]
                 code = 0;
                 ~~~~~^~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:374:13: note: here
             case status:
             ^~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:393:23: warning: this statement may fall through [-Wimplicit-fallthrough=]
                 state = message;
                 ~~~~~~^~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:395:13: note: here
             case message:
             ^~~~
[100%] Linking C shared library lib.so
[100%] Built target httpd
[100%] Built target httpd
Install the project...
-- Install configuration: "Debug"
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/VERSION.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lib/http/lib.so
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/init.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/tsgi_adapter.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/nginx_server/init.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/init.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/fs.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/matching.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/middleware.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/request.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/response.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/tsgi.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/utils.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/mime_types.lua
-- Installing: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/codes.lua
http scm-1 is now installed in /.rocks (license: BSD)

root@test2:/#

ഓടാൻ ഞങ്ങൾക്ക് പ്രോമിത്യൂസും ആവശ്യമാണ്:

root@test2:/# tarantoolctl rocks install prometheus
Installing http://rocks.tarantool.org/prometheus-scm-1.rockspec

Cloning into 'prometheus'...
remote: Enumerating objects: 19, done.
remote: Counting objects: 100% (19/19), done.
remote: Compressing objects: 100% (19/19), done.
remote: Total 19 (delta 2), reused 5 (delta 0), pack-reused 0
Receiving objects: 100% (19/19), 10.73 KiB | 10.73 MiB/s, done.
Resolving deltas: 100% (2/2), done.
prometheus scm-1 is now installed in /.rocks (license: BSD)

root@test2:/#

ഞങ്ങൾ സമാരംഭിക്കുകയും മൊഡ്യൂളുകൾ ആക്സസ് ചെയ്യുകയും ചെയ്യാം

root@test2:/# curl -D - -s http://127.0.0.1:8080/token
HTTP/1.1 200 Ok
Content-length: 44
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Connection: keep-alive

{"token":"e2tPq9l5Z3QZrewRf6uuoJUl3lJgSLOI"}

root@test2:/# curl -D - -s http://127.0.0.1:8080/token
HTTP/1.1 200 Ok
Content-length: 44
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Connection: keep-alive

{"token":"fR5aCA84gj9eZI3gJcV0LEDl9XZAG2Iu"}

root@test2:/# curl -D - -s http://127.0.0.1:8080/count
HTTP/1.1 200 Ok
Content-length: 11
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Connection: keep-alive

{"count":2}root@test2:/#

/എണ്ണം ഞങ്ങൾക്ക് സ്റ്റാറ്റസ് 200 നൽകുന്നു.
/ടോക്കൺ ഒരു ടോക്കൺ നൽകുകയും ഈ ടോക്കൺ ഡാറ്റാബേസിലേക്ക് എഴുതുകയും ചെയ്യുന്നു.

വേഗത പരിശോധിക്കുന്നു

50 അഭ്യർത്ഥനകൾക്കായി നമുക്ക് ഒരു മാനദണ്ഡം പ്രവർത്തിപ്പിക്കാം. 000 മത്സര അഭ്യർത്ഥനകൾ ഉണ്ടാകും.

root@test2:/# ab -c 500 -n 50000 http://127.0.0.1:8080/token
This is ApacheBench, Version 2.3 <$Revision: 1807734 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking 127.0.0.1 (be patient)
Completed 5000 requests
Completed 10000 requests
Completed 15000 requests
Completed 20000 requests
Completed 25000 requests
Completed 30000 requests
Completed 35000 requests
Completed 40000 requests
Completed 45000 requests
Completed 50000 requests
Finished 50000 requests


Server Software:        Tarantool
Server Hostname:        127.0.0.1
Server Port:            8080

Document Path:          /token
Document Length:        44 bytes

Concurrency Level:      500
Time taken for tests:   14.578 seconds
Complete requests:      50000
Failed requests:        0
Total transferred:      7950000 bytes
HTML transferred:       2200000 bytes
Requests per second:    3429.87 [#/sec] (mean)
Time per request:       145.778 [ms] (mean)
Time per request:       0.292 [ms] (mean, across all concurrent requests)
Transfer rate:          532.57 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0   10 103.2      0    3048
Processing:    12   69 685.1     15   13538
Waiting:       12   69 685.1     15   13538
Total:         12   78 768.2     15   14573

Percentage of the requests served within a certain time (ms)
  50%     15
  66%     15
  75%     16
  80%     16
  90%     16
  95%     16
  98%     21
  99%     42
 100%  14573 (longest request)
root@test2:/#

ടോക്കണുകൾ വിതരണം ചെയ്യുന്നു. ഞങ്ങൾ നിരന്തരം ഡാറ്റ റെക്കോർഡുചെയ്യുന്നു. 99% അഭ്യർത്ഥനകളും 42 മില്ലിസെക്കൻഡിൽ പ്രോസസ്സ് ചെയ്തു. അതനുസരിച്ച്, 3500 കോറുകളും 2 ജിഗാബൈറ്റ് മെമ്മറിയുമുള്ള ഒരു ചെറിയ മെഷീനിൽ ഞങ്ങൾക്ക് സെക്കൻഡിൽ ഏകദേശം 4 അഭ്യർത്ഥനകളുണ്ട്.

നിങ്ങൾക്ക് ഏകദേശം 50000 ടോക്കൺ തിരഞ്ഞെടുത്ത് അതിന്റെ മൂല്യം കാണാനും കഴിയും.

നിങ്ങൾക്ക് http മാത്രമല്ല, നിങ്ങളുടെ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്ന പശ്ചാത്തല പ്രവർത്തനങ്ങളും പ്രവർത്തിപ്പിക്കാം. കൂടാതെ, വിവിധ ട്രിഗറുകൾ ഉണ്ട്. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് അപ്ഡേറ്റുകളിൽ ഫംഗ്ഷനുകൾ വിളിക്കാം, എന്തെങ്കിലും പരിശോധിക്കുക - ശരിയായ വൈരുദ്ധ്യങ്ങൾ.

നിങ്ങൾക്ക് ഡാറ്റാബേസ് സെർവറിൽ തന്നെ നേരിട്ട് സ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനുകൾ എഴുതാം, കൂടാതെ ഒന്നിലും പരിമിതപ്പെടുത്തരുത്, ഏതെങ്കിലും മൊഡ്യൂളുകൾ ബന്ധിപ്പിച്ച് ഏതെങ്കിലും ലോജിക് നടപ്പിലാക്കുക.

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

ടരാന്റുല ഇത് സ്വയം ചെയ്യും, നിങ്ങൾ ഒരു പ്രത്യേക ആപ്ലിക്കേഷൻ എഴുതേണ്ടതില്ല.

ഉപസംഹാരമായി

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

ഞങ്ങൾ ഓൺലൈനിൽ ഇവ നിർമ്മിക്കുന്ന ഇവന്റുകളിൽ പങ്കെടുക്കാനും തത്സമയം ചോദ്യങ്ങൾ ചോദിക്കാനും നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, ട്യൂൺ ചെയ്യുക REBRAIN എന്നയാളുടെ ചാനൽ DevOps.

നിങ്ങൾക്ക് ക്ലൗഡിലേക്ക് നീങ്ങണമെങ്കിൽ അല്ലെങ്കിൽ നിങ്ങളുടെ ഇൻഫ്രാസ്ട്രക്ചറിനെ കുറിച്ച് ചോദ്യങ്ങളുണ്ടെങ്കിൽ, ഒരു അഭ്യർത്ഥന നൽകാൻ മടിക്കേണ്ടതില്ല.

PS ഞങ്ങൾക്ക് പ്രതിമാസം 2 സൗജന്യ ഓഡിറ്റുകൾ ഉണ്ട്, ഒരുപക്ഷേ നിങ്ങളുടെ പ്രോജക്റ്റ് അവയിലൊന്നായിരിക്കാം.

അവലംബം: www.habr.com