Vijf jaar geleden probeerde ik met Tarantool te werken, maar toen werkte het niet voor mij. Maar onlangs hield ik een webinar waarin ik sprak over Hadoop en hoe MapReduce werkt. Daar stelden ze me een vraag: "Waarom zou je Tarantool niet voor deze taak gebruiken?"
Uit nieuwsgierigheid besloot ik ernaar terug te keren en de nieuwste versie te testen - en deze keer vond ik het project erg leuk. Nu zal ik je laten zien hoe je een eenvoudige applicatie in Tarantool schrijft, deze laadt en de prestaties ervan controleert, en je zult zien hoe gemakkelijk en cool alles is.
Wat is Tarantool
Tarantool positioneert zichzelf als een ultrasnelle database. Je kunt daar alle gewenste gegevens plaatsen. Plus, repliceer ze, shard (dat wil zeggen, verdeel een enorme hoeveelheid gegevens over verschillende servers en combineer de resultaten ervan) en maak fouttolerante master-master-verbindingen.
Ten tweede is dit een applicatieserver. U kunt er uw applicaties op schrijven, met gegevens werken, bijvoorbeeld oude records op de achtergrond verwijderen volgens bepaalde regels. Je kunt rechtstreeks in Tarantula een Http-server schrijven die met gegevens werkt: geef hun hoeveelheid door, schrijf daar nieuwe gegevens en breng alles terug naar de master.
Ik heb een artikel gelezen over hoe de jongens een berichtenwachtrij van 300 regels hebben gemaakt, die simpelweg barst en haastt - ze hebben een minimale prestatie van 20 berichten per seconde. Hier kun je echt omdraaien en een hele grote applicatie schrijven, en het zal geen opslag zijn, zoals in PostgreS.
Ik zal in dit artikel proberen zoiets als deze server, alleen simpel, te beschrijven.
installatie
Voor de test startte ik drie standaard virtuele machines: een harde schijf van 20 GB, Ubuntu 18.04. 2 virtuele CPU's en 4 gigabyte geheugen.
We installeren Tarantool - voer het bash-script uit of voeg een repository toe en installeer Tarantool. Link naar script - (krul -L | VER=2.4 sudo -E bash). We hebben commando's zoals:
tarantoolctl — het hoofdcommando voor het beheren van Tarantula-instanties.
/etc/tarantool - hier is de volledige configuratie.
var/log/tarantool - hier zijn de logboeken.
var/lib/tarantool — de gegevens liggen hier en worden vervolgens in instanties verdeeld.
Er zijn mappen instance-available en instance-enable - het bevat wat er zal worden gestart - een instance-configuratiebestand met lua-code, die beschrijft op welke poorten het luistert, welk geheugen ervoor beschikbaar is, Vinyl engine-instellingen, code die wordt uitgevoerd bij het opstarten servers, sharding, wachtrijen, verwijdering van verouderde gegevens, enzovoort.
Instanties werken zoals in PostgreS. U wilt bijvoorbeeld meerdere exemplaren uitvoeren van een database die op verschillende poorten vastloopt. Het blijkt dat er meerdere database-instances op één server worden gelanceerd, die op verschillende poorten blijven hangen. Ze kunnen totaal verschillende instellingen hebben: de ene instantie implementeert de ene logica, de tweede een andere.
Instantiebeheer
We hebben de opdracht tarantoolctl, waarmee u Tarantula-instanties kunt beheren. Het voorbeeld van tarantoolctl check controleert bijvoorbeeld het configuratiebestand en zegt: het bestand is in orde als er geen syntaxisfouten zijn.
U kunt de status van de instantie zien: tarantoolctl-statusvoorbeeld. Op dezelfde manier kunt u starten, stoppen en opnieuw opstarten.
Zodra de instantie actief is, kunt u er op twee manieren verbinding mee maken.
1. Beheerconsole
Standaard opent Tarantool een socket, normale ASCII-tekst wordt daarheen gestuurd om Tarantool te besturen. Verbinding met de console vindt altijd plaats onder de admin-gebruiker. Er is geen authenticatie, dus het is niet nodig om de consolepoort te externaliseren om Tarantula te beheren.
Om via deze methode verbinding te maken, moet u Tarantoolctl invoeren en de exemplaarnaam invoeren. Met de opdracht wordt de console gestart en wordt verbinding gemaakt als beheerder. Stel de consolepoort nooit bloot aan de buitenkant; het is beter om deze als unit-aansluiting te laten. Dan kunnen alleen degenen die toegang hebben om naar de socket te schrijven, verbinding maken met Tarantula.
Deze methode is nodig voor administratieve zaken. Gebruik de tweede methode om met gegevens te werken: het binaire protocol.
2. Een binair protocol gebruiken om verbinding te maken met een specifieke poort
De configuratie bevat een luisterinstructie, die een poort opent voor externe communicatie. Deze poort wordt gebruikt met het binaire protocol en authenticatie is daar ingeschakeld.
Voor deze verbinding wordt tarantoolctl connect to port number gebruikt. Hiermee kunt u verbinding maken met externe servers, authenticatie gebruiken en verschillende toegangsrechten geven.
Gegevensregistratie en boxmodule
Omdat Tarantool zowel een database als een applicatieserver is, beschikt het over verschillende modules. We zijn geïnteresseerd in de boxmodule - deze implementeert het werken met data. Wanneer u iets naar Box schrijft, schrijft Tarantool de gegevens naar schijf, slaat deze in het geheugen op of doet er iets anders mee.
Record
We gaan bijvoorbeeld naar de box-module en roepen de box.once-functie aan. Hierdoor wordt Tarantool gedwongen onze code uit te voeren wanneer de server wordt geïnitialiseerd. We creëren een ruimte waarin onze gegevens worden opgeslagen.
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')
endHierna creëren we een primaire index – primair – waarmee we naar gegevens kunnen zoeken. Als u geen parameters opgeeft, wordt standaard het eerste veld in elke record gebruikt voor de primaire index.
Vervolgens geven we een subsidie aan de gastgebruiker, waarbij we verbinding maken via het binaire protocol. We staan lezen, schrijven en uitvoeren over de hele instantie toe.
Vergeleken met conventionele databases is alles hier vrij eenvoudig. We hebben ruimte - een ruimte waarin onze gegevens eenvoudigweg worden opgeslagen. Elk record wordt een tupel genoemd. Het is verpakt in MessagePack. Dit is een heel cool formaat - het is binair en neemt minder ruimte in beslag - 18 bytes versus 27.
Het is best handig om met hem samen te werken. Bijna elke regel, elk gegevensrecord kan totaal verschillende kolommen hebben.
We kunnen alle spaties bekijken met behulp van de opdracht Box.space. Om een specifiek exemplaar te selecteren, schrijft u box.space example en krijgt u er volledige informatie over.
Tarantool heeft twee ingebouwde motoren: Memory en Vinyl. Geheugen slaat alle gegevens in het geheugen op. Daarom werkt alles eenvoudig en snel. De gegevens worden op schijf gedumpt en er is ook een logmechanisme dat vooruit schrijft, zodat we niets verliezen als de server crasht.
Vinyl slaat gegevens op schijf op in een vorm die ons meer bekend is - dat wil zeggen dat u meer gegevens kunt opslaan dan we geheugen hebben, en Tarantula zal deze van schijf lezen.
Voorlopig zullen we Geheugen gebruiken.
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>Inhoudsopgave:
Voor elke ruimte moet een primaire index worden gemaakt, want zonder deze index zal niets werken. Zoals in elke database creëren we het eerste veld: record-ID.
Onderdelen:
Hier geven we aan waaruit onze index bestaat. Het bestaat uit één deel - het eerste veld dat we zullen gebruiken is van het type unsigned - een positief geheel getal. Voor zover ik me uit de documentatie herinner, is het maximale aantal dat kan zijn 18 biljoen. Dat is een hoop.
Vervolgens kunnen we gegevens invoegen met behulp van de opdracht invoegen.
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>Het eerste veld wordt gebruikt als primaire sleutel en moet dus uniek zijn. We zijn niet beperkt door het aantal kolommen, dus we kunnen daar zoveel gegevens invoegen als we willen. Ze zijn gespecificeerd in het MessagePack-formaat, dat ik hierboven heb beschreven.
Gegevensuitvoer
Vervolgens kunnen we de gegevens weergeven met behulp van de select-opdracht.
Box.example.select met de toets {1} geeft het gewenste item weer. Als we de sleutel verlagen, zien we alle records die we hebben. Ze verschillen allemaal in het aantal kolommen, maar hier is er in principe geen concept van kolommen - er zijn veldnummers.
Er kan absoluut elke hoeveelheid gegevens zijn. En we moeten ze bijvoorbeeld zoeken via het tweede veld. Om dit te doen, maken we een nieuwe secundaire index.
box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }})
We gebruiken de opdracht Create_index.
Laten we het secundair noemen.
Hierna moet u de parameters opgeven. Indextype is BOOM. Het is mogelijk niet uniek, dus voer Unique = false in.
Vervolgens geven wij aan uit welke onderdelen onze index bestaat. Veld is het nummer van het veld waaraan we de index binden en specificeert het tekenreekstype. En zo ontstond het.
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>Dit is hoe we het kunnen noemen:
unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...
behoud
Als we de instantie opnieuw opstarten en de gegevens opnieuw proberen op te roepen, zullen we zien dat deze er niet zijn: alles is leeg. Dit gebeurt omdat Tarantool controlepunten maakt en de gegevens op schijf opslaat, maar als we stoppen met werken tot de volgende opslag, verliezen we alle bewerkingen - omdat we zullen herstellen van het laatste controlepunt, dat bijvoorbeeld twee uur geleden was.
Het zal ook niet werken om elke seconde op te slaan, omdat het voortdurend dumpen van 20 GB op schijf geen goed idee is.
Voor dit doel werd het concept van write-ahead log bedacht en geïmplementeerd. Met zijn hulp wordt voor elke wijziging in de gegevens een vermelding gemaakt in een klein vooruitschrijflogbestand.
Elke invoer tot aan het controlepunt wordt erin opgeslagen. Voor deze bestanden stellen we de grootte in, bijvoorbeeld 64 MB. Als het vol is, begint de opname naar het tweede bestand. En na de herstart wordt Tarantool hersteld vanaf het laatste controlepunt en rolt vervolgens alle latere transacties door totdat het stopt.
Om een dergelijke opname uit te voeren, moet u de optie opgeven in de box.cfg-instellingen (in het voorbeeld.lua-bestand):
wal_mode = “write”;data gebruik
Met wat we nu hebben geschreven, kun je Tarantula gebruiken om gegevens op te slaan en het zal heel snel werken als database. En nu is de kers op de taart wat je er allemaal mee kunt doen.
Een aanvraag schrijven
Laten we bijvoorbeeld de volgende toepassing voor Tarantula schrijven
Zie de applicatie onder de 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()We declareren een tabel in lua die de karakters definieert. Deze plaat is nodig om een willekeurige string te genereren.
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
endDaarna declareren we de functie - randomString en geven we de lengtewaarde tussen haakjes.
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)]
endVervolgens verbinden we de http-router en http-server met onze Tarantula-server, JSON, die we naar de client sturen.
local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')Hierna beginnen we op poort 8080 op alle http-serverinterfaces, die alle verzoeken en fouten zullen loggen.
local httpd = http_server.new('0.0.0.0', 8080, {
log_requests = true,
log_errors = true
})Vervolgens declareren we route, zodat als een verzoek met de GET-methode binnenkomt op poort 8080 /count, we de functie vanaf één regel aanroepen. Het retourneert de status: 200, 404, 403 of een andere die we specificeren.
router:route({method = 'GET', path = '/count'}, function()
return {status = 200, body = json.encode({count = get_count()})}
end)In de body retourneren we json.encode, daarin geven we count en getcount aan, die wordt aangeroepen en het aantal records in onze database toont.
De tweede methode
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 de rij router:route({methode = 'GET', pad = '/token'}, functie() we roepen de functie aan en genereren een token.
rij lokaal token = randomString(32) is een willekeurige reeks van 32 tekens.
In lijn lokale laatste = box.space.example:len() we halen het laatste element eruit.
En in de rij box.space.example:insert{ laatste + 1, token } we schrijven de gegevens in onze database, dat wil zeggen, we verhogen eenvoudigweg de ID met 1. Dit kan overigens niet alleen op deze onhandige manier worden gedaan. Er zijn hiervoor sequenties in Tarantula.
We schrijven het token daar.
Daarom hebben we de applicatie in één bestand geschreven. U kunt de gegevens daar direct manipuleren en de boxmodule doet al het vuile werk voor u.
Het luistert naar http en werkt met data, alles bevindt zich in één exemplaar: zowel de applicatie als de data. Daarom gebeurt alles vrij snel.
Om te beginnen installeren we de http-module:
Hoe wij dit doen, kijk onder de spoiler
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:/#We hebben ook prometheus nodig om te rennen:
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:/#
We starten en hebben toegang tot de 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 geeft ons de status 200.
/token geeft een token uit en schrijft dit token naar de database.
Het testen van de snelheid
Laten we een benchmark uitvoeren voor 50 verzoeken. Er zullen 000 concurrerende aanvragen zijn.
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 worden uitgegeven. En we registreren voortdurend gegevens. 99% van de verzoeken werd binnen 42 milliseconden verwerkt. Dienovereenkomstig hebben we ongeveer 3500 verzoeken per seconde op een kleine machine met 2 cores en 4 gigabyte geheugen.
U kunt ook ongeveer 50000 tokens selecteren en de waarde ervan bekijken.
U kunt niet alleen http gebruiken, maar ook achtergrondfuncties uitvoeren die uw gegevens verwerken. Bovendien zijn er verschillende triggers. U kunt bijvoorbeeld functies voor updates oproepen, iets controleren - conflicten corrigeren.
U kunt scripttoepassingen rechtstreeks in de databaseserver zelf schrijven, zonder ergens door beperkt te worden, alle modules aansluiten en elke logica implementeren.
De applicatieserver heeft toegang tot externe servers, haalt gegevens op en voegt deze toe aan de database. Gegevens uit deze database zullen door andere applicaties worden gebruikt.
Tarantula doet dit zelf en u hoeft geen aparte aanvraag te schrijven.
Concluderend
Dit is slechts het eerste deel van een groot werk. De tweede zal zeer binnenkort op de blog van Mail.ru Group worden gepubliceerd en we zullen er zeker een link naar toevoegen in dit materiaal.
Als je geïnteresseerd bent in het bijwonen van evenementen waar we deze dingen online bouwen en in realtime vragen stellen, stem dan af.
Als u naar de cloud moet verhuizen of vragen heeft over uw infrastructuur, .
PS We hebben 2 gratis audits per maand, wellicht is jouw project daar één van.
Bron: www.habr.com