For fem år siden prøvde jeg å jobbe med Tarantool, men da fungerte det ikke for meg. Men nylig holdt jeg et webinar hvor jeg snakket om Hadoop og hvordan MapReduce fungerer. Der stilte de meg et spørsmål: "Hvorfor ikke bruke Tarantool til denne oppgaven?"
For nysgjerrighetens skyld bestemte jeg meg for å gå tilbake til den, teste den siste versjonen – og denne gangen likte jeg prosjektet veldig godt. Nå skal jeg vise hvordan du skriver en enkel applikasjon i Tarantool, laster den og sjekker ytelsen, og du vil se hvor enkelt og kult alt er der.
Hva er Tarantool
Tarantool posisjonerer seg som en ultrarask database. Du kan legge inn alle data du vil. Pluss, repliker dem, shard - det vil si del en enorm mengde data på flere servere og kombiner resultatene fra dem - lag feiltolerante master-master-koblinger.
For det andre er det en applikasjonsserver. Du kan skrive applikasjonene dine på den, jobbe med data, for eksempel slette gamle oppføringer i bakgrunnen i henhold til visse regler. Du kan skrive en Http-server direkte i Tarantula som fungerer med data: gi ut nummeret deres, skriv nye data der og reduser det hele til en master.
Jeg leste en artikkel om hvordan gutta laget en 300-linjers meldingskø, som bare river og svir – de har en minimum ytelse på 20 000 meldinger per sekund. Her kan du virkelig snu deg og skrive en veldig stor søknad, og disse blir ikke lagret, som i PostgreS.
Jeg skal prøve å beskrive noe som denne serveren, bare enkelt, i denne artikkelen.
Installasjon
For testen startet jeg tre standard virtuelle maskiner - en 20 gigabyte harddisk, Ubuntu 18.04. 2 virtuelle CPU og 4 gigabyte minne.
Vi installerer Tarantool - kjør et bash-skript eller legg til et depot og installerer Tarantool. Link til manuset - (krøll -L | VER=2.4 sudo -E bash). Vi har kommandoer som:
tarantoolctl er hovedkommandoen for å administrere Tarantula-forekomster.
/etc/tarantool - her ligger hele konfigurasjonen.
var/log/tarantool - her er loggene.
var/lib/tarantool – her ligger dataene, og så deles de inn i instanser.
Det er mapper som er tilgjengelige for forekomst og aktiverer forekomster - den inneholder det som vil bli lansert - forekomstens konfigurasjonsfil med lua-kode, som beskriver hvilke porter den lytter på, hvilket minne som er tilgjengelig for den, vinylmotorinnstillinger, kode som fungerer ved oppstart servere, sharding, køer, sletting av foreldede data og så videre.
Forekomster fungerer som i PostgreS. For eksempel vil du kjøre flere kopier av en database som henger på forskjellige porter. Det viser seg at flere databaseforekomster blir lansert på én server, som henger på forskjellige porter. De kan ha helt forskjellige innstillinger - en instans implementerer en logikk, den andre - en annen.
Forekomstbehandling
Vi har kommandoen tarantoolctl som lar oss administrere Tarantula-forekomster. Tarantoolctl check eksempel vil for eksempel sjekke konfigurasjonsfilen og si at filen er ok hvis det ikke er syntaksfeil.
Du kan se statusen til forekomsten - tarantoolctl status eksempel. På samme måte kan du starte, stoppe, starte på nytt.
Når forekomsten kjører, kan du koble til den på to måter.
1. Administrasjonskonsoll
Som standard åpner Tarantool en socket og sender ren ASCII-tekst for å kontrollere Tarantula. Tilkobling til konsollen skjer alltid under admin-brukeren, det er ingen autentisering, så du trenger ikke ta ut konsollporten for å kontrollere Tarantulaen utenfor.
For å koble til på denne måten, må du skrive inn Tarantoolctl enter forekomstnavn. Kommandoen vil starte konsollen og koble til som admin-bruker. Utsett aldri konsollporten til utsiden - det er bedre å la den stå som en enhetskontakt. Da vil kun de som har skrivetilgang til stikkontakten kunne koble seg til Tarantulaen.
Denne metoden er nødvendig for administrative ting. For å jobbe med data, bruk den andre metoden - den binære protokollen.
2. Bruke en binær protokoll for å koble til en bestemt port
Det er et lyttedirektiv i konfigurasjonen, som åpner porten for ekstern kommunikasjon. Denne porten brukes med binær protokoll og autentisering er aktivert der.
For denne tilkoblingen brukes tarantoolctl connect to portnummer. Ved å bruke den kan du koble til eksterne servere, bruke autentisering og gi ulike tilgangsrettigheter.
Dataregistrering og boksmodul
Siden Tarantool både er en database og en applikasjonsserver, har den ulike moduler. Vi er interessert i boksmodulen - den implementerer arbeid med data. Når du skriver noe til en boks, skriver Tarantool dataene til disken, lagrer dem i minnet eller gjør noe annet med dem.
Record
For eksempel går vi inn i boksmodulen og kaller funksjonen boks.en gang. Det vil tvinge Tarantool til å kjøre koden vår når serveren initialiseres. Vi oppretter et rom hvor dataene våre vil bli lagret.
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')
endEtter det lager vi en primærindeks – primær – som vi kan søke etter data med. Som standard, hvis ingen parametere er spesifisert, vil det første feltet i hver oppføring for primerindeksen bli brukt.
Deretter gir vi et tilskudd til gjestebrukeren, som vi kobler til via en binær protokoll. Vi tillater lesing, skriving og utførelse i hele forekomsten.
Sammenlignet med konvensjonelle databaser er alt ganske enkelt her. Vi har plass – et område der dataene våre rett og slett lagres. Hver oppføring kalles en tuppel. Den er pakket i en MessagePack. Dette er et veldig kult format - det er binært og tar mindre plass - 18 byte mot 27.
Det er ganske praktisk å jobbe med ham. Nesten hver linje, hver dataoppføring kan ha helt forskjellige kolonner.
Vi kan vise alle mellomrom ved å bruke Box.space-kommandoen. For å velge en spesifikk forekomst skriver vi box.space eksempel og får full informasjon om det.
Tarantool har to innebygde motorer: Memory og Vinyl. Minnet lagrer alle data i minnet. Derfor fungerer alt enkelt og raskt. Dataene blir dumpet til disk, og det er også en loggmekanisme for å skrive frem, så vi vil ikke miste noe hvis serveren krasjer.
Vinyl lagrer data på disk i en form som er mer kjent for oss - det vil si at du kan lagre mer data enn vi har minne, og Tarantula vil lese det fra disk.
Nå skal vi bruke 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>indeks:
En primær indeks må opprettes for enhver plass, fordi ingenting vil fungere uten den. Som i enhver database oppretter vi det første feltet - post-IDen.
Deler:
Her angir vi hva indeksen vår består av. Den består av en del - det første feltet vi skal bruke er av typen usignert - et positivt heltall. Så vidt jeg husker fra dokumentasjonen er det maksimale antallet som kan være 18 kvintillioner. Det er mye.
Vi kan deretter sette inn data ved å bruke insert-kommandoen.
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ørste feltet brukes som primærnøkkel, så det må være unikt. Vi er ikke begrenset av antall kolonner, så vi kan sette inn så mye data vi vil der. De er spesifisert i MessagePack-formatet, som jeg beskrev ovenfor.
Datautgang
Deretter kan vi vise dataene med select-kommandoen.
Box.example.select med tasten {1} vil vise ønsket oppføring. Hvis vi utelater nøkkelen, vil vi se alle postene vi har. De er alle forskjellige i antall kolonner, men her er det i prinsippet ikke noe begrep om kolonner - det er feltnummer.
Det kan være absolutt så mye data du vil. Og for eksempel må vi søke etter dem i det andre feltet. For å gjøre dette lager vi en ny sekundærindeks.
box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }})
Vi bruker kommandoen Create_index.
Vi kaller det sekundært.
Etter det må du spesifisere parametrene. Indekstypen er TRÆ. Det er kanskje ikke unikt, så vi skriver inn Unique = false.
Deretter angir vi hvilke deler indeksen vår består av. Felt er nummeret på feltet som vi binder indeksen til, og spesifiserer strengtypen. Og slik ble det skapt.
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å er det slik vi kan kalle det:
unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...
bevaring
Hvis vi starter instansen på nytt og prøver å ringe dataene på nytt, vil vi se at de ikke er der - alt er tomt. Dette skjer fordi Tarantool lager sjekkpunkter og lagrer dataene på disk, men hvis vi slutter å jobbe før neste lagring, mister vi alle operasjoner – fordi vi kommer oss tilbake fra det siste sjekkpunktet, som for eksempel var for to timer siden.
Å spare hvert sekund vil heller ikke fungere – for å konstant dumpe 20 GB til disk er en så som så idé.
For dette ble konseptet med fremskrivningslogg oppfunnet og implementert. Med dens hjelp, for hver endring i dataene, blir det opprettet en post i en liten loggfil for fremskrivning.
Hver oppføring opp til sjekkpunktet er lagret i dem. For disse filene setter vi størrelsen - for eksempel 64 mb. Når den fylles opp, begynner opptaket å gå til den andre filen. Og etter omstarten gjenoppretter Tarantool seg fra det siste sjekkpunktet og ruller deretter over alle senere transaksjoner til det stopper.
For å utføre et slikt opptak, må du spesifisere alternativet i box.cfg-innstillingene (i example.lua-filen):
wal_mode = “write”;databruk
Med det vi har skrevet nå kan du bruke Tarantula til å lagre data og den vil fungere veldig raskt som en database. Og nå kirsebær på kaken - hva kan du gjøre med det hele.
Vi skriver en søknad
La oss for eksempel skrive en slik søknad for Tarantella
Se søknaden under spoileren
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 erklærer en tabell i lua som definerer tegnene. Denne platen er nødvendig for å generere en tilfeldig streng.
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
endEtter det erklærer vi en funksjon - randomString og gir lengdeverdien i 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)]
endDeretter kobler vi http-ruteren og http-serveren til vår Tarantula-server, JSON, som vi gir til klienten.
local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')Etter det starter vi på port 8080 på alle http-servergrensesnitt, som vil logge alle forespørsler og feil.
local httpd = http_server.new('0.0.0.0', 8080, {
log_requests = true,
log_errors = true
})Deretter erklærer vi en rute som hvis en forespørsel med GET-metoden kommer på port 8080 /count, så kaller vi funksjonen fra én linje. Den returnerer en status - 200, 404, 403 eller hva vi angir.
router:route({method = 'GET', path = '/count'}, function()
return {status = 200, body = json.encode({count = get_count()})}
end)I kroppen returnerer vi json.encode, vi spesifiserer count og getcount i den, som kalles og viser antall poster i databasen vår.
Den andre 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)Hvor i rekken ruter:rute({metode = 'GET', bane = '/token'}, funksjon() vi kaller funksjonen og genererer en token.
Linje lokal token = randomString(32) er en tilfeldig streng på 32 tegn.
På linje local last = box.space.example:len() vi trekker ut det siste elementet.
Og i køen box.space.example:insert{ siste + 1, token } vi skriver dataene inn i databasen vår, det vil si at vi rett og slett øker IDen med 1. Dette kan forresten gjøres ikke bare på denne klønete måten. Det er sekvenser for dette i Tarantula.
Vi skriver symbolet der.
Dermed skrev vi en søknad i én fil. Du får tilgang til dataene med en gang, og boksmodulen vil gjøre alt det skitne arbeidet for deg.
Den lytter til http og jobber med data, alt er i en enkelt instans – både applikasjonen og dataene. Derfor skjer alt ganske raskt.
For å kjøre, installerer vi http-modulen:
Hvordan vi gjør det, se under spoileren
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 trenger også prometheus for å kjøre:
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 starter og kan få tilgang til moduler
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 gir oss status 200.
/token utsteder et token og skriver dette tokenet til databasen.
Tester hastigheten
La oss kjøre en benchmark for 50 000 søk. Konkurransedyktige forespørsler vil være 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:/#Tokens utstedes. Og vi registrerer stadig data. 99 % av forespørslene ble behandlet på 42 millisekunder. Følgelig har vi omtrent 3500 forespørsler per sekund på en liten maskin med 2 kjerner og 4 gigabyte minne.
Du kan også velge noen 50000 token og se verdien.
Du kan ikke bare bruke http, kjøre bakgrunnsfunksjoner som behandler dataene dine. I tillegg er det forskjellige triggere. Du kan for eksempel kalle opp funksjoner på oppdateringer, sjekke noe - fikse konflikter.
Du kan skrive skriptapplikasjoner direkte i selve databaseserveren, og ikke være begrenset av noe, koble til eventuelle moduler og implementere hvilken som helst logikk.
Applikasjonsserveren kan få tilgang til eksterne servere, samle inn data og legge dem til databasen. Data fra denne databasen vil bli brukt av andre applikasjoner.
Dette vil gjøres av Tarantellen selv, og det er ikke nødvendig å skrive en egen søknad.
i konklusjonen
Dette er bare første del av et stort arbeid. Den andre vil snart bli publisert på Mail.ru Group-bloggen, og vi vil definitivt legge til en lenke til den i dette materialet.
Hvis du er interessert i å delta på arrangementer der vi lager disse tingene på nettet og stille spørsmål i sanntid, koble til.
Hvis du trenger å flytte til skyen eller har spørsmål om infrastrukturen din, .
PS Vi har 2 gratis revisjoner per måned, kanskje prosjektet ditt blir en av dem.
Kilde: www.habr.com