Před pěti lety jsem zkusil pracovat s Tarantool, ale tehdy mi to nevyhovovalo. Nedávno jsem ale vedl webinář, kde jsem hovořil o Hadoopu a o tom, jak funguje MapReduce. Tam mi položili otázku: „Proč pro tento úkol nepoužít Tarantool?“.
Zvědavostí jsem se rozhodl k němu vrátit, otestovat nejnovější verzi – a tentokrát se mi projekt velmi líbil. Teď vám ukážu, jak napsat jednoduchou aplikaci v Tarantool, zatížit ji a zkontrolovat výkon, uvidíte, jak je to všechno snadné a skvělé.
Co je Tarantool
Tarantool se prezentuje jako superrychlá databáze. Můžete do ní vkládat jakákoliv data, jaká chcete. Navíc je možné je replikovat, shardovat – tedy rozdělit obrovské množství dat mezi několik serverů a kombinovat výsledky, vytvářet odolné svazky typu „master-master“.
Za druhé, je to aplikační server. Můžete na něm psát vlastní aplikace, pracovat s daty, například v pozadí mazat staré záznamy podle určitých pravidel. Můžete napsat přímo v Tarantoolu Http-server, který bude pracovat s daty: poskytovat jejich počet, zapisovat nové údaje a redukovat to vše na master.
Četl jsem článek, jak kluci udělali frontu zpráv na 300 řádcích, která prostě drtí – mají minimální výkon od 20 000 zpráv za sekundu. Tady se opravdu můžete rozjet a napsat velmi velkou aplikaci, a to nebudou historické záznamy jako v PostgreS.
Přibližně takový server, jen jednoduchý, se pokusím popsat v tomto článku.
Instalace
Pro test jsem založil tři standardní virtuální stroje – pevný disk o velikosti 20 gigabajtů, Ubuntu 18.04, 2 virtuální CPU a 4 gigabajty paměti.
Instalujeme Tarantool – spustíme bash skript nebo přidáme repozitář a provedeme apt get install Tarantool. Odkaz na skript – (curl -L | VER=2.4 sudo -E bash). Zde se objeví takové příkazy, jako:
tarantoolctl – hlavní příkaz pro správu instancí Tarantoolu.
/etc/tarantool – zde se nachází veškerá konfigurace.
var/log/tarantool – zde leží logy.
var/lib/tarantool – zde leží data, a dále jsou rozdělena podle instancí.
Existují složky instance-available a instance-enable — v ní se nachází to, co bude spuštěno — konfigurační soubor instance s kódem Lua, kde je popsáno, na jakých portech naslouchá, jaká paměť mu je dostupná, nastavení motoru Vinyl, kód, který se spouští při startu serveru, shardování, fronty, odstraňování zastaralých dat a tak dále.
Instance fungují podobně jako v PostgreS. Například, pokud chcete spustit několik kopií databáze, která běží na různých portech. Na jednom serveru se spouští několik instancí databází, které běží na různých portech. Mohou mít naprosto odlišná nastavení — jedna instance realizuje jednu logiku, druhá — jinou.
Správa instancí
Máme příkaz tarantoolctl, který umožňuje spravovat instance Tarantula. Například, tarantoolctl check example zkontroluje konfigurační soubor a oznámí — soubor je v pořádku, pokud neobsahuje žádné syntaktické chyby.
Můžete zkontrolovat stav instance — tarantoolctl status example. Stejným způsobem můžete provádět start, stop, restart.
Když je instance spuštěna, můžete se k ní připojit dvěma způsoby.
1. Administrativní konzole
Výchozí nastavení Tarantool otevírá soket, kde se předává obyčejný ASCII text pro správu Tarantula. Připojení k konzoli probíhá vždy pod uživatelským účtem admin, není zde žádná autentizace, proto není nutné vyhazovat konzolový port pro správu Tarantula ven.
Pro připojení tímto způsobem je nutné zadat Tarantoolctl enter instance name. Tento příkaz spustí konzoli a připojí se pod uživatelským účtem admin. Nikdy neodhalujte konzolový port ven — je lepší nechat ho jako jednotkový soket. Možnost připojit se k Tarantulu tak bude mít pouze ti, kteří mají přístup k zápisu do soketu.
Tento způsob je potřebný pro administrativní úkoly. Pro práci s daty použijte druhý způsob — binární protokol.
2. Použití binárního protokolu pro připojení k určené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 zapnuta autentizace.
Pro toto připojení se používá tarantoolctl connect to port number. Pomocí něj se lze připojit k vzdáleným serverům, využít autentizaci a udělit různá práva přístupu.
Zápis dat a modul Box
Tarantool je jak databází, tak aplikačním serverem, a obsahuje různé moduly. Zajímá nás modul box – ten dává možnost pracovat s daty. Když něco uložíte do boxu, Tarantool zapisuje data na disk, uchovává je v paměti nebo s nimi dělá něco jiného.
Záznam
Například vstoupíme do modulu box a zavoláme funkci box.once. Ta donuti Tarantool spustit náš kód při inicializaci serveru. Vytvoříme space, ve kterém budou uložena naše data.
local function bootstrap()
local space = box.schema.create_space('example')
space:create_index('primary')
box.schema.user.grant('guest', 'read,write,execute', 'universe')
-- Chraňte věci bezpečně jako výchozí
-- 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 – primary –, podle kterého lze vyhledávat data. Výchozí, pokud nejsou specifikovány žádné parametry, použije první pole v každém záznamu pro primární index.
Následně udělíme grant uživateli guest, pod kterým se připojujeme prostřednictvím binárního protokolu. Umožňujeme čtení, zápis a vykonávání v celé instanci.
Pokud porovnáme s běžnými databázemi, je to zde poměrně jednoduché. Máme space – oblast, kde se pouze uchovávají naše data. Každý záznam se nazývá tuple. Ten je zabalen v MessagePacku. To je velmi zajímavý formát – je binární a zabírá méně místa – 18 bajtů oproti 27.
S ním je velmi pohodlné pracovat. Téměř každý řádek, každý záznam dat může mít naprosto různé sloupce.
Všechny spaces můžeme zobrazit pomocí příkazu Box.space. Abychom vybrali konkrétní instanci – napíšeme box.space example a získáme kompletní informace o ní.
Tarantool má vestavěné dva typy motorů: Memory a Vinyl. Memory ukládá všechna data do paměti. Proto to funguje jednoduše a rychle. Data se ukládají na disk a také existuje mechanismus write ahead log, takže nic neztratíme při pádu serveru.
Vinyl uchovává data na disku v nám známějším formátu – což znamená, že můžeme uchovávat více dat, než kolik máme paměti, a Tarantool je bude číst z disku.
Teď budeme používat 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ární index je třeba vytvořit pro každé space, protože bez něj nic nebude fungovat. Stejně jako v jakékoli databázi, vytváříme první pole – ID záznamu.
Parts:
Zde uvádíme, z čeho se náš index skládá. Skládá se z jedné části – prvního pole, které použijeme, typ unsigned — kladné celé číslo. Pokud si pamatuji z dokumentace, maximální číslo, které může být – 18 kvintiliónů. Opravdu hodně.
Poté můžeme vkládat data 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é. Počtem sloupců nejsme omezeni, a tak můžeme vložit libovolné množství dat. Ty se uvádějí ve formátu MessagePack, který jsem postupně popisoval.
Výstup dat
Poté můžeme data načíst příkazem select.
Box.example.select s uvedením klíče {1} vrátí požadovaný záznam. Pokud klíč vynecháme, zobrazí se všechny záznamy, které máme. Ty se liší počtem sloupců, ale zde v podstatě neexistuje pojem sloupců — existují čísla polí.
Dat může být absolutně kolik chce. Například, pokud potřebujeme je hledat podle druhého pole. K tomu vytvoříme nový sekundární index.
box.space.example:create_index( 'secondary', { type = 'TREE', unique = false, parts = {{field = 2, type ='string' }}}) Používáme příkaz Create_index.
Nazveme ho Secondary.
Poté je třeba uvést parametry. Typ indexu — TREE. Může být nejedinečný, takže uvádíme Unique = false.
Poté uvedeme, z jakých částí se náš index skládá. Field — to je číslo pole, na které připojujeme index, a uvádíme typ string. A tak byl vytvořen.
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í ho můžeme vyvolat tímto způsobem:
unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...
Uložení
Pokud restartujeme instanci a znovu se pokusíme vyvolat data, uvidíme, že nejsou — všechno je prázdné. To se děje, protože Tarantool provádí checkpointy a ukládá data na disk, ale pokud zastavíme práci před nejbližším uložením, ztratíme všechny operace — protože se vrátíme k poslednímu checkpointu, který byl, například, před dvěma hodinami.
Ukládat každou sekundu také nepůjde — protože neustálé dumpování na disk po 20 GB — to není nejlepší nápad.
K tomu byla vymyšlena a implementována koncepce write-ahead log. S její pomocí se na každou změnu dat vytvoří zápis v malém write-ahead log souboru.
Každý zápis do checkpointu se v nich ukládá. Pro tyto soubory nastavujeme velikost — například 64 MB. Když se naplní, zápis se začne provádět do druhého souboru. A po restartu Tarantool se obnoví z posledního checkpointu a poté se aplikují všechny novější transakce až do okamžiku zastavení.
Aby bylo možné provádět takové zápisy, musíte v nastavení box.cfg (v souboru example.lua) určit tuto možnost:
wal_mode = "write";Použití dat
S tím, co jsme nyní napsali, můžete použít Tarantool pro ukládání dat a bude velmi rychle fungovat jako databáze. A nyní ta největší lahůdka — co vše s tím můžete dělat.
Píšeme aplikaci
Například napíšeme pro Tarantool takovou aplikaci
Aplikaci najdete 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; -- 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
-- pro první běh vytvořte prostor a nastavte oprávnění
box.once('replica', bootstrap)
-- povolení přístupu k konzole
console = require('console')
console.listen('127.0.0.1:3302')
-- http konfigurace
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 tokenů")
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 v Lua nějakou tabulku, která určuje znaky. Tato tabulka je potřebná pro generaci 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 předáme jako parametr hodnotu délky.
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)]
endPak načteme http-router a http-server do našeho Tarantool serveru, JSON, které budeme vracet klientovi.
local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')Poté spustíme http server na portu 8080 na všech rozhraních, který bude logovat 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 trasu, že když na port 8080 /count přijde požadavek metodou GET, zavoláme funkci s jedním řádkem. Ta vrací stav — 200, 404, 403 nebo jakýkoliv jiný, který určíme.
router:route({method = 'GET', path = '\/count'}, function()
return {status = 200, body = json.encode({count = get_count()})}
end)V těle vracíme json.encode, ve které uvádíme count a get_count, která je volána 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 ve řádku router:route({method = ‘GET’, path = ‘\/token’}, function() vyvoláváme funkci a generujeme token.
Řádek local token = randomString(32) – to je náhodný řetězec o 32 znacích.
Ve řádku local last = box.space.example:len() vytahujeme poslední prvek.
A ve řádku box.space.example:insert{ last + 1, token } zapíšeme do naší databáze údaje, tedy jednoduše zvýšíme ID o 1. To lze, mimochodem, udělat nejen tímto neohrabaným způsobem. V Tarantulu existují sekvence pro tuto záležitost.
Zapíšeme tam token.
Takto jsme napsali aplikaci ve jednom souboru. V něm lze ihned manipulovat s daty a modul box za vás udělá veškerou špinavou práci.
Naslouchá http a pracuje s daty, vše se nachází v jediné instanci — jak aplikace, tak data. Proto vše probíhá poměrně rychle.
Pro spuštění instalujeme http modul:
Jak to děláme, viz pod spoilerem
root@test2:~# tarantoolctl rocks install http
Instalace http://rocks.tarantool.org/http-scm-1.src.rock
Chybějící závislosti pro http scm-1:
checks >= 3.0.1 (není nainstalováno)
http scm-1 závisí na checks >= 3.0.1 (není nainstalováno)
Instalace http://rocks.tarantool.org/checks-3.0.1-1.rockspec
Klonování do 'checks'...
remote: Vyčítání objektů: 28, hotovo.
remote: Počítání objektů: 100% (28/28), hotovo.
remote: Komprimování objektů: 100% (19/19), hotovo.
remote: Celkem 28 (delta 1), znovu použito 16 (delta 1), balení znovu použito 0
Přijímání objektů: 100% (28/28), 12.69 KiB | 12.69 MiB/s, hotovo.
Řešení deltas: 100% (1/1), hotovo.
Poznámka: kontrola '580388773ef11085015b5a06fe52d61acf16b201'.
Jste ve stavu 'odpojené hlavy'. Můžete se podívat kolem, provádět experimentální
změny a provádět je, a můžete zrušit jakékoli commity, které provedete v tomto
stavu, aniž by to mělo vliv na jakékoli větve provedením dalšího checkoutu.
Pokud chcete vytvořit novou větev pro uložení commitů, které vytvoříte, můžete
to udělat (nyní nebo později) pomocí -b s příkazem checkout znovu. Příklad:
git checkout -b
Žádný existující manifest. Pokus o reconstruování...
checks 3.0.1-1 je nyní nainstalován v /.rocks (licence: BSD)
-- Identifikace C kompilátoru je GNU 7.5.0
-- Kontrola funkčního C kompilátoru: /usr/bin/cc
-- Kontrola funkčního C kompilátoru: /usr/bin/cc -- funguje
-- Detekce C kompilátoru ABI info
-- Detekce informací ABI C kompilátoru - hotovo
-- Detekce funkcí kompilace C
-- Detekce funkcí kompilace C - hotovo
-- Nalezen TARANTOOL: /usr/include (nalezená verze "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
-- Konfigurace dokončena
-- Generování dokončeno
CMake Varování:
Ručně specifikované proměnné nebyly použity projektem:
version
-- Souborové výstupy byly zapsány do: /tmp/luarocks_http-scm-1-V4P9SM/http/build.luarocks
Skenování závislostí cíle httpd
[ 50%] Kompilace C objektu http/CMakeFiles/httpd.dir/lib.c.o
V souboru zahrnutém z /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:32:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c: V funkci 'tpl_term':
/usr/include/tarantool/lauxlib.h:144:15: varování: tento příkaz může pokračovat [-Wimplicit-fallthrough=]
(*(B)->p++ = (char)(c)))
~~~~~~~~~~~^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:62:7: poznámka: při expanze makra 'luaL_addchar'
luaL_addchar(b, '\');
^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:63:6: poznámka: zde
default:
^~~~~~~
V souboru zahrnutém z /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:39:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h: V funkci 'tpe_parse':
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:147:9: varování: tento příkaz může pokračovat [-Wimplicit-fallthrough=]
type = TPE_TEXT;
~~~~~^~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:149:3: poznámka: zde
case TPE_LINECODE:
^~~~
V souboru zahrnutém z /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:40:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h: V funkci 'httpfast_parse':
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:372:22: varování: tento příkaz může pokračovat [-Wimplicit-fallthrough=]
code = 0;
~~~~~^~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:374:13: poznámka: zde
case status:
^~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:393:23: varování: tento příkaz může pokračovat [-Wimplicit-fallthrough=]
state = message;
~~~~~~^~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:395:13: poznámka: zde
case message:
^~~~
[100%] Propojení sdílené knihovny C lib.so
[100%] Cílový httpd byl sestaven
[100%] Cílový httpd byl sestaven
Nainstalujte projekt...
-- Konfigurace instalace: "Debug"
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/VERSION.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lib/http/lib.so
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/init.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/tsgi_adapter.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/nginx_server/init.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/init.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/fs.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/matching.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/middleware.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/request.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/response.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/tsgi.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/utils.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/mime_types.lua
-- Instalace: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/codes.lua
http scm-1 je nyní nainstalován v /.rocks (licence: BSD)
root@test2:~#K spuštění potřebujeme také prometheus:
root@test2:~# tarantoolctl rocks install prometheus
Instaluji http://rocks.tarantool.org/prometheus-scm-1.rockspec
Klónuji do 'prometheus'...
remote: Vyjmenovávám objekty: 19, hotovo.
remote: Počítám objekty: 100% (19/19), hotovo.
remote: Komprimuji objekty: 100% (19/19), hotovo.
remote: Celkem 19 (delta 2), opětovně použito 5 (delta 0), pak-reused 0
Přijímání objektů: 100% (19/19), 10.73 KiB | 10.73 MiB/s, hotovo.
Řešení delt: 100% (2/2), hotovo.
prometheus scm-1 je nyní nainstalován v /.rocks (licence: BSD)
root@test2:~#
Spouštíme a můžeme se obracet na moduly
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 выдает токен и делает запись этого токена в базу.
Testujeme rychlost
Pojďme spustit benchmark na 50 000 dotazů. Současných dotazů bude 500.
root@test2:~# ab -c 500 -n 50000 http://127.0.0.1:8080/token
Tohle je ApacheBench, Verze 2.3
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licencováno Apache Software Foundation, http://www.apache.org/
Benchmarking 127.0.0.1 (buďte trpěliví)
Dokončeno 5000 dotazů
Dokončeno 10000 dotazů
Dokončeno 15000 dotazů
Dokončeno 20000 dotazů
Dokončeno 25000 dotazů
Dokončeno 30000 dotazů
Dokončeno 35000 dotazů
Dokončeno 40000 dotazů
Dokončeno 45000 dotazů
Dokončeno 50000 dotazů
Dokončeno 50000 dotazů
Server Software: Tarantool
Server Hostname: 127.0.0.1
Server Port: 8080
Dokument Path: /token
Dokument Length: 44 bytes
Úroveň konkurence: 500
Čas potřebný pro testy: 14.578 seconds
Celkové dotazy: 50000
Neúspěšné dotazy: 0
Celkem přeneseno: 7950000 bytes
HTML přeneseno: 2200000 bytes
Dotazy za sekundu: 3429.87 [# /sec] (průměr)
Čas na dotaz: 145.778 [ms] (průměr)
Čas na dotaz: 0.292 [ms] (průměr, napříč všemi současnými dotazy)
Rychlost přenosu: 532.57 [Kbytes /sec] přijato
Časy spojení (ms)
min průměr[+/ -sd] medián max
Connect: 0 10 103.2 0 3048
Zpracování: 12 69 685.1 15 13538
Čekání: 12 69 685.1 15 13538
Celkem: 12 78 768.2 15 14573
Procento dotazů obsloužených během určitého času (ms)
50% 15
66% 15
75% 16
80% 16
90% 16
95% 16
98% 21
99% 42
100% 14573 (nejdelší dotaz)
root@test2:~#Tokeny se vydávají. A neustále zapisujeme data. 99% dotazů bylo zpracováno za 42 milisekund. V souladu s tím máme přibližně 3500 dotazů za sekundu na malém stroji, kde jsou 2 jádra a 4 gigabajty paměti.
Také si můžete vybrat nějaký 50000-token a prohlédnout si jeho hodnotu.
Můžete používat nejen http, ale spouštět na pozadí funkce, které zpracovávají vaše data. Plus jsou zde různé spouštěče. Například můžete volat funkce na aktualizacích, něco kontrolovat – řešit konflikty.
Lze psát skriptovací aplikace přímo na serveru databáze a nic tím neomezovat, připojit libovolné moduly a realizovat jakoukoli logiku.
Aplikační server může komunikovat s externími servery, stahovat data a ukládat je do své databáze. Tato data pak budou využívat jiné aplikace.
Toto bude dělat sám Tarantool, a nebude třeba psát zvláštní aplikaci.
Na závěr
To je jen první část velké práce. Druhá část bude brzy zveřejněna na blogu Mail.ru Group, a určitě na ni přidáme odkaz v tomto materiálu.
Pokud máte zájem navštěvovat akce, kde vytváříme takové věci online a klást otázky v reálném čase, připojte se k.
Pokud potřebujete migrovat do cloudu nebo máte otázky k vaší infrastruktuře, .
P.S. Máme 2 bezplatné audity měsíčně, možná právě váš projekt bude mezi nimi.
Zdroj: habr.com
