U Tarantoolu možete kombinirati superbrzu bazu podataka i aplikaciju za rad s njima. Evo kako je to lako učiniti

Prije pet godina pokušao sam raditi sa Tarantoolom, ali tada mi nije išlo. Ali nedavno sam održao webinar na kojem sam govorio o Hadoop-u i kako MapReduce funkcionira. Tamo su mi postavili pitanje: "Zašto ne koristiti Tarantool za ovaj zadatak?"

Iz radoznalosti, odlučio sam da mu se vratim, testiram najnoviju verziju – i ovaj put mi se projekat jako dopao. Sada ću vam pokazati kako da napišete jednostavnu aplikaciju u Tarantoolu, učitate je i provjerite njene performanse i vidjet ćete kako je sve jednostavno i cool.

Šta je Tarantool?

Tarantool se pozicionira kao ultra-brza baza podataka. Tamo možete staviti bilo koje podatke. Plus, replicirajte ih, shard - to jest, podijelite ogromnu količinu podataka na nekoliko servera i kombinirajte rezultate s njih - napravite master-master veze otporne na greške.

Drugo, ovo je server aplikacija. Na njemu možete pisati svoje aplikacije, raditi s podacima, na primjer, brisati stare zapise u pozadini prema određenim pravilima. Možete napisati Http server direktno u Tarantuli koji će raditi s podacima: dati njihovu količinu, upisati nove podatke tamo i sve to svesti na mastera.

Pročitao sam članak o tome kako su momci napravili red poruka od 300 redova, koji jednostavno puca i žuri - imaju minimalne performanse od 20 poruka u sekundi. Ovdje se zaista možete okrenuti i napisati veoma veliku aplikaciju, a to neće biti skladište, kao u PostgreS-u.

Pokušat ću opisati nešto poput ovog servera, samo jednostavnog, u ovom članku.

postavljanje

Za test sam pokrenuo tri standardne virtuelne mašine - hard disk od 20 GB, Ubuntu 18.04. 2 virtuelna procesora i 4 giga memorije.

Instaliramo Tarantool - pokrenite bash skriptu ili dodajte spremište i uradite apt get install Tarantool. Veza do skripte - (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Imamo komande poput:

tarantoolctl — glavna komanda za upravljanje instancama Tarantule.
/etc/tarantool - evo cijele konfiguracije.
var/log/tarantool - Evo dnevnika.
var/lib/tarantool — podaci leže ovdje, a zatim se dijele na instance.

Postoje fascikle instance-available i instance-enable - sadrži ono što će biti pokrenuto - konfiguracionu datoteku instance sa lua kodom, koji opisuje na kojim portovima sluša, koja mu je memorija dostupna, postavke Vinyl motora, kod koji se pokreće pri pokretanju serveri, dijeljenje, redovi, brisanje zastarjelih podataka, itd.

Instance rade kao u PostgreS-u. Na primjer, želite pokrenuti nekoliko kopija baze podataka koja visi na različitim portovima. Ispostavilo se da se na jednom serveru pokreće nekoliko instanci baze podataka, koje vise na različitim portovima. Mogu imati potpuno različite postavke - jedna instanca implementira jednu logiku, druga - drugu.

Upravljanje instancama

Imamo komandu tarantoolctl, koja vam omogućava da upravljate instancama Tarantule. Na primjer, tarantoolctl check example će provjeriti konfiguracijsku datoteku i reći - datoteka je u redu ako tamo nema sintaksičkih grešaka.

Možete vidjeti status instance - tarantoolctl primjer statusa. Na isti način možete pokrenuti, zaustaviti, ponovo pokrenuti.

Kada se instanca pokrene, možete se povezati s njom na dva načina.

1. Administrativna konzola

Podrazumevano, Tarantool otvara socket, normalan ASCII tekst se tamo šalje da kontroliše Tarantool. Povezivanje s konzolom uvijek se odvija pod administratorskim korisnikom, nema autentifikacije, tako da nema potrebe za eksternalizacijom porta konzole za upravljanje Tarantulom.

Da biste se povezali pomoću ove metode, trebate unijeti Tarantoolctl enter name instance. Komanda će pokrenuti konzolu i povezati se kao administratorski korisnik. Nikada nemojte izlagati konzolni port spolja – bolje ga je ostaviti kao jediničnu utičnicu. Tada će samo oni koji imaju pristup za pisanje u utičnicu moći da se povežu na Tarantula.

Ova metoda je potrebna za administrativne stvari. Za rad s podacima koristite drugu metodu - binarni protokol.

2. Korištenje binarnog protokola za povezivanje na određeni port

Konfiguracija sadrži direktivu slušanja, koja otvara port za eksternu komunikaciju. Ovaj port se koristi s binarnim protokolom i tu je omogućena autentifikacija.

Za ovu vezu se koristi tarantoolctl connect to port number. Koristeći ga, možete se povezati na udaljene servere, koristiti autentifikaciju i dodijeliti različita prava pristupa.

Modul za snimanje podataka i kutiju

Pošto je Tarantool i baza podataka i server aplikacija, ima različite module. Zanima nas modul box - implementira rad sa podacima. Kada nešto napišete u kutiju, Tarantool zapisuje podatke na disk, pohranjuje ih u memoriju ili radi nešto drugo s njima.

rekord

Na primjer, idemo u modul box i pozivamo funkciju box.once. Ovo će primorati Tarantool da pokrene naš kod kada se server inicijalizira. Kreiramo prostor u kojem će biti pohranjeni naši podaci.

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

Nakon toga kreiramo primarni indeks - primarni - pomoću kojeg možemo pretraživati ​​podatke. Podrazumevano, ako ne navedete nijedan parametar, prvo polje u svakom zapisu će se koristiti za primarni indeks.

Zatim gostu korisniku dajemo grant pod kojim se povezujemo putem binarnog protokola. Dozvoljavamo čitanje, pisanje i izvršavanje na cijeloj instanci.

U poređenju sa konvencionalnim bazama podataka, ovde je sve prilično jednostavno. Imamo prostor – područje u kojem se naši podaci jednostavno pohranjuju. Svaki zapis se naziva tuple. Upakovan je u MessagePack. Ovo je vrlo cool format - binarni je i zauzima manje prostora - 18 bajtova naspram 27.

Sa njim je prilično zgodno raditi. Gotovo svaki red, svaki zapis podataka može imati potpuno različite stupce.

Možemo vidjeti sve prostore pomoću naredbe Box.space. Da biste odabrali određenu instancu, napišite primjer box.space i dobijte potpune informacije o tome.

Tarantool ima dva ugrađena motora: Memory i Vinyl. Memorija pohranjuje sve podatke u memoriju. Dakle, sve radi jednostavno i brzo. Podaci se izbacuju na disk, a postoji i mehanizam dnevnika za upisivanje unaprijed, tako da nećemo ništa izgubiti ako se server sruši.

Vinyl pohranjuje podatke na disk u nama poznatijem obliku - to jest, možete pohraniti više podataka nego što imamo memorije, a Tarantula će ih pročitati s diska.

Za sada ćemo koristiti Memoriju.

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:

Primarni indeks se mora kreirati za bilo koji prostor, jer bez njega ništa neće raditi. Kao iu svakoj bazi podataka, kreiramo prvo polje – ID zapisa.

Dijelovi:

Ovdje navodimo od čega se sastoji naš indeks. Sastoji se od jednog dijela - prvo polje koje ćemo koristiti je tipa unsigned - pozitivan cijeli broj. Koliko se sjećam iz dokumentacije, maksimalni broj koji može biti je 18 kvintiliona. To je mnogo.

Tada možemo umetnuti podatke pomoću naredbe 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>

Prvo polje se koristi kao primarni ključ, tako da mora biti jedinstveno. Nismo ograničeni brojem kolona, ​​tako da tamo možemo ubaciti koliko god želimo podataka. Oni su navedeni u formatu MessagePack, koji sam gore opisao.

Izlaz podataka

Zatim možemo prikazati podatke pomoću naredbe select.

Box.example.select sa tipkom {1} će prikazati željeni unos. Ako spustimo ključ, možemo vidjeti sve zapise koje imamo. Svi se razlikuju po broju kolona, ​​ali ovdje, u principu, ne postoji koncept stupaca - postoje brojevi polja.

Može postojati apsolutno bilo koja količina podataka. I na primjer, trebamo ih tražiti po drugom polju. Da bismo to učinili, kreiramo novi sekundarni indeks.

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

Koristimo naredbu Create_index.
Nazovimo to sekundarnim.

Nakon toga morate odrediti parametre. Tip indeksa je TREE. Možda nije jedinstven, pa unesite Unique = false.

Zatim naznačimo od kojih dijelova se sastoji naš indeks. Polje je broj polja za koje vezujemo indeks i specificiramo tip stringa. I tako je nastao.

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>

Sada to možemo nazvati ovako:

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

Očuvanje

Ako ponovo pokrenemo instancu i pokušamo ponovo pozvati podatke, vidjet ćemo da ih nema - sve je prazno. To se dešava zato što Tarantool pravi kontrolne tačke i sprema podatke na disk, ali ako prestanemo da radimo do sledećeg snimanja, izgubićemo sve operacije - jer ćemo se oporaviti od poslednje kontrolne tačke, koja je bila, na primer, pre dva sata.

Neće uspjeti ni uštedjeti svaku sekundu, jer stalno bacanje 20 GB na disk nije dobra ideja.

U tu svrhu je izmišljen i implementiran koncept dnevnika zapisa unaprijed. Uz njegovu pomoć, za svaku promjenu podataka, kreira se unos u malu datoteku dnevnika za upisivanje unaprijed.

Svaki ulaz do kontrolne tačke je pohranjen u njima. Za ove datoteke postavljamo veličinu - na primjer, 64 MB. Kada se napuni, snimanje počinje da ide na drugu datoteku. A nakon ponovnog pokretanja, Tarantool se vraća sa zadnje kontrolne tačke i zatim prebacuje sve kasnije transakcije dok se ne zaustavi.

Da biste izvršili takvo snimanje, potrebno je da navedete opciju u postavkama box.cfg (u datoteci example.lua):

wal_mode = “write”;

korištenje podataka

Uz ovo što smo sada napisali, možete koristiti Tarantulu za pohranjivanje podataka i vrlo brzo će raditi kao baza podataka. A sada je šlag na torti ono što možete učiniti sa svime.

Pisanje aplikacije

Na primjer, napišimo sljedeću aplikaciju za Tarantulu

Pogledajte aplikaciju ispod spojlera

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()

Deklarišemo neku tabelu u lua koja definiše znakove. Ova ploča je potrebna za generiranje slučajnog niza.

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

Nakon toga, deklariramo funkciju - randomString i dajemo vrijednost dužine u zagradama.

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

Zatim povezujemo http ruter i http server sa našim Tarantula serverom, JSON, koji ćemo poslati klijentu.

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

Nakon toga počinjemo na portu 8080 na svim interfejsima http servera, koji će evidentirati sve zahtjeve i greške.

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

Zatim deklariramo rutu, tako da ako zahtjev sa metodom GET stigne na port 8080 /count, onda pozivamo funkciju iz jedne linije. Vraća status - 200, 404, 403 ili bilo koji drugi koji odredimo.

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

U tijelu vraćamo json.encode, u njemu označavamo count i getcount, koji se poziva i pokazuje broj zapisa u našoj bazi podataka.

Drugi 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)

Gdje u redu router:route({method = 'GET', path = '/token'}, function() pozivamo funkciju i generiramo token.

Gudački lokalni token = randomString(32) je nasumični niz od 32 znaka.
U redu lokalni zadnji = box.space.example:len() vadimo poslednji element.
I u redu box.space.example:insert{ posljednji + 1, token } upisujemo podatke u našu bazu podataka, odnosno jednostavno povećavamo ID za 1. To se, inače, može učiniti ne samo na ovaj nespretan način. Postoje sekvence za ovo u Tarantuli.

Tamo upisujemo token.

Tako smo aplikaciju napisali u jedan fajl. Možete odmah manipulirati podacima, a modul box će obaviti sav prljavi posao umjesto vas.

Sluša http i radi sa podacima, sve je u jednoj instanci - i aplikacija i podaci. Dakle, sve se dešava prilično brzo.

Za početak instaliramo http modul:

Kako to radimo, pogledajte ispod spojlera

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:/#

Takođe nam je potreban prometheus za pokretanje:

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:/#

Pokrećemo i možemo pristupiti modulima

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 nam daje status 200.
/token izdaje token i upisuje ovaj token u bazu podataka.

Testiranje brzine

Pokrenimo benčmark za 50 zahtjeva. Bit će 000 konkurentnih zahtjeva.

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:/#

Izdaju se tokeni. I stalno bilježimo podatke. 99% zahtjeva obrađeno je za 42 milisekunde. Shodno tome, imamo oko 3500 zahtjeva u sekundi na maloj mašini sa 2 jezgra i 4 gigabajta memorije.

Također možete odabrati nekih 50000 tokena i vidjeti njegovu vrijednost.

Možete koristiti ne samo http, već i pokrenuti pozadinske funkcije koje obrađuju vaše podatke. Osim toga, postoje različiti okidači. Na primjer, možete pozvati funkcije na ažuriranjima, provjeriti nešto - ispraviti konflikte.

Možete pisati skript aplikacije direktno u samom serveru baze podataka, i ne biti ničim ograničen, povezati bilo koje module i implementirati bilo koju logiku.

Aplikacijski server može pristupiti vanjskim serverima, preuzimati podatke i dodati ih u svoju bazu podataka. Podatke iz ove baze podataka će koristiti druge aplikacije.

Tarantula će to učiniti sama i nećete morati pisati posebnu aplikaciju.

U zaključku

Ovo je samo prvi dio velikog posla. Drugi će biti vrlo brzo objavljen na blogu Mail.ru Group, a mi ćemo svakako dodati link na njega u ovom materijalu.

Ako ste zainteresovani da prisustvujete događajima na kojima gradimo ove stvari na mreži i postavljate pitanja u realnom vremenu, uključite se DevOps po kanalu REBRAIN.

Ako trebate preći na oblak ili imate pitanja o svojoj infrastrukturi, Slobodno podnesite zahtjev.

PS Imamo 2 besplatne revizije mjesečno, možda će vaš projekat biti jedan od njih.

izvor: www.habr.com