TOC

Hinzufügen von NoSQL-Abfragen zu MySQL mit memcached unter Ubuntu 14.04

Einführung

Die allgemeine Idee, memcached und seine eigenständige Serverimplementierung mit MySQL zu verwenden, wurde in vielen guten Artikeln beschrieben, wie zum Beispiel dem https://www.digitalocean.com/community/tutorials/how-to-install-and-use-memcache- on-ubuntu-14-04 [Installieren und Verwenden von Memcache unter Ubuntu 14.04]. Memcached als eigenständiger Server fungiert jedoch als Vermittler vor der MySQL-Clientzugriffsebene und verwaltet Informationen nur im Speicher, ohne die Option, sie dauerhaft zu speichern. Dies macht es für Aufgaben wie das Zwischenspeichern der Ergebnisse doppelter MySQL-Abfragen geeignet. Dies spart Ressourcen und optimiert die Leistung stark ausgelasteter Standorte.

In diesem Artikel werden wir jedoch etwas anderes diskutieren. Memcached wird als MySQL-Plugin installiert und fest in MySQL integriert. Es bietet eine Zugriffsschicht im NoSQL-Stil für die Verwaltung von Informationen direkt in regulären MySQL InnoDB-Tabellen. Dies hat zahlreiche Vorteile, wie wir später in diesem Artikel sehen werden.

Grundlegendes Verständnis

Um diesem Artikel folgen zu können, benötigen Sie grundlegende Kenntnisse über NoSQL und memcached. Vereinfacht ausgedrückt, arbeitet NoSQL mit Informationen in Form von Schlüsselwerten. Dieser offensichtlich einfachere Ansatz als das Standard-SQL weist auf eine bessere Leistung und Skalierbarkeit hin, die besonders für die Arbeit mit großen Informationsmengen (Big Data) gefragt sind.

Die gute Leistung von NoSQL reicht jedoch nicht aus, um das übliche SQL zu ersetzen. Die Einfachheit von NoSQL macht es für strukturierte Daten mit komplexen Beziehungen ungeeignet. Somit ist NoSQL kein Ersatz für SQL, sondern eine wichtige Ergänzung dazu.

Was memcached angeht, kann es als eine beliebte Implementierung von NoSQL angesehen werden. Es ist sehr schnell und verfügt über hervorragende Caching-Mechanismen, wie der Name schon sagt. Deshalb ist es eine gute Wahl, um dem traditionellen MySQL den NoSQL-Stil zu verleihen.

Ein gewisses Verständnis des zwischengespeicherten Protokolls ist ebenfalls erforderlich. Memcached funktioniert mit Elementen, die die folgenden Teile haben:

  • A - Alphanumerischer Wert, der der Schlüssel für den Zugriff auf das Element ist.

  • A - Beliebige Daten, in denen die wesentlichen Nutzdaten aufbewahrt werden.

  • A - Normalerweise ein Wert, der zum Einstellen zusätzlicher Parameter in Bezug auf den Hauptwert verwendet wird. Beispielsweise könnte es ein Flag sein, ob eine Komprimierung verwendet werden soll oder nicht.

  • An - Ablaufzeit in Sekunden. Denken Sie daran, dass memcached ursprünglich im Hinblick auf das Caching entwickelt wurde.

  • A - Eindeutige Kennung jedes Artikels.

Voraussetzungen

Dieses Handbuch wurde unter Ubuntu 14.04 getestet. Die beschriebene Installation und Konfiguration ist unter anderen Betriebssystemen oder Betriebssystemversionen ähnlich, die Befehle und der Speicherort der Konfigurationsdateien können jedoch variieren.

Sie benötigen Folgendes:

  • Ubuntu 14.04 Neuinstallation

  • Nicht-Root-Benutzer mit Sudo-Berechtigungen

Alle Befehle in diesem Lernprogramm sollten als Benutzer ohne Rootberechtigung ausgeführt werden. Wenn für den Befehl root-Zugriff erforderlich ist, wird vor + sudo + angezeigt. Wenn Sie das noch nicht eingerichtet haben, folgen Sie diesem Tutorial: Initial Server Setup with Ubuntu 14.04 .

[[step-1-- installing-mysql-5-6]] === Schritt 1 - Installation von MySQL 5.6

Das memcached Plugin in MySQL ist in Versionen von MySQL über 5.6.6 verfügbar. Dies bedeutet, dass Sie das MySQL-Paket (Version 5.5) aus dem Standard-Ubuntu 14.04-Repository nicht verwenden können. Stattdessen müssen Sie:

  1. Fügen Sie das offizielle MySQL-Repository hinzu

  2. Installieren Sie den MySQL-Server, den Client und die Bibliotheken von dort

Rufen Sie zunächst die Seite MySQL apt repository auf und laden Sie das Paket herunter, mit dem das MySQL-Repository zu Ihrem Ubuntu 14.04-System hinzugefügt wird. Sie können das Paket direkt auf Ihr Droplet herunterladen:

wget https://dev.mysql.com/get/mysql-apt-config_0.3.5-1ubuntu14.04_all.deb

Als nächstes installieren Sie es mit + dpkg +:

sudo dpkg -i mysql-apt-config_0.3.5-1ubuntu14.04_all.deb

Wenn Sie den obigen Befehl ausführen, wird ein Textmodus-Assistent mit zwei Fragen angezeigt:

  • Welches MySQL-Produkt möchten Sie konfigurieren? Antworten Sie mit + Server +.

  • Welche Serverversion möchten Sie erhalten? Antworten Sie mit + mysql-5.6 +.

Wenn Sie diese beiden Fragen beantwortet haben, kehren Sie zur ersten Frage zurück, welches Produkt Sie installieren möchten. Antworten Sie mit "+ Übernehmen +", der unteren Auswahl, um Ihre Auswahl zu bestätigen und den Assistenten zu beenden.

Nachdem Sie das neue MySQL-Repository installiert haben, müssen Sie den Apt-Cache aktualisieren, d. H. die Informationen zu den verfügbaren Paketen für die Installation in Ubuntu. Wenn Sie sich also für die Installation von MySQL entscheiden, wird es aus dem neuen Repository abgerufen. Führen Sie den folgenden Befehl aus, um den Apt-Cache zu aktualisieren:

sudo apt-get update

Danach können Sie MySQL 5.6 unter Ubuntu 14.04 mit folgendem Befehl installieren:

sudo apt-get install mysql-server

Sobald Sie den obigen Befehl ausführen, werden Sie aufgefordert, ein MySQL-Root-Passwort (Administrator-Passwort) auszuwählen. Zur Vereinfachung können Sie an dieser Stelle festlegen, dass kein Kennwort festgelegt werden soll, und bei Aufforderung einfach die EINGABETASTE drücken. Sobald Sie sich jedoch entschließen, diesen Server in Betrieb zu nehmen, wird empfohlen, den Befehl "+ sudo mysql_secure_installation +" auszuführen, um Ihre MySQL-Installation zu sichern und ein Root-Passwort zu konfigurieren.

Nach Abschluss des Installationsvorgangs wird MySQL Server 5.6 zusammen mit dem Befehlszeilen-Client und den erforderlichen Bibliotheken installiert. Sie können dies überprüfen, indem Sie den Client mit dem folgenden Befehl starten:

mysql -u root

Wenn Sie ein Kennwort festlegen, müssen Sie den folgenden Befehl verwenden und Ihr MySQL-Root-Kennwort eingeben, wenn Sie dazu aufgefordert werden:

mysql -u root -p

Das solltest du sehen:

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.6.25 MySQL Community Server (GPL)
...

Erstellen Sie im MySQL-Monitor (Client-Terminal) eine neue Datenbank mit dem Namen "+ test":

CREATE DATABASE test;

Diese Datenbank benötigen wir später für Ihre Tests.

So beenden Sie den MySQL-Client:

quit

Schließlich müssen Sie als Abhängigkeit für das Plugin memcached auch das Entwicklungspaket für die Bibliothek für asynchrone Ereignisbenachrichtigungen installieren - + libevent-dev +. Führen Sie dazu den folgenden Befehl aus:

sudo apt-get install libevent-dev

Schritt 2 - Installation des memcached Plugins in MySQL

Um sich auf die Installation des memcached Plugins vorzubereiten, müssen Sie zuerst die in der Datei + / usr / share / mysql / innodb_memcached_config.sql + gefundenen Abfragen ausführen. Starten Sie den MySQL-Client:

mysql -u root

oder, wenn Sie ein Passwort vergeben:

mysql -u root -p

und führe aus:

source /usr/share/mysql/innodb_memcached_config.sql;

Dadurch werden alle erforderlichen Einstellungen für das Plugin in der Datenbank "+ innodb_memcache " erstellt und einige Beispieldaten in unsere neu erstellte Datenbank " test +" eingefügt.

Danach können Sie die Installation des memcached-Plugins vom MySQL-Terminal aus mit folgendem Befehl durchführen:

install plugin daemon_memcached soname "libmemcached.so";

Beenden Sie die MySQL-Sitzung:

quit

Dadurch wird das im Speicher befindliche Plugin installiert, das sich in Ubuntu 14.04 im Verzeichnis + / usr / lib / mysql / plugin / + befindet. Diese Datei ist nur in MySQL ab Version 5.6 verfügbar.

Sobald die Installation abgeschlossen ist, müssen Sie den im Speicher befindlichen Plugin-Listener konfigurieren. Sie benötigen es, um sich mit dem im Speicher befindlichen Plugin zu verbinden. Öffnen Sie dazu die Datei "+ / etc / mysql / my.cnf +" mit Ihrem Lieblingseditor wie folgt:

sudo vim /etc/mysql/my.cnf

Irgendwo nach der Zeile + [mysqld] + eine neue Zeile einfügen, die Folgendes enthält:

/etc/mysql/my.cnf

daemon_memcached_option="-p11222 -l 127.0.0.1"

Mit dem obigen Befehl wird der Listener für im Speicher befindliche Plug-ins an Port 11222 konfiguriert, der nur für die Loopback-IP 127.0.0.1 aktiviert ist. Dies bedeutet, dass nur Clients aus dem Droplet eine Verbindung herstellen können. Wenn Sie den Teil über die IP weglassen (+ -l 127.0.0.1 +), ist der neue Listener von überall frei zugänglich, was ein ernstes Sicherheitsrisiko darstellt. Wenn Sie weitere Bedenken hinsichtlich der Sicherheit des im Speicher befindlichen Plugins haben, lesen Sie bitte http://dev.mysql.com/doc/refman/5.6/de/innodb-memcached-security.html maturits security documentation].

Um den neuen Listener-Prozess für das Plugin memcached zu starten, starten Sie den MySQL-Server mit dem folgenden Befehl neu:

sudo service mysql restart

Schritt 3 - Testen des memcached Plugins

Um zu überprüfen, ob die Installation erfolgreich war, führen Sie den folgenden MySQL-Befehl vom MySQL-Client aus aus (starten Sie den Client mit + mysql -u root + oder + mysql -u root -p +):

show plugins;

Wenn alles in Ordnung ist, sollten Sie in der Ausgabe sehen:

| daemon_memcached           |   | DAEMON             | libmemcached.so | GPL     |

Wenn dies nicht angezeigt wird, stellen Sie sicher, dass Sie MySQL ab Version 5.6 verwenden und die Installationsanweisungen genau befolgt haben.

Sie können auch versuchen, von Ihrem Droplet aus eine Verbindung mit der neuen memcached-Plugin-Schnittstelle mit Telnet herzustellen:

telnet localhost 11222

Bei Erfolg sollten Sie folgende Ergebnisse sehen:

Connected to localhost.
Escape character is '^]'.

Jetzt können Sie einen allgemeinen Befehl wie "+ stats " für die Statistik ausführen, um zu sehen, wie diese Verbindung funktioniert. Um die Eingabeaufforderung zu beenden, drücken Sie gleichzeitig die Tastenkombination STRG und] auf Ihrer Tastatur. Geben Sie danach " quit +" ein, um den Telnet-Client selbst zu beenden.

Telnet bietet Ihnen die einfachste Möglichkeit, eine Verbindung zum Plugin memcached und zu den MySQL-Daten selbst herzustellen. Es ist gut zum Testen, aber wenn Sie sich für eine professionelle Verwendung entscheiden, sollten Sie die sofort verfügbaren Bibliotheken für gängige Programmiersprachen wie PHP und Python verwenden.

[[step-4 --running-nosql-queries-in-mysql-via-memcached-plugin]] === Schritt 4 - Ausführen von NoSQL-Abfragen in MySQL über das zwischengespeicherte Plugin

Wenn Sie in diesem Artikel zum Installationsteil des Plugins memcached zurückkehren, werden Sie feststellen, dass wir die Anweisungen aus der Datei "+ / usr / share / mysql / innodb_memcached_config.sql " ausgeführt haben. Diese Anweisungen erzeugten eine neue Tabelle " demo_test" in der "+ test" -Datenbank. Die "+ demo_test +" - Tabelle enthält die folgenden Spalten in Übereinstimmung mit dem zwischengespeicherten Protokoll:

  • + c1 + implementiert das Feld.

  • + c2 + implementiert das Feld.

  • + c3 + implementiert das Feld.

  • + c4 + implementiert das Feld.

  • + c5 + implementiert das Feld.

Die Tabelle "+ demo_test +" ist diejenige, mit der wir testen werden. Öffnen wir zuerst die Datenbank / Tabelle mit dem MySQL-Client mit dem folgenden Befehl:

mysql -u root

Oder, wenn Sie ein MySQL-Passwort festgelegt haben:

mysql -u root  -p

In der Tabelle + demo_test + sollte bereits eine Zeile vorhanden sein:

SELECT * FROM demo_test;

Die Ergebnisse sollten folgendermaßen aussehen:

+-------------+--------------+------+------+------+
| c1          | c2           | c3   | c4   | c5   |
+-------------+--------------+------+------+------+
| AA          | HELLO, HELLO |    8 |    0 |    0 |
+-------------+--------------+------+------+------+
1 rows in set (0.00 sec)

Beenden Sie die MySQL-Sitzung:

quit

Jetzt erstellen wir einen zweiten Datensatz mit der zwischengespeicherten NoSQL-Schnittstelle und Telnet. Stellen Sie erneut eine Verbindung zu localhost über TCP-Port 11222 her:

telnet localhost 11222

Verwenden Sie dann die folgende Syntax:

set [] [] [] []
[]

Beachten Sie, dass sich das in einer neuen Zeile befinden muss. Außerdem müssen Sie für jeden Datensatz die Länge in Byte für den Wert angeben, wenn Sie auf die oben beschriebene Weise arbeiten.

Als Beispiel erstellen wir ein neues Element (Datenbankzeile) mit dem Schlüssel "+ newkey ", dem Wert " 0 " für "flag" und dem Wert " 0 +" für "expiration" (never to expire). Der Wert ist 12 Byte lang.

set newkey 0 0 12
NewTestValue

Natürlich können Sie auch Werte über diese NoSQL-Schnittstelle abrufen. Dies geschieht mit dem Befehl "+ get +", gefolgt vom Namen des Schlüssels, den Sie abrufen möchten. Geben Sie in der Telnet-Sitzung Folgendes ein:

get newkey

Das Ergebnis sollte sein:

VALUE newkey 0 12
NewTestValue

Die obigen Befehle "+ set" und "+ get" gelten für jeden zwischengespeicherten Server. Dies sind nur einige einfache Beispiele für das Einfügen und Abrufen von Datensätzen in einem NoSQL-Stil.

Stellen wir nun erneut eine Verbindung zum MySQL-Client her, indem Sie den Befehl "+ mysql -u root test " oder " mysql -u root test -p " eingeben und den Inhalt der Tabelle " demo_test +" erneut anzeigen, indem Sie das qyery ausführen:

SELECT * FROM demo_test WHERE c1="newkey";

Dort sollte die neu erstellte Zeile so aussehen:

+--------+--------------+------+------+------+
| c1     | c2           | c3   | c4   | c5   |
+--------+--------------+------+------+------+
| newkey | NewTestValue |    0 |    1 |    0 |
+--------+--------------+------+------+------+

Inzwischen werden Sie sich vielleicht fragen, wie das Plug-in im Memcached-Modus weiß, mit welcher Datenbank und Tabelle eine Verbindung hergestellt werden soll und wie Informationen den Tabellenspalten zugeordnet werden sollen. Die Antwort befindet sich in der Datenbank "+ innodb memcached" und ihrer Tabelle "+ container".

Führen Sie diese select-Anweisung aus:

select * from containers \G

Sie werden folgendes sehen:

*************************** 1. row ***************************
                 name: aaa
            db_schema: test
             db_table: demo_test
          key_columns: c1
        value_columns: c2
                flags: c3
           cas_column: c4
   expire_time_column: c5
unique_idx_name_on_key: PRIMARY
1 row in set (0.00 sec)

Weitere Informationen zum Erstellen verschiedener Zuordnungen und zu den erweiterten Funktionen des Plugins memcached finden Sie unter the memcached plugin Interna Seite.

Vorteile der Integration von MySQL mit dem memcached Plugin

Die obigen Informationen und Beispiele zeigen einige wichtige Vorteile der Integration von MySQL in NoSQL über das Plugin memcached:

  • Alle Ihre Daten (MySQL und NoSQL) können an einem Ort aufbewahrt werden. Sie müssen keine zusätzliche Software für NoSQL-Daten installieren und warten.

  • Datenpersistenz, -wiederherstellung und -replikation für NoSQL-Daten sind dank der leistungsstarken InnoDB-Speicher-Engine möglich.

  • Die unglaublich schnell gespeicherte Datenzugriffsebene kann weiterhin verwendet werden, sodass Sie mit einem höheren Informationsvolumen arbeiten können als mit dem langsameren MySQL-Client.

  • NoSQL-Daten können mit der MySQL-Schnittstelle und -Syntax verwaltet werden. So können Sie NoSQL-Daten in komplexere SQL-Abfragen wie Left Joins einbeziehen.

Fazit

Am Ende dieses Artikels sollten Sie mit den neuen Möglichkeiten zum Arbeiten mit von MySQL bereitgestellten NoSQL-Daten vertraut sein. Dies ist möglicherweise keine universelle Lösung, um dedizierte NoSQL-Server wie MongoDB zu ersetzen, aber es hat sicherlich seine Vorzüge.

Related