Öt évvel ezelőtt próbáltam a Tarantool-lal dolgozni, de akkor nem működött nekem. Nemrég azonban tartottam egy webináriumot, ahol a Hadoopról beszéltem, a MapReduce működéséről. Ott megkérdezték tőlem a kérdést: „Miért nem használja a Tarantool-t erre a feladatra?”.
Az érdekesség kedvéért úgy döntöttem, hogy visszatérek hozzá, tesztelem a legújabb verziót - és ezúttal nagyon tetszett a projekt. Most megmutatom, hogyan kell írni egy egyszerű alkalmazást a Tarantoolban, betölteni és ellenőrizni a teljesítményt, és látni fogja, milyen egyszerű és menő minden.
Mi az a Tarantool
A Tarantool ultragyors adatbázisként pozicionálja magát. Bármilyen adatot beírhat oda. Ráadásul replikálja őket, shard – azaz hatalmas mennyiségű adatot ossza szét több szerver között, és egyesítse az eredményeket azokból – hozzon létre hibatűrő master-master kapcsolatokat.
Másodszor, ez egy alkalmazásszerver. Írhatod rá az alkalmazásaidat, dolgozhatsz adatokkal, például bizonyos szabályok szerint törölheted a háttérben a régi bejegyzéseket. Közvetlenül a Tarantulába írhat egy Http szervert, amely az adatokkal fog működni: adja meg a számukat, írjon oda új adatokat és redukálja le az egészet egy masterre.
Olvastam egy cikket arról, hogy a srácok 300 soros üzenetsort hoztak létre, ami csak tép és ver – másodpercenként 20 000 üzenet minimális a teljesítményük. Itt tényleg meg lehet fordulni és írni egy nagyon nagy alkalmazást, és ezek nem lesznek tárolva, mint a PostgreS-ben.
Körülbelül egy ilyen szerver, csak egyszerű, megpróbálom leírni ebben a cikkben.
Telepítés
A teszthez három szabványos virtuális gépet indítottam el – egy 20 gigabájtos merevlemezt, az Ubuntu 18.04-et. 2 virtuális CPU és 4 gigabájt memória.
Telepítjük a Tarantool-t - futtassunk egy bash szkriptet vagy adjunk hozzá egy adattárat, és telepítsük a Tarantool-t. Link a szkripthez - (curl -L | VER=2.4 sudo -E bash). Vannak olyan parancsaink, mint:
tarantoolctl a Tarantula példányok kezelésének fő parancsa.
/etc/tarantool - itt található a teljes konfiguráció.
var/log/tarantool - itt vannak a naplók.
var/lib/tarantool - itt vannak az adatok, majd példányokra osztják őket.
Vannak példány-elérhető és példányengedélyező mappák - tartalmazza, hogy mi fog elindulni - a példány konfigurációs fájlja lua kóddal, amely leírja, hogy melyik portokon figyel, milyen memória áll rendelkezésre, Vinyl motor beállításai, indításkor működő kód szerverek, felosztás, sorok, elavult adatok törlése stb.
A példányok úgy működnek, mint a PostgreS-ben. Például egy olyan adatbázis több példányát szeretné futtatni, amely különböző portokon lóg. Kiderült, hogy egy szerveren több adatbázispéldány indul, amelyek különböző portokon lógnak. Teljesen eltérő beállításokkal rendelkezhetnek - az egyik példány egy, a második egy másik logikát valósít meg.
Példánykezelés
Rendelkezünk a tarantoolctl paranccsal, amely lehetővé teszi a Tarantula példányok kezelését. Például a tarantoolctl ellenőrzési példa ellenőrzi a konfigurációs fájlt, és azt mondja, hogy a fájl rendben van, ha nincsenek szintaktikai hibák.
Megtekintheti a példány állapotát - tarantoolctl állapotpélda. Ugyanígy elindíthatja, leállíthatja, újraindíthatja.
Ha egy példány fut, kétféleképpen csatlakozhat hozzá.
1. Adminisztrációs konzol
Alapértelmezés szerint a Tarantool megnyit egy socketet, és sima ASCII szöveget küld a Tarantula vezérléséhez. A konzolhoz való csatlakozás mindig az admin felhasználó alatt történik, nincs hitelesítés, így nem kell kivenni a konzol portot a Tarantula külső vezérléséhez.
Az ilyen módon történő csatlakozáshoz meg kell adnia a Tarantoolctl enter példánynevet. A parancs elindítja a konzolt, és rendszergazdaként csatlakozik. Soha ne tegye ki a konzolportot kívülre – jobb, ha egységaljzatnak hagyja. Ekkor csak azok tudnak majd csatlakozni a Tarantulához, akiknek van írási joguk a foglalathoz.
Ez a módszer adminisztratív dolgokhoz kell. Az adatokkal való munkavégzéshez használja a második módszert - a bináris protokollt.
2. Bináris protokoll használata egy adott porthoz való csatlakozáshoz
A konfigurációban egy figyelési utasítás található, amely megnyitja a portot a külső kommunikáció számára. Ezt a portot bináris protokollal használják, és ott engedélyezve van a hitelesítés.
Ehhez a kapcsolathoz a tarantoolctl connect to portszámot használják. Segítségével távoli szerverekhez kapcsolódhat, hitelesítést használhat és különféle hozzáférési jogokat adhat.
Adatrögzítés és Box modul
Mivel a Tarantool adatbázis- és alkalmazáskiszolgáló is, különféle modulokkal rendelkezik. Érdekel minket a doboz modul - adatokkal való munkát valósít meg. Amikor valamit egy dobozba ír, a Tarantool lemezre írja az adatokat, eltárolja a memóriában, vagy mást csinál vele.
rekord
Például bemegyünk a box modulba, és meghívjuk a box.once függvényt. Ez arra kényszeríti a Tarantool-t, hogy futtassa a kódunkat, amikor a szerver inicializálódik. Létrehozunk egy teret, ahol 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')
-- 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')
endEzt követően létrehozunk egy elsődleges indexet - elsődleges -, amely alapján adatokat kereshetünk. Alapértelmezés szerint, ha nincsenek paraméterek megadva, a primer index minden egyes bejegyzésének első mezője kerül felhasználásra.
Ezután a vendégfelhasználónak egy engedélyt adunk, amely alatt bináris protokollon keresztül csatlakozunk. A teljes példányban engedélyezzük az olvasást, írást és végrehajtást.
A hagyományos adatbázisokhoz képest itt minden nagyon egyszerű. Van helyünk – egy olyan terület, ahol egyszerűen tároljuk az adatainkat. Minden bejegyzést sornak neveznek. MessagePack-be van csomagolva. Ez egy nagyon klassz formátum - bináris és kevesebb helyet foglal - 18 bájt a 27-hez képest.
Nagyon kényelmes vele dolgozni. Szinte minden sor, minden adatbevitel teljesen más oszlopokat tartalmazhat.
A Box.space paranccsal minden teret megtekinthetünk. Egy adott példány kiválasztásához a box.space példát írjuk, és teljes információt kapunk róla.
A Tarantool-ba kétféle motor van beépítve: memória és vinyl. A memória az összes adatot a memóriában tárolja. Ezért minden egyszerűen és gyorsan működik. Az adatok lemezre kerülnek, és van egy írás előre naplózási mechanizmus is, így nem veszítünk semmit, ha a szerver összeomlik.
A vinyl az adatokat a lemezen egy ismertebb formában tárolja - vagyis több adatot tárolhat, mint amennyi memóriánk van, és a Tarantula kiolvassa a lemezről.
Most a memóriá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:
Minden térhez létre kell hozni egy elsődleges indexet, mert enélkül semmi sem fog működni. Mint minden adatbázisban, létrehozzuk az első mezőt - a rekordazonosítót.
Részből áll:
Itt adjuk meg, hogy miből álljon az indexünk. Ez egy részből áll - az első használt mezőből, írja be az unsigned - pozitív egész számot. Ha jól emlékszem a dokumentációból, maximum 18 kvintillió lehet. Sok fantasztikus.
Ezután beszúrhatunk adatokat az insert paranccsal.
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ő elsődleges kulcsként használatos, ezért egyedinek kell lennie. Nem korlátoz minket az oszlopok száma, így annyi adatot szúrhatunk be, amennyit csak akarunk. A fent leírt MessagePack formátumban vannak megadva.
Adatkimenet
Ezután a select paranccsal tudjuk megjeleníteni az adatokat.
A Box.example.select a {1} gombbal megjeleníti a kívánt bejegyzést. Ha kihagyjuk a kulcsot, látni fogjuk az összes rendelkezésünkre álló rekordot. Mindegyik különbözik az oszlopok számában, de itt elvileg nincs oszlopfogalom - vannak mezőszámok.
Abszolút annyi adat lehet, amennyit csak akar. És például a második mezőben kell keresnünk őket. Ehhez új másodlagos indexet készítünk.
box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }})
A Create_index parancsot használjuk.
Másodlagosnak hívjuk.
Ezt követően meg kell adni a paramétereket. Az index típusa FA. Lehet, hogy nem egyedi, ezért írjuk be az Egyedi = false.
Ezután jelezzük, hogy az indexünk mely részekből áll. A mező annak a mezőnek a száma, amelyhez az indexet kötjük, és megadja a karakterlánc típusát. És így jött létre.
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 így nevezhetjük:
unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...
megőrzés
Ha újraindítjuk a példányt, és megpróbáljuk újra hívni az adatokat, látni fogjuk, hogy nincsenek ott – minden üres. Ez azért történik, mert a Tarantool ellenőrzőpontokat készít, és lemezre menti az adatokat, de ha a következő mentés előtt abbahagyjuk a munkát, akkor minden műveletet elveszítünk - mert helyreállunk az utolsó ellenőrzőpontból, ami például két órája volt.
A minden másodperc mentése sem fog működni – mert 20 GB állandóan lemezre helyezése nagyon jó ötlet.
Ehhez találták ki és valósították meg az előre írható napló koncepcióját. Segítségével minden adatmódosításról rekord készül egy kis előre írható naplófájlban.
Minden bejegyzés az ellenőrzőpontig bennük tárolódik. Ezeknél a fájloknál beállítjuk a méretet - például 64 mb. Amikor megtelik, a felvétel elindul a második fájlra. Az újraindítás után a Tarantool helyreáll az utolsó ellenőrzőpontból, majd leállítja az összes későbbi tranzakciót.
Egy ilyen rögzítés végrehajtásához meg kell adnia egy beállítást a box.cfg beállításokban (az example.lua fájlban):
wal_mode = “write”;adathasználat
A most leírtakkal a Tarantula használható adatok tárolására, és nagyon gyorsan fog működni adatbázisként. És most a cseresznye a tortán – mit lehet kezdeni ezzel az egésszel.
Pályázat írása
Például írjunk egy ilyen pályázatot a Tarantulára
Lásd az alkalmazást a spoiler alatt
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()Deklarálunk néhány táblázatot a lua-ban, amely szimbólumokat határoz meg. Ez a táblázat véletlenszerű karakterlánc generálásához szükséges.
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
endEzt követően deklarálunk egy függvényt - randomString, és zárójelben adjuk meg a hossz é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)]
endEzután csatlakoztatjuk a http routert és a http szervert a Tarantula szerverünkhöz, a JSON-hoz, amit átadunk a kliensnek.
local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')Ezt követően a 8080-as portról indulunk az összes http szerver interfészen, amely minden kérést és hibát naplóz.
local httpd = http_server.new('0.0.0.0', 8080, {
log_requests = true,
log_errors = true
})Ezután deklarálunk egy útvonalat, hogy ha a 8080 /count porton érkezik egy kérés GET metódussal, akkor egy sorból hívjuk meg a függvényt. Állapotot ad vissza - 200, 404, 403 vagy bármi, 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-ot adjuk vissza, megadjuk benne a count-ot és a getcount-ot, ami meghívva megmutatja az adatbázisunkban lévő rekordok számát.
A 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)Hol a sorban router:route({method = 'GET', elérési út = '/token'}, function() meghívjuk a függvényt és generálunk egy tokent.
Vonal helyi token = randomString(32) egy 32 karakterből álló véletlenszerű karakterlánc.
Sorban local last = box.space.example:len() kihúzzuk az utolsó elemet.
És a sorban box.space.example:insert{ last + 1, token } beírjuk az adatokat az adatbázisunkba, vagyis egyszerűen megnöveljük az azonosítót 1-gyel. Ezt egyébként nem csak ilyen ügyetlenül meg lehet csinálni. A Tarantulának vannak sorozatai erre az esetre.
Oda írjuk a tokent.
Így egy állományba írtunk egy pályázatot. Az adatokhoz azonnal hozzáférhet, és a dobozmodul elvégzi helyetted az összes piszkos munkát.
http-t hallgat és adatokkal dolgozik, minden egy példányban van - az alkalmazás és az adatok is. Ezért minden elég gyorsan történik.
A futtatáshoz telepítjük a http modult:
Hogyan csináljuk, lásd a spoiler alatt
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:/#Prométheuszra is szükségünk van a futtatáshoz:
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:/#
Elindulunk és hozzáférhetünk a modulokhoz
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:/#
A /count értéke 200.
A /token kiad egy tokent, és beírja az adatbázisba.
Tesztelési sebesség
Futtassunk le egy benchmarkot 50 000 lekérdezésre. A versenyképes kérelmek száma 500 lesz.
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:/#Tokeneket bocsátanak ki. És folyamatosan rögzítjük az adatokat. A kérések 99%-a 42 ezredmásodperc alatt teljesült. Ennek megfelelően másodpercenként körülbelül 3500 kérésünk van egy kis gépen, ahol 2 mag és 4 gigabájt memória van.
Kiválaszthat néhány 50000 XNUMX tokent is, és megnézheti az értékét.
Nem csak http-t használhat, hanem az adatait feldolgozó háttérfunkciókat is futtathat. Ezen kívül vannak különféle triggerek. Például meghívhat funkciókat a frissítéseknél, ellenőrizhet valamit - javíthatja az ütközéseket.
Írhat parancsfájl-alkalmazásokat közvetlenül az adatbázis-kiszolgálón, és nem korlátozza Önt semmi, semmilyen modult csatlakoztathat és bármilyen logikát megvalósíthat.
Az alkalmazásszerver hozzáférhet külső szerverekhez, adatokat gyűjthet és hozzáadhat az adatbázisához. Az adatbázisból származó adatokat más alkalmazások is felhasználják.
Ezt maga a Tarantula fogja megtenni, és nem kell külön pályázatot írni.
Összefoglalva
Ez csak az első része egy nagy munkának. A második hamarosan megjelenik a Mail.ru Group blogon, és ebben az anyagban minden bizonnyal adunk hozzá egy linket.
Ha szeretne részt venni olyan eseményeken, ahol ezeket a dolgokat online hozzuk létre, és valós időben szeretne kérdéseket feltenni, csatlakozzon.
Ha át kell térnie a felhőre, vagy kérdései vannak az infrastruktúrával kapcsolatban, .
PS Havonta 2 ingyenes auditunk van, talán az Ön projektje lesz az egyik ilyen.
Forrás: will.com