I Tarantool kan du kombinere en superhurtig database og en applikation til at arbejde med dem. Her er hvordan det gøres så enkelt

For five years, I tried to work with Tarantool, but it didn't click for me at the time. Recently, I was conducting a webinar where I discussed Hadoop and how MapReduce works. Someone asked me, "Why not use Tarantool for this task?"

Out of curiosity, I decided to return to it, test the latest version — and this time, I really liked the project. Now, I will show you how to write a simple application in Tarantool, load it, and check its performance, and you'll see how easy and cool it all is.

What is Tarantool

Tarantool positions itself as an ultra-fast database. You can stuff any data you want into it. Plus, you can replicate and shard it — that is, split a huge amount of data across several servers and aggregate the results from them — creating fault-tolerant setups like "master-master."

Secondly, it is an application server. You can write your applications on it, work with data, for example, deleting old records in the background based on specific rules. You can write an HTTP server directly in Tarantool that works with the data: providing the count, writing new data, and reducing everything to the master.

I read an article about how some guys built a messaging queue in 300 lines that just tears through — they have a minimum throughput of 20,000 messages per second. Here you can really spread your wings and write a very large application, and it won't be like stored procedures in PostgreSQL.

I will attempt to describe a server like this, but in a simple way, in this article.

Installation

For the test, I set up three standard virtual machines – 20 gigabytes of hard drive space, Ubuntu 18.04, 2 virtual CPUs, and 4 gigabytes of RAM.

We install Tarantool — we run a Bash script or add the repository and execute apt get install Tarantool. The link to the script is (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). We get commands like:

tarantoolctl — the main command for managing Tarantool instances.
/etc/tarantool — this is where all the configuration lies.
var/log/tarantool — this is where the logs are stored.
var/lib/tarantool — this is where the data is stored, and it is further divided by instances.

Der er mapperne instance-available og instance-enable – i den ligger det, der vil blive startet – konfigurationsfilen for instansen med lua-kode, hvor det er angivet, hvilke porte den lytter på, hvilken hukommelse der er tilgængelig, indstillingerne for Vinyl-motoren, koden, der aktiveres ved serverstart, sharding, køer, fjernelse af forældede data og så videre.

Instanserne fungerer som i PostgreS. For eksempel, hvis du ønsker at starte flere kopier af en database, der kører på forskellige porte. Det vil sige, på én server startes flere databasinstrumenter, der kører på forskellige porte. De kan have helt forskellige indstillinger – én instans implementerer én logik, den anden en anden.

Håndtering af instanser

Vi har kommandoen tarantoolctl, som gør det muligt at administrere Tarantula-instanser. For eksempel vil tarantoolctl check example kontrollere konfigurationsfilen og sige – filen er ok, hvis der ikke er nogen syntaksfejl.

Du kan se status for instansen – tarantoolctl status example. På samme måde kan du udføre start, stop, genstart.

Når instansen er startet, kan du oprette forbindelse på to måder.

1. Administrativ konsol

Som standard åbner Tarantool en socket, hvor almindelig ASCII-tekst sendes til at administrere Tarantula. Tilslutning til konsollen sker altid under brugeren admin, der er ingen autentifikation, så det er ikke nødvendigt at udsætte konsolporten for at administrere Tarantula ude.

For at tilslutte på denne måde skal du indtaste Tarantoolctl enter instance name. Kommandoen vil starte konsollen og oprette forbindelse under brugeren admin. Udstil aldrig konsolporten udad – det er bedre at lade den være en unit-socket. Så vil kun dem, der har adgang til at skrive til socketen, kunne oprette forbindelse til Tarantula.

Denne metode er nødvendig for administrative opgaver. Til dataarbejde skal du bruge den anden metode – den binære protokol.

2. Brug af binærprotokol til at oprette forbindelse til en bestemt port

I konfigurationen er der en direktive listen, der åbner en port for eksterne kommunikationer. Denne port bruges med binærprotokollen, og der er aktiveret autentifikation.

Til denne forbindelse bruges tarantoolctl connect to port number. Ved at bruge den kan du oprette forbindelse til fjernservere, bruge autentifikation og give forskellige adgangsrettigheder.

Dataregistrering og modulet Box

Da Tarantool både er en database og en applikationsserver, er der forskellige moduler. Vi er interesserede i modulet box - det implementerer arbejdet med data. Når du skriver noget til box, gemmer Tarantool dataene på disken, holder dem i hukommelsen eller gør noget andet med dem.

Skriv

For eksempel går vi ind i modulet box og kalder funktionen box.once. Denne får Tarantool til at køre vores kode ved serverens initialisering. Vi opretter et space, hvor vores data vil blive gemt.

local function bootstrap()
    local space = box.schema.create_space('example')
    space:create_index('primary')
    box.schema.user.grant('guest', 'read,write,execute', 'universe')

    -- Hold tingene sikre som standard
    --  box.schema.user.create('example', { password = 'secret' })
    --  box.schema.user.grant('example', 'replication')
    --  box.schema.user.grant('example', 'read,write,execute', 'space', 'example')
end

Derefter opretter vi et primært indeks - primary - som vil blive brugt til at søge efter data. Som standard, hvis der ikke angives nogen parametre, vil det første felt i hver post blive brugt til primærindekset.

Derefter giver vi adgang til brugeren guest, som vi logger ind med via det binære protokol. Vi tillader at læse, skrive og udføre i hele instansen.

Sammenlignet med almindelige databaser er det hele ret enkelt her. Vi har et space - et område, hvor vores data simpelthen opbevares. Hver post kaldes en tuple. Den pakkes i MessagePack. Dette er et meget cool format - det er binært og fylder mindre - 18 byte mod 27.

Det er ret nemt at arbejde med. Næsten hver linje, hver datapost kan have helt forskellige kolonner.

Vi kan se alle spaces ved hjælp af kommandoen Box.space. For at fremhæve en bestemt instans skriver vi box.space example og får alle oplysninger om den.

Tarantool har indbyggede to typer motorer: Memory og Vinyl. Memory gemmer alle data i hukommelsen. Så alt fungerer enkelt og hurtigt. Data dumpes til disk, og der er også en mekanisme til write ahead log, så vi ikke mister noget ved servernedbrud.

Vinyl gemmer data på disken i et mere velkendt format for os - det betyder, at vi kan gemme mere data, end vi har hukommelse til, og Tarantool vil læse dem fra disken.

Nu vil vi bruge 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>

Indeks:

Et primærindeks skal oprettes for enhver plads, fordi uden det vil intet fungere. Som i enhver database opretter vi det første felt – ID for posten.

Dele:

Her angiver vi, hvad vores indeks består af. Det består af en del – det første felt, som vi vil bruge, type unsigned — et positivt heltal. Så vidt jeg husker fra dokumentationen, er det maksimale tal, der kan være – 18 quintillioner. En imponerende mængde.

Derefter kan vi indsætte data ved hjælp af insert-kommandoen.

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>

Det første felt bruges som primærnøgle, så det skal være unikt. Antallet af kolonner er vi ikke begrænset af, så vi kan indsætte så mange data, vi vil. De angives i MessagePack-format, som jeg beskrev ovenfor.

Dataudgang

Derefter kan vi udtrække data med select-kommandoen.

Box.example.select med angivelse af nøglen {1} vil returnere den ønskede post. Hvis vi udelader nøglen, ser vi alle poster, vi har. De adskiller sig alle i antal kolonner, men her er der i princippet ikke noget begreb om kolonner — der er feltnumre.

Der kan være absolut uendeligt mange data. Og for eksempel, hvis vi skal søge i dem efter det andet felt. For dette opretter vi et nyt sekundært indeks.

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

Vi bruger kommandoen Create_index.
Vi kalder det Sekundært.

Derefter skal vi angive parametrene. Indeksets type — TREE. Det kan være ikke-unik, så vi indtaster Unique = false.

Derefter angiver vi, hvilke dele vores indeks består af. Felt — det er nummerskemaet, som vi binder indekset til, og vi angiver typen string. Og så er det oprettet.

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>

Nu kan vi kalde det sådan:

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

Gem

Hvis vi genstarter instansen og prøver at kalde dataene igen, vil vi se, at de ikke er der - alt er tomt. Det sker, fordi Tarantool laver checkpoints og gemmer dataene på disken, men hvis vi stopper før den næste gemmeoperation, mister vi alle ændringerne - fordi vi genopretter fra det sidste checkpoint, som var, for eksempel, for to timer siden.

At gemme hvert sekund vil heller ikke fungere - fordi det at dump'e 20 GB data til disken konstant ikke er en god idé.

Derfor blev konceptet write-ahead log udviklet og implementeret. Med det oprettes der en optegnelse i en lille write-ahead log-fil for hver ændring i dataene.

Hver optegnelse før checkpointet gemmes i dem. For disse filer sætter vi en størrelse - for eksempel 64 MB. Når den fyldes op, begynder optegnelsen at gå til den anden fil. Og efter en genstart genopretter Tarantool fra det sidste checkpoint og anvender derefter alle senere transaktioner indtil stop.

For at foretage en sådan optegnelse skal du angive en indstilling i konfigurationen box.cfg (i filen example.lua):

wal_mode = “write”;

Brug af data

Med det, vi lige har skrevet, kan du bruge Tarantool til at gemme data, og den vil fungere meget hurtigt som en database. Og nu den bedste del – hvad du kan gøre med alt dette.

Vi skriver applikationen

For eksempel kan vi skrive en sådan applikation til Tarantool

Se applikationen under spoileren

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; -- en time
    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

-- ved første kørsel opretter du et rum og indstiller tilladelser
box.once('replica', bootstrap)

-- aktivering af konsoladgang
console = require('console')
console.listen('127.0.0.1:3302')

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

Vi erklærer en tabel i Lua, der definerer tegn. Denne tabel er nødvendig til at generere en tilfældig streng.

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

Derefter erklærer vi en funktion – randomString og giver værdien af længden i parentes.

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

Så tilslutter vi http-routeren og http-serveren til vores Tarantool-server, samt JSON, som vi vil returnere til klienten.

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

Hereafter we start on port 8080 on all interfaces an http server that will log all requests and errors.

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

Next, we declare a route that when a request with the GET method comes to port 8080 /count, we call a function that returns a status — 200, 404, 403 or any other status we specify.

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

In the body, we return json.encode, where we specify count and get_count, which is called and displays the number of records in our database.

Second method

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)

Where in the line router:route({method = ‘GET’, path = ‘\/token’}, function() we call a function and generate a token.

Streng local token = randomString(32) – this is a random string of 32 characters.
I linjen local last = box.space.example:len() we extract the last element.
And in the line box.space.example:insert{ last + 1, token } we write data to our database, simply incrementing the ID by 1. This can actually be done in a more elegant way. Tarantool has sequences for this purpose.

Let’s write the token there.

Thus, we have written an application in one file. It can immediately interact with data, and the box module does all the dirty work for you.

It listens to http and works with data; everything exists in a single instance — both the application and the data. Therefore, everything happens quite quickly.

To start, we install the http module:

How we do this, see under the spoiler

root@test2:/# tarantoolctl rocks install http
Installerer http://rocks.tarantool.org/http-scm-1.src.rock
Mangler afhængigheder for http scm-1:
   checks >= 3.0.1 (ikke installeret)

http scm-1 afhænger af checks >= 3.0.1 (ikke installeret)
Installerer http://rocks.tarantool.org/checks-3.0.1-1.rockspec

Kloner til 'checks'...
remote: Optælling af objekter: 28, afsluttet.
remote: Optælling af objekter: 100% (28/28), afsluttet.
remote: Komprimering af objekter: 100% (19/19), afsluttet.
remote: I alt 28 (delta 1), genbrugt 16 (delta 1), pakke-genbrugt 0
Modtager objekter: 100% (28/28), 12.69 KiB | 12.69 MiB/s, afsluttet.
Løser deltakoder: 100% (1/1), afsluttet.
Bemærk: tjekker ud '580388773ef11085015b5a06fe52d61acf16b201'.

Du er i 'frakoblet HEAD'-tilstand. Du kan kigge rundt, foretage eksperimantale ændringer og committe dem, og du kan kassere eventuelle commits, du laver i denne tilstand uden at påvirke nogen grene ved at udføre endnu en checkout.

Hvis du vil oprette en ny gren for at bevare commits, du opretter, kan du gøre det (nu eller senere) ved at bruge -b med checkout-kommandoen igen. eksempel:

  git checkout -b 

Ingen eksisterende manifest. Forsøger at genopbygge...
checks 3.0.1-1 er nu installeret i /.rocks (licens: BSD)

-- C-kompilerens identifikation er GNU 7.5.0
-- Kontrollerer for fungerende C-kompilator: /usr/bin/cc
-- Kontrollerer for fungerende C-kompilator: /usr/bin/cc -- fungerer
-- Registrerer C-kompilator ABI info
-- Registrerer C-kompilator ABI info - afsluttet
-- Registrerer C-kompileringsfunktioner
-- Registrerer C-kompileringsfunktioner - afsluttet
-- Fundet TARANTOOL: /usr/include (fundet version "2.4.2-80-g18f2bc82d")
-- Tarantool LUADIR er /.rocks/share/tarantool/rocks/http/scm-1/lua
-- Tarantool LIBDIR er /.rocks/share/tarantool/rocks/http/scm-1/lib
-- Konfigurationen er afsluttet
-- Generering er afsluttet
CMake Advarsel:
  Manuel-specifikke variable blev ikke brugt af projektet:

    version


-- Bygge filer er blevet skrevet til: /tmp/luarocks_http-scm-1-V4P9SM/http/build.luarocks
Scanning af afhængigheder af mål httpd
[ 50%] Bygger C-objekt http/CMakeFiles/httpd.dir/lib.c.o
I fil inkluderet fra /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:32:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c: I funktion ’tpl_term’:
/usr/include/tarantool/lauxlib.h:144:15: advarsel: denne erklæring kan falde igennem [-Wimplicit-fallthrough=]
    (*(B)->p++ = (char)(c)))
    ~~~~~~~~~~~^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:62:7: bemærk: i udvidelsen af makroen ’luaL_addchar’
       luaL_addchar(b, '\');
       ^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:63:6: bemærk: her
      default:
      ^~~~~~~
I fil inkluderet fra /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:39:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h: I funktion ’tpe_parse’:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:147:9: advarsel: denne erklæring kan falde igennem [-Wimplicit-fallthrough=]
    type = TPE_TEXT;
    ~~~~~^~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:149:3: bemærk: her
   case TPE_LINECODE:
   ^~~~
I fil inkluderet fra /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:40:0:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h: I funktion ’httpfast_parse’:
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:372:22: advarsel: denne erklæring kan falde igennem [-Wimplicit-fallthrough=]
                 code = 0;
                 ~~~~~^~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:374:13: bemærk: her
             case status:
             ^~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:393:23: advarsel: denne erklæring kan falde igennem [-Wimplicit-fallthrough=]
                 state = message;
                 ~~~~~~^~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:395:13: bemærk: her
             case message:
             ^~~~
[100%] Linker C delt bibliotek lib.so
[100%] Bygget mål httpd
[100%] Bygget mål httpd
Installer projektet...
-- Installationskonfiguration: "Debug"
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/VERSION.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lib/http/lib.so
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/init.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/tsgi_adapter.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/nginx_server/init.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/init.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/fs.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/matching.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/middleware.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/request.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/response.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/tsgi.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/utils.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/mime_types.lua
-- Installerer: /.rocks/share/tarantool/rocks/http/scm-1/lua/http/codes.lua
http scm-1 er nu installeret i /.rocks (licens: BSD)

root@test2:/#

Vi har også brug for prometheus for at starte.

root@test2:/# tarantoolctl rocks install prometheus
Installerer http://rocks.tarantool.org/prometheus-scm-1.rockspec

Kloner ind i 'prometheus'...
remote: Tæller objekter: 19, færdig.
remote: Tæller objekter: 100% (19/19), færdig.
remote: Komprimerer objekter: 100% (19/19), færdig.
remote: I alt 19 (delta 2), genbrugt 5 (delta 0), pakke-genbrugt 0
Modtager objekter: 100% (19/19), 10.73 KiB | 10.73 MiB/s, færdig.
Løser deltaljer: 100% (2/2), færdig.
prometheus scm-1 er nu installeret i /.rocks (licens: BSD)

root@test2:/#

Vi starter og kan tilgå modulerne.

root@test2:/# curl -D - -s http://127.0.0.1:8080/token
HTTP/1.1 200 Ok
Indholdslængde: 44
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Forbindelse: keep-alive

{"token":"e2tPq9l5Z3QZrewRf6uuoJUl3lJgSLOI"}

root@test2:/# curl -D - -s http://127.0.0.1:8080/token
HTTP/1.1 200 Ok
Indholdslængde: 44
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Forbindelse: keep-alive

{"token":"fR5aCA84gj9eZI3gJcV0LEDl9XZAG2Iu"}

root@test2:/# curl -D - -s http://127.0.0.1:8080/count
HTTP/1.1 200 Ok
Indholdslængde: 11
Server: Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Forbindelse: keep-alive

{"count":2}root@test2:/#

/count отдает нам статус 200.
/token выдает токен и делает запись этого токена в базу.

Tester hastigheden.

Lad os køre et benchmark med 50.000 forespørgsler. Der vil være 500 samtidige forespørgsler.

root@test2:/# ab -c 500 -n 50000 http://127.0.0.1:8080/token
Dette er ApacheBench, Version 2.3 
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licenseret til Apache Software Foundation, http://www.apache.org/

Benchmarking 127.0.0.1 (vent venligst)
Fuldførte 5000 forespørgsler
Fuldførte 10000 forespørgsler
Fuldførte 15000 forespørgsler
Fuldførte 20000 forespørgsler
Fuldførte 25000 forespørgsler
Fuldførte 30000 forespørgsler
Fuldførte 35000 forespørgsler
Fuldførte 40000 forespørgsler
Fuldførte 45000 forespørgsler
Fuldførte 50000 forespørgsler
Færdige 50000 forespørgsler


Server Software:        Tarantool
Server Hostname:        127.0.0.1
Server Port:            8080

Dokumentsti:          /token
Dokumentlængde:        44 bytes

Samtidighedsniveau:      500
Tid taget til tests:   14.578 sekunder
Komplette forespørgsler:      50000
Fejlede forespørgsler:        0
Total overført:      7950000 bytes
HTML overført:       2200000 bytes
Forespørgsler per sekund:    3429.87 [#/sek] (gennemsnit)
Tid per forespørgsel:       145.778 [ms] (gennemsnit)
Tid per forespørgsel:       0.292 [ms] (gennemsnit, på tværs af alle samtidige forespørgsler)
Overførselsrate:          532.57 [Kbytes/sek] modtaget

Forbindelsestider (ms)
              min  mean[+/-sd] median   max
Forbindelse:        0   10 103.2      0    3048
Behandling:    12   69 685.1     15   13538
Ventende:       12   69 685.1     15   13538
Total:         12   78 768.2     15   14573

Procentdel af forespørgsler serveret inden for en given tid (ms)
  50%     15
  66%     15
  75%     16
  80%     16
  90%     16
  95%     16
  98%     21
  99%     42
 100%  14573 (længste forespørgsel)
root@test2:/#

Tokens udstedes. Og vi gemmer konstant data. 99% af forespørgslerne blev håndteret inden for 42 millisekunder. Dermed har vi omkring 3500 forespørgsler i sekundet på en lille maskine med 2 kerner og 4 gigabyte ram.

Man kan også vælge en hvilken som helst 50000-token og se dens værdi.

Du kan bruge ikke kun http, men også køre baggrundsfunktioner, der behandler dine data. Plus der er forskellige triggers. For eksempel kan du kalde funktioner på opdateringer, kontrollere noget – løse konflikter.

Du kan skrive applikationsscripts direkte på databaseserveren uden begrænsninger, tilslutte enhver module og implementere enhver logik.

Applikationsserveren kan kommunikere med eksterne servere, hente data og gemme dem i sin egen database. Data fra denne database vil blive brugt af andre applikationer.

Dette vil blive gjort af Tarantool, og du behøver ikke at skrive en separat applikation.

Afslutningsvis

Dette er kun den første del af et stort arbejde. Den anden del vil blive offentliggjort meget snart på Mail.ru Groups blog, og vi vil helt sikkert tilføje et link til det i dette materiale.

Hvis du er interesseret i at deltage i arrangementer, hvor vi laver sådanne ting online, og stille spørgsmål i realtid, så tilslut dig kanalen DevOps by REBRAIN.

Hvis du har brug for at migrere til skyen eller har spørgsmål til din infrastruktur, så send endelig en ansøgning.

P.S. Vi har 2 gratis audits om måneden, måske er det netop dit projekt, der vil være blandt dem.

Kilde: habr.com