ProHoster > බ්ලොග් > පරිපාලනය > Tarantool හි, ඔබට ඔවුන් සමඟ වැඩ කිරීමට සුපිරි වේගවත් දත්ත සමුදායක් සහ යෙදුමක් ඒකාබද්ධ කළ හැකිය. මෙන්න එය කොතරම් පහසුද යන්නයි

Tarantool හි, ඔබට ඔවුන් සමඟ වැඩ කිරීමට සුපිරි වේගවත් දත්ත සමුදායක් සහ යෙදුමක් ඒකාබද්ධ කළ හැකිය. මෙන්න එය කොතරම් පහසුද යන්නයි

මීට වසර පහකට පෙර මම ටැරන්ටූල් සමඟ වැඩ කිරීමට උත්සාහ කළ නමුත් පසුව එය මට සාර්ථක වූයේ නැත. නමුත් මෑතකදී මම වෙබ්නාර් එකක් පැවැත්වූ අතර එහිදී මම Hadoop ගැන, MapReduce ක්‍රියා කරන ආකාරය ගැන කතා කළෙමි. එහිදී මගෙන් ප්‍රශ්නය අසන ලදී - "මෙම කාර්යය සඳහා ටැරන්ටූල් භාවිතා නොකරන්නේ මන්ද?".

කුතුහලය සඳහා, මම එය වෙත ආපසු යාමට තීරණය කළෙමි, නවතම අනුවාදය පරීක්ෂා කරන්න - මේ වතාවේ මම ව්‍යාපෘතියට ඇත්තෙන්ම කැමතියි. දැන් මම ටැරන්ටූල් හි සරල යෙදුමක් ලියන්නේ කෙසේදැයි පෙන්වන්නම්, එය පූරණය කර කාර්ය සාධනය පරීක්ෂා කරන්න, එවිට සෑම දෙයක්ම කොතරම් පහසු සහ සිසිල් දැයි ඔබට පෙනෙනු ඇත.

Tarantool හි, ඔබට ඔවුන් සමඟ වැඩ කිරීමට සුපිරි වේගවත් දත්ත සමුදායක් සහ යෙදුමක් ඒකාබද්ධ කළ හැකිය. මෙන්න එය කොතරම් පහසුද යන්නයි

ටැරන්ටූල් යනු කුමක්ද?

Tarantool අතිශය වේගවත් දත්ත ගබඩාවක් ලෙස ස්ථානගත කරයි. ඔබට අවශ්‍ය ඕනෑම දත්තයක් එහි තැබිය හැකිය. ඊට අමතරව, ඒවා ප්‍රතිනිර්මාණය කරන්න, ෂාර්ඩ් - එනම්, විශාල දත්ත ප්‍රමාණයක් සේවාදායකයන් කිහිපයක් හරහා බෙදා ඒවායින් ලැබෙන ප්‍රතිඵල ඒකාබද්ධ කරන්න - දෝෂ-ඉවසන මාස්ටර්-මාස්ටර් සබැඳි සාදන්න.

දෙවනුව, එය යෙදුම් සේවාදායකයකි. ඔබට එය මත ඔබේ යෙදුම් ලිවිය හැකිය, දත්ත සමඟ වැඩ කරන්න, උදාහරණයක් ලෙස, යම් නීතිරීති අනුව පසුබිමේ පැරණි ඇතුළත් කිරීම් මකා දමන්න. ඔබට දත්ත සමඟ ක්‍රියා කරන Http සේවාදායකයක් ටැරන්ටුලා හි කෙලින්ම ලිවිය හැකිය: ඔවුන්ගේ අංකය ලබා දෙන්න, එහි නව දත්ත ලියන්න සහ ඒ සියල්ල මාස්ටර් වෙත අඩු කරන්න.

මම ලිපියක් කියෙව්වා යාලුවනේ පේළි 300 ක පණිවිඩ පෝලිමක් සෑදූ ආකාරය, එය හුදෙක් කඳුළු සහ පහර - ඔවුන්ට තත්පරයකට අවම වශයෙන් පණිවිඩ 20 ක කාර්ය සාධනයක් ඇත. මෙහිදී ඔබට සැබවින්ම හැරී ඉතා විශාල යෙදුමක් ලිවිය හැකි අතර, PostgreS හි මෙන් මේවා ගබඩා නොකෙරේ.

ආසන්න වශයෙන් එවැනි සේවාදායකයක්, සරල පමණක්, මම මෙම ලිපියෙන් විස්තර කිරීමට උත්සාහ කරමි.

ස්ථාපනය

පරීක්ෂණය සඳහා, මම සම්මත අථත්‍ය යන්ත්‍ර තුනක් ආරම්භ කළෙමි - ගිගාබයිට් 20 ක දෘඪ තැටියක්, උබුන්ටු 18.04. අතථ්‍ය CPU 2ක් සහ ගිගාබයිට් 4ක මතකයක්.

අපි Tarantool ස්ථාපනය කරමු - bash ස්ක්‍රිප්ට් එකක් ධාවනය කරන්න හෝ ගබඩාවක් එකතු කර Tarantool ස්ථාපනය කරන්න. පිටපතට සබැඳිය - (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). අපට මෙවැනි විධාන ඇත:

tarantoolctl Tarantula අවස්ථා කළමනාකරණය සඳහා ප්රධාන විධානය වේ.
/etc/tarantool - සම්පූර්ණ වින්‍යාසය මෙහි ඇත.
var/log/tarantool - මෙන්න ලඝු-සටහන්.
var/lib/tarantool - මෙහි දත්ත පිහිටා ඇති අතර පසුව ඒවා අවස්ථා වලට බෙදා ඇත.

උදාහරණ-ලබා ගත හැකි සහ උදාහරණ-සක්‍රීය ෆෝල්ඩර ඇත - එහි දියත් කරන දේ අඩංගු වේ - lua කේතය සහිත අවස්ථා වින්‍යාස ගොනුව, එය සවන් දෙන්නේ කුමන වරායද, එයට ලබා ගත හැකි මතකය කුමක්ද, Vinyl එන්ජින් සැකසුම්, ආරම්භයේදී ක්‍රියා කරන කේතය විස්තර කරයි. සේවාදායකයන්, බෙදා හැරීම, පෝලිම්, යල් පැන ගිය දත්ත මකා දැමීම සහ යනාදිය.

PostgreS හි මෙන් අවස්ථා ක්‍රියා කරයි. උදාහරණයක් ලෙස, ඔබට විවිධ වරායන් මත එල්ලා ඇති දත්ත සමුදායක පිටපත් කිහිපයක් ධාවනය කිරීමට අවශ්‍ය වේ. විවිධ වරායන් මත එල්ලෙන එක් සේවාදායකයක් මත දත්ත සමුදා අවස්ථා කිහිපයක් දියත් කර ඇති බව පෙනේ. ඔවුන්ට සම්පූර්ණයෙන්ම වෙනස් සැකසුම් තිබිය හැකිය - එක් අවස්ථාවක් එක් තර්කයක් ක්රියාත්මක කරයි, දෙවන - තවත්.

අවස්ථා කළමනාකරණය

Tarantula අවස්ථා කළමනාකරණය කිරීමට අපට ඉඩ දෙන tarantoolctl විධානය අප සතුව ඇත. උදාහරණයක් ලෙස, tarantoolctl චෙක් උදාහරණය මඟින් වින්‍යාස ගොනුව පරීක්ෂා කර වාක්‍ය ඛණ්ඩ දෝෂ නොමැති නම් ගොනුව හරි යැයි කියනු ඇත.

ඔබට අවස්ථාවෙහි තත්ත්වය දැකිය හැක - tarantoolctl තත්ව උදාහරණය. ඒ ආකාරයෙන්ම, ඔබට ආරම්භ කිරීම, නතර කිරීම, නැවත ආරම්භ කිරීම කළ හැකිය.

අවස්ථාවක් ක්‍රියාත්මක වූ පසු, එයට සම්බන්ධ වීමට ක්‍රම දෙකක් තිබේ.

1. පරිපාලන කොන්සෝලය

පෙරනිමියෙන්, Tarantool විසින් සොකට් එකක් විවෘත කර Tarantula පාලනය කිරීමට සරල ASCII පෙළ යවයි. කොන්සෝලයට සම්බන්ධ වීම සැමවිටම සිදුවන්නේ පරිපාලක පරිශීලකයා යටතේය, සත්‍යාපනයක් නොමැත, එබැවින් ටැරන්ටුල පිටතින් පාලනය කිරීමට ඔබට කොන්සෝල වරාය ඉවත් කිරීමට අවශ්‍ය නොවේ.

මේ ආකාරයෙන් සම්බන්ධ වීමට, ඔබ Tarantoolctl enter instance නම ඇතුළත් කළ යුතුය. විධානය මඟින් කොන්සෝලය දියත් කර පරිපාලක පරිශීලකයා ලෙස සම්බන්ධ වේ. කොන්සෝල වරාය කිසි විටෙකත් පිටත නිරාවරණය නොකරන්න - එය ඒකක සොකට් එකක් ලෙස තැබීම වඩා හොඳය. එවිට සොකට් එකට ලිවීමට ප්‍රවේශය ඇති අයට පමණක් ටැරන්ටුලාවට සම්බන්ධ විය හැකිය.

පරිපාලන කටයුතු සඳහා මෙම ක්රමය අවශ්ය වේ. දත්ත සමඟ වැඩ කිරීමට, දෙවන ක්රමය භාවිතා කරන්න - ද්විමය ප්රොටෝකෝලය.

2. නිශ්චිත වරායකට සම්බන්ධ වීමට ද්විමය ප්‍රොටෝකෝලයක් භාවිතා කිරීම

වින්‍යාසය තුළ සවන්දීමේ නියෝගයක් ඇත, එය බාහිර සන්නිවේදනය සඳහා වරාය විවෘත කරයි. මෙම වරාය ද්විමය ප්‍රොටෝකෝලය සමඟ භාවිතා වන අතර සත්‍යාපනය එහි සක්‍රීය කර ඇත.

මෙම සම්බන්ධතාවය සඳහා, tarantoolctl connect to port number භාවිතා වේ. එය භාවිතා කිරීමෙන්, ඔබට දුරස්ථ සේවාදායකයන්ට සම්බන්ධ වීමට, සත්‍යාපනය භාවිතා කිරීමට සහ විවිධ ප්‍රවේශ අයිතිවාසිකම් ලබා දිය හැකිය.

දත්ත පටිගත කිරීම සහ කොටු මොඩියුලය

ටැරන්ටූල් දත්ත සමුදායක් සහ යෙදුම් සේවාදායකයක් වන බැවින් එයට විවිධ මොඩියුල ඇත. අපි පෙට්ටි මොඩියුලය ගැන උනන්දු වෙමු - එය දත්ත සමඟ වැඩ කිරීම ක්රියාත්මක කරයි. ඔබ පෙට්ටියකට යමක් ලියන විට, ටැරන්ටූල් දත්ත තැටියට ලියයි, මතකයේ ගබඩා කරයි, නැතහොත් එය සමඟ වෙනත් දෙයක් කරයි.

වාර්තාව

උදාහරණයක් ලෙස, අපි කොටු මොඩියුලයට ගොස් 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

ඊට පසු, අපි ප්‍රාථමික දර්ශකයක් - ප්‍රාථමිකයක් සාදන්නෙමු, එමඟින් අපට දත්ත සෙවිය හැකිය. පෙරනිමියෙන්, පරාමිති කිසිවක් සඳහන් කර නොමැති නම්, ප්‍රාථමික දර්ශකය සඳහා එක් එක් ප්‍රවේශයේ පළමු ක්ෂේත්‍රය භාවිතා කරනු ලැබේ.

එවිට අපි ආගන්තුක පරිශීලකයාට ප්‍රදානයක් කරන්නෙමු, ඒ යටතේ අපි ද්විමය ප්‍රොටෝකෝලය හරහා සම්බන්ධ වෙමු. අපි සම්පූර්ණ අවස්ථාවෙහිදී කියවීමට, ලිවීමට සහ ක්‍රියාත්මක කිරීමට ඉඩ දෙමු.

සාම්ප්‍රදායික දත්ත සමුදායන් හා සසඳන විට, මෙහි සෑම දෙයක්ම තරමක් සරල ය. අපට ඉඩක් ඇත - අපගේ දත්ත සරලව ගබඩා කර ඇති ප්රදේශයකි. සෑම ඇතුල්වීමක්ම ටියුපල් ලෙස හැඳින්වේ. එය MessagePack එකක ඇසුරුම් කර ඇත. මෙය ඉතා සිසිල් ආකෘතියකි - එය ද්විමය වන අතර අඩු ඉඩක් ගනී - බයිට් 18 සහ 27.

Tarantool හි, ඔබට ඔවුන් සමඟ වැඩ කිරීමට සුපිරි වේගවත් දත්ත සමුදායක් සහ යෙදුමක් ඒකාබද්ධ කළ හැකිය. මෙන්න එය කොතරම් පහසුද යන්නයි

ඔහු සමඟ වැඩ කිරීම තරමක් පහසුය. සෑම පේළියකටම, සෑම දත්ත ඇතුළත් කිරීමකටම සම්පූර්ණයෙන්ම වෙනස් තීරු තිබිය හැක.

Box.space විධානය භාවිතයෙන් අපට සියලුම හිස්තැන් නැරඹිය හැක. නිශ්චිත අවස්ථාවක් තෝරාගැනීම සඳහා, අපි box.space උදාහරණය ලියා එය පිළිබඳ සම්පූර්ණ තොරතුරු ලබා ගනිමු.

ටැරන්ටූල් තුළ නිපදවන ලද එන්ජින් වර්ග දෙකක් තිබේ: මතකය සහ වයිනයිල්. මතකය සියලුම දත්ත මතකයේ ගබඩා කරයි. එමනිසා, සෑම දෙයක්ම සරලව හා ඉක්මනින් ක්රියා කරයි. දත්ත තැටියට දමනු ලබන අතර, ලිවීමට පෙර ලොග් යාන්ත්‍රණයක් ද ඇත, එබැවින් සේවාදායකය බිඳ වැටුණහොත් අපට කිසිවක් අහිමි නොවනු ඇත.

Vinyl තැටියේ දත්ත වඩාත් හුරුපුරුදු ආකාරයෙන් ගබඩා කරයි - එනම්, ඔබට අපට මතකයට වඩා වැඩි දත්ත ගබඩා කළ හැකි අතර, Tarantula එය තැටියෙන් කියවනු ඇත.

දැන් අපි මතකය භාවිතා කරමු. 

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 කි. නියමයි ගොඩක්.

එවිට අපට insert විධානය භාවිතයෙන් දත්ත ඇතුලත් කළ හැක.

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>

පළමු ක්ෂේත්‍රය මූලික යතුර ලෙස භාවිතා කරයි, එබැවින් එය අද්විතීය විය යුතුය. අපි තීරු ගණනින් සීමා නොවේ, එබැවින් අපට කැමති තරම් දත්ත එහි ඇතුළත් කළ හැකිය. ඒවා මා ඉහත විස්තර කළ MessagePack ආකෘතියෙන් දක්වා ඇත.

දත්ත ප්රතිදානය

ඊට පස්සේ අපිට select command එකෙන් data display කරන්න පුළුවන්.

Box.example.select යතුර සමඟින් {1} අපේක්ෂිත ප්‍රවේශය පෙන්වනු ඇත. අපි යතුර මඟ හැරියහොත්, අප සතුව ඇති සියලුම වාර්තා අපට පෙනෙනු ඇත. ඒවා සියල්ලම තීරු ගණන අනුව වෙනස් වේ, නමුත් මෙහි ප්‍රතිපත්තිමය වශයෙන් තීරු පිළිබඳ සංකල්පයක් නොමැත - ක්ෂේත්‍ර අංක ඇත.

ඔබට අවශ්‍ය තරම් දත්ත ප්‍රමාණයක් තිබිය හැක. උදාහරණයක් ලෙස, අපි ඒවා දෙවන ක්ෂේත්‍රයේ සෙවිය යුතුය. මෙය සිදු කිරීම සඳහා, අපි නව ද්විතියික දර්ශකයක් සාදන්නෙමු.


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

අපි Create_index විධානය භාවිතා කරමු.
අපි එය ද්විතියික ලෙස හඳුන්වමු.

ඊට පසු, ඔබ පරාමිතීන් නියම කළ යුතුය. දර්ශක වර්ගය TREE වේ. එය අද්විතීය නොවිය හැක, එබැවින් අපි Unique = අසත්‍ය ලෙස ඇතුළත් කරමු.

එවිට අපගේ දර්ශකය සමන්විත වන්නේ කුමන කොටස් වලින්ද යන්න අපි දක්වන්නෙමු. ක්ෂේත්‍රය යනු අපි දර්ශකය බැඳ තබන ක්ෂේත්‍ර අංකය වන අතර, තන්තු වර්ගය නියම කරයි. ඒ නිසා එය නිර්මාණය විය.

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 අවසන් මුරපොලෙන් යථා තත්ත්වයට පත් වන අතර පසුව එය නතර වන තෙක් සියලු පසු ගනුදෙනු පෙරළේ.

Tarantool හි, ඔබට ඔවුන් සමඟ වැඩ කිරීමට සුපිරි වේගවත් දත්ත සමුදායක් සහ යෙදුමක් ඒකාබද්ධ කළ හැකිය. මෙන්න එය කොතරම් පහසුද යන්නයි

එවැනි පටිගත කිරීමක් සිදු කිරීම සඳහා, ඔබ box.cfg සැකසුම් තුළ (උදාහරණ.lua ගොනුවේ) විකල්පයක් සඳහන් කළ යුතුය: 

wal_mode = “write”;

දත්ත භාවිතය

අපි දැන් ලියා ඇති දේ සමඟ, ඔබට දත්ත ගබඩා කිරීමට ටැරන්ටුල භාවිතා කළ හැකි අතර එය දත්ත සමුදායක් ලෙස ඉතා වේගයෙන් ක්‍රියා කරයි. දැන් කේක් මත චෙරි - ඔබට ඒ සියල්ලෙන් කළ හැක්කේ කුමක්ද?

අයදුම්පතක් ලිවීම

උදාහරණයක් ලෙස, Tarantula සඳහා එවැනි යෙදුමක් ලියන්න

ස්පොයිලර් යටතේ ඇති යෙදුම බලන්න

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()

අපි සංකේත නිර්වචනය කරන lua හි වගුවක් ප්‍රකාශ කරමු. අහඹු තන්තුවක් ජනනය කිරීමට මෙම වගුව අවශ්‍ය වේ. 

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

ඉන්පසුව අපි සේවාදායකයාට ලබා දෙන අපගේ Tarantula සේවාදායකය වන JSON වෙත http රවුටරය සහ http සේවාදායකය සම්බන්ධ කරමු.

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 ක්‍රමය සමඟ ඉල්ලීමක් port 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)

කෝ පේලියෙ router:route({method = 'GET', path = '/token'}, function() අපි ශ්‍රිතය අමතා ටෝකනයක් ජනනය කරමු.

රේඛාව දේශීය ටෝකනය = randomString(32) අක්ෂර 32 කින් යුත් අහඹු තන්තුවකි.
පෙළට දේශීය අන්තිම = box.space.example:len() අපි අවසාන අංගය ඉවත් කරමු.
සහ පේළියේ box.space.example:insert{ last + 1, token } අපි දත්ත අපගේ දත්ත ගබඩාවට ලියන්නෙමු, එනම්, අපි හුදෙක් හැඳුනුම්පත 1 කින් වැඩි කරමු. මෙය සිදු කළ හැක්කේ, එවැනි අවුල් සහගත ආකාරයෙන් පමණක් නොවේ. Tarantula මෙම නඩුව සඳහා අනුපිළිවෙල ඇත.

අපි එහි සංකේතය ලියන්නෙමු.

මේ අනුව, අපි එක් ගොනුවක යෙදුමක් ලිව්වෙමු. ඔබට වහාම දත්ත වෙත ප්‍රවේශ විය හැකි අතර, කොටු මොඩියුලය ඔබ වෙනුවෙන් සියලු අපිරිසිදු වැඩ කරනු ඇත.

එය 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:/#

අපට ධාවනය කිරීමට prometheus ද අවශ්‍ය වේ:

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ක් පමණ ඇති අතර එහිදී cores 2ක් සහ ගිගාබයිට් 4ක මතකයක් ඇත.

ඔබට ටෝකන 50000 ක් තෝරාගෙන එහි වටිනාකම බලන්න.

ඔබට http පමණක් නොව ඔබගේ දත්ත සකසන පසුබිම් ක්‍රියාකාරකම් ධාවනය කළ හැක. ඊට අමතරව විවිධ ප්‍රේරක ඇත. උදාහරණයක් ලෙස, ඔබට යාවත්කාලීන මත කාර්යයන් ඇමතිය හැකිය, යමක් පරීක්ෂා කරන්න - ගැටුම් නිරාකරණය කරන්න.

ඔබට ස්ක්‍රිප්ට් යෙදුම් සෘජුවම දත්ත සමුදා සේවාදායකය තුළම ලිවිය හැකි අතර කිසිම දෙයකින් සීමා නොවිය හැක, ඕනෑම මොඩියුලයක් සම්බන්ධ කර ඕනෑම තර්කයක් ක්‍රියාත්මක කරන්න.

යෙදුම් සේවාදායකයට බාහිර සේවාදායකයන්ට ප්‍රවේශ විය හැකි අතර, දත්ත රැස්කර එහි දත්ත ගබඩාවට එක් කළ හැක. මෙම දත්ත සමුදායේ දත්ත වෙනත් යෙදුම් විසින් භාවිතා කරනු ඇත.

මෙය Tarantula විසින්ම සිදු කරනු ලබන අතර, වෙනම අයදුම්පතක් ලිවීමට අවශ්ය නොවේ.

අවසාන වශයෙන්

මෙය විශාල කාර්යයක පළමු කොටස පමණි. දෙවන එක Mail.ru සමූහ බ්ලොග් අඩවියේ ඉතා ඉක්මනින් ප්‍රකාශයට පත් කරනු ලබන අතර, අපි අනිවාර්යයෙන්ම මෙම ද්‍රව්‍යයේ එයට සබැඳියක් එක් කරන්නෙමු.

අප මෙම දේවල් මාර්ගගතව නිර්මාණය කරන සිදුවීම් වලට සහභාගී වීමට සහ තථ්‍ය කාලීනව ප්‍රශ්න ඇසීමට ඔබ කැමති නම්, සම්බන්ධ වන්න REBRAIN නාලිකාව මගින් DevOps.

ඔබට වලාකුළ වෙත යාමට අවශ්‍ය නම් හෝ ඔබේ යටිතල පහසුකම් පිළිබඳ ප්‍රශ්න තිබේ නම්, ඉල්ලීමක් ඉදිරිපත් කිරීමට නිදහස් වන්න.

PS අපට මසකට නොමිලේ විගණන 2ක් ඇත, සමහරවිට ඔබේ ව්‍යාපෘතිය ඒවායින් එකක් වනු ඇත.

මූලාශ්රය: www.habr.com

අදහස් එක් කරන්න