🥇Di Tarantool de hûn dikarin databasek super-lez û serîlêdanek ji bo xebata bi wan re bikin yek. Li vir e ku meriv çawa hêsan e

Pênc sal berê min hewl da ku bi Tarantool re bixebitim, lê paşê ew ji min re nexebitî. Lê vê dawiyê min webinarek li dar xist ku min li ser Hadoop û çawa MapReduce dixebite axivî. Li wir pirsek ji min kirin: "Çima Tarantool ji bo vî karî bikar naynin?"

Ji meraqê, min biryar da ku vegerim wê, guhertoya herî dawî ceribînim - û vê carê min pir ji projeyê hez kir. Naha ez ê nîşanî we bidim ka meriv çawa di Tarantool de serîlêdanek hêsan binivîse, wê bar bike û performansa wê kontrol bike, û hûn ê bibînin ka her tişt çiqas hêsan û xweş e.

Tarantool çi ye

Tarantool xwe wekî databasek ultra-lez cih digire. Hûn dikarin her daneyên ku hûn dixwazin li wir bicîh bikin. Zêdetir, wan dubare bikin, perçe - ango, hejmareke mezin a daneyan li ser çend serveran veqetînin û encamên ji wan berhev bikin - girêdanên master-master-tolerant xelet çêbikin.

Ya duyemîn, ev serverek serîlêdanê ye. Hûn dikarin serîlêdanên xwe li ser wê binivîsin, bi daneyan re bixebitin, mînakî, li gorî hin qaîdeyan tomarên kevn ên li paşnavê jêbirin. Hûn dikarin rasterast serverek Http-ê li Tarantula binivîsin ku dê bi daneyan re bixebite: hêjahiya wan bidin, daneyên nû li wir binivîsin û hemî ji masterê re kêm bikin.

Min gotarek xwend ka meriv çawa ji 300 rêzan rêzek peyamê çêkir, ku bi hêsanî diqelişe û diheje - performansa wan a herî kêm 20 peyam di çirkekê de heye. Li vir hûn dikarin bi rastî li dora xwe bizivirin û serîlêdanek pir mezin binivîsin, û ew ê nebe hilanîn, wekî PostgreS.

Ez ê hewl bidim ku di vê gotarê de tiştek mîna vê serverê, tenê hêsan, diyar bikim.

mîhengê

Ji bo ceribandinê, min sê makîneyên virtual standard dest pê kir - dîskek hişk a 20 GB, Ubuntu 18.04. 2 CPU-yên virtual û 4 giga bîranîn.

Em Tarantool saz dikin - skrîpta bash bimeşînin an depoyek lê zêde bikin û guncan bikin ku Tarantool saz bikin. Girêdana nivîsarê - (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Fermanên me hene:

tarantoolctl - Fermana sereke ji bo birêvebirina mînakên Tarantula.
/hwd/tarantool - Li vir tevahiya veavakirinê ye.
var / têketin / tarantool - Li vir têketin hene.
var/lib/tarantool - Daneyên li vir hene, û dûv re ew li mînakan têne dabeş kirin.

Peldank hene mînak-berdest û mînak-çalak - ew dihewîne ya ku dê were destpêkirin - pelek mîhengê mînakek bi koda lua, ku diyar dike li kîjan portan guhdarî dike, çi bîranîn jê re heye, mîhengên motora Vinyl, koda ku di destpêkê de dimeşe pêşkêşker, parvekirin, rêz, jêbirina daneyên kevinbûyî, û hwd.

Mînakên mîna PostgreS dixebitin. Mînakî, hûn dixwazin çend kopiyên databasek ku li ser benderên cûda ve girêdayî ye bimeşînin. Derket holê ku çend mînakên databasê li ser yek serverê têne destpêkirin, ku li ser portên cihêreng têne girtin. Dibe ku ew mîhengên bi tevahî cûda hebin - mînakek yek mantiqê pêk tîne, ya duyemîn - ya din.

rêveberiya nimûne

Fermana me tarantoolctl heye, ku dihêle hûn mînakên Tarantula birêve bibin. Mînakî, mînaka kontrolê ya tarantoolctl dê pelê mîhengê kontrol bike û bêje - heke li wir xeletiyên hevoksaziyê tunebin pel baş e.

Hûn dikarin rewşa nimûneyê bibînin - mînaka statuya tarantoolctl. Bi heman awayî hûn dikarin dest pê bikin, bisekinin, ji nû ve bidin destpêkirin.

Gava ku mînak dimeşîne, hûn dikarin bi du awayan pê ve girêbidin.

1. Konsolê îdarî

Bi xwerû, Tarantool soketek vedike, nivîsa normal ASCII li wir tê şandin da ku Tarantool kontrol bike. Girêdana bi konsolê re her gav di bin bikarhênerê rêvebir de pêk tê, erêkirin tune, ji ber vê yekê ne hewce ye ku porta konsolê ji derve were derxistin da ku Tarantula birêve bibe.

Ji bo ku hûn bi vê rêbazê ve girêdayî bibin, hûn hewce ne ku navê nimûneya Tarantoolctl têkevin. Ferman dê konsolê bide destpêkirin û wekî bikarhênerê rêveberê ve girêdayî ye. Tu carî porta konsolê li derve dernexin - çêtir e ku hûn wê wekî soketek yekîneyê bihêlin. Wê hingê tenê yên ku gihîştina nivîsandina soketê heye dê karibin bi Tarantula ve girêdayî bin.

Ev rêbaz ji bo tiştên îdarî hewce ye. Ji bo ku bi daneyan re bixebitin, rêbaza duyemîn bikar bînin - protokola binary.

2. Bikaranîna protokola binary ji bo girêdana portek taybetî

Veavakirin rêwerzek guhdarîkirinê vedihewîne, ku portek ji bo danûstendinên derveyî vedike. Ev port bi protokola binaryê re tê bikar anîn û li wir verastkirin tê çalak kirin.

Ji bo vê pêwendiyê, tarantoolctl girêdana bi hejmara portê ve tê bikar anîn. Bi karanîna wê, hûn dikarin bi serverên dûr ve girêdin, erêkirinê bikar bînin û mafên gihîştina cihêreng bidin.

Tomarkirina Daneyên û Modula Box

Ji ber ku Tarantool hem danegehek û hem jî serverek serîlêdanê ye, modulên wê yên cihêreng hene. Em bi modula qutiyê re eleqedar dibin - ew xebata bi daneyan re pêk tîne. Dema ku hûn tiştek li qutikê dinivîsin, Tarantool daneyan li ser dîskê dinivîse, wê di bîranînê de hilîne, an tiştek din pê re dike.

Girtinî

Mînakî, em diçin modula qutiyê û bangî fonksiyona box.once dikin. Ev ê zorê bide Tarantool ku gava server were destpêkirin koda me bimeşîne. Em cîhek ku dê daneyên me tê de werin hilanîn ava dikin.

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

Piştî vê yekê, em navnîşek bingehîn - seretayî - diafirînin ku em dikarin li daneyan bigerin. Ji hêla xwerû ve, heke hûn pîvanek diyar nekin, qada yekem di her tomarê de dê ji bo navnîşa bingehîn were bikar anîn.

Dûv re em ji bikarhênerê mêvan re destûrek didin, ku di binê wê de em bi protokola binary ve girêdayî ne. Em destûr didin xwendin, nivîsandin û bicihkirinê li seranserê nimûneyê.

Li gorî databasên kevneşopî, her tişt li vir pir hêsan e. Cihê me heye - deverek ku daneyên me bi tenê têne hilanîn. Ji her qeydê re tuple tê gotin. Ew di MessagePack de tête pak kirin. Ev formatek pir xweş e - ew binar e û cîhê hindik digire - 18 byte li hember 27.

Karkirina bi wî re pir hêsan e. Hema hema her rêz, her tomarek daneyê dikare stûnên bi tevahî cûda hebin.

Em dikarin hemî cîhan bi karanîna fermana Box.space bibînin. Ji bo ku mînakek taybetî hilbijêrin, mînakek box.space binivîsin û derheqê wê de agahdariya bêkêmasî bistînin.

Tarantool du motorên çêkirî hene: Bîr û Vinyl. Bîr hemû daneyan di bîrê de diparêze. Ji ber vê yekê, her tişt bi hêsanî û zû dixebite. Daneyên li ser dîskê têne avêtin, û di heman demê de mekanîzmayek têketinê ya pêşîn jî heye, ji ber vê yekê em ê tiştek winda nekin ger server têk bibe.

Vinyl daneyan li ser dîskê bi rengek ku ji me re naskirî ye hilîne - ango, hûn dikarin ji bîra me bêtir daneyan hilînin, û Tarantula wê ji dîskê bixwîne.

Ji bo niha em ê Bîrê bikar bînin.

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>

Naverok:

Pêdivî ye ku ji bo her cîhekî navnîşek bingehîn were afirandin, ji ber ku bêyî wê tiştek dê nexebite. Mîna ku di her databasê de, em qada yekem diafirînin - ID tomar.

Perçeyên

Li vir em destnîşan dikin ku index me ji çi pêk tê. Ew ji yek beşê pêk tê - qada yekem a ku em ê bikar bînin ji celebê nenîşankirî ye - hejmarek erênî. Bi qasî ku ji belgeyê tê bîra min, herî zêde hejmara ku dikare bibe 18 quintillion e. Ew gelek e.

Wê hingê em dikarin bi karanîna fermana têxê daneyan têxin.

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>

Qada yekem wekî mifteya bingehîn tê bikar anîn, ji ber vê yekê divê ew yekta be. Em ji hêla hejmara stûnan ve ne sînorkirî ne, ji ber vê yekê em dikarin bi qasî ku em dixwazin daneyan têxin wir. Ew di forma MessagePack de, ku min li jor diyar kir, têne destnîşan kirin.

Daneyên derketinê

Wê hingê em dikarin daneyan bi karanîna fermana hilbijartî nîşan bidin.

Box.example.select bi bişkoja {1} dê têketina xwestî nîşan bide. Ger em mifteyê dakêşin, em ê hemî tomarên ku di destê me de ne bibînin. Ew hemî di hejmara stûnan de cûda dibin, lê li vir, di prensîbê de, têgeha stûnan tune - hejmarên zeviyê hene.

Dibe ku bi tevahî her mîqdara daneyê hebe. Û wek nimûne, em hewce ne ku ji hêla qada duyemîn ve li wan bigerin. Ji bo vê yekê, em navnîşek duyemîn a nû ava dikin.


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

Em fermana Create_index bikar tînin.
Ka em jê re bibêjin Duyemîn.

Piştî vê yekê hûn hewce ne ku pîvanan diyar bikin. Cûreya îndeksê DAR e. Dibe ku ew ne yekta be, ji ber vê yekê Yekane = derewîn binivîse.

Dûv re em destnîşan dikin ku indeksa me ji kîjan beşan pêk tê. Qadan hejmara zeviyê ye ku em pêvekê pê ve girêdidin, û cureya rêzê diyar dikin. Û bi vî awayî hat afirandin.

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>

Niha bi vî awayî em dikarin jê re bibêjin:

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

Saving

Ger em nimûneyê ji nû ve bidin destpêkirin û hewl bidin ku daneyan dîsa bang bikin, em ê bibînin ku ew ne li wir e - her tişt vala ye. Ev diqewime ji ber ku Tarantool nuqteyên kontrolê çêdike û daneyan li ser dîskê hilîne, lê heke em heya hilanînê ya din bixebitin, em ê hemî operasyonan winda bikin - ji ber ku em ê ji nuqteya kontrolê ya paşîn xilas bibin, ku, mînakî, du demjimêr berê bû.

Ew ê nexebite ku her duyemîn jî hilîne, ji ber ku bi domdarî avêtina 20 GB li ser dîskê ne ramanek baş e.

Ji bo vê armancê, têgîna qeydkirina pêş-nivîsandinê hate îcadkirin û bicihanîn. Bi alîkariya wê, ji bo her guhartina daneyê, têketinek di pelek têketinek piçûk a pêş-nivîsandinê de tê afirandin.

Her têketinek heya nuqteya kontrolê di wan de tê hilanîn. Ji bo van pelan em mezinahiyê destnîşan dikin - mînakî, 64 MB. Dema ku ew tije ye, tomar dest pê dike ku diçe pelê duyemîn. Û piştî ji nû ve destpêkirinê, Tarantool ji nuqteya kontrolê ya paşîn tê nûve kirin û dûv re li ser hemî danûstendinên paşîn vedigere heya ku raweste.

Ji bo pêkanîna tomarek weha, hûn hewce ne ku vebijarkê di mîhengên box.cfg de (di pelê example.lua de) diyar bikin:

wal_mode = “write”;

bikaranîna daneyan

Bi ya ku me nuha nivîsandiye, hûn dikarin Tarantula bikar bînin da ku daneyan hilînin û ew ê wekî databasek pir zû bixebite. Û aniha çîçeka li ser kekê ew e ku hûn dikarin bi hemîyan re bikin.

Nivîsandina serîlêdanê

Mînakî, em ji bo Tarantula serîlêdana jêrîn binivîsin

Serlêdanê di binê spoilerê de bibînin

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

Em di lua de hin tabloya ku karakteran diyar dike diyar dikin. Ev plakaya pêdivî ye ku rêzek rasthatî çêbike.

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

Piştî wê, em fonksiyonê - randomString radigihînin û nirxa dirêjiyê di nav parantezê de didin.

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

Dûv re em routerê http û servera http bi servera xweya Tarantula, JSON ve girêdidin, ku em ê ji xerîdar re bişînin.

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

Piştî vê yekê, em dest bi porta 8080-ê li ser hemî navgînên servera http dikin, ku dê hemî daxwaz û xeletiyan tomar bike.

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

Dûv re, em rêgezê radigihînin, da ku heke daxwazek bi rêbaza GET-ê bigihîje porta 8080 / hejmartinê, wê hingê em fonksiyonê ji yek rêzê bang dikin. Ew statûyê vedigerîne - 200, 404, 403 an ya din ku em diyar dikin.

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

Di laşê de em vedigerin json.encode, di wê de em jimartin û jimartin destnîşan dikin, ku tê gotin û hejmara tomarên di databasa me de nîşan dide.

Mînemek duyem

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)

Ku di rêzê de router: rê ({rêbaz = 'GET', rê = '/token'}, fonksiyon() em bang li fonksiyonê dikin û nîşanek çêdikin.

Xet nîşana herêmî = randomString(32) rêzikek rasthatî ya 32 tîpan e.
Di rêzê de herêmî dawî = box.space.example:len() em hêmana dawî derdixin.
Û di rêzê de box.space.example:insert{ dawî + 1, nîşan } em daneyan di databasa xwe de dinivîsin, ango em bi tenê ID-ê 1-ê zêde dikin. Ev jî, ne tenê bi vî awayî nebaş, dikare were kirin. Di Tarantula de rêzikên vê yekê hene.

Em nîşanek li wir dinivîsin.

Bi vî awayî, me daxwazname di yek dosyayê de nivîsand. Hûn dikarin rasterast daneyan li wir manîpule bikin, û modula qutîkê dê hemî karên qirêj ji we re bike.

Ew li http guhdarî dike û bi daneyan re dixebite, her tişt di yek nimûneyê de ye - hem serîlêdan û hem jî dane. Ji ber vê yekê, her tişt pir zû diqewime.

Ji bo destpêkirinê em modula http saz dikin:

Em çawa vê yekê dikin, li binê xerakirinê binêrin

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

Di heman demê de ji me re Prometheus jî hewce ye ku bimeşîne:

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

Em dest pê dikin û dikarin bigihîjin modulan

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 statûya 200 dide me.
/token nîşanek derdixe û vê tokenê li databasê dinivîse.

Testkirina lezê

Ka em ji bo 50 daxwazan pîvanek bimeşînin. Dê 000 daxwazên hevrikî hebin.

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

Nîşan têne derxistin. Û em bi berdewamî daneyan tomar dikin. 99% ji daxwazan di 42 millisecons de hatin kirin. Li gorî vê yekê, li ser makîneyek piçûk a bi 3500 core û 2 gigabayt bîranîn di çirkeyê de nêzî 4 daxwazên me hene.

Her weha hûn dikarin hin 50000 token hilbijêrin û nirxa wê bibînin.

Hûn dikarin ne tenê http bikar bînin, lê di heman demê de fonksiyonên paşîn ên ku daneyên we pêvajoyê dikin jî bimeşînin. Digel vê yekê, rêgezên cûda hene. Mînakî, hûn dikarin li ser nûvekirinan bangî fonksiyonan bikin, tiştek kontrol bikin - nakokiyên rast bikin.

Hûn dikarin serîlêdanên skrîptê rasterast di servera databasê de bixwe binivîsin, û ji hêla tiştek ve neyên sînordar kirin, tu modulan girêdin û her mantiqê bicîh bînin.

Pêşkêşkara serîlêdanê dikare bigihîje serverên derveyî, daneyan bigire û li databasa xwe zêde bike. Daneyên ji vê databasê dê ji hêla sepanên din ve werin bikar anîn.

Tarantula dê bi xwe vê yekê bike, û hûn neçar in ku serîlêdanek cûda binivîsin.

Di encamê de

Ev tenê beşa yekem a xebatek mezin e. Ya duyemîn dê di demek nêzîk de li ser bloga Koma Mail.ru were weşandin, û em ê bê guman di vê materyalê de girêdanek jê re zêde bikin.

Heke hûn dixwazin beşdarî bûyerên ku em van tiştan serhêl ava dikin û di wextê rast de pirsan dikin, bişopînin kanala DevOps ji hêla REBRAIN.

Heke hûn hewce ne ku biçin ewr an jî di derheqê binesaziya xwe de pirsên we hebin, bi dilxwazî daxwazek bihêlin.

PS Me mehê 2 kontrolên belaş hene, dibe ku projeya we yek ji wan be.

Source: www.habr.com

Di Tarantool de, hûn dikarin databasek super-lez û serîlêdanek bi wan re bixebitin. Li vir e ku ew çiqas hêsan e