Как установить MemSQL на Ubuntu 14.04

Написано в сотрудничестве с MemSQL

Вступление

MemSQL - это тип базы данных в памяти, который может выполнять чтение и запись быстрее, чем традиционная база данных. Несмотря на то, что это новая технология, она говорит по протоколу MySQL, поэтому с ней приятно работать.

MemSQL объединила новейшие возможности MySQL с современными функциями, такими как поддержка JSON и возможность переноса данных. Одним из величайших преимуществ MemSQL по сравнению с MySQL является его способность разбивать один запрос на несколько узлов, известный как massively параллельная обработка, что приводит к гораздо более быстрым запросам на чтение.

В этом руководстве мы установим MemSQL на одном сервере Ubuntu 14.04, запустим тесты производительности и поиграем со вставкой данных JSON через клиент MySQL из командной строки.

Предпосылки

Чтобы следовать этому уроку, вам понадобится:

Одна капля Ubuntu 14.04 x64 с оперативной памятью не менее 8 ГБ
Пользователь без полномочий root с привилегиями sudo, который вы можете настроить, следуя Initial Server Setup с Ubuntu 14.04 учебник

Шаг 1 - Установка MemSQL

В этом разделе мы подготовим нашу рабочую среду для установки MemSQL.

Последняя версия MemSQL указана на странице загрузки their. Мы будем загружать и устанавливать MemSQL Ops, программу, которая управляет загрузкой и подготовкой вашего сервера к корректной работе MemSQL. Самая последняя версия MemSQL Ops на момент написания этой статьи - 4.0.35.

Сначала загрузите файл установочного пакета MemSQL с их веб-сайта.

wget http://download.memsql.com/memsql-ops-4.0.35/memsql-ops-4.0.35.tar.gz

Далее извлеките пакет.

tar -xzf memsql-ops-4.0.35.tar.gz

Извлечение пакета создало папку с именем + memsql-ops-4.0.35 +. Обратите внимание, что имя папки имеет номер версии, поэтому, если вы загрузите более новую версию, чем указана в этом руководстве, у вас будет папка с версией, которую вы скачали.

Поменяйте каталоги в эту папку.

cd memsql-ops-4.0.35

Затем запустите сценарий установки, который является частью только что извлеченного установочного пакета.

sudo ./install.sh

Вы увидите некоторые результаты из сценария. Через некоторое время он спросит вас, хотите ли вы установить MemSQL только на этот хост. Мы рассмотрим установку MemSQL на нескольких машинах в следующем руководстве. Итак, для целей данного руководства давайте скажем «да», введя * y *.

Запрос и вывод сценария установки

. . .
Do you want to install MemSQL on this host only? [y/N]

2015-09-04 14:30:38: Jd0af3b [INFO] Deploying MemSQL to 45.55.146.81:3306
2015-09-04 14:30:38: J4e047f [INFO] Deploying MemSQL to 45.55.146.81:3307
2015-09-04 14:30:48: J4e047f [INFO] Downloading MemSQL: 100.00%
2015-09-04 14:30:48: J4e047f [INFO] Installing MemSQL
2015-09-04 14:30:49: Jd0af3b [INFO] Downloading MemSQL: 100.00%
2015-09-04 14:30:49: Jd0af3b [INFO] Installing MemSQL
2015-09-04 14:31:01: J4e047f [INFO] Finishing MemSQL Install
2015-09-04 14:31:03: Jd0af3b [INFO] Finishing MemSQL Install
Waiting for MemSQL to start...

Теперь у вас есть кластер MemSQL, развернутый на вашем сервере Ubuntu! Однако из приведенных выше журналов вы заметите, что MemSQL был установлен дважды.

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

Aggregator node это ваш интерфейс к MemSQL. Для внешнего мира он очень похож на MySQL: он прослушивает один и тот же порт, и вы можете подключить к нему инструменты, которые ожидают соединения с MySQL и стандартными библиотеками MySQL. Работа агрегатора заключается в том, чтобы знать обо всех конечных узлах MemSQL, обрабатывать клиенты MySQL и переводить их запросы в MemSQL.

Leaf node на самом деле хранит данные. Когда конечный узел получает запрос от узла-агрегатора на чтение или запись данных, он выполняет этот запрос и возвращает результаты узлу-агрегатору. MemSQL позволяет вам обмениваться данными между несколькими хостами, и каждый конечный узел имеет часть этих данных. (Даже с одним конечным узлом ваши данные разделяются внутри этого конечного узла.)

Когда у вас есть несколько конечных узлов, агрегатор отвечает за перевод запросов MySQL ко всем конечным узлам, которые должны быть задействованы в этом запросе. Затем он принимает ответы от всех конечных узлов и объединяет результат в один запрос, который возвращается вашему клиенту MySQL. Вот как параллельные запросы управляются.

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

Шаг 2 - Запуск теста

Давайте посмотрим, как быстро может работать MemSQL, используя инструмент MemSQL Ops, который был установлен как часть установочного скрипта MemSQL.

В вашем веб-браузере перейдите к + http: //: 9000 +

Изображение: HTTPS: //assets.digitalocean.com/articles/memsql/img1.png [IMG]

Инструмент MemSQL Ops дает вам обзор вашего кластера. У нас есть 2 узла MemSQL: главный агрегатор и конечный узел.

Давайте возьмем тест скорости на нашем узле MemSQL с одной машиной. Нажмите * Speed Test * в меню слева, затем нажмите * START TEST *. Вот пример результатов, которые вы можете увидеть:

изображение: https: //assets.digitalocean.com/articles/memsql/img2.png [Результаты теста скорости]

В этом руководстве мы не расскажем, как установить MemSQL на несколько серверов, но для сравнения приведем сравнительный анализ кластера MemSQL с тремя 8-гигабайтными узлами Ubuntu 14.04 (один агрегатор и два конечных узла):

Изображение: HTTPS: //assets.digitalocean.com/articles/memsql/img3.png [IMG]

Удвоив число листовых узлов, мы смогли почти удвоить нашу скорость вставки. Изучив разделы * Rows Read *, мы увидим, что наш кластер из трех узлов мог одновременно читать на 12 миллионов строк больше, чем кластер из одного узла за то же время.

Шаг 3 - Взаимодействие с MemSQL через mysql-клиент

Для клиентов MemSQL выглядит как MySQL; они оба говорят по одному протоколу. Чтобы начать общаться с нашим кластером MemSQL, давайте установим mysql-клиент.

Сначала обновите apt, чтобы на следующем шаге мы установили последнюю версию клиента.

sudo apt-get update

Теперь установите клиент MySQL. Это даст нам команду + mysql для выполнения.

sudo apt-get install mysql-client-core-5.6

Теперь мы готовы подключиться к MemSQL с помощью клиента MySQL. Мы собираемся подключиться как пользователь * root * к хосту + 127.0.0.1 + (который является нашим локальным IP-адресом) на порту 3306. Мы также настроим подсказку на + memsql> +.

mysql -u root -h 127.0.0.1 -P 3306 --prompt="memsql> "

Вы увидите несколько строк вывода, сопровождаемых подсказкой + memsql> +.

Давайте перечислим базы данных.

show databases;

Вы увидите этот вывод.

Вывод базы данных

+--------------------+
| Database           |
+--------------------+
| information_schema |
| memsql             |
| sharding           |
+--------------------+
3 rows in set (0.01 sec)

Создайте новую базу данных под названием * tutorial *.

create database tutorial;

Затем переключитесь на использование новой базы данных с помощью команды + use +.

use tutorial;

Далее мы создадим таблицу + user in, которая будет иметь поля` + id из и поля + + email +. Мы должны указать тип для этих двух полей. Давайте сделаем id и отправим по электронной почте varchar длиной 255. Мы также сообщим базе данных, что поле `+ id + является первичным ключом, а поле + email + не может быть пустым.

create table users (id bigint auto_increment primary key, email varchar(255) not null);

Вы можете заметить плохое время выполнения этой последней команды (15 - 20 секунд). Существует одна главная причина, почему MemSQL не спешит создавать эту новую таблицу: генерация кода.

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

Вернуться к нашей таблице пользователей, взгляните на определение таблицы.

describe users;

Вывод определения таблицы

+-------+--------------+------+------+---------+----------------+
| Field | Type         | Null | Key  | Default | Extra          |
+-------+--------------+------+------+---------+----------------+
| id    | bigint(20)   | NO   | PRI  | NULL    | auto_increment |
| email | varchar(255) | NO   |      | NULL    |                |
+-------+--------------+------+------+---------+----------------+
2 rows in set (0.00 sec)

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

insert into users (email) values ('[email protected]'), ('[email protected]'), ('[email protected]');

Вставка вывода электронной почты

Query OK, 3 rows affected (1.57 sec)
Records: 3  Duplicates: 0  Warnings: 0

Теперь запросите таблицу пользователей.

select * from users;

Вы можете увидеть данные, которые мы только что ввели:

Вывод таблицы пользователей

+----+-------------------+
| id | email             |
+----+-------------------+
|  2 | [email protected]   |
|  1 | [email protected]   |
|  3 | [email protected] |
+----+-------------------+
3 rows in set (0.07 sec)

Шаг 4 - Вставка и запрос JSON

MemSQL предоставляет тип JSON, поэтому на этом шаге мы создадим таблицу событий, чтобы использовать входящие события. Эта таблица будет иметь поле + id (как мы сделали для пользователей) и поле` + event on`, которое будет иметь тип JSON.

create table events (id bigint auto_increment primary key, event json not null);

Давайте вставим пару событий. В JSON мы будем ссылаться на поле + email +, которое, в свою очередь, ссылается на идентификаторы пользователей, которые мы вставили на шаге 3.

insert into events (event) values ('{"name": "sent email", "email": "[email protected]"}'), ('{"name": "received email", "email": "[email protected]"}');

Теперь мы можем взглянуть на события, которые мы только что вставили.

select * from events;

Вывод таблицы событий

+----+-----------------------------------------------------+
| id | event                                               |
+----+-----------------------------------------------------+
|  2 | {"email":"[email protected]","name":"received email"} |
|  1 | {"email":"[email protected]","name":"sent email"}     |
+----+-----------------------------------------------------+
2 rows in set (3.46 sec)

Затем мы можем запросить все события, для которых свойство JSON + name + является текстом «получено по электронной почте».

select * from events where event::$name = 'received email';

Вывод запроса «получено по электронной почте»

+----+-----------------------------------------------------+
| id | event                                               |
+----+-----------------------------------------------------+
|  2 | {"email":"[email protected]","name":"received email"} |
+----+-----------------------------------------------------+
1 row in set (5.84 sec)

Попробуйте изменить этот запрос, чтобы найти тех, чьим свойством + name + является текст «отправленное электронное письмо».

select * from events where event::$name = 'sent email';

Вывод запроса «отправлено по электронной почте»

+----+-------------------------------------------------+
| id | event                                           |
+----+-------------------------------------------------+
|  1 | {"email":"[email protected]","name":"sent email"} |
+----+-------------------------------------------------+
1 row in set (0.00 sec)

Этот последний запрос выполнялся намного быстрее, чем предыдущий. Это потому, что мы изменили только параметр в запросе, поэтому MemSQL смогла пропустить генерацию кода.

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

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

select * from users left join events on users.email = events.event::$email where events.event::$name = 'received email';

Вывод полей «полученное письмо»

+----+-----------------+------+-----------------------------------------------------+
| id | email           | id   | event                                               |
+----+-----------------+------+-----------------------------------------------------+
|  2 | [email protected] |    2 | {"email":"[email protected]","name":"received email"} |
+----+-----------------+------+-----------------------------------------------------+
1 row in set (14.19 sec)

Затем попробуйте тот же запрос, но отфильтруйте только события «отправлено по электронной почте».

select * from users left join events on users.email = events.event::$email where events.event::$name = 'sent email';

Вывод полей «отправлено по электронной почте»

+----+-----------------+------+-------------------------------------------------+
| id | email           | id   | event                                           |
+----+-----------------+------+-------------------------------------------------+
|  1 | [email protected] |    1 | {"email":"[email protected]","name":"sent email"} |
+----+-----------------+------+-------------------------------------------------+
1 row in set (0.01 sec)

Как и раньше, второй запрос был намного быстрее, чем первый. Как мы видели в тесте, преимущества генерации кода окупаются при выполнении более миллиона строк. Гибкость в использовании масштабируемой базы данных SQL, которая понимает JSON и как произвольно объединять таблицы, является мощной пользовательской функцией.

Заключение

Вы установили MemSQL, запустили тест производительности вашего узла, взаимодействовали с ним через стандартный клиент MySQL и использовали некоторые расширенные функции, которых нет в MySQL. Это должно быть хорошим вкусом того, что может сделать для вас база данных SQL в памяти.

Еще многое предстоит узнать о том, как MemSQL фактически распределяет ваши данные, как структурировать таблицы для максимальной производительности, как расширить MemSQL на несколько узлов, как реплицировать ваши данные для обеспечения высокой доступности и как защитить MemSQL.

TOC