Viis aastat tagasi proovisin Tarantooliga koostööd teha, aga siis see minu jaoks ei töötanud. Kuid hiljuti pidasin veebiseminari, kus rääkisin Hadoopist, sellest, kuidas MapReduce töötab. Seal esitati mulle küsimus - "Miks mitte kasutada selle ülesande jaoks Tarantooli?".
Uudishimu huvides otsustasin selle juurde tagasi pöörduda, testida uusimat versiooni – ja seekord meeldis see projekt mulle väga. Nüüd näitan, kuidas Tarantoolis lihtsat rakendust kirjutada, see laadida ja jõudlust kontrollida ning näete, kui lihtne ja lahe kõik seal on.
Mis on Tarantool
Tarantool positsioneerib end ülikiire andmebaasina. Saate sinna sisestada kõik soovitud andmed. Lisaks kopeerige neid, shard - st jagage tohutul hulgal andmeid mitme serveri vahel ja ühendage nende tulemused - looge tõrketaluvusega master-master linke.
Teiseks on see rakendusserver. Sinna saab kirjutada oma rakendusi, töötada andmetega, näiteks kustutada taustal vanu kirjeid teatud reeglite järgi. Saate kirjutada otse Tarantulasse Http-serveri, mis töötab andmetega: andke välja nende number, kirjutage sinna uued andmed ja redigeerige see kõik masteriks.
Lugesin artiklit selle kohta, kuidas poisid lõid 300-realise sõnumijärjekorra, mis lihtsalt rebib ja rabab – neil on minimaalne jõudlus 20 000 sõnumit sekundis. Siin saate tõesti ümber pöörata ja kirjutada väga suure rakenduse ning neid ei salvestata, nagu PostgreSis.
Umbes sellist serverit, ainult lihtsat, püüan selles artiklis kirjeldada.
Paigaldamine
Testi jaoks käivitasin kolm tavalist virtuaalmasinat – 20 gigabaidine kõvaketas, Ubuntu 18.04. 2 virtuaalset protsessorit ja 4 gigabaiti mälu.
Installime Tarantooli - käivitame bash-skripti või lisame hoidla ja installime Tarantooli. Link skriptile - (curl -L | VER=2.4 sudo -E bash). Meil on sellised käsud nagu:
tarantoolctl on Tarantula eksemplaride haldamise peamine käsk.
/etc/tarantool - siin on kogu konfiguratsioon.
var/log/tarantool - siin on palgid.
var/lib/tarantool - siin asuvad andmed ja seejärel jagatakse need eksemplarideks.
Seal on eksemplari jaoks saadaolevad ja eksemplari lubamise kaustad - see sisaldab käivitatavat - eksemplari konfiguratsioonifaili lua koodiga, mis kirjeldab, millistel portidel see kuulab, milline mälu on sellel, vinüülmootori seaded, käivitamisel töötav kood serverid, jagamine, järjekorrad, aegunud andmete kustutamine jne.
Eksemplarid töötavad nagu PostgreSis. Näiteks soovite käitada mitut koopiat andmebaasist, mis ripub erinevates portides. Selgub, et ühes serveris käivitatakse mitu andmebaasi eksemplari, mis ripuvad erinevates portides. Neil võivad olla täiesti erinevad sätted - üks eksemplar rakendab üht loogikat, teine - teist.
Eksemplari juhtimine
Meil on käsk tarantoolctl, mis võimaldab meil hallata Tarantula eksemplare. Näiteks kontrollib tarantoolctl kontrolli näide konfiguratsioonifaili ja ütleb, et fail on korras, kui süntaksivigu pole.
Näete eksemplari olekut - tarantoolctl oleku näide. Samamoodi saate käivitada, peatada, taaskäivitada.
Kui eksemplar töötab, on sellega ühenduse loomiseks kaks võimalust.
1. Halduskonsool
Vaikimisi avab Tarantool pistikupesa ja saadab Tarantula juhtimiseks lihtsa ASCII-teksti. Ühendus konsooliga toimub alati administraatori kasutaja all, autentimist pole, seega ei pea Tarantula väljas juhtimiseks konsooliporti välja võtma.
Sel viisil ühenduse loomiseks peate sisestama käsu Tarantoolctl enter eksemplari nimi. Käsk käivitab konsooli ja loob ühenduse administraatori kasutajana. Ärge kunagi jätke konsooliporti väljapoole – parem on jätta see seadme pistikupesaks. Siis saavad Tarantulaga ühenduse luua ainult need, kellel on pistikupesale kirjutamisõigus.
Seda meetodit on vaja haldusasjade jaoks. Andmetega töötamiseks kasutage teist meetodit - binaarprotokolli.
2. Binaarprotokolli kasutamine kindla pordiga ühenduse loomiseks
Konfiguratsioonis on kuulamisdirektiiv, mis avab pordi välisside jaoks. Seda porti kasutatakse binaarprotokolliga ja autentimine on seal lubatud.
Selle ühenduse jaoks kasutatakse tarantoolctl ühendust pordi numbriga. Seda kasutades saate luua ühenduse kaugserveritega, kasutada autentimist ja anda erinevaid juurdepääsuõigusi.
Andmete salvestamise ja kasti moodul
Kuna Tarantool on nii andmebaas kui ka rakendusserver, on sellel erinevaid mooduleid. Oleme huvitatud kastimoodulist - see rakendab tööd andmetega. Kui kirjutate midagi kasti, kirjutab Tarantool andmed kettale, salvestab need mällu või teeb nendega midagi muud.
Rekord
Näiteks läheme kasti moodulisse ja kutsume funktsiooni box.once. See sunnib Tarantooli serveri initsialiseerimisel meie koodi käivitama. Loome ruumi, kus meie andmeid hoitakse.
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')
endPärast seda loome esmase indeksi – esmase – mille järgi saame andmeid otsida. Kui parameetreid pole määratud, kasutatakse vaikimisi praimeri indeksi iga kirje esimest välja.
Seejärel teeme külaliskasutajale grandi, mille alusel ühendume binaarprotokolli kaudu. Lubame lugeda, kirjutada ja täita kogu eksemplari.
Võrreldes tavapäraste andmebaasidega on siin kõik üsna lihtne. Meil on ruum – ala, kus meie andmeid lihtsalt hoitakse. Iga kirjet nimetatakse korteežiks. See on pakitud MessagePacki. See on väga lahe formaat – see on binaarne ja võtab vähem ruumi – 18 baiti versus 27.
Temaga on üsna mugav töötada. Peaaegu igal real, igal andmesisestamisel võivad olla täiesti erinevad veerud.
Kõiki tühikuid saame vaadata käsuga Box.space. Konkreetse eksemplari valimiseks kirjutame näite box.space ja saame selle kohta täielikku teavet.
Tarantoolis on kahte tüüpi mootoreid: mälu ja vinüül. Mälu salvestab kõik andmed mällu. Seetõttu töötab kõik lihtsalt ja kiiresti. Andmed kantakse kettale ja seal on ka ettekirjutamise logimehhanism, nii et me ei kaota midagi, kui server jookseb kokku.
Vinüül salvestab andmed kettale tuttavamal kujul - see tähendab, et saate salvestada rohkem andmeid, kui meil on mälu ja Tarantula loeb neid kettalt.
Nüüd kasutame mälu.
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>Indeks:
Iga ruumi jaoks tuleb luua esmane indeks, sest ilma selleta ei tööta midagi. Nagu igas andmebaasis, loome esimese välja - kirje ID.
Parts:
Siin täpsustame, millest meie indeks koosneb. See koosneb ühest osast - esimesest väljast, mida me kasutame, tippige märgita - positiivne täisarv. Nii palju kui ma dokumentatsioonist mäletan, on maksimaalne arv, mis võib olla, 18 kvintiljonit. Palju ägedat.
Seejärel saame andmed sisestada käsu sisestamise abil.
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>Esimest välja kasutatakse esmase võtmena, seega peab see olema kordumatu. Meid ei piira veergude arv, nii et saame sinna sisestada nii palju andmeid, kui meile meeldib. Need on määratud MessagePacki vormingus, mida ma eespool kirjeldasin.
Andmete väljund
Seejärel saame andmeid kuvada käsuga select.
Box.example.select klahviga {1} kuvab soovitud kirje. Kui jätame võtme välja, näeme kõiki meil olevaid kirjeid. Need on kõik erinevad veergude arvu poolest, kuid siin pole põhimõtteliselt veergude mõistet - on väljade numbrid.
Andmeid võib olla absoluutselt nii palju kui soovite. Ja näiteks peame neid otsima teiselt väljalt. Selleks teeme uue sekundaarse indeksi.
box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }})
Kasutame käsku Create_index.
Me nimetame seda sekundaarseks.
Pärast seda peate määrama parameetrid. Indeksi tüüp on PUUD. See ei pruugi olla kordumatu, seega sisestame Unique = false.
Seejärel näitame, millistest osadest meie indeks koosneb. Väli on selle välja number, millega me indeksi seome, ja määrab stringi tüübi. Ja nii see loodi.
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>Nüüd saame seda nimetada järgmiselt:
unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...
Säästmine
Kui taaskäivitame eksemplari ja proovime andmeid uuesti helistada, näeme, et neid pole - kõik on tühi. See juhtub seetõttu, et Tarantool teeb kontrollpunkte ja salvestab andmed kettale, kuid kui me lõpetame töö enne järgmist salvestamist, siis kaotame kõik toimingud – kuna taastume viimasest kontrollpunktist, mis oli näiteks kaks tundi tagasi.
Ka iga sekundi salvestamine ei toimi - kuna 20 GB pidev kettale salvestamine on nii-nii idee.
Selleks leiutati ja rakendati ettekirjutamise logi kontseptsioon. Tema abiga luuakse iga andmete muudatuse kohta kirje väikeses ettekirjutatavas logifailis.
Neisse salvestatakse iga kirje kuni kontrollpunktini. Nende failide jaoks määrame suuruse - näiteks 64 mb. Kui see saab täis, läheb salvestus teise faili juurde. Ja pärast taaskäivitamist taastub Tarantool viimasest kontrollpunktist ja jätkab seejärel kõigist hilisematest tehingutest kuni peatumiseni.
Sellise salvestuse tegemiseks peate määrama suvandi box.cfg sätetes (failis example.lua):
wal_mode = “write”;andmekasutus
Sellega, mida oleme nüüd kirjutanud, saate Tarantulat kasutada andmete salvestamiseks ja see töötab andmebaasina väga kiiresti. Ja nüüd kirss tordil – mis selle kõigega peale hakata.
Avalduse kirjutamine
Näiteks kirjutame Tarantulale sellise taotluse
Vaata rakendust spoileri alt
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()Me deklareerime mõne tabeli lua-s, mis määratleb sümbolid. Seda tabelit on vaja juhusliku stringi genereerimiseks.
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
endPärast seda deklareerime funktsiooni - randomString ja anname pikkuse väärtuse sulgudes.
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)]
endSeejärel ühendame http ruuteri ja http serveri oma Tarantula serveriga JSON, mille anname kliendile.
local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')Pärast seda alustame kõikidel http-serveri liidestel pordist 8080, mis logib kõik päringud ja vead.
local httpd = http_server.new('0.0.0.0', 8080, {
log_requests = true,
log_errors = true
})Järgmisena deklareerime marsruudi, et kui GET meetodiga päring saabub pordile 8080 /count, siis kutsume funktsiooni ühelt realt. See tagastab oleku – 200, 404, 403 või mis iganes me täpsustame.
router:route({method = 'GET', path = '/count'}, function()
return {status = 200, body = json.encode({count = get_count()})}
end)Kehas tagastame json.encode, määrame selles count ja getcount, mida kutsutakse ja see näitab meie andmebaasi kirjete arvu.
Teine meetod
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)Kus reas ruuter:route({method = 'GET', path = '/token'}, function() kutsume funktsiooni välja ja genereerime märgi.
Rida kohalik tunnus = randomString(32) on 32 märgist koosnev juhuslik string.
Järjekorras kohalik viimane = box.space.example:len() tõmbame välja viimase elemendi.
Ja rivis box.space.example:insert{ viimane + 1, märk } kirjutame andmed oma andmebaasi ehk suurendame lihtsalt ID-d 1 võrra. Seda saab teha muide mitte ainult nii kohmakalt. Tarantul on selle juhtumi jaoks järjestused.
Kirjutame märgi sinna.
Seega kirjutasime avalduse ühte faili. Saate andmetele kohe juurde pääseda ja kastimoodul teeb kogu musta töö teie eest ära.
See kuulab http ja töötab andmetega, kõik on ühes eksemplaris - nii rakendus kui ka andmed. Seetõttu toimub kõik üsna kiiresti.
Käivitamiseks installime http mooduli:
Kuidas me seda teeme, vaata spoileri alt
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:/#Samuti vajame jooksmiseks Prometheust:
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:/#
Käivitame ja pääseme moodulitele juurde
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 annab meile staatuse 200.
/token väljastab märgi ja kirjutab selle loa andmebaasi.
Testimiskiirus
Käitame 50 000 päringu võrdlusuuringu. Konkurentsitaotlusi on 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:/#Tokenid väljastatakse. Ja me salvestame pidevalt andmeid. 99% taotlustest täideti 42 millisekundiga. Vastavalt sellele on meil väikesel masinal umbes 3500 päringut sekundis, kus on 2 tuuma ja 4 gigabaiti mälu.
Samuti saate valida 50000 XNUMX märgi ja vaadata selle väärtust.
Saate kasutada lisaks http-le ka taustafunktsioone, mis teie andmeid töötlevad. Lisaks on erinevaid käivitajaid. Näiteks saate värskenduste funktsioonidele helistada, midagi kontrollida - konflikte parandada.
Saate kirjutada skriptirakendusi otse andmebaasiserveris endas ja mitte olla millegagi piiratud, ühendada mis tahes mooduleid ja rakendada mis tahes loogikat.
Rakendusserver pääseb juurde välistele serveritele, kogub andmeid ja lisab need oma andmebaasi. Selle andmebaasi andmeid kasutavad teised rakendused.
Seda teeb Tarantula ise ja eraldi avaldust pole vaja kirjutada.
Kokkuvõttes
See on vaid esimene osa suurest tööst. Teine ilmub peagi Mail.ru Groupi ajaveebis ja kindlasti lisame sellesse artiklisse lingi.
Kui olete huvitatud üritustel osalemisest, kus me neid asju veebis loome, ja reaalajas küsimusi esitada, võtke ühendust.
Kui teil on vaja pilve üle minna või teil on oma infrastruktuuri kohta küsimusi, .
PS Meil on 2 tasuta auditit kuus, võib-olla on teie projekt üks neist.
Allikas: www.habr.com