Fiif jier lyn besocht ik te wurkjen mei Tarantool, mar doe wurke it net foar my. Mar koartlyn hold ik in webinar wêr't ik praat oer Hadoop en hoe't MapReduce wurket. Dêr stelden se my in fraach: "Wêrom net Tarantool brûke foar dizze taak?"
Ut nijsgjirrigens besleat ik der nei werom te gean, de lêste ferzje te testen - en dizze kear fûn ik it projekt echt leuk. No sil ik jo sjen litte hoe't jo in ienfâldige applikaasje yn Tarantool skriuwe, it laden en de prestaasjes kontrolearje, en jo sille sjen hoe maklik en cool alles is.
Wat is Tarantool
Tarantool positionearret himsels as in ultrasnelle database. Jo kinne dêr alle gegevens pleatse dy't jo wolle. Plus, replikearje se, shard - dat is, split in enoarme hoemannichte gegevens oer ferskate servers en kombinearje de resultaten fan har - meitsje fouttolerante master-master-ferbiningen.
Twadder is dit in applikaasjetsjinner. Jo kinne jo applikaasjes derop skriuwe, wurkje mei gegevens, bygelyks âlde records op 'e eftergrûn wiskje neffens bepaalde regels. Jo kinne direkt in Http-tsjinner skriuwe yn Tarantula dy't sil wurkje mei gegevens: werjaan syn kwantiteit, skriuw nije gegevens dêr en ferminderje it allegear nei de master.
Ik lês in artikel oer hoe't de jonges in berjochtwachtrige makken fan 300 rigels, dy't gewoan barst en hastich - se hawwe in minimale prestaasjes fan 20 berjochten per sekonde. Hjir kinne jo echt omdraaie en in heul grutte applikaasje skriuwe, en it sil gjin opslach wêze, lykas yn PostgreS.
Ik sil besykje wat as dizze server te beskriuwen, allinich ienfâldich, yn dit artikel.
ynstelling
Foar de test begon ik trije standert firtuele masines - in 20 GB hurde skiif, Ubuntu 18.04. 2 firtuele CPU's en 4 optredens fan ûnthâld.
Wy ynstallearje Tarantool - rinne it bash-skript of foegje in repository ta en doch apt Tarantool te ynstallearjen. Link nei skript - (curl -L | VER=2.4 sudo -E bash). Wy hawwe kommando's lykas:
tarantoolctl - it haadkommando foar it behearen fan Tarantula-eksimplaren.
/etc/tarantool - hjir is de hiele konfiguraasje.
var/log/tarantool - hjir binne de logs.
var/lib/tarantool - de gegevens lizze hjir, en dan wurdt it ferdield yn eksimplaren.
D'r binne mappen instance-beskikber en instance-enable - it befettet wat sil wurde lansearre - in eksimplaar konfiguraasjetriem mei lua-koade, dy't beskriuwt op hokker havens it harket, hokker ûnthâld der beskikber is, Vinylmotorynstellingen, koade dy't rint by it opstarten tsjinners, sharding, wachtrijen, wiskjen fan ferâldere gegevens, ensfh.
Ynstânsjes wurkje lykas yn PostgreS. Jo wolle bygelyks ferskate kopyen fan in databank útfiere dy't op ferskate havens hinget. It docht bliken dat ferskate database-eksimplaren wurde lansearre op ien server, dy't hingje oan ferskate havens. Se kinne folslein oare ynstellings hawwe - ien eksimplaar ymplementearret ien logika, de twadde - in oar.
Ynstânsje behear
Wy hawwe it kommando tarantoolctl, wêrtroch jo Tarantula-eksimplaren kinne beheare. Bygelyks, tarantoolctl check foarbyld sil kontrolearje de konfiguraasje triem en sizze - de triem is ok as der gjin syntaksis flaters dêr.
Jo kinne de status fan 'e eksimplaar sjen - tarantoolctl status foarbyld. Op deselde manier kinne jo begjinne, stopje, opnij starte.
Sadree't eksimplaar rint, kinne jo der op twa manieren mei ferbine.
1. Bestjoerlike konsole
Standert iepenet Tarantool in socket en wurdt normale ASCII-tekst dêr stjoerd om Tarantool te kontrolearjen. Ferbining mei de konsole komt altyd foar ûnder de admin-brûker, d'r is gjin autentikaasje, dus it is net nedich om de konsole-poarte te eksternalisearje om Tarantula te behearjen.
Om te ferbinen mei dizze metoade, moatte jo Tarantoolctl ynfiere ynstânsnamme ynfiere. It kommando sil de konsole starte en ferbine as de admin-brûker. Nea bleatstelle de konsole haven nei bûten - it is better om te ferlitte it as in ienheid socket. Dan sille allinich dejingen dy't tagong hawwe om te skriuwen nei de socket kinne ferbine mei Tarantula.
Dizze metoade is nedich foar bestjoerlike saken. Om te wurkjen mei gegevens, brûk de twadde metoade - it binêre protokol.
2. Mei help fan in binêre protokol om te ferbinen mei in spesifike haven
De konfiguraasje befettet in harkrjochtline, dy't in poarte iepenet foar eksterne kommunikaasje. Dizze poarte wurdt brûkt mei it binêre protokol en autentikaasje is dêr ynskeakele.
Foar dizze ferbining wurdt tarantoolctl ferbine mei poartenûmer brûkt. Mei it brûken kinne jo ferbine mei servers op ôfstân, ferifikaasje brûke en ferskate tagongsrjochten jaan.
Data Recording en Box Module
Sûnt Tarantool is sawol in databank as in applikaasje-tsjinner, hat it ferskate modules. Wy binne ynteressearre yn 'e fakmodule - it ymplementearret wurkjen mei gegevens. As jo skriuwe wat oan doaze, Tarantool skriuwt de gegevens op skiif, bewarret it yn it ûnthâld, of docht wat oars mei it.
Opname
Bygelyks, wy geane yn de fak module en neame de box.once funksje. Dit sil Tarantool twinge om ús koade út te fieren as de server is inisjalisearre. Wy meitsje in romte wêryn ús gegevens sille wurde opslein.
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')
endHjirnei meitsje wy in primêre yndeks - primêr - wêrmei wy nei gegevens kinne sykje. Standert, as jo gjin parameters opjaan, sil it earste fjild yn elke record brûkt wurde foar de primêre yndeks.
Dan meitsje wy in subsydzje oan de gastbrûker, wêrby't wy ferbine fia it binêre protokol. Wy tastean lêzen, skriuwen en útfieren oer de hiele eksimplaar.
Yn ferliking mei konvinsjonele databases is alles hjir frij ienfâldich. Wy hawwe romte - in gebiet wêryn ús gegevens gewoan wurde opslein. Elk rekord wurdt in tuple neamd. It is ferpakt yn MessagePack. Dit is in heul cool formaat - it is binêr en nimt minder romte yn - 18 bytes tsjin 27.
It is hiel handich om mei him te wurkjen. Hast elke rigel, elke gegevensrecord kin folslein oare kolommen hawwe.
Wy kinne alle spaasjes besjen mei it kommando Box.space. Om in spesifyk eksimplaar te selektearjen, skriuw box.space foarbyld en krije folsleine ynformaasje deroer.
Tarantool hat twa ynboude motoren: Unthâld en Vinyl. Unthâld bewarret alle gegevens yn it ûnthâld. Dêrom wurket alles ienfâldich en fluch. De gegevens wurde dumpt op skiif, en der is ek in skriuw foarút log meganisme, dus wy sille net ferlieze neat as de tsjinner crashes.
Vinyl bewarret gegevens op skiif yn in foarm bekender foar ús - dat is, kinne jo opslaan mear gegevens as wy hawwe ûnthâld, en Tarantula sil lêze it út skiif.
Foar no sille wy Memory brûke.
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>Yndeks:
Foar elke romte moat in primêre yndeks oanmakke wurde, want sûnder dat sil neat wurkje. Lykas yn elke databank, meitsje wy it earste fjild - record ID.
Dielen:
Hjir jouwe wy oan wêrút ús yndeks bestiet. It bestiet út ien diel - it earste fjild dat wy sille brûke is fan it type net ûndertekene - in posityf hiel getal. Sa fier as ik tink út de dokumintaasje, is it maksimum oantal dat kin wêze 18 quintillion. Dat is in soad.
Dan kinne wy gegevens ynfoegje mei it kommando ynfoegje.
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>It earste fjild wurdt brûkt as de primêre kaai, dus it moat unyk wêze. Wy binne net beheind troch it oantal kolommen, dus kinne wy dêr safolle gegevens ynfoegje as wy wolle. Se wurde spesifisearre yn it MessagePack-formaat, dat ik hjirboppe beskreaun.
Data útfier
Dan kinne wy de gegevens werjaan mei it selektearje kommando.
Box.example.select mei de {1}-kaai sil de winske yngong werjaan. As wy de kaai ferleegje, sille wy alle records sjen dy't wy hawwe. Se ferskille allegear yn it oantal kolommen, mar hjir is yn prinsipe gjin konsept fan kolommen - d'r binne fjildnûmers.
D'r kin perfoarst elke hoemannichte gegevens wêze. En bygelyks, wy moatte sykje foar harren troch it twadde fjild. Om dit te dwaan, meitsje wy in nije sekundêre yndeks.
box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }})
Wy brûke it kommando Create_index.
Litte wy it Secondary neame.
Nei dit moatte jo de parameters opjaan. Yndekstype is TREE. It kin net unyk wêze, dus fier Unique = false yn.
Dan jouwe wy oan út hokker ûnderdielen ús yndeks bestiet. Fjild is it nûmer fan it fjild dêr't wy bine de yndeks, en spesifisearje it tekenrige type. En sa is it makke.
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>No kinne wy it sa neame:
unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...
Besparring
As wy it eksimplaar opnij starte en besykje de gegevens opnij te neamen, sille wy sjen dat it der net is - alles is leech. Dit bart om't Tarantool kontrolepunten makket en de gegevens op skiif bewarret, mar as wy ophâlde mei wurkjen oant de folgjende opslach, sille wy alle operaasjes ferlieze - om't wy weromkomme fan it lêste kontrôlepunt, dat wie bygelyks twa oeren lyn.
It sil ek net wurkje om elke sekonde te bewarjen, om't hieltyd 20 GB op skiif dumpe is gjin goed idee.
Foar dit doel waard it konsept fan skriuw-foarút log útfûn en ymplementearre. Mei har help, foar elke wiziging yn 'e gegevens, wurdt in yngong makke yn in lyts skriuw-foarút-logbestân.
Elke yngong oant it kontrôlepunt wurdt yn har opslein. Foar dizze triemmen wy sette de grutte - bygelyks, 64 MB. As it fol is, begjint opname te gean nei it twadde bestân. En nei de trochstart wurdt Tarantool weromset fan it lêste kontrôlepunt en rôlet dan oer alle lettere transaksjes oant it stopet.
Om sa'n opname út te fieren, moatte jo de opsje opjaan yn 'e box.cfg-ynstellingen (yn it example.lua-bestân):
wal_mode = “write”;data gebrûk
Mei wat wy no skreaun hawwe, kinne jo Tarantula brûke om gegevens op te slaan en it sil heul rap wurkje as in databank. En no is de kers op 'e taart wat jo der allegear mei kinne.
It skriuwen fan in applikaasje
Litte wy bygelyks de folgjende applikaasje foar Tarantula skriuwe
Sjoch de applikaasje ûnder de spoiler
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()Wy ferklearje wat tabel yn lua dy't de karakters definiearret. Dizze plaat is nedich om in willekeurige tekenrige te generearjen.
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
endDêrnei ferklearje wy de funksje - randomString en jouwe de lingtewearde tusken heakjes.
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)]
endDan ferbine wy de http-router en http-tsjinner oan ús Tarantula-tsjinner, JSON, dy't wy nei de kliïnt stjoere.
local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')Hjirnei begjinne wy op poarte 8080 op alle http-server-ynterfaces, dy't alle oanfragen en flaters sille oanmelde.
local httpd = http_server.new('0.0.0.0', 8080, {
log_requests = true,
log_errors = true
})Dêrnei ferklearje wy rûte, sadat as in fersyk mei de GET-metoade komt op poarte 8080 /count, dan neame wy de funksje fan ien rigel. It jout de status werom - 200, 404, 403 of elke oare dy't wy oantsjutte.
router:route({method = 'GET', path = '/count'}, function()
return {status = 200, body = json.encode({count = get_count()})}
end)Yn it lichem jouwe wy json.encode werom, dêryn jouwe wy count en getcount oan, dy't neamd wurdt en it oantal records yn ús databank toant.
Twadde metoade
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)Wêr yn 'e line router:route({method = 'GET', paad = '/token'}, function() wy neame de funksje en generearje in token.
String lokale token = randomString(32) is in willekeurige tekenrige fan 32 tekens.
In line local last = box.space.example:len() wy nimme út it lêste elemint.
En yn 'e line box.space.example:ynfoegje{ lêste + 1, token } wy skriuwe de gegevens yn ús databank, dat is, wy ferheegje de ID gewoan mei 1. Dit kin trouwens net allinich op dizze ûnhandige manier dien wurde. D'r binne sekwinsjes foar dit yn Tarantula.
Wy skriuwe dêr de token.
Sa hawwe wy de applikaasje yn ien bestân skreaun. Jo kinne direkt manipulearje de gegevens dêr, en de doaze module sil dwaan al it smoarge wurk foar dy.
It harket nei http en wurket mei gegevens, alles is yn ien eksimplaar - sawol de applikaasje as de gegevens. Dêrom, alles bart frij fluch.
Om te begjinnen ynstallearje wy de http-module:
Hoe't wy dit dogge, sjoch ûnder de 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:/#Wy hawwe ek prometheus nedich om te rinnen:
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:/#
Wy lansearje en kinne tagong krije ta de modules
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 jout ús de status 200.
/token jout in token út en skriuwt dit token nei de databank.
Testje de snelheid
Litte wy in benchmark útfiere foar 50 oanfragen. Der komme 000 konkurrearjende oanfragen.
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:/#Tokens wurde útjûn. En wy registrearje konstant gegevens. 99% fan oanfragen waarden ferwurke yn 42 millisekonden. Dêrtroch hawwe wy sa'n 3500 oanfragen per sekonde op in lytse masine mei 2 kearnen en 4 gigabyte ûnthâld.
Jo kinne ek selektearje guon 50000 token en sjoch de wearde.
Jo kinne net allinich http brûke, mar ek eftergrûnfunksjes útfiere dy't jo gegevens ferwurkje. Plus d'r binne ferskate triggers. Jo kinne bygelyks funksjes neame op updates, wat kontrolearje - konflikten korrigearje.
Jo kinne skriptapplikaasjes direkt yn 'e databanktsjinner sels skriuwe, en net troch alles beheind wurde, alle modules ferbine en elke logika útfiere.
De applikaasjetsjinner kin tagong krije ta eksterne servers, gegevens ophelje en it tafoegje oan syn database. Gegevens út dizze databank sille brûkt wurde troch oare applikaasjes.
Tarantula sil dit sels dwaan, en jo hoege gjin aparte applikaasje te skriuwen.
Yn ôfsluting
Dit is mar it earste diel fan in grut wurk. De twadde sil heul gau wurde publisearre op it blog fan Mail.ru Group, en wy sille grif in kepling taheakje yn dit materiaal.
As jo ynteressearre binne yn eveneminten by te wenjen wêr't wy dizze dingen online bouwe en fragen yn realtime stelle, stim dan ôf.
As jo nei de wolk moatte ferhúzje of fragen hawwe oer jo ynfrastruktuer, .
PS Wy hawwe 2 fergese audits per moanne, miskien sil jo projekt ien fan har wêze.
Boarne: www.habr.com