Tarantool-ում դուք կարող եք միավորել գերարագ տվյալների բազան և հավելվածը՝ նրանց հետ աշխատելու համար: Ահա թե որքան հեշտ է դա անել

Հինգ տարի առաջ ես փորձեցի աշխատել Tarantool-ի հետ, բայց հետո դա ինձ մոտ չստացվեց: Բայց վերջերս ես անցկացրեցի վեբինար, որտեղ ես խոսեցի Hadoop-ի և այն մասին, թե ինչպես է աշխատում MapReduce-ը: Այնտեղ նրանք ինձ հարց տվեցին. «Ինչո՞ւ չօգտագործել Tarantool-ը այս առաջադրանքի համար»:

Հետաքրքրությունից դրդված որոշեցի վերադառնալ դրան, փորձարկել վերջին տարբերակը, և այս անգամ ինձ շատ դուր եկավ նախագիծը: Այժմ ես ձեզ ցույց կտամ, թե ինչպես գրել պարզ հավելված Tarantool-ում, բեռնել այն և ստուգել դրա կատարումը, և դուք կտեսնեք, թե որքան հեշտ և զով է ամեն ինչ:

Ինչ է Tarantool-ը

Tarantool-ը իրեն ներկայացնում է որպես գերարագ տվյալների բազա: Դուք կարող եք այնտեղ տեղադրել ցանկացած տվյալ, որը ցանկանում եք: Բացի այդ, կրկնօրինակեք դրանք, բեկոր, այսինքն՝ բաժանեք հսկայական քանակությամբ տվյալներ մի քանի սերվերների վրա և միավորեք դրանցից ստացված արդյունքները. ստեղծեք սխալ հանդուրժող վարպետ-վարպետ կապեր:

Երկրորդ, սա հավելվածի սերվեր է: Դուք կարող եք դրա վրա գրել ձեր հավելվածները, աշխատել տվյալների հետ, օրինակ՝ ջնջել հին գրառումները հետին պլանում՝ ըստ որոշակի կանոնների։ Դուք կարող եք ուղղակիորեն Tarantula-ում գրել Http սերվեր, որը կաշխատի տվյալների հետ. տրամադրեք դրանց քանակությունը, այնտեղ գրեք նոր տվյալներ և այդ ամենը կրճատեք որպես վարպետ:

Ես կարդացի մի հոդված այն մասին, թե ինչպես տղաները հաղորդագրությունների հերթ են կազմել 300 տողից, որը պարզապես պայթում է և շտապում. նրանց նվազագույն կատարումը կազմում է վայրկյանում 20 հաղորդագրություն: Այստեղ դուք իսկապես կարող եք շրջվել և գրել շատ մեծ հավելված, և դա պահեստավորում չի լինի, ինչպես PostgreS-ում:

Ես կփորձեմ նկարագրել այս սերվերի նման մի բան, միայն պարզ, այս հոդվածում:

Տեղակայում

Փորձարկման համար ես սկսեցի երեք ստանդարտ վիրտուալ մեքենաներ՝ 20 ԳԲ կոշտ սկավառակ, Ubuntu 18.04: 2 վիրտուալ պրոցեսոր և 4 գիգաբ հիշողություն:

Մենք տեղադրում ենք Tarantool - գործարկում ենք bash սկրիպտը կամ ավելացնում ենք պահոց և apt տեղադրում ենք Tarantool-ը: Հղում դեպի սցենար - (curl -L https://tarantool.io/installer.sh | VER=2.4 սուդո -Է բաշ): Մենք ունենք հրամաններ, ինչպիսիք են.

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 մուտքագրեք օրինակի անունը: Հրամանը կգործարկի վահանակը և կմիանա որպես ադմինիստրատոր: Երբեք մի բացեք կոնսոլի միացքը դեպի դրս. ավելի լավ է այն թողնել որպես միավորի վարդակից: Այդ դեպքում միայն նրանք, ովքեր մուտք ունեն վարդակից գրելու հնարավորություն, կկարողանան միանալ Tarantula-ին:

Այս մեթոդը անհրաժեշտ է վարչական գործերի համար։ Տվյալների հետ աշխատելու համար օգտագործեք երկրորդ մեթոդը՝ երկուական արձանագրությունը:

2. Օգտագործելով երկուական արձանագրություն՝ կոնկրետ պորտին միանալու համար

Կազմաձևը պարունակում է լսելու հրահանգ, որը բացում է պորտ արտաքին հաղորդակցության համար: Այս նավահանգիստն օգտագործվում է երկուական արձանագրության հետ, և նույնականացումը միացված է այնտեղ:

Այս կապի համար օգտագործվում է tarantoolctl connect to port number: Օգտագործելով այն, դուք կարող եք միանալ հեռավոր սերվերներին, օգտագործել նույնականացում և տալ տարբեր մուտքի իրավունքներ:

Տվյալների գրանցման և տուփի մոդուլ

Քանի որ Tarantool-ը և՛ տվյալների բազա է, և՛ հավելվածի սերվեր, այն ունի տարբեր մոդուլներ: Մեզ հետաքրքրում է տուփի մոդուլը՝ այն իրականացնում է տվյալների հետ աշխատելը: Երբ դուք ինչ-որ բան եք գրում տուփի մեջ, Tarantool-ը տվյալները գրում է սկավառակի վրա, պահում դրանք հիշողության մեջ կամ այլ բան է անում դրա հետ:

Գրառում

Օրինակ՝ մենք մտնում ենք box մոդուլ և կանչում 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-ի դիմաց:

Նրա հետ աշխատելը բավականին հարմար է։ Գրեթե յուրաքանչյուր տող, տվյալների յուրաքանչյուր գրառում կարող է ունենալ բոլորովին այլ սյունակներ:

Մենք կարող ենք դիտել բոլոր բացատները՝ օգտագործելով 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>

Ինդեքս:

Ցանկացած տարածքի համար պետք է ստեղծվի առաջնային ինդեքս, քանի որ առանց դրա ոչինչ չի ստացվի։ Ինչպես ցանկացած տվյալների բազայում, մենք ստեղծում ենք առաջին դաշտը՝ ռեկորդային ID:

Մասեր:

Այստեղ մենք նշում ենք, թե ինչից է բաղկացած մեր ցուցանիշը։ Այն բաղկացած է մեկ մասից՝ առաջին դաշտը, որը մենք կօգտագործենք, անստորագիր տիպի է՝ դրական ամբողջ թիվ։ Որքան հիշում եմ փաստաթղթերից, առավելագույն թիվը, որը կարող է լինել, 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 ձևաչափով, որը ես նկարագրեցի վերևում:

Տվյալների ելք

Այնուհետև մենք կարող ենք ցուցադրել տվյալները՝ օգտագործելով ընտրել հրամանը:

Box.example.select-ը {1} ստեղնով կցուցադրի ցանկալի գրառումը: Եթե ​​մենք իջեցնենք բանալին, մենք կտեսնենք բոլոր գրառումները, որոնք մենք ունենք: Նրանք բոլորը տարբերվում են սյունակների քանակով, բայց այստեղ, սկզբունքորեն, սյունակներ հասկացություն չկա՝ կան դաշտերի համարներ:

Բացարձակապես ցանկացած քանակությամբ տվյալներ կարող են լինել: Եվ օրինակ, մենք պետք է դրանք փնտրենք երկրորդ դաշտով։ Դա անելու համար մենք ստեղծում ենք նոր երկրորդական ինդեքս:

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

Մենք օգտագործում ենք Create_index հրամանը:
Եկեք այն անվանենք Երկրորդական:

Դրանից հետո դուք պետք է նշեք պարամետրերը: Ցուցանիշի տեսակը ԾԱՌ է: Այն կարող է եզակի չլինել, ուստի մուտքագրեք 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 ԳԲ անընդհատ սկավառակի վրա լցնելը լավ գաղափար չէ:

Այդ նպատակով հորինվել և իրագործվել է նախօրոք գրելու մատյան հասկացությունը: Նրա օգնությամբ տվյալների յուրաքանչյուր փոփոխության համար ստեղծվում է մուտքագրում նախօրոք գրանցված փոքր մատյան ֆայլում:

Դրանցում պահվում է յուրաքանչյուր մուտք մինչև անցակետ։ Այս ֆայլերի համար մենք սահմանել ենք չափը, օրինակ՝ 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)

Որտեղ գծում router:route({method = 'GET', path = '/token'}, function() մենք կանչում ենք ֆունկցիան և ստեղծում նշան:

Լարային տեղական նշան = 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 REBRAIN-ի կողմից.

Եթե ​​Ձեզ անհրաժեշտ է տեղափոխվել ամպ կամ ունեք հարցեր ձեր ենթակառուցվածքի վերաբերյալ, ազատ զգալ թողնել խնդրանք.

Հ.Գ Ամսական 2 անվճար աուդիտ ունենք, գուցե ձեր նախագիծը լինի դրանցից մեկը։

Source: www.habr.com