Comment optimiser MySQL avec Query Cache sur Ubuntu 18.04

L'auteur a sélectionné lesApache Software Foundation pour recevoir un don dans le cadre du programmeWrite for DOnations.

introduction

Query cache est une fonctionMySQL importante qui accélère la récupération des données à partir d'une base de données. Il y parvient en stockant les instructions MySQLSELECT avec le jeu d'enregistrements récupéré en mémoire, puis si un client demande des requêtes identiques, il peut servir les données plus rapidement sans exécuter à nouveau les commandes de la base de données.

Comparées aux données lues sur le disque, les données en cache de la RAM (Random Access Memory) ont un temps d’accès plus court, ce qui réduit le temps de latence et améliore les opérations d’entrée / sortie (E / S). Par exemple, pour un site WordPress ou un portail de commerce électronique avec un nombre d'appels en lecture élevé et des modifications de données peu fréquentes, le cache de requêtes peut considérablement améliorer les performances du serveur de base de données et le rendre plus évolutif.

Dans ce tutoriel, vous allez d'abord configurer MySQL sans cache de requête et exécuter des requêtes pour voir à quelle vitesse elles sont exécutées. Ensuite, vous allez configurer le cache de requêtes et tester votre serveur MySQL avec ce dernier activé pour montrer la différence de performances.

[.note] #Note: Bien que le cache de requêtes soit obsolète à partir de MySQL 5.7.20 et supprimé dans MySQL 8.0, il reste un outil puissant si vous utilisez des versions prises en charge de MySQL. Cependant, si vous utilisez des versions plus récentes de MySQL, vous pouvez adopter d'autres outils tiers tels queProxySQL pour optimiser les performances de votre base de données MySQL.
#

Conditions préalables

Avant de commencer, vous aurez besoin des éléments suivants:

[[step-1 -—- checking-the-availability-of-query-cache]] == Étape 1 - Vérification de la disponibilité du cache de requêtes

Avant de configurer le cache de requêtes, vous allez vérifier si votre version de MySQL prend en charge cette fonctionnalité. Tout d'abord,ssh dans votre serveur Ubuntu 18.04:

ssh user_name@your_server_ip

Ensuite, exécutez la commande suivante pour vous connecter au serveur MySQL en tant qu'utilisateur root:

sudo mysql -u root -p

Entrez le mot de passe racine de votre serveur MySQL lorsque vous y êtes invité, puis appuyez surENTER pour continuer.

Utilisez la commande suivante pour vérifier si le cache de requête est pris en charge:

show variables like 'have_query_cache';

Vous devriez obtenir un résultat similaire à celui-ci:

Output+------------------+-------+
| Variable_name    | Value |
+------------------+-------+
| have_query_cache | YES   |
+------------------+-------+
1 row in set (0.01 sec)

Vous pouvez voir que la valeur dehave_query_cache est définie surYES et cela signifie que le cache de requête est pris en charge. Si vous recevez une sortie indiquant que votre version ne prend pas en charge le cache de requêtes, veuillez consulter la remarque de la section Introduction pour plus d'informations.

Maintenant que vous avez vérifié et confirmé que votre version de MySQL prend en charge le cache de requêtes, passez à l'examen des variables contrôlant cette fonctionnalité sur votre serveur de base de données.

[[step-2 -—- checking-the-default-query-cache-variables]] == Étape 2 - Vérification des variables de cache de requête par défaut

Dans MySQL, un certain nombre de variables contrôlent le cache de requêtes. Au cours de cette étape, vous allez vérifier les valeurs par défaut fournies avec MySQL et comprendre ce que chaque variable contrôle.

Vous pouvez examiner ces variables à l'aide de la commande suivante:

show variables like 'query_cache_%' ;

Vous verrez les variables listées dans votre sortie:

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)

La valeurquery_cache_limit détermine la taille maximale des résultats de requête individuels qui peuvent être mis en cache. La valeur par défaut est 1 048 576 octets, ce qui équivaut à 1 Mo.

MySQL ne gère pas les données mises en cache dans un gros morceau; au lieu de cela il est manipulé dans les blocs. La quantité minimale de mémoire allouée à chaque bloc est déterminée par la variablequery_cache_min_res_unit. La valeur par défaut est 4096 octets ou 4 Ko.

query_cache_size contrôle la quantité totale de mémoire allouée au cache de requêtes. Si la valeur est définie sur zéro, cela signifie que le cache de requête est désactivé. Dans la plupart des cas, la valeur par défaut peut être définie sur 16 777 216 (environ 16 Mo). Gardez également à l'esprit quequery_cache_size a besoin d'au moins 40 Ko pour allouer ses structures. La valeur attribuée ici est alignée sur le bloc de 1024 octets le plus proche. Cela signifie que la valeur indiquée peut être légèrement différente de celle que vous avez définie.

MySQL détermine les requêtes à mettre en cache en examinant la variablequery_cache_type. La définition de cette valeur sur0 ouOFF empêche la mise en cache ou la récupération des requêtes mises en cache. Vous pouvez également le définir sur1 pour activer la mise en cache pour toutes les requêtes à l'exception de celles commençant par l'instructionSELECT SQL_NO_CACHE. Une valeur de2 indique à MySQL de ne mettre en cache que les requêtes commençant par la commandeSELECT SQL_CACHE.

La variablequery_cache_wlock_invalidate contrôle si MySQL doit récupérer les résultats du cache si la table utilisée sur la requête est verrouillée. La valeur par défaut estOFF.

[.note] #Note: La variablequery_cache_wlock_invalidate est obsolète à partir de la version 5.7.20 de MySQL. En conséquence, cela peut ne pas apparaître dans votre sortie en fonction de la version de MySQL que vous utilisez.
#

Après avoir examiné les variables système qui contrôlent le cache de requêtes MySQL, vous allez maintenant tester le fonctionnement de MySQL sans d'abord activer la fonctionnalité.

[[step-3 -—- testing-your-mysql-server-without-query-cache]] == Étape 3 - Test de votre serveur MySQL sans cache de requêtes

Le but de ce tutoriel est d’optimiser votre serveur MySQL en utilisant la fonctionnalité de cache de requêtes. Pour voir la différence de vitesse, vous allez exécuter des requêtes et voir leurs performances avant et après la mise en œuvre de la fonctionnalité.

Dans cette étape, vous allez créer un exemple de base de données et insérer des données pour voir comment MySQL fonctionne sans cache de requêtes.

Tout en restant connecté à votre serveur MySQL, créez une base de données et nommez-lasample_db en exécutant la commande suivante:

Create database sample_db;
OutputQuery OK, 1 row affected (0.00 sec)

Puis passez à la base de données:

Use sample_db;
OutputDatabase changed

Créez une table avec deux champs (customer_id etcustomer_name) et nommez-lacustomers:

Create table customers (customer_id INT PRIMARY KEY, customer_name VARCHAR(50) NOT NULL) Engine = InnoDB;
OutputQuery OK, 0 rows affected (0.01 sec)

Ensuite, exécutez les commandes suivantes pour insérer des exemples de données:

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

L'étape suivante consiste à démarrer leMySQL profiler, qui est un service d'analyse pour surveiller les performances des requêtes MySQL. Pour activer le profil pour la session en cours, exécutez la commande suivante en le définissant sur1, qui est activé:

SET profiling = 1;
OutputQuery OK, 0 rows affected, 1 warning (0.00 sec)

Ensuite, exécutez la requête suivante pour récupérer tous les clients:

Select * from customers;

Vous recevrez le résultat suivant:

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)

Ensuite, exécutez la commandeSHOW PROFILES pour récupérer les informations de performances sur la requêteSELECT que vous venez d'exécuter:

SHOW PROFILES;

Vous obtiendrez une sortie similaire à celle-ci:

Output+----------+------------+-------------------------+
| Query_ID | Duration   | Query                   |
+----------+------------+-------------------------+
|        1 | 0.00044075 | Select * from customers |
+----------+------------+-------------------------+
1 row in set, 1 warning (0.00 sec)

La sortie indique le temps total passé par MySQL lors de la récupération des enregistrements de la base de données. Vous allez comparer ces données dans les étapes suivantes lorsque le cache de requêtes est activé, alors notez vosDuration. Vous pouvez ignorer l'avertissement dans la sortie car cela indique simplement que la commandeSHOW PROFILES sera supprimée dans une future version de MySQL et remplacée parPerformance Schema.

Ensuite, quittez l'interface de ligne de commande MySQL.

quit;

Vous avez exécuté une requête avec MySQL avant d'activer le cache de requêtes et noté lesDuration ou le temps passé à récupérer les enregistrements. Ensuite, vous allez activer le cache de requête et voir s'il y a une amélioration des performances lors de l'exécution de la même requête.

[[step-4 -—- setting-up-query-cache]] == Étape 4 - Configuration du cache de requêtes

À l'étape précédente, vous avez créé des exemples de données et exécuté une instructionSELECT avant d'activer le cache de requêtes. Dans cette étape, vous activerez le cache de requêtes en modifiant le fichier de configuration MySQL.

Utiliseznano pour éditer le fichier:

sudo nano /etc/mysql/my.cnf

Ajoutez les informations suivantes à la fin de votre fichier:

/etc/mysql/my.cnf

...
[mysqld]
query_cache_type=1
query_cache_size = 10M
query_cache_limit=256K

Ici, vous avez activé le cache de requêtes en définissantquery_cache_type sur1. Vous avez également défini la taille de limite de requête individuelle sur256K et demandé à MySQL d'allouer10 mégaoctets au cache de requête en définissant la valeur dequery_cache_size sur10M.

Enregistrez et fermez le fichier en appuyant surCTRL +X,Y, puisENTER. Ensuite, redémarrez votre serveur MySQL pour implémenter les modifications:

sudo systemctl restart mysql

Vous avez maintenant activé le cache de requêtes.

Une fois que vous avez configuré le cache de requête et redémarré MySQL pour appliquer les modifications, vous pouvez tester les performances de MySQL avec la fonctionnalité activée.

[[step-5 -—- testing-your-mysql-server-with-query-cache-enabled]] == Étape 5 - Test de votre serveur MySQL avec le cache de requêtes activé

Au cours de cette étape, vous exécuterez une nouvelle fois la même requête que celle exécutée à l'étape 3 pour vérifier comment le cache de requêtes optimise les performances de votre serveur MySQL.

Tout d'abord, connectez-vous à votre serveur MySQL en tant qu'utilisateurroot:

sudo mysql -u root -p

Entrez votre mot de passeroot pour le serveur de base de données et appuyez surENTER pour continuer.

Maintenant, confirmez votre configuration définie à l'étape précédente pour vous assurer d'activer le cache de requêtes:

show variables like 'query_cache_%' ;

Vous verrez le résultat suivant:

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)

La variablequery_cache_type est définie surON; cela confirme que vous avez activé le cache de requêtes avec les paramètres définis à l'étape précédente.

Basculez vers la base de donnéessample_db que vous avez créée précédemment.

Use sample_db;

Démarrez le profileur MySQL:

SET profiling = 1;

Ensuite, exécutez la requête pour extraire tous les clients au moins deux fois afin de générer suffisamment d'informations de profilage.

N'oubliez pas qu'une fois que vous avez exécuté la première requête, MySQL créera un cache des résultats. Par conséquent, vous devez l'exécuter deux fois pour déclencher le cache:

Select * from customers;
Select * from customers;

Ensuite, listez les informations de profils:

SHOW PROFILES;

Vous recevrez une sortie semblable à celle-ci:

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)

Comme vous pouvez le voir, le temps nécessaire à l'exécution de la requête a considérablement diminué de0.00044075 (sans cache de requête à l'étape 3) à0.00026000 (la deuxième requête) à cette étape.

Vous pouvez voir l'optimisation de l'activation de la fonctionnalité de cache de requête en profilant la première requête en détail:

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)

Exécutez la commande suivante pour afficher les informations de profil de la deuxième requête, qui est mise en cache:

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)

Les résultats du profileur montrent que MySQL a pris moins de temps pour la deuxième requête, car il était capable de récupérer des données à partir du cache de requêtes au lieu de les lire à partir du disque. Vous pouvez comparer les deux ensembles de résultats pour chacune des requêtes. Si vous regardez les informations de profil surQUERY 2, l'état desending cached result to client indique que les données ont été lues à partir du cache et qu'aucune table n'a été ouverte car l'état deOpening tables est manquant.

Avec la fonctionnalité de cache de requêtes MySQL activée sur votre serveur, la vitesse de lecture sera améliorée.

Conclusion

Vous avez configuré le cache de requêtes pour accélérer votre serveur MySQL sur Ubuntu 18.04. L'utilisation de fonctionnalités telles que le cache de requêtes de MySQL peut améliorer la vitesse de votre site Web ou de votre application Web. La mise en cache réduit l'exécution inutile des instructions SQL. Il s'agit d'une méthode hautement recommandée et largement répandue pour optimiser votre base de données. Pour en savoir plus sur l'accélération de votre serveur MySQL, essayez le didacticielHow To Set Up a Remote Database to Optimize Site Performance with MySQL on Ubuntu 18.04.

Related