ProHoster > Blog > Uprava > Tarantool omogoča kombinacijo super hitre baze podatkov in aplikacije za delo z njimi. Tako enostavno je to narediti

Tarantool omogoča kombinacijo super hitre baze podatkov in aplikacije za delo z njimi. Tako enostavno je to narediti

Pred petimi leti sem poskusil delati s Tarantoolom, a mi takrat ni šlo. Pred kratkim pa sem imel spletni seminar, na katerem sem govoril o Hadoopu in o tem, kako deluje MapReduce. Tam so mi zastavili vprašanje: "Zakaj ne bi za to nalogo uporabili Tarantoola?"

Iz radovednosti sem se odločil, da se vrnem k njemu, preizkusim najnovejšo različico - in tokrat mi je bil projekt zelo všeč. Zdaj vam bom pokazal, kako napisati preprosto aplikacijo v Tarantoolu, jo naložiti in preveriti njeno delovanje, in videli boste, kako enostavno in kul je vse.

Tarantool omogoča kombinacijo super hitre baze podatkov in aplikacije za delo z njimi. Tako enostavno je to narediti

Kaj je Tarantool

Tarantool se pozicionira kot ultra hitra zbirka podatkov. Tam lahko vnesete poljubne podatke. Poleg tega jih posnemajte, razdelite - to je, razdelite ogromno količino podatkov na več strežnikov in združite njihove rezultate - ustvarite povezave master-master, odporne na napake.

Drugič, to je aplikacijski strežnik. Nanj lahko pišete svoje aplikacije, delate s podatki, na primer brišete stare zapise v ozadju po določenih pravilih. Neposredno v Tarantuli lahko napišete strežnik Http, ki bo delal s podatki: izdajte njihovo količino, tam zapišite nove podatke in vse zmanjšajte na master.

Prebral sem članek o tem, kako so fantje naredili čakalno vrsto sporočil 300 vrstic, ki preprosto poka in hiti - imajo minimalno zmogljivost 20 sporočil na sekundo. Tukaj se res lahko obrnete in napišete zelo veliko aplikacijo, pa ne bo shramba, kot v PostgreS.

V tem članku bom poskušal opisati nekaj podobnega temu strežniku, le preprostemu.

Namestitev

Za test sem zagnal tri standardne virtualne stroje - 20 GB trdi disk, Ubuntu 18.04. 2 virtualni procesorji in 4 GB pomnilnika.

Namestimo Tarantool - zaženite skript bash ali dodajte repozitorij in naredite apt get install Tarantool. Povezava do skripte - (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Imamo ukaze, kot so:

tarantoolctl — glavni ukaz za upravljanje primerkov Tarantula.
/etc/tarantool - tukaj je celotna konfiguracija.
var/log/tarantool - tukaj so dnevniki.
var/lib/tarantool — podatki ležijo tukaj, nato pa so razdeljeni na primerke.

Obstajata mapi instance-available in instance-enable - vsebuje tisto, kar se bo zagnalo - konfiguracijsko datoteko primerka s kodo lua, ki opisuje, na katerih vratih posluša, kakšen pomnilnik mu je na voljo, nastavitve motorja Vinyl, kodo, ki se izvaja ob zagonu strežniki, razčlenjevanje, čakalne vrste, brisanje zastarelih podatkov itd.

Primerki delujejo kot v PostgreS. Na primer, želite zagnati več kopij baze podatkov, ki visi na različnih vratih. Izkazalo se je, da se na enem strežniku zažene več primerkov baze podatkov, ki visijo na različnih vratih. Lahko imajo popolnoma različne nastavitve - en primerek izvaja eno logiko, drugi - drugo.

Upravljanje primerkov

Imamo ukaz tarantoolctl, ki vam omogoča upravljanje primerkov Tarantula. Primer preverjanja tarantoolctl bo na primer preveril konfiguracijsko datoteko in rekel - datoteka je v redu, če tam ni sintaksičnih napak.

Ogledate si lahko stanje primerka - primer stanja tarantoolctl. Na enak način lahko naredite zagon, zaustavitev, ponovni zagon.

Ko se primerek zažene, se lahko z njim povežete na dva načina.

1. Administrativna konzola

Tarantool privzeto odpre vtičnico, običajno besedilo ASCII je poslano tja za nadzor Tarantoola. Povezava s konzolo se vedno izvede pod skrbniškim uporabnikom, ni avtentikacije, zato ni potrebe po eksternalizaciji vrat konzole za upravljanje Tarantule.

Za povezavo s to metodo morate vnesti Tarantoolctl vnesite ime primerka. Ukaz bo zagnal konzolo in se povezal kot skrbniški uporabnik. Konzolnih vrat nikoli ne izpostavljajte navzven – bolje jih pustite kot vtičnico enote. Potem se bodo na Tarantulo lahko povezali samo tisti, ki imajo dostop do pisanja v vtičnico.

Ta metoda je potrebna za administrativne zadeve. Za delo s podatki uporabite drugo metodo - binarni protokol.

2. Uporaba binarnega protokola za povezavo z določenimi vrati

Konfiguracija vsebuje direktivo poslušanja, ki odpre vrata za zunanje komunikacije. Ta vrata se uporabljajo z binarnim protokolom in tam je omogočeno preverjanje pristnosti.

Za to povezavo se uporablja tarantoolctl connect to port number. Z njim se lahko povežete z oddaljenimi strežniki, uporabite avtentikacijo in podelite različne pravice dostopa.

Snemanje podatkov in Box Module

Ker je Tarantool hkrati zbirka podatkov in aplikacijski strežnik, ima različne module. Zanima nas modul box - izvaja delo s podatki. Ko nekaj zapišete v škatlo, Tarantool zapiše podatke na disk, jih shrani v pomnilnik ali naredi nekaj drugega z njimi.

Posneti

Na primer, gremo v modul box in pokličemo funkcijo box.once. To bo prisililo Tarantool, da zažene našo kodo, ko je strežnik inicializiran. Ustvarimo prostor, v katerem bodo shranjeni naši podatki. 

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

Po tem ustvarimo primarni indeks - primarni - po katerem lahko iščemo podatke. Če ne podate nobenega parametra, bo privzeto prvo polje v vsakem zapisu uporabljeno za primarni indeks.

Nato naredimo grant gostujočemu uporabniku, pod katerim se povežemo preko binarnega protokola. Omogočamo branje, pisanje in izvajanje po celotni instanci.

V primerjavi z običajnimi zbirkami podatkov je tukaj vse precej preprosto. Imamo prostor – območje, v katerem so preprosto shranjeni naši podatki. Vsak zapis se imenuje tuple. Pakiran je v MessagePack. To je zelo kul format - je binarni in zavzame manj prostora - 18 bajtov v primerjavi s 27.

Tarantool omogoča kombinacijo super hitre baze podatkov in aplikacije za delo z njimi. Tako enostavno je to narediti

Zelo priročno je delati z njim. Skoraj vsaka vrstica, vsak podatkovni zapis ima lahko popolnoma različne stolpce.

Z ukazom Box.space si lahko ogledamo vse prostore. Če želite izbrati določen primerek, napišite box.space example in pridobite popolne informacije o njem.

Tarantool ima dva vgrajena motorja: Memory in Vinyl. Pomnilnik shrani vse podatke v pomnilnik. Zato vse deluje preprosto in hitro. Podatki se prenesejo na disk, na voljo pa je tudi mehanizem zapisovanja vnaprej, tako da ne bomo izgubili ničesar, če se strežnik zruši.

Vinyl shranjuje podatke na disk v nam bolj znani obliki - to pomeni, da lahko shranite več podatkov, kot imamo pomnilnika, Tarantula pa jih bo prebrala z diska.

Za zdaj bomo uporabljali 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>

Kazalo:

Za vsak prostor je treba ustvariti primarni indeks, saj brez njega nič ne deluje. Kot v vsaki bazi podatkov ustvarimo prvo polje – ID zapisa.

Deli:

Tukaj navajamo, iz česa je sestavljen naš indeks. Sestavljeno je iz enega dela - prvo polje, ki ga bomo uporabili, je tipa unsigned - pozitivno celo število. Kolikor se spomnim iz dokumentacije, je največje možno število 18 kvintiljonov. To je veliko.

Nato lahko z ukazom vstavi podatke vstavimo.

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 uporablja kot primarni ključ, zato mora biti unikatno. Nismo omejeni s številom stolpcev, zato lahko tja vnesemo poljubno količino podatkov. Podani so v formatu MessagePack, ki sem ga opisal zgoraj.

Izpis podatkov

Nato lahko prikažemo podatke z ukazom select.

Box.example.select s tipko {1} prikaže želeni vnos. Če spustimo ključ, bomo videli vse zapise, ki jih imamo. Vsi se razlikujejo po številu stolpcev, vendar tukaj načeloma ni koncepta stolpcev - obstajajo številke polj.

Podatkov je lahko popolnoma poljubno. In na primer, moramo jih iskati po drugem polju. Da bi to naredili, ustvarimo nov sekundarni indeks.


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

Uporabljamo ukaz Create_index.
Imenujmo to sekundarno.

Po tem morate določiti parametre. Vrsta indeksa je DREVO. Morda ni edinstven, zato vnesite Unique = false.

Nato navedemo, iz katerih delov je sestavljen naš indeks. Polje je številka polja, na katerega vežemo indeks, in podamo tip niza. In tako je nastal.

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>

Zdaj ga lahko imenujemo takole:

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

ohranjanje

Če znova zaženemo instanco in znova poskusimo priklicati podatke, bomo videli, da jih ni - vse je prazno. To se zgodi zato, ker Tarantool naredi kontrolne točke in shrani podatke na disk, če pa nehamo delati do naslednjega shranjevanja, bomo izgubili vse operacije – ker se bomo obnovili od zadnje kontrolne točke, ki je bila na primer pred dvema urama.

Tudi varčevanje vsako sekundo ne bo šlo, ker nenehno odlaganje 20 GB na disk ni dobra ideja.

V ta namen je bil izumljen in implementiran koncept dnevnika pisanja vnaprej. Z njegovo pomočjo se za vsako spremembo podatkov ustvari vnos v majhni dnevniški datoteki za vnaprejšnje pisanje.

Vsak vnos do kontrolne točke je shranjen v njih. Za te datoteke nastavimo velikost - na primer 64 MB. Ko je polna, se začne snemanje druge datoteke. In po ponovnem zagonu se Tarantool obnovi z zadnje kontrolne točke in nato prevrne vse kasnejše transakcije, dokler se ne ustavi.

Tarantool omogoča kombinacijo super hitre baze podatkov in aplikacije za delo z njimi. Tako enostavno je to narediti

Če želite izvesti takšno snemanje, morate v nastavitvah box.cfg (v datoteki example.lua) določiti možnost: 

wal_mode = “write”;

uporaba podatkov

S tem, kar smo napisali zdaj, lahko uporabite Tarantulo za shranjevanje podatkov in zelo hitro bo deloval kot baza podatkov. In zdaj je češnja na torti tisto, kar lahko naredite z vsem tem.

Pisanje vloge

Na primer, napišimo naslednjo aplikacijo za Tarantulo

Glej aplikacijo pod spojlerjem

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

V lui deklariramo neko tabelo, ki definira znake. Ta plošča je potrebna za ustvarjanje naključnega 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

Po tem deklariramo funkcijo - randomString in podamo vrednost dolžine v oklepaju. 

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

Nato povežemo http usmerjevalnik in http strežnik z našim strežnikom Tarantula, JSON, ki ga bomo poslali odjemalcu.

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

Po tem zaženemo na vratih 8080 na vseh strežniških vmesnikih http, ki beležijo vse zahteve in napake.

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

Nato deklariramo route, tako da če zahteva z metodo GET prispe na vrata 8080 /count, potem pokličemo funkcijo iz ene vrstice. Vrne status - 200, 404, 403 ali katerega koli drugega, ki ga določimo. 

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

V telesu vrnemo json.encode, v njem označimo count in getcount, ki se pokliče in prikaže število zapisov v naši bazi.

Druga metoda

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)

Kje v vrsti router:route({method = 'GET', path = '/token'}, function() pokličemo funkcijo in ustvarimo žeton.

Linija lokalni žeton = randomString(32) je naključen niz 32 znakov.
V vrsti lokalni zadnji = box.space.example:len() vzamemo zadnji element.
In v vrsti box.space.example:insert{ zadnji + 1, žeton} podatke zapišemo v našo bazo, se pravi ID enostavno povečamo za 1. To se da, mimogrede, storiti ne samo na ta klavrn način. V Tarantuli obstajajo sekvence za to.

Tam zapišemo žeton.

Tako smo vlogo napisali v eno datoteko. Tam lahko neposredno manipulirate s podatki, modul box pa bo namesto vas opravil vse umazano delo.

Posluša http in dela s podatki, vse je v eni instanci - tako aplikacija kot podatki. Zato se vse zgodi zelo hitro.

Za začetek namestimo modul http:

Kako to naredimo, poglejte pod spojlerjem

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

Za delovanje potrebujemo tudi prometeja:

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

Zaženemo in lahko dostopamo do modulov

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 izda žeton in ga zapiše v bazo podatkov.

Testiranje hitrosti

Izvedimo merilo uspešnosti za 50 zahtev. Tekmovalo bo 000 zahtevkov. 

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

Žetoni so izdani. In nenehno beležimo podatke. 99 % zahtevkov je bilo obdelanih v 42 milisekundah. Temu primerno imamo približno 3500 zahtev na sekundo na majhnem stroju z 2 jedri in 4 gigabajti pomnilnika.

Izberete lahko tudi nekaj 50000 žetonov in vidite njihovo vrednost.

Uporabljate lahko ne le http, ampak tudi izvajate funkcije v ozadju, ki obdelujejo vaše podatke. Poleg tega obstajajo različni sprožilci. Na primer, lahko pokličete funkcije za posodobitve, preverite nekaj - odpravite konflikte.

Skriptne aplikacije lahko pišete neposredno v samem strežniku baz podatkov in niste z ničemer omejeni, povezujete poljubne module in izvajate poljubno logiko.

Aplikacijski strežnik lahko dostopa do zunanjih strežnikov, pridobi podatke in jih doda v svojo bazo podatkov. Podatke iz te zbirke podatkov bodo uporabljale druge aplikacije.

Tarantula bo to naredila sama in vam ne bo treba pisati posebne prijave.

Na koncu

To je le prvi del velikega dela. Drugi bo kmalu objavljen na blogu skupine Mail.ru in v tem gradivu bomo zagotovo dodali povezavo do njega.

Če vas zanima udeležba na dogodkih, kjer te stvari gradimo na spletu, in zastavljanje vprašanj v realnem času, se pridružite kanal DevOps podjetja REBRAIN.

Če se morate preseliti v oblak ali imate vprašanja o vaši infrastrukturi, pustite prošnjo.

PS Imamo 2 brezplačni reviziji na mesec, morda bo vaš projekt ena izmed njih.

Vir: www.habr.com

Dodaj komentar