🥇Tarantoolis saab ühendada superkiire andmebaasi ja rakenduse nende haldamiseks. Nii lihtsalt see käib

Viis aastat tagasi proovisin ma Tarantooliga töötada, kuid siis ei olnud see mulle sobiv. Hiljuti aga viisin läbi veebiseminari, kus rääkisin Hadoopist ja selle MapReduce'i toimimisest. Seal küsiti minult küsimus – "Miks mitte kasutada selle ülesande jaoks Tarantooli?".

Huvi pärast otsustasin selle juurde tagasi pöörduda, testisin viimast versiooni – ja seekord meeldis projekt mulle väga. Praegu näitan, kuidas kirjutada Tarantoolis lihtne rakendus, koormata seda ja kontrollida jõudlust ning näete, kui lihtne ja äge see kõik on.

Mis on Tarantool

Tarantool positsioneerib end ülikiire andmebaasina. Sinna saab sisestada igasuguseid andmeid, mida soovite. Lisaks saab neid replikeerida, sharding'ida – st jagada tohutut hulka andmeid mitmele serverile ja ühendada nende tulemused – teha talitlushäirete kindlaid seoseid tüüpi "master-master".

Teiseks on see rakendusserver. Te saate kirjutada seal oma rakendusi, töötada andmetega, näiteks kustutada taustal vanu kirjeid vastavalt teatud reeglitele. Võite kirjutada otse Tarantoolis HTTP-serveri, mis töötab andmetega: edastab nende arvu, salvestab sinna uusi andmeid ja redutseerib seda kõike masterile.

Lugesin artiklit, kuidas pojad tegid 300 rea pikkuse sõnumijärje, mis lihtsalt tormab ja rebib – nende minimaalne jõudlus on 20 000 sõnumit sekundis. Siin saab tõeliselt avarduda ja kirjutada väga suure rakenduse, ja need ei ole Postgresi sarnased salvestused.

Umbes sellist serverit, ainult lihtsat, püüan ma selles artiklis kirjeldada.

Paigaldamine

Testimiseks lõin kolm standardset virtuaalmasinat – kõvaketas 20 gigabaiti, Ubuntu 18.04. 2 virtuaalset CPU-d ja 4 gigabaiti mälu.

Me paigaldame Tarantooli – käivitame shelli skripti või lisame hoidla ja teeme apt get install Tarantool. Link skripti jaoks – (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Meil on nüüd sellised käsklused nagu:

tarantoolctl – peamine käsk Tarantooli instantside haldamiseks.
/etc/tarantool – siin on kogu konfiguratsioon.
var/log/tarantool – siin on logid.
var/lib/tarantool – siin on andmed, ja need on edaspidi jagatud instantside vahel.

On leiad kaustad instance-available ja instance-enabled — neis asub see, mis käivitub — instantsi konfiguratsioonifail, kus on kirjas, millistel portidel ta kuulab, kui palju mälu tal on, Vinyli mootori seadistused, kood, mis käivitub serveri käivitamisel, sharding, järjekorrad, aegunud andmete eemaldamine ja nii edasi.

Instantsid töötavad nagu PostgreS. Näiteks soovite käivitada mitu koopiat andmebaasist, mis on erinevatel portidel. Nii saab ühel serveril töötada mitu andmebaasi instantsi, mis on erinevatel portidel. Neil võivad olla täiesti erinevad seadistused — üks instants rakendab ühte loogikat, teine — teist.

Instantside haldamine

Meil on käsk tarantoolctl, mis võimaldab hallata Tarantuule instantsid. Näiteks, tarantoolctl check example kontrollib konfiguratsioonifaili ja ütleb — fail on ok, kui seal ei ole süntaktilisi vigu.

Saate vaadata instantsi staatust — tarantoolctl status example. Samamoodi saab teha start, stop, restart.

Kui instants on käivitunud, saab sellele ühenduda kahel viisil.

1. Halduse konsool

Vaikimisi avab Tarantool sokli, kuhu edastatakse tavaline ASCII-tekst Tarantuuli haldamiseks. Ühendus konsooliga toimub alati kasutaja admin all, seal ei ole autentimist, seetõttu ei pea konsooli porti Tarantuuli haldamiseks välja viima.

Selle viisi jaoks tuleb sisestada Tarantoolctl enter instance name. Käsk käivitab konsooli ja ühendub kasutaja admin all. Ärge kunagi avage konsooli porti välismaailmale — parem jätke see unit-soketiks. Siis saab Tarantuulile ühenduda ainult neil, kellel on sukeldus soketisse.

See viis on vajalik haldusülesannete jaoks. Andmete töötlemiseks kasutage teist viisi — binaarprotokolli.

2. Binaarprotokolli kasutamine kindla portaali jaoks ühendumiseks

Konfiguratsioonis on direktiiv listen, mis avab portaali välisteks suheldamiseks. Seda portaali kasutatakse binaarprotokolliga ja seal on sisse lülitatud autentimine.

Selle ühenduse jaoks kasutatakse tarantoolctl connect to port number. Selle abil saab ühenduda kaugserveritega, kasutada autentimist ja anda erinevaid juurdepääsuõigusi.

Andmete salvestamine ja Box moodul

Kuna Tarantool on nii andmebaas kui ka rakenduste server, on seal erinevad moodulid. Meid huvitab moodul box — see teostab andmetega töötamise. Kui kirjutate midagi box'i, salvestab Tarantool andmed kettale, hoiab neid mälus või teeb nendega midagi muud.

Kirjutamine

Näiteks siseneme moodulisse box ja kutsume esile funktsiooni box.once. See paneb Tarantooli käivitama meie koodi serveri initsialiseerimisel. Loome space'i, kus meie andmed salvestatakse.

local function bootstrap()
    local space = box.schema.create_space('example')
    space:create_index('primary')
    box.schema.user.grant('guest', 'read,write,execute', 'universe')

    -- Hoidke asju vaikimisi turvaliselt
    --  box.schema.user.create('example', { password = 'secret' })
    --  box.schema.user.grant('example', 'replication')
    --  box.schema.user.grant('example', 'read,write,execute', 'space', 'example')
end

Pärast seda loome esmase indeksi – primary – mille abil saame andmeid otsida. Vaikimisi, kui mingeid parameetreid ei määra, kasutatakse iga kirje esimest väli primaarindeksi jaoks.

Seejärel teeme külalisele guest õiguste andmise, millega me ühenduse loome binaarprotokolli kaudu. Lubame lugeda, kirjutada ja täita kõikjal instantsis.

Kui võrrelda tavapäraste andmebaasidega, siis siin on kõik üsna lihtne. Meil on space – ala, kus meie andmed lihtsalt asuvad. Iga kirje nimetatakse tupikuks. See pakitakse MessagePack formaati. See on väga lahe formaat — see on binaarne ja võtab vähem ruumi – 18 baiti versus 27.

Seda on üsna mugav kasutada. Peaaegu iga rida, iga andmekirje võib omada täiesti erinevaid veerge.

Saame vaadata kõiki space'e käsu Box.space abil. Konkreetse instantsi eristamiseks kirjutame box.space example ja saame selle kohta täieliku teabe.

Tarantoolis on sisse ehitatud kaks tüüpi jõu- ja andmebaasi mootoreid: Memory ja Vinyl. Memory salvestab kõik andmed mällu. Seetõttu töötab kõik lihtsalt ja kiiresti. Andmed kirjutatakse kettale, samuti on olemas write ahead log mehhanism, mistõttu me ei kaota midagi serveri krahhi korral.

Vinyl salvestab andmed kettale tuttavamal kujul — see tähendab, et saame salvestada rohkem andmeid, kui meil on mälu, ja Tarantool loeb neid kettalt.

Praegu hakkame kasutama 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:

Esimene indeks tuleb luua igas ruumis, sest ilma selleta ei tööta miski. Nagu igas andmebaasis, loome me esimese välja - kirje ID.

Osad:

Siin näitame, millest meie indeks koosneb. See koosneb ühest osast - esimesest väljast, mida me kasutame, tüüp unsigned - positiivne täisarv. Kui ma õigesti mäletan dokumentatsioonist, siis on maksimaalne arv 18 kvadrillionit. Üksjagu palju.

Edasi saame andmeid sisestada käsuga 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>

Esimene väli kasutatakse primaarse võtmena, seega peab see olema ainulaadne. Me ei ole piiratud veergude arvuga, seega saame sinna sisestada nii palju andmeid kui soovime. Need on esitatud MessagePack formaadis, millest ma eespool rääkisin.

Andmete väljastamine

Edasi saame andmeid väljastada käsuga select.

Box.example.select, kus on võti {1}, väljastab vajaliku kirje. Kui jätame võtme vahele, siis näeme kõiki meie olemasolevaid kirjeid. Need erinevad veergude arvu poolest, kuid siin pole põhimõtteliselt veergude mõistet - on välja numbrid.

Andmeid võib olla absoluutselt kuidas palju. Ja näiteks, kui peame neid otsima teise välja järgi. Selleks loome uue teise indeksi.


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

Kasutame käsku Create_index.
Anname sellele nimeks Secondary.

Pärast seda tuleb näidata parameetreid. Indeksi tüüp on TREE. See ei pruugi olla ainulaadne, seega sisestame Unique = false.

Seejärel näitame, millest meie indeks koosneb. Field - see on välja number, millega me indeksi seome, ja näitame tüübi string. Ja siin see on loodud.

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üüd saame seda kutsuda järgmiselt:

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

Salvestamine

Kui me instantsi taaskäivitame ja proovime andmeid uuesti kutsuda — siis näeme, et neid pole — kõik on tühi. Nii juhtub, kuna Tarantool teeb kontrollpunktid ja salvestab andmed kettale, kuid kui me peatame töö enne järgmise salvestamise toimumist, siis kaotame kõik toimingud — sest taastume viimases kontrollpunktis, mis oli, näiteks, kaks tundi tagasi.

Iga sekundi jäädvustamine ei tule ka kõne alla — sest pidev 20 GB andmete kettale kirjutamine ei ole just parim idee.

Selleks mõeldi ja rakendati ette kirjutamise logi (write-ahead log) kontseptsioon. Selle abil luuakse iga andmete muutuse jaoks sissekanne väikeses ette kirjutamise logi failis.

Iga sissekanne enne kontrollpunkti salvestatakse neisse. Nende failide jaoks seadistame suuruse — näiteks 64 MB. Kui see täitub, algab kirjutamine teise faili. Ja pärast taaskäivitamist taastab Tarantool end viimastest kontrollpunktidest ja hakkab siis üles laadima kõiki hilisemaid tehinguid kuni peatamiseni.

Selle kirjutamise teostamiseks tuleb box.cfg seadetes (failis example.lua) näidata järgmist valikut:

wal_mode = “write”;

Andmete kasutamine

Sellega, mis me just kirjutasime, võite kasutada Tarantooli andmete salvestamiseks, ja see töötab väga kiiresti nagu andmebaas. Ja nüüd kõige tähtsam - mis kõik selle kõigega teha saab.

Kirjutame rakenduse

Näiteks kirjutame Tarantooli jaoks sellise rakenduse

Rakendust vaadake spoileris

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

Me deklareerime Luuas teatud tabeli, mis määratleb sümbolid. Seda tabelit on vaja juhusliku stringi genereerimiseks.

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

Pärast seda deklareerime funktsiooni – randomString ja anname selle parameetriks pikkuse väärtuse.

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

Seejärel ühendame http-routeri ja http-serveri meie Tarantooliserveriga, samuti JSON-i, mida edastame kliendile.

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

Pärast seda käivitame http serveri sadamal 8080 kõigis liideses, mis logib kõik päringud ja vead.

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

Seejärel kuulutame välja marsruudi, et kui sadamasse 8080 /count tuleb GET-päring, siis kutsume välja ühe rea funktsiooni. See tagastab staatuse — 200, 404, 403 või mis tahes muu, mida me määrame.

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

Kehas tagastame json.encode, kus me määrame count ja getcount, mis kutsutakse välja ja näitab meie andmebaasis kirjeid.

Teine meetod

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)

Kus reas router:route({method = ‘GET’, path = ‘\/token’}, function() kutsume välja funktsiooni ja genereerime tokeni.

Rida local token = randomString(32) – see on 32 tähemärgist koosnev juhuslik string.
Reas local last = box.space.example:len() saame viimase elemendi.
Ja reas box.space.example:insert{ last + 1, token } salvestame oma andmebaasi andmed, see tähendab lihtsalt ID suurendamist 1 võrra. Seda saab tegelikult teha ka mitte ainult sellise toore meetodiga. Tarantulos on selleks järjestused.

Salvestame sinna tokeni.

Nii oleme ühes failis kirjutanud rakenduse. Sellega saab kohe andmetega suhelda ning moodul box teeb kogu musta töö teie eest.

See kuulab http ja töötab andmetega, kõik on ühes instantsis — nii rakendus kui andmed. Seetõttu toimub kõik piisavalt kiiresti.

Käivitusel installime http mooduli:

Kuidas me seda teeme, vaadake spoilerist

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 

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

Samuti vajame prometheuse käivitamiseks:

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 on nüüd installitud .rocks (license: BSD)

root@test2:/$

Käivitame ja saame moodulitele juurde pääseda

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 отдает нам статус 200.
/token выдает токен и делает запись этого токена в базу.

Testime kiirus

Käivitame 50 000 päringu bänkmargi. Konkurentsi päringute arv on 500.

root@test2:/$ ab -c 500 -n 50000 http://127.0.0.1:8080/token
This is ApacheBench, Version 2.3 
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:/$

Tokenid väljastatakse. Ja me salvestame pidevalt andmeid. 99% päringutest töötas 42 millisekundi jooksul. Seega, meil on umbes 3500 päringut sekundis väiksemas masinas, kus on 2 tuuma ja 4 gigabaiti mälu.

Saame ka valida mõne 50000-tokeni ja vaadata selle väärtust.

Saame kasutada mitte ainult http-d, vaid ka käivitada taustfunktsioone, mis töötlevad teie andmeid. Lisaks on erinevaid käivitajaid. Näiteks saate kutsuda funktsioone uuendustel, et midagi kontrollida - lahendada konflikte.

Otse serveri andmebaasis saab kirjutada rakendusskripte, ilma piiranguteta, ühendades mis tahes mooduleid ja teostades mis tahes loogikat.

Rakendusse server saab pöörduda väliste serverite poole, tooma andmeid ja salvestama need enda andmebaasi. Need andmed tulevad teistes rakendustes kasutusele.

Seda teeb ise Tarantool, nii et eraldi rakendust kirjutama ei pea.

Kokkuvõtteks

See on vaid esimene osa suurest tööst. Teine osa avaldatakse varsti Mail.ru Groupi blogis, ja me lisame kindlasti sellele materjalile lingi.

Kui teil on huvi osaleda üritustel, kus me internetis selliseid asju loome ja reaalajas küsimusi esitada, liituge kanaliga DevOps by REBRAIN.

Kui vajate üleminekut pilve või teil on küsimusi oma infrastruktuuri kohta, võite julgelt esitada taotluse.

P.S. Meil on iga kuu 2 tasuta auditi võimalust, võib-olla on just teie projekt nende seas.

Allikas: habr.com

Tarantoolis saab ühildada ülikiire andmebaasi ja rakenduse nende jaoks. Nii on see lihtsalt tehtud