TOC

So installieren Sie MemSQL unter Ubuntu 14.04

Geschrieben in Zusammenarbeit mit MemSQL

Einführung

MemSQL ist eine Art In-Memory-Datenbank, die schnellere Lese- und Schreibvorgänge als herkömmliche Datenbanken ermöglicht. Auch wenn es sich um eine neue Technologie handelt, spricht sie das MySQL-Protokoll, weshalb es sich sehr vertraut anfühlt, damit zu arbeiten.

MemSQL nutzt die neuesten Funktionen von MySQL mit modernen Funktionen wie JSON-Unterstützung und der Möglichkeit, Daten auf den neuesten Stand zu bringen. Einer der größten Vorteile von MemSQL gegenüber MySQL ist die Möglichkeit, eine einzelne Abfrage auf mehrere Knoten aufzuteilen. Dies wird als "massiv parallele Verarbeitung" bezeichnet und führt zu deutlich schnelleren Leseabfragen.

In diesem Tutorial werden wir MemSQL auf einem einzelnen Ubuntu 14.04-Server installieren, Leistungsbenchmarks ausführen und mit dem Einfügen von JSON-Daten über einen Befehlszeilen-MySQL-Client spielen.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

Schritt 1 - Installieren von MemSQL

In diesem Abschnitt bereiten wir unsere Arbeitsumgebung auf die MemSQL-Installation vor.

Die neueste Version von MemSQL finden Sie unter Ihre Download-Seite. Wir werden MemSQL Ops herunterladen und installieren, ein Programm, das das Herunterladen und Vorbereiten Ihres Servers für die ordnungsgemäße Ausführung von MemSQL verwaltet. Die aktuellste Version von MemSQL Ops ist zum Zeitpunkt des Schreibens 4.0.35.

Laden Sie zunächst die Installationspaketdatei von MemSQL von der Website herunter.

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

Als nächstes extrahieren Sie das Paket.

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

Durch das Extrahieren des Pakets wurde ein Ordner mit dem Namen "+ memsql-ops-4.0.35 +" erstellt. Beachten Sie, dass der Ordnername die Versionsnummer enthält. Wenn Sie also eine neuere Version herunterladen, als in diesem Lernprogramm angegeben, verfügen Sie über einen Ordner mit der von Ihnen heruntergeladenen Version.

Wechseln Sie in diesen Ordner.

cd memsql-ops-4.0.35

Führen Sie dann das Installationsskript aus, das Teil des gerade extrahierten Installationspakets ist.

sudo ./install.sh

Sie werden eine Ausgabe des Skripts sehen. Nach einem Moment werden Sie gefragt, ob Sie MemSQL nur auf diesem Host installieren möchten. In einem zukünftigen Tutorial werden wir uns mit der Installation von MemSQL auf mehreren Computern befassen. Sagen wir für die Zwecke dieses Lernprogramms "Ja", indem Sie "* y *" eingeben.

Eingabeaufforderung und Ausgabe des Installationsskripts

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

Jetzt haben Sie einen MemSQL-Cluster auf Ihrem Ubuntu-Server bereitgestellt! In den obigen Protokollen werden Sie jedoch feststellen, dass MemSQL zweimal installiert wurde.

MemSQL kann in zwei verschiedenen Rollen ausgeführt werden: einem Aggregatorknoten und einem Blattknoten. Der Grund, warum MemSQL zweimal installiert wurde, besteht darin, dass mindestens ein Aggregatorknoten und mindestens ein Blattknoten für den Betrieb eines Clusters erforderlich sind.

Der aggregator node ist Ihre Schnittstelle zu MemSQL. Für die Außenwelt ähnelt es MySQL: Es lauscht auf demselben Port und Sie können Tools anschließen, die eine Kommunikation mit MySQL und Standard-MySQL-Bibliotheken erwarten. Die Aufgabe des Aggregators besteht darin, alle MemSQL-Blattknoten zu kennen, MySQL-Clients zu behandeln und deren Abfragen in MemSQL zu übersetzen.

Ein Blattknoten speichert tatsächlich Daten. Wenn der Blattknoten vom Aggregatorknoten eine Anforderung zum Lesen oder Schreiben von Daten erhält, führt er diese Abfrage aus und gibt die Ergebnisse an den Aggregatorknoten zurück. Mit MemSQL können Sie Ihre Daten auf mehreren Hosts gemeinsam nutzen, und jeder Blattknoten verfügt über einen Teil dieser Daten. (Auch mit einem einzelnen Blattknoten werden Ihre Daten innerhalb dieses Blattknotens aufgeteilt.)

Wenn Sie mehrere Blattknoten haben, ist der Aggregator für die Übersetzung von MySQL-Abfragen in alle Blattknoten verantwortlich, die an dieser Abfrage beteiligt sein sollen. Anschließend werden die Antworten von allen Blattknoten übernommen und das Ergebnis in einer Abfrage zusammengefasst, die an Ihren MySQL-Client zurückgegeben wird. So werden parallele Abfragen verwaltet.

In unserem Einzelhost-Setup werden der Aggregator und der Blattknoten auf demselben Computer ausgeführt. Sie können jedoch auf vielen anderen Computern weitere Blattknoten hinzufügen.

Schritt 2 - Ausführen eines Benchmarks

Lassen Sie uns sehen, wie schnell MemSQL mit dem MemSQL Ops-Tool arbeiten kann, das als Teil des MemSQL-Installationsskripts installiert wurde.

Gehen Sie in Ihrem Webbrowser zu "+ http: //: 9000 +"

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

Das MemSQL Ops-Tool gibt Ihnen einen Überblick über Ihren Cluster. Wir haben 2 MemSQL-Knoten: den Master-Aggregator und den Blattknoten.

Machen wir den Geschwindigkeitstest auf unserem Einzelmaschinen-MemSQL-Knoten. Klicken Sie links im Menü auf * Speed ​​Test * (Geschwindigkeitstest) und dann auf * START TEST * (Test starten). Hier ist ein Beispiel für die Ergebnisse, die möglicherweise angezeigt werden:

image: https://assets.digitalocean.com/articles/memsql/img2.png [Beispielergebnisse für Geschwindigkeitstests]

In diesem Tutorial wird nicht erläutert, wie MemSQL auf mehreren Servern installiert wird. Zum Vergleich sehen Sie hier einen Benchmark eines MemSQL-Clusters mit drei 8-GB-Ubuntu-14.04-Knoten (ein Aggregatorknoten und zwei Blattknoten):

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

Durch die Verdoppelung der Anzahl der Blattknoten konnten wir unsere Einfügerate fast verdoppeln. Anhand der Abschnitte * Rows Read * können wir erkennen, dass unser Cluster mit drei Knoten in der Lage war, gleichzeitig 12 Millionen Zeilen mehr als der Cluster mit einem Knoten in der gleichen Zeit zu lesen.

Schritt 3 - Interaktion mit MemSQL über MySQL-Client

Für Kunden sieht MemSQL wie MySQL aus. beide sprechen dasselbe Protokoll. Um mit unserem MemSQL-Cluster zu kommunizieren, installieren wir einen mysql-client.

Aktualisieren Sie zunächst apt, damit wir im nächsten Schritt den neuesten Client installieren.

sudo apt-get update

Installieren Sie jetzt einen MySQL-Client. Dies gibt uns einen Befehl + mysql zum Ausführen.

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

Jetzt können wir über einen MySQL-Client eine Verbindung zu MemSQL herstellen. Wir werden uns als * root * -Nutzer mit dem Host + 127.0.0.1 + (das ist unsere lokale Host-IP-Adresse) an Port 3306 verbinden. Wir werden auch die Eingabeaufforderung an "+ memsql> +" anpassen.

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

Es werden einige Ausgabezeilen angezeigt, gefolgt von der Eingabeaufforderung "+ memsql> +".

Lassen Sie uns die Datenbanken auflisten.

show databases;

Sie sehen diese Ausgabe.

Datenbankausgabe

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

Erstellen Sie eine neue Datenbank mit dem Namen * tutorial *.

create database tutorial;

Wechseln Sie dann mit dem Befehl + use + zur Verwendung der neuen Datenbank.

use tutorial;

Als nächstes erstellen wir eine "+ user in" -Tabelle, die die "+ id" eines "+ email " -Feldes enthält. Für diese beiden Felder müssen wir einen Typ angeben. Lassen Sie uns id zu bigint machen und ein varchar mit einer Länge von 255 per E-Mail versenden. Wir werden der Datenbank auch mitteilen, dass das Feld " id " ein Primärschlüssel ist und das Feld " email +" nicht null sein darf.

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

Möglicherweise stellen Sie bei diesem letzten Befehl eine schlechte Ausführungszeit fest (15 bis 20 Sekunden). Es gibt einen Hauptgrund, warum MemSQL diese neue Tabelle nur langsam erstellt: Codegenerierung.

Unter der Haube verwendet MemSQL die Codegenerierung, um Abfragen auszuführen. Dies bedeutet, dass MemSQL jedes Mal, wenn ein neuer Abfragetyp auftritt, Code generieren und kompilieren muss, der die Abfrage darstellt. Dieser Code wird dann zur Ausführung an den Cluster gesendet. Dadurch wird die Verarbeitung der eigentlichen Daten beschleunigt, die Vorbereitung ist jedoch kostenintensiv. MemSQL unternimmt alles, um vorgenerierte Abfragen wiederzuverwenden. Neue Abfragen, deren Struktur noch nicht bekannt ist, werden jedoch langsamer.

Zurück zu unserer Benutzertabelle werfen Sie einen Blick auf die Tabellendefinition.

describe users;

Tabellendefinitionsausgabe

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

Fügen Sie nun einige Beispiel-E-Mails in die Benutzertabelle ein. Diese Syntax ist dieselbe, die wir möglicherweise für eine MySQL-Datenbank verwenden.

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

Einfügen der E-Mail-Ausgabe

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

Fragen Sie jetzt die Benutzertabelle ab.

select * from users;

Sie können die Daten sehen, die wir gerade eingegeben haben:

Benutzer Tabellenausgabe

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

Schritt 4 - JSON einfügen und abfragen

MemSQL bietet einen JSON-Typ. In diesem Schritt erstellen wir eine Ereignistabelle, um eingehende Ereignisse zu nutzen. Diese Tabelle hat ein "+ id" -Feld (wie wir es für Benutzer getan haben) und ein "+ event on" -Feld, das ein JSON-Typ ist.

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

Fügen wir ein paar Ereignisse ein. In JSON verweisen wir auf ein Feld "+ email +", das wiederum auf die IDs der Benutzer verweist, die wir in Schritt 3 eingefügt haben.

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

Jetzt können wir uns die Ereignisse ansehen, die wir gerade eingefügt haben.

select * from events;

Ereignistabellenausgabe

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

Als nächstes können wir alle Ereignisse abfragen, deren JSON-Eigenschaft "+ name +" der Text "receive email" ist.

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

Abfrage-Ausgabe "E-Mail empfangen"

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

Versuchen Sie, diese Abfrage so zu ändern, dass diejenigen gefunden werden, deren "+ name +" - Eigenschaft der Text "gesendete E-Mail" ist.

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

Abfrage-Ausgabe "E-Mail gesendet"

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

Diese letzte Abfrage lief viel schneller als die vorherige. Dies liegt daran, dass wir nur einen Parameter in der Abfrage geändert haben, sodass MemSQL die Codegenerierung überspringen konnte.

Lassen Sie uns etwas Fortgeschrittenes für eine verteilte SQL-Datenbank tun: Verbinden wir zwei Tabellen mit Nicht-Primärschlüsseln, wobei ein Wert des Joins in einem JSON-Wert verschachtelt ist, aber nach einem anderen JSON-Wert filtert.

Zunächst werden alle Felder der Benutzertabelle mit der Ereignistabelle abgefragt, an die sich eine übereinstimmende E-Mail anschließt, bei der der Ereignisname "E-Mail empfangen" lautet.

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

Die Felder "empfangene E-Mail" werden ausgegeben

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

Versuchen Sie als Nächstes dieselbe Abfrage, filtern Sie jedoch nur nach gesendeten E-Mail-Ereignissen.

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

Ausgabe der Felder "E-Mail gesendet"

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

Wie zuvor war die zweite Abfrage viel schneller als die erste. Die Vorteile der Codegenerierung machen sich bei der Ausführung von über Millionen Zeilen bezahlt, wie wir im Benchmark gesehen haben. Die Flexibilität, eine skalierbare SQL-Datenbank zu verwenden, die JSON versteht und Tabellen beliebig verknüpft, ist eine leistungsstarke Benutzerfunktion.

Fazit

Sie haben MemSQL installiert, einen Benchmark der Leistung Ihres Knotens durchgeführt, über einen Standard-MySQL-Client mit Ihrem Knoten interagiert und mit einigen erweiterten Funktionen gespielt, die in MySQL nicht zu finden sind. Dies sollte einen guten Eindruck davon vermitteln, was eine In-Memory-SQL-Datenbank für Sie tun kann.

Es bleibt noch viel zu lernen, wie MemSQL Ihre Daten tatsächlich verteilt, wie Tabellen strukturiert werden, wie MemSQL auf mehrere Knoten erweitert wird, wie Ihre Daten für hohe Verfügbarkeit repliziert werden und wie MemSQL gesichert wird.

Related