A Tarantool, podeu combinar una base de dades súper ràpida i una aplicació per treballar-hi. Aquí teniu el fàcil que és de fer

Fa cinc anys vaig intentar treballar amb Tarantool, però després no em va funcionar. Però fa poc vaig fer un seminari web on vaig parlar sobre Hadoop i com funciona MapReduce. Allà em van fer una pregunta: "Per què no utilitzar Tarantool per a aquesta tasca?"

Per curiositat, vaig decidir tornar-hi, provar la darrera versió, i aquesta vegada el projecte m'ha agradat molt. Ara us mostraré com escriure una aplicació senzilla a Tarantool, carregar-la i comprovar-ne el rendiment, i veureu com de fàcil i genial és tot.

Què és Tarantool

Tarantool es posiciona com una base de dades ultraràpida. Hi podeu posar les dades que vulgueu. A més, replicar-los, fragmentar, és a dir, dividir una gran quantitat de dades en diversos servidors i combinar-ne els resultats, fer connexions mestre-mestre tolerants a errors.

En segon lloc, aquest és un servidor d'aplicacions. Podeu escriure-hi les vostres aplicacions, treballar amb dades, per exemple, eliminar registres antics en segon pla segons determinades regles. Podeu escriure un servidor Http directament a Tarantula que funcioni amb dades: doneu la seva quantitat, escriviu-hi dades noves i reduïu-ho tot al mestre.

Vaig llegir un article sobre com els nois van fer una cua de missatges de 300 línies, que simplement esclata i es precipita: tenen un rendiment mínim de 20 missatges per segon. Aquí podeu donar la volta i escriure una aplicació molt gran, i no serà emmagatzematge, com a PostgreS.

Intentaré descriure alguna cosa com aquest servidor, només senzill, en aquest article.

Instal · lació

Per a la prova, vaig iniciar tres màquines virtuals estàndard: un disc dur de 20 GB, Ubuntu 18.04. 2 CPU virtuals i 4 giga de memòria.

Instal·lem Tarantool: executem l'script bash o afegim un dipòsit i instal·lem Tarantool. Enllaç a l'script - (rínxol -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Tenim ordres com:

tarantoolctl — l'ordre principal per gestionar les instàncies de Tarantula.
/etc/tarantool - Aquí teniu tota la configuració.
var/log/tarantool - Aquí teniu els registres.
var/lib/tarantool — les dades es troben aquí, i després es divideixen en instàncies.

Hi ha carpetes instance-available i instance-enable: conté el que s'iniciarà, un fitxer de configuració de la instància amb codi lua, que descriu quins ports escolta, quina memòria hi té disponible, la configuració del motor de vinil, el codi que s'executa a l'inici. servidors, sharding, cues, supressió de dades obsoletes, etc.

Les instàncies funcionen com a PostgreS. Per exemple, voleu executar diverses còpies d'una base de dades que es penja en diferents ports. Resulta que es llancen diverses instàncies de base de dades en un servidor, que es pengen en diferents ports. Poden tenir configuracions completament diferents: una instància implementa una lògica, la segona, una altra.

Gestió d'instàncies

Tenim l'ordre tarantoolctl, que us permet gestionar les instàncies de Tarantula. Per exemple, l'exemple de comprovació de tarantoolctl comprovarà el fitxer de configuració i dirà: el fitxer està bé si no hi ha errors de sintaxi.

Podeu veure l'estat de la instància - exemple d'estat tarantoolctl. De la mateixa manera, podeu començar, aturar, reiniciar.

Un cop s'executa la instància, podeu connectar-hi de dues maneres.

1. Consola administrativa

Per defecte, Tarantool obre un sòcol, el text ASCII normal s'envia allà per controlar Tarantool. La connexió a la consola sempre es produeix sota l'usuari administrador, no hi ha autenticació, de manera que no cal externalitzar el port de la consola per gestionar Tarantula.

Per connectar-vos mitjançant aquest mètode, heu d'introduir Tarantoolctl introduïu el nom de la instància. L'ordre iniciarà la consola i es connectarà com a usuari administrador. No exposeu mai el port de la consola a l'exterior; és millor deixar-lo com a presa de la unitat. Aleshores, només aquells que tinguin accés per escriure al sòcol podran connectar-se a Tarantula.

Aquest mètode és necessari per a coses administratives. Per treballar amb dades, utilitzeu el segon mètode: el protocol binari.

2. Utilitzar un protocol binari per connectar-se a un port específic

La configuració conté una directiva listen, que obre un port per a comunicacions externes. Aquest port s'utilitza amb el protocol binari i allà s'habilita l'autenticació.

Per a aquesta connexió, s'utilitza tarantoolctl connect to port number. Amb ell, podeu connectar-vos a servidors remots, utilitzar l'autenticació i donar diversos drets d'accés.

Enregistrament de dades i mòdul de caixa

Com que Tarantool és alhora una base de dades i un servidor d'aplicacions, té diversos mòduls. Ens interessa el mòdul de caixa: implementa el treball amb dades. Quan escriviu alguna cosa a la caixa, Tarantool escriu les dades al disc, les emmagatzema a la memòria o en fa alguna cosa més.

Registre

Per exemple, entrem al mòdul box i cridem a la funció box.once. Això obligarà Tarantool a executar el nostre codi quan s'inicialitzi el servidor. Creem un espai on s'emmagatzemaran les nostres dades.

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

Després d'això, creem un índex primari - primari - mitjançant el qual podem cercar dades. Per defecte, si no especifiqueu cap paràmetre, el primer camp de cada registre s'utilitzarà per a l'índex primari.

A continuació, fem una subvenció a l'usuari convidat, sota la qual ens connectem mitjançant el protocol binari. Permetem llegir, escriure i executar a tota la instància.

En comparació amb les bases de dades convencionals, aquí tot és bastant senzill. Tenim espai, una àrea en què simplement s'emmagatzemen les nostres dades. Cada registre s'anomena tupla. Està empaquetat al MessagePack. Aquest és un format molt interessant: és binari i ocupa menys espai: 18 bytes enfront de 27.

És molt convenient treballar amb ell. Gairebé cada línia, cada registre de dades pot tenir columnes completament diferents.

Podem veure tots els espais mitjançant l'ordre Box.space. Per seleccionar una instància específica, escriviu l'exemple box.space i obteniu informació completa al respecte.

Tarantool té dos motors integrats: Memory i Vinyl. La memòria emmagatzema totes les dades a la memòria. Per tant, tot funciona de manera senzilla i ràpida. Les dades s'aboquen al disc i també hi ha un mecanisme de registre d'escriptura anticipada, de manera que no perdrem res si el servidor es bloqueja.

El vinil emmagatzema dades al disc d'una forma més familiar per a nosaltres, és a dir, podeu emmagatzemar més dades de les que tenim memòria i Tarantula les llegirà des del disc.

De moment utilitzarem la memòria.

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>

Índex:

S'ha de crear un índex primari per a qualsevol espai, perquè sense ell res no funcionarà. Com en qualsevol base de dades, creem el primer camp: identificador de registre.

parts:

Aquí us indiquem en què consisteix el nostre índex. Consta d'una part (el primer camp que utilitzarem és de tipus sense signe), un nombre enter positiu. Pel que recordo de la documentació, la xifra màxima que pot ser és de 18 quintilions. Això és molt.

A continuació, podem inserir dades mitjançant l'ordre 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>

El primer camp s'utilitza com a clau primària, de manera que ha de ser únic. No estem limitats pel nombre de columnes, així que hi podem inserir tantes dades com vulguem. S'especifiquen en el format MessagePack, que he descrit anteriorment.

Sortida de dades

A continuació, podem mostrar les dades mitjançant l'ordre select.

Box.example.select amb la tecla {1} mostrarà l'entrada desitjada. Si baixem la tecla, veurem tots els registres que tenim. Tots es diferencien pel nombre de columnes, però aquí, en principi, no hi ha cap concepte de columnes: hi ha números de camp.

Hi pot haver qualsevol quantitat de dades. I, per exemple, hem de cercar-los pel segon camp. Per fer-ho, creem un nou índex secundari.

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

Utilitzem l'ordre Create_index.
Diguem-ne Secundària.

Després d'això, heu d'especificar els paràmetres. El tipus d'índex és TREE. Pot ser que no sigui únic, així que introduïu Únic = fals.

A continuació indiquem de quines parts consta el nostre índex. El camp és el número del camp al qual enllacem l'índex i especifiquem el tipus de cadena. I així es va crear.

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>

Ara és com podem anomenar-ho:

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

preservació

Si reiniciem la instància i intentem tornar a cridar les dades, veurem que no hi és: tot està buit. Això passa perquè Tarantool fa punts de control i desa les dades al disc, però si deixem de treballar fins al següent desat, perdrem totes les operacions, perquè ens recuperarem de l'últim punt de control, que va ser, per exemple, fa dues hores.

Tampoc funcionarà per estalviar cada segon, perquè abocar constantment 20 GB al disc no és una bona idea.

Amb aquesta finalitat, es va inventar i implementar el concepte de registre d'escriptura anticipada. Amb la seva ajuda, per a cada canvi en les dades, es crea una entrada en un petit fitxer de registre d'escriptura anticipada.

Cada entrada fins al punt de control s'emmagatzema en ells. Per a aquests fitxers establim la mida, per exemple, 64 MB. Quan està ple, la gravació comença a anar al segon fitxer. I després del reinici, Tarantool es restaura des de l'últim punt de control i després passa a totes les transaccions posteriors fins que s'atura.

Per dur a terme aquest enregistrament, heu d'especificar l'opció a la configuració box.cfg (al fitxer example.lua):

wal_mode = “write”;

ús de dades

Amb el que hem escrit ara, podeu utilitzar Tarantula per emmagatzemar dades i funcionarà molt ràpidament com a base de dades. I ara la cirereta del pastís és el que pots fer amb tot.

Redacció d'una sol·licitud

Per exemple, escrivim la següent aplicació per a Tarantula

Vegeu l'aplicació sota l'spoiler

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

Declarem alguna taula en lua que defineix els caràcters. Aquesta placa és necessària per generar una cadena aleatòria.

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

Després d'això, declarem la funció - randomString i donem el valor de longitud entre parèntesis.

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

Després connectem l'encaminador http i el servidor http al nostre servidor Tarantula, JSON, que enviarem al client.

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

Després d'això, comencem al port 8080 a totes les interfícies del servidor http, que registrarà totes les sol·licituds i errors.

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

A continuació, declarem ruta, de manera que si una sol·licitud amb el mètode GET arriba al port 8080 /count, cridem la funció des d'una línia. Retorna l'estat: 200, 404, 403 o qualsevol altre que especifiquem.

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

Al cos tornem json.encode, en ell indiquem count i getcount, que s'anomena i mostra el nombre de registres de la nostra base de dades.

El segon mètode

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)

On a la línia router:route({mètode = 'GET', camí = '/token'}, function() anomenem la funció i generem un testimoni.

Cadena testimoni local = randomString (32) és una cadena aleatòria de 32 caràcters.
En linia local last = box.space.example:len() traiem l'últim element.
I a la línia box.space.example:insert{ last + 1, token } escrivim les dades a la nostra base de dades, és a dir, simplement augmentem l'ID en 1. Això es pot fer, per cert, no només d'aquesta manera maldestra. Hi ha seqüències per a això a Taràntula.

Allà escrivim el testimoni.

Així, vam escriure l'aplicació en un sol fitxer. Podeu manipular directament les dades allà i el mòdul de caixa farà tot el treball brut per vosaltres.

Escolta http i funciona amb dades, tot està en una sola instància, tant l'aplicació com les dades. Per tant, tot passa amb força rapidesa.

Per començar instal·lem el mòdul http:

Com ho fem, mira sota l'aleró

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

També necessitem Prometheus per executar:

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

Llencem i podem accedir als mòduls

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 ens dóna l'estat 200.
/token emet un testimoni i escriu aquest testimoni a la base de dades.

Prova de velocitat

Fem un punt de referència per a 50 sol·licituds. Hi haurà 000 sol·licituds competidores.

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

S'emeten fitxes. I estem registrant dades constantment. El 99% de les sol·licituds es van processar en 42 mil·lisegons. En conseqüència, tenim unes 3500 peticions per segon en una màquina petita amb 2 nuclis i 4 gigabytes de memòria.

També podeu seleccionar uns 50000 testimonis i veure el seu valor.

No només podeu utilitzar http, sinó també executar funcions en segon pla que processen les vostres dades. A més, hi ha diversos desencadenants. Per exemple, podeu trucar a funcions sobre actualitzacions, comprovar alguna cosa: corregir conflictes.

Podeu escriure aplicacions d'script directament al propi servidor de bases de dades, sense limitar-vos a res, connectar qualsevol mòdul i implementar qualsevol lògica.

El servidor d'aplicacions pot accedir a servidors externs, recuperar dades i afegir-les a la seva base de dades. Les dades d'aquesta base de dades seran utilitzades per altres aplicacions.

Tarantula ho farà ella mateixa i no haureu d'escriure una aplicació independent.

en conclusió

Aquesta és només la primera part d'una gran obra. El segon es publicarà molt aviat al bloc del Grup Mail.ru i, sens dubte, hi afegirem un enllaç en aquest material.

Si estàs interessat a assistir a esdeveniments on creem aquestes coses en línia i fer preguntes en temps real, sintonitza canal DevOps de REBRAIN.

Si necessiteu passar al núvol o teniu preguntes sobre la vostra infraestructura, No dubteu a enviar una sol·licitud.

PS Tenim 2 auditories gratuïtes al mes, potser el vostre projecte serà una d'elles.

Font: www.habr.com