I Tarantool kan du kombinere en superhurtig database og et program for at arbejde med dem. Her er, hvor nemt det er at gøre

For fem år siden prøvede jeg at arbejde med Tarantool, men så virkede det ikke for mig. Men for nylig holdt jeg et webinar, hvor jeg talte om Hadoop og hvordan MapReduce virker. Der stillede de mig et spørgsmål: "Hvorfor ikke bruge Tarantool til denne opgave?"

Af nysgerrighed besluttede jeg at vende tilbage til det, teste den seneste version – og denne gang kunne jeg virkelig godt lide projektet. Nu vil jeg vise dig, hvordan du skriver en simpel applikation i Tarantool, indlæser den og kontrollerer dens ydeevne, og du vil se, hvor nemt og fedt alt er.

Hvad er Tarantool

Tarantool positionerer sig som en ultrahurtig database. Du kan lægge alle data, du ønsker, der. Plus, repliker dem, shard - det vil sige opdel en enorm mængde data på tværs af flere servere og kombiner resultaterne fra dem - lav fejltolerante master-master-forbindelser.

For det andet er dette en applikationsserver. Du kan skrive dine applikationer på den, arbejde med data, for eksempel slette gamle poster i baggrunden efter bestemte regler. Du kan skrive en Http-server direkte i Tarantula, der vil arbejde med data: udlever deres mængde, skriv nye data der og reducer det hele til masteren.

Jeg læste en artikel om, hvordan fyrene lavede en beskedkø på 300 linjer, som simpelthen brister og haster – de har en minimumsydelse på 20 beskeder i sekundet. Her kan man virkelig vende sig om og skrive en meget stor ansøgning, og det bliver ikke opbevaring, som i PostgreS.

Jeg vil prøve at beskrive noget som denne server, kun simpelt, i denne artikel.

Installation

Til testen startede jeg tre standard virtuelle maskiner - en 20 GB harddisk, Ubuntu 18.04. 2 virtuelle CPU'er og 4 gigs hukommelse.

Vi installerer Tarantool - kør bash-scriptet eller tilføj et depot og installerer Tarantool. Link til script - (krølle -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Vi har kommandoer som:

tarantoolctl — hovedkommandoen til styring af Tarantula-forekomster.
/etc/tarantool - her er hele konfigurationen.
var/log/tarantool - her er loggene.
var/lib/tarantool — dataene ligger her, og så opdeles det i instanser.

Der er mapper instance-available og instance-enable - den indeholder, hvad der vil blive lanceret - en instance-konfigurationsfil med lua-kode, som beskriver hvilke porte den lytter på, hvilken hukommelse der er tilgængelig for den, vinylmotorindstillinger, kode, der kører ved opstart servere, sharding, køer, sletning af forældede data og så videre.

Forekomster fungerer som i PostgreS. For eksempel vil du køre flere kopier af en database, der hænger på forskellige porte. Det viser sig, at flere databaseinstanser lanceres på én server, som hænger på forskellige porte. De kan have helt forskellige indstillinger - en instans implementerer en logik, den anden - en anden.

Forekomststyring

Vi har kommandoen tarantoolctl, som giver dig mulighed for at administrere Tarantula-forekomster. For eksempel vil tarantoolctl check eksempel tjekke konfigurationsfilen og sige - filen er ok, hvis der ikke er syntaksfejl der.

Du kan se status for instansen - tarantoolctl status eksempel. På samme måde kan du starte, stoppe, genstarte.

Når instansen kører, kan du oprette forbindelse til den på to måder.

1. Administrativ konsol

Som standard åbner Tarantool en socket, normal ASCII-tekst sendes dertil for at styre Tarantool. Forbindelse til konsollen sker altid under admin-brugeren, der er ingen godkendelse, så der er ingen grund til at eksternalisere konsolporten for at administrere Tarantula.

For at oprette forbindelse ved hjælp af denne metode skal du indtaste Tarantoolctl enter instansnavn. Kommandoen vil starte konsollen og oprette forbindelse som admin-bruger. Udsæt aldrig konsolporten til ydersiden - det er bedre at lade den være som en enhedsstikkontakt. Så er det kun dem, der har adgang til at skrive til stikkontakten, der kan oprette forbindelse til Tarantula.

Denne metode er nødvendig for administrative ting. For at arbejde med data skal du bruge den anden metode - den binære protokol.

2. Brug af en binær protokol til at oprette forbindelse til en specifik port

Konfigurationen indeholder et lyttedirektiv, som åbner en port for ekstern kommunikation. Denne port bruges sammen med den binære protokol, og godkendelse er aktiveret der.

Til denne forbindelse bruges tarantoolctl connect to portnummer. Ved at bruge det kan du oprette forbindelse til fjernservere, bruge godkendelse og give forskellige adgangsrettigheder.

Dataoptagelse og boksmodul

Da Tarantool både er en database og en applikationsserver, har den forskellige moduler. Vi er interesserede i boksmodulet - det implementerer arbejdet med data. Når du skriver noget til boksen, skriver Tarantool dataene til disken, gemmer dem i hukommelsen eller gør noget andet med det.

Optag

For eksempel går vi ind i boksmodulet og kalder funktionen box.once. Dette vil tvinge Tarantool til at køre vores kode, når serveren initialiseres. Vi opretter et rum, hvor vores data vil blive opbevaret.

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')
end

Herefter opretter vi et primært indeks - primært - hvormed vi kan søge efter data. Som standard, hvis du ikke angiver nogen parametre, vil det første felt i hver post blive brugt til det primære indeks.

Derefter giver vi en bevilling til gæstebrugeren, hvorunder vi forbinder via den binære protokol. Vi tillader læsning, skrivning og eksekvering på tværs af hele instansen.

Sammenlignet med konventionelle databaser er alt her ganske enkelt. Vi har plads – et område, hvor vores data simpelthen opbevares. Hver post kaldes en tupel. Det er pakket i MessagePack. Dette er et meget cool format - det er binært og fylder mindre - 18 bytes mod 27.

Det er ret praktisk at arbejde med ham. Næsten hver linje, hver datapost kan have helt forskellige kolonner.

Vi kan se alle mellemrum ved at bruge kommandoen Box.space. For at vælge en specifik instans skal du skrive box.space-eksempel og få fuldstændige oplysninger om det.

Tarantool har to indbyggede motorer: Memory og Vinyl. Hukommelsen gemmer alle data i hukommelsen. Derfor fungerer alt enkelt og hurtigt. Dataene dumpes til disken, og der er også en skrive-forud-logmekanisme, så vi ikke mister noget, hvis serveren går ned.

Vinyl gemmer data på disken i en form, der er mere bekendt for os - det vil sige, du kan gemme flere data, end vi har hukommelse, og Tarantula vil læse det fra disken.

For nu vil vi bruge 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:

Et primært indeks skal oprettes for ethvert rum, for uden det fungerer intet. Som i enhver database opretter vi det første felt – record ID.

Dele:

Her angiver vi, hvad vores indeks består af. Det består af én del - det første felt, vi vil bruge, er af typen unsigned - et positivt heltal. Så vidt jeg husker fra dokumentationen, er det maksimale antal, der kan være 18 kvintillioner. Det er en del.

Så kan vi indsætte data ved hjælp af kommandoen indsæt.

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 felt bruges som den primære nøgle, så det skal være unikt. Vi er ikke begrænset af antallet af kolonner, så vi kan indsætte så meget data, som vi vil der. De er specificeret i MessagePack-formatet, som jeg beskrev ovenfor.

Dataoutput

Derefter kan vi vise dataene ved hjælp af select-kommandoen.

Box.example.select med {1}-tasten vil vise den ønskede post. Hvis vi sænker tasten, vil vi se alle de poster, vi har. De er alle forskellige i antallet af kolonner, men her er der i princippet ikke noget kolonnebegreb – der er feltnumre.

Der kan være absolut enhver mængde data. Og for eksempel skal vi søge efter dem ved det andet felt. For at gøre dette opretter vi et nyt sekundært indeks.

box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }}) 

Vi bruger kommandoen Create_index.
Lad os kalde det sekundært.

Herefter skal du angive parametrene. Indekstypen er TRÆ. Det er muligvis ikke unikt, så indtast Unique = false.

Derefter angiver vi, hvilke dele vores indeks består af. Felt er nummeret på det felt, som vi binder indekset til og angiver strengtypen. Og sådan blev det skabt.

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 er det sådan, vi kan kalde det:

unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...

konservering

Hvis vi genstarter instansen og prøver at kalde dataene igen, vil vi se, at de ikke er der - alt er tomt. Det sker, fordi Tarantool laver checkpoints og gemmer dataene på disken, men hvis vi holder op med at arbejde indtil næste lagring, mister vi alle operationer - fordi vi kommer tilbage fra det sidste checkpoint, som for eksempel var for to timer siden.

Det vil heller ikke fungere at spare hvert sekund, for konstant at dumpe 20 GB på disken er ikke en god idé.

Til dette formål blev konceptet med fremskrivningslog opfundet og implementeret. Med dens hjælp oprettes der for hver ændring i dataene en post i en lille fremskrivningslogfil.

Hver indgang op til kontrolpunktet er gemt i dem. For disse filer sætter vi størrelsen - for eksempel 64 MB. Når den er fuld, begynder optagelsen at gå til den anden fil. Og efter genstarten gendannes Tarantool fra det sidste kontrolpunkt og ruller derefter over alle senere transaktioner, indtil det stopper.

For at udføre en sådan optagelse skal du angive indstillingen i box.cfg-indstillingerne (i filen example.lua):

wal_mode = “write”;

dataforbrug

Med det vi har skrevet nu, kan du bruge Tarantula til at gemme data, og det vil fungere meget hurtigt som en database. Og nu er prikken over i'et, hvad du kan gøre med det hele.

At skrive en ansøgning

Lad os for eksempel skrive følgende ansøgning til Tarantula

Se ansøgningen 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 tabel i lua, der definerer tegnene. Denne plade er nødvendig for at generere en tilfældig 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
end

Derefter erklærer vi funktionen - randomString og angiver længdeværdien 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)]
end

Derefter forbinder vi http-routeren og http-serveren til vores Tarantula-server, JSON, som vi sender til klienten.

local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')

Herefter starter vi på port 8080 på alle http-servergrænseflader, som vil logge alle anmodninger og fejl.

local httpd = http_server.new('0.0.0.0', 8080, {
    log_requests = true,
    log_errors = true
})

Dernæst erklærer vi rute, så hvis en anmodning med GET-metoden ankommer på port 8080 /count, så kalder vi funktionen fra én linje. Det returnerer status - 200, 404, 403 eller enhver anden, som vi angiver.

router:route({method = 'GET', path = '/count'}, function()
    return {status = 200, body = json.encode({count = get_count()})}
end)

I brødteksten returnerer vi json.encode, i den angiver vi count og getcount, som kaldes og viser antallet af poster i vores database.

Den anden metode

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 køen router:route({metode = 'GET', sti = '/token'}, funktion() vi kalder funktionen og genererer et token.

Line lokal token = randomString(32) er en tilfældig streng på 32 tegn.
I kø local last = box.space.example:len() vi tager det sidste element ud.
Og i køen box.space.example:insert{ last + 1, token } vi skriver dataene ind i vores database, det vil sige at vi blot øger ID'et med 1. Det kan i øvrigt gøres ikke kun på denne klodsede måde. Der er sekvenser for dette i Tarantula.

Vi skriver tokenet der.

Således skrev vi ansøgningen i én fil. Du kan direkte manipulere dataene der, og boksmodulet vil gøre alt det beskidte arbejde for dig.

Den lytter til http og arbejder med data, alt er i en enkelt instans – både applikationen og dataene. Derfor sker alt ret hurtigt.

For at starte installerer vi http-modulet:

Hvordan vi gør dette, 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 har også brug for Prometheus til at kø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 tilgå modulerne

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 giver os status 200.
/token udsteder et token og skriver dette token til databasen.

Test af hastigheden

Lad os køre et benchmark for 50 anmodninger. Der vil være 000 konkurrerende anmodninger.

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 udstedes. Og vi registrerer konstant data. 99 % af anmodningerne blev behandlet på 42 millisekunder. Derfor har vi omkring 3500 anmodninger i sekundet på en lille maskine med 2 kerner og 4 gigabyte hukommelse.

Du kan også vælge omkring 50000 tokens og se dens værdi.

Du kan ikke kun bruge http, men også køre baggrundsfunktioner, der behandler dine data. Derudover er der forskellige triggere. Du kan for eksempel kalde funktioner på opdateringer, tjekke noget - rette konflikter.

Du kan skrive script-applikationer direkte i selve databaseserveren og ikke være begrænset af noget, forbinde eventuelle moduler og implementere enhver logik.

Applikationsserveren kan få adgang til eksterne servere, hente data og tilføje dem til sin database. Data fra denne database vil blive brugt af andre applikationer.

Tarantula vil gøre dette selv, og du behøver ikke at skrive en separat ansøgning.

Afslutningsvis

Dette er kun den første del af et stort arbejde. Den anden vil blive offentliggjort meget snart på Mail.ru Group-bloggen, og vi vil helt sikkert tilføje et link til det i dette materiale.

Hvis du er interesseret i at deltage i begivenheder, hvor vi bygger disse ting online og stille spørgsmål i realtid, så tuner ind kanal DevOps af REBRAIN.

Hvis du har brug for at flytte til skyen eller har spørgsmål om din infrastruktur, efterlad gerne en anmodning.

PS Vi har 2 gratis revisioner om måneden, måske bliver dit projekt et af dem.

Kilde: www.habr.com