För fem år sedan försökte jag arbeta med Tarantool, men då fungerade det inte för mig. Men nyligen höll jag ett webinar där jag pratade om Hadoop och hur MapReduce fungerar. Där ställde de en fråga till mig: "Varför inte använda Tarantool för den här uppgiften?"
Av nyfikenhet bestämde jag mig för att återvända till det, testa den senaste versionen – och den här gången gillade jag projektet verkligen. Nu ska jag visa dig hur du skriver en enkel applikation i Tarantool, laddar den och kontrollerar dess prestanda, och du kommer att se hur enkelt och coolt allt är.
Vad är Tarantool
Tarantool positionerar sig som en ultrasnabb databas. Du kan lägga vilken data du vill där. Plus, replikera dem, skära - det vill säga dela en enorm mängd data över flera servrar och kombinera resultaten från dem - skapa feltoleranta master-master-anslutningar.
För det andra är detta en applikationsserver. Du kan skriva dina applikationer på den, arbeta med data, till exempel radera gamla poster i bakgrunden enligt vissa regler. Du kan skriva en Http-server direkt i Tarantula som kommer att arbeta med data: ge ut deras kvantitet, skriv ny data där och reducera allt till mastern.
Jag läste en artikel om hur killarna skapade en meddelandekö på 300 rader, vilket helt enkelt spricker och rusar – de har en minimiprestanda på 20 000 meddelanden per sekund. Här kan du verkligen vända dig om och skriva en väldigt stor applikation, och det blir inte lagring, som i PostgreS.
Jag ska försöka beskriva något som denna server, bara enkelt, i den här artikeln.
Installation
För testet startade jag tre vanliga virtuella maskiner - en 20 GB hårddisk, Ubuntu 18.04. 2 virtuella processorer och 4 spelningar minne.
Vi installerar Tarantool - kör bash-skriptet eller lägg till ett arkiv och installerar Tarantool. Länk till manus - (curl -L | VER=2.4 sudo -E bash). Vi har kommandon som:
tarantoolctl — huvudkommandot för att hantera Tarantula-instanser.
/etc/tarantool - här är hela konfigurationen.
var/log/tarantool - här är loggarna.
var/lib/tarantool — uppgifterna ligger här, och sedan delas de in i instanser.
Det finns mappar instance-available och instance-enable - den innehåller det som kommer att lanseras - en instanskonfigurationsfil med lua-kod, som beskriver vilka portar den lyssnar på, vilket minne som är tillgängligt för den, vinylmotorinställningar, kod som körs vid start servrar, skärning, köer, radering av föråldrad data och så vidare.
Instanser fungerar som i PostgreS. Till exempel vill du köra flera kopior av en databas som hänger på olika portar. Det visar sig att flera databasinstanser startas på en server, som hänger på olika portar. De kan ha helt olika inställningar - en instans implementerar en logik, den andra - en annan.
Instanshantering
Vi har kommandot tarantoolctl, som låter dig hantera Tarantula-instanser. Till exempel kommer tarantoolctl check exempel att kontrollera konfigurationsfilen och säga - filen är ok om det inte finns några syntaxfel där.
Du kan se statusen för instansen - tarantoolctl statusexempel. På samma sätt kan du starta, stoppa, starta om.
När instansen väl körs kan du ansluta till den på två sätt.
1. Administrativ konsol
Som standard öppnar Tarantool en socket, normal ASCII-text skickas dit för att styra Tarantool. Anslutning till konsolen sker alltid under administratörsanvändaren, det finns ingen autentisering, så det finns inget behov av att externisera konsolporten för att hantera Tarantula.
För att ansluta med den här metoden måste du ange Tarantoolctl enter instansnamn. Kommandot startar konsolen och ansluter som administratörsanvändare. Exponera aldrig konsolporten till utsidan - det är bättre att lämna den som ett enhetsuttag. Då är det bara de som har tillgång att skriva till uttaget som kan koppla upp sig mot Tarantula.
Denna metod behövs för administrativa saker. För att arbeta med data, använd den andra metoden - det binära protokollet.
2. Använda ett binärt protokoll för att ansluta till en specifik port
Konfigurationen innehåller ett lyssningsdirektiv, som öppnar en port för extern kommunikation. Denna port används med det binära protokollet och autentisering är aktiverad där.
För denna anslutning används tarantoolctl connect to portnummer. Med hjälp av den kan du ansluta till fjärrservrar, använda autentisering och ge olika åtkomsträttigheter.
Datainspelning och boxmodul
Eftersom Tarantool både är en databas och en applikationsserver har den olika moduler. Vi är intresserade av boxmodulen - den implementerar att arbeta med data. När du skriver något till box, skriver Tarantool data till disk, lagrar det i minnet eller gör något annat med det.
Rekord
Vi går till exempel in i boxmodulen och anropar box.once-funktionen. Detta kommer att tvinga Tarantool att köra vår kod när servern initieras. Vi skapar ett utrymme där vår data kommer att lagras.
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')
endEfter detta skapar vi ett primärt index - primärt - med vilket vi kan söka efter data. Som standard, om du inte anger några parametrar, kommer det första fältet i varje post att användas för det primära indexet.
Sedan gör vi ett bidrag till gästanvändaren, under vilket vi ansluter via det binära protokollet. Vi tillåter läsning, skrivning och exekvering över hela instansen.
Jämfört med konventionella databaser är allt här ganska enkelt. Vi har utrymme – ett område där vår data helt enkelt lagras. Varje post kallas en tuppel. Den är förpackad i MessagePack. Det här är ett väldigt coolt format - det är binärt och tar mindre plats - 18 byte mot 27.
Det är ganska bekvämt att arbeta med honom. Nästan varje rad, varje datapost kan ha helt olika kolumner.
Vi kan visa alla mellanslag med kommandot Box.space. För att välja en specifik instans, skriv box.space-exempel och få fullständig information om den.
Tarantool har två inbyggda motorer: Memory och Vinyl. Minnet lagrar all data i minnet. Därför fungerar allt enkelt och snabbt. Datan dumpas till disken, och det finns också en loggmekanism för att skriva framåt, så vi kommer inte att förlora något om servern kraschar.
Vinyl lagrar data på disken i en form som är mer bekant för oss - det vill säga du kan lagra mer data än vi har minne, och Tarantula kommer att läsa det från disken.
För nu kommer vi att använda 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:
Ett primärt index måste skapas för vilket utrymme som helst, för utan det fungerar ingenting. Som i vilken databas som helst skapar vi det första fältet – post-ID.
Delar:
Här anger vi vad vårt index består av. Den består av en del - det första fältet vi kommer att använda är av typen unsigned - ett positivt heltal. Såvitt jag minns från dokumentationen är det maximala antalet som kan vara 18 kvintiljoner. Det är mycket.
Sedan kan vi infoga data med kommandot 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>Det första fältet används som primärnyckel, så det måste vara unikt. Vi är inte begränsade av antalet kolumner, så vi kan infoga hur mycket data vi vill där. De är specificerade i MessagePack-formatet, som jag beskrev ovan.
Datautgång
Sedan kan vi visa data med hjälp av kommandot select.
Box.example.select med {1}-tangenten visar önskad post. Om vi sänker nyckeln kommer vi att se alla rekord vi har. De skiljer sig alla åt i antalet kolumner, men här finns i princip inget begrepp om kolumner - det finns fältnummer.
Det kan finnas absolut hur mycket data som helst. Och till exempel måste vi söka efter dem i det andra fältet. För att göra detta skapar vi ett nytt sekundärt index.
box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }})
Vi använder kommandot Create_index.
Låt oss kalla det sekundärt.
Efter detta måste du ange parametrarna. Indextypen är TREE. Det kanske inte är unikt, så ange Unique = false.
Sedan anger vi vilka delar vårt index består av. Fält är numret på fältet som vi binder indexet till och anger strängtypen. Och så skapades den.
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>Nu är det så här vi kan kalla det:
unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...
konservering
Om vi startar om instansen och försöker ringa upp data igen ser vi att den inte finns där – allt är tomt. Detta händer för att Tarantool gör checkpoints och sparar data till disk, men om vi slutar arbeta tills nästa sparning kommer vi att förlora alla operationer - eftersom vi kommer att återhämta oss från den senaste checkpointen, som var till exempel för två timmar sedan.
Det kommer inte att fungera att spara varje sekund heller, eftersom det inte är en bra idé att ständigt dumpa 20 GB på disken.
För detta ändamål uppfanns och implementerades konceptet med loggbok. Med dess hjälp skapas en post för varje ändring i data i en liten loggfil för att skriva framåt.
Varje ingång fram till kontrollpunkten lagras i dem. För dessa filer ställer vi in storleken - till exempel 64 MB. När den är full börjar inspelningen gå till den andra filen. Och efter omstarten återställs Tarantool från den sista kontrollpunkten och rullar sedan över alla senare transaktioner tills det stannar.
För att utföra en sådan inspelning måste du ange alternativet i box.cfg-inställningarna (i filen example.lua):
wal_mode = “write”;dataanvändning
Med det vi har skrivit nu kan du använda Tarantula för att lagra data och det kommer att fungera väldigt snabbt som en databas. Och nu är grädden på moset vad du kan göra med allt.
Att skriva en ansökan
Låt oss till exempel skriva följande applikation för Tarantula
Se ansökan under spoilern
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()Vi deklarerar någon tabell i lua som definierar tecknen. Denna platta behövs för att generera en slumpmässig sträng.
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
endEfter det deklarerar vi funktionen - randomString och ger längdvärdet inom parentes.
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)]
endSedan kopplar vi http-routern och http-servern till vår Tarantula-server, JSON, som vi skickar till klienten.
local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')Efter detta börjar vi på port 8080 på alla http-servergränssnitt, som loggar alla förfrågningar och fel.
local httpd = http_server.new('0.0.0.0', 8080, {
log_requests = true,
log_errors = true
})Därefter deklarerar vi rutt, så att om en begäran med GET-metoden anländer på port 8080 /count, så anropar vi funktionen från en rad. Den returnerar status - 200, 404, 403 eller något annat som vi anger.
router:route({method = 'GET', path = '/count'}, function()
return {status = 200, body = json.encode({count = get_count()})}
end)I kroppen returnerar vi json.encode, i den anger vi count och getcount, som anropas och visar antalet poster i vår databas.
Den andra metoden
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)Var i raden router:route({method = 'GET', path = '/token'}, function() vi anropar funktionen och genererar en token.
Linje lokal token = randomString(32) är en slumpmässig sträng på 32 tecken.
I kö local last = box.space.example:len() vi tar ut det sista elementet.
Och i kö box.space.example:insert{ last + 1, token } vi skriver in datan i vår databas, det vill säga vi ökar helt enkelt ID:t med 1. Detta kan för övrigt göras inte bara på det här klumpiga sättet. Det finns sekvenser för detta i Tarantula.
Vi skriver token där.
Därför skrev vi ansökan i en fil. Du kan direkt manipulera data där, och boxmodulen kommer att göra allt det smutsiga arbetet åt dig.
Den lyssnar på http och arbetar med data, allt finns i en enda instans – både applikationen och data. Därför händer allt ganska snabbt.
För att börja installerar vi http-modulen:
Hur vi gör detta, titta under spoilern
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:/#Vi behöver också prometheus för att köra:
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:/#
Vi lanserar och kan komma åt modulerna
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 ger oss statusen 200.
/token utfärdar en token och skriver denna token till databasen.
Testar hastigheten
Låt oss köra ett riktmärke för 50 000 förfrågningar. Det kommer att finnas 500 konkurrerande förfrågningar.
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 utfärdas. Och vi registrerar ständigt data. 99 % av förfrågningarna behandlades på 42 millisekunder. Följaktligen har vi cirka 3500 förfrågningar per sekund på en liten maskin med 2 kärnor och 4 gigabyte minne.
Du kan också välja cirka 50000 XNUMX token och se dess värde.
Du kan inte bara använda http, utan även köra bakgrundsfunktioner som bearbetar dina data. Dessutom finns det olika triggers. Du kan till exempel anropa funktioner på uppdateringar, kolla något - korrigera konflikter.
Du kan skriva skriptapplikationer direkt i själva databasservern, och inte begränsas av någonting, ansluta vilka moduler som helst och implementera vilken logik som helst.
Applikationsservern kan komma åt externa servrar, hämta data och lägga till den i sin databas. Data från denna databas kommer att användas av andra applikationer.
Tarantula kommer att göra detta själv, och du behöver inte skriva en separat ansökan.
Sammanfattningsvis
Detta är bara den första delen av ett stort verk. Den andra kommer att publiceras mycket snart på Mail.ru Group-bloggen, och vi kommer definitivt att lägga till en länk till den i det här materialet.
Om du är intresserad av att delta i evenemang där vi bygger dessa saker online och ställa frågor i realtid, lyssna på.
Om du behöver flytta till molnet eller har frågor om din infrastruktur, .
PS Vi har 2 gratis revisioner per månad, kanske ditt projekt blir en av dem.
Källa: will.com