Dalam Tarantool, anda boleh menggabungkan pangkalan data yang sangat pantas dan aplikasi untuk berfungsi dengannya. Begini caranya mudah dilakukan

Lima tahun lalu saya cuba bekerja dengan Tarantool, tetapi ia tidak berkesan untuk saya. Tetapi baru-baru ini saya mengadakan webinar di mana saya bercakap tentang Hadoop, tentang cara MapReduce berfungsi. Di sana saya ditanya soalan - "Mengapa tidak menggunakan Tarantool untuk tugas ini?".

Demi rasa ingin tahu, saya memutuskan untuk kembali kepadanya, menguji versi terkini - dan kali ini saya sangat menyukai projek itu. Sekarang saya akan menunjukkan cara menulis aplikasi mudah di Tarantool, memuatkannya dan menyemak prestasi, dan anda akan melihat betapa mudah dan sejuk segala-galanya ada di sana.

Apa itu Tarantool

Tarantool meletakkan dirinya sebagai pangkalan data ultra-pantas. Anda boleh meletakkan sebarang data yang anda mahu di sana. Selain itu, replikakannya, shard - iaitu, bahagikan sejumlah besar data merentas beberapa pelayan dan gabungkan hasil daripadanya - buat pautan induk-induk yang toleran terhadap kesalahan.

Kedua, ia adalah pelayan aplikasi. Anda boleh menulis aplikasi anda di atasnya, bekerja dengan data, contohnya, memadam entri lama di latar belakang mengikut peraturan tertentu. Anda boleh menulis pelayan Http terus dalam Tarantula yang akan berfungsi dengan data: berikan nombor mereka, tulis data baharu di sana dan kurangkan semuanya kepada induk.

Saya membaca artikel tentang cara mereka membuat baris gilir mesej 300 baris, yang hanya mengoyak dan meronta-ronta - mereka mempunyai prestasi minimum 20 mesej sesaat. Di sini anda benar-benar boleh berpatah balik dan menulis aplikasi yang sangat besar, dan ini tidak akan disimpan, seperti dalam PostgreS.

Kira-kira pelayan sedemikian, hanya mudah, saya akan cuba menerangkan dalam artikel ini.

Pemasangan

Untuk ujian, saya memulakan tiga mesin maya standard - pemacu keras 20 gigabait, Ubuntu 18.04. 2 CPU maya dan 4 gigabait memori.

Kami memasang Tarantool - jalankan skrip bash atau tambah repositori dan lakukan pemasangan Tarantool dengan tepat. Pautan ke skrip - (curl -L https://tarantool.io/installer.sh | VER=2.4 sudo -E bash). Kami mempunyai arahan seperti:

tarantoolctl ialah arahan utama untuk menguruskan kejadian Tarantula.
/etc/tarantool - di sini terletak keseluruhan konfigurasi.
var/log/tarantool - inilah lognya.
var/lib/tarantool - di sini terletak data, dan kemudian ia dibahagikan kepada contoh.

Terdapat folder instance-available dan instance-enable - ia mengandungi apa yang akan dilancarkan - fail konfigurasi instance dengan kod lua, yang menerangkan port mana ia mendengar, memori yang tersedia untuknya, tetapan enjin vinil, kod yang berfungsi semasa permulaan pelayan, sharding, baris gilir, pemadaman data usang, dan sebagainya.

Instance berfungsi seperti dalam PostgreS. Sebagai contoh, anda ingin menjalankan berbilang salinan pangkalan data yang digantung pada port yang berbeza. Ternyata beberapa contoh pangkalan data dilancarkan pada satu pelayan, yang tergantung pada port yang berbeza. Mereka boleh mempunyai tetapan yang sama sekali berbeza - satu contoh melaksanakan satu logik, yang kedua - yang lain.

Pengurusan Instance

Kami mempunyai perintah tarantoolctl yang membolehkan kami mengurus kejadian Tarantula. Sebagai contoh, contoh semakan tarantoolctl akan menyemak fail konfigurasi dan mengatakan fail itu ok jika tiada ralat sintaks.

Anda boleh melihat status contoh - contoh status tarantoolctl. Dengan cara yang sama, anda boleh mula, berhenti, mulakan semula.

Sebaik sahaja contoh sedang berjalan, terdapat dua cara untuk menyambung kepadanya.

1. Konsol pentadbiran

Secara lalai, Tarantool membuka soket dan menghantar teks ASCII biasa untuk mengawal Tarantula. Sambungan ke konsol sentiasa berlaku di bawah pengguna pentadbir, tiada pengesahan, jadi anda tidak perlu mengeluarkan port konsol untuk mengawal Tarantula di luar.

Untuk menyambung dengan cara ini, anda perlu memasukkan Tarantoolctl masukkan nama contoh. Perintah itu akan melancarkan konsol dan menyambung sebagai pengguna pentadbir. Jangan sekali-kali dedahkan port konsol ke luar - lebih baik biarkan ia sebagai soket unit. Kemudian hanya mereka yang mempunyai akses tulis kepada soket akan dapat menyambung ke Tarantula.

Kaedah ini diperlukan untuk urusan pentadbiran. Untuk bekerja dengan data, gunakan kaedah kedua - protokol binari.

2. Menggunakan protokol binari untuk menyambung ke port tertentu

Terdapat arahan dengar dalam konfigurasi, yang membuka port untuk komunikasi luaran. Port ini digunakan dengan protokol binari dan pengesahan didayakan di sana.

Untuk sambungan ini, tarantoolctl connect to port number digunakan. Menggunakannya, anda boleh menyambung ke pelayan jauh, menggunakan pengesahan dan memberikan pelbagai hak akses.

Perekodan Data dan Modul Kotak

Memandangkan Tarantool ialah pangkalan data dan pelayan aplikasi, ia mempunyai pelbagai modul. Kami berminat dengan modul kotak - ia melaksanakan kerja dengan data. Apabila anda menulis sesuatu pada kotak, Tarantool menulis data ke cakera, menyimpannya dalam ingatan atau melakukan sesuatu yang lain dengannya.

Rekod

Sebagai contoh, kita pergi ke modul kotak dan memanggil fungsi box.once. Ia akan memaksa Tarantool untuk menjalankan kod kami apabila pelayan dimulakan. Kami mencipta ruang di mana data kami akan disimpan.

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

    -- Keep things safe by default
    --  box.schema.user.create('example', { password = 'secret' })
    --  box.schema.user.grant('example', 'replication')
    --  box.schema.user.grant('example', 'read,write,execute', 'space', 'example')
end

Selepas itu, kami mencipta indeks utama - primer - yang mana kami boleh mencari data. Secara lalai, jika tiada parameter dinyatakan, medan pertama dalam setiap entri untuk indeks primer akan digunakan.

Kemudian kami membuat geran kepada pengguna tetamu, di mana kami menyambung melalui protokol binari. Kami membenarkan membaca, menulis dan melaksanakan dalam keseluruhan contoh.

Berbanding dengan pangkalan data konvensional, semuanya agak mudah di sini. Kami mempunyai ruang - kawasan di mana data kami disimpan secara ringkas. Setiap entri dipanggil tuple. Ia dibungkus dalam MessagePack. Ini adalah format yang sangat keren - ia adalah binari dan menggunakan lebih sedikit ruang - 18 bait berbanding 27.

Ia agak mudah untuk bekerja dengannya. Hampir setiap baris, setiap kemasukan data boleh mempunyai lajur yang berbeza.

Kita boleh melihat semua ruang menggunakan arahan Box.space. Untuk memilih contoh tertentu, kami menulis contoh box.space dan mendapatkan maklumat penuh mengenainya.

Terdapat dua jenis enjin terbina dalam Tarantool: Memori dan Vinyl. Memori menyimpan semua data dalam ingatan. Oleh itu, semuanya berfungsi dengan mudah dan cepat. Data dibuang ke cakera, dan terdapat juga mekanisme log tulis ke hadapan, jadi kami tidak akan kehilangan apa-apa jika pelayan ranap.

Vinyl menyimpan data pada cakera dalam bentuk yang lebih biasa - iaitu, anda boleh menyimpan lebih banyak data daripada memori yang kita ada, dan Tarantula akan membacanya dari cakera.

Sekarang kita akan menggunakan Memori.

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:

Indeks utama mesti dibuat untuk mana-mana ruang, kerana tiada apa yang akan berfungsi tanpanya. Seperti dalam mana-mana pangkalan data, kami mencipta medan pertama - ID rekod.

Bahagian:

Di sinilah kami menentukan kandungan indeks kami. Ia terdiri daripada satu bahagian - medan pertama yang akan kami gunakan, taip unsigned - integer positif. Seingat saya dari dokumentasi, jumlah maksimum yang boleh ialah 18 quintillion. Banyak yang hebat.

Kami kemudiannya boleh memasukkan data menggunakan arahan sisip.

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>

Medan pertama digunakan sebagai kunci utama, jadi ia mestilah unik. Kami tidak dihadkan oleh bilangan lajur, jadi kami boleh memasukkan seberapa banyak data yang kami suka di sana. Ia dinyatakan dalam format MessagePack, yang saya terangkan di atas.

Keluaran data

Kemudian kita boleh memaparkan data dengan arahan pilih.

Box.example.select dengan kekunci {1} akan memaparkan masukan yang diingini. Jika kita meninggalkan kunci, kita akan melihat semua rekod yang kita ada. Mereka semua berbeza dalam bilangan lajur, tetapi di sini, pada dasarnya, tidak ada konsep lajur - terdapat nombor medan.

Terdapat sebanyak mungkin data yang anda mahukan. Dan sebagai contoh, kita perlu mencari mereka dalam medan kedua. Untuk melakukan ini, kami membuat indeks sekunder baharu.

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

Kami menggunakan arahan Create_index.
Kami memanggilnya Menengah.

Selepas itu, anda perlu menentukan parameter. Jenis indeks ialah TREE. Ia mungkin tidak unik, jadi kami masukkan Unique = false.

Kemudian kami menunjukkan bahagian yang terdiri daripada indeks kami. Medan ialah nombor medan yang kami ikat indeks dan menentukan jenis rentetan. Maka ia dicipta.

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>

Sekarang ini adalah bagaimana kita boleh memanggilnya:

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

Pemeliharaan

Jika kita memulakan semula kejadian dan cuba memanggil data sekali lagi, kita akan melihat bahawa ia tidak ada - semuanya kosong. Ini berlaku kerana Tarantool membuat pusat pemeriksaan dan menyimpan data ke cakera, tetapi jika kami berhenti bekerja sebelum menyimpan seterusnya, kami akan kehilangan semua operasi - kerana kami akan pulih dari pusat pemeriksaan terakhir, iaitu, sebagai contoh, dua jam yang lalu.

Menyimpan setiap saat juga tidak akan berfungsi - kerana sentiasa membuang 20 GB ke cakera adalah idea yang begitu-begitu.

Untuk ini, konsep log tulis ke hadapan telah dicipta dan dilaksanakan. Dengan bantuannya, untuk setiap perubahan dalam data, rekod dibuat dalam fail log tulis hadapan kecil.

Setiap kemasukan sehingga ke pusat pemeriksaan disimpan di dalamnya. Untuk fail ini, kami menetapkan saiz - contohnya, 64 mb. Apabila ia penuh, rakaman mula pergi ke fail kedua. Dan selepas dimulakan semula, Tarantool pulih dari pusat pemeriksaan terakhir dan kemudian melancarkan semua transaksi kemudian sehingga ia berhenti.

Untuk melakukan rakaman sedemikian, anda perlu menentukan pilihan dalam tetapan box.cfg (dalam fail example.lua):

wal_mode = “write”;

data yang digunakan

Dengan apa yang telah kami tulis sekarang, anda boleh menggunakan Tarantula untuk menyimpan data dan ia akan berfungsi dengan pantas sebagai pangkalan data. Dan sekarang ceri pada kek - apa yang boleh anda lakukan dengan semuanya.

Menulis permohonan

Sebagai contoh, mari kita tulis permohonan sedemikian untuk Tarantula

Lihat aplikasi di bawah 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()

Kami mengisytiharkan beberapa jadual dalam lua yang mentakrifkan simbol. Jadual ini diperlukan untuk menjana rentetan rawak.

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

Selepas itu, kami mengisytiharkan fungsi - randomString dan memberikan nilai panjang dalam kurungan.

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

Kemudian kami menyambungkan penghala http dan pelayan http ke pelayan Tarantula kami, JSON, yang akan kami berikan kepada pelanggan.

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

Selepas itu, kami mulakan pada port 8080 pada semua antara muka pelayan http, yang akan log semua permintaan dan ralat.

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

Seterusnya, kami mengisytiharkan laluan bahawa jika permintaan dengan kaedah GET tiba pada port 8080 /count, maka kami memanggil fungsi dari satu baris. Ia mengembalikan status - 200, 404, 403 atau apa sahaja yang kami tentukan.

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

Dalam badan, kami mengembalikan json.encode, kami menentukan kiraan dan dapatkan kiraan di dalamnya, yang dipanggil dan menunjukkan bilangan rekod dalam pangkalan data kami.

Kaedah kedua

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)

Di mana dalam barisan penghala:laluan({kaedah = 'GET', laluan = '/token'}, function() kami memanggil fungsi dan menjana token.

Garisan token tempatan = randomString(32) ialah rentetan rawak 32 aksara.
Dalam barisan local last = box.space.example:len() kami mengeluarkan elemen terakhir.
Dan dalam barisan box.space.example:insert{ last + 1, token } kami menulis data ke pangkalan data kami, iaitu, kami hanya meningkatkan ID sebanyak 1. Ini boleh dilakukan, dengan cara itu, bukan sahaja dengan cara yang kekok. Tarantula mempunyai urutan untuk kes ini.

Kami menulis token di sana.

Oleh itu, kami menulis permohonan dalam satu fail. Anda boleh mengakses data dengan segera, dan modul kotak akan melakukan semua kerja kotor untuk anda.

Ia mendengar http dan berfungsi dengan data, semuanya dalam satu contoh - kedua-dua aplikasi dan data. Oleh itu, semuanya berlaku dengan cepat.

Untuk menjalankan, kami memasang modul http:

Bagaimana kita melakukannya, lihat di bawah 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:/#

Kami juga memerlukan prometheus untuk menjalankan:

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

Kami mula dan boleh mengakses modul

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 memberi kita status 200.
/token mengeluarkan token dan menulis token ini ke pangkalan data.

Menguji kelajuan

Mari jalankan penanda aras untuk 50 permintaan. Permintaan kompetitif ialah 000.

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 dikeluarkan. Dan kami sentiasa merekodkan data. 99% permintaan telah diselesaikan dalam 42 milisaat. Sehubungan itu, kami mempunyai kira-kira 3500 permintaan sesaat pada mesin kecil, di mana terdapat 2 teras dan 4 gigabait memori.

Anda juga boleh memilih kira-kira 50000 token dan melihat nilainya.

Anda boleh menggunakan bukan sahaja http, menjalankan fungsi latar belakang yang memproses data anda. Tambahan pula terdapat pelbagai pencetus. Sebagai contoh, anda boleh memanggil fungsi pada kemas kini, menyemak sesuatu - membetulkan konflik.

Anda boleh menulis aplikasi skrip terus dalam pelayan pangkalan data itu sendiri, dan tidak dihadkan oleh apa-apa, sambungkan mana-mana modul dan laksanakan sebarang logik.

Pelayan aplikasi boleh mengakses pelayan luaran, mengumpul data dan menambahnya ke pangkalan datanya. Data daripada pangkalan data ini akan digunakan oleh aplikasi lain.

Ini akan dilakukan oleh Tarantula sendiri, dan tidak perlu menulis aplikasi berasingan.

Kesimpulannya

Ini hanyalah bahagian pertama kerja besar. Yang kedua akan diterbitkan tidak lama lagi di blog Kumpulan Mail.ru, dan kami pasti akan menambah pautan kepadanya dalam artikel ini.

Jika anda berminat untuk menghadiri acara di mana kami mencipta perkara ini dalam talian dan bertanya soalan dalam masa nyata, sambung ke DevOps oleh saluran REBRAIN.

Jika anda perlu beralih ke awan atau mempunyai soalan tentang infrastruktur anda, Jangan ragu untuk menghantar permintaan.

PS Kami mempunyai 2 audit percuma setiap bulan, mungkin projek anda akan menjadi salah satu daripadanya.

Sumber: www.habr.com