🥇A Tarantool lehetővé teszi egy szupergyors adatbázis és az azokkal való munka alkalmazásának ötvözését. Így egyszerűen megvalósítható

Öt évvel ezelőtt kipróbáltam a Tarantoolt, de akkor nem jött be. Nemrég azonban egy webináriumot tartottam, ahol a Hadoopról beszéltem, arról, hogy működik a MapReduce. Ott felmerült a kérdés — "Miért nem használjuk Tarantoolt erre a feladatra?"

Kíváncsiságból úgy döntöttem, hogy visszatérek hozzá, letesztelem az utolsó verziót — és ezúttal a projekt nagyon tetszett. Most megmutatom, hogyan lehet egy egyszerű alkalmazást írni Tarantoolban, megterhelni azt és ellenőrizni a teljesítményt, és láthatják, mennyire egyszerű és menő az egész.

Mi az a Tarantool?

A Tarantool úgy pozicionálja magát, mint egy szupergyors DB. Bármilyen adatot eltárolhat, amit csak szeretne. Ráadásul könnyen replikálhatja, shardingolhatja — azaz egy óriási adatmennyiséget több szerverre oszthat el, és azokat egyesítheti — létrehozhat olyan hibatűrő párosításokat, mint a "master-master".

Másodsorban alkalmazásszerverként funkcionál. Írhat rá saját alkalmazásokat, dolgozhat az adatokkal, például háttérben törölheti a régi rekordokat bizonyos szabályok szerint. Közvetlenül a Tarantoolban írhat egy Http-szervert, amely az adatokkal foglalkozik: kiadja azok mennyiségét, új adatokat rögzíthet és mindezt a masterhez redukálhatja.

Olvastam egy cikket, amelyben a srácok készítettek egy 300 soros üzenetsorozatot, amely egyszerűen szétveri a határokat — minimális teljesítményük 20 000 üzenet másodpercenként. Itt valóban fejest ugorhat, és egy nagyon nagy alkalmazást írhat, és ezek nem tárolt eljárások, mint a PostgreS-nél.

Körülbelül egy ilyen szervert, csak egyszerűt, próbálok leírni ebben a cikkben.

Telepítés

A teszteléshez három standard virtuális gépet indítottam – 20 gigabájt merevlemezzel, Ubuntu 18.04 operációs rendszerrel, 2 virtuális CPU-val és 4 giga memóriával.

Telepítjük a Tarantoolt — elindítjuk a shell scriptet, vagy hozzáadjuk a repót és futtatjuk az apt get install Tarantool parancsot. A script linkje — (curl -L | VER=2.4 sudo -E bash). Itt kapunk olyan parancsokat, mint: https://tarantool.io/installer.sh tarantoolctl

— az alapvető parancs a Tarantool példányok kezelésére. — itt található a teljes konfiguráció.
/etc/tarantool var/log/tarantool
— itt találhatók a naplók. var/lib/tarantool
— itt találhatók az adatok, és azokat a példányok szerint felosztva tároljuk. — itt találhatók az adatok, és azokat a példányok szerint felosztva tároljuk.

Van instance-available és instance-enable mappák találhatók – az utóbbiban van az a fájl, amely elindítódik – egy példány konfigurációs fájlja lua kóddal, amelyben le van írva, hogy milyen portokon hallgat, mennyi memória áll a rendelkezésére, a Vinyl motor beállításai, kód, ami a szerver indításakor aktiválásra kerül, sharding, sorok, elavult adatok törlése és így tovább.

Az instance-ök olyanok, mint a PostgreS. Például, ha több másolatot szeretne indítani az adatbázisból, amely különböző portokon van. Így egy szerveren több adatbázis instance fut, amelyek különböző portokon elérhetők. Teljesen eltérő beállításokkal rendelkezhetnek — az egyik instance egy logikát valósít meg, a másik pedig egy másikat.

Instance-ok kezelése

Van egy tarantoolctl parancsunk, amely lehetővé teszi a Tarantool instance-ok kezelését. Például a tarantoolctl check example ellenőrzi a konfigurációs fájlt, és megmondja – a fájl rendben van, ha nincs benne szintaktikai hiba.

Meg lehet nézni az instance állapotát — a tarantoolctl status example paranccsal. Ugyanígy lehet start, stop, restart parancsokat kiadni.

Amikor az instance elindult, kétféleképpen lehet csatlakozni hozzá.

1. Adminisztratív konzol

Alapértelmezés szerint a Tarantool egy socketet nyit, ahol a Tarantool irányításához szükséges egyszerű ASCII szöveget továbbítanak. A konzolra való csatlakozás mindig admin felhasználóként történik, ott nincs hitelesítés, ezért a konzol portot nem kell külső irányba kitenni a Tarantool irányításához.

Ehhez a kapcsolódáshoz be kell írnia a Tarantoolctl enter instance name parancsot. A parancs elindítja a konzolt és admin felhasználóként csatlakozik. Soha ne helyezze ki a konzol portját kívülre — jobban jár, ha unix socketet hagy. Így a Tarantoolhoz való csatlakozás lehetősége csak azok számára áll fenn, akiknek hozzáférésük van a socket írásához.

Ez a módszer adminisztratív feladatokhoz szükséges. Az adatokkal való munka érdekében használja a második módszert — a bináris protokollt.

2. A bináris protokoll használata a meghatározott porthoz való csatlakozáshoz

A konfigurációban van egy listen direktíva, amely megnyit egy portot a külső kommunikációkhoz. Ezt a portot a bináris protokoll használja, és ott hitelesítés van bekapcsolva.

Ehhez a kapcsolódáshoz a tarantoolctl connect to port number parancsot használja. Ezzel távoli szerverekhez lehet csatlakozni, használni a hitelesítést és különböző hozzáférési jogokat kiosztani.

Adatok írása és a Box modul

Mivel a Tarantool egyaránt adatbázis és alkalmazásszerver, különböző modulok találhatók benne. Minket a box modul érdekel — ez valósítja meg az adatok kezelését. Amikor valamit a box-ba írsz, a Tarantool adatokat ír a lemezre, memóriába menti azokat, vagy más műveleteket végez velük.

Írás

Például belépünk a box modulba, és meghívjuk a box.once függvényt. Ez arra kényszeríti a Tarantoolt, hogy indítsa el a kódunkat a szerver inicializálásakor. Létrehozunk egy teret, amelyben az adatainkat tároljuk.

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

    -- Biztonságosabb mindent alapértelmezés szerint
    -- box.schema.user.create('example', { password = 'secret' })
    -- box.schema.user.grant('example', 'replication')
    -- box.schema.user.grant('example', 'read,write,execute', 'space', 'example')
end

Ezután létrehozzuk az elsődleges indexet – primary – amelyre keresni lehet az adatokat. Alapértelmezés szerint, ha nem adunk meg paramétereket, az első mezőt használja majd minden rekordnál az elsődleges indexhez.

Ezután engedélyt adunk a vendég felhasználónak, amely alatt a bináris protokollon csatlakozunk. Engedélyezzük az olvasást, írást és futtatást az egész példányban.

Ha összehasonlítjuk a hagyományos adatbázisokkal, itt minden elég egyszerű. Van egy területünk – space – amely egyszerűen tárolja az adatainkat. Minden rekordot tuple-nak hívunk. Az MessagePack formátumban van csomagolva. Ez egy nagyon klassz formátum — bináris, és kevesebb helyet foglal — 18 byte a 27-hez képest.

Könnyű vele dolgozni. Szinte minden sor, minden adat rekord teljesen különböző oszlopokat tartalmazhat.

Az összes space-t meg tudjuk nézni a Box.space parancs segítségével. Ha egy adott példányt szeretnénk kiemelni – írjuk be a box.space example parancsot, és teljes információt kapunk róla.

A Tarantool két típusú motorral rendelkezik: Memory és Vinyl. A Memory minden adatot a memóriában tárol. Ezért minden egyszerűen és gyorsan működik. Az adatok lementésre kerülnek a lemezre, és létezik egy write ahead log mechanizmus is, így nem veszítünk semmit a szerver leállásakor.

A Vinyl a lemezen tárolja az adatokat a számunkra ismertebb formátumban — tehát többet lehet tárolni, mint amennyi memória rendelkezésre áll, és a Tarantool leolvassa őket a lemezről.

Most a Memory-t fogjuk használni.

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:

Az elsődleges indexet minden egyes térhez létre kell hozni, mert nélküle semmi sem működik. Mint minden adatbázisban, itt is létrehozzuk az első mezőt – a rekord azonosítóját.

Részek:

Itt határozzuk meg, hogy az indexünk miből áll. Csak egy részből áll – az első mező, amelyet használni fogunk, unsigned típussal – pozitív egész szám. Amennyire emlékszem a dokumentációból, a maximális szám, amely lehet – 18 kvadrillió. Hatalmas mennyiség.

Ezután az insert parancs segítségével tudunk beilleszteni adatokat.

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>

Az első mezőt elsődleges kulcsként használjuk, ezért annak egyedinek kell lennie. A mezők számának nincs korlátja, ezért bármennyi adatot beilleszthetünk. Ezek MessagePack formátumban vannak megadva, amelyről korábban beszéltem.

Adatok kiírása

Ezután a select parancs segítségével írhatunk ki adatokat.

A Box.example.select a {1} kulcs megadásával ki fogja írni a megfelelő rekordot. Ha kihagyjuk a kulcsot, akkor az összes rekordot látni fogjuk, amit tárolunk. Ezek különböző mennyiségű mezővel bírnak, de itt alapvetően nincsenek oszlopok – csak mezőszámok vannak.

Abszolút bármennyi adat lehet. Például, ha a második mező alapján szeretnénk keresni, akkor új másodlagos indexet kell létrehozzunk.


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

A Create_index parancsot használjuk.
A nevét Secondary-ra állítjuk.

Ezután meg kell adni a paramétereket. Az index típusa - TREE. Ez nem lehet egyedi, tehát beírjuk az Unique = false értéket.

Végül megadjuk, hogy az index miből áll. A Field a mező száma, amelyhez az indexet hozzárendeljük, és megadjuk a típust, amely string. És voilà, meg is van.

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>

Most már így hívhatjuk:

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

Mentés

Ha újraindítjuk az instance-t és megpróbáljuk újra elérni az adatokat, akkor azt fogjuk látni, hogy azok nincsenek ott — minden üres. Ez azért történik, mert a Tarantool ellenőrzi a pontokat és menti az adatokat a lemezre, de ha leállítjuk a működést a legközelebbi mentés előtt, akkor minden műveletet elveszítünk — mert az utolsó ellenőrzési pontból állunk vissza, ami például két órával ezelőtt volt.

Minden másodpercben menteni sem lehetséges — mert folyamatosan 20 Gb-t dumpolni a lemezre — nem túl jó ötlet.

Erre kifejlesztették és megvalósították a write-ahead log koncepcióját. Ennek segítségével minden adatváltozáshoz egy bejegyzés készül egy kis write-ahead log fájlban.

Minden bejegyzést az ellenőrzési pontig ezekben mentünk el. Ezekhez a fájlokhoz beállítjuk a méretet — például 64 mb. Amikor megtelik, a bejegyzés a második fájlba kezd el folyni. A Tarantool a legutolsó ellenőrzési pontból áll helyre, majd alkalmazza az összes későbbi tranzakciót a leállításig.

Ehhez a bejegyzéshez be kell állítani egy opciót a box.cfg beállításokban (a example.lua fájlban):

wal_mode = “write”;

Adatok használata

A most írtakkal lehetőséget ad a Tarantulnak adatok tárolására, és nagyon gyorsan működik mint adatbázis. És most itt a torta legszebb része – hogy mit lehet mindezzel csinálni.

Alkalmazás írása

Például írjunk egy ilyen alkalmazást a Tarantul számára

Az alkalmazást a spoiler alatt tekintheti meg

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; -- egy óra
    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

-- az első futáshoz hozzunk létre egy teret és állítsuk be a jogosultságokat
box.once('replica', bootstrap)

-- konzol hozzáférés engedélyezése
console = require('console')
console.listen('127.0.0.1:3302')

-- http konfiguráció
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 Száma")

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

Kihirdetünk egy Lua táblát, amely meghatározza a karaktereket. Ezt a táblát a véletlenszerű sztring generálásához használjuk.

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

Ezután bejelentjük a randomString függvényt, és megadjuk a zárójelben a hosszúság értékét.

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

Majd csatlakoztatjuk az http-routert és az http-szervert a Tarantool szerverünkhöz, JSON-t, amelyet a kliensnek fogunk visszaadni.

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

Ezután elindítjuk a http szervert a 8080-as porton minden interfészen, amely naplózni fogja az összes kérést és hibát.

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

Ezután definiáljuk az útvonalat, hogy ha a 8080-as porton /count érkezik egy GET módszerű kérés, akkor egy egyvonalas függvényt hívunk meg. Ez visszaadja a státuszt — 200, 404, 403 vagy bármely más, amit megadunk.

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

A törzsben a json.encode-t használva visszaadjuk a count-ot és a getcount-ot, amelyet meghívunk, és megjeleníti a nyilvántartások számát az adatbázisunkban.

Második módszer

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)

A sorban router:route({method = ‘GET’, path = ‘\/token’}, function() meghívjuk a függvényt és generáljuk a tokent.

A sor local token = randomString(32) – 32 karakterből álló véletlenszerű karakterlánc.
A sorban local last = box.space.example:len() kivesszük az utolsó elemet.
A sorban box.space.example:insert{ last + 1, token } beírjuk az adatbázisunkba az adatokat, tehát egyszerűen csak növeljük az ID-t 1-el. Ezt egyébként nem csak ilyen nehézkes módon lehet megtenni. A Tarantoolban vannak szekvenciák erre.

Beírjuk oda a tokent.

Így egyetlen fájlban írtuk meg az alkalmazást. Az adatokkal azonnal kapcsolatba léphetünk, és a box modul mindent elintéz helyettünk.

Ez http-t hallgat és az adatokkal dolgozik, minden egy egységes példányban található — és az alkalmazás, és az adatok. Ezért minden elég gyorsan zajlik.

A telepítéshez telepítjük a http modult:

Hogyan csináljuk ezt, nézd meg a spoiler alatt

root@test2:/${tarantoolctl rocks install http
Installing http://rocks.tarantool.org/http-scm-1.src.rock
Hiányzó függőségek a http scm-1 számára:
   checks >= 3.0.1 (nincs telepítve)

A http scm-1 a checks >= 3.0.1-re támaszkodik (nincs telepítve)
Installing http://rocks.tarantool.org/checks-3.0.1-1.rockspec

Klónozás a 'checks'-be...
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.
Megjegyzés: '580388773ef11085015b5a06fe52d61acf16b201' kiretetés.

'leválasztott HEAD' állapotban vagy. Körülnézhetsz, kísérleti
változtatásokat végezhetsz és elmentheted őket, és
ezek a bizonylatok jönnek az állapotban, anélkül, hogy bármilyen ágat befolyásolnál egy újabb checkout végrehajtásával.

Ha új ágat akarsz létrehozni a bizonylatok megőrzéséhez, akkor azt
megteheted (most vagy később) a -b használatával a checkout parancs során. Például:

  git checkout -b 

Nincs meglévő manifeszt. Kísérlet újbóli építésére...
checks 3.0.1-1 most telepítve van a /.rocks-ban (licenc: BSD)

-- A C fordító azonosítása: GNU 7.5.0
-- Ellenőrzés a működő C fordítóért: /usr/bin/cc
-- Ellenőrzés a működő C fordítóért: /usr/bin/cc -- működik
-- C fordító ABI információinak felismerése
-- C fordító ABI információinak felismerése - kész
-- C fordító funkciók érzékelése
-- C fordító funkciók érzékelése - kész
-- TARANTOOL megtalálva: /usr/include (verzió találva: "2.4.2-80-g18f2bc82d")
-- Tarantool LUADIR a /.rocks/share/tarantool/rocks/http/scm-1/lua
-- Tarantool LIBDIR a /.rocks/share/tarantool/rocks/http/scm-1/lib
-- Konfigurálás kész
-- Generálás kész
CMake Figyelmeztetés:
  Manuálisan megadott változók nem lettek felhasználva a projekten:

    version


-- A build fájlok írásra kerültek: /tmp/luarocks_http-scm-1-V4P9SM/http/build.luarocks
Célzott httpd függőségeinek átvizsgálása
[ 50%] C objektum építése http/CMakeFiles/httpd.dir/lib.c.o
A fájl a következőből származik: /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:32:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c: A 'tpl_term' függvényben:
/usr/include/tarantool/lauxlib.h:144:15: figyelmeztetés: ez az állítás leeshet [-Wimplicit-fallthrough=]
    (*(B)->p++ = (char)(c)))
    ~~~~~~~~~~~^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:62:7: megjegyzés: a 'luaL_addchar' makró kibővítésekor
       luaL_addchar(b, '\');
       ^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:63:6: megjegyzés: itt
      alapértelmezett:
      ^~~~~~~
A fájl a következőből származik: /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:39:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h: A 'tpe_parse' függvényben:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:147:9: figyelmeztetés: ez az állítás leeshet [-Wimplicit-fallthrough=]
    type = TPE_TEXT;
    ~~~~~^~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:149:3: megjegyzés: itt
   case TPE_LINECODE:
   ^~~~
A fájl a következőből származik: /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:40:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h: A 'httpfast_parse' függvényben:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:372:22: figyelmeztetés: ez az állítás leeshet [-Wimplicit-fallthrough=]
                 code = 0;
                 ~~~~~^~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:374:13: megjegyzés: itt
             case status:
             ^~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:393:23: figyelmeztetés: ez az állítás leeshet [-Wimplicit-fallthrough=]
                 state = message;
                 ~~~~~~^~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:395:13: megjegyzés: itt
             case message:
             ^~~~
[100%] C megosztott könyvtár linkelése lib.so
[100%] C építési cél megépítése
[100%] C építési cél megépítése
A projekt telepítése...
-- Telepítési konfiguráció: "Debug"
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/VERSION.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lib/http/lib.so
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/init.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/tsgi_adapter.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/nginx_server/init.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/init.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/fs.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/matching.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/middleware.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/request.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/response.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/tsgi.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/utils.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/mime_types.lua
-- Telepítés: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/codes.lua
http scm-1 most telepítve van a /.rocks-ban (licenc: BSD)

root@test2:/${

A prometheus indítása is szükséges.

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 most már telepítve van a /.rocks könyvtárba (licenc: BSD)

root@test2:~#

Indítjuk, és elérhetjük a modulokat.

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

{"token":"e2tPq9l5Z3QZrewRf6uuoJUl3lJgSLOI"}

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

{"token":"fR5aCA84gj9eZI3gJcV0LEDl9XZAG2Iu"}

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

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

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

Teszteljük a sebességet.

Indítsuk el a benchmarkot 50 000 lekérdezésre. A párhuzamos lekérdezések száma 500 lesz.

root@test2:~# ab -c 500 -n 50000 http://127.0.0.1:8080/token
This is ApacheBench, Version 2.3 
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 (legyél türelemmel)
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 (leghosszabb kérés)
root@test2:~#

Tokenek kiadásra kerülnek. Folyamatosan rögzítjük az adatokat. A lekérdezések 99%-a 42 milliszekundumban feldolgozásra került. Ez körülbelül 3500 lekérdezést jelent másodpercenként egy kis gépen, ahol 2 mag és 4 gigabyte memória található.

Egy 50 000-es tokent is kiválaszthatunk, és megnézhetjük az értékét.

Nemcsak http-t használhatunk, hanem háttérfunkciókat is indíthatunk, amelyek feldolgozzák az adatait. Továbbá különféle triggereket is használhatunk. Például funkciókat hívhat meg frissítésekkor, ellenőrizhet valamit – megoldhatja a konfliktusokat.

Alkalmas alkalmazás-szkripteket közvetlenül az adatbázis szerverén írni, korlátozások nélkül, bármilyen modult csatlakoztatva és bármilyen logikát megvalósítva.

Az alkalmazásszerver külső szerverekhez férhet hozzá, adatokat gyűjthet be és tárolhatja az adatbázisában. Ezeket az adatokat más alkalmazások fogják felhasználni.

Ezt maga Tarantool fogja megtenni, nem szükséges külön alkalmazást írni.

Végül

Ez csak a nagy munka első része. A második részt hamarosan közzéteszik a Mail.ru Group blogján, és mindenképp hozzáadjuk a linket ehhez a anyaghoz.

Ha érdekli, hogy részt vegyen olyan eseményeken, ahol ezeket az dolgokat online készítjük, és valós időben kérdéseket tehet fel, csatlakozzon a DevOps by REBRAIN csatornához.

Ha felhőbe szeretne költözni, vagy kérdései vannak az infrastruktúrával kapcsolatban, nyugodtan küldje el a jelentkezését..

P.S. Havonta 2 ingyenes auditunk van, lehet, hogy éppen az Ön projektje lesz az egyik.

Forrás: habr.com