V Tarantool môžete spojiť superrýchlu databázu a aplikáciu na prácu s nimi. Takto jednoducho sa to robí

Pred piatimi rokmi som sa pokúsil pracovať s Tarantool, ale vtedy ma neoslovil. Nedávno som však uskutočnil webinár, kde som hovoril o Hadoope a o tom, ako funguje MapReduce. Tam sa ma pýtali: "Prečo na túto úlohu nepoužiť Tarantool?".

Z radosti zvedavosti som sa rozhodol vrátiť k nemu, otestovať najnovšiu verziu — a tentoraz ma projekt veľmi zaujímal. Teraz vám ukážem, ako napísať jednoduchú aplikáciu v Tarantool, zaťažiť ju a skontrolovať výkon, a uvidíte, aké to všetko je jednoduché a skvelé.

Čo je Tarantool

Tarantool sa prezentuje ako ultrarýchla databáza. Môžete do nej vkladať akékoľvek dáta, ktoré chcete. Navyše, môžete ich replikovať, shardovať — t.j. rozdeliť obrovské množstvo dát medzi viaceré servery a zlučovať výsledky — vytvárať odolné väzby typu "master-master".

Po druhé, je to aplikačný server. Môžete na ňom písať svoje aplikácie, pracovať s dátami, napríklad z pozadia mazať staré záznamy na základe určitých pravidiel. Môžete napísať priamo v Tarantool HTTP server, ktorý bude pracovať s dátami: vydávať ich množstvo, zapisovať nové dáta a redukovať to všetko na majstra.

Čítal som článok o tom, ako chlapci vytvorili frontu správ na 300 riadkov, ktorá jednoducho pália a metú — majú minimálny výkon od 20 000 správ za sekundu. Tu sa naozaj dá rozbehnúť a napísať veľmi veľkú aplikáciu, a to nebudú uloženky, ako v PostgreS.

Takýto server, len jednoduchý, sa pokúsim popísať v tomto článku.

Inštalácia

Na test som vytvoril tri štandardné virtuálne stroje – disk s kapacitou 20 gigabajtov, Ubuntu 18.04, 2 virtuálne CPU a 4 gigabajty pamäte.

Nainštalujeme Tarantool — spustíme shell skript alebo pridáme repozitár a vykonáme apt get install Tarantool. Odkaz na skript — (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Máme takéto príkazy, ako:

tarantoolctl — hlavný príkaz na správu inštancií Tarantoolu.
/etc/tarantool — tu leží všetka konfigurácia.
var/log/tarantool — tu sú logy.
var/lib/tarantool — tu sú dáta, a ďalej sú rozdelené podľa inštancií.

Existujú priečinky instance-available a instance-enable — v druhom sa nachádza to, čo sa spustí — konfiguračný súbor inštancie s kódom lua, kde je popísané, na akých portoch počúva, aká pamäť je mu k dispozícii, nastavenia enginu Vinyl, kód, ktorý sa vykoná pri spustení servera, shardovanie, fronty, odstraňovanie zastaraných údajov a podobne.

Inštancie fungujú podobne ako v PostgreS. Napríklad, ak chcete spustiť niekoľko kópií databázy, ktorá beží na rôznych portoch. Výsledkom je, že na jednom serveri sa spúšťa niekoľko inštancií databáz, ktoré bežia na rôznych portoch. Môžu mať úplne odlišné nastavenia — jedna inštancia realizuje jednu logiku, druhá — druhú.

Správa inštancií

Máme príkaz tarantoolctl, ktorý umožňuje spravovať inštancie Tarantoola. Napríklad, tarantoolctl check example skontroluje súbor s konfiguráciou a povie — súbor je ok, ak tam nie sú žiadne syntaktické chyby.

Status inštancie môžete skontrolovať pomocou príkazu — tarantoolctl status example. Rovnako sa dá vykonávať spustenie, zastavenie a reštart.

Keď je inštancia spustená, môžete sa k nej pripojiť dvoma spôsobmi.

1. Administratívna konzola

Predvolene Tarantool otvára socket, kde sa posiela bežný ASCII text na správu Tarantoola. Pripojenie k konzole sa vždy uskutočňuje pod používateľom admin, nie je tam žiadne overovanie, takže port konzoly na správu Tarantoola netreba vystavovať von.

Na pripojenie týmto spôsobom je potrebné zadať príkaz Tarantoolctl enter instance name. Tento príkaz spustí konzolu a pripojí sa pod používateľom admin. Nikdy nezverejňujte port konzoly von — lepšie je ho nechať ako unix socket. Takto sa môže k Tarantoolu pripojiť len ten, kto má prístup na zápis do socketu.

Tento spôsob je potrebný na administratívne úlohy. Na prácu s dátami použite druhý spôsob — binárny protokol.

2. Použitie binárneho protokolu na pripojenie k určitému portu

V konfigurácii je direktíva listen, ktorá otvára port pre vonkajšiu komunikáciu. Tento port sa používa s binárnym protokolom a je tam zapnuté overovanie.

Na toto pripojenie sa používa príkaz tarantoolctl connect to port number. Pomocou neho sa môžete pripojiť k vzdialeným serverom, používať overovanie a udeľovať rôzne prístupové práva.

Zápis dát a modul Box

Keďže Tarantool je zároveň databáza a aplikačný server, má rôzne moduly. Zaujíma nás modul box — ten realizuje prácu s dátami. Keď do boxu zapisujete niečo, Tarantool ukladá dáta na disk, uchováva ich v pamäti alebo s nimi robí niečo iné.

Záznam

Napríklad, vstúpime do modulu box a zavoláme funkciu box.once. Táto funkcia privedie Tarantool k spusteniu nášho kódu pri inicializácii servera. Vytvoríme space, v ktorom budú uložené naše dáta.

local function bootstrap()
    local space = box.schema.create_space('example')
    space:create_index('primary')
    box.schema.user.grant('guest', 'read,write,execute', 'universe')

    -- Chrániť veci predvolene
    --  box.schema.user.create('example', { password = 'secret' })
    --  box.schema.user.grant('example', 'replication')
    --  box.schema.user.grant('example', 'read,write,execute', 'space', 'example')
end

Potom vytvoríme primárny index – primary – ktorý umožní vyhľadávanie dát. Predvolene, ak nie sú zadané žiadne parametre, prvé pole v každom zázname sa použije ako primárny index.

Následne udelíme práva používateľovi guest, pod ktorým sa pripájame cez binárny protokol. Povolenie čítať, zapisovať a vykonávať v celom inštancii.

Ak to porovnáme s bežnými databázami, všetko je tu celkom jednoduché. Máme space – oblasť, kde sú uložené naše dáta. Každý záznam sa nazýva tuple. Je zabalený v MessagePack. Je to veľmi zaujímavý formát — je binárny a zaberá menej miesta – 18 bajtov oproti 27.

S ním sa pracuje veľmi pohodlne. Takmer každý riadok, každý záznam dát môže mať úplne rôzne stĺpce.

Všetky spaces môžeme vidieť pomocou príkazu Box.space. Aby sme vybrali konkrétny inštanciu – napíšeme box.space example a dostaneme kompletné informácie o ňom.

V Tarantool sú zabudované dva typy enginov: Memory a Vinyl. Memory uchováva všetky dáta v pamäti. Preto všetko funguje jednoducho a rýchlo. Dáta sú prenášané na disk a existuje aj mechanizmus write ahead log, takže pri páde servera nič nestratíme.

Vinyl uchováva dáta na disku v pre nás známejšom formáte — teda je možné uchovávať viac dát, než máme v pamäti, a Tarantool ich bude čítať z disku.

Teraz budeme používať Memory.

unix/:/var/run/tarantool/example.control> box.space.example
---
- engine: memtx
  before_replace: 'function: 0x41eb02c8'
  on_replace: 'function: 0x41eb0568'
  ck_constraint: []
  field_count: 0
  temporary: false
  index:
    0: &0
      unique: true
      parts:
      - type: unsigned
        is_nullable: false
        fieldno: 1
      id: 0
      space_id: 512
      type: TREE
      name: primary
    primary: *0
  is_local: false
  enabled: true
  name: example
  id: 512
...

unix/:/var/run/tarantool/example.control>

Index:

Primárny index je potrebné vytvoriť pre každú špeciálnu sekciu, lebo bez neho nič nebude fungovať. Tak ako v každej databáze, vytvárame prvé pole – ID záznamu.

Časti:

Tu uvádzame, z čoho sa náš index skladá. Skladá sa z jednej časti – prvé pole, ktoré budeme používať, typ unsigned — kladné celé číslo. Koľko si pamätám z dokumentácie, maximálne číslo, ktoré môže byť – 18 kvintiliónov. Neuveriteľne veľa.

Následne môžeme vkladať dáta pomocou príkazu 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>

Prvé pole slúži ako primárny kľúč, takže musí byť jedinečné. Počet stĺpcov nie je obmedzený, takže môžeme vložiť koľko chceme dát. Tieto sú uvádzané vo formáte MessagePack, ktorý som opísal vyššie.

Výstup dát

Následne môžeme vypisovať dáta príkazom select.

Box.example.select s uvedením kľúča {1} vypíše požadovaný záznam. Ak kľúč vynecháme, uvidíme všetky záznamy, ktoré máme. Všetky sa líšia počtom stĺpcov, ale v podstate tu nie je pojem stĺpcov — sú tu čísla polí.

Dát môže byť v zásade koľko len chceme. A napríklad, potrebujeme ich vyhľadávať podľa druhého poľa. Na to vytvoríme nový sekundárny index.

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

Používame príkaz Create_index.
Nazývame ho Sekundárny.

Potom musíme uviesť parametre. Typ indexu — TREE. Môže byť nie jedinečný, takže zadáme Unique = false.

Následne určujeme, z akých častí pozostáva náš index. Field — to je číslo poľa, ku ktorému index pripájame, a uvádzame typ string. A tak bol vytvorený.

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>

Takto ho môžeme teraz vyvolať:

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

Uloženie

Ak reštartujeme inštanciu a znova sa pokúsime získať údaje – uvidíme, že nie sú – všetko je prázdne. Tak sa to deje, pretože Tarantool robí kontrolné body a ukladá údaje na disk, ale ak zastavíme prácu pred najbližším uložením, stratíme všetky operácie – pretože sa obnovíme z posledného kontrolného bodu, ktorý bol, napríklad, pred dvoma hodinami.

Ukladať každú sekundu tiež nebude možné – pretože neustále dumpovať na disk po 20 GB – to nie je práve najlepšia myšlienka.

Na tento účel bola vymyslená a implementovaná koncepcia write-ahead log. S jej pomocou sa na každú zmenu v údajoch vytvorí záznam v malom súbore write-ahead log.

Každý záznam pred kontrolným bodom sa v nich ukladá. Pre tieto súbory nastavujeme veľkosť – napríklad 64 MB. Keď sa zaplní, záznam sa začne zapisovať do druhého súboru. A po reštarte sa Tarantool obnovuje z posledného kontrolného bodu a potom aplikuje všetky neskoršie transakcie do momentu zastavenia.

Aby sa taký záznam realizoval, je potrebné uviesť možnosť v nastaveniach box.cfg (v súbore example.lua):

wal_mode = "write";

Používanie údajov

S tým, čo sme teraz napísali, môžete používať Tarantool na uchovávanie údajov a bude veľmi rýchlo fungovať ako databáza. A teraz najlepšia časť – čo s tým všetkým môžete robiť.

Píšeme aplikáciu

Napríklad napíšeme pre Tarantool takúto aplikáciu

Aplikáciu si pozrite pod spoilerom

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; -- jedna hodina
    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

-- pri prvom spustení vytvoríme tabuľku a nastavíme prístupové práva
box.once('replica', bootstrap)

-- povolenie prístupu k konzole
console = require('console')
console.listen('127.0.0.1:3302')

-- http konfigurácia
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",
                              "Počet API tokenov")

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

Deklarujeme tabuľku v lua, ktorá definuje znaky. Táto tabuľka je potrebná na generovanie náhodného reťazca.

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

Potom deklarujeme funkciu – randomString a nastavíme hodnotu dĺžky v zátvorkách.

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

Následne pripojíme http-router a http-server k nášmu Tarantool serveru, ako aj JSON, ktorý budeme posielať klientovi.

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

Potom spustíme HTTP server na porte 8080 na všetkých rozhraniach, ktorý bude zapisovať všetky požiadavky a chyby.

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

Ďalej vyhlasujeme routu, aby sme ak na port 8080 /count prišla požiadavka s metódou GET, zavolali funkciu z jedného riadku. Táto funkcia vráti status — 200, 404, 403 alebo akýkoľvek iný, ktorý zadáme.

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

V tele vraciame json.encode, kde uvádzame count a getcount, ktorá sa volá a ukazuje počet záznamov v našej databáze.

Druhý spôsob

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)

Kde v riadku router:route({method = ‘GET’, path = ‘\/token’}, function() voláme funkciu a generujeme token.

Riadok local token = randomString(32) – je to náhodný reťazec z 32 znakov.
V riadku local last = box.space.example:len() vyťahujeme posledný prvok.
A v riadku box.space.example:insert{ last + 1, token } zapíšeme do našej databázy údaje, teda jednoducho zvýšime ID o 1. Toto sa dá, mimochodom, urobiť nie len takýmto kostrbatým spôsobom. V Tarantule existujú sekvencie na tento účel.

Zapíšeme tam token.

Takto sme v jednom súbore napísali aplikáciu. V nej môžeme okamžite manipulovať s údajmi a modul box za vás vykoná všetku zložitú prácu.

Ona počúva HTTP a pracuje s údajmi, všetko sa nachádza v jednom inštancii — teda aplikácia aj údaje. Preto sa všetko deje dosť rýchlo.

Na spustenie inštalujeme HTTP modul:

Ako to robíme, pozrite si pod spoilerom

root@test2: # tarantoolctl rocks install http
Inštalovanie http://rocks.tarantool.org/http-scm-1.src.rock
Chýbajúce závislosti pre http scm-1:
   checks >= 3.0.1 (nie je nainštalované)

http scm-1 závisí od checks >= 3.0.1 (nie je nainštalované)
Inštalovanie http://rocks.tarantool.org/checks-3.0.1-1.rockspec

Klónoje sa do 'checks'...
remote: Prezeranie objektov: 28, hotovo.
remote: Počítanie objektov: 100% (28/28), hotovo.
remote: Kompresia objektov: 100% (19/19), hotovo.
remote: Celkom 28 (delta 1), znovu použité 16 (delta 1), balík-znovu použitý 0
Prijímanie objektov: 100% (28/28), 12.69 KiB | 12.69 MiB/s, hotovo.
Riešenie delt: 100% (1/1), hotovo.
Poznámka: kontrola '580388773ef11085015b5a06fe52d61acf16b201'.

Nachádzate sa v stave 'odpojené HEAD'. Môžete sa pozrieť, urobiť experimentálne
změny a potvrdiť ich, a môžete zrušiť akékoľvek potvrdenia, ktoré urobíte v tomto
stavom bez ovplyvnenia akýchkoľvek vetiev vykonaním ďalšej kontroly.

Ak chcete vytvoriť novú vetvu, aby ste si udržali potvrdenia, ktoré vytvárate, môžete
tak urobiť (teraz alebo neskôr) pomocou -b s príkazom checkout znova. Príklad:

  git checkout -b 

Žiadny existujúci manifest. Pokus o obnovu...
checks 3.0.1-1 je teraz nainštalované v /.rocks (licencia: BSD)

-- Identifikácia C kompilátora je GNU 7.5.0
-- Kontrola funkčného C kompilátora: /usr/bin/cc
-- Kontrola funkčného C kompilátora: /usr/bin/cc -- funguje
-- Zisťovanie C kompilátor ABI info
-- Zisťovanie C kompilátor ABI info - hotovo
-- Zisťovanie C kompilátor funkcií
-- Zisťovanie C kompilátor funkcií - hotovo
-- Nájdené TARANTOOL: /usr/include (nájdená verzia "2.4.2-80-g18f2bc82d")
-- Tarantool LUADIR je /.rocks/share/tarantool/rocks/http/scm-1/lua
-- Tarantool LIBDIR je /.rocks/share/tarantool/rocks/http/scm-1/lib
-- Konfigurácia je hotová
-- Generovanie je hotové
CMake Varovanie:
  Manuálne špecifikované premenné neboli použité projektom:

    version


-- Súbory na zostavenie boli napísané do: /tmp/luarocks_http-scm-1-V4P9SM/http/build.luarocks
Skenovanie závislostí cieľa httpd
[ 50%] Budovanie C objektu http/CMakeFiles/httpd.dir/lib.c.o
V súbore zahrnutom z /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:32:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c: V funkcii ‘tpl_term’:
/usr/include/tarantool/lauxlib.h:144:15: varovanie: toto vyhlásenie môže prepadnúť [-Wimplicit-fallthrough=]
    (*(B)->p++ = (char)(c)))
    ~~~~~~~~~~~^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:62:7: poznámka: v rozšírení makra ‘luaL_addchar’
       luaL_addchar(b, '\');
       ^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:63:6: poznámka: tu
      predvolené:
      ^~~~~~~
V súbore zahrnutom z /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:39:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h: V funkcii ‘tpe_parse’:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:147:9: varovanie: toto vyhlásenie môže prepadnúť [-Wimplicit-fallthrough=]
    typ = TPE_TEXT;
    ~~~~~^~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:149:3: poznámka: tu
   prípad TPE_LINECODE:
   ^~~~
V súbore zahrnutom z /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:40:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h: V funkcii ‘httpfast_parse’:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:372:22: varovanie: toto vyhlásenie môže prepadnúť [-Wimplicit-fallthrough=]
                 kód = 0;
                 ~~~~~^~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:374:13: poznámka: tu
             prípad stav:
             ^~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:393:23: varovanie: toto vyhlásenie môže prepadnúť [-Wimplicit-fallthrough=]
                 stav = správa;
                 ~~~~~~^~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:395:13: poznámka: tu
             prípad správa:
             ^~~~
[100%] Prepojenie C zdieľanej knižnice lib.so
[100%] Zostavený cieľ httpd
[100%] Zostavený cieľ httpd
Nainštalujte projekt...
-- Konfigurácia inštalácie: "Debug"
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/VERSION.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lib/http/lib.so
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/init.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/tsgi_adapter.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/nginx_server/init.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/init.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/fs.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/matching.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/middleware.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/request.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/response.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/tsgi.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/utils.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/mime_types.lua
-- Inštalácia: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/codes.lua
http scm-1 je teraz nainštalované v /.rocks (licencia: BSD)

root@test2: /

Na spustenie budeme potrebovať prometheus:

root@test2:~# tarantoolctl rocks install prometheus
Inštalácia http://rocks.tarantool.org/prometheus-scm-1.rockspec

Klónovanie do 'prometheus'...
remote: Vymenovanie objektov: 19, hotovo.
remote: Počítanie objektov: 100% (19/19), hotovo.
remote: Komprimovanie objektov: 100% (19/19), hotovo.
remote: Celkovo 19 (delta 2), znovu použité 5 (delta 0), pack-reused 0
Prijímanie objektov: 100% (19/19), 10.73 KiB | 10.73 MiB/s, hotovo.
Riešenie deltas: 100% (2/2), hotovo.
prometheus scm-1 je teraz nainštalovaný v /.rocks (licencia: BSD)

root@test2:~#

Spúšťame a môžeme sa obracať na moduly

root@test2:~# curl -D - -s http://127.0.0.1:8080/token
HTTP/1.1 200 Ok
Dĺžka obsahu: 44
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Pripojenie: keep-alive

{"token":"e2tPq9l5Z3QZrewRf6uuoJUl3lJgSLOI"}

root@test2:~# curl -D - -s http://127.0.0.1:8080/token
HTTP/1.1 200 Ok
Dĺžka obsahu: 44
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Pripojenie: keep-alive

{"token":"fR5aCA84gj9eZI3gJcV0LEDl9XZAG2Iu"}

root@test2:~# curl -D - -s http://127.0.0.1:8080/count
HTTP/1.1 200 Ok
Dĺžka obsahu: 11
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Pripojenie: keep-alive

{"count":2}root@test2:~#

/count отдает нам статус 200.
/token выдает токен и делает запись этого токена в базу.

Testujeme rýchlosť

Spustime benchmark na 50 000 požiadaviek. Konkurentných požiadaviek bude 500.

root@test2:~# ab -c 500 -n 50000 http://127.0.0.1:8080/token
Toto je ApacheBench, Verzia 2.3 
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licencované Apache Software Foundation, http://www.apache.org/

Benchmarking 127.0.0.1 (buďte trpezliví)
Dokončené 5000 požiadaviek
Dokončené 10000 požiadaviek
Dokončené 15000 požiadaviek
Dokončené 20000 požiadaviek
Dokončené 25000 požiadaviek
Dokončené 30000 požiadaviek
Dokončené 35000 požiadaviek
Dokončené 40000 požiadaviek
Dokončené 45000 požiadaviek
Dokončené 50000 požiadaviek
Dokončené 50000 požiadaviek


Serverový softvér:        Tarantool
Názov hostiteľa servera:        127.0.0.1
Port servera:            8080

Cesta dokumentu:          /token
Dĺžka dokumentu:        44 bajtov

Úroveň konkurencie:      500
Čas potrebný na testy:   14.578 sekúnd
Úplné požiadavky:      50000
Nepodarilo sa požiadaviek:        0
Celkový prenesený:      7950000 bajtov
Prenesené HTML:       2200000 bajtov
Požiadavky za sekundu:    3429.87 [#/sec] (priemer)
Čas na požiadavku:       145.778 [ms] (priemer)
Čas na požiadavku:       0.292 [ms] (priemer, pri všetkých konkurentných požiadavkách)
Prenosová rýchlosť:          532.57 [Kbytes/sec] prijaté

Časy pripojenia (ms)
              min  priemer[+/-sd] medián   max
Pripojenie:        0   10 103.2      0    3048
Spracovanie:    12   69 685.1     15   13538
Čakanie:       12   69 685.1     15   13538
Celkom:         12   78 768.2     15   14573

Percento požiadaviek servisovaných v určitom čase (ms)
  50%     15
  66%     15
  75%     16
  80%     16
  90%     16
  95%     16
  98%     21
  99%     42
 100%  14573 (najdlhšia požiadavka)
root@test2:~#

Tokeny sa vydávajú. A neustále zapisujeme údaje. 99% požiadaviek bolo spracovaných za 42 milisekúnd. Tým pádom máme približne 3500 požiadaviek za sekundu na malom stroji, kde sú 2 jadrá a 4 gigabajty pamäte.

Môžete si tiež vybrať nejaký 50000-token a pozrieť sa na jeho hodnotu.

Môžete používať nielen http, môžete spúšťať funkcie na pozadí, ktoré spracovávajú vaše údaje. Navyše sú k dispozícii rôzne spúšťače. Napríklad, môžete volať funkcie pri aktualizáciách, niečo kontrolovať – riešiť konflikty.

Môžete písať aplikácie-skripty priamo na samotnom serveri databázy bez obmedzení, pripojiť akékoľvek moduly a realizovať akúkoľvek logiku.

Aplikačný server môže pristupovať k externým serverom, odoberať dáta a ukladať ich do svojej databázy. Tieto dáta budú využívať iné aplikácie.

Toto bude robiť samotný Tarantool, a nebude potrebné písať samostatnú aplikáciu.

Na záver

Toto je len prvá časť veľkej práce. Druhá bude čoskoro zverejnená na blogu Mail.ru Group a určite pridáme odkaz na ňu do tohto materiálu.

Ak máte záujem navštevovať akcie, kde online vytvárame také veci a klásť otázky v reálnom čase, pripojte sa k kanálu DevOps by REBRAIN.

Ak potrebujete presun do cloudu alebo máte otázky týkajúce sa vašej infraštruktúry, neváhajte a zanechajte žiadosť.

P.S. Máme 2 bezplatné audity mesačne, možno práve váš projekt bude v ich počte.

Zdroj: habr.com