Ann an Tarantool, faodaidh tu stòr-dàta fìor-luath agus tagradh a chur còmhla gus obrachadh leotha. Seo cho furasta ‘s a tha e a dhèanamh

Còig bliadhna air ais dh'fheuch mi ri bhith ag obair le Tarantool, ach an uairsin cha do dh'obraich e dhomh. Ach o chionn ghoirid chùm mi webinar far an do bhruidhinn mi mu Hadoop agus mar a tha MapReduce ag obair. An sin chuir iad ceist orm: “Carson nach cleachd thu Tarantool airson a’ ghnìomh seo? ”

A-mach à feòrachas, chuir mi romham tilleadh thuige, deuchainn a dhèanamh air an dreach as ùire - agus an turas seo chòrd am pròiseact rium gu mòr. A-nis seallaidh mi dhut mar a sgrìobhas tu tagradh sìmplidh ann an Tarantool, luchdaich e agus thoir sùil air a choileanadh, agus chì thu cho furasta agus cho fionnar sa tha a h-uile dad.

Dè th 'ann an Tarantool?

Tha Tarantool ga shuidheachadh fhèin mar stòr-dàta ultra-luath. Faodaidh tu dàta sam bith a tha thu ag iarraidh a chuir an sin. A bharrachd air an sin, dèan ath-aithris orra, shard - is e sin, roinn tòrr dàta thairis air grunn luchd-frithealaidh agus cuir còmhla na toraidhean bhuapa - dèan ceanglaichean maighstir-mhaighstir a tha fo fhulangas lochdan.

San dàrna h-àite, is e frithealaiche tagraidh a tha seo. Faodaidh tu na tagraidhean agad a sgrìobhadh air, obrachadh le dàta, mar eisimpleir, cuir às do sheann chlàran air a’ chùl a rèir riaghailtean sònraichte. Faodaidh tu frithealaiche Http a sgrìobhadh gu dìreach ann an Tarantula a dh’ obraicheas le dàta: thoir seachad an àireamh aca, sgrìobh dàta ùr an sin agus lughdaich e uile chun mhaighstir.

Leugh mi artaigil mu mar a rinn na balaich ciudha teachdaireachd de 300 loidhne, a tha dìreach a ’spreadhadh agus a’ reubadh - tha coileanadh as ìsle aca de 20 teachdaireachd gach diog. An seo faodaidh tu tionndadh agus sgrìobhadh iarrtas glè mhòr, agus cha bhith e na stòradh, mar ann am PostgreS.

Feuchaidh mi ri cunntas a thoirt air rudeigin mar an t-seirbheisiche seo, dìreach sìmplidh, san artaigil seo.

suidheachadh

Airson an deuchainn, thòisich mi air trì innealan brìgheil àbhaisteach - draibhear cruaidh 20 GB, Ubuntu 18.04. 2 CPU brìgheil agus 4 gigs cuimhne.

Bidh sinn a’ stàladh Tarantool - ruith an sgriobt bash no cuir stòr ris agus bidh e iomchaidh faighinn a-steach Tarantool. Ceangal gu sgriobt - (curl -L https://tarantool.io/installer.sh | VER = 2.4 sudo -E bash). Tha òrdughan againn mar:

tarantoolctl - am prìomh àithne airson suidheachaidhean Tarantula a riaghladh.
/etc/tarantool - seo an rèiteachadh gu lèir.
var/log/tarantool - Seo na clàran.
var/lib/tarantool - tha an dàta na laighe an seo, agus an uairsin tha e air a roinn ann an suidheachaidhean.

Tha pasganan ann mar eisimpleir-ri fhaighinn agus eisimpleir-comas - tha na thèid a chuir air bhog - faidhle rèiteachaidh eisimpleir le còd lua, a tha ag innse dè na puirt air a bheil e ag èisteachd, dè an cuimhne a tha ri fhaighinn dha, roghainnean einnsean Vinyl, còd a ruitheas aig àm tòiseachaidh frithealaichean, sharding, ciudhaichean, cuir às do dhàta a tha air a dhol à bith, agus mar sin air adhart.

Bidh cùisean ag obair mar ann am PostgreS. Mar eisimpleir, tha thu airson grunn leth-bhreacan de stòr-dàta a ruith a tha crochte air diofar phuirt. Tha e coltach gu bheil grunn shuidheachaidhean stòr-dàta air an cur air bhog air aon fhrithealaiche, a tha crochte air diofar phuirt. Is dòcha gu bheil suidheachaidhean gu tur eadar-dhealaichte aca - bidh aon eisimpleir a’ cur an gnìomh aon loidsig, an dàrna fear - fear eile.

Stiùireadh cùise

Tha an àithne tarantoolctl againn, a leigeas leat suidheachaidhean Tarantula a riaghladh. Mar eisimpleir, bheir eisimpleir sgrùdaidh tarantoolctl sùil air an fhaidhle rèiteachaidh agus canaidh e - tha am faidhle ceart gu leòr mura h-eil mearachdan co-chòrdalachd ann.

Chì thu inbhe an eisimpleir - tarantoolctl status example . San aon dòigh as urrainn dhut tòiseachadh, stad, ath-thòiseachadh.

Aon uair ‘s gu bheil eisimpleir a’ ruith, faodaidh tu ceangal ris ann an dà dhòigh.

1. Console rianachd

Gu gnàthach, bidh Tarantool a’ fosgladh socaid, thèid teacsa àbhaisteach ASCII a chuir an sin gus smachd a chumail air Tarantool. Bidh ceangal ris a’ chonsail an-còmhnaidh a’ tachairt fon neach-cleachdaidh rianachd, chan eil dearbhadh sam bith ann, agus mar sin chan fheumar am port tòcan a chuir a-mach gus Tarantula a riaghladh.

Gus ceangal a dhèanamh leis an dòigh seo, feumaidh tu a dhol a-steach Tarantoolctl cuir a-steach ainm eisimpleir. Cuiridh an àithne air bhog an consol agus ceangail e mar an neach-cleachdaidh rianachd. Na cuir a-mach am port tòcan air an taobh a-muigh - tha e nas fheàrr fhàgail mar aonad socaid. An uairsin is e dìreach an fheadhainn aig a bheil cothrom sgrìobhadh chun t-socaid a bhios comasach air ceangal ri Tarantula.

Tha feum air an dòigh seo airson cùisean rianachd. Gus obrachadh le dàta, cleachd an dàrna dòigh - am protocol binary.

2. A 'cleachdadh protocol binary gus ceangal ri port sònraichte

Anns an rèiteachadh tha stiùireadh èisteachd, a tha a’ fosgladh port airson conaltradh taobh a-muigh. Tha am port seo air a chleachdadh leis a’ phròtacal dà-chànanach agus tha dearbhadh air a chomasachadh an sin.

Airson a’ cheangail seo, thathas a’ cleachdadh ceangal tarantoolctl ri àireamh port. Le bhith ga chleachdadh, faodaidh tu ceangal ri frithealaichean iomallach, dearbhadh a chleachdadh agus diofar chòraichean-slighe a thoirt seachad.

Clàradh Dàta agus Modal Bogsa

Leis gu bheil Tarantool an dà chuid na stòr-dàta agus na fhrithealaiche tagraidh, tha grunn mhodalan ann. Tha ùidh againn anns a 'mhodal bogsa - bidh e a' cur an gnìomh obrachadh le dàta. Nuair a sgrìobhas tu rudeigin gu bogsa, bidh Tarantool a’ sgrìobhadh an dàta gu diosc, ga stòradh mar chuimhne, no a’ dèanamh rudeigin eile leis.

Clàradh

Mar eisimpleir, thèid sinn a-steach don mhodal bogsa agus cuir fios gu gnìomh box.once. Bheir seo air Tarantool an còd againn a ruith nuair a thèid am frithealaiche a thòiseachadh. Bidh sinn a’ cruthachadh àite anns am bi an dàta againn air a stòradh.

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

Às deidh seo, cruthaichidh sinn clàr-amais bun-sgoile - bun-sgoile - leis an urrainn dhuinn dàta a lorg. Gu gnàthach, mura sònraich thu crìochan sam bith, thèid a’ chiad raon anns gach clàr a chleachdadh airson a’ phrìomh chlàr-amais.

An uairsin bidh sinn a’ toirt seachad tabhartas don neach-cleachdaidh aoigh, fon bheil sinn a’ ceangal tron ​​phròtacal binary. Bidh sinn a’ ceadachadh leughadh, sgrìobhadh agus cur an gnìomh thairis air an eisimpleir gu lèir.

An coimeas ri stòran-dàta àbhaisteach, tha a h-uile dad an seo gu math sìmplidh. Tha àite againn - àite anns a bheil an dàta againn dìreach air a stòradh. Canar tuple ris gach clàr. Tha e air a phacaigeadh ann am MessagePack. Is e cruth gu math fionnar a tha seo - tha e dà-chànanach agus a’ gabhail nas lugha de rùm - 18 bytes an aghaidh 27.

Tha e gu math goireasach a bhith ag obair còmhla ris. Faodaidh colbhan gu tur eadar-dhealaichte a bhith aig cha mhòr a h-uile loidhne, a h-uile clàr dàta.

Is urrainn dhuinn a h-uile àite fhaicinn a’ cleachdadh an àithne Box.space. Gus eisimpleir sònraichte a thaghadh, sgrìobh eisimpleir box.space agus faigh fiosrachadh iomlan mu dheidhinn.

Tha dà einnsean togte aig Tarantool: Memory agus Vinyl. Bidh cuimhne a’ stòradh a h-uile dàta mar chuimhne. Mar sin, bidh a h-uile dad ag obair gu sìmplidh agus gu sgiobalta. Tha an dàta air a dhumpadh gu diosc, agus tha inneal log sgrìobhaidh air adhart ann cuideachd, gus nach caill sinn dad ma thuiteas am frithealaiche.

Bidh Vinyl a’ stòradh dàta air diosc ann an cruth a tha nas eòlaiche dhuinn - is e sin, faodaidh tu barrachd dàta a stòradh na tha cuimhne againn, agus leughaidh Tarantula bhon diosc e.

Airson a-nis cleachdaidh sinn Cuimhne.

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>

Clàr-amais:

Feumar clàr-amais bun-sgoile a chruthachadh airson àite sam bith, oir às aonais cha obraich dad. Mar ann an stòr-dàta sam bith, bidh sinn a’ cruthachadh a’ chiad raon - ID clàraidh.

Pàirtean:

An seo tha sinn a’ sealltainn cò tha anns a’ chlàr-amais againn. Tha aon phàirt ann - is e a’ chiad raon a chleachdas sinn den t-seòrsa gun ainm-sgrìobhte - slòigh dheimhinneach. Cho fad ‘s as cuimhne leam bho na sgrìobhainnean, is e 18 quintillion an àireamh as motha as urrainn a bhith. Tha sin tòrr.

An uairsin is urrainn dhuinn dàta a chuir a-steach a’ cleachdadh an àithne cuir a-steach.

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>

Tha a’ chiad raon air a chleachdadh mar phrìomh iuchair, agus mar sin feumaidh e a bhith gun samhail. Chan eil sinn cuingealaichte leis an àireamh de cholbhan, agus mar sin is urrainn dhuinn na h-uimhir de dhàta a tha sinn ag iarraidh a chuir a-steach an sin. Tha iad air an sònrachadh ann an cruth MessagePack, a mhìnich mi gu h-àrd.

Toradh dàta

An uairsin is urrainn dhuinn an dàta a thaisbeanadh a’ cleachdadh an àithne taghte.

Nochdaidh Box.example.select leis an iuchair {1} an inntrigeadh a tha thu ag iarraidh. Ma lughdaicheas sinn an iuchair, chì sinn a h-uile clàr a th’ againn. Tha iad uile eadar-dhealaichte anns an àireamh de cholbhan, ach an seo, ann am prionnsabal, chan eil bun-bheachd colbhan - tha àireamhan achaidhean.

Faodaidh àireamh sam bith de dhàta a bhith ann. Agus mar eisimpleir, feumaidh sinn an dàrna raon a lorg. Gus seo a dhèanamh, cruthaichidh sinn clàr-amais àrd-sgoile ùr.

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

Cleachdaidh sinn an àithne Create_index.
Canaidh sinn Àrd-sgoil ris.

Às deidh seo feumaidh tu na paramadairean a shònrachadh. Is e an seòrsa clàr-amais TREE. Is dòcha nach eil e gun samhail, mar sin cuir a-steach Unique = meallta.

An uairsin bidh sinn a’ comharrachadh dè na pàirtean den chlàr-amais againn. Is e raon àireamh an raoin ris am bi sinn a’ ceangal an clàr-amais, agus a’ sònrachadh an seòrsa sreang. Agus mar sin chaidh a chruthachadh.

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>

A-nis seo mar as urrainn dhuinn a ghairm:

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

glèidheadh

Ma nì sinn ath-thòiseachadh air an eisimpleir agus feuch ris an dàta a ghairm a-rithist, chì sinn nach eil e ann - tha a h-uile dad falamh. Bidh seo a’ tachairt leis gu bheil Tarantool a’ dèanamh puingean-seic agus a’ sàbhaladh an dàta gu diosc, ach ma stadas sinn ag obair gus an ath shàbhaladh, caillidh sinn a h-uile gnìomhachd - oir gheibh sinn air ais bhon àite-seic mu dheireadh, a bha, mar eisimpleir, o chionn dà uair a thìde.

Chan obraich e gus a h-uile diog a shàbhaladh nas motha, oir chan e deagh bheachd a th’ ann a bhith a’ dumpadh 20 GB air diosc gu cunbhalach.

Airson an adhbhair seo, chaidh bun-bheachd log sgrìobhadh air adhart a chruthachadh agus a bhuileachadh. Le a chuideachadh, airson gach atharrachadh san dàta, thèid inntrig a chruthachadh ann am faidhle log beag sgrìobhadh air thoiseach.

Tha gach inntrigeadh suas chun àite-seic air a stòradh annta. Airson na faidhlichean sin shuidhich sinn am meud - mar eisimpleir, 64 MB. Nuair a bhios e làn, tòisichidh clàradh a’ dol chun dàrna faidhle. Agus às deidh an ath-thòiseachadh, tha Tarantool air ath-nuadhachadh bhon àite-seic mu dheireadh agus an uairsin a ’dol thairis air a h-uile gnothach nas fhaide air adhart gus an stad e.

Gus an leithid de chlàradh a dhèanamh, feumaidh tu an roghainn a shònrachadh anns na roghainnean box.cfg (anns an fhaidhle eisimpleir.lua):

wal_mode = “write”;

cleachdadh dàta

Leis na tha sinn air a sgrìobhadh a-nis, faodaidh tu Tarantula a chleachdadh airson dàta a stòradh agus obraichidh e gu math luath mar stòr-dàta. Agus a-nis is e an icing air a’ chèic an rud as urrainn dhut a dhèanamh leis uile.

A 'sgrìobhadh tagradh

Mar eisimpleir, sgrìobhamaid an tagradh a leanas airson Tarantula

Faic an tagradh fon 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()

Bidh sinn a 'foillseachadh clàr air choreigin ann an lua a tha a' mìneachadh nan caractaran. Tha feum air a’ phlàta seo gus sreang air thuaiream a ghineadh.

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

Às deidh sin, bidh sinn a’ cur an cèill an gnìomh - randomString agus a’ toirt luach an fhaid ann am bragan.

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

An uairsin bidh sinn a’ ceangal an router http agus am frithealaiche http ris an t-seirbheisiche Tarantula againn, JSON, a chuireas sinn chun neach-dèiligidh.

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

Às deidh seo, tòisichidh sinn air port 8080 air a h-uile eadar-aghaidh frithealaiche http, a logas a h-uile iarrtas agus mearachd.

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

An ath rud, bidh sinn ag ainmeachadh slighe, gus an tig iarrtas leis an dòigh GET gu port 8080 /count, an uairsin canaidh sinn an gnìomh bho aon loidhne. Bidh e a 'tilleadh an inbhe - 200, 404, 403 no gin eile a shònraicheas sinn.

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

Anns a’ bhodhaig bidh sinn a’ tilleadh json.encode, ann tha sinn a’ comharrachadh cunntais is faighinn, ris an canar agus a’ sealltainn an àireamh de chlàran san stòr-dàta againn.

An dàrna modh

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)

Far a bheil an loidhne router: route({method = 'GET', path = '/ token'}, gnìomh () canaidh sinn an gnìomh agus cruthaichidh sinn comharradh.

Loidhne tòcan ionadail = randomString(32) 'S e sreath air thuaiream de 32 caractaran.
Ann an loidhne ionadail mu dheireadh = box.space.example:len() bheir sinn a-mach an eileamaid mu dheireadh.
Agus anns an loidhne box.space.example: cuir a-steach { last + 1, token } bidh sinn a 'sgrìobhadh an dàta a-steach don stòr-dàta againn, is e sin, bidh sinn dìreach a' meudachadh an ID le 1. Faodar seo a dhèanamh, leis an t-slighe, chan ann a-mhàin san dòigh neo-shoilleir seo. Tha sreathan ann airson seo ann an Tarantula.

Bidh sinn a’ sgrìobhadh an tòcan an sin.

Mar sin, sgrìobh sinn an tagradh ann an aon fhaidhle. Faodaidh tu an dàta a làimhseachadh gu dìreach an sin, agus nì am modal bogsa an obair shalach gu lèir dhut.

Bidh e ag èisteachd ri http agus ag obair le dàta, tha a h-uile dad ann an aon suidheachadh - an dà chuid an tagradh agus an dàta. Mar sin, bidh a h-uile dad a ’tachairt gu math luath.

Gus tòiseachadh bidh sinn a’ stàladh modal http:

Mar a nì sinn seo, seall fon 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:/#

Feumaidh sinn cuideachd prometheus airson ruith:

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

Bidh sinn a 'cur air bhog agus gheibh sinn cothrom air na modalan

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

Bheir /count inbhe 200 dhuinn.
/token a’ toirt seachad comharra agus a’ sgrìobhadh an tòcan seo chun stòr-dàta.

A 'dèanamh deuchainn air an astar

Feuch an ruith sinn slat-tomhais airson 50 iarrtas. Bidh 000 iarrtas farpaiseach ann.

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

Tha comharran air an toirt seachad. Agus tha sinn an-còmhnaidh a’ clàradh dàta. Chaidh 99% de na h-iarrtasan a phròiseasadh ann an 42 milliseconds. Mar sin, tha timcheall air 3500 iarrtas againn gach diog air inneal beag le 2 cores agus 4 gigabytes de chuimhne.

Faodaidh tu cuideachd cuid de chomharran 50000 a thaghadh agus a luach fhaicinn.

Faodaidh tu chan e a-mhàin http a chleachdadh, ach cuideachd gnìomhan cùl-fhiosrachaidh a ruith a bhios a’ pròiseasadh an dàta agad. A bharrachd air an sin, tha diofar shlatan-tomhais ann. Mar eisimpleir, faodaidh tu gnìomhan a ghairm air ùrachaidhean, thoir sùil air rudeigin - còmhstri ceart.

Faodaidh tu tagraidhean sgriobt a sgrìobhadh gu dìreach ann am frithealaiche an stòr-dàta fhèin, agus gun a bhith cuibhrichte le rud sam bith, modalan sam bith a cheangal agus loidsig sam bith a chuir an gnìomh.

Gheibh frithealaiche an aplacaid cothrom air frithealaichean bhon taobh a-muigh, dàta fhaighinn air ais agus a chur ris an stòr-dàta aige. Thèid dàta bhon stòr-dàta seo a chleachdadh le tagraidhean eile.

Nì Tarantula seo e fhèin, agus cha bhith agad ri tagradh air leth a sgrìobhadh.

Ann an co-dhùnadh

Chan e seo ach a’ chiad phàirt de dh’ obair mhòr. Thèid an dàrna fear fhoillseachadh gu math luath air blog Mail.ru Group, agus gu cinnteach cuiridh sinn ceangal ris anns an stuth seo.

Ma tha ùidh agad a bhith an làthair aig tachartasan far am bi sinn a’ togail na rudan sin air-loidhne agus a’ faighneachd cheistean ann an àm fìor, èist a-steach sianal DevOps le REBRAIN.

Ma dh’ fheumas tu gluasad chun sgòth no ma tha ceistean agad mun bhun-structar agad, faodaidh tu iarrtas fhàgail.

PS Tha 2 sgrùdadh an-asgaidh againn gach mìos, is dòcha gum bi am pròiseact agad mar aon dhiubh.

Source: www.habr.com