Acum cinci ani am încercat să lucrez cu Tarantool, dar apoi nu a funcționat pentru mine. Dar recent am ținut un webinar în care am vorbit despre Hadoop și cum funcționează MapReduce. Acolo mi-au pus o întrebare: „De ce să nu folosesc Tarantool pentru această sarcină?”
Din curiozitate, am decis să revin la el, să testez cea mai recentă versiune – și de data aceasta mi-a plăcut foarte mult proiectul. Acum vă voi arăta cum să scrieți o aplicație simplă în Tarantool, să o încărcați și să verificați performanța ei și veți vedea cât de ușor și cool este totul.
Ce este Tarantool
Tarantool se poziționează ca o bază de date ultra-rapidă. Puteți pune orice date doriți acolo. În plus, replicați-le, shard - adică împărțiți o cantitate imensă de date pe mai multe servere și combinați rezultatele de la acestea - faceți conexiuni master-master tolerante la erori.
În al doilea rând, acesta este un server de aplicații. Puteți să vă scrieți aplicațiile pe el, să lucrați cu date, de exemplu, să ștergeți înregistrările vechi în fundal conform anumitor reguli. Puteți scrie un server Http direct în Tarantula care va funcționa cu date: dați-le cantitatea, scrieți date noi acolo și reduceți totul la master.
Am citit un articol despre cum băieții au făcut o coadă de mesaje de 300 de linii, care este pur și simplu exploziv și grăbit - au o performanță minimă de 20 de mesaje pe secundă. Aici vă puteți întoarce cu adevărat și scrie o aplicație foarte mare și nu va fi stocare, ca în PostgreS.
Voi încerca să descriu ceva ca acest server, doar simplu, în acest articol.
Instalare
Pentru test, am pornit trei mașini virtuale standard - un hard disk de 20 GB, Ubuntu 18.04. 2 procesoare virtuale și 4 giga de memorie.
Instalăm Tarantool - rulăm scriptul bash sau adăugăm un depozit și facem apt get install Tarantool. Link către script - (curl -L | VER=2.4 sudo -E bash). Avem comenzi precum:
tarantoolctl — comanda principală pentru gestionarea instanțelor Tarantula.
/etc/tarantool - aici este întreaga configurație.
var/log/tarantool - aici sunt jurnalele.
var/lib/tarantool — datele se află aici și apoi sunt împărțite în instanțe.
Există foldere instance-available și instance-enable - conține ceea ce va fi lansat - un fișier de configurare a instanței cu cod lua, care descrie pe ce porturi ascultă, ce memorie este disponibilă, setările motorului Vinyl, codul care rulează la pornire servere, sharding, cozi, ștergerea datelor învechite și așa mai departe.
Instanțele funcționează ca în PostgreS. De exemplu, doriți să rulați mai multe copii ale unei baze de date care se blochează pe diferite porturi. Se dovedește că pe un server sunt lansate mai multe instanțe de baze de date, care se blochează pe diferite porturi. Ele pot avea setări complet diferite - o instanță implementează o logică, a doua - alta.
Managementul instanțelor
Avem comanda tarantoolctl, care vă permite să gestionați instanțe Tarantula. De exemplu, exemplul de verificare tarantoolctl va verifica fișierul de configurare și va spune - fișierul este ok dacă nu există erori de sintaxă acolo.
Puteți vedea starea instanței - exemplu de stare tarantoolctl. În același mod, puteți face pornirea, oprirea, repornirea.
Odată ce instanța rulează, vă puteți conecta la ea în două moduri.
1. Consolă administrativă
În mod implicit, Tarantool deschide un socket, textul ASCII normal este trimis acolo pentru a controla Tarantool. Conexiunea la consolă are loc întotdeauna sub utilizatorul admin, nu există autentificare, deci nu este nevoie să externalizați portul de consolă pentru a gestiona Tarantula.
Pentru a vă conecta folosind această metodă, trebuie să introduceți Tarantoolctl introduceți numele instanței. Comanda va lansa consola și va conecta ca utilizator administrator. Nu expuneți niciodată portul consolei la exterior - este mai bine să-l lăsați ca priză pentru unitate. Atunci doar cei care au acces să scrie pe socket se vor putea conecta la Tarantula.
Această metodă este necesară pentru lucruri administrative. Pentru a lucra cu date, utilizați a doua metodă - protocolul binar.
2. Utilizarea unui protocol binar pentru a vă conecta la un anumit port
Configurația conține o directivă de ascultare, care deschide un port pentru comunicații externe. Acest port este utilizat cu protocolul binar și autentificarea este activată acolo.
Pentru această conexiune, se folosește tarantoolctl connect to port number. Folosind-o, vă puteți conecta la servere la distanță, utilizați autentificarea și acordați diferite drepturi de acces.
Modul de înregistrare a datelor și box
Deoarece Tarantool este atât o bază de date, cât și un server de aplicații, are diverse module. Suntem interesați de modulul cutie - implementează lucrul cu date. Când scrieți ceva pe cutie, Tarantool scrie datele pe disc, le stochează în memorie sau face altceva cu ele.
Record
De exemplu, intrăm în modulul box și apelăm funcția box.once. Acest lucru va forța Tarantool să ruleze codul nostru atunci când serverul este inițializat. Creăm un spațiu în care datele noastre vor fi stocate.
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')
endDupă aceasta, creăm un index primar - primar - prin care putem căuta date. În mod implicit, dacă nu specificați niciun parametru, primul câmp din fiecare înregistrare va fi folosit pentru indexul primar.
Apoi acordăm o grant utilizatorului invitat, sub care ne conectăm prin protocolul binar. Permitem citirea, scrierea și executarea în întreaga instanță.
În comparație cu bazele de date convenționale, totul aici este destul de simplu. Avem spațiu - o zonă în care datele noastre sunt pur și simplu stocate. Fiecare înregistrare se numește tuplu. Este ambalat în MessagePack. Acesta este un format foarte cool - este binar și ocupă mai puțin spațiu - 18 octeți față de 27.
Este destul de convenabil să lucrezi cu el. Aproape fiecare linie, fiecare înregistrare de date poate avea coloane complet diferite.
Putem vizualiza toate spațiile folosind comanda Box.space. Pentru a selecta o anumită instanță, scrieți exemplu box.space și obțineți informații complete despre aceasta.
Tarantool are două motoare încorporate: Memory și Vinyl. Memoria stochează toate datele în memorie. Prin urmare, totul funcționează simplu și rapid. Datele sunt aruncate pe disc și există, de asemenea, un mecanism de jurnal de scriere înainte, astfel încât nu vom pierde nimic dacă serverul se blochează.
Vinyl stochează datele pe disc într-o formă mai familiară nouă - adică puteți stoca mai multe date decât avem memorie, iar Tarantula le va citi de pe disc.
Deocamdată vom folosi 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:
Trebuie creat un index primar pentru orice spațiu, deoarece fără el nimic nu va funcționa. Ca în orice bază de date, creăm primul câmp – ID înregistrare.
Piese de schimb:
Aici indicăm în ce constă indexul nostru. Este alcătuit dintr-o parte - primul câmp pe care îl vom folosi este de tip unsigned - un număr întreg pozitiv. Din câte îmi amintesc din documentație, numărul maxim care poate fi este de 18 chintilioane. Asta e mult.
Apoi putem introduce date folosind comanda 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>Primul câmp este folosit ca cheie primară, deci trebuie să fie unic. Nu suntem limitați de numărul de coloane, așa că putem introduce acolo câte date vrem. Sunt specificate în formatul MessagePack, pe care l-am descris mai sus.
Ieșire de date
Apoi putem afișa datele folosind comanda select.
Caseta.exemplu.selectați cu tasta {1} va afișa intrarea dorită. Dacă coborâm cheia, vom vedea toate înregistrările pe care le avem. Toate diferă în ceea ce privește numărul de coloane, dar aici, în principiu, nu există un concept de coloane - există numere de câmp.
Poate exista absolut orice cantitate de date. Și, de exemplu, trebuie să le căutăm după al doilea câmp. Pentru a face acest lucru, creăm un nou index secundar.
box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }})
Folosim comanda Create_index.
Să-i spunem Secundar.
După aceasta, trebuie să specificați parametrii. Tipul de index este TREE. Este posibil să nu fie unic, așa că introduceți Unique = false.
Apoi indicăm din ce părți constă indexul nostru. Câmp este numărul câmpului la care legăm indexul și specificăm tipul șirului. Și așa a fost creat.
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>Acum, așa o putem numi:
unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...
conservare
Dacă repornim instanța și încercăm să apelăm din nou datele, vom vedea că nu sunt acolo - totul este gol. Acest lucru se întâmplă deoarece Tarantool face puncte de control și salvează datele pe disc, dar dacă încetăm să lucrăm până la următoarea salvare, vom pierde toate operațiunile - pentru că ne vom recupera de la ultimul punct de control, care a fost, de exemplu, acum două ore.
Nu va funcționa nici să economisiți fiecare secundă, deoarece descărcarea constantă a 20 GB pe disc nu este o idee bună.
În acest scop, a fost inventat și implementat conceptul de jurnal de scriere anticipată. Cu ajutorul acestuia, pentru fiecare modificare a datelor, este creată o intrare într-un mic fișier jurnal de scriere anticipată.
Fiecare intrare până la punctul de control este stocată în ele. Pentru aceste fișiere setăm dimensiunea - de exemplu, 64 MB. Când este plin, înregistrarea începe să treacă la al doilea fișier. Și după repornire, Tarantool este restaurat de la ultimul punct de control și apoi trece peste toate tranzacțiile ulterioare până când se oprește.
Pentru a efectua o astfel de înregistrare, trebuie să specificați opțiunea în setările box.cfg (în fișierul example.lua):
wal_mode = “write”;utilizarea de date
Cu ceea ce am scris acum, puteți folosi Tarantula pentru a stoca date și va funcționa foarte repede ca bază de date. Și acum cireașa de pe tort este ceea ce poți face cu toate acestea.
Scrierea unei cereri
De exemplu, să scriem următoarea aplicație pentru Tarantula
Vezi aplicația sub 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()Declarăm un tabel în lua care definește caracterele. Această placă este necesară pentru a genera un șir aleator.
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
endDupă aceea, declarăm funcția - randomString și dăm valoarea lungimii în paranteze.
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)]
endApoi conectăm routerul http și serverul http la serverul nostru Tarantula, JSON, pe care îl vom trimite clientului.
local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')După aceasta, începem pe portul 8080 pe toate interfețele serverului http, care va înregistra toate solicitările și erorile.
local httpd = http_server.new('0.0.0.0', 8080, {
log_requests = true,
log_errors = true
})În continuare, declarăm ruta, astfel încât dacă o solicitare cu metoda GET ajunge pe portul 8080 /count, atunci apelăm funcția de pe o linie. Returnează starea - 200, 404, 403 sau oricare alta pe care o specificăm.
router:route({method = 'GET', path = '/count'}, function()
return {status = 200, body = json.encode({count = get_count()})}
end)În body returnăm json.encode, în el indicăm count și getcount, care este numit și arată numărul de înregistrări din baza noastră de date.
A doua metodă
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)Unde în linie router:route({method = 'GET', path = '/token'}, function() apelăm funcția și generăm un token.
rând jeton local = randomString(32) este un șir aleatoriu de 32 de caractere.
In linie local last = box.space.example:len() scoatem ultimul element.
Și în linie box.space.example:insert{ last + 1, token } scriem datele în baza noastră de date, adică pur și simplu creștem ID-ul cu 1. Acest lucru se poate face, apropo, nu numai în acest mod stângaci. Există secvențe pentru asta în Tarantula.
Scriem jetonul acolo.
Astfel, am scris aplicația într-un singur fișier. Puteți manipula direct datele acolo, iar modulul cutie va face toată munca murdară pentru dvs.
Ascultă http și funcționează cu date, totul este într-o singură instanță - atât aplicația, cât și datele. Prin urmare, totul se întâmplă destul de repede.
Pentru a începe, instalăm modulul http:
Cum facem asta, uită-te sub 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:/#Avem nevoie și de prometheus pentru a rula:
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:/#
Lansăm și putem accesa modulele
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 ne dă statutul 200.
/token emite un token și scrie acest token în baza de date.
Testarea vitezei
Să rulăm un benchmark pentru 50 de solicitări. Vor fi 000 de cereri concurente.
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:/#Se emit jetoane. Și înregistrăm în mod constant date. 99% dintre cereri au fost procesate în 42 de milisecunde. În consecință, avem aproximativ 3500 de solicitări pe secundă pe o mașină mică cu 2 nuclee și 4 gigaocteți de memorie.
De asemenea, puteți selecta aproximativ 50000 de jetoane și puteți vedea valoarea acestuia.
Puteți utiliza nu numai http, ci și să rulați funcții de fundal care vă prelucrează datele. În plus, există diferiți factori declanșatori. De exemplu, puteți apela funcții privind actualizările, verificați ceva - corectați conflictele.
Puteți scrie aplicații de script direct în serverul de baze de date în sine, și nu vă limitați de nimic, conectați orice module și implementați orice logică.
Serverul de aplicații poate accesa servere externe, poate prelua date și le poate adăuga la baza de date. Datele din această bază de date vor fi folosite de alte aplicații.
Tarantula va face acest lucru singură și nu va trebui să scrieți o aplicație separată.
în concluzie
Aceasta este doar prima parte a unei mari lucrări. Al doilea va fi publicat foarte curând pe blogul Mail.ru Group și cu siguranță vom adăuga un link către acesta în acest material.
Dacă sunteți interesat să participați la evenimente în care construim aceste lucruri online și să puneți întrebări în timp real, conectați-vă.
Dacă trebuie să treceți la cloud sau aveți întrebări despre infrastructura dvs., .
PS Avem 2 audituri gratuite pe lună, poate că proiectul tău va fi unul dintre ele.
Sursa: www.habr.com