Der Autor hat dieApache Software Foundationausgewählt, um eine Spende im Rahmen desWrite for DOnations-Programms zu erhalten.
Einführung
Query cache ist eine herausragende Funktion vonMySQL, die das Abrufen von Daten aus einer Datenbank beschleunigt. Dies wird erreicht, indem die Anweisungen von MySQLSELECTzusammen mit dem abgerufenen Datensatz im Speicher gespeichert werden. Wenn ein Client identische Abfragen anfordert, kann er die Daten schneller bereitstellen, ohne erneut Befehle aus der Datenbank ausführen zu müssen.
Im Vergleich zu Daten, die von der Festplatte gelesen werden, haben zwischengespeicherte Daten aus dem RAM (Direktzugriffsspeicher) eine kürzere Zugriffszeit, wodurch die Latenz verringert und die Eingabe- / Ausgabeoperationen (E / A) verbessert werden. Beispielsweise kann bei einer WordPress-Site oder einem E-Commerce-Portal mit häufig gelesenen Aufrufen und seltenen Datenänderungen der Abfrage-Cache die Leistung des Datenbankservers drastisch steigern und die Skalierbarkeit erhöhen.
In diesem Lernprogramm konfigurieren Sie zunächst MySQL ohne Abfragecache und führen Abfragen aus, um festzustellen, wie schnell sie ausgeführt werden. Anschließend richten Sie den Abfrage-Cache ein und testen Ihren MySQL-Server mit aktiviertem Cache, um den Leistungsunterschied anzuzeigen.
[.note] #Note: Obwohl der Abfragecache ab MySQL 5.7.20 veraltet ist und in MySQL 8.0 entfernt wurde, ist er immer noch ein leistungsstarkes Tool, wenn Sie unterstützte Versionen von MySQL verwenden. Wenn Sie jedoch neuere Versionen von MySQL verwenden, können Sie alternative Tools von Drittanbietern wieProxySQL verwenden, um die Leistung Ihrer MySQL-Datenbank zu optimieren.
#
Voraussetzungen
Bevor Sie beginnen, benötigen Sie Folgendes:
-
Ein Ubuntu 18.04-Server, der mit einer Firewall und einem Benutzer ohne Rootberechtigung konfiguriert ist. Informationen zur Konfiguration Ihres Servers finden Sie in der Anleitung zuInitial Server Setup with Ubuntu 18.04.
-
Ein MySQL-Server, der wie in diesem Tutorial vonHow To Install MySQL on Ubuntu 18.04beschrieben eingerichtet wurde. Stellen Sie sicher, dass Sie ein Root-Passwort für den MySQL-Server festgelegt haben.
[[Schritt-1 -—- Überprüfung der Verfügbarkeit des Abfrage-Cache]] == Schritt 1 - Überprüfung der Verfügbarkeit des Abfrage-Cache
Bevor Sie den Abfrage-Cache einrichten, prüfen Sie, ob Ihre Version von MySQL diese Funktion unterstützt. Zuerstssh in Ihren Ubuntu 18.04 Server:
ssh user_name@your_server_ipFühren Sie dann den folgenden Befehl aus, um sich als Root-Benutzer beim MySQL-Server anzumelden:
sudo mysql -u root -pGeben Sie Ihr MySQL-Server-Root-Passwort ein, wenn Sie dazu aufgefordert werden, und drücken Sie dannENTER, um fortzufahren.
Verwenden Sie den folgenden Befehl, um zu überprüfen, ob der Abfragecache unterstützt wird:
show variables like 'have_query_cache';Sie sollten eine Ausgabe ähnlich der folgenden erhalten:
Output+------------------+-------+
| Variable_name | Value |
+------------------+-------+
| have_query_cache | YES |
+------------------+-------+
1 row in set (0.01 sec)Sie können sehen, dass der Wert vonhave_query_cache aufYES festgelegt ist. Dies bedeutet, dass der Abfragecache unterstützt wird. Wenn Sie eine Ausgabe erhalten, aus der hervorgeht, dass Ihre Version den Abfrage-Cache nicht unterstützt, lesen Sie den Hinweis im Abschnitt Einführung, um weitere Informationen zu erhalten.
Nachdem Sie überprüft und bestätigt haben, dass Ihre Version von MySQL den Abfrage-Cache unterstützt, werden Sie die Variablen untersuchen, die diese Funktion auf Ihrem Datenbankserver steuern.
[[Schritt-2 - Überprüfen der Standard-Abfrage-Cache-Variablen]] == Schritt 2 - Überprüfen der Standard-Abfrage-Cache-Variablen
In MySQL steuern eine Reihe von Variablen den Abfrage-Cache. In diesem Schritt überprüfen Sie die mit MySQL gelieferten Standardwerte und verstehen, was die einzelnen Variablen steuern.
Sie können diese Variablen mit dem folgenden Befehl untersuchen:
show variables like 'query_cache_%' ;Sie werden die in Ihrer Ausgabe aufgelisteten Variablen sehen:
Output+------------------------------+----------+
| Variable_name | Value |
+------------------------------+----------+
| query_cache_limit | 1048576 |
| query_cache_min_res_unit | 4096 |
| query_cache_size | 16777216 |
| query_cache_type | OFF |
| query_cache_wlock_invalidate | OFF |
+------------------------------+----------+
5 rows in set (0.00 sec)Der Wertquery_cache_limitbestimmt die maximale Größe der einzelnen Abfrageergebnisse, die zwischengespeichert werden können. Der Standardwert ist 1.048.576 Byte und dies entspricht 1 MB.
MySQL verarbeitet keine zwischengespeicherten Daten in einem großen Block. stattdessen wird es in Blöcken behandelt. Die jedem Block zugewiesene Mindestspeichermenge wird durch die Variablequery_cache_min_res_unitbestimmt. Der Standardwert ist 4096 Byte oder 4 KB.
query_cache_size steuert die Gesamtmenge an Speicher, die dem Abfragecache zugewiesen ist. Wenn der Wert auf Null gesetzt ist, bedeutet dies, dass der Abfragecache deaktiviert ist. In den meisten Fällen kann der Standardwert auf 16.777.216 (ca. 16 MB) festgelegt werden. Beachten Sie außerdem, dassquery_cache_size mindestens 40 KB benötigt, um seine Strukturen zuzuweisen. Der hier zugewiesene Wert ist auf den nächsten 1024-Byte-Block ausgerichtet. Dies bedeutet, dass der gemeldete Wert möglicherweise geringfügig von Ihrer Einstellung abweicht.
MySQL ermittelt die Caches, die zwischengespeichert werden sollen, indem die Variablequery_cache_typeuntersucht wird. Wenn Sie diesen Wert auf0 oderOFF setzen, wird das Zwischenspeichern oder Abrufen zwischengespeicherter Abfragen verhindert. Sie können es auch auf1 setzen, um das Caching für alle Abfragen zu aktivieren, mit Ausnahme derjenigen, die mit der AnweisungSELECT SQL_NO_CACHEbeginnen. Der Wert2 weist MySQL an, nur Abfragen zwischenzuspeichern, die mit dem BefehlSELECT SQL_CACHEbeginnen.
Die Variablequery_cache_wlock_invalidate steuert, ob MySQL Ergebnisse aus dem Cache abrufen soll, wenn die für die Abfrage verwendete Tabelle gesperrt ist. Der Standardwert istOFF.
[.note] #Note: Die Variablequery_cache_wlock_invalidate ist ab MySQL Version 5.7.20 veraltet. Infolgedessen wird dies in Ihrer Ausgabe möglicherweise nicht angezeigt, abhängig von der verwendeten MySQL-Version.
#
Nachdem Sie die Systemvariablen überprüft haben, die den MySQL-Abfrage-Cache steuern, testen Sie die Leistung von MySQL, ohne zuvor die Funktion zu aktivieren.
[[Schritt 3 - Testen Ihres MySQL-Servers ohne Abfrage-Cache] == Schritt 3 - Testen Ihres MySQL-Servers ohne Abfrage-Cache
Ziel dieses Tutorials ist es, Ihren MySQL-Server mithilfe der Abfrage-Cache-Funktion zu optimieren. Um den Geschwindigkeitsunterschied festzustellen, werden Sie Abfragen ausführen und deren Leistung vor und nach der Implementierung der Funktion überprüfen.
In diesem Schritt erstellen Sie eine Beispieldatenbank und fügen einige Daten ein, um zu sehen, wie sich MySQL ohne Abfragecache verhält.
Während Sie noch bei Ihrem MySQL-Server angemeldet sind, erstellen Sie eine Datenbank und benennen Sie siesample_db, indem Sie den folgenden Befehl ausführen:
Create database sample_db;OutputQuery OK, 1 row affected (0.00 sec)Dann wechseln Sie in die Datenbank:
Use sample_db;OutputDatabase changedErstellen Sie eine Tabelle mit zwei Feldern (customer_id undcustomer_name) und nennen Sie siecustomers:
Create table customers (customer_id INT PRIMARY KEY, customer_name VARCHAR(50) NOT NULL) Engine = InnoDB;OutputQuery OK, 0 rows affected (0.01 sec)Führen Sie dann die folgenden Befehle aus, um einige Beispieldaten einzufügen:
Insert into customers(customer_id, customer_name) values ('1', 'JANE DOE');
Insert into customers(customer_id, customer_name) values ('2', 'JANIE DOE');
Insert into customers(customer_id, customer_name) values ('3', 'JOHN ROE');
Insert into customers(customer_id, customer_name) values ('4', 'MARY ROE');
Insert into customers(customer_id, customer_name) values ('5', 'RICHARD ROE');
Insert into customers(customer_id, customer_name) values ('6', 'JOHNNY DOE');
Insert into customers(customer_id, customer_name) values ('7', 'JOHN SMITH');
Insert into customers(customer_id, customer_name) values ('8', 'JOE BLOGGS');
Insert into customers(customer_id, customer_name) values ('9', 'JANE POE');
Insert into customers(customer_id, customer_name) values ('10', 'MARK MOE');OutputQuery OK, 1 row affected (0.01 sec)
Query OK, 1 row affected (0.00 sec)
...Der nächste Schritt ist das Starten vonMySQL profiler, einem Analysedienst zur Überwachung der Leistung von MySQL-Abfragen. Führen Sie den folgenden Befehl aus, um das Profil für die aktuelle Sitzung zu aktivieren, und setzen Sie es auf1, das aktiviert ist:
SET profiling = 1;OutputQuery OK, 0 rows affected, 1 warning (0.00 sec)Führen Sie dann die folgende Abfrage aus, um alle Kunden abzurufen:
Select * from customers;Sie erhalten folgende Ausgabe:
Output+-------------+---------------+
| customer_id | customer_name |
+-------------+---------------+
| 1 | JANE DOE |
| 2 | JANIE DOE |
| 3 | JOHN ROE |
| 4 | MARY ROE |
| 5 | RICHARD ROE |
| 6 | JOHNNY DOE |
| 7 | JOHN SMITH |
| 8 | JOE BLOGGS |
| 9 | JANE POE |
| 10 | MARK MOE |
+-------------+---------------+
10 rows in set (0.00 sec)Führen Sie dann den BefehlSHOW PROFILES aus, um Leistungsinformationen zu der gerade ausgeführten AbfrageSELECTabzurufen:
SHOW PROFILES;Sie erhalten eine Ausgabe ähnlich der folgenden:
Output+----------+------------+-------------------------+
| Query_ID | Duration | Query |
+----------+------------+-------------------------+
| 1 | 0.00044075 | Select * from customers |
+----------+------------+-------------------------+
1 row in set, 1 warning (0.00 sec)Die Ausgabe zeigt die Gesamtzeit an, die MySQL beim Abrufen von Datensätzen aus der Datenbank benötigt. Sie werden diese Daten in den nächsten Schritten vergleichen, wenn der Abfragecache aktiviert ist. Notieren Sie sich also IhreDuration. Sie können die Warnung in der Ausgabe ignorieren, da dies lediglich anzeigt, dass der BefehlSHOW PROFILES in einer zukünftigen MySQL-Version entfernt und durchPerformance Schema ersetzt wird.
Beenden Sie als Nächstes die MySQL-Befehlszeilenschnittstelle.
quit;Sie haben eine Abfrage mit MySQL ausgeführt, bevor Sie den Abfragecache aktiviert haben, und dieDuration oder die Zeit notiert, die zum Abrufen von Datensätzen aufgewendet wurde. Als Nächstes aktivieren Sie den Abfrage-Cache und prüfen, ob es bei der Ausführung derselben Abfrage zu einer Leistungssteigerung kommt.
[[Schritt 4 - Einrichten des Abfrage-Cache]] == Schritt 4 - Einrichten des Abfrage-Cache
Im vorherigen Schritt haben Sie Beispieldaten erstellt und eineSELECT-Anweisung ausgeführt, bevor Sie den Abfragecache aktiviert haben. In diesem Schritt aktivieren Sie den Abfrage-Cache, indem Sie die MySQL-Konfigurationsdatei bearbeiten.
Verwenden Sienano, um die Datei zu bearbeiten:
sudo nano /etc/mysql/my.cnfFügen Sie die folgenden Informationen am Ende Ihrer Datei hinzu:
/etc/mysql/my.cnf
...
[mysqld]
query_cache_type=1
query_cache_size = 10M
query_cache_limit=256KHier haben Sie den Abfragecache aktiviert, indem Siequery_cache_type auf1 gesetzt haben. Sie haben auch die individuelle Abfragegrenzengröße auf256K festgelegt und MySQL angewiesen,10 Megabyte für den Abfragecache zuzuweisen, indem Sie den Wert vonquery_cache_size auf10M setzen.
Speichern und schließen Sie die Datei, indem SieCTRL +X,Y und dannENTER drücken. Starten Sie dann Ihren MySQL-Server neu, um die Änderungen zu implementieren:
sudo systemctl restart mysqlSie haben jetzt den Abfrage-Cache aktiviert.
Nachdem Sie den Abfrage-Cache konfiguriert und MySQL neu gestartet haben, um die Änderungen zu übernehmen, testen Sie die Leistung von MySQL mit aktivierter Funktion.
[[Schritt 5 - Testen Ihres MySQL-Servers mit aktiviertem Abfrage-Cache]] == Schritt 5 - Testen Ihres MySQL-Servers mit aktiviertem Abfrage-Cache
In diesem Schritt führen Sie dieselbe Abfrage wie in Schritt 3 noch einmal aus, um zu überprüfen, wie der Abfrage-Cache die Leistung Ihres MySQL-Servers optimiert hat.
Stellen Sie zunächst als Benutzer vonrooteine Verbindung zu Ihrem MySQL-Server her:
sudo mysql -u root -pGeben Sie Ihrroot-Kennwort für den Datenbankserver ein und drücken SieENTER, um fortzufahren.
Bestätigen Sie nun Ihren Konfigurationssatz im vorherigen Schritt, um sicherzustellen, dass Sie den Abfrage-Cache aktiviert haben:
show variables like 'query_cache_%' ;Sie sehen die folgende Ausgabe:
Output+------------------------------+----------+
| Variable_name | Value |
+------------------------------+----------+
| query_cache_limit | 262144 |
| query_cache_min_res_unit | 4096 |
| query_cache_size | 10485760 |
| query_cache_type | ON |
| query_cache_wlock_invalidate | OFF |
+------------------------------+----------+
5 rows in set (0.01 sec)Die Variablequery_cache_type wird aufON gesetzt; Dies bestätigt, dass Sie den Abfragecache mit den im vorherigen Schritt definierten Parametern aktiviert haben.
Wechseln Sie zur zuvor erstelltensample_db-Datenbank.
Use sample_db;Starten Sie den MySQL-Profiler:
SET profiling = 1;Führen Sie dann die Abfrage aus, um alle Kunden mindestens zweimal abzurufen, um genügend Profilinformationen zu generieren.
Denken Sie daran, dass MySQL nach dem Ausführen der ersten Abfrage einen Cache mit den Ergebnissen erstellt. Daher müssen Sie die Abfrage zweimal ausführen, um den Cache auszulösen:
Select * from customers;
Select * from customers;Listen Sie dann die Profilinformationen auf:
SHOW PROFILES;Sie erhalten eine Ausgabe ähnlich der folgenden:
Output+----------+------------+-------------------------+
| Query_ID | Duration | Query |
+----------+------------+-------------------------+
| 1 | 0.00049250 | Select * from customers |
| 2 | 0.00026000 | Select * from customers |
+----------+------------+-------------------------+
2 rows in set, 1 warning (0.00 sec)Wie Sie sehen, hat sich die zum Ausführen der Abfrage benötigte Zeit in diesem Schritt drastisch von0.00044075 (ohne Abfragecache in Schritt 3) auf0.00026000 (die zweite Abfrage) verringert.
Sie können die Optimierung anhand der Aktivierung der Abfrage-Cache-Funktion sehen, indem Sie die erste Abfrage im Detail profilieren:
SHOW PROFILE FOR QUERY 1;Output+--------------------------------+----------+
| Status | Duration |
+--------------------------------+----------+
| starting | 0.000025 |
| Waiting for query cache lock | 0.000004 |
| starting | 0.000003 |
| checking query cache for query | 0.000045 |
| checking permissions | 0.000008 |
| Opening tables | 0.000014 |
| init | 0.000018 |
| System lock | 0.000008 |
| Waiting for query cache lock | 0.000002 |
| System lock | 0.000018 |
| optimizing | 0.000003 |
| statistics | 0.000013 |
| preparing | 0.000010 |
| executing | 0.000003 |
| Sending data | 0.000048 |
| end | 0.000004 |
| query end | 0.000006 |
| closing tables | 0.000006 |
| freeing items | 0.000006 |
| Waiting for query cache lock | 0.000003 |
| freeing items | 0.000213 |
| Waiting for query cache lock | 0.000019 |
| freeing items | 0.000002 |
| storing result in query cache | 0.000003 |
| cleaning up | 0.000012 |
+--------------------------------+----------+
25 rows in set, 1 warning (0.00 sec)Führen Sie den folgenden Befehl aus, um Profilinformationen für die zweite zwischengespeicherte Abfrage anzuzeigen:
SHOW PROFILE FOR QUERY 2;Output+--------------------------------+----------+
| Status | Duration |
+--------------------------------+----------+
| starting | 0.000024 |
| Waiting for query cache lock | 0.000003 |
| starting | 0.000002 |
| checking query cache for query | 0.000006 |
| checking privileges on cached | 0.000003 |
| checking permissions | 0.000027 |
| sending cached result to clien | 0.000187 |
| cleaning up | 0.000008 |
+--------------------------------+----------+
8 rows in set, 1 warning (0.00 sec)Die Ausgaben des Profilers zeigen, dass MySQL bei der zweiten Abfrage weniger Zeit in Anspruch nahm, da es Daten aus dem Abfrage-Cache abrufen konnte, anstatt sie von der Festplatte zu lesen. Sie können die beiden Ausgabesätze für jede der Abfragen vergleichen. Wenn Sie sich die Profilinformationen zuQUERY 2 ansehen, zeigt der Status vonsending cached result to client, dass Daten aus dem Cache gelesen wurden und keine Tabellen geöffnet wurden, da der Status vonOpening tablesfehlt.
Wenn die MySQL-Abfrage-Cache-Funktion auf Ihrem Server aktiviert ist, werden Sie jetzt eine verbesserte Lesegeschwindigkeit feststellen.
Fazit
Sie haben den Abfrage-Cache eingerichtet, um Ihren MySQL-Server unter Ubuntu 18.04 zu beschleunigen. Durch die Verwendung von Funktionen wie dem Abfrage-Cache von MySQL kann die Geschwindigkeit Ihrer Website oder Webanwendung gesteigert werden. Das Zwischenspeichern reduziert die unnötige Ausführung von SQL-Anweisungen und ist eine sehr empfohlene und beliebte Methode zur Optimierung Ihrer Datenbank. Weitere Informationen zur Beschleunigung Ihres MySQL-Servers finden Sie im TutorialHow To Set Up a Remote Database to Optimize Site Performance with MySQL on Ubuntu 18.04.