Clever Geek Handbook

Di Tarantool, Anda dapat menggabungkan database dan aplikasi super cepat untuk bekerja dengannya. Begini caranya mudah

Lima tahun lalu saya mencoba bekerja dengan Tarantool, tetapi kemudian tidak berhasil. Namun baru-baru ini saya menyelenggarakan webinar di mana saya berbicara tentang Hadoop, tentang cara kerja MapReduce. Di sana saya ditanyai pertanyaan - "Mengapa tidak menggunakan Tarantool untuk tugas ini?"



Demi rasa penasaran, saya memutuskan untuk kembali ke sana, menguji versi terbaru - dan kali ini saya sangat menyukai proyek tersebut. Sekarang saya akan menunjukkan kepada Anda cara menulis aplikasi sederhana di Tarantool, memuatnya dan menguji kinerjanya, dan Anda akan melihat betapa mudah dan kerennya semua yang ada di sana.







Apa itu Tarantool



Tarantool memposisikan dirinya sebagai database super cepat. Anda dapat memasukkan data apa pun yang Anda inginkan ke sana. Plus, gandakan mereka, pecahan - yaitu, membagi sejumlah besar data di beberapa server dan menggabungkan hasil dari mereka - untuk membuat bundel "master-master" yang toleran terhadap kesalahan.



Kedua, ini adalah server aplikasi. Anda dapat menulis aplikasi Anda di atasnya, bekerja dengan data, misalnya, menghapus catatan lama di latar belakang sesuai dengan aturan tertentu. Anda dapat menulis server Http langsung di Tarantula, yang akan bekerja dengan data: keluarkan jumlahnya, tulis data baru di sana dan kurangi semuanya ke master.



Saya membaca artikel tentang bagaimana orang-orang itu membuat antrian pesan 300 baris yang hanya membuat mereka menangis dan berlalu - mereka memiliki kinerja minimum 20.000 pesan per detik. Di sini Anda benar-benar dapat memperluas dan menulis aplikasi yang sangat besar, dan itu tidak akan disimpan seperti di PostgreS.



Tentang server seperti itu, sederhana saja, saya akan coba jelaskan dalam artikel ini.



Instalasi



Untuk pengujian, saya memulai tiga mesin virtual standar - hard drive 20 gigabyte, Ubuntu 18.04. 2 CPU virtual dan memori 4 gigabyte.



Kami menginstal Tarantool - jalankan skrip bash atau tambahkan repositori dan lakukan untuk menginstal Tarantool. Tautan ke skrip adalah (curl -L https://tarantool.io/installer.sh | VER = 2.4 sudo -E bash). Kami memiliki perintah seperti:



tarantoolctl - perintah utama untuk mengelola instance Tarantula.

/ etc / tarantool - semua konfigurasi ada di sini.

var / log / tarantool - log disimpan di sini.

var / lib / tarantool - ini adalah tempat data disimpan , dan kemudian dipecah menjadi beberapa instance.



Ada folder yang tersedia untuk instans dan aktifkan instans - ini berisi apa yang akan diluncurkan - file konfigurasi instans dengan kode lua, yang menjelaskan pada port mana ia mendengarkan, memori apa yang tersedia untuk itu, pengaturan mesin Vinyl, kode yang dipicu saat startup server, sharding, antrean, penghapusan data usang, dan sebagainya.



Instance berfungsi seperti PostgreS. Misalnya, Anda ingin menjalankan beberapa salinan database yang tergantung pada port yang berbeda. Ternyata beberapa contoh database diluncurkan di server yang sama, yang bergantung pada port yang berbeda. Mereka dapat memiliki pengaturan yang sangat berbeda - satu contoh menerapkan satu logika, yang kedua - yang lain.



Manajemen instance



Kami memiliki perintah tarantoolctl yang memungkinkan Anda untuk mengelola instance Tarantula Anda. Sebagai contoh, contoh pemeriksaan tarantoolctl akan memeriksa file konfigurasi dan mengatakan - file tersebut ok jika tidak ada kesalahan sintaks.



Anda dapat melihat status dari instance - contoh status tarantoolctl. Dengan cara yang sama Anda dapat melakukan start, stop, restart.



Saat instance berjalan, ada dua cara untuk menghubungkannya.



1. Konsol Administratif



Secara default, Tarantool membuka soket, yang mengirimkan teks ASCII biasa untuk mengontrol Tarantula. Koneksi ke konsol selalu dilakukan di bawah pengguna admin, tidak ada otentikasi, jadi Anda tidak perlu mengeluarkan port konsol untuk mengelola Tarantula.



Untuk menghubungkan dengan cara ini, masukkan Tarantoolctl masukkan nama instance. Perintah tersebut akan meluncurkan konsol dan terhubung sebagai pengguna admin. Jangan pernah mengekspos port konsol ke luar - yang terbaik adalah membiarkannya sebagai soket unit. Maka hanya mereka yang memiliki akses tulis ke soket yang dapat terhubung ke Tarantula.



Cara ini diperlukan untuk urusan administrasi. Untuk bekerja dengan data, gunakan metode kedua - protokol biner.



2. Menggunakan protokol biner untuk terhubung ke port tertentu



Ada arahan mendengarkan dalam konfigurasi, yang membuka port untuk komunikasi eksternal. Porta ini digunakan dengan protokol biner dan otentikasi diaktifkan di sana.



Untuk koneksi ini, tarantoolctl terhubung ke nomor port digunakan. Dengan menggunakannya, Anda dapat terhubung ke server jarak jauh, menggunakan otentikasi dan memberikan berbagai hak akses.



Data logger dan modul Box



Karena Tarantool adalah database dan server aplikasi, ia memiliki berbagai modul. Kami tertarik pada modul kotak - ini mengimplementasikan pekerjaan dengan data. Saat Anda menulis sesuatu ke box, Tarantool menulis data ke disk, menyimpannya dalam memori, atau melakukan sesuatu yang lain dengannya.



Rekaman



Misalnya, kita masuk ke modul kotak dan memanggil fungsi box.once. Ini akan membuat Tarantool menjalankan kode kita saat server diinisialisasi. Kami membuat 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


Setelah itu, kami membuat indeks utama - primer - yang digunakan untuk mencari data. Secara default, jika Anda tidak menentukan parameter apa pun, kolom pertama di setiap entri untuk indeks primer akan digunakan.



Kemudian kami memberikan hibah kepada pengguna tamu, di mana kami terhubung melalui protokol biner. Mengizinkan membaca, menulis, dan mengeksekusi di seluruh instance.



Dibandingkan dengan database konvensional, semuanya cukup sederhana di sini. Kami memiliki ruang - area yang hanya menyimpan data kami. Setiap entri disebut tupel. Itu dikemas dalam MessagePack. Ini adalah format yang sangat keren - ini biner dan membutuhkan lebih sedikit ruang - 18 byte versus 27.







Ini cukup nyaman untuk digunakan. Hampir setiap baris, setiap record data dapat memiliki kolom yang sangat berbeda.



Kita bisa melihat semua ruang menggunakan perintah Box.space. Untuk memilih contoh tertentu - tulis contoh box.space dan dapatkan informasi lengkapnya.



Tarantool memiliki dua mesin bawaan: Memori dan Vinyl. Memori menyimpan semua data dalam memori. Oleh karena itu, semuanya bekerja dengan sederhana dan cepat. Data dibuang ke disk, dan ada juga mekanisme log depan tulis, jadi kami tidak akan kehilangan apa pun jika server macet.



Vinyl menyimpan data pada disk dalam bentuk yang lebih familiar - yaitu, Anda dapat menyimpan lebih banyak data daripada memori yang kami miliki, dan Tarantula akan membacanya dari disk.



Kami sekarang 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 harus dibuat untuk ruang apa pun, karena tanpanya tidak ada yang berfungsi. Seperti database lainnya, kami membuat bidang pertama - ID rekaman.



Bagian:



Di sini kami menunjukkan terdiri dari apa indeks kami. Ini terdiri dari satu bagian - bidang pertama yang akan kita gunakan adalah unsigned, bilangan bulat positif. Seingat saya dari dokumentasinya, angka maksimal yang bisa 18 triliun. Luar biasa.



Kemudian kita dapat memasukkan data menggunakan perintah sisipkan. 



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>


Kolom pertama digunakan sebagai kunci utama, jadi harus unik. Kami tidak dibatasi oleh jumlah kolom, jadi kami dapat memasukkan data sebanyak yang kami suka. Mereka ditentukan dalam format MessagePack yang saya jelaskan di atas.



Keluaran data



Kemudian kita dapat menampilkan data dengan perintah pilih.



Box.example.select dengan kunci {1} akan menampilkan rekaman yang diperlukan. Jika kita menghilangkan kuncinya, kita akan melihat semua record yang kita miliki. Semuanya berbeda dalam jumlah kolom, tetapi pada prinsipnya tidak ada konsep kolom - ada nomor kolom.



Benar-benar ada sejumlah data. Dan misalnya, kita perlu mencarinya dengan kolom kedua. Untuk ini kami membuat indeks sekunder baru. 




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


Kami menggunakan perintah Create_index.

Kami menyebutnya Sekunder.



Setelah itu, Anda perlu menentukan parameternya. Jenis indeks adalah TREE. Ini mungkin tidak unik, jadi kami memasukkan Unique = false.



Kemudian kami menunjukkan bagian mana dari indeks kami. Bidang adalah nomor bidang tempat kita mengikat indeks, dan menentukan jenis string. Dan begitulah diciptakan. 



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 begini kita menyebutnya: 



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


Kelestarian



Jika kita memulai ulang instance dan mencoba memanggil data lagi, kita akan melihat bahwa data tidak ada - semuanya kosong. Ini terjadi karena Tarantool membuat pos pemeriksaan dan menyimpan datanya ke disk, tetapi jika kami berhenti bekerja sebelum penyimpanan berikutnya, kami akan kehilangan semua operasi - karena kami akan memulihkan dari pos pemeriksaan terakhir, misalnya, dua jam yang lalu.



Menyimpan setiap detik juga tidak akan berhasil - karena terus-menerus membuang 20 GB ke disk biasa saja.



Untuk ini, konsep log depan tulis diciptakan dan diterapkan. Ini membuat entri dalam file log depan tulis kecil untuk setiap perubahan dalam data.



Setiap entri sebelum pos pemeriksaan disimpan di dalamnya. Untuk file ini, kami menetapkan ukurannya - misalnya, 64 MB. Saat sudah penuh, rekaman mulai masuk ke file kedua. Dan setelah memulai ulang, Tarantool memulihkan dari pos pemeriksaan terakhir dan kemudian menggulirkan semua transaksi selanjutnya hingga berhenti.







Untuk membuat rekaman seperti itu, Anda perlu menentukan opsi di pengaturan box.cfg (di file example.lua): 



wal_mode = “write”;


penggunaan data



Dengan apa yang telah kami tulis sekarang, Anda dapat menggunakan Tarantula untuk menyimpan data, dan itu akan bekerja dengan sangat cepat sebagai database. Dan sekarang ceri di atas kue - apa yang dapat Anda lakukan dengan semuanya.



Menulis aplikasi



Misalnya mari kita tulis aplikasi seperti itu untuk Tarantula



Lihat aplikasinya 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 mendeklarasikan beberapa label di lua yang mendefinisikan simbol. Pelat ini diperlukan untuk menghasilkan garis acak. 



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


Setelah itu, kami mendeklarasikan fungsi - randomString dan memberikan nilai panjang dalam tanda kurung. 



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 menghubungkan http-router dan http-server ke Tarantula-server kami, JSON, yang akan kami kirim ke klien. 



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


Setelah itu, kita mulai pada port 8080 di semua antarmuka server http, yang akan mencatat semua permintaan dan kesalahan. 



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


Selanjutnya, kami mendeklarasikan rute bahwa jika permintaan dengan metode GET datang ke port 8080 / count, maka kami memanggil fungsi dari satu baris. Ini mengembalikan status - 200, 404, 403 atau apa pun yang kami tentukan. 



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


Di bagian body, kami mengembalikan json.encode, di dalamnya kami menentukan count dan getcount, yang dipanggil dan menunjukkan jumlah record dalam database kami.



Metode dua 



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 di router baris : route ({method = ' GET', path = '/ token'}, function () , kita memanggil fungsi dan menghasilkan token.



Bar local token = randomString (32) - adalah string Randomnaya yang terdiri dari 32 karakter.

Line local last = box.space.example: len () kita menarik elemen terakhir,

dan di baris box.space.example: masukkan {last + 1, token} kita tulis ke database kita, yaitu, kita hanya menambah ID dengan 1. Ini bisa dilakukan Ngomong-ngomong, tidak hanya dengan cara yang canggung. Di Tarantula ada urutan untuk bisnis ini. Kami



menulis token di sana.



Jadi, kami menulis aplikasi dalam satu file. Di dalamnya, Anda dapat segera menangani data, dan modul kotak akan melakukan semua pekerjaan kotor untuk Anda ...



Itu mendengarkan http dan bekerja dengan data, semuanya dalam satu contoh - baik aplikasi dan datanya. Karena itu, semuanya terjadi cukup cepat.



Untuk menjalankannya, kami memasang modul http:



Bagaimana kami 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 membutuhkan 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 mulai dan kami dapat 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 200 status.

/ token mengeluarkan token dan menulis token ini ke database.



Kecepatan pengujian



Mari kita jalankan tolok ukur dengan 50.000 kueri. Akan ada 500 permintaan kompetitif. 



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 terus merekam data. 99% permintaan diselesaikan dalam 42 milidetik. Karenanya, kami memiliki sekitar 3500 permintaan per detik pada mesin kecil, yang memiliki 2 core dan 4 gigabyte memori.



Anda juga dapat memilih sekitar 50.000 token dan melihat nilainya.



Anda tidak hanya dapat menggunakan http, Anda dapat menjalankan fungsi latar belakang yang memproses data Anda. Ditambah, ada berbagai pemicu. Misalnya, Anda dapat memanggil fungsi pada pembaruan, memeriksa sesuatu - memperbaiki konflik.



Anda dapat menulis skrip aplikasi langsung di server database itu sendiri, dan tidak terbatas, menghubungkan modul apa pun, dan menerapkan logika apa pun.



Server aplikasi dapat mengakses server eksternal, mengumpulkan data dan menyimpannya dalam database-nya. Data dari database ini akan digunakan oleh aplikasi lain.



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



Akhirnya



Ini hanyalah bagian pertama dari banyak pekerjaan. Yang kedua akan segera diterbitkan di blog Grup Mail.ru, dan kami pasti akan menambahkan tautan ke dalamnya di artikel ini.



Jika Anda tertarik untuk menghadiri acara di mana kami membuat hal-hal seperti itu secara online dan mengajukan pertanyaan secara real time, bergabunglah dengan saluran DevOps by REBRAIN .



Jika Anda perlu pindah ke cloud atau memiliki pertanyaan tentang infrastruktur Anda, silakan tinggalkan permintaan .



PS Kami memiliki 2 audit gratis per bulan, mungkin proyek Anda termasuk di antaranya.


More articles:


All Articles