🥇In Tarantool kan jy 'n supervinnige databasis en 'n toepassing kombineer om daarmee te werk. Hier is hoe maklik dit gedoen word

Vyf jaar gelede het ek probeer om met Tarantool te werk, maar toe werk dit nie vir my nie. Maar onlangs het ek 'n webinar gehou waar ek oor Hadoop gepraat het, oor hoe MapReduce werk. Daar is ek die vraag gevra - "Hoekom nie Tarantool vir hierdie taak gebruik nie?".

Vir nuuskierigheid het ek besluit om daarna terug te keer, die nuutste weergawe te toets – en hierdie keer het ek baie van die projek gehou. Nou sal ek wys hoe om 'n eenvoudige toepassing in Tarantool te skryf, dit te laai en die prestasie na te gaan, en jy sal sien hoe maklik en cool alles daar is.

Wat is Tarantool

Tarantool posisioneer homself as 'n ultra-vinnige databasis. Jy kan enige data wat jy wil daarin plaas. Boonop, herhaal hulle, shard - dit wil sê, verdeel 'n groot hoeveelheid data oor verskeie bedieners en kombineer die resultate daarvan - maak foutverdraagsame meester-meester-skakels.

Tweedens is dit 'n toepassingsbediener. Jy kan jou toepassings daarop skryf, met data werk, byvoorbeeld ou inskrywings op die agtergrond uitvee volgens sekere reëls. Jy kan 'n Http-bediener direk in Tarantula skryf wat met data sal werk: gee hul nommer uit, skryf nuwe data daar en verminder dit alles tot 'n meester.

Ek het 'n artikel gelees oor hoe die ouens 'n 300-reël boodskap tou gemaak het, wat net skeur en slaan - hulle het 'n minimum prestasie van 20 000 boodskappe per sekonde. Hier kan jy regtig omdraai en 'n baie groot toepassing skryf, en dit sal nie gestoor word nie, soos in PostgreS.

Ongeveer so 'n bediener, net eenvoudig, sal ek in hierdie artikel probeer beskryf.

installasie

Vir die toets het ek drie standaard virtuele masjiene begin - 'n 20 gigagreep hardeskyf, Ubuntu 18.04. 2 virtuele SVE en 4 gigagrepe geheue.

Ons installeer Tarantool - voer 'n bash-skrip uit of voeg 'n bewaarplek by en kan Tarantool installeer. Skakel na die skrif - (krul -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Ons het opdragte soos:

tarantoolctl is die hoofopdrag vir die bestuur van Tarantula-gevalle.
/etc/tarantool - hier lê die hele konfigurasie.
var/log/tarantool - hier is die logs.
var/lib/tarantool - hier lê die data, en dan word hulle in gevalle verdeel.

Daar is instansies beskikbaar en instansie-aktiveer dopgehou - dit bevat wat geloods sal word - die instansie konfigurasielêer met lua-kode, wat beskryf op watter poorte dit luister, watter geheue daarvoor beskikbaar is, Vinyl-enjininstellings, kode wat by opstart werk bedieners, versplintering, toue, verwydering van verouderde data, ensovoorts.

Gevalle werk soos in PostgreS. Byvoorbeeld, jy wil veelvuldige kopieë van 'n databasis laat loop wat op verskillende poorte hang. Dit blyk dat verskeie databasisgevalle op een bediener geloods word, wat aan verskillende poorte hang. Hulle kan heeltemal verskillende instellings hê - een geval implementeer een logika, die tweede - 'n ander.

Gevalbestuur

Ons het die tarantoolctl-opdrag wat ons in staat stel om Tarantula-gevalle te bestuur. Byvoorbeeld, tarantoolctl check-voorbeeld sal die konfigurasielêer nagaan en sê dat die lêer in orde is as daar geen sintaksisfoute is nie.

Jy kan die status van die instansie sien - tarantoolctl status voorbeeld. Op dieselfde manier kan jy begin, stop, herbegin.

Sodra 'n instansie aan die gang is, is daar twee maniere om daaraan te koppel.

1. Administratiewe konsole

By verstek maak Tarantool 'n sok oop en stuur gewone ASCII-teks om die Tarantula te beheer. Verbinding met die konsole vind altyd plaas onder die admin-gebruiker, daar is geen verifikasie nie, so jy hoef nie die konsolepoort uit te haal om die Tarantula buite te beheer nie.

Om op hierdie manier te koppel, moet jy Tarantoolctl invoer instansie naam invoer. Die opdrag sal die konsole begin en verbind as die admin gebruiker. Moet nooit die konsolepoort aan die buitekant blootstel nie - dit is beter om dit as 'n eenheidsok te laat. Dan sal slegs diegene wat skryftoegang tot die sok het, aan die Tarantula kan koppel.

Hierdie metode is nodig vir administratiewe dinge. Om met data te werk, gebruik die tweede metode - die binêre protokol.

2. Gebruik 'n binêre protokol om aan 'n spesifieke poort te koppel

Daar is 'n luisteraanwysing in die konfigurasie, wat die poort oopmaak vir eksterne kommunikasie. Hierdie poort word gebruik met binêre protokol en stawing is daar geaktiveer.

Vir hierdie verbinding word tarantoolctl connect to poortnommer gebruik. Deur dit te gebruik, kan jy aan afgeleë bedieners koppel, stawing gebruik en verskeie toegangsregte gee.

Dataopname en Box Module

Aangesien Tarantool beide 'n databasis en 'n toepassingsbediener is, het dit verskeie modules. Ons stel belang in die boksmodule - dit implementeer werk met data. Wanneer jy iets na 'n boks skryf, skryf Tarantool die data na skyf, stoor dit in die geheue, of doen iets anders daarmee.

rekord

Ons gaan byvoorbeeld na die boksmodule en roep die boks.eens-funksie. Dit sal Tarantool dwing om ons kode te laat loop wanneer die bediener geïnisialiseer word. Ons skep 'n spasie waar ons data gestoor sal word.

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

Daarna skep ons 'n primêre indeks – primêre – waarmee ons data kan soek. By verstek, as geen parameters gespesifiseer word nie, sal die eerste veld in elke inskrywing vir die primer indeks gebruik word.

Dan maak ons 'n toekenning aan die gasgebruiker, waaronder ons verbind via 'n binêre protokol. Ons laat lees, skryf en uitvoer in die hele instansie toe.

In vergelyking met konvensionele databasisse, is alles hier redelik eenvoudig. Ons het spasie - 'n area waarin ons data eenvoudig gestoor word. Elke inskrywing word 'n tupel genoem. Dit is verpak in 'n MessagePack. Dit is 'n baie oulike formaat - dit is binêr en neem minder spasie op - 18 grepe teenoor 27.

Dit is baie gerieflik om saam met hom te werk. Byna elke reël, elke data-invoer kan heeltemal verskillende kolomme hê.

Ons kan alle spasies bekyk deur die Box.space-opdrag te gebruik. Om 'n spesifieke instansie te kies, skryf ons box.space-voorbeeld en kry volledige inligting daaroor.

Daar is twee tipes enjins wat in Tarantool ingebou is: geheue en vinyl. Geheue stoor alle data in die geheue. Daarom werk alles eenvoudig en vinnig. Die data word na skyf gestort, en daar is ook 'n skryf-vooruitlog-meganisme, so ons sal niks verloor as die bediener ineenstort nie.

Vinyl stoor data op skyf in 'n meer bekende vorm - dit wil sê, jy kan meer data stoor as wat ons geheue het, en Tarantula sal dit van skyf af lees.

Nou sal ons Memory gebruik.

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:

’n Primêre indeks moet vir enige spasie geskep word, want niks sal daarsonder werk nie. Soos in enige databasis, skep ons die eerste veld - die rekord-ID.

Dele:

Dit is waar ons spesifiseer waaruit ons indeks bestaan. Dit bestaan uit een deel - die eerste veld wat ons sal gebruik, tik unsigned - 'n positiewe heelgetal. Sover ek uit die dokumentasie onthou, is die maksimum getal wat kan wees 18 kwintiljoen. Baie awesome.

Ons kan dan data invoeg deur die insert-opdrag te gebruik.

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>

Die eerste veld word as die primêre sleutel gebruik, dus moet dit uniek wees. Ons word nie beperk deur die aantal kolomme nie, so ons kan soveel data daar invoeg as wat ons wil. Hulle word gespesifiseer in die MessagePack-formaat, wat ek hierbo beskryf het.

Data-uitset

Dan kan ons die data vertoon met die kies-opdrag.

Box.example.select met die sleutel {1} sal die verlangde inskrywing vertoon. As ons die sleutel weglaat, sal ons al die rekords sien wat ons het. Hulle verskil almal in die aantal kolomme, maar hier is in beginsel geen konsep van kolomme nie - daar is veldnommers.

Daar kan absoluut soveel data wees as wat jy wil. En byvoorbeeld, ons moet hulle in die tweede veld soek. Om dit te doen, maak ons 'n nuwe sekondêre indeks.


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

Ons gebruik die Create_index opdrag.
Ons noem dit Sekondêr.

Daarna moet u die parameters spesifiseer. Die indekstipe is TREE. Dit is dalk nie uniek nie, daarom voer ons Uniek = vals in.

Dan dui ons aan uit watter dele ons indeks bestaan. Veld is die nommer van die veld waaraan ons die indeks bind, en spesifiseer die string tipe. En so is dit geskep.

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>

Nou is dit hoe ons dit kan noem:

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

bewaring

As ons die instansie herbegin en weer probeer om die data te bel, sal ons sien dat hulle nie daar is nie - alles is leeg. Dit gebeur omdat Tarantool kontrolepunte maak en die data op skyf stoor, maar as ons ophou werk voor die volgende stoor, sal ons alle bewerkings verloor - want ons sal herstel van die laaste kontrolepunt, wat byvoorbeeld twee uur gelede was.

Om elke sekonde te stoor sal ook nie werk nie - want om voortdurend 20 GB op skyf te stort is 'n so-so idee.

Hiervoor is die konsep van voorskryf-logboek uitgevind en geïmplementeer. Met sy hulp, vir elke verandering in die data, word 'n rekord geskep in 'n klein skryf-vooruit-loglêer.

Elke inskrywing tot by die kontrolepunt word daarin gestoor. Vir hierdie lêers stel ons die grootte - byvoorbeeld 64 mb. Wanneer dit vol is, begin die opname na die tweede lêer gaan. En na die herbegin herstel Tarantool van die laaste kontrolepunt en rol dan alle latere transaksies oor totdat dit stop.

Om so 'n opname uit te voer, moet jy 'n opsie spesifiseer in die box.cfg instellings (in die example.lua lêer):

wal_mode = “write”;

data gebruik

Met wat ons nou geskryf het, kan jy die Tarantula gebruik om data te stoor en dit sal baie vinnig as 'n databasis werk. En nou die kersie op die koek - wat kan jy met dit alles doen.

Die skryf van 'n aansoek

Kom ons skryf byvoorbeeld so 'n aansoek vir die Tarantula

Sien die aansoek onder die bederf

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

Ons verklaar een of ander tabel in lua wat simbole definieer. Hierdie tabel is nodig om 'n ewekansige string te genereer.

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

Daarna verklaar ons 'n funksie - randomString en gee die lengtewaarde tussen hakies.

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

Dan koppel ons die http-roeteerder en http-bediener aan ons Tarantula-bediener, JSON, wat ons aan die kliënt sal gee.

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

Daarna begin ons op poort 8080 op alle http-bediener-koppelvlakke, wat alle versoeke en foute sal aanteken.

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

Vervolgens verklaar ons 'n roete dat as 'n versoek met die GET-metode op poort 8080 /count arriveer, dan roep ons die funksie van een lyn af. Dit gee 'n status terug - 200, 404, 403 of wat ons ook al spesifiseer.

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

In die liggaam gee ons json.encode terug, ons spesifiseer telling en getcount daarin, wat genoem word en die aantal rekords in ons databasis wys.

Die tweede 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)

Waar in die ry router:route({metode = 'GET', pad = '/token'}, funksie() ons roep die funksie en genereer 'n teken.

ry plaaslike teken = randomString(32) is 'n ewekansige string van 32 karakters.
In lyn local last = box.space.example:len() ons trek die laaste element uit.
En in die ry box.space.example:insert{ last + 1, token } ons skryf die data na ons databasis, dit wil sê ons verhoog eenvoudig die ID met 1. Dit kan terloops nie net op so 'n lomp manier gedoen word nie. Tarantula het rye vir hierdie geval.

Ons skryf die teken daar.

Ons het dus 'n aansoek in een lêer geskryf. Jy kan dadelik toegang tot die data kry, en die boksmodule sal al die vuil werk vir jou doen.

Dit luister na http en werk met data, alles is in 'n enkele geval - beide die toepassing en die data. Daarom gebeur alles redelik vinnig.

Om te hardloop, installeer ons die http-module:

Hoe ons dit doen, sien onder die bederf

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

Ons het ook Prometheus nodig om te hardloop:

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

Ons begin en het toegang tot modules

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 gee ons status 200.
/token reik 'n teken uit en skryf hierdie teken na die databasis.

Toets spoed

Kom ons stel 'n maatstaf vir 50 000 versoeke. Mededingende versoeke sal 500 wees.

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

Tokens word uitgereik. En ons teken voortdurend data aan. 99% van versoeke is in 42 millisekondes voltooi. Gevolglik het ons ongeveer 3500 versoeke per sekonde op 'n klein masjien, waar daar 2 kerns en 4 gigagrepe geheue is.

Jy kan ook sowat 50000 XNUMX tokens kies en die waarde daarvan sien.

Jy kan nie net http gebruik nie, hardloop agtergrondfunksies wat jou data verwerk. Boonop is daar verskeie snellers. Byvoorbeeld, jy kan funksies op opdaterings oproep, iets nagaan - konflikte regstel.

Jy kan skriftoepassings direk in die databasisbediener self skryf, en deur niks beperk word nie, enige modules koppel en enige logika implementeer.

Die toepassingsbediener kan toegang tot eksterne bedieners kry, data insamel en dit by sy databasis voeg. Data van hierdie databasis sal deur ander toepassings gebruik word.

Dit sal deur die Tarantula self gedoen word, en dit is nie nodig om 'n aparte aansoek te skryf nie.

Ten slotte

Dit is net die eerste deel van 'n groot werk. Die tweede een sal binnekort op die Mail.ru Group-blog gepubliseer word, en ons sal beslis 'n skakel daarby voeg in hierdie artikel.

As jy belangstel om geleenthede by te woon waar ons hierdie dinge aanlyn skep en intyds vrae vra, maak kontak met DevOps deur REBRAIN-kanaal.

As jy na die wolk moet skuif of vrae het oor jou infrastruktuur, Dien gerus 'n versoek in.

NS Ons het 2 gratis oudits per maand, miskien sal jou projek een van hulle wees.

Bron: will.com

In Tarantool kan u 'n supervinnige databasis en 'n toepassing kombineer om daarmee te werk. Hier is hoe maklik dit is om te doen