Осваиваем Tarantool 1.6

Евгений Шадрин (Sberbank Digital Ventures)

Отслеживая новости последних нескольких лет, можно заметить, что новые NoSQL-решения, какие-то релизы появляются чуть ли не каждые две недели. Конечно, многие из них не выживают, проигрывают конкуренцию, пропадают, но мир NoSQL пополняется новыми решениями очень часто.

На конференции есть как люди, которые никогда в жизни не использовали NoSQL, так и люди, которые больше пяти лет используют NoSQL в своих проектах, компаниях. Некоторые даже участвуют в open-source проектах. Их немного, но такие тоже есть.

Меня зовут Евгений. Я работаю в небольшом подразделении Сбербанка Digital Ventures, которое занимается внедрением инновационных продуктов и решений, т.е. мы делаем IT-прототипы на стыке новых технологий.

В этом докладе я хочу рассказать про свой кейс использования NoSQL-решения со стороны пользователя, поэтому в начале хотелось бы вкратце пройтись по теории.

Что же такое NoSQL?

Я использую акроним not only SQL, т.е. не только SQL. Это решения, которые содержат в себе модели данных, отличные от реляционных и призванные решать какие-то вопросы; например, вопрос простоты масштабирования. Зачастую за счет того, что в NoSQL-решениях для хранения и работы с данными не нужно задавать конкретные схемы, сущности и много конфигураций, очень легко и просто решать вопрос масштабирования, развертывать большие кластеры с большим количеством узлов, добавлять и удалять эти узлы. Также NoSQL-решения зачастую весьма специализированы, т.е. каждая команда разработчиков не всегда старается сделать большой универсальный проект, а пытается решить какую-то задачу. Такая специализация решений позволяет добиться весьма высоких показателей производительности в конкретных задачах. И в таких задачах использовать NoSQL-решения может быть удобно и просто.

Тут я привел наиболее популярные базы данных в порядке классификации. Вы слышали про key-value хранилища Redis и Riak — они используют модель «ключ-значение» для хранения данных. Документоориентированная база данных MongoDB весьма распространена и известна. Документоориентированная модель чуть более сложная, чем модель «ключ-значение» и позволяет хранить весьма большую иерархическую информацию. Далее идут табличные, матричные базы данных — например, Apache HBase. В них можно работать с большим количеством распределенной информации. Отдельно стоит OrientDB — база данных, которая поддерживает мультипарадигмы, но я привел ее в качестве примера баз данных, поддерживающих графовую модель. У графовой модели есть преимущество: очень удобно прослеживать связи между данными, что бывает неплохо при работе с проектами-аналогами соцсетей.

Как же из всего этого разнообразия выбрать то решение, которое подходит именно вам? Я пользуюсь следующими принципами:

• Не стоит изобретать велосипед. Я встречал команды разработчиков, которые рвались в бой, говоря, что сейчас они быстро напишут свое небольшое хранилище, которое подходит именно им, которое хранит те типы данных, которые им нужны. Все оказывается не так просто. Вот база данных Tarantool разрабатывается больше четырех лет командой профессиональных разработчиков, и постоянно возникают какие-то вопросы, которые стоит решать, решать и решать. Многие NoSQL-решения старше десяти лет. Поэтому правильно выбирать нужное вам решение, исходя из вашей конкретной задачи.
• Большинство баз данных призваны решать какую-то проблему. Если вы поймете, какую проблему решаете, вы, скорее всего, сможете подобрать нужное решение.
• Надеюсь, пункт «опирайтесь на опыт других» понятен. В мире Интернета не так сложно залезть, погуглить, почитать книги, в конце концов, внаглую взять и написать разработчикам и сказать: «У меня есть такой кейс. Скажите, пожалуйста, как вы посоветуете его решить?». Многие разработчики весьма отзывчивы и помогают.
• Если вам повезло и для вашей задачи существует несколько решений, то не стоит очень долго углубляться в сравнение производительности, построение тестовых стендов, понимание того, что же лучше — А или Б. Выберите то, что знаете. Сэкономьте время на изучение, на разборку продукта. Если знаете вы — хорошо, если знает ваш коллега — тоже неплохо, всегда можно к нему обратиться.

И краткое перечисление тех кейсов, которые решает NoSQL.

С большинством из них я сталкивался лично.

• «Кэширование» данных — всем известная база данных Memcached. Сюда можно добавить хранение промежуточных данных, т.е. это те данные, к которым мы хотим получить доступ быстро, сейчас, в нужный момент.
• «Работа с большими объемами данных», наверное, не совсем корректно звучит, потому что реляционные базы данных тоже работают с большими, огромными потоками данных… Я имел в виду именно слово «потоки», т.е., например, нам льются откуда-то запросы серверов, и мы хотим их быстро сохранить, а потом разбираться, что с ними делать дальше. Эту задачу, например, неплохо решает HBase в рамках продукта Hadoop.
• Сервисы очередей. NoSQL может выступать как часть сервиса очередей. К примеру, связка RabbitMQ и Redis пару раз встречалась на моей практике — простой и удобный бэкенд в виде NoSQL.
• Отдельно я вынес платформы для статистической обработки данных. Это когда мы получаем данные и не хотим хранить их все: у нас нет памяти, у нас ограниченные ресурсы. Мы можем эти данные сразу же обрабатывать. Например, получаем какие-то признаки пользователей, ненужные признаки можем выкидывать, остальные нормализовывать и просто хранить их в виде векторов «ключ-значение», к примеру, в Redis.
• Еще можно использовать NoSQL в качестве небольшого удобного бэкенда для хранения, т.е. просто взяли и сохранили. MongoDB — достаточно быстро и удобно развертываемая база данных, которая подходит для этого кейса.

Кейсов, конечно, намного больше, но я рассказал о тех, с которыми сталкивался. Вообще, в Sberbank Digital Ventures я занимаюсь разработкой систем, которые работают в режиме реального времени и основное предназначение которых — получить информацию с сервера, сохранить ее, обработать, понять, что она из себя представляет, и выдать серверу нужный ответ.

К примеру, я получаю нужную информацию о пользователе, который ходит где-то в недрах Интернета. Я получаю все данные, которые смог собрать, анализирую их и могу сегментировать пользователя, отнести его к той или иной категории, т.е. узнать, что, скажем, это молодой человек 25 лет, который интересуется автомобилями, или это молодая девушка 18 лет, которая хочет поступить в университет и ищет, где возьмут взятку за поступление.

Для решения своей задачи я использую NoSQL базу данных Tarantool. В дальнейшем я расскажу, почему и для чего ее использую и как она помогает решать задачи, которые передо мной возникают.

На слайде — цитата с главной страницы сайта разработчиков, это их позиционирование проекта. «A NoSQL database running in a Lua application server», т.е. сами разработчики позиционируют Tarantool как проект, который состоит из двух частей: 1-ая часть — это нереляционная база данных, 2-ая часть — это Lua application server, т.е. сервер приложений с использованием языка Lua.

Кстати, обратите внимание, что большинство современных значков NoSQL баз данных используют серый и красный цвета. Наверное, это в тренде =)

Дальше я буду приводить вам примеры кода. Если у кого-то есть возможность, можете пройти по ссылке на сервер try.tarantool.org — это интерактивный сервис, где сразу можно использовать Tarantool, т.е. это некий интерактивный Tarantool, который выделяется под вас на серверах разработчиков. Возможно, кто-то захочет примеры кода сразу туда вбить.

Что же выделяет Tarantool из большого стека NoSQL-технологий?

Tarantool хранит все свои данные в памяти, благодаря чему мы получаем к ним быстрый доступ. То, что Tarantool хранит их в памяти, не значит, что это небезопасно и данные мы можем потерять. В Tarantool есть механизмы сохранения данных: логи журналов и бинарные снимки состояний. Эти два механизма работают вместе: у нас есть точки с сохраненными данными и описания действий, которые делались до или после с этими данными. Имея такую информацию, мы всегда можем прийти в нужное состояние.

В свое время хранение данных в памяти приводило к тому, что эта память очень быстро заканчивалась. Она заканчивается и сейчас, но все-таки объемы оперативной памяти постоянно растут, и похожие базы данных получают более широкий спектр применения. Tarantool использует документоориентированную модель данных, т.е. все данные он хранит в некой абстракции, называемой документ. У документа есть свои поля, с которыми Tarantool и работает.

Одна из особенностей Tarantool как базы данных — это наличие вторичных индексов. Наличие вторичных индексов позволяет сделать действия с данными более живыми, интересными и быстрыми.

Я пока не использовал транзакции в своих проектах, но Tarantool поддерживает полноценные транзакции. Насколько я знаю, в некоторых компаниях — Mail.Ru Group, Avito — успешно используют их для решения своих кейсов. В Tarantool есть модель легковесных потоков, или green threads. Это многопоточная модель, только потоки создаются не на уровне Unix, а внутри самого приложения, что позволяет реализовывать какие-то асинхронные вещи, событийные модели.

Также Tarantool работает с сетью и файлами: у него есть свой HTTP-сервер, свои библиотеки, которые сохраняют и открывают файлы; это тоже пригодилось мне при решении задач.

Tarantool — это Lua application server, а Lua — это встраиваемый язык Tarantool. Здесь я привел пример очень искусственного, абсолютно не используемого на практике скрипта для того, чтобы показать, что такое Lua:

#!/usr/bin/tarantool
-- This is lua script

function hw(a, b)
    print (a.hello..b.world)
end

b = {}
a = { hello = 'Hello ' }

b['world'] = 'world!'

hw(a, b)

Язык Lua был разработан в Бразилии, в католическом университете; он произошел от языка SOL, который работает именно с данными и был заточен под работу с базами данных. Здесь мы можем видеть, что это не просто скрипт, а исполняемый скрипт. Решеточка и восклицательный знак — это механизм, который позволяет нам задать, кто и как должен запускать этот скрипт. Введя в консоли tarantool script.lua, мы получим на экране hello world. Здесь мы видим функцию, которая работает с двумя объектами, и ниже инициализируем сами эти объекты.

Основная структура данных Lua — это таблицы. Объекты a и b — это таблицы, и я специально инициализировал их по-разному, чтобы показать, что язык Lua очень гибкий и синтакcически приятный. Эти таблицы могут содержать внутри себя другие данные — например, такие же таблицы, которые, в свою очередь, могут содержать в себе другие таблицы. Иногда по неопытности составлялись очень большие вложенности. Функции тоже могут храниться внутри таблицы. Вообще, с объектом «функции» тоже можно работать как с таблицей — для этого есть свои методы.

Дальше я приведу пример более практичного скрипта, который можно дорабатывать и использовать в каком-то вашем продакшне. Он решает маленькую задачку, и решает весьма тривиально: считает количество уникальных посетителей на страничке.

#!/usr/bin/tarantool
-- Tarantool init script

local log = require('log')
local console = require('console')
local server = require('http.server')

local HOST = 'localhost'
local PORT = 8008

box.cfg {
    log_level = 5,
    slab_alloc_arena = 1,
}
console.listen('127.0.0.1:33013')

if not box.space.users then
        s = box.schema.space.create('users')
        s:create_index('primary',
             {type = 'tree', parts = {1, 'NUM'}})
end

function handler(self)
    local id = self:cookie('tarantool_id')
    local ip = self.peer.host
    local data = ''
    log.info('Users id = %s', id)
    if not id then
        data = 'Welcome to tarantool server!'
        box.space.users:auto_increment({ip})
        id = box.space.users:len()
        return self:render({ text = data}):
               setcookie({ name = 'tarantool_id', value = id, expires = '+1y' })
    else
        local count = box.space.users:len()
        data = 'You id is ' .. id .. '. We have ' .. count .. ' users'
        return self:render({ text = data })
    end
end

httpd = server.new(HOST, PORT)
httpd:route({ path = '/' }, handler)
httpd:start()

Это так называемый исполняемый Lua-скрипт, который будет запускаться в Tarantool и выполнять ту последовательность действий, которая в нем заложена.

Вкратце пройдем по блокам того, что здесь есть, а потом разберем детали.

Вверху я подключаю те пакеты, которые мне понадобятся, через луашный механизм require: log, console, server. Определяю какие-то константы, которые использую.

Дальше идет конфигурирование базы данных Tarantool с помощью модуля box.cfg, где я задаю два необходимых мне параметра. Я запускаю консоль и создаю сущности нашей базы данных с помощью box.schema.space.create('users') — т.е. я создал пространство users. Обо всем этом расскажу чуть позже.

Вторая часть скрипта — это работа с сервером Tarantool: я описываю функцию handler (обработчик запросов), а внизу создаю сервер, создаю route для обработки и стартую этот сервер.

Со стороны пользователя результат выполнения этого скрипта выглядит примерно так:

Пользователь зашел, например, на localhost и увидел приветственное сообщение. В дальнейшем, если он будет обновлять страницу, у него уже будет ссылка на cookie, ему будет присвоен какой-то id, и он будет знать количество уникальных пользователей, которое заходит на эту страничку.

Этот небольшой скрипт решает какую-то нужную мне задачу — это ответ на вопрос, почему мы используем язык Lua.

Язык Lua весьма простой. Существуют целые наборы статей «Lua за 15 минут», «за 30 минут»… Вам действительно нужно немного, чтобы познакомиться с этим интересным языком. За пару часов вы узнаете все его особенности.

Очень удобно, что основная структура данных — это таблицы. Это позволяет единообразно работать со всеми остальными данными.

Сам по себе стандартный интерпретатор Lua не очень быстрый, вернее — совсем небыстрый, но существует аналогичный интерпретатор LuaJIT, который делает JIT-компиляцию, и он намного быстрее. Именно он делает Lua очень производительным языком.

Есть такая библиотечка luafun, которая позволяет программировать на Lua в функциональном стиле. Благодаря LuaJIT эта библиотечка работает очень быстро. Вы можете погуглить, почитать про нее, посмотреть отзывы о ее производительности — очень интересно.

Также Lua — очень хорошо встраиваемый язык, у него прекрасная интеграция с языком С. Благодаря тому, что сишные процедуры можно запустить внутри Lua, а Lua можно запустить внутри языка С, Lua очень широко применяется в геймдеве. Довольно много расширений, квестов и различной игровой механики и логики в известной игре World of Warcraft написано и до сих пор пишется на Lua.

Tarantool — это полноценный Lua-интерпретатор, т.е. если вы просто запустите Tarantool, вы можете банально работать с Lua.

Tarantool можно запустить в двух сущностях:

• Первая — как интерпретатор, т.е. запустить Tarantool и построчно выполнять какие-то команды. Это бывает полезно, если вы что-то не знаете или хотите выполнить какую-то команду из документации.
• Вторая — с помощью стартового скрипта init.lua (называть его можно как угодно), в котором записана последовательность команд.

Разберем более подробно приведенный выше пример стартового скрипта init.lua.

Начинается работа с базой с ее конфигурирования, т.е. механизм box.cfg — это пакет box, который внутри себя содержит табличку cfg, и я могу задавать какие-то ее параметры. Box — это ящик, коробка. Этот пакет отвечает непосредственно за базу данных. Вы можете просто так запустить Tarantool, выполнить процедуры, функции, написать какие-то сообщения и т.д., но без конфигурирования box.cfg базу данных вы не запустите. В данном случае я задал два параметра, которые мне хотелось бы видеть. Во-первых, я задал уровень логов, которые будут печататься — это пятый уровень, DEBUG. Еще я задал очень важный параметр slab_alloc_arena — это та память, которая выделяется в Tarantool — точнее, в оперативной памяти — под аллоцирование и размещение данных. В данном случае «1» — это 1 Гб.

Также пакет box содержит много других вспомогательных вещей и средств, таких как:

• box.info — библиотечка, которая выводит общую информацию о Tarantool.
• box.slab — важная табличка, с помощью которой мы мониторим данные нашего Tarantool и смотрим, сколько у нас места осталось.
• box.stat — библиотечка статистики, показывает количество insert, select и других операций, которые вы совершили.

Если в интерпретаторе Tarantool после задания параметров набрать box.cfg, то вы получите объект с описанием всех параметров, которые есть, — не только тех, которые задал я, но и тех, которые задаются по умолчанию.

Здесь мы видим, что я задал slab_alloc_arena — пространство для аллокации в 1 Гб, видим log_level пятого уровня (DEBUG), также видим важный параметр snapshot_count — это количество снимков состояния, которое Tarantool будет хранить. В данном случае он будет хранить последние 6 снимков, которые делались за определенный период. Кстати, этот период тоже задается здесь с помощью параметра snapshot_period; по умолчанию его значение — 3600 секунд, т.е. Tarantool будет делать снимок состояния раз в час. Вы сами можете выбирать необходимый уровень безопасности, можно делать снимок хоть каждую секунду или минуту, но это будет очень сильно отнимать ваши ресурсы. Параметры snap_dir и wal_dir определяют, где вы храните свои снимки состояния и логи, соответственно.

Вот пример пакета box.info. Здесь можно посмотреть информацию о Tarantool, т.е. если Tarantool запущен как демон, вы можете узнать его pid, версию (на данный момент актуальна версия 1.6.5), время беспрерывной работы и статус, в котором находится ваша машинка.

После того, как вы сконфигурировали данные, можно переходить к созданию самих сущностей, самих данных внутри Tarantool.

Здесь я привел картинку из документации. Это изображение модели данных Tarantool, т.е. в Tarantool данные хранятся в спейсах, в каждом спейсе есть сущность tuple — это записи и индексы, которые вы задаете, первичные или вторичные.

Покончив с конфигурированием, переходим к заполнению базы данных, т.е. мне нужно пространство, в котором я буду задавать информацию о пользователях.

Вы можете заметить, что я поместил эту информацию в условную конструкцию. Сделано это с определенной целью: если по какой-то причине ваш Tarantool был остановлен и вы запускаете его заново при сохраненных снимках и икслогах, он, прежде чем запуститься, восстанавливает свое состояние, т.е. берет снимок состояния и проделывает действие из xlog. Если вы запустили так, он не даст вам создать нужное пространство users, но оно скорее всего вам и не надо, поэтому очень часто вставляем такую проверку для того, чтобы не получить ошибку. Если у нас такого пространства не создано, то мы создаем спейс и индекс к нему. В данном случае это primary — первичный индекс в виде деревьев, который представляет собой одно число.

В дальнейшем в скрипте мне необходимо добавлять новые записи о пользователях. Можно это делать с помощью стандартной операции insert, где мы передаем пару «ключ-значение», но в моем случае в этом простом скрипте удобно это сделать с помощью auto_increment. Пользователь будет заходить, и ему автоматически будет присваиваться ключ на единицу больше, чем количество записей в базе на данный момент. Если я хочу узнать количество записей в своей базе, я могу воспользоваться стандартным механизмом len(). Как видите, синтаксис весьма прост и понятен.

Как уже говорилось выше, Tarantool — это не просто база данных, а полноценный Lua application server. Вероятно, разработчики здесь подразумевали то, что на языке Lua вы можете писать любые модули и пакеты и тем самым реализовывать необходимую вам логику. По сути, вы не изобретаете большой велосипед — вы можете изобрести несколько маленьких, если вам очень нужно или этого нет в других решениях.

Посмотреть все это вы можете в репозиториях на GitHub. Основные модули, которые так или иначе используются, — это http и queue. К примеру, try.tarantool.org написан полностью на Tarantool, там используется Tarantool-хранилище, Tarantool-сервер. Также Tarantool поддерживает LuaRocks, пакетный менеджер, который работает со своим репозиторием и через который очень удобно устанавливать пакеты. Это делается одной командой.

Пакеты. Пакеты нужно подключить.

Под пакетом подразумевается какой-то другой Lua-скрипт, реализующий какую-то логику. Подключив этот пакет, вы можете получить методы из этого файла, какие-то данные из этого файла, какие-то переменные. На этом примере я подключаю с помощью луашного механизма require два пакета — console и log.

console я запускаю на localhost и вешаю на порт 33013. С помощью пакета log я могу делать записи в журнал логов. Под консолью здесь подразумевается консоль администратора или удаленная консоль управления, которая позволяет вам следить за состоянием Tarantool. Сделать это несложно: если у вас консоль запущена, подойдут стандартные средства Unix или еще какие-нибудь, например, telnet и rlwrap. telnet нужен для подключения на порт и его прослушки, a rlwrap для удобного ввода команд и сохранения истории команд.

Вы можете зайти на тот Tarantool, который у вас работает, и посмотреть какую-то информацию из box.info или box.stat.

Пакет, который я использую и который весьма часто необходим, — http. Это пока еще ограниченный HTTP-сервер, но работающий со многими нужными механизмами. В данном случае я подключил пакет, создал сервер, повесил route для обработки, запустил его. А потом в функции handler я вернул ответ серверу в виде текстовой информации и установил cookie пользователю — tarantool_id, value = id. Также задал время экспирации, т.е. время удаления; здесь cookie хранятся год.

Основные механизмы пакета http позволяют реализовывать минимальную логику, т.е. здесь есть весьма полноценный сервер, есть клиент. Этот пакет работает с cookie и поддерживает Lua как некий встраиваемый язык каких-нибудь переменных внутри Template, т.е. мы можем на Lua писать маленькие процедурки внутри HTML.

#!/usr/bin/tarantool
-- Tarantool init script

local log = require('log')
local console = require('console')
local server = require('http.server')

local HOST = 'localhost'
local PORT = 8008

box.cfg {
    log_level = 5,
    slab_alloc_arena = 1,
}
console.listen('127.0.0.1:33013')

if not box.space.users then
        s = box.schema.space.create('users')
        s:create_index('primary',
             {type = 'tree', parts = {1, 'NUM'}})
end

Я постарался рассказать основные моменты этого скрипта, поэтому вам должно быть уже более понятно. Чтобы закрепить, можно и еще раз пройтись. У нас исполняемый скрипт Tarantool с комментарием. Дальше у нас происходит подключение пакетов через require. У нас есть две переменные — HOST и PORT. Дальше происходит конфигурирование Tarantool через box.cfg, и я задаю два параметра: log_level (уровень журналирования) и slab_alloc_arena (пространство для аллокаций).

Я создаю консоль администратора, которой буду пользоваться. Дальше, если у меня нет нужного спейса, я создаю спейс users с помощью box.schema.space.create и создаю к нему индекс.

function handler(self)
    local id = self:cookie('tarantool_id')
    local ip = self.peer.host
    local data = ''
    log.info('Users id = %s', id)
    if not id then
        data = 'Welcome to tarantool server!'
        box.space.users:auto_increment({ip})
        id = box.space.users:len()
        return self:render({ text = data}):
               setcookie({ name = 'tarantool_id', value = id, expires = '+1y' })
    else
        local count = box.space.users:len()
        data = 'You id is ' .. id .. '. We have ' .. count .. ' users'
        return self:render({ text = data })
    end
end

httpd = server.new(HOST, PORT)
httpd:route({ path = '/' }, handler)
httpd:start()

В функции обработки я получаю cookie, которые содержатся у пользователя, который зашел на мою страницу. Я смотрю его IP, делаю запись в лог. Если id нет в tarantool_id, тогда я заношу автоинкрементом информацию об IP этого пользователя в базу, смотрю его id и возвращаю приветственную информацию data и присваиваю cookie значение id. В противном случае я считаю количество записей у нас в таблицах и возвращаю пользователю просто количество уникальных посетителей. И в конце, когда я описал функцию, я запускаю сам сервер и уже с ним работаю.

Это несложный пример, но благодаря модулям и расширяемости доступа языка Lua его можно дописывать, дописывать, дописывать и через какое-то время довести до такого состояния, которое используется в реальных проектах.

У Tarantool очень много разных пакетов. Есть пакет для работы с JSON, есть пакет fiber (я ниже расскажу о нем чуть подробнее), yaml, криптографическая библиотека digest (содержит основные необходимые механизмы шифрования). Есть свой пакет неблокирующих сокетов, и вы можете сами работать по сети, реализовывать какие-то протоколы. Есть работа с MessagePack, есть библиотечка fio (file input/output) для работы с файлами. И есть интересный механизм net.box, который позволяет Tarantool работать по бинарному протоколу — например, с другим Tarantool; получается очень быстро и удобно. Также реализован net.box.sql для работы с какой-нибудь реляционной SQL базой данных.

Файберы — это так называемые легкие потоки, которые работают по модели green threads. Основное отличие их от стандартных потоков в том, что они создаются и работают внутри Tarantool, поэтому создаются они достаточно быстро и имеют неплохую производительность переключения. Они могут пригодиться вам, если вы реализуете какую-то асинхронную модель или вам нужно, чтобы был запущен какой-то демон, выполняющий параллельно основной логике еще что-то.

Основные принципы работы с файбером: файбер нужно создать, файбер можно поставить в режим ожидания с помощью fiber.sleep, и fiber_object — это есть fiber.create, вы всегда можете его кансельнуть и завершить работу с ним.

Очень удобная библиотечка fiber.time, которая из событийного цикла, считающего время, всегда может вывести нам нужное значение.

С помощью библиотечки fiber написана очень популярная библиотека expirationd, которая может производить удаление из базы по каким-то признакам; обычно это время, т.е. все, что хранится, скажем, месяц, может удаляться и очищаться.

Про Tarantool можно говорить долго, мы тоже не знаем всего. Не знаю, знают ли сами разработчики все о нем. Всегда можно почитать документацию на tarantool.org, в последнее время она поменялась и стала более читабельной.

Tarantool поддерживает большинство Unix-подобных систем, у них есть свой Buildbot, и мы всегда следим за появлением новых пакетов — мы работаем на Red Hat Enterprise Linux. Также разработчики Tarantool официально поддерживают пакет Tarantool в том же Debian.

И очень важный пункт, который мне нравится: в Tarantool возможна связь с разработчиками. У меня были вопросы, я нашел разработчиков в Skype. Костя Осипов, главный разработчик Tarantool, читал на этой конференции небольшой доклад про очереди. Разработчикам, особенно начинающим, очень важно обратиться за советом и узнать из первых уст, как делать то или иное. Надо быть готовым, что ребята, которые разрабатывают open-source приложения, весьма своеобразны, там весьма своеобразное комьюнити. Возможно, эта картинка сможет сказать больше, чем смог бы я:

Но в то же время общение в комьюнити может быть очень интересным опытом, который позволит вам расти самому и делать свои проекты немного лучше.

В конце хотел бы подвести итоги по докладу.

У каждого NoSQL-решения есть своя сфера применения. Зачастую очень сложно сказать, какая база лучше или хуже, какая производительнее. Они действительно часто решают разные задачи.

Инструмент разработки — это очень важно: правильно подобранный инструмент позволяет вам разрабатывать быстро и легко и избежать массы проблем. Но не стоит забывать, что важнее идея, цель; все-таки задача каждого разработчика — это решать проблему, реализовывать какие-то свои идеи и делать этот мир немножко лучше.

Надеюсь, я смог показать вам, что Tarantool совсем несложный и вы тоже можете попробовать использовать его. Спасибо за внимание.

Этот доклад — расшифровка одного из лучших выступлений на обучающей конференции разработчиков высоконагруженных систем HighLoad++ Junior.

Также некоторые из этих материалов используются нами в обучающем онлайн-курсе по разработке высоконагруженных систем HighLoad.Guide — это цепочка специально подобранных писем, статей, материалов, видео. Уже сейчас в нашем учебнике более 30 уникальных материалов. Подключайтесь!

Ну и главная новость — мы начали подготовку весеннего фестиваля "Российские интернет-технологии", в который входит восемь конференций, включая HighLoad++ Junior.

Let's block ads! (Why?)