Comment installer MemSQL sur Ubuntu 14.04

Écrit en collaboration avec MemSQL

introduction

MemSQL est un type de base de données en mémoire capable de lire et d’écrire plus rapidement qu’une base de données traditionnelle. Même s’il s’agit d’une nouvelle technologie, il utilise le protocole MySQL, ce qui rend le travail très familier.

MemSQL a adopté les toutes dernières fonctionnalités de MySQL avec des fonctionnalités modernes, telles que la prise en charge de JSON et la possibilité de transférer des données. L’un des principaux avantages de MemSQL par rapport à MySQL réside dans sa capacité à fractionner une requête unique entre plusieurs nœuds, appelée «traitement parallèle massivement», ce qui permet de lire les requêtes beaucoup plus rapidement.

Dans ce didacticiel, nous allons installer MemSQL sur un seul serveur Ubuntu 14.04, exécuter des tests de performances et utiliser l’insertion de données JSON via un client MySQL en ligne de commande.

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin de:

Un droplet Ubuntu 14.04 x64 avec au moins 8 Go de RAM
Un utilisateur non root avec des privilèges sudo, que vous pouvez configurer en suivant les Initial Initial Server avec Ubuntu. 14.04 tutoriel

Étape 1 - Installation de MemSQL

Dans cette section, nous préparerons notre environnement de travail pour l’installation de MemSQL.

La dernière version de MemSQL est disponible sur their leur page de téléchargement. Nous allons télécharger et installer MemSQL Ops, un programme qui gère le téléchargement et prépare votre serveur pour l’exécution correcte de MemSQL. La version la plus récente de MemSQL Ops au moment de la rédaction est 4.0.35.

Tout d’abord, téléchargez le fichier du package d’installation de MemSQL à partir de leur site Web.

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

Ensuite, extrayez le package.

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

L’extraction du paquet a créé un dossier appelé + memsql-ops-4.0.35 +. Notez que le nom du dossier porte le numéro de version. Par conséquent, si vous téléchargez une version plus récente que celle spécifiée dans ce tutoriel, vous aurez un dossier contenant la version que vous avez téléchargée.

Changer les répertoires dans ce dossier.

cd memsql-ops-4.0.35

Ensuite, exécutez le script d’installation, qui fait partie du package d’installation que nous venons d’extraire.

sudo ./install.sh

Vous verrez une sortie du script. Après un moment, il vous sera demandé si vous souhaitez installer MemSQL sur cet hôte uniquement. Nous étudierons l’installation de MemSQL sur plusieurs ordinateurs lors d’un prochain tutoriel. Donc, pour les besoins de ce tutoriel, disons oui en entrant * y *.

Invite et sortie du script d’installation

. . .
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...

Vous avez maintenant un cluster MemSQL déployé sur votre serveur Ubuntu! Cependant, à partir des journaux ci-dessus, vous remarquerez que MemSQL a été installé deux fois.

MemSQL peut fonctionner sous deux rôles différents: un nœud agrégateur et un nœud feuille. La raison pour laquelle MemSQL a été installée deux fois est qu’elle nécessite au moins un nœud agrégateur et au moins un nœud feuille pour l’exploitation d’un cluster.

Aggregator node est votre interface avec MemSQL. Pour le monde extérieur, cela ressemble beaucoup à MySQL: il écoute sur le même port et vous pouvez connecter des outils qui s’attendent à communiquer avec MySQL et aux bibliothèques MySQL standard. Le travail de l’agrégateur consiste à connaître tous les noeuds feuilles MemSQL, à gérer les clients MySQL et à traduire leurs requêtes en MemSQL.

Un leaf node stocke en réalité des données. Lorsque le nœud feuille reçoit une demande du nœud agrégateur pour lire ou écrire des données, il exécute cette requête et renvoie les résultats au nœud agrégateur. MemSQL vous permet de partager vos données sur plusieurs hôtes et chaque nœud feuille en possède une partie. (Même avec un seul nœud feuille, vos données sont divisées dans ce nœud feuille.)

Lorsque vous avez plusieurs nœuds terminaux, l’agrégateur est chargé de la traduction des requêtes MySQL vers tous les nœuds terminaux devant être impliqués dans cette requête. Il prend ensuite les réponses de tous les nœuds terminaux et regroupe le résultat en une requête renvoyée à votre client MySQL. Voici comment sont gérées les requêtes parallèles.

Dans notre configuration à hôte unique, l’agrégateur et le nœud feuille s’exécutent sur le même ordinateur, mais vous pouvez en ajouter beaucoup plus sur de nombreux autres ordinateurs.

Étape 2 - Exécution d’un point de repère

Voyons à quelle vitesse MemSQL peut fonctionner en utilisant l’outil MemSQL Ops, installé dans le cadre du script d’installation de MemSQL.

Dans votre navigateur Web, accédez à + http: //: 9000 +

image: https: //assets.digitalocean.com/articles/memsql/img1.png [img]

L’outil MemSQL Ops vous donne un aperçu de votre cluster. Nous avons 2 nœuds MemSQL: l’agrégateur principal et le nœud feuille.

Prenons le test de vitesse sur notre nœud MemSQL mono-ordinateur. Cliquez sur * Test de vitesse * dans le menu de gauche, puis sur * DÉBUT DE TEST *. Voici un exemple des résultats que vous pourriez voir:

image: https: //assets.digitalocean.com/articles/memsql/img2.png [Résultats d’un test de vitesse]

Nous ne vous expliquerons pas comment installer MemSQL sur plusieurs serveurs dans ce didacticiel, mais à titre de comparaison, voici un point de repère issu d’un cluster MemSQL avec trois nœuds Ubuntu 14.04 de 8 Go (un nœud agrégateur et deux nœuds feuilles):

image: https: //assets.digitalocean.com/articles/memsql/img3.png [img]

En doublant le nombre de nœuds feuilles, nous avons presque doublé notre taux d’insertion. En examinant les sections * Rows Read *, nous pouvons constater que notre cluster à trois nœuds a été capable de lire simultanément 12 millions de lignes supplémentaires par rapport au cluster à nœud unique dans le même temps.

Étape 3 - Interaction avec MemSQL via mysql-client

Pour les clients, MemSQL ressemble à MySQL; ils parlent tous deux le même protocole. Pour commencer à parler à notre cluster MemSQL, installons un client mysql.

Commencez par mettre à jour apt pour installer le dernier client à l’étape suivante.

sudo apt-get update

Maintenant, installez un client MySQL. Cela nous donnera une commande + mysql à exécuter.

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

Nous sommes maintenant prêts à nous connecter à MemSQL avec un client MySQL. Nous allons nous connecter en tant qu’utilisateur * root * à l’hôte + 127.0.0.1 + (qui est notre adresse IP localhost) sur le port 3306. Nous allons également personnaliser le message d’invite en + memsql> +.

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

Vous verrez quelques lignes de sortie suivies de l’invite + memsql> +.

Listons les bases de données.

show databases;

Vous verrez cette sortie.

Sortie de la base de données

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

Créez une nouvelle base de données appelée * tutorial *.

create database tutorial;

Puis utilisez la nouvelle base de données avec la commande + use +.

use tutorial;

Ensuite, nous allons créer une table + user in qui aura les champs` + id of` et les champs '+ email + . Nous devons spécifier un type pour ces deux champs. Faisons de id un bigint et envoyons un varchar de 255. Nous indiquerons également à la base de données que le champ `+ id + est une clé primaire et que le champ + email + ne peut pas être nul.

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

Vous remarquerez peut-être un temps d’exécution médiocre sur cette dernière commande (15 à 20 secondes). Il y a une raison principale pour laquelle MemSQL tarde à créer cette nouvelle table: la génération de code.

Sous le capot, MemSQL utilise code generation pour exécuter des requêtes. Cela signifie que chaque fois qu’un nouveau type de requête est rencontré, MemSQL doit générer et compiler le code qui représente la requête. Ce code est ensuite envoyé au cluster pour exécution. Cela accélère le traitement des données réelles, mais la préparation présente un coût. MemSQL fait ce qu’il peut pour réutiliser des requêtes pré-générées, mais les nouvelles requêtes dont la structure n’a encore jamais été vue verront un ralentissement.

De retour à la table des utilisateurs, jetez un coup d’œil à la définition de la table.

describe users;

Sortie de définition de table

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

Maintenant, insérons quelques exemples de courriels dans la table des utilisateurs. Cette syntaxe est la même que celle que nous pourrions utiliser pour une base de données MySQL.

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

Insertion de la sortie des emails

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

Interrogez maintenant la table des utilisateurs.

select * from users;

Vous pouvez voir les données que nous venons d’entrer:

Sortie du tableau des utilisateurs

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

Étape 4 - Insertion et interrogation de JSON

MemSQL fournit un type JSON. Dans cette étape, nous allons créer un tableau d’événements pour utiliser les événements entrants. Cette table aura un champ + id (comme nous l’avons fait pour les utilisateurs) et un champ` + event on`, qui sera un type JSON.

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

Insérons quelques événements. Dans le JSON, nous référencerons un champ + email + qui, à son tour, renverra aux ID des utilisateurs que nous avons insérés à l’étape 3.

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

Nous pouvons maintenant examiner les événements que nous venons d’insérer.

select * from events;

Sortie de la table des événements

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

Ensuite, nous pouvons interroger tous les événements dont la propriété JSON + nom + est le texte «courrier électronique reçu».

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

Sortie de requête "email reçu"

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

Essayez de changer cette requête pour trouver ceux dont la propriété + name + est le texte "email envoyé".

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

Sortie de requête «email envoyé»

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

Cette dernière requête a été exécutée beaucoup plus rapidement que la précédente. En effet, nous n’avons modifié qu’un paramètre dans la requête. MemSQL a donc pu ignorer la génération de code.

Faisons quelque chose d’avancé pour une base de données SQL distribuée: joignons deux tables sur des clés non primaires où une valeur de la jointure est imbriquée dans une valeur JSON mais filtre sur une valeur JSON différente.

Tout d’abord, nous demanderons tous les champs de la table utilisateur avec la table des événements jointe en faisant correspondre le courrier électronique où le nom de l’événement est «courrier reçu».

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

Sortie des champs «email reçu»

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

Ensuite, essayez la même requête, mais filtrez uniquement les événements «email envoyé».

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

Sortie des champs «email envoyé»

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

Comme auparavant, la deuxième requête était beaucoup plus rapide que la première. Les avantages de la génération de code sont payants lorsque vous exécutez des millions de lignes, comme nous l’avons vu dans le benchmark. La possibilité d’utiliser une base de données SQL scale-out qui comprend JSON et comment joindre arbitrairement des tables est une fonctionnalité utilisateur puissante.

Conclusion

Vous avez installé MemSQL, effectué une analyse des performances de votre nœud, interagi avec votre nœud via un client MySQL standard et utilisé certaines fonctionnalités avancées introuvables dans MySQL. Cela devrait être un bon avant-goût de ce qu’une base de données SQL en mémoire peut faire pour vous.

Il reste encore beaucoup à apprendre sur la façon dont MemSQL distribue réellement vos données, comment structurer les tables pour optimiser les performances, comment étendre MemSQL sur plusieurs nœuds, comment répliquer vos données pour une haute disponibilité et comment sécuriser MemSQL.

TOC