Aus Neugier habe ich mich entschlossen, darauf zurückzukommen und die neueste Version zu testen - und dieses Mal hat mir das Projekt wirklich gut gefallen. Jetzt werde ich Ihnen zeigen, wie Sie eine einfache Anwendung in Tarantool schreiben, laden und die Leistung testen, und Sie werden sehen, wie einfach und cool alles ist.
Was ist Tarantool?
Tarantool positioniert sich als superschnelle Datenbank. Sie können dort beliebige Daten pushen. Replizieren Sie sie außerdem, shard - das heißt, teilen Sie eine große Datenmenge auf mehrere Server auf und kombinieren Sie die Ergebnisse daraus -, um fehlertolerante "Master-Master" -Verbindungen herzustellen.
Zweitens ist es ein Anwendungsserver. Sie können Ihre Anwendungen darauf schreiben, mit Daten arbeiten, beispielsweise alte Datensätze im Hintergrund nach bestimmten Regeln löschen. Sie können einen HTTP-Server direkt in Tarantula schreiben, der mit Daten arbeitet: Geben Sie deren Menge aus, schreiben Sie dort neue Daten und reduzieren Sie alles auf den Master.
Ich habe einen Artikel darüber gelesen, wie die Jungs eine 300-Zeilen-Nachrichtenwarteschlange erstellt haben, die nur reißt und fliegt - sie haben eine Mindestleistung von 20.000 Nachrichten pro Sekunde. Hier können Sie eine sehr große Anwendung wirklich erweitern und schreiben, und sie wird nicht wie in PostgreS gespeichert.
Über einen solchen Server, ganz einfach, werde ich versuchen, in diesem Artikel zu beschreiben.
Installation
Für den Test habe ich drei virtuelle Standardmaschinen gestartet - eine 20-Gigabyte-Festplatte, Ubuntu 18.04. 2 virtuelle CPU und 4 Gigabyte Speicher.
Wir installieren Tarantool - führen Sie das Bash-Skript aus oder fügen Sie ein Repository hinzu und installieren Sie Tarantool. Der Link zum Skript lautet (curl -L https://tarantool.io/installer.sh | VER = 2.4 sudo -E bash). Wir haben solche Befehle wie:
tarantoolctl - der Hauptbefehl zum Verwalten von Tarantula-Instanzen.
/ etc / tarantool - die gesamte Konfiguration liegt hier.
var / log / tarantool - Protokolle werden hier gespeichert .
var / lib / tarantool - Hier werden die Daten gespeichert und dann in Instanzen aufgeteilt.
Es gibt Ordner, die instanzverfügbar und instanzaktiviert sind - sie enthalten, was gestartet werden soll - eine Instanzkonfigurationsdatei mit Lua-Code, die beschreibt, an welchen Ports sie überwacht, welcher Speicher für sie verfügbar ist, Vinyl-Engine-Einstellungen, Code, der beim Start ausgelöst wird Server, Sharding, Warteschlangen, Löschen veralteter Daten usw.
Instanzen funktionieren wie PostgreS. Sie möchten beispielsweise mehrere Kopien einer Datenbank ausführen, die an verschiedenen Ports hängt. Es stellt sich heraus, dass mehrere Datenbankinstanzen auf demselben Server gestartet werden, die an verschiedenen Ports hängen. Sie können völlig unterschiedliche Einstellungen haben - eine Instanz implementiert eine Logik, die zweite - eine andere.
Instanzverwaltung
Wir haben den Befehl tarantoolctl, mit dem Sie Ihre Tarantula-Instanzen verwalten können. Das Beispiel tarantoolctl check überprüft beispielsweise die Konfigurationsdatei und sagt: - Die Datei ist in Ordnung, wenn keine Syntaxfehler vorliegen.
Sie können den Status der Instanz sehen - Beispiel für den Status tarantoolctl. Auf die gleiche Weise können Sie starten, stoppen und neu starten.
Wenn die Instanz ausgeführt wird, gibt es zwei Möglichkeiten, eine Verbindung herzustellen.
1. Administrationskonsole
Standardmäßig öffnet Tarantool einen Socket, in dem einfacher ASCII-Text zur Steuerung der Tarantel übertragen wird. Die Verbindung zur Konsole wird immer unter dem Administrator hergestellt. Es erfolgt keine Authentifizierung, sodass Sie den Konsolenport nicht verschieben müssen, um die Tarantel zu verwalten.
Um auf diese Weise eine Verbindung herzustellen, geben Sie Tarantoolctl ein. Geben Sie den Instanznamen ein. Der Befehl startet die Konsole und stellt eine Verbindung als Administrator her. Legen Sie den Konsolenanschluss niemals nach außen frei - lassen Sie ihn am besten als Gerätebuchse. Dann können nur diejenigen, die Schreibzugriff auf den Socket haben, eine Verbindung zur Tarantel herstellen.
Diese Methode wird für administrative Zwecke benötigt. Verwenden Sie zum Arbeiten mit Daten die zweite Methode - das Binärprotokoll.
2. Verwenden eines Binärprotokolls zum Herstellen einer Verbindung zu einem bestimmten Port
In der Konfiguration befindet sich eine Listen-Direktive, die den Port für die externe Kommunikation öffnet. Dieser Port wird mit einem Binärprotokoll verwendet und dort ist die Authentifizierung aktiviert.
Für diese Verbindung wird tarantoolctl connect to port number verwendet. Mit ihm können Sie eine Verbindung zu Remoteservern herstellen, die Authentifizierung verwenden und verschiedene Zugriffsrechte erteilen.
Datenlogger und Box-Modul
Da Tarantool sowohl eine Datenbank als auch ein Anwendungsserver ist, verfügt es über verschiedene Module. Wir interessieren uns für das Box-Modul - es implementiert die Arbeit mit Daten. Wenn Sie etwas in die Box schreiben, schreibt Tarantool die Daten auf die Festplatte, speichert sie im Speicher oder macht etwas anderes damit.
Aufzeichnung
Zum Beispiel gehen wir in das Box-Modul und rufen die Funktion box.once auf. Dadurch wird Tarantool unseren Code ausführen, wenn der Server initialisiert wird. Wir schaffen einen Raum, in dem unsere Daten gespeichert werden.
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')
endDanach erstellen wir einen Primärindex - Primärindex -, anhand dessen wir nach Daten suchen können. Wenn Sie keine Parameter angeben, wird standardmäßig das erste Feld in jedem Eintrag für den Primer-Index verwendet.
Dann gewähren wir dem Gastbenutzer einen Zuschuss, unter dem wir uns über ein Binärprotokoll verbinden. Ermöglichen des Lesens, Schreibens und Ausführens in der gesamten Instanz.
Im Vergleich zu herkömmlichen Datenbanken ist hier alles ganz einfach. Wir haben einen Raum - einen Bereich, in dem einfach unsere Daten gespeichert werden. Jeder Eintrag wird als Tupel bezeichnet. Es ist in einem MessagePack verpackt. Dies ist ein sehr cooles Format - es ist binär und nimmt weniger Platz ein - 18 Bytes gegenüber 27.
Es ist sehr praktisch, damit zu arbeiten. Fast jede Zeile, jeder Datensatz kann völlig unterschiedliche Spalten haben.
Mit dem Befehl Box.space können wir alle Leerzeichen anzeigen. Um eine bestimmte Instanz auszuwählen, schreiben Sie ein Beispiel für box.space und erhalten Sie vollständige Informationen dazu.
Tarantool verfügt über zwei integrierte Motoren: Memory und Vinyl. Der Speicher speichert alle Daten im Speicher. Daher funktioniert alles einfach und schnell. Die Daten werden auf die Festplatte geschrieben, und es gibt auch einen Write-Ahead-Protokollmechanismus, sodass wir nichts verlieren, wenn der Server abstürzt.
Vinyl speichert Daten auf der Festplatte in einer vertrauten Form - das heißt, Sie können mehr Daten speichern, als wir über Speicher verfügen, und die Tarantula liest sie von der Festplatte.
Wir werden jetzt Speicher verwenden.
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>Index:
Der Primärindex sollte für jeden Speicherplatz erstellt werden, da ohne ihn nichts funktioniert. Wie bei jeder Datenbank erstellen wir das erste Feld - die Datensatz-ID.
Teile:
Hier geben wir an, woraus unser Index besteht. Es besteht aus einem Teil - das erste Feld, das wir verwenden, ist ohne Vorzeichen, eine positive Ganzzahl. Wie ich mich aus der Dokumentation erinnere, können maximal 18 Billionen sein. Super viel.
Dann können wir Daten mit dem Befehl insert einfügen.
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>Das erste Feld wird als Primärschlüssel verwendet und muss daher eindeutig sein. Wir sind nicht auf die Anzahl der Spalten beschränkt, sodass wir so viele Daten einfügen können, wie wir möchten. Sie sind im oben beschriebenen MessagePack-Format angegeben.
Datenausgabe
Dann können wir Daten mit dem Befehl select anzeigen.
Box.example.select mit der Taste {1} zeigt den gewünschten Datensatz an. Wenn wir den Schlüssel weglassen, sehen wir alle Datensätze, die wir haben. Sie unterscheiden sich alle in der Anzahl der Spalten, aber hier gibt es im Prinzip kein Konzept für Spalten - es gibt Feldnummern.
Es kann absolut viele Daten geben. Und zum Beispiel müssen wir sie im zweiten Feld suchen. Dazu erstellen wir einen neuen Sekundärindex.
box.space.example:create_index( ‘secondary’, { type = ‘TREE’, unique = false, parts = {{field = 2, type =’string’} }}) Wir verwenden den Befehl Create_index.
Wir nennen es sekundär.
Danach müssen Sie die Parameter angeben. Der Indextyp ist TREE. Es ist möglicherweise nicht eindeutig, daher geben wir Unique = false ein.
Dann geben wir an, aus welchen Teilen unser Index besteht. Feld ist die Nummer des Feldes, an das wir den Index binden und die Typzeichenfolge angeben. Und so wurde es geschaffen.
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>So können wir es nennen:
unix/:/var/run/tarantool/example.control> box.space.example.index.secondary:select('test1')
---
- - [1, 'test1', 'test2']
...
Erhaltung
Wenn wir die Instanz neu starten und versuchen, die Daten erneut aufzurufen, werden wir feststellen, dass sie nicht vorhanden sind - alles ist leer. Dies geschieht, weil Tarantool Prüfpunkte erstellt und die Daten auf der Festplatte speichert. Wenn wir jedoch vor dem nächsten Speichern aufhören zu arbeiten, verlieren wir alle Vorgänge - weil wir uns vom letzten Prüfpunkt erholen, der beispielsweise vor zwei Stunden war.
Das Speichern jeder Sekunde funktioniert auch nicht - denn das ständige Speichern von 20 GB auf die Festplatte ist mittelmäßig.
Hierzu wurde das Write-Ahead-Log-Konzept erfunden und umgesetzt. Für jede Datenänderung wird ein Eintrag in einer kleinen Write-Ahead-Protokolldatei erstellt.
Jeder Eintrag vor dem Prüfpunkt wird darin gespeichert. Für diese Dateien legen wir die Größe fest - zum Beispiel 64 MB. Wenn es voll ist, beginnt die Aufnahme mit der zweiten Datei. Nach dem Neustart wird Tarantool vom letzten Prüfpunkt wiederhergestellt und setzt dann alle späteren Transaktionen fort, bis sie gestoppt werden.
Um eine solche Aufnahme zu machen, müssen Sie die Option in den Einstellungen von box.cfg (in der Datei example.lua) angeben:
wal_mode = “write”;Datenverbrauch
Mit dem, was wir jetzt geschrieben haben, können Sie die Tarantel zum Speichern von Daten verwenden, und sie funktioniert sehr schnell als Datenbank. Und jetzt die Kirsche oben auf dem Kuchen - was kann man mit allem machen?
Eine Bewerbung schreiben
Schreiben wir zum Beispiel eine solche Anwendung für Tarantula
Siehe die Anwendung unter dem 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()Wir deklarieren in lua ein Etikett, das Symbole definiert. Diese Platte wird benötigt, um eine zufällige Linie zu erzeugen.
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
endDanach deklarieren wir eine Funktion - randomString und geben den Längenwert in Klammern an.
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)]
endDann verbinden wir den http-Router und den http-Server mit unserem Tarantula-Server JSON, den wir an den Client senden.
local http_router = require('http.router')
local http_server = require('http.server')
local json = require('json')Danach starten wir an Port 8080 auf allen Schnittstellen des http-Servers, der alle Anforderungen und Fehler protokolliert.
local httpd = http_server.new('0.0.0.0', 8080, {
log_requests = true,
log_errors = true
})Als nächstes deklarieren wir route, dass wir die Funktion von einer Zeile aus aufrufen, wenn eine Anforderung mit der GET-Methode an Port 8080 / count eingeht. Es gibt den Status zurück - 200, 404, 403 oder was auch immer wir angeben.
router:route({method = 'GET', path = '/count'}, function()
return {status = 200, body = json.encode({count = get_count()})}
end)Im Body geben wir json.encode zurück, darin geben wir count und getcount an, die aufgerufen werden und die Anzahl der Datensätze in unserer Datenbank anzeigen.
Methode zwei
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)Wo im Zeilenrouter: route ({method = ' GET', path = '/ token'}, function () , rufen wir die Funktion auf und generieren ein Token.
Bar local token = randomString (32) - ist eine Randomnaya-Zeichenfolge mit 32 Zeichen.
Zeile local last = box.space.example: len () Wir ziehen das letzte Element heraus
und in der Zeile box.space.example: insert {last + 1, token} schreiben wir in unsere Datenbank, dh wir erhöhen nur die ID um 1. Dies kann durchgeführt werden Übrigens nicht nur so ungeschickt. In Tarantula gibt es Sequenzen für diesen Fall. Wir
schreiben dort ein Token.
Also haben wir eine Anwendung in eine Datei geschrieben. Darin können Sie die Daten sofort verarbeiten, und das Box-Modul erledigt die ganze Drecksarbeit für Sie ...
Es hört auf http und arbeitet mit Daten, alles ist in einer einzigen Instanz - sowohl die Anwendung als auch die Daten. Daher geht alles schnell genug.
Zum Ausführen installieren wir das http-Modul:
Wie wir das machen, schau unter den 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:/#Wir brauchen auch Prometheus, um zu 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:/#
Wir starten und können auf die Module zugreifen
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 gibt uns den Status 200.
/ token gibt ein Token aus und schreibt dieses Token in die Datenbank.
Testgeschwindigkeit
Lassen Sie uns einen Benchmark mit 50.000 Abfragen durchführen. Es wird 500 Wettbewerbsanfragen geben.
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:/#Token werden ausgegeben. Und wir zeichnen ständig Daten auf. 99% der Anfragen wurden in 42 Millisekunden erledigt. Dementsprechend haben wir ungefähr 3500 Anfragen pro Sekunde auf einem kleinen Computer, auf dem 2 Kerne und 4 Gigabyte Speicher vorhanden sind.
Sie können auch etwa 50.000 Token auswählen und deren Wert anzeigen.
Sie können nicht nur http verwenden, sondern auch Hintergrundfunktionen ausführen, die Ihre Daten verarbeiten. Außerdem gibt es verschiedene Auslöser. Sie können beispielsweise Funktionen für Updates aufrufen, etwas überprüfen und Konflikte beheben.
Sie können Anwendungsskripte direkt auf dem Datenbankserver selbst schreiben, ohne auf irgendetwas beschränkt zu sein, Module verbinden und Logik implementieren.
Der Anwendungsserver kann auf externe Server zugreifen, Daten sammeln und in seiner Datenbank speichern. Daten aus dieser Datenbank werden von anderen Anwendungen verwendet.
Dies wird von Tarantula selbst durchgeführt, und Sie müssen keine separate Anwendung schreiben.
Abschließend
Dies ist nur der erste Teil vieler Arbeiten. Der zweite wird sehr bald auf dem Blog der Mail.ru-Gruppe veröffentlicht, und wir werden in diesem Artikel definitiv einen Link dazu hinzufügen.
Wenn Sie an Veranstaltungen teilnehmen möchten , bei denen wir solche Dinge online erstellen und Fragen in Echtzeit stellen, treten Sie dem DevOps by REBRAIN-Kanal bei .
Wenn Sie einen Wechsel in die Cloud benötigen oder Fragen zu Ihrer Infrastruktur haben, können Sie gerne eine Anfrage hinterlassen .
PS Wir haben 2 kostenlose Audits pro Monat, vielleicht gehört Ihr Projekt dazu.