🥇Avec Tarantool, vous pouvez combiner une base de données super rapide et une application pour les gérer. Voici comment c'est facile à faire

Il y a cinq ans, j'ai essayé de travailler avec Tarantool, mais cela ne m'a pas convaincu à l'époque. Récemment, j'ai animé un webinaire où j'ai parlé de Hadoop et du fonctionnement de MapReduce. On m'a alors posé la question : « Pourquoi ne pas utiliser Tarantool pour cette tâche ? »

Par curiosité, j'ai décidé de revenir à Tarantool, de tester la dernière version — et cette fois, le projet m'a beaucoup plu. Je vais maintenant vous montrer comment écrire une application simple dans Tarantool, la solliciter et vérifier ses performances, et vous verrez à quel point tout est facile et impressionnant.

Qu'est-ce que Tarantool

Tarantool se positionne comme une base de données ultra-rapide. Vous pouvez y insérer n'importe quelles données que vous souhaitez. De plus, vous pouvez les répliquer, les shardiser — c'est-à-dire répartir une grande quantité de données sur plusieurs serveurs et combiner les résultats — créer des configurations résilientes comme des « maître-maître ».

En second lieu, c'est un serveur d'applications. Vous pouvez y écrire vos propres applications, travailler avec les données, par exemple, supprimer en arrière-plan les anciens enregistrements selon certaines règles. Il est possible de créer directement dans Tarantool un serveur Http qui traitera les données : fournir leur quantité, y enregistrer de nouvelles données et réduire tout cela sur le maître.

J'ai lu un article sur la façon dont des développeurs ont mis en place une file de messages en 300 lignes, qui fonctionne à merveille — leur performance minimale est de 20 000 messages par seconde. Vous pouvez réellement vous déployer et écrire une très grande application, contrairement aux solutions utilisées dans PostgreSQL.

Je vais essayer de décrire un serveur de ce type, mais de manière simple, dans cet article.

Installation

Pour le test, j'ai créé trois machines virtuelles standard — un disque dur de 20 Go, Ubuntu 18.04, 2 CPU virtuels et 4 Go de mémoire.

Nous installons Tarantool — soit nous lançons un script bash, soit nous ajoutons le dépôt et faisons un apt get install Tarantool. Lien vers le script — (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Nous avons des commandes comme :

tarantoolctl — la commande principale pour gérer les instances de Tarantool.
/etc/tarantool — ici se trouve toute la configuration.
var/log/tarantool — ici se trouvent les journaux.
var/lib/tarantool — ici se trouvent les données, qui sont ensuite réparties par instances.

Il existe des dossiers instance-available et instance-enable : le premier contient ce qui va être exécuté : un fichier de configuration de l'instance avec du code Lua, où sont décrits les ports sur lesquels il écoute, la mémoire qui lui est allouée, les paramètres du moteur Vinyl, le code qui s'active au démarrage du serveur, le sharding, les files d'attente, la suppression des données obsolètes, etc.

Les instances fonctionnent comme dans PostgreS. Par exemple, vous souhaitez lancer plusieurs copies d'une base de données, qui se trouvent sur différents ports. Cela signifie que plusieurs instances de base de données sont lancées sur un même serveur, chacune sur des ports différents. Elles peuvent avoir des configurations entièrement différentes : une instance réalise une logique, l'autre en réalise une différente.

Gestion des instances

Nous avons la commande tarantoolctl, qui permet de gérer les instances de Tarantool. Par exemple, tarantoolctl check example vérifiera le fichier de configuration et indiquera — fichier is ok, s'il n'y a pas d'erreurs de syntaxe.

Vous pouvez voir le statut de l'instance avec tarantoolctl status example. De la même manière, vous pouvez faire start, stop, restart.

Lorsque l'instance est lancée, il existe deux manières de s'y connecter.

1. Console administrative

Par défaut, Tarantool ouvre un socket, cela transmet du texte ASCII standard pour gérer Tarantool. La connexion à la console se fait toujours sous l'utilisateur admin, il n'y a pas d'authentification, donc il n'est pas nécessaire d'exposer le port de la console pour gérer Tarantool à l'extérieur.

Pour se connecter de cette manière, vous devez entrer Tarantoolctl enter instance name. La commande lancera la console et se connectera en tant qu'utilisateur admin. Ne jamais exposer le port de la console à l'extérieur — il vaut mieux le laisser en socket unit. Ainsi, seule les personnes ayant accès en écriture au socket pourront se connecter à Tarantool.

Cette méthode est nécessaire pour les opérations administratives. Pour travailler avec les données, utilisez la seconde méthode — le protocole binaire.

2. Utilisation du protocole binaire pour se connecter à un port spécifique

Dans la configuration, il existe une directive listen qui ouvre un port pour les communications externes. Ce port est utilisé avec le protocole binaire, et l'authentification y est activée.

Pour cette connexion, on utilise tarantoolctl connect to port number. En l'utilisant, on peut se connecter à des serveurs distants, utiliser l'authentification et accorder divers droits d'accès.

Enregistrement des données et module Box

Puisque Tarantool est à la fois une base de données et un serveur d'applications, il possède différents modules. Nous nous intéressons au module box — il implémente le travail avec les données. Lorsque vous écrivez quelque chose dans box, Tarantool enregistre les données sur le disque, les conserve en mémoire ou effectue d'autres opérations avec elles.

Écriture

Par exemple, nous allons dans le module box et appelons la fonction box.once. Cela va forcer Tarantool à exécuter notre code lors de l'initialisation du serveur. Nous créons un espace où nos données seront stockées.

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

    -- Garder les choses sécurisées par défaut
    --  box.schema.user.create('example', { password = 'secret' })
    --  box.schema.user.grant('example', 'replication')
    --  box.schema.user.grant('example', 'read,write,execute', 'space', 'example')
end

Après cela, nous créons un index primaire — primary — qui pourra être utilisé pour rechercher des données. Par défaut, si aucun paramètre n'est spécifié, le premier champ de chaque enregistrement sera utilisé pour l'index primaire.

Nous faisons ensuite un grant à l'utilisateur guest, par lequel nous nous connectons via le protocole binaire. Nous autorisons la lecture, l'écriture et l'exécution dans toute l'instance.

Comparé aux bases de données ordinaires, ici c'est assez simple. Nous avons un space – un domaine où nos données sont simplement stockées. Chaque enregistrement est appelé un tuple. Il est empaqueté en MessagePack. C'est un format très intéressant — il est binaire et occupe moins d'espace – 18 octets contre 27.

Il est assez pratique à manipuler. Presque chaque ligne, chaque enregistrement de données peut avoir des colonnes totalement différentes.

Nous pouvons voir tous les espaces avec la commande Box.space. Pour sélectionner une instance spécifique – nous écrivons box.space example et obtenons des informations complètes à son sujet.

Tarantool intègre deux types de moteurs : Memory et Vinyl. Memory stocke toutes les données en mémoire. C'est pourquoi tout fonctionne simplement et rapidement. Les données sont sauvegardées sur disque, et il existe également un mécanisme de journalisation anticipée, donc nous ne perdrons rien en cas de panne du serveur.

Vinyl stocke les données sur le disque de manière plus familière — cela signifie que l'on peut stocker plus de données que ce que nous avons en mémoire, et Tarantool les lira depuis le disque.

Nous allons maintenant utiliser 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>

Index:

Un index primaire doit être créé pour tout espace, car sans lui, rien ne fonctionnera. Comme dans toute base de données, nous créons le premier champ – l'ID de l'enregistrement.

Parts:

Ici, nous spécifions de quoi se compose notre index. Il se compose d'une seule partie – le premier champ que nous allons utiliser, de type unsigned — un entier positif. Si je me souviens bien de la documentation, le nombre maximum peut atteindre 18 quintillions. Énormément.

Ensuite, nous pouvons insérer des données avec la commande 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>

Le premier champ est utilisé comme clé primaire, il doit donc être unique. Nous ne sommes pas limités par le nombre de colonnes, donc nous pouvons y insérer autant de données que nous le souhaitons. Elles sont spécifiées au format MessagePack, que j'ai décrit ci-dessus.

Sortie des données

Ensuite, nous pouvons afficher les données avec la commande select.

Box.example.select en spécifiant la clé {1} affichera l'enregistrement souhaité. Si nous omettons la clé, nous verrons tous les enregistrements que nous avons. Ils varient en nombre de colonnes, mais ici, il n'y a pas vraiment de notion de colonnes – il y a des numéros de champ.

Il peut y avoir absolument autant de données que nécessaire. Et par exemple, nous devons les rechercher par le deuxième champ. Pour cela, nous créons un nouvel index secondaire.


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

Utilisons la commande Create_index.
Nous l'appelons Secondary.

Après cela, nous devons spécifier les paramètres. Le type d'index — TREE. Il peut ne pas être unique, donc nous saisissons Unique = false.

Ensuite, nous spécifions de quelles parties notre index est composé. Field — c'est le numéro du champ auquel nous attachons l'index, et nous indiquons le type string. Et voilà, il a été créé.

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>

Voici comment nous pouvons l'appeler :

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

Sauvegarde

Si nous redémarrons l'instance et essayons à nouveau d'appeler les données, nous verrons qu'elles sont absentes — tout est vide. C'est ainsi que cela se passe, car Tarantool effectue des checkpoints et enregistre les données sur le disque, mais si nous arrêtons avant la dernière sauvegarde, nous perdrons toutes les opérations — car nous restaurerons à partir du dernier checkpoint, qui était, par exemple, deux heures auparavant.

Sauvegarder chaque seconde n'est pas non plus possible — car dump sur le disque de 20 Go en continu n'est pas vraiment une bonne idée.

Pour cela, le concept de journalisation anticipée (write-ahead log) a été conçu et réalisé. Avec cela, une entrée est créée dans un petit fichier de journalisation anticipée pour chaque modification des données.

Chaque entrée jusqu'au checkpoint est enregistrée dans ces fichiers. Pour ces fichiers, nous définissons une taille — par exemple, 64 Mo. Lorsqu'il est rempli, l'enregistrement commence dans un second fichier. Et après le redémarrage, Tarantool se restaure à partir du dernier checkpoint puis applique toutes les transactions plus récentes jusqu'au moment de l'arrêt.

Pour permettre cette écriture, une option doit être spécifiée dans les paramètres box.cfg (dans le fichier example.lua) :

wal_mode = “write”;

Utilisation des données

Avec ce que nous venons d'écrire, vous pouvez utiliser Tarantool pour stocker des données, et il fonctionnera très rapidement comme une base de données. Et maintenant, la cerise sur le gâteau – ce que vous pouvez faire avec tout cela.

Nous écrivons une application

Par exemple, écrivons une telle application pour Tarantool.

Vous pouvez voir l'application sous spoiler.

box.cfg {
    listen = '0.0.0.0:3301';
    io_collect_interval = nil;
    readahead = 16320;
    memtx_memory = 128 * 1024 * 1024; -- 128Mo
    memtx_min_tuple_size = 16;
    memtx_max_tuple_size = 128 * 1024 * 1024; -- 128Mo
    vinyl_memory = 128 * 1024 * 1024; -- 128Mo
    vinyl_cache = 128 * 1024 * 1024; -- 128Mo
    vinyl_max_tuple_size = 128 * 1024 * 1024; -- 128Mo
    vinyl_write_threads = 2;
    wal_mode = "write";
    wal_max_size = 256 * 1024 * 1024;
    checkpoint_interval = 60 * 60; -- une heure
    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

-- pour la première exécution, créez un espace et configurez les autorisations
box.once('replica', bootstrap)

-- activation de l'accès console
console = require('console')
console.listen('127.0.0.1:3302')

-- configuration http
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",
                              "Nombre de jetons API")

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

Nous déclarons un tableau en lua qui définit des caractères. Ce tableau est nécessaire pour générer une chaîne aléatoire.

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

Ensuite, nous déclarons la fonction – randomString et passons en paramètre la valeur de longueur.

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

Puis, nous connectons le routeur http et le serveur http à notre serveur Tarantool, ainsi que le JSON que nous allons renvoyer au client.

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

Ensuite, nous démarrons le serveur http sur le port 8080 sur toutes les interfaces, qui enregistrera toutes les requêtes et erreurs.

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

Ensuite, nous déclarons la route, pour que si une requête avec la méthode GET arrive sur le port 8080 /count, nous appelons une fonction en une ligne. Elle retourne un statut — 200, 404, 403 ou tout autre, selon ce que nous indiquerons.

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

Dans le corps, nous retournons json.encode, où nous indiquons count et get_count, qui est appelée et montre le nombre d'enregistrements dans notre base.

Deuxième méthode

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)

Où dans la ligne router:route({method = 'GET', path = ' /token'}, function() nous appelons une fonction et générons un token.

Chaîne local token = randomString(32) – c'est une chaîne aléatoire de 32 caractères.
Dans la ligne local last = box.space.example:len() nous récupérons le dernier élément.
Et dans la ligne box.space.example:insert{ last + 1, token } nous enregistrons les données dans notre base, c'est-à-dire que nous augmentons simplement l'ID de 1. Cela peut d'ailleurs être fait, non seulement de cette manière peu élégante. Dans Tarantool, il existe des séquences pour cela.

Nous y écrivons le token.

Ainsi, nous avons écrit une application dans un seul fichier. Nous pouvons immédiatement interagir avec les données, et le module box fera tout le travail pénible pour vous.

Il écoute http et travaille avec les données, tout se trouve dans une seule instance — à la fois l'application et les données. Donc tout se passe assez rapidement.

Pour démarrer, nous installons le module http :

Comment nous le faisons, regardez sous le spoiler

root@test2:/# tarantoolctl rocks install http
Installation de http/rocks.tarantool.org/http-scm-1.src.rock
Dépendances manquantes pour http scm-1 :
   checks >= 3.0.1 (non installé)

http scm-1 dépend de checks >= 3.0.1 (non installé)
Installation de http/rocks.tarantool.org/checks-3.0.1-1.rockspec

Clonage dans 'checks'...
remote: Enumeration des objets : 28, terminé.
remote: Comptage des objets : 100% (28/28), terminé.
remote: Compression des objets : 100% (19/19), terminé.
remote: Total 28 (delta 1), réutilisé 16 (delta 1), pack-réutilisé 0
Réception des objets : 100% (28/28), 12.69 KiB | 12.69 MiB/s, terminé.
Résolution des deltas : 100% (1/1), terminé.
Note : vérification de '580388773ef11085015b5a06fe52d61acf16b201'.

Vous êtes dans un état 'HEAD détaché'. Vous pouvez explorer, apporter des modifications expérimentales et les valider, et vous pouvez annuler toute validation que vous effectuez dans cet état sans impacter aucune branche en effectuant un autre checkout.

Si vous souhaitez créer une nouvelle branche pour conserver les validations que vous créez, vous pouvez le faire (maintenant ou plus tard) en utilisant -b avec la commande checkout à nouveau. Exemple :

  git checkout -b <nom-nouvelle-branche>

Aucun manifeste existant. Tentative de reconstruction...
checks 3.0.1-1 est maintenant installé dans /.rocks (license : BSD)

-- L'identification du compilateur C est GNU 7.5.0
-- Vérification du compilateur C fonctionnel : /usr/bin/cc
-- Vérification du compilateur C fonctionnel : /usr/bin/cc -- fonctionne
-- Détection des informations d'ABI du compilateur C
-- Détection des informations d'ABI du compilateur C - terminé
-- Détection des caractéristiques de compilation C
-- Détection des caractéristiques de compilation C - terminé
-- TARANTOOL trouvé : /usr/include (version trouvée "2.4.2-80-g18f2bc82d")
-- Tarantool LUADIR est /.rocks/share/tarantool/rocks/http/scm-1/lua
-- Tarantool LIBDIR est /.rocks/share/tarantool/rocks/http/scm-1/lib
-- Configuration terminée
-- Génération terminée
Avertissement CMake :
  Les variables spécifiées manuellement n'ont pas été utilisées par le projet :

    version


-- Les fichiers de construction ont été écrits dans : /tmp/luarocks_http-scm-1-V4P9SM/http/build.luarocks
Analyse des dépendances de la cible httpd
[ 50%] Construction de l'objet C http/CMakeFiles/httpd.dir/lib.c.o
Dans le fichier inclus de /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:32:0 :
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c: Dans la fonction ‘tpl_term’ :
/usr/include/tarantool/lauxlib.h:144:15: avertissement : cette déclaration peut tomber à travers [-Wimplicit-fallthrough=]
    (*(B)->p++ = (char)(c)))
    ~~~~~~~~~~~^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:62:7: note : dans l'expansion de la macro ‘luaL_addchar’
       luaL_addchar(b, '\');
       ^~~~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:63:6: note : ici
      default:
      ^~~~~~~
Dans le fichier inclus de /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:39:0 :
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h: Dans la fonction ‘tpe_parse’ :
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:147:9: avertissement : cette déclaration peut tomber à travers [-Wimplicit-fallthrough=]
    type = TPE_TEXT;
    ~~~~~^~~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/tpleval.h:149:3: note : ici
   case TPE_LINECODE:
   ^~~~
Dans le fichier inclus de /tmp/luarocks_http-scm-1-V4P9SM/http/http/lib.c:40:0 :
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h: Dans la fonction ‘httpfast_parse’ :
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:372:22: avertissement : cette déclaration peut tomber à travers [-Wimplicit-fallthrough=]
                 code = 0;
                 ~~~~~^~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:374:13: note : ici
             case status:
             ^~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:393:23: avertissement : cette déclaration peut tomber à travers [-Wimplicit-fallthrough=]
                 state = message;
                 ~~~~~~^~~~~~~~~
/tmp/luarocks_http-scm-1-V4P9SM/http/http/httpfast.h:395:13: note : ici
             case message:
             ^~~~
[100%] Lien de la bibliothèque partagée C lib.so
[100%] Cible httpd construite
[100%] Cible httpd construite
Installer le projet...
-- Configuration d'installation : "Debug"
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/VERSION.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lib/http/lib.so
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/init.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/server/tsgi_adapter.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/nginx_server/init.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/init.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/fs.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/matching.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/middleware.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/request.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/router/response.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/tsgi.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/utils.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/mime_types.lua
-- Installation : /.rocks/share/tarantool/rocks/http/scm-1/lua/http/codes.lua
http scm-1 est maintenant installé dans /.rocks (license : BSD)

root@test2:/#

Nous avons également besoin de prometheus pour démarrer :

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

Clonage dans 'prometheus'...
remote: Enumération des objets : 19, fait.
remote: Comptage des objets : 100 % (19/19), fait.
remote: Compression des objets : 100 % (19/19), fait.
remote: Total 19 (delta 2), réutilisé 5 (delta 0), pack-réutilisé 0
Réception des objets : 100 % (19/19), 10.73 KiB | 10.73 MiB/s, fait.
Résolution des deltas : 100 % (2/2), fait.
prometheus scm-1 est maintenant installé dans /.rocks (licence : BSD)

root@test2:~#

Nous lançons et pouvons accéder aux modules

root@test2:~# curl -D - -s http://127.0.0.1:8080/token
HTTP/1.1 200 Ok
Content-length: 44
Serveur : 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
Serveur : 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
Serveur : Tarantool http (tarantool v2.4.2-80-g18f2bc82d)
Connection : keep-alive

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

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

Testons la vitesse

Lançons un benchmark avec 50 000 requêtes. Le nombre de requêtes concurrentes sera de 500.

root@test2:~# ab -c 500 -n 50000 http://127.0.0.1:8080/token
This is ApacheBench, Version 2.3 
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 (soyez patient)
5000 requêtes terminées
10000 requêtes terminées
15000 requêtes terminées
20000 requêtes terminées
25000 requêtes terminées
30000 requêtes terminées
35000 requêtes terminées
40000 requêtes terminées
45000 requêtes terminées
50000 requêtes terminées
50000 requêtes finalisées


Logiciel serveur :        Tarantool
Nom d'hôte serveur :        127.0.0.1
Port serveur :            8080

Chemin du document :          /token
Longueur du document :        44 octets

Niveau de concurrence :      500
Temps pris pour les tests :   14.578 secondes
Requêtes complètes :      50000
Requêtes échouées :        0
Total transféré :      7950000 octets
HTML transféré :       2200000 octets
Requêtes par seconde :    3429.87 [# /sec] (moyenne)
Temps par requête :       145.778 [ms] (moyenne)
Temps par requête :       0.292 [ms] (moyenne, sur toutes les requêtes concurrentes)
Taux de transfert :          532.57 [Ko/sec] reçu

Temps de connexion (ms)
              min  mean[+/-sd] median   max
Connexion :        0   10 103.2      0    3048
Traitement :    12   69 685.1     15   13538
Attente :       12   69 685.1     15   13538
Total :         12   78 768.2     15   14573

Pourcentage des requêtes servies dans un certain temps (ms)
  50 %     15
  66 %     15
  75 %     16
  80 %     16
  90 %     16
  95 %     16
  98 %     21
  99 %     42
 100 %  14573 (requête la plus longue)
root@test2:~#

Les tokens sont générés. Nous enregistrons constamment des données. 99 % des requêtes ont été traitées en 42 millisecondes. Cela nous donne environ 3500 requêtes par seconde sur une petite machine avec 2 cœurs et 4 Go de mémoire.

Il est également possible de sélectionner un token de 50000 et de voir sa valeur.

Vous pouvez utiliser non seulement http, mais aussi exécuter des fonctions en arrière-plan qui traitent vos données. De plus, il existe différents déclencheurs. Par exemple, vous pouvez appeler des fonctions lors de mises à jour, vérifier certaines choses – corriger des conflits.

Il est possible d'écrire des applications scripts directement sur le serveur de la base de données, sans aucune limitation, en connectant n'importe quel module et en réalisant n'importe quelle logique.

Le serveur d'applications peut se connecter à des serveurs externes, récupérer des données et les stocker dans sa propre base. Ces données seront utilisées par d'autres applications.

C'est Tarantool qui s'en chargera, et il ne sera pas nécessaire d'écrire une application séparée.

En conclusion

Ce n'est que la première partie d'un grand travail. La deuxième sera publiée très bientôt sur le blog de Mail.ru Group, et nous ajouterons certainement un lien vers celle-ci dans ce matériel.

Si vous êtes intéressé à participer à des événements où nous créons ce genre de choses en ligne et à poser des questions en temps réel, rejoignez-nous sur la chaîne DevOps by REBRAIN.

Si vous avez besoin de passer au cloud ou si vous avez des questions sur votre infrastructure, n'hésitez pas à laisser une demande.

P.S. Nous avons 2 audits gratuits par mois, peut-être que votre projet sera l'un d'eux.

Source : habr.com

Avec Tarantool, vous pouvez associer une base de données super rapide et une application pour travailler avec celle-ci. Voici comment c'est fait simplement