Tarantool საშუალებას გაძლევთ დააკავშიროთ სუპერ სწრაფი მონაცემთა ბაზა და აპლიკაცია მათთან მუშაობისთვის. აი რა ადვილი გასაკეთებელია

ხუთი წლის წინ ვცადე მუშაობა Tarantool-თან, მაგრამ შემდეგ ეს არ გამომივიდა. მაგრამ ახლახან გავმართე ვებინარი, სადაც ვისაუბრე Hadoop-ზე და როგორ მუშაობს MapReduce. იქ მათ დამისვეს კითხვა: "რატომ არ გამოიყენოთ Tarantool ამ ამოცანისთვის?"

ცნობისმოყვარეობის გამო გადავწყვიტე დავბრუნებულიყავი, გამოვცადე უახლესი ვერსია - და ამჯერად ძალიან მომეწონა პროექტი. ახლა მე გაჩვენებთ, თუ როგორ უნდა დაწეროთ მარტივი აპლიკაცია Tarantool-ში, ჩატვირთოთ და შეამოწმოთ მისი შესრულება და ნახავთ, რამდენად მარტივი და მაგარია ყველაფერი.

რა არის Tarantool

Tarantool პოზიციონირებს როგორც ულტრა სწრაფი მონაცემთა ბაზა. თქვენ შეგიძლიათ განათავსოთ ნებისმიერი მონაცემი, რომელიც გსურთ. გარდა ამისა, გაიმეორეთ ისინი, ფრაგმენტი - ანუ, გაყავით დიდი რაოდენობით მონაცემები რამდენიმე სერვერზე და გააერთიანეთ მათგან მიღებული შედეგები - შექმენით შეცდომის შემწყნარებლობა Master-Master კავშირები.

მეორეც, ეს არის აპლიკაციის სერვერი. შეგიძლიათ მასზე დაწეროთ თქვენი აპლიკაციები, იმუშაოთ მონაცემებთან, მაგალითად, წაშალოთ ძველი ჩანაწერები ფონზე გარკვეული წესების მიხედვით. თქვენ შეგიძლიათ დაწეროთ Http სერვერი პირდაპირ Tarantula-ში, რომელიც იმუშავებს მონაცემებთან: გამოაქვეყნეთ მათი რაოდენობა, ჩაწერეთ ახალი მონაცემები იქ და შეამცირეთ ეს ყველაფერი მასტერზე.

წავიკითხე სტატია იმის შესახებ, თუ როგორ შექმნეს ბიჭებმა შეტყობინებების რიგს 300 სტრიქონი, რომელიც უბრალოდ იფეთქებს და ჩქარობს - მათ აქვთ მინიმალური შესრულება 20 შეტყობინება წამში. აქ ნამდვილად შეგიძლიათ შემობრუნდეთ და დაწეროთ ძალიან დიდი აპლიკაცია, და ეს არ იქნება შენახვა, როგორც PostgreS-ში.

მე შევეცდები აღვწერო რაღაც ამ სერვერის მსგავსი, მხოლოდ მარტივი, ამ სტატიაში.

დაყენების

ტესტისთვის დავიწყე სამი სტანდარტული ვირტუალური მანქანა - 20 GB მყარი დისკი, Ubuntu 18.04. 2 ვირტუალური პროცესორი და 4 გიგა მეხსიერება.

ჩვენ დავაინსტალირეთ Tarantool - გაუშვით bash სკრიპტი ან დავამატეთ საცავი და გააკეთეთ Apt დააინსტალირეთ Tarantool. ბმული სკრიპტთან - (curl -L https://tarantool.io/installer.sh | VER=2.4 სუდო -E ბაშ). ჩვენ გვაქვს ბრძანებები, როგორიცაა:

tarantoolctl - ტარანტულას ინსტანციების მართვის მთავარი ბრძანება.
/etc/tarantool - აქ არის მთელი კონფიგურაცია.
var/log/tarantool - აი მორები.
var/lib/tarantool — მონაცემები აქ დევს და შემდეგ იყოფა ინსტანციებად.

არსებობს საქაღალდეები instance-available და instance-enable - შეიცავს ის, რაც გაშვებული იქნება - ინსტანციის კონფიგურაციის ფაილი lua კოდით, რომელიც აღწერს რომელ პორტებს უსმენს, რა მეხსიერება აქვს მისთვის ხელმისაწვდომი, ვინილის ძრავის პარამეტრები, კოდი, რომელიც მუშაობს გაშვებისას. სერვერები, დაშლა, რიგები, მოძველებული მონაცემების წაშლა და ა.შ.

ინსტანციები მუშაობს როგორც PostgreS-ში. მაგალითად, გსურთ გაუშვათ მონაცემთა ბაზის რამდენიმე ასლი, რომელიც დაკიდებულია სხვადასხვა პორტებზე. გამოდის, რომ ერთ სერვერზე გაშვებულია მონაცემთა რამდენიმე ინსტანცია, რომლებიც სხვადასხვა პორტზეა დაკიდებული. მათ შეიძლება ჰქონდეთ სრულიად განსხვავებული პარამეტრები - ერთი ინსტანცია ახორციელებს ერთ ლოგიკას, მეორე - მეორეს.

ინსტანციის მენეჯმენტი

ჩვენ გვაქვს tarantoolctl ბრძანება, რომელიც საშუალებას გაძლევთ მართოთ Tarantula ინსტანციები. მაგალითად, tarantoolctl შემოწმების მაგალითი შეამოწმებს კონფიგურაციის ფაილს და იტყვის - ფაილი წესრიგშია, თუ იქ სინტაქსური შეცდომები არ არის.

თქვენ შეგიძლიათ ნახოთ ინსტანციის სტატუსი - tarantoolctl სტატუსის მაგალითი. ანალოგიურად შეგიძლიათ გააკეთოთ დაწყება, გაჩერება, გადატვირთვა.

ინსტანციის გაშვების შემდეგ, შეგიძლიათ დაუკავშირდეთ მას ორი გზით.

1. ადმინისტრაციული კონსოლი

ნაგულისხმევად, Tarantool ხსნის სოკეტს, ნორმალური ASCII ტექსტი იგზავნება იქ Tarantool-ის გასაკონტროლებლად. კონსოლთან დაკავშირება ყოველთვის ხდება ადმინისტრატორის მომხმარებლის ქვეშ, არ არის ავთენტიფიკაცია, ამიტომ არ არის საჭირო კონსოლის პორტის ექსტერნალიზება Tarantula-ს სამართავად.

ამ მეთოდით დასაკავშირებლად, თქვენ უნდა შეიყვანოთ Tarantoolctl, შეიყვანეთ ინსტანციის სახელი. ბრძანება გაუშვებს კონსოლს და დაუკავშირდება როგორც ადმინისტრატორი. არასოდეს გამოაშკარავოთ კონსოლის პორტი გარედან - უმჯობესია დატოვოთ იგი როგორც ერთეულის სოკეტი. მაშინ მხოლოდ მათ, ვისაც აქვს წვდომა სოკეტზე ჩაწერაზე, შეძლებს ტარანტულასთან დაკავშირებას.

ეს მეთოდი საჭიროა ადმინისტრაციული საქმეებისთვის. მონაცემებთან მუშაობისთვის გამოიყენეთ მეორე მეთოდი - ბინარული პროტოკოლი.

2. ორობითი პროტოკოლის გამოყენება კონკრეტულ პორტთან დასაკავშირებლად

კონფიგურაცია შეიცავს მოსმენის დირექტივას, რომელიც ხსნის პორტს გარე კომუნიკაციებისთვის. ეს პორტი გამოიყენება ორობითი პროტოკოლით და იქ ჩართულია ავთენტიფიკაცია.

ამ კავშირისთვის გამოიყენება tarantoolctl connect to პორტის ნომერი. მისი გამოყენებით შეგიძლიათ დაუკავშირდეთ დისტანციურ სერვერებს, გამოიყენოთ ავტორიზაცია და მისცეთ სხვადასხვა წვდომის უფლება.

მონაცემთა ჩაწერის და ყუთის მოდული

ვინაიდან Tarantool არის მონაცემთა ბაზაც და აპლიკაციის სერვერიც, მას აქვს სხვადასხვა მოდული. ჩვენ გვაინტერესებს ყუთის მოდული - ის ახორციელებს მონაცემებთან მუშაობას. როდესაც რაღაცას წერთ ყუთში, Tarantool წერს მონაცემებს დისკზე, ინახავს მას მეხსიერებაში ან აკეთებს სხვა რამეს.

ჩანაწერების

მაგალითად, ჩვენ შევდივართ box მოდულში და მოვუწოდებთ box.one ფუნქციას. ეს აიძულებს 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-ის წინააღმდეგ.

მასთან მუშაობა საკმაოდ მოსახერხებელია. თითქმის ყველა ხაზს, ყველა მონაცემთა ჩანაწერს შეიძლება ჰქონდეს სრულიად განსხვავებული სვეტები.

ჩვენ შეგვიძლია ვნახოთ ყველა სივრცე Box.space ბრძანების გამოყენებით. კონკრეტული მაგალითის შესარჩევად ჩაწერეთ box.space მაგალითი და მიიღეთ სრული ინფორმაცია მის შესახებ.

Tarantool-ს აქვს ორი ჩაშენებული ძრავა: Memory და Vinyl. მეხსიერება ინახავს ყველა მონაცემს მეხსიერებაში. ამიტომ ყველაფერი მარტივად და სწრაფად მუშაობს. მონაცემები იყრება დისკზე და ასევე არის ჩაწერის წინა ჟურნალის მექანიზმი, ასე რომ, ჩვენ არაფერს დავკარგავთ, თუ სერვერი გაფუჭდა.

ვინილი ინახავს მონაცემებს დისკზე ჩვენთვის უფრო ნაცნობი ფორმით - ანუ თქვენ შეგიძლიათ შეინახოთ მეტი მონაცემი ვიდრე ჩვენ გვაქვს მეხსიერება და ტარანტულა წაიკითხავს მას დისკიდან.

ახლა ჩვენ გამოვიყენებთ მეხსიერებას.

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>

Index:

პირველადი ინდექსი უნდა შეიქმნას ნებისმიერი სივრცისთვის, რადგან მის გარეშე არაფერი იმუშავებს. როგორც ნებისმიერ მონაცემთა ბაზაში, ჩვენ ვქმნით პირველ ველს - ჩანაწერის ID.

ნაწილები:

აქ ჩვენ მივუთითებთ რისგან შედგება ჩვენი ინდექსი. იგი შედგება ერთი ნაწილისაგან - პირველი ველი, რომელსაც ჩვენ გამოვიყენებთ, არის ტიპის unsigned - დადებითი მთელი რიცხვი. რამდენადაც მე მახსოვს დოკუმენტაციიდან, მაქსიმალური რაოდენობა, რაც შეიძლება იყოს, არის 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 ბრძანების გამოყენებით.

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

შენახვა

თუ ჩვენ გადავტვირთავთ ინსტანციას და კვლავ ვცდილობთ მონაცემთა გამოძახებას, დავინახავთ, რომ ის იქ არ არის - ყველაფერი ცარიელია. ეს იმიტომ ხდება, რომ Tarantool აკეთებს საკონტროლო პუნქტებს და ინახავს მონაცემებს დისკზე, მაგრამ თუ მუშაობას შევწყვეტთ მომდევნო შენახვამდე, ჩვენ დავკარგავთ ყველა ოპერაციას - იმიტომ, რომ ჩვენ აღვადგენთ ბოლო გამშვებ პუნქტს, რომელიც იყო, მაგალითად, ორი საათის წინ.

ყოველი წამის დაზოგვაც არ იმუშავებს, რადგან 20 GB დისკზე მუდმივად გადაყრა არ არის კარგი იდეა.

ამ მიზნით გამოიგონეს და განხორციელდა ჩაწერის წინა ჟურნალის კონცეფცია. მისი დახმარებით, მონაცემების ყოველი ცვლილებისთვის, ჩანაწერი იქმნება მცირე ჩაწერის ჟურნალის ფაილში.

ყოველი ჩანაწერი საგუშაგომდე ინახება მათში. ამ ფაილებისთვის ჩვენ ვაყენებთ ზომას - მაგალითად, 64 მბ. როდესაც ის სავსეა, ჩაწერა იწყება მეორე ფაილზე გადასვლა. და გადატვირთვის შემდეგ, 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

შემდეგ ჩვენ ვუკავშირებთ 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 /count, მაშინ გამოვიძახებთ ფუნქციას ერთი ხაზიდან. ის აბრუნებს სტატუსს - 200, 404, 403 ან ნებისმიერ სხვას, რასაც ჩვენ ვაზუსტებთ.

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

სხეულში ვაბრუნებთ json.encode-ს, მასში მივუთითებთ count და getcount, რომელიც იწოდება და აჩვენებს ჩანაწერების რაოდენობას ჩვენს მონაცემთა ბაზაში.

მეორე მეთოდი

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)

სად რიგში როუტერი:route({method = 'GET', გზა = '/token'}, ფუნქცია() ჩვენ ვუწოდებთ ფუნქციას და ვქმნით ჟეტონს.

ხაზი ლოკალური ნიშანი = randomString(32) არის 32 სიმბოლოსგან შემდგარი შემთხვევითი სტრიქონი.
Ხაზში ადგილობრივი ბოლო = box.space.example:len() ჩვენ ამოვიღებთ ბოლო ელემენტს.
და ხაზში box.space.example:insert{ last + 1, token } ჩვენ ვწერთ მონაცემებს ჩვენს მონაცემთა ბაზაში, ანუ უბრალოდ გავზრდით ID-ს 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:/#

/count გვაძლევს სტატუსს 200.
/token გასცემს ჟეტონს და წერს ამ ჟეტონს მონაცემთა ბაზაში.

სიჩქარის ტესტირება

მოდით გავუშვათ საორიენტაციო მაჩვენებელი 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 Group-ის ბლოგზე და ამ მასალაში აუცილებლად დავამატებთ მის ბმულს.

თუ გაინტერესებთ დაესწროთ ღონისძიებებს, სადაც ჩვენ ვაშენებთ ამ ნივთებს ონლაინ და დაუსვით შეკითხვები რეალურ დროში, ჩაერთეთ არხი DevOps by REBRAIN.

თუ გჭირდებათ ღრუბელზე გადასვლა ან გაქვთ შეკითხვები თქვენი ინფრასტრუქტურის შესახებ, მოგერიდებათ დატოვოთ მოთხოვნა.

PS თვეში 2 უფასო აუდიტი გვაქვს, ალბათ თქვენი პროექტი იქნება ერთ-ერთი მათგანი.

წყარო: www.habr.com