Před pěti lety jsem zkoušel pracovat s Tarantoolem, ale pak mi to nefungovalo. Ale nedávno jsem pořádal webinář, kde jsem mluvil o Hadoopu, o tom, jak funguje MapReduce. Tam jsem dostal otázku - "Proč k tomuto úkolu nepoužít Tarantool?".
Pro zajímavost jsem se k tomu rozhodl vrátit, otestovat nejnovější verzi – a tentokrát se mi projekt moc líbil. Nyní ukážu, jak v Tarantool napsat jednoduchou aplikaci, načíst ji a zkontrolovat výkon a uvidíte, jak je tam vše snadné a cool.
Co je Tarantool
Tarantool se staví jako ultrarychlá databáze. Můžete si tam dát jakákoliv data, která chcete. Navíc je replikujte, shard – to znamená, že rozdělíte obrovské množství dat na několik serverů a zkombinujete výsledky z nich – vytvoříte propojení master-master odolná proti chybám.
Za druhé je to aplikační server. Můžete na něm psát své aplikace, pracovat s daty, například mazat staré záznamy na pozadí podle určitých pravidel. Přímo v Tarantule můžete napsat Http server, který bude pracovat s daty: rozdejte jejich číslo, zapište tam nová data a vše zredukujte na master.
Četl jsem článek o tom, jak kluci udělali 300řádkovou frontu zpráv, která se jen trhá a mlátí - mají minimální výkon 20 000 zpráv za sekundu. Zde se můžete opravdu otočit a napsat velmi rozsáhlou aplikaci a ty se nebudou ukládat jako v PostgreSu.
Přibližně takový server, jen jednoduchý, se pokusím popsat v tomto článku.
Instalace
Pro test jsem spustil tři standardní virtuální stroje – 20gigabajtový pevný disk, Ubuntu 18.04. 2 virtuální CPU a 4 gigabajty paměti.
Nainstalujeme Tarantool - spusťte bash skript nebo přidejte úložiště a proveďte apt get install Tarantool. Odkaz na skript - (curl -L | VER=2.4 sudo -E bash). Máme příkazy jako:
tarantoolctl je hlavní příkaz pro správu instancí Tarantule.
/etc/tarantool - zde leží celá konfigurace.
var/log/tarantool - tady jsou protokoly.
var/lib/tarantool - zde leží data a pak jsou rozdělena do instancí.
Existují složky dostupné pro instance a složky umožňující instance - obsahuje to, co se bude spouštět - konfigurační soubor instance s kódem lua, který popisuje, na kterých portech poslouchá, jaká paměť je pro ni dostupná, nastavení Vinyl engine, kód, který funguje při startu servery, sharding, fronty, mazání zastaralých dat a tak dále.
Instance fungují jako v PostgreS. Chcete například spustit více kopií databáze, která visí na různých portech. Ukazuje se, že na jednom serveru je spuštěno několik instancí databáze, které visí na různých portech. Mohou mít zcela odlišná nastavení - jedna instance implementuje jednu logiku, druhá - další.
Správa instancí
Máme příkaz tarantoolctl, který nám umožňuje spravovat instance Tarantule. Například kontrolní příklad tarantoolctl zkontroluje konfigurační soubor a řekne, že soubor je v pořádku, pokud nejsou žádné syntaktické chyby.
Můžete vidět stav instance - příklad stavu tarantoolctl. Stejným způsobem můžete spustit, zastavit, restartovat.
Jakmile je instance spuštěna, existují dva způsoby, jak se k ní připojit.
1. Administrativní konzole
Ve výchozím nastavení Tarantool otevře soket a odešle prostý ASCII text k ovládání Tarantule. Připojení ke konzoli vždy probíhá pod uživatelem admin, neexistuje žádná autentizace, takže pro ovládání Tarantuly zvenčí nemusíte vyjímat port konzoly.
Chcete-li se připojit tímto způsobem, musíte zadat název instance Tarantoolctl. Příkaz spustí konzolu a připojí se jako uživatel admin. Nikdy nevystavujte port konzoly vnějšku - je lepší jej ponechat jako zásuvku jednotky. Pak se k Tarantule budou moci připojit pouze ti, kteří mají přístup pro zápis do zásuvky.
Tento způsob je potřeba pro administrativní věci. Pro práci s daty použijte druhý způsob - binární protokol.
2. Použití binárního protokolu pro připojení ke konkrétnímu portu
V konfiguraci je direktiva listen, která otevírá port pro externí komunikaci. Tento port se používá s binárním protokolem a je zde povolena autentizace.
Pro toto připojení se používá tarantoolctl connect to port number. Pomocí něj se můžete připojit ke vzdáleným serverům, používat autentizaci a udělovat různá přístupová práva.
Modul pro záznam dat a schránku
Protože Tarantool je databázový i aplikační server, má různé moduly. Zajímá nás modul box - implementuje práci s daty. Když něco zapíšete do krabice, Tarantool zapíše data na disk, uloží je do paměti nebo s nimi udělá něco jiného.
Záznam
Například vstoupíme do modulu box a zavoláme funkci box.once. Přinutí Tarantool ke spuštění našeho kódu, když je server inicializován. Vytváříme prostor, kde budou naše data uložena.
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')
endPoté vytvoříme primární index - primární - pomocí kterého můžeme vyhledávat data. Standardně, pokud nejsou zadány žádné parametry, bude použito první pole v každé položce pro index primeru.
Poté provedeme grant hostujícímu uživateli, pod kterým se připojíme přes binární protokol. Umožňujeme čtení, zápis a spouštění v celé instanci.
Ve srovnání s konvenčními databázemi je zde vše velmi jednoduché. Máme prostor – oblast, ve které jsou naše data jednoduše uložena. Každý záznam se nazývá n-tice. Je zabalen v balíčku MessagePack. Toto je velmi skvělý formát – je binární a zabírá méně místa – 18 bajtů oproti 27.
Je docela pohodlné s ním pracovat. Téměř každý řádek, každý záznam dat může mít úplně jiné sloupce.
Všechny prostory můžeme zobrazit pomocí příkazu Box.space. Pro výběr konkrétní instance napíšeme box.space example a získáme o ní úplné informace.
Tarantool obsahuje dva typy motorů: paměť a vinyl. Paměť ukládá všechna data do paměti. Vše proto funguje jednoduše a rychle. Data se ukládají na disk a je zde také mechanismus zápisu dopředu, takže v případě zhroucení serveru nic neztratíme.
Vinyl ukládá data na disk ve známější podobě – to znamená, že můžete uložit více dat, než máme paměti, a Tarantula je načte z disku.
Nyní použijeme paměť.
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ární index musí být vytvořen pro jakýkoli prostor, protože bez něj nebude nic fungovat. Jako v každé databázi vytvoříme první pole – ID záznamu.
Části:
Zde specifikujeme, z čeho se náš index skládá. Skládá se z jedné části – prvního pole, které budeme používat, zadejte unsigned – kladné celé číslo. Pokud si pamatuji z dokumentace, maximální počet, který může být, je 18 kvintilionů. Hodně úžasných.
Data pak můžeme vložit pomocí pří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>První pole se používá jako primární klíč, takže musí být jedinečné. Nejsme omezeni počtem sloupců, takže si tam můžeme vkládat tolik dat, kolik chceme. Jsou specifikovány ve formátu MessagePack, který jsem popsal výše.
Výstup dat
Poté můžeme data zobrazit příkazem select.
Box.example.select pomocí tlačítka {1} zobrazí požadovaný záznam. Pokud klíč vynecháme, uvidíme všechny záznamy, které máme. Všechny se liší počtem sloupců, ale zde v zásadě neexistuje žádný koncept sloupců - existují čísla polí.
Údajů může být absolutně tolik, kolik chcete. A například je musíme hledat ve druhém poli. Za tímto účelem vytvoříme nový sekundární index.
box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }})
Použijeme příkaz Create_index.
Říkáme tomu sekundární.
Poté musíte zadat parametry. Typ indexu je TREE. Nemusí být unikátní, proto zadáme Unique = false.
Poté uvedeme, z jakých částí se náš index skládá. Pole je číslo pole, ke kterému vážeme index, a určuje typ řetězce. A tak to vzniklo.
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>Nyní to můžeme nazvat takto:
unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...
konzervace
Pokud restartujeme instanci a pokusíme se volat data znovu, uvidíme, že tam nejsou - vše je prázdné. Děje se tak proto, že Tarantool dělá kontrolní body a ukládá data na disk, ale pokud přestaneme pracovat před dalším uložením, přijdeme o všechny operace – obnovíme se totiž z posledního kontrolního bodu, který byl například před dvěma hodinami.
Ukládat každou sekundu také nebude fungovat – protože neustále vyhazovat 20 GB na disk je takový nápad.
Za tímto účelem byl vynalezen a implementován koncept zápisu napřed. S jeho pomocí se pro každou změnu v datech vytvoří záznam v malém souboru protokolu pro zápis dopředu.
Je v nich uložen každý vstup až ke kontrolnímu bodu. U těchto souborů nastavíme velikost – například 64 mb. Když se zaplní, záznam začne přecházet do druhého souboru. A po restartu se Tarantool zotaví z posledního kontrolního bodu a poté přetočí všechny pozdější transakce, dokud se nezastaví.
Chcete-li provést takový záznam, musíte zadat volbu v nastavení box.cfg (v souboru example.lua):
wal_mode = “write”;využití dat
S tím, co jsme nyní napsali, můžete Tarantulu použít k ukládání dat a jako databáze bude fungovat velmi rychle. A teď třešnička na dortu – co se s tím vším dá dělat.
Psaní aplikace
Napišme si například takovou aplikaci pro Tarantule
Viz aplikace pod spoilerem
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()Deklarujeme nějakou tabulku v lua, která definuje symboly. Tato tabulka je potřebná pro generování náhodného řetězce.
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
endPoté deklarujeme funkci - randomString a uvedeme hodnotu délky v závorká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)]
endPoté připojíme http router a http server k našemu Tarantula serveru JSON, který dáme klientovi.
local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')Poté začneme na portu 8080 na všech rozhraních http serveru, který bude protokolovat všechny požadavky a chyby.
local httpd = http_server.new('0.0.0.0', 8080, {
log_requests = true,
log_errors = true
})Dále deklarujeme cestu, že pokud požadavek s metodou GET dorazí na port 8080 /count, pak funkci zavoláme z jednoho řádku. Vrací stav - 200, 404, 403 nebo cokoliv, co určíme.
router:route({method = 'GET', path = '/count'}, function()
return {status = 200, body = json.encode({count = get_count()})}
end)V těle vrátíme json.encode, zadáme count a v něm getcount, který se volá a ukazuje počet záznamů v naší databázi.
Druhá metoda
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 řadě router:route({method = 'GET', cesta = '/token'}, function() zavoláme funkci a vygenerujeme token.
Řetězec místní token = randomString(32) je náhodný řetězec 32 znaků.
V souladu local last = box.space.example:len() vytáhneme poslední prvek.
A v řadě box.space.example:insert{ poslední + 1, token } data zapíšeme do naší databáze, tedy jednoduše zvýšíme ID o 1. Dá se to mimochodem udělat nejen takto neohrabaně. Tarantule má pro tento případ sekvence.
Napíšeme tam token.
Napsali jsme tedy aplikaci v jednom souboru. K datům se dostanete hned a box modul udělá všechnu špinavou práci za vás.
Poslouchá http a pracuje s daty, vše je v jediné instanci – aplikace i data. Proto se vše děje poměrně rychle.
Pro spuštění nainstalujeme http modul:
Jak to děláme, podívejte se pod spoiler
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:/#Ke spuštění také potřebujeme promethea:
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:/#
Spustíme a můžeme přistupovat k modulům
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 nám dává stav 200.
/token vydá token a zapíše tento token do databáze.
Testovací rychlost
Spusťte benchmark pro 50 000 požadavků. Konkurenční požadavky budou 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:/#Vydávají se tokeny. A neustále zaznamenáváme data. 99 % požadavků bylo dokončeno za 42 milisekund. Podle toho máme asi 3500 požadavků za sekundu na malém počítači, kde jsou 2 jádra a 4 gigabajty paměti.
Můžete si také vybrat nějakých 50000 XNUMX tokenů a zobrazit jejich hodnotu.
Můžete používat nejen http, ale spouštět funkce na pozadí, které zpracovávají vaše data. Navíc existují různé spouštěče. Můžete například volat funkce na aktualizace, něco zkontrolovat - opravit konflikty.
Skriptové aplikace můžete psát přímo v samotném databázovém serveru a nebýt ničím omezováni, připojovat libovolné moduly a implementovat libovolnou logiku.
Aplikační server může přistupovat k externím serverům, shromažďovat data a přidávat je do své databáze. Data z této databáze budou využívána jinými aplikacemi.
To provede sám Tarantule a není třeba psát samostatnou aplikaci.
Konečně,
Toto je jen první část velké práce. Druhý bude velmi brzy zveřejněn na blogu skupiny Mail.ru a odkaz na něj určitě přidáme v tomto článku.
Pokud máte zájem navštěvovat akce, kde tyto věci vytváříme online a klást otázky v reálném čase, připojte se na.
Pokud potřebujete přejít do cloudu nebo máte dotazy týkající se vaší infrastruktury, .
PS Máme 2 bezplatné audity měsíčně, možná bude váš projekt jedním z nich.
Zdroj: www.habr.com