នៅក្នុង Tarantool អ្នកអាចរួមបញ្ចូលគ្នានូវមូលដ្ឋានទិន្នន័យដែលមានល្បឿនលឿន និងកម្មវិធីដើម្បីធ្វើការជាមួយពួកគេ។ នេះជារបៀបដែលវាងាយស្រួលធ្វើ

ប្រាំឆ្នាំមុនខ្ញុំបានព្យាយាមធ្វើការជាមួយ Tarantool ប៉ុន្តែបន្ទាប់មកវាមិនដំណើរការសម្រាប់ខ្ញុំទេ។ ប៉ុន្តែថ្មីៗនេះខ្ញុំបានធ្វើសិក្ខាសាលាលើបណ្តាញមួយដែលខ្ញុំបាននិយាយអំពី Hadoop អំពីរបៀបដែល MapReduce ដំណើរការ។ នៅទីនោះខ្ញុំត្រូវបានគេសួរសំណួរ - "ហេតុអ្វីមិនប្រើ Tarantool សម្រាប់កិច្ចការនេះ?" ។

សម្រាប់ជាប្រយោជន៍នៃការចង់ដឹងចង់ឃើញ ខ្ញុំបានសម្រេចចិត្តត្រឡប់ទៅវាវិញ សាកល្បងកំណែចុងក្រោយបំផុត - ហើយលើកនេះខ្ញុំពិតជាចូលចិត្តគម្រោងនេះ។ ឥឡូវនេះខ្ញុំនឹងបង្ហាញពីរបៀបសរសេរកម្មវិធីសាមញ្ញមួយនៅក្នុង Tarantool ផ្ទុកវា ហើយពិនិត្យមើលការអនុវត្ត ហើយអ្នកនឹងឃើញពីរបៀបដែលងាយស្រួល និងត្រជាក់គ្រប់យ៉ាងនៅទីនោះ។

តើអ្វីទៅជា Tarantool

Tarantool កំណត់ទីតាំងខ្លួនវាជាមូលដ្ឋានទិន្នន័យលឿនបំផុត។ អ្នកអាចដាក់ទិន្នន័យណាមួយដែលអ្នកចង់បាននៅទីនោះ។ លើសពីនេះ ចម្លងពួកវាឡើងវិញ shard - នោះគឺបំបែកបរិមាណដ៏ធំនៃទិន្នន័យឆ្លងកាត់ម៉ាស៊ីនមេជាច្រើន ហើយបញ្ចូលគ្នានូវលទ្ធផលពីពួកគេ - បង្កើតតំណភ្ជាប់មេដែលអត់ឱនដល់កំហុស។

ទីពីរវាគឺជាម៉ាស៊ីនមេកម្មវិធី។ អ្នកអាចសរសេរកម្មវិធីរបស់អ្នកនៅលើវា ធ្វើការជាមួយទិន្នន័យ ឧទាហរណ៍ លុបធាតុចាស់នៅក្នុងផ្ទៃខាងក្រោយដោយយោងទៅតាមច្បាប់ជាក់លាក់។ អ្នកអាចសរសេរម៉ាស៊ីនមេ Http ដោយផ្ទាល់នៅក្នុង Tarantula ដែលនឹងធ្វើការជាមួយទិន្នន័យ៖ ផ្តល់លេខរបស់ពួកគេ សរសេរទិន្នន័យថ្មីនៅទីនោះ ហើយកាត់បន្ថយវាទាំងអស់ទៅជាមេ។

ខ្ញុំបានអានអត្ថបទមួយអំពីរបៀបដែលបុរសបង្កើតជួរសារចំនួន 300 ជួរ ដែលគ្រាន់តែស្រក់ទឹកភ្នែក ហើយពួកគេមានដំណើរការអប្បបរមា 20 សារក្នុងមួយវិនាទី។ នៅទីនេះអ្នកពិតជាអាចបង្វែរ និងសរសេរកម្មវិធីធំខ្លាំងណាស់ ហើយកម្មវិធីទាំងនេះនឹងមិនត្រូវបានរក្សាទុកដូចនៅក្នុង PostgreS ទេ។

ប្រហែលជាម៉ាស៊ីនមេបែបនេះ មានតែសាមញ្ញទេ ខ្ញុំនឹងព្យាយាមរៀបរាប់ក្នុងអត្ថបទនេះ។

ការកំណត់

សម្រាប់ការធ្វើតេស្តនេះ ខ្ញុំបានចាប់ផ្តើមម៉ាស៊ីននិម្មិតស្ដង់ដារចំនួនបី - ថាសរឹង 20 ជីហ្គាបៃ អ៊ូប៊ុនទូ 18.04 ។ ស៊ីភីយូនិម្មិត 2 និងអង្គចងចាំ 4 ជីហ្គាបៃ។

យើងដំឡើង Tarantool - ដំណើរការស្គ្រីប bash ឬបន្ថែមឃ្លាំងហើយធ្វើ apt ដំឡើង Tarantool ។ ភ្ជាប់ទៅស្គ្រីប - (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash)។ យើងមានពាក្យបញ្ជាដូចជា៖

tarantoolctl គឺ​ជា​ពាក្យ​បញ្ជា​ចម្បង​សម្រាប់​ការ​គ្រប់​គ្រង​ករណី Tarantula ។
/etc/tarantool - នេះគឺជាការកំណត់រចនាសម្ព័ន្ធទាំងមូល។
var/log/tarantool - នេះគឺជាកំណត់ហេតុ។
var/lib/tarantool - នៅទីនេះកុហកទិន្នន័យ ហើយបន្ទាប់មកពួកវាត្រូវបានបែងចែកទៅជាឧទាហរណ៍។

មាន instance-available and instance-enable folders - វាផ្ទុកនូវអ្វីដែលនឹងត្រូវបានដាក់ឱ្យដំណើរការ - ឯកសារកំណត់រចនាសម្ព័ន្ធ instance ជាមួយ lua code ដែលពណ៌នាអំពី ports ដែលវាស្តាប់ ថាតើ memory ណាមានសម្រាប់វា ការកំណត់ម៉ាស៊ីន Vinyl កូដដែលដំណើរការនៅពេលចាប់ផ្តើម servers, sharding, ជួរ, លុបទិន្នន័យដែលលែងប្រើ ហើយដូច្នេះនៅលើ។

ឧទាហរណ៍ដំណើរការដូចនៅក្នុង PostgreS ។ ឧទាហរណ៍ អ្នកចង់ដំណើរការច្បាប់ចម្លងជាច្រើននៃមូលដ្ឋានទិន្នន័យដែលព្យួរនៅលើច្រកផ្សេងៗគ្នា។ វាប្រែថាឧទាហរណ៍មូលដ្ឋានទិន្នន័យជាច្រើនត្រូវបានបើកដំណើរការនៅលើម៉ាស៊ីនមេតែមួយ ដែលព្យួរនៅលើច្រកផ្សេងៗគ្នា។ ពួកគេអាចមានការកំណត់ខុសគ្នាទាំងស្រុង - ឧទាហរណ៍មួយអនុវត្តតក្កវិជ្ជាមួយ ទីពីរ - មួយផ្សេងទៀត។

ការគ្រប់គ្រងវត្ថុ

យើងមានពាក្យបញ្ជា tarantoolctl ដែលអនុញ្ញាតឱ្យយើងគ្រប់គ្រងករណី Tarantula ។ ឧទាហរណ៍ tarantoolctl check example នឹងពិនិត្យឯកសារកំណត់រចនាសម្ព័ន្ធ ហើយនិយាយថាឯកសារមិនអីទេ ប្រសិនបើមិនមានកំហុសវាក្យសម្ព័ន្ធ។

អ្នកអាចឃើញស្ថានភាពនៃវត្ថុ - ឧទាហរណ៍ស្ថានភាព tarantoolctl ។ នៅក្នុងវិធីដូចគ្នានេះដែរអ្នកអាចចាប់ផ្តើម, បញ្ឈប់, ចាប់ផ្តើមឡើងវិញ។

នៅពេលដែល instance កំពុងដំណើរការ មានវិធីពីរយ៉ាងដើម្បីភ្ជាប់ទៅវា។

1. កុងសូលរដ្ឋបាល

តាមលំនាំដើម Tarantool បើករន្ធមួយ ហើយផ្ញើអត្ថបទ ASCII ធម្មតា ដើម្បីគ្រប់គ្រង Tarantula ។ ការភ្ជាប់ទៅកុងសូលតែងតែកើតឡើងនៅក្រោមអ្នកប្រើប្រាស់អ្នកគ្រប់គ្រង មិនមានការផ្ទៀងផ្ទាត់ទេ ដូច្នេះអ្នកមិនចាំបាច់ដកច្រកកុងសូលដើម្បីគ្រប់គ្រង Tarantula នៅខាងក្រៅនោះទេ។

ដើម្បីភ្ជាប់តាមវិធីនេះ អ្នកត្រូវបញ្ចូល Tarantoolctl បញ្ចូលឈ្មោះឧទាហរណ៍។ ពាក្យបញ្ជានឹងចាប់ផ្តើមកុងសូល ហើយភ្ជាប់ជាអ្នកប្រើប្រាស់អ្នកគ្រប់គ្រង។ កុំបញ្ចេញច្រកកុងសូលទៅខាងក្រៅ - វាជាការប្រសើរក្នុងការទុកវាជារន្ធឯកតា។ បន្ទាប់មកមានតែអ្នកដែលមានសិទ្ធិសរសេរទៅកាន់រន្ធនឹងអាចភ្ជាប់ទៅ Tarantula បាន។

វិធីសាស្រ្តនេះគឺចាំបាច់សម្រាប់កិច្ចការរដ្ឋបាល។ ដើម្បីធ្វើការជាមួយទិន្នន័យ សូមប្រើវិធីទីពីរ - ពិធីការប្រព័ន្ធគោលពីរ។

2. ការប្រើប្រាស់ពិធីការប្រព័ន្ធគោលពីរដើម្បីភ្ជាប់ទៅកាន់ច្រកជាក់លាក់មួយ។

មានការណែនាំស្តាប់នៅក្នុងការកំណត់ដែលបើកច្រកសម្រាប់ទំនាក់ទំនងខាងក្រៅ។ ច្រកនេះត្រូវបានប្រើជាមួយពិធីការប្រព័ន្ធគោលពីរ ហើយការផ្ទៀងផ្ទាត់ត្រូវបានបើកនៅទីនោះ។

សម្រាប់ការតភ្ជាប់នេះ tarantoolctl តភ្ជាប់ទៅលេខច្រកត្រូវបានប្រើ។ ដោយប្រើវា អ្នកអាចភ្ជាប់ទៅម៉ាស៊ីនមេពីចម្ងាយ ប្រើការផ្ទៀងផ្ទាត់ និងផ្តល់សិទ្ធិចូលប្រើប្រាស់ផ្សេងៗ។

ការកត់ត្រាទិន្នន័យ និងម៉ូឌុលប្រអប់

ដោយសារ Tarantool គឺជាមូលដ្ឋានទិន្នន័យ និងជាម៉ាស៊ីនបម្រើកម្មវិធី វាមានម៉ូឌុលផ្សេងៗ។ យើងចាប់អារម្មណ៍លើម៉ូឌុលប្រអប់ - វាអនុវត្តធ្វើការជាមួយទិន្នន័យ។ នៅពេលអ្នកសរសេរអ្វីមួយទៅប្រអប់មួយ Tarantool សរសេរទិន្នន័យទៅក្នុងថាស រក្សាទុកវាក្នុងអង្គចងចាំ ឬធ្វើអ្វីផ្សេងទៀតជាមួយវា។

ការកត់ត្រា

ឧទាហរណ៍ យើងចូលទៅក្នុងប្រអប់ម៉ូឌុល ហើយហៅមុខងារ 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

បន្ទាប់ពីនោះយើងបង្កើតលិបិក្រមបឋម - បឋម - ដោយយើងអាចស្វែងរកទិន្នន័យ។ តាមលំនាំដើម ប្រសិនបើគ្មានប៉ារ៉ាម៉ែត្រត្រូវបានបញ្ជាក់ទេ វាលទីមួយក្នុងធាតុនីមួយៗសម្រាប់សន្ទស្សន៍បឋមនឹងត្រូវបានប្រើ។

បន្ទាប់​មក​យើង​ធ្វើ​ការ​ផ្តល់​ជំនួយ​ដល់​អ្នក​ប្រើ​ជា​ភ្ញៀវ ដែល​យើង​ភ្ជាប់​តាម​រយៈ​ពិធីការ​គោលពីរ។ យើងអនុញ្ញាតឱ្យអាន សរសេរ និងប្រតិបត្តិក្នុងឧទាហរណ៍ទាំងមូល។

បើប្រៀបធៀបទៅនឹងមូលដ្ឋានទិន្នន័យធម្មតា អ្វីគ្រប់យ៉ាងគឺសាមញ្ញណាស់នៅទីនេះ។ យើងមានកន្លែងទំនេរ - ជាតំបន់ដែលទិន្នន័យរបស់យើងត្រូវបានរក្សាទុកយ៉ាងសាមញ្ញ។ ធាតុនីមួយៗត្រូវបានគេហៅថា tuple ។ វាត្រូវបានខ្ចប់នៅក្នុង MessagePack ។ នេះគឺជាទម្រង់ដ៏ត្រជាក់បំផុត - វាជាប្រព័ន្ធគោលពីរ ហើយប្រើទំហំតិចជាងមុន - 18 បៃធៀបនឹង 27 ។

វាងាយស្រួលណាស់ក្នុងការធ្វើការជាមួយគាត់។ ស្ទើរតែគ្រប់បន្ទាត់ រាល់ការបញ្ចូលទិន្នន័យអាចមានជួរឈរខុសគ្នាទាំងស្រុង។

យើងអាចមើលចន្លោះទាំងអស់ដោយប្រើពាក្យបញ្ជា Box.space ។ ដើម្បីជ្រើសរើសឧទាហរណ៍ជាក់លាក់មួយ យើងសរសេរឧទាហរណ៍ box.space ហើយទទួលបានព័ត៌មានពេញលេញនៅលើវា។

មានម៉ាស៊ីនពីរប្រភេទដែលត្រូវបានបង្កើតឡើងនៅក្នុង Tarantool: Memory និង Vinyl ។ អង្គចងចាំផ្ទុកទិន្នន័យទាំងអស់នៅក្នុងអង្គចងចាំ។ ដូច្នេះអ្វីៗដំណើរការយ៉ាងសាមញ្ញ និងរហ័ស។ ទិន្នន័យ​ត្រូវ​បាន​បោះចោល​ទៅ​ក្នុង​ថាស ហើយ​វា​ក៏​មាន​យន្តការ​សរសេរ​ទុក​មុន​ផង​ដែរ ដូច្នេះ​យើង​នឹង​មិន​បាត់បង់​អ្វី​ទេ​ប្រសិន​បើ​ម៉ាស៊ីន​មេ​គាំង។

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>

សន្ទស្សន៍៖

លិបិក្រមចម្បងត្រូវតែបង្កើតសម្រាប់ចន្លោះណាមួយ ពីព្រោះគ្មានអ្វីនឹងដំណើរការដោយគ្មានវាទេ។ ដូចនៅក្នុងមូលដ្ឋានទិន្នន័យណាមួយ យើងបង្កើតវាលដំបូង - លេខសម្គាល់កំណត់ត្រា។

ផ្នែក៖

នេះគឺជាកន្លែងដែលយើងបញ្ជាក់ពីអ្វីដែលសន្ទស្សន៍របស់យើងមាន។ វាមានផ្នែកមួយ - វាលដំបូងដែលយើងនឹងប្រើ វាយ unsigned - ចំនួនគត់វិជ្ជមាន។ តាមខ្ញុំចាំពីឯកសារ លេខអតិបរមាដែលអាចមានគឺ 18 quintillion។ អស្ចារ្យណាស់។

បន្ទាប់មកយើងអាចបញ្ចូលទិន្នន័យដោយប្រើពាក្យបញ្ជាបញ្ចូល។

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 ដែលខ្ញុំបានពិពណ៌នាខាងលើ។

ទិន្នផលទិន្នន័យ

បន្ទាប់មកយើងអាចបង្ហាញទិន្នន័យដោយប្រើពាក្យបញ្ជាជ្រើសរើស។

Box.example.select ដោយ​ចុច {1} នឹង​បង្ហាញ​ធាតុ​ដែល​ចង់​បាន។ ប្រសិនបើយើងលុបសោនោះ យើងនឹងឃើញកំណត់ត្រាទាំងអស់ដែលយើងមាន។ ពួកវាទាំងអស់មានភាពខុសប្លែកគ្នានៅក្នុងចំនួនជួរឈរ ប៉ុន្តែនៅទីនេះជាគោលការណ៍មិនមានគំនិតនៃជួរឈរទេ - មានលេខវាល។

អាចមានទិន្នន័យច្រើនតាមដែលអ្នកចង់បាន។ ហើយឧទាហរណ៍យើងត្រូវស្វែងរកពួកវានៅក្នុងវាលទីពីរ។ ដើម្បីធ្វើដូចនេះយើងបង្កើតសន្ទស្សន៍បន្ទាប់បន្សំថ្មី។

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']
...

កំពុងរក្សាទុក

ប្រសិនបើយើងចាប់ផ្តើម instance ឡើងវិញ ហើយព្យាយាមហៅទិន្នន័យម្តងទៀត យើងនឹងឃើញថាពួកគេមិននៅទីនោះទេ - អ្វីគ្រប់យ៉ាងគឺទទេ។ វាកើតឡើងដោយសារតែ Tarantool បង្កើតប៉ុស្តិ៍ត្រួតពិនិត្យ និងរក្សាទុកទិន្នន័យទៅក្នុងថាស ប៉ុន្តែប្រសិនបើយើងឈប់ដំណើរការមុនពេលការរក្សាទុកបន្ទាប់ យើងនឹងបាត់បង់ប្រតិបត្តិការទាំងអស់ ដោយសារយើងនឹងងើបឡើងវិញពីចំណុចត្រួតពិនិត្យចុងក្រោយ ដែលជាឧទាហរណ៍កាលពីពីរម៉ោងមុន។

ការសន្សំរាល់វិនាទីក៏នឹងមិនដំណើរការដែរ - ដោយសារតែការបោះចោល 20 GB ទៅក្នុងឌីសឥតឈប់ឈរគឺជាគំនិតដូច្នេះ។

ចំពោះបញ្ហានេះ គំនិតនៃកំណត់ហេតុសរសេរមុនត្រូវបានបង្កើត និងអនុវត្ត។ ដោយមានជំនួយរបស់វា សម្រាប់ការផ្លាស់ប្តូរនីមួយៗនៅក្នុងទិន្នន័យ កំណត់ត្រាមួយត្រូវបានបង្កើតនៅក្នុងឯកសារកំណត់ហេតុតូចមួយដែលសរសេរជាមុន។

ធាតុនីមួយៗរហូតដល់ប៉ុស្តិ៍ត្រួតពិនិត្យត្រូវបានរក្សាទុកនៅក្នុងពួកគេ។ សម្រាប់ឯកសារទាំងនេះយើងកំណត់ទំហំ - ឧទាហរណ៍ 64 mb ។ នៅពេលដែលវាបំពេញឡើង ការថតនឹងចាប់ផ្តើមទៅកាន់ឯកសារទីពីរ។ ហើយបន្ទាប់ពីការចាប់ផ្តើមឡើងវិញ Tarantool ងើបឡើងវិញពីចំណុចត្រួតពិនិត្យចុងក្រោយហើយបន្ទាប់មករំកិលលើប្រតិបត្តិការក្រោយៗទៀតរហូតដល់វាឈប់។

ដើម្បីអនុវត្តការថតបែបនេះ អ្នកត្រូវបញ្ជាក់ជម្រើសមួយនៅក្នុងការកំណត់ box.cfg (ក្នុងឯកសារ example.lua)៖

wal_mode = “write”;

ការប្រើប្រាស់ទិន្នន័យ

ជាមួយនឹងអ្វីដែលយើងបានសរសេរនៅពេលនេះ អ្នកអាចប្រើ Tarantula ដើម្បីរក្សាទុកទិន្នន័យ ហើយវានឹងដំណើរការលឿនជាឃ្លាំងទិន្នន័យ។ ហើយឥឡូវនេះ cherry នៅលើនំ - តើអ្នកអាចធ្វើអ្វីបានជាមួយវាទាំងអស់។

ការសរសេរកម្មវិធី

ជាឧទាហរណ៍ ចូរយើងសរសេរកម្មវិធីបែបនេះសម្រាប់ Tarantula

សូមមើលកម្មវិធីនៅក្រោម spoiler

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

បន្ទាប់មកយើងភ្ជាប់រ៉ោតទ័រ http និងម៉ាស៊ីនមេ http ទៅម៉ាស៊ីនមេ Tarantula របស់យើង JSON ដែលយើងនឹងផ្តល់ឱ្យទៅអតិថិជន។

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

បន្ទាប់ពីនោះ យើងចាប់ផ្តើមនៅលើច្រក 8080 នៅលើចំណុចប្រទាក់ម៉ាស៊ីនមេ http ទាំងអស់ ដែលនឹងកត់ត្រារាល់សំណើ និងកំហុសទាំងអស់។

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

បន្ទាប់យើងប្រកាសផ្លូវថាប្រសិនបើសំណើជាមួយវិធីសាស្ត្រ GET មកដល់ច្រក 8080 / រាប់បន្ទាប់មកយើងហៅមុខងារពីបន្ទាត់មួយ។ វាត្រឡប់ស្ថានភាព - 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 តួអក្សរ។
នៅក្នុងជួរ local last = box.space.example:len() យើងដកធាតុចុងក្រោយចេញ។
ហើយនៅក្នុងបន្ទាត់ box.space.example:insert{ last +1, token } យើងសរសេរទិន្នន័យទៅក្នុងមូលដ្ឋានទិន្នន័យរបស់យើង ពោលគឺយើងគ្រាន់តែបង្កើនលេខសម្គាល់ដោយ 1 ។ នេះអាចត្រូវបានធ្វើដោយវិធីនេះ មិនត្រឹមតែតាមរបៀបដែលច្របូកច្របល់នោះទេ។ Tarantula មានលំដាប់សម្រាប់ករណីនេះ។

យើងសរសេរនិមិត្តសញ្ញានៅទីនោះ។

ដូច្នេះ យើង​បាន​សរសេរ​កម្មវិធី​ក្នុង​ឯកសារ​មួយ។ អ្នកអាចចូលប្រើទិន្នន័យបានភ្លាមៗ ហើយម៉ូឌុលប្រអប់នឹងធ្វើការងារកខ្វក់ទាំងអស់សម្រាប់អ្នក។

វាស្តាប់ http និងធ្វើការជាមួយទិន្នន័យ អ្វីគ្រប់យ៉ាងគឺនៅក្នុងឧទាហរណ៍តែមួយ - ទាំងកម្មវិធី និងទិន្នន័យ។ ដូច្នេះហើយ អ្វីៗកើតឡើងយ៉ាងលឿន។

ដើម្បីដំណើរការ យើងដំឡើងម៉ូឌុល http៖

របៀបដែលយើងធ្វើវាសូមមើលនៅក្រោម spoiler

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 ។
/token ចេញ token ហើយសរសេរ token នេះទៅកាន់ database។

ល្បឿនសាកល្បង

ចូរដំណើរការស្តង់ដារសម្រាប់សំណើ 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 ដំណើរការមុខងារផ្ទៃខាងក្រោយដែលដំណើរការទិន្នន័យរបស់អ្នក។ លើសពីនេះ មានការកេះផ្សេងៗ។ ឧទាហរណ៍អ្នកអាចហៅមុខងារនៅលើការអាប់ដេតពិនិត្យមើលអ្វីមួយ - ជួសជុលការប៉ះទង្គិច។

អ្នកអាចសរសេរកម្មវិធីស្គ្រីបដោយផ្ទាល់នៅក្នុងម៉ាស៊ីនមេមូលដ្ឋានទិន្នន័យដោយខ្លួនឯង និងមិនត្រូវបានកំណត់ដោយអ្វីទាំងអស់ ភ្ជាប់ម៉ូឌុលណាមួយ និងអនុវត្តតក្កវិជ្ជាណាមួយ។

ម៉ាស៊ីនមេកម្មវិធីអាចចូលប្រើម៉ាស៊ីនមេខាងក្រៅ ប្រមូលទិន្នន័យ និងបន្ថែមវាទៅក្នុងមូលដ្ឋានទិន្នន័យរបស់វា។ ទិន្នន័យពីមូលដ្ឋានទិន្នន័យនេះនឹងត្រូវបានប្រើប្រាស់ដោយកម្មវិធីផ្សេងទៀត។

នេះនឹងត្រូវបានធ្វើឡើងដោយ Tarantula ខ្លួនឯងហើយមិនចាំបាច់សរសេរកម្មវិធីដាច់ដោយឡែកទេ។

នៅក្នុងសេចក្តីសន្និដ្ឋាន

នេះគ្រាន់តែជាផ្នែកដំបូងនៃការងារធំប៉ុណ្ណោះ។ អត្ថបទទីពីរនឹងត្រូវបានបោះពុម្ពឆាប់ៗនេះនៅលើប្លុក Mail.ru Group ហើយយើងនឹងបន្ថែមតំណភ្ជាប់ទៅវានៅក្នុងអត្ថបទនេះ។

ប្រសិនបើអ្នកចាប់អារម្មណ៍ក្នុងការចូលរួមក្នុងព្រឹត្តិការណ៍ដែលយើងបង្កើតរឿងទាំងនេះតាមអ៊ីនធឺណិត និងសួរសំណួរក្នុងពេលជាក់ស្តែង សូមភ្ជាប់ទៅ DevOps ដោយឆានែល REBRAIN.

ប្រសិនបើអ្នកត្រូវការផ្លាស់ទីទៅពពក ឬមានសំណួរអំពីហេដ្ឋារចនាសម្ព័ន្ធរបស់អ្នក មានអារម្មណ៍សេរីក្នុងការដាក់សំណើ.

PS យើងមានសវនកម្មឥតគិតថ្លៃចំនួន 2 ក្នុងមួយខែ ប្រហែលជាគម្រោងរបស់អ្នកនឹងក្លាយជាមួយក្នុងចំណោមពួកគេ។

ប្រភព: www.habr.com