Tarantool galite sujungti ypač greitą duomenų bazę ir programą, kad galėtumėte dirbti su jomis. Štai kaip lengva tai padaryti

Prieš penkerius metus bandžiau dirbti su Tarantool, bet tada man tai nepasiteisino. Tačiau neseniai surengiau internetinį seminarą, kuriame kalbėjau apie Hadoop, apie tai, kaip veikia MapReduce. Ten man buvo užduotas klausimas - „Kodėl šiai užduočiai nenaudoti Tarantool?

Smalsumo dėlei nusprendžiau prie jo sugrįžti, išbandyti naujausią versiją – ir šį kartą projektas man labai patiko. Dabar aš parodysiu, kaip parašyti paprastą programą Tarantool, įkelti ją ir patikrinti našumą, ir pamatysite, kaip viskas paprasta ir šaunu.

Kas yra Tarantool

Tarantool pozicionuoja save kaip itin greitą duomenų bazę. Ten galite įdėti bet kokius norimus duomenis. Be to, atkartokite juos, sardinkite – tai yra, padalykite didžiulį duomenų kiekį keliuose serveriuose ir sujunkite jų rezultatus – sukurkite gedimams atsparias pagrindinio ir pagrindinio ryšio nuorodas.

Antra, tai yra programų serveris. Galite rašyti jame savo programas, dirbti su duomenimis, pavyzdžiui, ištrinti senus įrašus fone pagal tam tikras taisykles. Galite įrašyti Http serverį tiesiai į Tarantulą, kuris dirbs su duomenimis: nurodykite jų numerį, įrašykite naujus duomenis ir sumažinkite visa tai iki pagrindinio.

Skaičiau straipsnį apie tai, kaip vaikinai sudarė 300 eilučių žinučių eilę, kuri tiesiog drasko ir daužosi – jų minimalus našumas yra 20 000 pranešimų per sekundę. Čia tikrai galite apsisukti ir parašyti labai didelę programą, o jos nebus saugomos, kaip PostgreS.

Maždaug tokį serverį, tik paprastą, pabandysiu aprašyti šiame straipsnyje.

Montavimas

Bandymui paleidau tris standartines virtualias mašinas – 20 gigabaitų standųjį diską, Ubuntu 18.04. 2 virtualus procesorius ir 4 gigabaitai atminties.

Įdiegiame Tarantool – paleidžiame bash scenarijų arba pridedame saugyklą ir apt get įdiegiame Tarantool. Nuoroda į scenarijų - (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Turime tokias komandas kaip:

tarantoolctl yra pagrindinė Tarantulos egzempliorių valdymo komanda.
/etc/tarantool - čia yra visa konfigūracija.
var/log/tarantool – štai rąstai.
var/lib/tarantool - čia yra duomenys, o tada jie skirstomi į egzempliorius.

Yra egzempliorių pasiekiami ir įgalinti aplankai – jame yra tai, kas bus paleista – egzemplioriaus konfigūracijos failas su lua kodu, kuriame aprašoma, kuriuose prievaduose jis klausosi, kokia atmintis jam prieinama, vinilo variklio nustatymai, kodas, kuris veikia paleidžiant. serveriai, dalijimasis, eilės, pasenusių duomenų ištrynimas ir pan.

Pavyzdžiai veikia kaip PostgreS. Pavyzdžiui, norite paleisti kelias duomenų bazės, kuri kabo skirtinguose prievaduose, kopijas. Pasirodo, viename serveryje paleidžiami keli duomenų bazės egzemplioriai, kurie kabo skirtinguose prievaduose. Jie gali turėti visiškai skirtingus nustatymus – vienas egzempliorius įgyvendina vieną logiką, antrasis – kitą.

Instancijų valdymas

Mes turime tarantoolctl komandą, kuri leidžia mums valdyti Tarantula egzempliorius. Pavyzdžiui, tarantoolctl patikrinimo pavyzdys patikrins konfigūracijos failą ir pasakys, kad failas yra gerai, jei nėra sintaksės klaidų.

Galite pamatyti egzemplioriaus būseną - tarantoolctl būsenos pavyzdys. Taip pat galite pradėti, sustabdyti, paleisti iš naujo.

Kai egzempliorius veikia, yra du būdai prie jo prisijungti.

1. Administracinė konsolė

Pagal numatytuosius nustatymus Tarantool atidaro lizdą ir siunčia paprastą ASCII tekstą, kad valdytų Tarantula. Prisijungimas prie konsolės visada vyksta pas admin vartotoją, nėra autentifikavimo, todėl nereikia išimti konsolės prievado, kad galėtumėte valdyti Tarantula išorėje.

Norėdami prisijungti tokiu būdu, turite įvesti Tarantoolctl enter egzemplioriaus pavadinimą. Komanda paleis konsolę ir prisijungs kaip administratorius. Niekada neatidenkite konsolės prievado į išorę – geriau palikite jį kaip įrenginio lizdą. Tada prie Tarantulo galės prisijungti tik tie, kurie turi rašymo prieigą prie lizdo.

Šis metodas reikalingas administraciniams dalykams. Norėdami dirbti su duomenimis, naudokite antrąjį metodą - dvejetainį protokolą.

2. Dvejetainio protokolo naudojimas prisijungti prie konkretaus prievado

Konfigūracijoje yra klausymo direktyva, kuri atidaro prievadą išoriniams ryšiams. Šis prievadas naudojamas su dvejetainiu protokolu ir čia įjungtas autentifikavimas.

Šiam ryšiui naudojamas tarantoolctl prisijungti prie prievado numerio. Naudodamiesi juo galite prisijungti prie nuotolinių serverių, naudoti autentifikavimą ir suteikti įvairias prieigos teises.

Duomenų įrašymo ir dėžutės modulis

Kadangi Tarantool yra ir duomenų bazė, ir programų serveris, joje yra įvairių modulių. Mus domina dėžės modulis – jis realizuoja darbą su duomenimis. Kai ką nors rašote į dėžutę, Tarantool įrašo duomenis į diską, išsaugo juos atmintyje arba daro ką nors kita su jais.

Įrašai

Pavyzdžiui, einame į langelio modulį ir iškviečiame funkciją box.once. Tai privers Tarantool paleisti mūsų kodą, kai serveris bus inicijuotas. Sukuriame erdvę, kurioje bus saugomi mūsų duomenys.

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

Po to sukuriame pirminį indeksą – pirminį – pagal kurį galime ieškoti duomenų. Pagal numatytuosius nustatymus, jei parametrai nenurodyti, bus naudojamas pirmasis kiekvieno pradmenų indekso įrašo laukas.

Tada svečio vartotojui suteikiame dotaciją, pagal kurią jungiamės dvejetainiu protokolu. Leidžiame skaityti, rašyti ir vykdyti visoje instancijoje.

Palyginti su įprastomis duomenų bazėmis, čia viskas gana paprasta. Mes turime erdvę – sritį, kurioje tiesiog saugomi mūsų duomenys. Kiekvienas įrašas vadinamas koretu. Jis supakuotas į MessagePack. Tai labai šaunus formatas – jis dvejetainis ir užima mažiau vietos – 18 baitų, palyginti su 27 baitais.

Su juo gana patogu dirbti. Beveik kiekviena eilutė, kiekvienas duomenų įrašas gali turėti visiškai skirtingus stulpelius.

Visas erdves galime peržiūrėti naudodami komandą Box.space. Norėdami pasirinkti konkretų atvejį, rašome box.space pavyzdį ir gauname visą informaciją apie jį.

Tarantool yra dviejų tipų varikliai: atminties ir vinilo. Atmintis saugo visus duomenis atmintyje. Todėl viskas veikia paprastai ir greitai. Duomenys iškeliami į diską, taip pat yra įrašymo į priekį žurnalo mechanizmas, todėl nieko neprarasime, jei serveris sugenda.

Vinilas saugo duomenis diske labiau pažįstama forma - tai yra, galite saugoti daugiau duomenų nei turime atminties, o Tarantula juos nuskaitys iš disko.

Dabar naudosime atmintį.

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>

Pagrindinis puslapis:

Bet kuriai erdvei reikia sukurti pirminį indeksą, nes be jo niekas neveiks. Kaip ir bet kurioje duomenų bazėje, mes sukuriame pirmąjį lauką – įrašo ID.

Dalys:

Čia nurodome, iš ko susideda mūsų indeksas. Jį sudaro viena dalis – pirmasis laukas, kurį naudosime, įveskite unsigned – teigiamas sveikasis skaičius. Kiek pamenu iš dokumentacijos, didžiausias gali būti 18 kvintilijonų. Daug nuostabaus.

Tada galime įterpti duomenis naudodami įterpimo komandą.

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>

Pirmasis laukas naudojamas kaip pirminis raktas, todėl jis turi būti unikalus. Mūsų neriboja stulpelių skaičius, todėl galime ten įterpti tiek duomenų, kiek norime. Jie nurodyti MessagePack formatu, kurį aprašiau aukščiau.

Duomenų išvestis

Tada galime rodyti duomenis pasirinkdami komandą.

Box.example.select mygtuku {1} parodys norimą įrašą. Jei praleisime raktą, pamatysime visus turimus įrašus. Jie visi skiriasi stulpelių skaičiumi, bet čia iš esmės nėra stulpelių sąvokos – yra laukelių numeriai.

Duomenų gali būti tiek, kiek norite. Ir, pavyzdžiui, turime jų ieškoti antrame lauke. Norėdami tai padaryti, sukuriame naują antrinį indeksą.

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

Mes naudojame komandą Create_index.
Mes tai vadiname antriniu.

Po to turite nurodyti parametrus. Indekso tipas yra MEDIS. Jis gali būti ne unikalus, todėl įrašome Unique = false.

Tada nurodome, iš kokių dalių susideda mūsų indeksas. Laukas – tai lauko, su kuriuo susiejame indeksą, numeris ir nurodomas eilutės tipas. Ir taip jis buvo sukurtas.

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>

Dabar galime tai pavadinti taip:

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

Išsaugojimas

Jei iš naujo paleisime egzempliorių ir bandysime iškviesti duomenis dar kartą, pamatysime, kad jų nėra – viskas tuščia. Taip atsitinka todėl, kad Tarantool daro kontrolinius taškus ir išsaugo duomenis į diską, tačiau jei nustosime dirbti prieš kitą išsaugojimą, prarasime visas operacijas – nes atsigausime iš paskutinio patikros taško, kuris buvo, pavyzdžiui, prieš dvi valandas.

Taupyti kas sekundę taip pat nepavyks – nes nuolat leisti 20 GB į diską yra tokia idėja.

Tam buvo sugalvota ir įgyvendinta išankstinio įrašymo žurnalo koncepcija. Su jo pagalba kiekvienam duomenų pakeitimui sukuriamas įrašas mažame įrašymo į priekį žurnalo faile.

Juose saugomas kiekvienas įrašas iki patikros punkto. Šiems failams nustatome dydį - pavyzdžiui, 64 mb. Kai jis užpildomas, įrašymas pradedamas antrame faile. Ir po pakartotinio paleidimo Tarantool atsigauna po paskutinio patikros taško ir perkelia visas vėlesnes operacijas, kol sustos.

Norėdami atlikti tokį įrašymą, turite nurodyti parinktį box.cfg nustatymuose (pavyzdys.lua faile):

wal_mode = “write”;

duomenų naudojimas

Turėdami tai, ką parašėme dabar, galite naudoti Tarantula duomenims saugoti ir ji veiks labai greitai kaip duomenų bazė. O dabar vyšnia ant torto – ką su visa tai padaryti.

Paraiškos rašymas

Pavyzdžiui, parašykime tokią paraišką Tarantulai

Žiūrėkite programą po spoileriu

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

Mes deklaruojame tam tikrą lentelę lua, kuri apibrėžia simbolius. Ši lentelė reikalinga atsitiktinei eilutei sugeneruoti.

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

Po to deklaruojame funkciją - randomString ir ilgio reikšmę pateikiame skliausteliuose.

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

Tada sujungiame http maršrutizatorių ir http serverį prie mūsų Tarantula serverio JSON, kurį suteiksime klientui.

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

Po to visose http serverio sąsajose pradedame nuo 8080 prievado, kuris registruos visas užklausas ir klaidas.

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

Toliau deklaruojame maršrutą, kad jei užklausa su GET metodu ateina į prievadą 8080 /count, tada iškviečiame funkciją iš vienos eilutės. Jis grąžina būseną – 200, 404, 403 arba bet ką, ką mes nurodome.

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

Turinyje grąžiname json.encode, jame nurodome count ir getcount, kuris iškviečiamas ir parodo įrašų skaičių mūsų duomenų bazėje.

Antrasis metodas

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)

Kur eilėje router:route({method = 'GET', path = '/token'}, function() iškviečiame funkciją ir generuojame žetoną.

Linija vietinis prieigos raktas = randomString(32) yra atsitiktinė 32 simbolių eilutė.
Eilėje vietinis paskutinis = box.space.example:len() ištraukiame paskutinį elementą.
Ir eilėje box.space.example:insert{ paskutinis + 1, prieigos raktas } įrašome duomenis į savo duomenų bazę, tai yra tiesiog padidiname ID 1. Tai galima padaryti, beje, ne tik tokiu gremėzdišku būdu. Tarantula turi sekų šiam atvejui.

Ten rašome žetoną.

Taigi paraišką surašėme viename faile. Duomenis galite pasiekti iš karto, o dėžutės modulis atliks visą nešvarų darbą už jus.

Klauso http ir dirba su duomenimis, viskas viename egzemplioriuje – ir programa, ir duomenys. Todėl viskas vyksta gana greitai.

Norėdami paleisti, įdiegiame http modulį:

Kaip tai darome, žiūrėkite po spoileriu

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

Mums taip pat reikia Prometėjo, kad galėtume paleisti:

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

Pradedame ir galime prieiti prie modulių

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 suteikia mums 200 statusą.
/token išduoda prieigos raktą ir įrašo jį į duomenų bazę.

Bandymo greitis

Atlikime 50 000 užklausų etaloną. Konkurso prašymų bus 500.

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

Išduodami žetonai. Ir mes nuolat fiksuojame duomenis. 99% užklausų buvo įvykdytos per 42 milisekundes. Atitinkamai, mes turime apie 3500 užklausų per sekundę mažame kompiuteryje, kuriame yra 2 branduoliai ir 4 gigabaitai atminties.

Taip pat galite pasirinkti 50000 XNUMX žetonų ir pamatyti jo vertę.

Galite naudoti ne tik http, bet ir paleisti fonines funkcijas, kurios apdoroja jūsų duomenis. Be to, yra įvairių trigerių. Pavyzdžiui, galite iškviesti naujinimų funkcijas, ką nors patikrinti - išspręsti konfliktus.

Galite rašyti scenarijaus programas tiesiai pačiame duomenų bazės serveryje ir niekuo neapsiriboti, jungti bet kokius modulius ir įgyvendinti bet kokią logiką.

Programos serveris gali pasiekti išorinius serverius, rinkti duomenis ir įtraukti juos į savo duomenų bazę. Šios duomenų bazės duomenis naudos kitos programos.

Tai padarys pats Tarantulas, o atskiro prašymo rašyti nereikia.

užbaigiant

Tai tik pirmoji didelio darbo dalis. Antrasis jau labai greitai bus paskelbtas Mail.ru grupės tinklaraštyje, ir šioje medžiagoje būtinai pridėsime nuorodą į jį.

Jei norite dalyvauti renginiuose, kuriuose mes kuriame šiuos dalykus internete, ir užduoti klausimus realiuoju laiku, prisijunkite „DevOps by REBRAIN“ kanalas.

Jei reikia pereiti prie debesies arba turite klausimų apie infrastruktūrą, Nedvejodami pateikite prašymą.

PS Turime 2 nemokamus auditus per mėnesį, galbūt jūsų projektas bus vienas iš jų.

Šaltinis: www.habr.com