🥇Tarantoolis on võimalik ühendada superkiire andmebaas ja rakendus nendega töötamiseks. Nii lihtne on see

Viis aastat tagasi proovisin Tarantooliga töötada, kuid toona ei sobinud see mulle. Hiljuti korraldasin veebiseminari, kus rääkisin Hadoopist ja MapReduce tööpõhimõttest. Seal küsiti minult: "Aga miks mitte kasutada selle ülesande jaoks Tarantoolit?"

Huvi pärast otsustasin tagasi tulla, proovida viimast versiooni — ja seekord meeldis projekt mulle väga. Nüüd näitan, kuidas kirjutada Tarantoolis lihtne rakendus, koormata seda ja kontrollida tulemuslikkust, ning te näete, kui lihtne ja äge seal kõik on.

Mis on Tarantool

Tarantool positsioneerib end superkiire andmebaasina. Sinna saab sisestada igasuguseid andmeid, mida soovid. Pluss, saad neid replikeerida, shardida — st jagada tohutut andmemassi mitme serveri vahel ja liita nende tulemused — luua tõrketaluvuse seoseid nagu "meistri-meister".

Teiseks on see rakenduste server. Võite kirjutada sellele oma rakendused, töötada andmetega, näiteks eemaldada vanu kirjeid taustal teatud reeglite järgi. Samuti on võimalik kirjutada otse Tarantuuli HTTP-server, mis töötleb andmeid: kuvab nende arvu, salvestab uusi andmeid ja väheneb kõik peajuurde.

Lugesin artiklit, kuidas poisid tegid sõnumijärje 300 real, mis lihtsalt purustab kõik - nende minimaalne tootlikkus on 20 000 sõnumit sekundis. Siin on tõesti võimalik lahti lasta ja kirjutada väga suur rakendus, ja need ei ole nagu PostgreS-i salvestused.

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

Installeerimine

Testimiseks loodi mul kolm tavalist virtuaalmasinat - kõvaketas 20 gigabaiti, Ubuntu 18.04, 2 virtuaalset CPU-t ja 4 gigabaiti mälu.

Paigaldame Tarantooli - käivitame shell-skripti või lisame repoo ja teeme apt get install Tarantool. Skripti link - (curl -L | VER=2.4 sudo -E bash). Meil tekivad sellised käsklused nagu: https://tarantool.io/installer.sh tarantoolctl

— põhikäsu käitlemiseks Tarantuuli instantside jaoks. — siin on kogu konfiguratsioon.
/etc/tarantool var/log/tarantool
— siin on logid. — siin on logid.
var/lib/tarantool — siin on andmed, ja need on jagatud instantside kaupa.

On kaustad instance-available ja instance-enable — seal asub see, mis käivitub — instantsi konfiguratsioonifail koos lua koodiga, kus on kirjas, millistel portidel see kuulab, milline mälu on tal saadaval, Vinyli mootori seaded, kood, mis töötab serveri käivitamisel, sharding, järjekorrad, vanade andmete kustutamine ja nii edasi.

Instantsid töötavad nagu PostgreS. Näiteks soovite käivitada mitu koopiat andmebaasist, mis asub erinevatel portidel. Nii et ühel serveril käivitatakse mitu andmebaasi instantsi, mis asuvad 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 Tarantuuli instantside haldamist. Näiteks tarantoolctl check example kontrollib konfiguratsioonifaili ja ütleb — fail on korras, kui seal pole süntaksivigu.

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

Kui instants on käivitunud, on sellele võimalik kahel viisil ühenduda.

1. Administratiivne konsol

Vaikimisi avab Tarantool sokli, kus edastatakse tavaline ASCII-teksti TaranTooli haldamiseks. Ühendus konsooliga toimub alati kasutaja admin all, autentimist ei toimu, seega pole konsooliporti väliskasutuseks vaja avada.

Selle meetodi abil ühendamiseks peate sisestama Tarantoolctl enter instance name. Käsk käivitab konsooli ja ühendab kasutaja admin all. Ärge kunagi avage konsooliporti väljapoole — parem jätke see unit-soketiks. Sel juhul saavad TaranTooliga ühenduda ainult need, kellel on juurdepääs soketi kirjutamisõigusele.

See meetod on vajalik haldusülesannete jaoks. Andmete töötlemiseks kasutage teist meetodit — binaarset protokolli.

2. Binaarse protokolli kasutamine konkreetsele portile ühendamiseks

Konfiguratsioonis on direktiiv listen, mis avab porta väliste kommunikatsioonide jaoks. See port kasutatakse binaarse protokolliga ning seal on aktiveeritud autentimine.

Selle ühenduse jaoks kasutatakse tarantoolctl ühendust pordinumbriga. Selle abil saab luua ühenduse kaugserveritega, kasutada autentimist ja anda erinevaid juurdepääsuõigusi.

Andmete salvestamine ja moodul Box

Kuna Tarantool on nii andmebaas kui ka rakendusserver, sisaldab see erinevaid mooduleid. Meid huvitab moodul box — see realiseerib andmetega töötamise. Kui kirjutate midagi box'i, kirjutab Tarantool andmed kettale, salvestab need mällu või teeb nendega midagi muud.

Salvestamine

Näiteks siseneme moodulisse box ja kutsume esile funktsiooni box.once. See sunnib Tarantool'i käivitama meie koodi serveri alguses. Loome space'i, kuhu 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 asjad 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 alusel saab andmeid otsida. Vaikimisi, kui mingeid parameetreid ei ole määratud, kasutatakse iga kirje esimest väljad primaarindeksi jaoks.

Seejärel anname kasutajale guest õigused, mille kaudu me ühendume binaarprotokolliga. Lubame lugeda, kirjutada ja käivitada kogu instantsis.

Kui võrrelda tavaliste andmebaasidega, siis siin on kõik piisavalt lihtne. Meil on space — ala, kus meie andmed lihtsalt asuvad. Iga kirje nimetatakse tuple'ks. See pakitakse MessagePack formaati. See on väga äge formaat — see on binaarne ja võtab vähem ruumi – 18 baiti võrreldes 27-ga.

Sellel on piisavalt mugav töötada. Peaaegu igal real, igal andmekirjel võivad olla täiesti erinevad veerud.

Kogu spacet saab vaadata käsuga Box.space. Konkreetse instantsi eristamiseks kirjutame box.space example ja saame selle kohta täiendavat teavet.

Tarantoolis on integreeritud kaks tüüpi mootoreid: Memory ja Vinyl. Memory salvestab kõik andmed mällu. Seetõttu töötab kõik lihtsalt ja kiiresti. Andmed salvestatakse kettale ning olemas on kirjutamise eelposti mehhanism, nii et me ei kaota midagi serveri kokkupõrkel.

Vinyl salvestab andmeid kettale tavapärases vormis — see tähendab, et võib salvestada rohkem andmeid, kui meil on mälu, ja Tarantool loeb neid kettalt.

Nüüd kasutame mälu.

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, kuna ilma selleta ei tööta midagi. Nagu igas andmebaasis, loome esimese välja – kirje ID.

Osad:

Siin määratleme, millest meie indeks koosneb. See koosneb ühest osast – esimesest väljast, mida kasutame, tüüp unsigned – positiivne täisarv. Kui ma õigesti mäletan dokumentatsioonist, on maksimaalne number 18 kvadriljonit. Tõeliselt palju.

Edasi võime 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 peamise võtmena, seega peab see olema ainulaadne. Me ei ole piiratud tulbikogusega, seega saame sinna lisada lõputult andmeid. Need esitatakse MessagePack formaadis, mille ma eelnevalt kirjeldasin.

Andmete väljund

Edasi saame andmeid kuvada käsuga select.

Box.example.select koos võtmega {1} kuvab soovitud kirje. Kui me võtme vahele jätame, näeme kõiki kirjeid, mis meil on. Need kõik erinevad tulbikoguste poolest, kuid siinkohal ei ole mõistet tulbid — on olemas väljanumbrid.

Andmeid võib olla absoluutne arv, ja näiteks peame neid otsima teise välja järgi. Selleks loome uue sekundaarindeksi.


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

Kasutame käsku Create_index.
Nimeks anname Secondary.

Nüüd peame määrama parameetrid. Indeksi tüüp on — TREE. See ei pruugi olla unikaalne, seega määrame Unique = false.

Seejärel määrame, millistest osadest meie indeks koosneb. Field — see on välja number, millega seome indeksi, ja määrame tüübi string. Ja nüüd on see 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']
...

Salvesta

Kui me instantsi uuesti käivitame ja proovime andmeid uuesti kutsuda — siis näeme, et neid pole — kõik on tühi. Nii juhtub, kuna Tarantool teeb kontrollpunkte ja salvestab andmed kettale, kuid kui peatame töö enne lähima salvestamist, kaotame kõik toimingud — sest taastume viimasest kontrollpunktist, mis oli näiteks kaks tundi tagasi.

Iga sekundi järel salvestamine ei tule ka kõne alla — sest pidevalt 20 GB kettale dumpimine — pole just parim plaan.

Selleks loodi ja rakendati write-ahead log kontseptsioon. Selle abil luuakse iga andmete muutuse jaoks väike kirjutamislogi fail.

Iga kirje enne kontrollpunkti salvestatakse nendes. Neile failidele määrame suuruse - näiteks 64 MB. Kui see täitub, hakkavad kirjed minema teise faili. Ja pärast Tarantool'i taaskäivitamist taastatakse see viimasest kontrollpunktist, seejärel koondatakse kõik hilisemad tehingud kuni peatamiseni.

Selle kirjutamise teostamiseks tuleb määrata valik box.cfg seadetes (failis example.lua):

wal_mode = “write”;

Andmete kasutamine

Sellega, mida me praegu kirjutasime, saate kasutada Tarantooli andmete salvestamiseks, ja see töötab väga kiiresti nagu andmebaas. Ja nüüd on kõige parem osa - mida saab selle kõigega teha.

Kirjutame rakenduse

Näiteks kirjutame Tarantoolile sellise rakenduse

Rakendust näete 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; -- üks tund
    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

-- esmakordne ruum ja seadistage õigused
box.once('replica', bootstrap)

-- konsooli juurdepääsu lubamine
console = require('console')
console.listen('127.0.0.1:3302')

-- http konfiguratsioon
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 Tokenite arv")

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

Meie moodustame Lua-s teatud tabeli, mis määratleb sümbolid. See tabel on vajalik suvalise 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 kuulutame välja funktsiooni – randomString ja anname sulgudes väärtuse pikkuse.

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 Tarantuuli-serveriga, JSON, 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õikidel liidestel, mis logib kõiki päringuid ja vigu.

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

Edasi kuulutame marsruudi, et kui sadamasse 8080 saabub päring meetodiga GET, siis kutsume välja ühe rea funktsiooni. See tagastab staatuse – 200, 404, 403 või muu, mille me määrame.

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

Kehakeses tagastame json.encode'i, kus näitame count'i ja getcount'i, mis kutsutakse esile ja näitab meie andmebaasi 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 real router:route({method = 'GET', path = '/token'}, function() kutsume välja funktsiooni ja genereerime token'i.

String local token = randomString(32) – see on 32 tähemärgist koosnev juhuslik string.
Reas local last = box.space.example:len() toome välja viimase elemendi.
Ja real box.space.example:insert{ last + 1, token } salvestame meie andmebaasi andmed, st lihtsalt suurendame ID'd 1 võrra. Seda saab muuseas teha ka mitte nii kummalise meetodiga. Taranutil on selleks seadmed.

Salvestame sinna token'i.

Nii oleme ühes failis kirjutanud rakenduse. Seda saab kohe andmetega kasutada ning moodul box teeb kogu räpane töö teie eest.

See kuulab http'd ja töötab andmetega, kõik asub ühes instantsis — ning rakendus ja andmed. Seetõttu toimub kõik üsna kiiresti.

Käivitamiseks paigaldame http mooduli:

Kuidas me seda teeme, vaadake spoilerist

root@test2:/# tarantoolctl rocks install http
Installing http://rocks.tarantool.org/http-scm-1.src.rock
Puuduvad sõltuvused http scm-1 jaoks:
   checks >= 3.0.1 (pole installitud)

http scm-1 sõltub checks >= 3.0.1 (pole installitud)
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 on nüüd installitud /.rocks (license: BSD)

-- C kompilaatori tuvastamine on GNU 7.5.0
-- Kontrollimine töötava C kompilaatori jaoks: /usr/bin/cc
-- Kontrollimine töötava C kompilaatori jaoks: /usr/bin/cc -- töötab
-- C kompilaatori ABI info tuvastamine
-- C kompilaatori ABI info tuvastamine - valmis
-- C kompilaatori omaduste tuvastamine
-- C kompilaatori omaduste tuvastamine - valmis
-- Leitud TARANTOOL: /usr/include (leitud versioon "2.4.2-80-g18f2bc82d")
-- Tarantool LUADIR on /.rocks/share/tarantool/rocks/http/scm-1/lua
-- Tarantool LIBDIR on /.rocks/share/tarantool/rocks/http/scm-1/lib
-- Konfigureerimine tehtud
-- genereerimine tehtud
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 on nüüd installitud /.rocks (license: BSD)

root@test2:/#

Käivitamiseks vajame ka prometheus'e:

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

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 benchmark'i. 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öötati läbi 42 millisekundiga. Seega on meil umbes 3500 päringut sekundis väikeses masinas, kus on 2 tuuma ja 4 gigabaiti mälu.

Samuti on võimalik valida mingi 50000-token ja vaadata selle väärtust.

Saate kasutada mitte ainult http-d, käivitades taustafunktsioone, mis töötlevad teie andmeid. Pluss on olemas erinevad käivitajad. Näiteks võite kutsuda funktsioone üles uuenduste korral, midagi kontrollida – konflikte lahendada.

Saate kirjutada rakendusskripte otse andmebaasi serverisse, ilma piiranguteta, ühendades igasuguseid mooduleid ja rakendades igasugust loogikat.

Rakendussüsteem võib pöörduda väliste serverite poole, andmeid nendest võtta ja oma andmebaasi salvestada. Seda andmestikku kasutavad teised rakendused.

Seda teeb Tarantool ise, eraldi rakendust kirjutama ei pea.

Kokkuvõtteks

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

Kui teid huvitavad üritused, kus me luuakse selliseid asju veebis ja esitate küsimusi reaalajas, liituge kanaliga DevOps by REBRAIN.

Kui vajate pilve kolimist või teil on küsimusi oma infrastruktuuri kohta, võite julgelt jätta taotluse.

P.S. Meil on kuus 2 tasuta auditi võimalust, ehk just teie projekt on nende seas.

Allikas: habr.com

Tarantoolis saab liita superspeedy andmebaasi ja rakenduse nende haldamiseks. Nii lihtne see on!