Duela bost urte saiatu nintzen Tarantoolekin lan egiten, baina gero ez zidan funtzionatu. Baina duela gutxi webinar bat egin nuen, non Hadoop-i buruz eta MapReduce-k nola funtzionatzen duen hitz egin nuen. Han galdera bat egin zidaten: "Zergatik ez erabili Tarantool zeregin honetarako?"
Jakin-minagatik, bertara itzultzea erabaki nuen, azken bertsioa probatzea –eta oraingoan asko gustatu zait proiektua–. Orain Tarantool-en aplikazio sinple bat nola idatzi, kargatu eta bere errendimendua egiaztatuko dizut, eta ikusiko duzu nola dena erraza eta freskoa den.
Zer da Tarantool
Tarantool-ek datu-base ultra-azkar gisa kokatzen du. Bertan nahi dituzun datuak jar ditzakezu. Gainera, errepikatu, zatitu - hau da, datu kopuru handi bat zatitu hainbat zerbitzaritan eta konbinatu haien emaitzak - egin akatsen aurrean maisu-maisu konexioak.
Bigarrenik, hau aplikazio zerbitzari bat da. Zure aplikazioak bertan idatz ditzakezu, datuekin lan egin, adibidez, atzeko planoko erregistro zaharrak ezabatu arau batzuen arabera. Datuekin funtzionatuko duen HTTP zerbitzari bat idatz dezakezu zuzenean Tarantulan: eman haien kantitatea, idatzi bertan datu berriak eta murriztu dena maisuari.
Artikulu bat irakurri nuen mutilek 300 lerroko mezu-ilara nola egin zuten, hau da, lehertu eta presaka ari dena: segundoko 20 mezu gutxieneko errendimendua dute. Hemen benetan buelta eman eta oso aplikazio handi bat idatzi dezakezu, eta ez da biltegiratze izango, PostgreS-en bezala.
Zerbitzari honen antzeko zerbait deskribatzen saiatuko naiz, sinplea dena, artikulu honetan.
Instalazio-
Proba egiteko, hiru makina birtual estandar martxan jarri nituen: 20 GB-ko disko gogor bat, Ubuntu 18.04. 2 CPU birtual eta 4 giga memoria.
Tarantool instalatzen dugu - exekutatu bash script-a edo gehitu biltegi bat eta instalatu Tarantool. Gidoirako esteka - (kizkurra -L | VER=2.4 sudo -E bash). Horrelako komandoak ditugu:
tarantoolctl — Tarantula instantziak kudeatzeko komando nagusia.
/etc/tarantool - hona hemen konfigurazio osoa.
var/log/tarantool - hona hemen erregistroak.
var/lib/tarantool — datuak hemen daude, eta gero instantziatan banatzen da.
Instantzia erabilgarri eta gaituta dagoen karpetak daude - abiaraziko dena dauka - Lua kodea duen instantzia-konfigurazio fitxategi bat, zein portutan entzuten duen deskribatzen duena, zein memoria dagoen erabilgarri, Vinyl motorren ezarpenak, abiaraztean exekutatzen den kodea. zerbitzariak, sharding, ilarak, zaharkitutako datuen ezabaketa, etab.
Instantziak PostgreS-en bezala funtzionatzen du. Adibidez, portu ezberdinetan zintzilik dagoen datu-base baten hainbat kopia exekutatu nahi dituzu. Bihurtzen da datu-baseko hainbat instantzia zerbitzari batean abiarazten direla, portu ezberdinetan zintzilikatzen direnak. Ezarpen guztiz desberdinak izan ditzakete: instantzia batek logika bat inplementatzen du, bigarrenak beste bat.
Instantzia kudeaketa
Tarantoolctl komandoa dugu, Tarantula instantziak kudeatzeko aukera ematen duena. Adibidez, tarantoolctl check example-k konfigurazio fitxategia egiaztatuko du eta esango du: fitxategia ondo dago bertan sintaxi-akatsik ez badago.
Instantziaren egoera ikus dezakezu - tarantoolctl egoera adibidea. Era berean, hasi, gelditu eta berrabiarazi dezakezu.
Instantzia exekutatzen denean, bi modutara konekta zaitezke.
1. Administrazio kontsola
Lehenespenez, Tarantool-ek socket bat irekitzen du, ASCII testu normala bertara bidaltzen da Tarantool kontrolatzeko. Kontsolarekiko konexioa beti gertatzen da administratzailearen erabiltzailearen azpian, ez dago autentifikaziorik, beraz, ez dago kontsolaren ataka kanporatu beharrik Tarantula kudeatzeko.
Metodo hau erabiliz konektatzeko, Tarantoolctl idatzi instantziaren izena sartu behar duzu. Komandoak kontsola abiaraziko du eta erabiltzaile administratzaile gisa konektatuko da. Inoiz ez jarri kontsolaren ataka kanpoaldera; hobe da unitate-hargailu gisa uztea. Orduan socketera idazteko sarbidea dutenek bakarrik izango dute konektatu Tarantulara.
Metodo hau behar da administrazio gauzetarako. Datuekin lan egiteko, erabili bigarren metodoa - protokolo bitarra.
2. Portu zehatz batera konektatzeko protokolo bitar bat erabiltzea
Konfigurazioak entzun zuzentarau bat dauka, kanpoko komunikazioetarako ataka bat irekitzen duena. Ataka hau protokolo bitarrekin erabiltzen da eta bertan autentifikazioa gaituta dago.
Konexio honetarako, tarantoolctl konektatu ataka zenbakira erabiltzen da. Erabiliz, urruneko zerbitzarietara konekta zaitezke, autentifikazioa erabil dezakezu eta hainbat sarbide-eskubide eman.
Datuen Grabaketa eta Kutxa Modulua
Tarantool datu-base bat eta aplikazio zerbitzari bat denez, hainbat modulu ditu. Kutxaren modulua interesatzen zaigu: datuekin lan egitea inplementatzen du. Zerbait idazten duzunean koadroan, Tarantool-ek datuak diskoan idazten ditu, memorian gordetzen ditu edo berarekin beste zerbait egiten du.
erregistro
Adibidez, box moduluan sartu eta box.once funtzioari deituko diogu. Horrek Tarantool-ek gure kodea exekutatzera behartuko du zerbitzaria hasieratzen denean. Gure datuak gordeko diren espazio bat sortzen dugu.
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')
endHorren ostean, indize primario bat sortuko dugu - primarioa - eta horren bidez datuak bilatu ahal izango ditugu. Lehenespenez, ez baduzu parametrorik zehazten, erregistro bakoitzeko lehen eremua indize nagusirako erabiliko da.
Ondoren, erabiltzaile gonbidatuari beka bat egiten diogu, eta horren arabera konektatzen gara protokolo bitarraren bidez. Instantzia osoan irakurtzeko, idazteko eta exekutatzeko aukera ematen dugu.
Ohiko datu-baseekin alderatuta, hemen dena nahiko erraza da. Espazioa dugu, gure datuak besterik gabe gordetzen diren eremua. Erregistro bakoitzari tupla deitzen zaio. MessagePack-en paketatzen da. Oso formatu polita da - bitarra da eta espazio gutxiago hartzen du - 18 byte 27 baino.
Nahiko erosoa da berarekin lan egitea. Ia lerro guztietan, datu-erregistro bakoitzak zutabe guztiz desberdinak izan ditzake.
Espazio guztiak ikus ditzakegu Box.space komandoa erabiliz. Instantzia zehatz bat hautatzeko, idatzi box.space adibidea eta lortu horri buruzko informazio osoa.
Tarantool-ek bi motor ditu: Memoria eta Biniloa. Memoriak datu guztiak gordetzen ditu memorian. Hori dela eta, dena erraz eta azkar funtzionatzen du. Datuak diskora isurtzen dira, eta idazteko erregistro-mekanismo bat ere badago, beraz, ez dugu ezer galduko zerbitzariak huts egiten badu.
Biniloak datuak diskoan gordetzen ditu guretzat ezagunagoa den forma batean, hau da, memoria dugun baino datu gehiago gorde ditzakezu eta Tarantulak diskotik irakurriko ditu.
Oraingoz Memoria erabiliko dugu.
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:
Indize primario bat sortu behar da edozein espaziotarako, hura gabe ezer ez baita funtzionatuko. Edozein datu-basetan bezala, lehenengo eremua sortzen dugu - erregistro IDa.
Atalak:
Hemen gure indizea zertan datzan adierazten dugu. Zati batek osatzen du - erabiliko dugun lehenengo eremua zeinurik gabeko motakoa da - zenbaki oso positibo bat. Dokumentaziotik gogoratzen dudanez, izan daitekeen gehienezko kopurua 18 kintilioi da. Hori asko da.
Ondoren, datuak txerta ditzakegu insert komandoa erabiliz.
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>Lehen eremua gako nagusi gisa erabiltzen da, beraz, bakarra izan behar du. Ez gaude zutabe kopuruak mugatuta, beraz, nahi adina datu txerta ditzakegu bertan. Goian deskribatu dudan MessagePack formatuan zehazten dira.
Datuen irteera
Ondoren, datuak bistaratu ditzakegu select komandoa erabiliz.
Laukia.adibidea.hautatu {1} teklarekin nahi duzun sarrera bistaratuko da. Tekla jaisten badugu, ditugun erregistro guztiak ikusiko ditugu. Zutabe kopuruan desberdinak dira, baina hemen, printzipioz, ez dago zutabeen kontzepturik - eremu-zenbakiak daude.
Edozein datu egon daiteke. Eta adibidez, bigarren eremuaren arabera bilatu behar ditugu. Horretarako, bigarren mailako indize berri bat sortuko dugu.
box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }})
Sortu_index komandoa erabiltzen dugu.
Dei diezaiogun Bigarren Hezkuntza.
Horren ondoren, parametroak zehaztu behar dituzu. Indize mota TREE da. Baliteke bakarra ez izatea, beraz, idatzi Unique = false.
Ondoren, gure indizea zein zatitan dagoen adieraziko dugu. Eremua indizea lotzen diogun eremuaren zenbakia da, eta kate mota zehazten du. Eta horrela sortu zen.
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>Orain honela dei genezake:
unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...
kontserbazio
Instantzia berrabiarazi eta datuak berriro deitzen saiatzen bagara, ikusiko dugu ez dagoela hor - dena hutsik dago. Tarantool-ek kontrol-puntuak egiten dituelako eta datuak diskoan gordetzen dituelako gertatzen da, baina hurrengo gorde arte lanean uzten badiogu, eragiketa guztiak galduko ditugu -azken kontrol-puntutik berreskuratuko dugulako, hau da, adibidez, duela bi ordu-.
Ez du funtzionatuko segundo guztiak gordetzeak, 20 GB diskora etengabe isurtzea ez delako ideia ona.
Horretarako, write-ahead log kontzeptua asmatu eta ezarri zen. Haren laguntzarekin, datuen aldaketa bakoitzerako, sarrera bat sortzen da aurretik idazteko erregistro-fitxategi txiki batean.
Kontrol-punturainoko sarrera bakoitza horietan gordetzen da. Fitxategi hauetarako tamaina ezarri dugu, adibidez, 64 MB. Bete dagoenean, grabaketa hasten da bigarren fitxategira joaten. Eta berrabiarazi ondoren, Tarantool azken kontrol-puntutik berrezartzen da eta gero transakzio guztiak itzultzen ditu gelditu arte.
Grabaketa hori egiteko, box.cfg ezarpenetan aukera zehaztu behar duzu (adibidez.lua fitxategian):
wal_mode = “write”;datuen erabilera
Orain idatzi dugunarekin, Tarantula erabil dezakezu datuak gordetzeko eta oso azkar funtzionatuko du datu-base gisa. Eta orain pastelaren goitza da horrekin guztiarekin egin dezakezuna.
Aplikazio bat idaztea
Adibidez, idatz dezagun Tarantularako aplikazio hau
Ikusi aplikazioa spoiler azpian
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()Luan karaktereak definitzen dituen taula bat deklaratzen dugu. Plaka hau ausazko kate bat sortzeko beharrezkoa da.
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
endHorren ondoren, funtzioa deklaratzen dugu - randomString eta luzera balioa parentesi artean emango dugu.
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)]
endOndoren, http bideratzailea eta http zerbitzaria gure Tarantula zerbitzariarekin, JSONarekin, konektatzen ditugu, eta bezeroari bidaliko diogu.
local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')Honen ondoren, 8080 atakan hasiko gara http zerbitzariaren interfaze guztietan, eskaera eta errore guztiak erregistratuko dituena.
local httpd = http_server.new('0.0.0.0', 8080, {
log_requests = true,
log_errors = true
})Ondoren, ibilbidea deklaratzen dugu, horrela GET metodoarekin eskaera bat 8080 /count atakara iristen bada, orduan deitzen diogu funtzioari lerro batetik. Egoera itzultzen du - 200, 404, 403 edo guk zehazten dugun beste edozein.
router:route({method = 'GET', path = '/count'}, function()
return {status = 200, body = json.encode({count = get_count()})}
end)Gorputzean json.encode itzultzen dugu, bertan count eta getcount adierazten dugu, deitzen dena eta gure datu-baseko erregistro kopurua erakusten du.
Bigarren metodoa
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)Non lerroan bideratzailea: ibilbidea ({metodoa = 'GET', bidea = '/token'}, funtzioa () funtzioari deitu eta token bat sortzen dugu.
ilara tokiko token = randomString (32) 32 karaktereko ausazko katea da.
Ilaran azken lokala = box.space.example:len() azken elementua ateratzen dugu.
Eta lerroan box.space.example:txertatu{ azken + 1, tokena } datuak gure datu-basean idazten ditugu, hau da, ID-a 1ean handitzen dugu besterik gabe. Hori egin daiteke, bide batez, ez bakarrik modu trakets honetan. Tarantulan horretarako sekuentziak daude.
Han idazten dugu tokena.
Horrela, eskaera fitxategi batean idatzi genuen. Bertan datuak zuzenean manipula ditzakezu, eta kutxaren moduluak lan zikin guztia egingo dizu.
http-a entzuten du eta datuekin lan egiten du, dena instantzia bakarrean dago, bai aplikazioa bai datuak. Hori dela eta, dena nahiko azkar gertatzen da.
Hasteko http modulua instalatzen dugu:
Nola egiten dugun hau, begiratu spoiler azpian
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:/#Prometheus ere behar dugu korrika egiteko:
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:/#
Abian jartzen dugu eta moduluetara sar gaitezke
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 egoera ematen digu.
/token-ek token bat igortzen du eta token hau datu-basean idazten du.
Proba abiadura
Egin dezagun erreferentzia 50 eskaera egiteko. 000 eskaera lehiatuko dira.
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:/#Tokenak jaulkitzen dira. Eta etengabe ari gara datuak erregistratzen. Eskaeren % 99 42 milisegundotan prozesatu dira. Horren arabera, segundoko 3500 eskaera inguru ditugu 2 nukleo eta 4 gigabyte memoria dituen makina txiki batean.
50000 token batzuk ere hauta ditzakezu eta bere balioa ikusi.
http ez ezik, zure datuak prozesatzen dituzten atzeko planoko funtzioak ere exekutatu ditzakezu. Gainera, hainbat eragile daude. Adibidez, eguneratzeen funtzioetara dei dezakezu, zerbait egiaztatu - gatazkak zuzendu.
Script-aplikazioak zuzenean idatz ditzakezu datu-basearen zerbitzarian bertan, eta ezerk mugatu gabe, edozein modulu konektatu eta edozein logika inplementatu.
Aplikazio-zerbitzariak kanpoko zerbitzarietara sartu, datuak berreskuratu eta bere datu-basean gehi ditzake. Datu-base honetako datuak beste aplikazio batzuek erabiliko dituzte.
Tarantulak berak egingo du, eta ez duzu aparteko aplikaziorik idatzi beharko.
Ondorioz
Hau lan handi baten lehen zatia baino ez da. Bigarrena laster argitaratuko da Mail.ru Group blogean, eta, zalantzarik gabe, esteka bat gehituko diogu material honetan.
Gauza hauek linean eraikitzen ditugun ekitaldietara joateko eta denbora errealean galderak egiteko interesa baduzu, sintonizatu.
Hodeira joan behar baduzu edo zure azpiegiturei buruzko galderarik baduzu, .
PS Hilean 2 doako auditoria ditugu, agian zure proiektua horietako bat izango da.
Iturria: www.habr.com