One place for hosting & domains

      ProxySQLCaching

      So optimieren Sie MySQL-Abfragen mit ProxySQL-Caching unter Ubuntu 16.04


      Der Autor wählte die Free Software Foundation, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      ProxySQL ist ein SQL-fähiger Proxy-Server, der zwischen Ihrer Anwendung und Ihrer Datenbank positioniert werden kann. Er bietet viele Funktionen, wie z. B. Lastverteilung zwischen mehreren MySQL-Servern, und dient als Caching-Layer für Abfragen. Dieses Tutorial konzentriert sich auf die Cache-Funktion von ProxySQL und wie es Abfragen für Ihre MySQL-Datenbank optimieren kann.

      MySQL-Caching tritt bei der Speicherung des Ergebnisses einer Abfrage auf, sodass bei wiederholter Abfrage das Ergebnis zurückgegeben werden kann, ohne dass die Datenbank durchsucht werden muss. Dies kann die Geschwindigkeit gewöhnlicher Abfragen deutlich erhöhen. Bei vielen Caching-Methoden müssen die Entwickler jedoch den Code ihrer Anwendung modifizieren, was einen Fehler in die Codebase einbringen könnte. Um diese fehleranfällige Praxis zu vermeiden, erlaubt ProxySQL die Einrichtung eines transparenten Cachings.

      Bei dem transparenten Caching müssen nur Datenbankadministratoren die ProxySQL-Konfiguration ändern, um das Caching für die gängigsten Abfragen zu aktivieren, und diese Änderungen können über die ProxySQL-Verwaltungsschnittstelle vorgenommen werden. Der Entwickler muss sich nur mit dem protokollfähigen Proxy verbinden und der Proxy wird entscheiden, ob die Abfrage aus dem Cache bedient werden kann, ohne im Back-End-Server zu suchen.

      In diesem Tutorial werden Sie ProxySQL verwenden, um transparentes Caching für einen MySQL-Server unter Ubuntu 16.04. einzurichten. Anschließend werden Sie seine Leistung unter Verwendung von mysqlslap mit und ohne Caching testen, um die Wirkung des Caching zu demonstrieren und zu zeigen, wie viel Zeit es bei der Ausführung vieler ähnlicher Abfragen sparen kann.

      Voraussetzungen

      Bevor Sie diese Anleitung beginnen, benötigen Sie Folgendes:

      Schritt 1 – Installieren und Einrichten des MySQL-Servers

      Zuerst werden Sie MySQL-Server installieren und so konfigurieren, dass es ProxySQL als Backend-Server zur Bedienung von Client-Anfragen verwendet.

      Unter Ubuntu 16.04 kann mysql-server mit diesem Befehl installiert werden:

      • sudo apt-get install mysql-server

      Drücken Sie Y, um die Installation zu bestätigen.

      Sie werden dann zur Eingabe Ihres MySQL Root-Benutzer-Passwortes aufgefordert. Geben Sie ein starkes Passwort ein und speichern Sie es zur späteren Verwendung.

      Nachdem Ihr MySQL-Server nun bereit ist, konfigurieren Sie ihn so, dass ProxySQL korrekt zu arbeitet. Sie müssen einen Benutzer monitor für ProxySQL hinzufügen, um den MySQL-Server zu überwachen, da ProxySQL über das SQL-Protokoll auf den Backend-Server lauscht, anstatt eine TCP-Verbindung oder HTTP-GET-Anforderungen zu benutzen, um sicherzustellen, dass das Backend läuft. Um festzustellen, ob der Server noch aktiv ist, verwendet monitor eine Dummy-SQL-Verbindung.

      Melden Sie sich zuerst bei der MySQL-Shell an:

      -uroot meldet Sie unter Verwendung des MySQL Root-Benutzers an und -p fordert zur Eingabe des Passworts des Root-Benutzers auf. Dieser Root-Benutzer unterscheidet sich von dem Root-Benutzer Ihres Servers, und das Passwort ist dasjenige, das Sie bei der Installation des Pakets mysql-server eingegeben haben.

      Geben Sie das Root-Passwort ein und drücken Sie die EINGABETASTE.

      Nun erstellen Sie zwei Benutzer, einen namens monitor für ProxySQL und einen weiteren, den Sie zum Ausführen von Client-Abfragen und zur Gewährung der richtigen Berechtigungen verwenden. In diesem Tutorial wird dieser Benutzer sammy genannt.

      Erstellen Sie den Benutzer monitor:

      • CREATE USER 'monitor'@'%' IDENTIFIED BY 'monitor_password';

      Die Abfrage CREATE USER wird verwendet, um einen neuen Benutzer zu erstellen, der sich von bestimmten IPs aus verbinden kann. Die Verwendung von % bedeutet, dass der Benutzer eine Verbindung von einer beliebigen IP-Adresse aus herstellen kann. IDENTIFIED BY legt das Passwort für den neuen Benutzer fest; geben Sie ein beliebiges Passwort ein, aber merken Sie es sich für die spätere Verwendung.

      Nachdem der Benutzer monitor erstellt ist, erstellen Sie als Nächstes den Benutzer sammy:

      • CREATE USER 'sammy'@'%' IDENTIFIED BY 'sammy_password';

      Als Nächstes gewähren Sie Ihren neuen Benutzern Berechtigungen. Führen Sie den folgenden Befehl aus, um monitor zu konfigurieren:

      • GRANT SELECT ON sys.* TO 'monitor'@'%';

      Die Abfrage GRANT wird verwendet, um Benutzern Berechtigungen zu erteilen. Hier haben Sie dem Benutzer monitor nur SELECT auf alle Tabellen in der Datenbank sys gewährt; er benötigt diese Berechtigung nur, um auf den Back-End-Server zu lauschen.

      Gewähren Sie nun dem Benutzer sammy alle Berechtigungen für alle Datenbanken:

      • GRANT ALL PRIVILEGES on *.* TO 'sammy'@'%';

      Dies ermöglicht sammy, die notwendigen Abfragen durchzuführen, um Ihre Datenbank später zu testen.

      Wenden Sie die Änderungen der Berechtigungen an, indem Sie Folgendes ausführen:

      Beenden Sie im Anschluss die mysql-Shell:

      Sie haben nun mysql-server installiert und einen Benutzer zur Verwendung durch ProxySQL zur Überwachung Ihres MySQL-Servers und einen weiteren zur Ausführung von Client-Abfragen erstellt. Als Nächstes installieren und konfigurieren Sie ProxySQL.

      Schritt 2 – Installieren und Konfigurieren von ProxySQL

      Jetzt können Sie den ProxySQL-Server installieren, der als Caching-Layer für Ihre Abfragen verwendet wird. Ein Caching-Layer existiert als Zwischenstation zwischen Ihren Anwendungsservern und den Back-End-Servern der Datenbank. Er wird verwendet, um eine Verbindung zur Datenbank herzustellen und die Ergebnisse einiger Abfragen für den schnellen Zugriff zu einem späteren Zeitpunkt zu speichern.

      Die Github-Seite ProxySQL Releases bietet Installationsdateien für gängige Linux-Distributionen. Für dieses Tutorial verwenden Sie wget, um die ProxySQL Version 2.0.4 Debian-Installationsdatei herunterzuladen:

      • wget https://github.com/sysown/proxysql/releases/download/v2.0.4/proxysql_2.0.4-ubuntu16_amd64.deb

      Installieren Sie als Nächstes das Paket unter Verwendung von dpkg:

      • sudo dpkg -i proxysql_2.0.4-ubuntu16_amd64.deb

      Nach der Installation starten Sie ProxySQL mit diesem Befehl:

      • sudo systemctl start proxysql

      Ob ProxySQL korrekt gestartet ist, können Sie mit diesem Befehl überprüfen:

      • sudo systemctl status proxysql

      Sie erhalten eine Ausgabe, die der folgenden ähnelt:

      Output

      root@ubuntu-s-1vcpu-2gb-sgp1-01:~# systemctl status proxysql ● proxysql.service - LSB: High Performance Advanced Proxy for MySQL Loaded: loaded (/etc/init.d/proxysql; bad; vendor preset: enabled) Active: active (exited) since Wed 2019-06-12 21:32:50 UTC; 6 months 7 days ago Docs: man:systemd-sysv-generator(8) Tasks: 0 Memory: 0B CPU: 0

      Jetzt ist es an der Zeit, Ihren ProxySQL-Server mit dem MySQL-Server zu verbinden. Verwenden Sie hierzu die ProxySQL Admin-SQL-Schnittstelle, die standardmäßig Port 6032 auf localhost überwacht und als Benutzernamen und Passwort admin hat.

      Stellen Sie die Verbindung mit der Schnittstelle her, indem Sie Folgendes ausführen:

      • mysql -uadmin -p -h 127.0.0.1 -P6032

      Geben Sie admin ein, wenn Sie zur Eingabe des Passworts aufgefordert werden.

      -uadmin legt den Benutzernamen als admin fest und das Flag -h gibt den Host als localhost an. Der Port ist 6032, der mit dem Flag -P angegeben wird.

      Hier mussten Sie den Host und den Port explizit angeben, da der MySQL-Client standardmäßig eine Verbindung über eine lokale Socket-Datei und Port 3306 herstellt.

      Nachdem Sie nun als admin an der mysql-Shell angemeldet sind, konfigurieren Sie den Benutzer monitor, damit ProxySQL ihn verwenden kann. Verwenden Sie zuerst Standard-SQL-Abfragen, um die Werte von zwei globalen Variablen festzulegen:

      • UPDATE global_variables SET variable_value='monitor' WHERE variable_name='mysql-monitor_username';
      • UPDATE global_variables SET variable_value='monitor_password' WHERE variable_name='mysql-monitor_password';

      Die Variable mysql-monitor_username gibt den MySQL-Benutzernamen an, mit dem geprüft wird, ob der Backend-Server aktiv ist oder nicht. Die Variable mysql-monitor_password zeigt auf das Passwort, das bei der Verbindung mit dem Backend-Server verwendet wird. Verwenden Sie das Passwort, das Sie für den Benutzernamen monitor erstellt haben.

      Jedes Mal, wenn Sie eine Änderung in der ProxySQL Admin-Schnittstelle erstellen, müssen Sie den richtigen LOAD-Befehl verwenden, um Änderungen an der laufenden ProxySQL-Instanz vorzunehmen. Sie haben die globalen MySQL-Variablen geändert. Laden Sie sie also in RUNTIME, um die Änderungen anzuwenden:

      • LOAD MYSQL VARIABLES TO RUNTIME;

      Führen Sie als Nächstes SAVE für die Änderungen an der Datenbank auf der Festplatte aus, um die Änderungen zwischen Neustarts persistent zu speichern. ProxySQL verwendet seine eigene lokale SQLite-Datenbank, um seine eigenen Tabellen und Variablen zu speichern:

      • SAVE MYSQL VARIABLES TO DISK;

      Nun werden Sie ProxySQL über den Backend-Server informieren. Die Tabelle mysql_servers enthält Informationen über jeden Backend-Server, mit dem ProxySQL eine Verbindung herstellen und Abfragen ausführen kann. Fügen Sie also einen neuen Datensatz mit einer Standard-SQL-INSERT-Anweisung mit den folgenden Werten für hostgroup_id, hostname und Port hinzu:

      • INSERT INTO mysql_servers(hostgroup_id, hostname, port) VALUES (1, '127.0.0.1', 3306);

      Um die Änderungen anzuwenden, führen Sie LOAD und SAVE erneut aus:

      • LOAD MYSQL SERVERS TO RUNTIME;
      • SAVE MYSQL SERVERS TO DISK;

      Abschließend teilen Sie ProxySQL mit, welcher Benutzer sich mit dem Backend-Server verbinden wird; legen Sie sammy als Benutzer fest und ersetzen Sie sammy_password mit dem zuvor erstellten Passwort:

      • INSERT INTO mysql_users(username, password, default_hostgroup) VALUES ('sammy', 'sammy_password', 1);

      Die Tabelle mysql_users enthält Informationen über die Benutzer, die für die Verbindung zu den Backend-Servern verwendet werden; Sie haben den username, das password und default_hostgroup angegeben.

      Führen Sie LOAD und SAVE aus, um die Änderungen zu laden und zu speichern:

      • LOAD MYSQL USERS TO RUNTIME;
      • SAVE MYSQL USERS TO DISK;

      Beenden Sie dann die mysql-Shell:

      Um zu testen, ob Sie mit ProxySQL eine Verbindung zu Ihrem Backend-Server herstellen können, führen Sie die folgende Testanfrage aus:

      • mysql -usammy -h127.0.0.1 -p -P6033 -e "SELECT @@HOSTNAME as hostname"

      In diesem Befehl haben Sie Flag -e verwendet, um eine Abfrage auszuführen und die Verbindung zu schließen. Die Abfrage gibt den Hostnamen des Backend-Servers aus.

      Anmerkung: ProxySQL verwendet standardmäßig Port 6033 zum Lauschen auf eingehende Verbindungen.

      Die Ausgabe sieht wie folgt aus, wobei your_hostname durch Ihren Hostnamen ersetzt ist:

      Output

      +----------------------------+ | hostname | +----------------------------+ | your_hostname | +----------------------------+

      Um mehr über ProxySQL zu erfahren, lesen Sie Schritt 3 unter So verwenden Sie ProxySQL als Lastenausgleich für MySQL unter Ubuntu 16.04.

      Bisher haben Sie ProxySQL konfiguriert, um Ihren MySQL-Server als Backend zu verwenden und sich mit dem Backend unter Verwendung von ProxySQL zu verbinden. Jetzt können Sie mysqlslap verwenden, um die Abfrageleistung ohne Caching zu vergleichen.

      Schritt 4 – Testen unter Verwendung von mysqlslap ohne Caching

      In diesem Schritt laden Sie eine Testdatenbank herunter, damit Sie mit mysqlslap Abfragen gegen diese Datenbank ausführen können, um die Latenz ohne Caching zu testen, wobei Sie eine Benchmark für die Geschwindigkeit Ihrer Abfragen festlegen. Sie werden auch erfahren, wie ProxySQL Datensätze von Abfragen in der Tabelle stats_mysql_query_digest führt.

      mysqlslap ist ein Lastemulator-Client, der als Auslastungstest-Tool für MySQL verwendet wird. Er kann einen MySQL-Server mit automatisch generierten Abfragen oder mit einigen benutzerdefinierten Abfragen, die in einer Datenbank ausgeführt werden, testen. Er wird mit dem MySQL Client-Paket installiert, sodass Sie ihn nicht installieren müssen; laden Sie stattdessen eine Datenbank nur zu Testzwecken herunter, auf der Sie mysqlslap verwenden können.

      In diesem Tutorial werden Sie eine Beispiel-Mitarbeiter-Datenbank verwenden. Sie verwenden diese Mitarbeiterdatenbank, weil sie einen großen Datensatz enthält, der Unterschiede in der Abfrageoptimierung veranschaulichen kann. Die Datenbank verfügt über sechs Tabellen, aber die darin enthaltenen Daten haben mehr als 300.000 Mitarbeitereinträge. Dies wird Ihnen helfen, eine Auslastung in einer großen Produktivumgebung zu emulieren.

      Um die Datenbank herunterzuladen, klonen Sie zunächst das Github-Repository mit diesem Befehl:

      • git clone https://github.com/datacharmer/test_db.git

      Geben Sie dann das Verzeichnis test_db ein und laden Sie die Datenbank mit diesen Befehlen in den MySQL-Server:

      • cd test_db
      • mysql -uroot -p < employees.sql

      Dieser Befehl verwendet eine Shell-Umleitung, um die SQL-Abfragen in der Datei employees.sql zu lesen und sie auf dem MySQL-Server auszuführen, um die Datenbankstruktur zu erstellen.

      Sie werden eine Ausgabe wie diese sehen:

      Output

      INFO CREATING DATABASE STRUCTURE INFO storage engine: InnoDB INFO LOADING departments INFO LOADING employees INFO LOADING dept_emp INFO LOADING dept_manager INFO LOADING titles INFO LOADING salaries data_load_time_diff 00:00:32

      Sobald die Datenbank in Ihren MySQL-Server geladen ist, testen Sie, ob mysqlslap mit der folgenden Abfrage funktioniert:

      • mysqlslap -usammy -p -P6033 -h127.0.0.1 --auto-generate-sql --verbose

      mysqlslap hat ähnliche Flags wie der mysql-Client; hier sind die in diesem Befehl verwendeten aufgeführt:

      • -u gibt den Benutzer an, der für eine Verbindung mit dem Server verwendet wird.
      • -p fragt nach dem Passwort des Benutzers.
      • -P verbindet sich über den angegebenen Port.
      • -h verbindet sich mit dem angegebenen Host.
      • --auto-generate-sql lässt MySQL Auslastungstests unter Verwendung seiner eigenen erzeugten Abfragen durchführen.
      • --verbose lässt die Ausgabe mehr Informationen anzeigen.

      Sie erhalten eine Ausgabe, die der folgenden ähnelt:

      Output

      Benchmark Average number of seconds to run all queries: 0.015 seconds Minimum number of seconds to run all queries: 0.015 seconds Maximum number of seconds to run all queries: 0.015 seconds Number of clients running queries: 1 Average number of queries per client: 0

      In dieser Ausgabe sehen Sie die durchschnittliche, minimale und maximale Anzahl von Sekunden, die für die Ausführung aller Abfragen aufgewendet wurden. Dies gibt Ihnen einen Hinweis auf die Zeit, die für die Ausführung der Abfragen durch eine Reihe von Clients benötigt wird. In dieser Ausgabe wurde nur ein Client für die Ausführung von Abfragen verwendet.

      Finden Sie als Nächstes heraus, welche Abfragen mysqlslap im letzten Befehl ausgeführt hat, indem Sie sich ProxySQLs stats_mysql_query_digest ansehen. Damit erhalten wird Informationen wie den Digest der Abfragen, der eine normalisierte Form der SQL-Anweisung ist, auf die später verwiesen werden kann, um Caching zu aktivieren.

      Rufen Sie mit diesem Befehl die ProxySQL Admin-Schnittstelle auf:

      • mysql -uadmin -p -h 127.0.0.1 -P6032

      Führen Sie dann diese Abfrage aus, um Informationen in der Tabelle stats_mysql_query_digest zu finden:

      • SELECT count_star,sum_time,hostgroup,digest,digest_text FROM stats_mysql_query_digest ORDER BY sum_time DESC;

      Sie sehen eine Ausgabe, die der folgenden ähnelt:

      +------------+----------+-----------+--------------------+----------------------------------+
      | count_star | sum_time | hostgroup | digest             | digest_text                      |
      +------------+----------+-----------+--------------------+----------------------------------+
      | 1          | 598      | 1         | 0xF8F780C47A8D1D82 | SELECT @@HOSTNAME as hostname    |
      | 1          | 0        | 1         | 0x226CD90D52A2BA0B | select @@version_comment limit ? |
      +------------+----------+-----------+--------------------+----------------------------------+
      2 rows in set (0.01 sec)
      

      Die vorherige Abfrage wählt Daten aus der Tabelle stats_mysql_query_digest aus, die Informationen über alle ausgeführten Abfragen in ProxySQL enthält. Hier haben Sie fünf Spalten ausgewählt:

      • count_star: Die Anzahl, wie oft diese Abfrage ausgeführt wurde.
      • sum_time: Die Gesamtzeit in Millisekunden, die diese Abfrage zur Ausführung benötigt hat.
      • hostgroup: Die Hostgruppe, die zur Ausführung der Abfrage verwendet wurde.
      • digest: Ein Digest der ausgeführten Abfrage.
      • digest_text: Die eigentliche Abfrage. In dem Beispiel dieses Tutorials wird die zweite Abfrage mit ? Markierungen anstelle von variablen Parametern parametrisiert. Daher werden select@@version_comment limit 1 und select @@version_comment limit 2 als die gleiche Abfrage mit dem gleichen Digest gruppiert.

      Nachdem Sie nun wissen, wie Sie Abfragedaten in der Tabelle stats_mysql_query_digest überprüfen, verlassen Sie die mysql-Shell:

      Die von Ihnen heruntergeladene Datenbank enthält einige Tabellen mit Demo-Daten. Sie werden nun Abfragen an der Tabelle dept_emp testen, indem Sie alle Datensätze auswählen, deren from_date größer als 2000-04-20 ist, und die durchschnittliche Ausführungszeit aufzeichnen.

      Verwenden Sie diesen Befehl zur Durchführung des Tests:

      • mysqlslap -usammy -P6033 -p -h127.0.0.1 --concurrency=100 --iterations=20 --create-schema=employees --query="SELECT * from dept_emp WHERE from_date>'2000-04-20'" --verbose

      Hier verwenden Sie einige neue Flags:

      • --concurrency=100: Damit wird die Anzahl der zu simulierenden Benutzer festgelegt, in diesem Fall 100.
      • --iterations=20: Dadurch wird dieser Test 20-mal ausgeführt und Ergebnisse von allen berechnet.
      • --create-schema=employees: Hier haben Sie die Datenbank employees ausgewählt.
      • --query="SELECT * from dept_emp WHERE from_date>'2000-04-20'": Hier haben Sie die in dem Test ausgeführte Abfrage angegeben.

      Der Test dauert einige Minuten. Nachdem er durchgeführt wurde, erhalten Sie ähnliche Ergebnisse wie die folgenden:

      Output

      Benchmark Average number of seconds to run all queries: 18.117 seconds Minimum number of seconds to run all queries: 8.726 seconds Maximum number of seconds to run all queries: 22.697 seconds Number of clients running queries: 100 Average number of queries per client: 1

      Ihre Zahlen können etwas abweichen. Bewahren Sie diese Zahlen auf, um sie mit den Ergebnissen nach dem Aktivieren von Caching zu vergleichen.

      Nach dem Testen von ProxySQL ohne Caching ist es an der Zeit, den gleichen Test erneut durchzuführen, diesmal jedoch mit aktiviertem Caching.

      Schritt 3 – Testen unter Verwendung von mysqlslap mit Caching

      In diesem Schritt hilft uns das Caching, die Latenz bei der Ausführung ähnlicher Abfragen zu verringern. Hier identifizieren Sie die ausgeführten Abfragen, deren Digests aus der Tabelle stats_mysql_query_digest von ProxySQL entnehmen und diese zum Aktivieren des Cachings verwenden. Dann führen Sie einen neuen Test aus, um den Unterschied zu überprüfen.

      Zum Aktivieren des Caching müssen Sie die Digests der Abfragen kennen, die zwischengespeichert werden sollen. Melden Sie sich mit diesem Befehl an der ProxySQL Admin-Schnittstelle an:

      • mysql -uadmin -p -h127.0.0.1 -P6032

      Führen Sie dann diese Abfrage erneut aus, um eine Liste der ausgeführten Abfragen und deren Digests zu erhalten:

      • SELECT count_star,sum_time,hostgroup,digest,digest_text FROM stats_mysql_query_digest ORDER BY sum_time DESC;

      Sie erhalten ein ähnliches Ergebnis wie dieses:

      Output

      +------------+-------------+-----------+--------------------+------------------------------------------+ | count_star | sum_time | hostgroup | digest | digest_text | +------------+-------------+-----------+--------------------+------------------------------------------+ | 2000 | 33727110501 | 1 | 0xC5DDECD7E966A6C4 | SELECT * from dept_emp WHERE from_date>? | | 1 | 601 | 1 | 0xF8F780C47A8D1D82 | SELECT @@HOSTNAME as hostname | | 1 | 0 | 1 | 0x226CD90D52A2BA0B | select @@version_comment limit ? | +------------+-------------+-----------+--------------------+------------------------------------------+ 3 rows in set (0.00 sec)

      Schauen Sie sich die erste Zeile an. Es handelt sich um eine Abfrage, die 2000-mal ausgeführt wurde. Dies ist die zuvor ausgeführte Benchmarking-Abfrage: Speichern Sie ihre Digests, um sie für das Hinzufügen einer Abfrageregel für das Caching zu verwenden.

      Die nächsten Abfragen fügen eine neue Abfrageregel zu ProxySQL hinzu, die mit dem Digest der vorherigen Abfrage übereinstimmt und einen Wert cache_ttl für sie setzt. cache_ttl ist die Anzahl der Millisekunden, die das Ergebnis im Speicher zwischengespeichert wird:

      • INSERT INTO mysql_query_rules(active, digest, cache_ttl, apply) VALUES(1,'0xC5DDECD7E966A6C4',2000,1);

      In diesem Befehl fügen Sie einen neuen Datensatz zu der Tabelle mysql_query_rules hinzu; diese Tabelle enthält alle Regeln, die vor der Ausführung einer Abfrage angewendet wurden. In diesem Beispiel fügen Sie einen Wert für die Spalte cache_ttl hinzu, der bewirkt, dass die übereinstimmende Abfrage durch den gegebenen Digest für eine von dieser Spalte angegebene Anzahl von Millisekunden zwischengespeichert wird. Fügen Sie in der Spalte Anwenden eine 1 ein, um sicherzustellen, dass die Regel auf die Abfragen angewendet wird.

      Führen Sie LOAD und SAVE aus, um diese Änderungen zu laden und zu speichern, und beenden Sie dann die mysql-Shell:

      • LOAD MYSQL QUERY RULES TO RUNTIME;
      • SAVE MYSQL QUERY RULES TO DISK;
      • exit;

      Nachdem das Caching nun aktiviert ist, führen Sie den Test erneut aus, um das Ergebnis zu überprüfen:

      • mysqlslap -usammy -P6033 -p -h127.0.0.1 --concurrency=100 --iterations=20 --create-schema=employees --query="SELECT * from dept_emp WHERE from_date>'2000-04-20'" --verbose

      Dies ergibt eine Ausgabe, die der folgenden ähnelt:

      Output

      Benchmark Average number of seconds to run all queries: 7.020 seconds Minimum number of seconds to run all queries: 0.274 seconds Maximum number of seconds to run all queries: 23.014 seconds Number of clients running queries: 100 Average number of queries per client: 1

      Hier sehen Sie den großen Unterschied in der durchschnittlichen Ausführungszeit: sie fiel von 18.117 Sekunden auf 7.020.

      Zusammenfassung

      In diesem Artikel haben Sie das transparente Caching mit ProxySQL eingerichtet, um die Ergebnisse von Datenbankanfragen zwischenzuspeichern. Sie haben auch die Abfragegeschwindigkeit mit und ohne Caching getestet, um den Unterschied zu sehen, den Caching bewirken kann.

      In diesem Tutorial haben Sie eine Ebene des Caching verwendet. Sie können auch das Web-Caching ausprobieren, das vor einem Webserver sitzt und die Antworten auf ähnliche Anfragen zwischenspeichert und die Antworten an den Client zurücksendet, ohne in den Backend-Servern zu suchen. Dies ist dem ProxySQL Caching sehr ähnlich, aber auf einer anderen Ebene. Um mehr über das Web-Caching zu erfahren, besuchen Sie unsere Einführung Web-Caching-Grundlagen: Terminologie, HTTP-Headers und Caching.

      MySQL-Server verfügt auch über einen eigenen Abfrage-Cache; Sie können in unserem Tutorial So optimieren Sie MySQL mit Abfrage-Cache unter Ubuntu 18.04 mehr darüber erfahren.



      Source link