Programmā Tarantool varat apvienot īpaši ātru datu bāzi un lietojumprogrammu, lai strādātu ar tām. Lūk, cik viegli to izdarīt

Pirms pieciem gadiem es mēģināju strādāt ar Tarantool, bet tad tas man nedarbojās. Bet nesen es rīkoju vebināru, kurā runāju par Hadoop, par to, kā darbojas MapReduce. Tur man uzdeva jautājumu - "Kāpēc šim uzdevumam neizmantot Tarantool?".

Zinātkāres labad nolēmu pie tā atgriezties, notestēt jaunāko versiju – un šoreiz projekts man ļoti patika. Tagad es jums parādīšu, kā uzrakstīt vienkāršu lietojumprogrammu Tarantool, ielādēt to un pārbaudīt tā veiktspēju, un jūs redzēsiet, cik viss ir viegli un forši.

Kas ir Tarantool

Tarantool pozicionē sevi kā īpaši ātru datubāzi. Jūs varat ievietot visus vajadzīgos datus. Turklāt atkārtojiet tos, sadaliet tos — tas ir, sadaliet milzīgu datu apjomu vairākos serveros un apvienojiet to rezultātus — izveidojiet kļūmju izturīgas galvenās un galvenās saites.

Otrkārt, tas ir lietojumprogrammu serveris. Tajā varat rakstīt savas lietojumprogrammas, strādāt ar datiem, piemēram, dzēst vecos ierakstus fonā saskaņā ar noteiktiem noteikumiem. Jūs varat tieši Tarantulā uzrakstīt HTTP serveri, kas strādās ar datiem: norādiet to numuru, ierakstiet tur jaunus datus un samaziniet to visu uz galveno.

Izlasīju rakstu par to, kā puiši sastādīja 300 rindu ziņojumu rindu, kas vienkārši plosās un dauzās - viņiem minimālais sniegums ir 20 000 ziņojumu sekundē. Šeit jūs patiešām varat apgriezties un uzrakstīt ļoti lielu pieteikumu, un tie netiks saglabāti, kā PostgreS.

Apmēram šādu serveri, tikai vienkāršu, es mēģināšu aprakstīt šajā rakstā.

Uzstādīšana

Pārbaudei es iedarbināju trīs standarta virtuālās mašīnas - 20 gigabaitu cieto disku, Ubuntu 18.04. 2 virtuālais procesors un 4 gigabaiti atmiņa.

Mēs instalējam Tarantool — palaižam bash skriptu vai pievienojam repozitoriju un apt get instalējam Tarantool. Saite uz skriptu - (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Mums ir tādas komandas kā:

tarantoolctl ir galvenā komanda Tarantula gadījumu pārvaldībai.
/etc/tarantool - šeit ir visa konfigurācija.
var/log/tarantool - lūk, baļķi.
var/lib/tarantool - šeit atrodas dati, un pēc tam tie tiek sadalīti instancēs.

Ir instancē pieejamās un instanču iespējotas mapes - tajā ir ietverts tas, kas tiks palaists - instances konfigurācijas fails ar lua kodu, kurā aprakstīts, kuros portos tas klausās, kāda atmiņa tai ir pieejama, vinila dzinēja iestatījumi, kods, kas darbojas startēšanas laikā. serveri, sadalīšana, rindas, novecojušu datu dzēšana un tā tālāk.

Gadījumi darbojas tāpat kā PostgreS. Piemēram, vēlaties palaist vairākas datu bāzes kopijas, kas karājas dažādos portos. Izrādās, ka vienā serverī tiek palaisti vairāki datu bāzes gadījumi, kas karājas dažādos portos. Tiem var būt pilnīgi dažādi iestatījumi – viena instance īsteno vienu loģiku, otrā – citu.

Instanču vadība

Mums ir komanda tarantoolctl, kas ļauj mums pārvaldīt Tarantula gadījumus. Piemēram, tarantoolctl pārbaudes piemērs pārbaudīs konfigurācijas failu un paziņos, ka fails ir kārtībā, ja nav sintakses kļūdu.

Jūs varat redzēt instances statusu - tarantoolctl statusa piemēru. Tādā pašā veidā jūs varat sākt, apturēt, restartēt.

Kad instance darbojas, ir divi veidi, kā ar to izveidot savienojumu.

1. Administratīvā konsole

Pēc noklusējuma Tarantool atver ligzdu un nosūta vienkāršu ASCII tekstu, lai kontrolētu Tarantula. Savienojums ar konsoli vienmēr notiek administratora lietotāja vadībā, nav autentifikācijas, tāpēc jums nav jāizņem konsoles ports, lai kontrolētu Tarantula ārpusē.

Lai izveidotu savienojumu šādā veidā, jums jāievada Tarantoolctl enter instance name. Komanda palaidīs konsoli un izveidos savienojumu kā administratora lietotājs. Nekad nepakļaujiet konsoles pieslēgvietu ārpusei - labāk atstāt to kā ierīces ligzdu. Tad tikai tie, kuriem ir rakstīšanas piekļuve ligzdai, varēs pieslēgties Tarantulam.

Šī metode ir nepieciešama administratīvām lietām. Lai strādātu ar datiem, izmantojiet otro metodi - bināro protokolu.

2. Binārā protokola izmantošana, lai izveidotu savienojumu ar noteiktu portu

Konfigurācijā ir klausīšanās direktīva, kas atver portu ārējiem sakariem. Šis ports tiek izmantots ar bināro protokolu, un tajā ir iespējota autentifikācija.

Šim savienojumam tiek izmantots tarantoolctl savienojums ar porta numuru. Izmantojot to, jūs varat izveidot savienojumu ar attāliem serveriem, izmantot autentifikāciju un piešķirt dažādas piekļuves tiesības.

Datu ierakstīšanas un kastes modulis

Tā kā Tarantool ir gan datubāze, gan lietojumprogrammu serveris, tam ir dažādi moduļi. Mūs interesē kastes modulis - tas realizē darbu ar datiem. Kad kaut ko ierakstāt kastē, Tarantool ieraksta datus diskā, saglabā tos atmiņā vai dara ar tiem kaut ko citu.

Ieraksts

Piemēram, mēs ieejam kastes modulī un izsaucam funkciju box.once. Tas piespiedīs Tarantool palaist mūsu kodu, kad serveris tiks inicializēts. Mēs izveidojam vietu, kur tiks glabāti mūsu dati.

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

Pēc tam mēs izveidojam primāro indeksu - primāro -, pēc kura mēs varam meklēt datus. Ja parametri nav norādīti, pēc noklusējuma tiks izmantots pirmais lauks katrā primer indeksa ierakstā.

Pēc tam mēs piešķiram vieslietotājam grantu, saskaņā ar kuru mēs izveidojam savienojumu, izmantojot bināro protokolu. Mēs atļaujam lasīt, rakstīt un izpildīt visā instancē.

Salīdzinot ar parastajām datu bāzēm, šeit viss ir pavisam vienkārši. Mums ir telpa – zona, kurā vienkārši tiek glabāti mūsu dati. Katrs ieraksts tiek saukts par korteļļu. Tas ir iesaiņots MessagePack. Šis ir ļoti foršs formāts — tas ir binārs un aizņem mazāk vietas — 18 baiti pret 27.

Ar viņu ir diezgan ērti strādāt. Gandrīz katrā rindā, katrā datu ierakstā var būt pilnīgi atšķirīgas kolonnas.

Mēs varam apskatīt visas atstarpes, izmantojot komandu Box.space. Lai atlasītu konkrētu gadījumu, mēs rakstām box.space piemēru un iegūstam pilnu informāciju par to.

Tarantool ir iebūvēti divu veidu dzinēji: Memory un Vinyl. Atmiņa saglabā visus datus atmiņā. Tāpēc viss darbojas vienkārši un ātri. Dati tiek izmesti diskā, un ir arī ierakstīšanas žurnāla mehānisms, tāpēc mēs neko nezaudēsim, ja serveris avarē.

Vinils uzglabā datus diskā pazīstamākā formā - tas ir, jūs varat uzglabāt vairāk datu, nekā mums ir atmiņa, un Tarantula tos nolasīs no diska.

Tagad mēs izmantosim atmiņu.

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>

Indekss:

Jebkurai telpai ir jāizveido primārais indekss, jo bez tā nekas nedarbosies. Tāpat kā jebkurā datu bāzē, mēs izveidojam pirmo lauku - ieraksta ID.

Daļas:

Šeit mēs norādām, no kā sastāv mūsu indekss. Tas sastāv no vienas daļas - pirmā lauka, ko izmantosim, ierakstiet unsigned - pozitīvs vesels skaitlis. Cik atceros no dokumentācijas, maksimālais skaits, kas var būt, ir 18 kvintiljoni. Daudz satriecoša.

Pēc tam mēs varam ievietot datus, izmantojot ievietošanas komandu.

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>

Pirmais lauks tiek izmantots kā primārā atslēga, tāpēc tam ir jābūt unikālam. Mūs neierobežo kolonnu skaits, tāpēc mēs varam ievietot tik daudz datu, cik mums patīk. Tie ir norādīti MessagePack formātā, kuru es aprakstīju iepriekš.

Datu izvade

Pēc tam mēs varam parādīt datus ar atlases komandu.

Box.example.select ar taustiņu {1} parādīs vajadzīgo ierakstu. Ja izlaidīsim atslēgu, mēs redzēsim visus mūsu rīcībā esošos ierakstus. Tie visi atšķiras kolonnu skaitā, bet šeit principā nav kolonnu jēdziena - ir lauku numuri.

Datu var būt absolūti tik daudz, cik vēlaties. Un, piemēram, mums tie jāmeklē otrajā laukā. Lai to izdarītu, mēs izveidojam jaunu sekundāro indeksu.

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

Mēs izmantojam komandu Create_index.
Mēs to saucam par sekundāro.

Pēc tam jums jānorāda parametri. Indeksa veids ir KOKS. Tas var nebūt unikāls, tāpēc ievadām Unique = false.

Pēc tam mēs norādām, no kurām daļām sastāv mūsu indekss. Lauks ir tā lauka numurs, ar kuru mēs saistām indeksu, un norāda virknes veidu. Un tā tas tika izveidots.

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>

Tagad mēs to varam saukt šādi:

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

Konservēšana

Ja mēs restartēsim instanci un mēģināsim vēlreiz izsaukt datus, mēs redzēsim, ka to nav - viss ir tukšs. Tas notiek tāpēc, ka Tarantool veido kontrolpunktus un saglabā datus diskā, bet, ja mēs pārtrauksim darbu pirms nākamās saglabāšanas, mēs zaudēsim visas darbības - jo mēs atgūsim no pēdējā kontrolpunkta, kas bija, piemēram, pirms divām stundām.

Arī katras sekundes saglabāšana nedarbosies - jo pastāvīga 20 GB izmešana diskā ir tik ļoti ideja.

Šim nolūkam tika izgudrots un ieviests priekšraksta žurnāla jēdziens. Ar tās palīdzību par katru datu izmaiņu tiek izveidots ieraksts nelielā priekšraksta žurnālfailā.

Tajos tiek saglabāts katrs ieraksts līdz kontrolpunktam. Šiem failiem mēs iestatām izmēru - piemēram, 64 mb. Kad tas aizpildās, ieraksts sāk pāriet uz otro failu. Un pēc restartēšanas Tarantool atkopjas no pēdējā kontrolpunkta un pēc tam apceļ visus vēlākos darījumus, līdz tas apstājas.

Lai veiktu šādu ierakstu, box.cfg iestatījumos (failā example.lua) jānorāda opcija:

wal_mode = “write”;

datu lietojums

Ar to, ko esam uzrakstījuši tagad, jūs varat izmantot Tarantula datu glabāšanai, un tas darbosies ļoti ātri kā datu bāze. Un tagad ķirsis uz kūkas - ko ar to visu darīt.

Pieteikuma rakstīšana

Piemēram, uzrakstīsim šādu pieteikumu Tarantulam

Aplikāciju skatiet zem spoilera

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

Mēs deklarējam kādu tabulu lua valodā, kas definē simbolus. Šī tabula ir nepieciešama, lai ģenerētu nejaušu virkni.

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ēc tam mēs deklarējam funkciju - randomString un iekavās dodam garuma vērtību.

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

Pēc tam mēs savienojam http maršrutētāju un http serveri ar mūsu Tarantula serveri JSON, ko mēs nodosim klientam.

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

Pēc tam mēs sākam ar portu 8080 visās http servera saskarnēs, kas reģistrēs visus pieprasījumus un kļūdas.

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

Tālāk mēs deklarējam maršrutu, kurā, ja pieprasījums ar GET metodi ierodas portā 8080 /count, mēs izsaucam funkciju no vienas rindas. Tas atgriež statusu - 200, 404, 403 vai jebkuru citu, ko mēs norādām.

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

Pamattekstā mēs atgriežam json.encode, tajā norādām count un getcount, kas tiek izsaukts un parāda ierakstu skaitu mūsu datubāzē.

Otra metode

router:route({method = 'GET', path = '/token'}, function() 
    local token = randomString(32) 
    local last = box.space.example:len() 
    box.space.example:insert{ last + 1, token } 
    return {status = 200, body = json.encode({token = token})}
end)

Kur rindā router:route({method = 'GET', path = '/token'}, function() mēs izsaucam funkciju un ģenerējam marķieri.

String lokālais marķieris = randomString(32) ir nejauša 32 rakstzīmju virkne.
Rindā lokālais pēdējais = box.space.example:len() mēs izvelkam pēdējo elementu.
Un rindā box.space.example:insert{ pēdējais + 1, marķieris } mēs ierakstām datus savā datu bāzē, tas ir, mēs vienkārši palielinām ID par 1. To var izdarīt, starp citu, ne tikai tik neveikli. Tarantulam ir secības šim gadījumam.

Mēs tur rakstām žetonu.

Tādējādi mēs uzrakstījām pieteikumu vienā failā. Jūs varat piekļūt datiem uzreiz, un kastes modulis paveiks visu netīro darbu jūsu vietā.

Tas klausās http un strādā ar datiem, viss ir vienā instancē - gan lietojumprogramma, gan dati. Tāpēc viss notiek diezgan ātri.

Lai palaistu, mēs instalējam http moduli:

Kā mēs to darām, skatiet zem spoilera

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

Mums ir nepieciešams arī Prometejs, lai palaistu:

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

Mēs sākam un varam piekļūt moduļiem

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 dod mums statusu 200.
/token izdod marķieri un ieraksta to datu bāzē.

Pārbaudes ātrums

Izpildīsim etalonu 50 000 pieprasījumu. Konkursa pieprasījumu skaits būs 500.

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

Tiek izsniegti žetoni. Un mēs pastāvīgi ierakstām datus. 99% pieprasījumu tika izpildīti 42 milisekundēs. Attiecīgi mums ir aptuveni 3500 pieprasījumu sekundē uz mazas mašīnas, kur ir 2 kodoli un 4 gigabaiti atmiņa.

Varat arī izvēlēties kādu 50000 XNUMX marķieri un redzēt tā vērtību.

Varat izmantot ne tikai http, bet arī palaist fona funkcijas, kas apstrādā jūsu datus. Turklāt ir dažādi trigeri. Piemēram, varat izsaukt atjauninājumu funkcijas, kaut ko pārbaudīt - novērst konfliktus.

Jūs varat rakstīt skriptu lietojumprogrammas tieši pašā datu bāzes serverī un neko neierobežot, savienot moduļus un ieviest jebkuru loģiku.

Lietojumprogrammu serveris var piekļūt ārējiem serveriem, apkopot datus un pievienot tos savai datubāzei. Datus no šīs datu bāzes izmantos citas lietojumprogrammas.

To darīs pats Tarantula, un nav nepieciešams rakstīt atsevišķu pieteikumu.

Noslēgumā

Šī ir tikai pirmā liela darba daļa. Otrais pavisam drīz tiks publicēts Mail.ru grupas emuārā, un šajā rakstā noteikti pievienosim saiti uz to.

Ja vēlaties apmeklēt pasākumus, kuros mēs veidojam šīs lietas tiešsaistē, un uzdot jautājumus reāllaikā, izveidojiet savienojumu ar DevOps no REBRAIN kanāla.

Ja jums ir jāpāriet uz mākoni vai jums ir jautājumi par savu infrastruktūru, Jūtieties brīvi iesniegt pieprasījumu.

PS Mums ir 2 bezmaksas auditi mēnesī, iespējams, ka jūsu projekts būs viens no tiem.

Avots: www.habr.com