Ajustez les paramètres d’exécution de MySQL, modifiez le fichier /etc/my.cnf Ajustez les paramètres d’exécution de MySQL pour qu’ils prennent effet après un redémarrage de MySQL, après la version 4 de MySQL, certaines variables internes peuvent être définies à l’exécution de MySQL, mais cela sera invalide lors du redémarrage de MySQL.
Programme mysqLD - Annuaires et fichiers
basedir = chemin # Utilisez le répertoire donné comme répertoire racine (répertoire d’installation).
datadir = chemin # Lire le fichier de base de données à partir d’un répertoire donné.
pid-file = nom de fichier # Spécifier un fichier pour le programme mysqld afin de stocker l’ID du processus (disponible uniquement pour les systèmes UNIX/Linux) ;
[mysqld]
socket = /tmp/mysql.sock # Spécifie un fichier socket pour la communication locale entre le programme client MySQL et le serveur (par défaut est le fichier /var/lib/mysql/mysql.sock sous Linux)
port=3306 # Spécifie le port que MsSQL écoute
key_buffer = 384M # key_buffer est la taille du tampon utilisé pour indexer les blocs, augmentant ainsi l’index qu’il gère mieux (pour toutes les lectures et écritures multiples).
Le bloc d’index est mis en mémoire tampon et partagé par tous les threads, et la taille du key_buffer dépend de la taille de la mémoire.
table_cache = 512 # Le nombre de tables ouvertes pour tous les threads. Augmenter cette valeur augmente le nombre de descripteurs de fichier requis par mysqld. Cela évite la surcharge d’ouvrir fréquemment des tables de données
sort_buffer_size = 2M # Allouez un tampon de cette taille pour chaque thread à trier. Augmenter cette valeur accélère les opérations ORDER BY ou GROUP BY.
Note : La mémoire allouée correspondant à ce paramètre est exclusive à chaque connexion ! S’il y a 100 connexions, alors la taille totale du tampon de tri réellement allouée est de 100×6 = 600 Mo
read_buffer_size = 2M # La taille du tampon pouvant être utilisé pour l’opération de lecture de requête. Comme pour sort_buffer_size, la mémoire allouée correspondant à ce paramètre est également exclusive à chaque connexion.
query_cache_size = 32M # Spécifie la taille du tampon de résultats de requête MySQL
read_rnd_buffer_size = 8M # Changez le paramètre à lire aléatoirement après tri en utilisant le pointeur de ligne.
myisam_sort_buffer_size =64M # Tampon requis pour réorganiser les tables MyISAM lorsqu’elles changent
thread_concurrency = 8 # Le nombre maximal de threads concurrents est fixé comme le nombre de processeurs logiques des serveurs ×2, et si le processeur supporte l’hyperthreading H.T, × 2
thread_cache = 8 # #缓存可重用的线程数
Le verrouillage en saut # évite le verrouillage externe de MySQL, réduit le risque d’erreurs et améliore la stabilité.
[mysqldump]
max_allowed_packet =16M # Le paquet d’information maximal pouvant être envoyé entre le serveur et le client
[myisamchk]
key_buffer = 256M
sort_buffer = 256M
read_buffer = 2M
write_buffer = 2M
Autres paramètres optionnels :
back_log = 384
Spécifie le nombre de connexions possibles pour MySQL.
Lorsque le thread principal MySQL reçoit un très grand nombre de requêtes de connexion en très peu de temps, ce paramètre prend effet, et le thread principal met un court temps à vérifier la connexion et à en lancer un nouveau.
La valeur du paramètre back_log indique combien de requêtes peuvent être stockées dans la pile pendant une courte période avant que MySQL ne cesse temporairement de répondre aux nouvelles requêtes.
Si le système dispose de nombreuses connexions en peu de temps, il est nécessaire d’augmenter la valeur de ce paramètre, qui spécifie la taille de la file d’attente d’écoute pour les connexions TCP/IP entrantes.
Essayer de fixer une limite supérieure back_log à celle de votre système d’exploitation sera inefficace. La valeur par défaut est 50. Pour les systèmes Linux, il est recommandé de définir un entier inférieur à 512.
max_connections = n
Le nombre maximal de connexions à la base de données que le serveur MySQL peut gérer simultanément (le réglage par défaut est 100). Si la limite est dépassée, l’erreur de trop nombreuses connexions sera signalée
key_buffer_size = n
Valeur RMA pour les blocs d’index (réglage par défaut est 8M), augmentation de l’index pour une meilleure gestion (pour toutes les lectures et écritures multiples)
record_buffer :
Chaque thread effectuant un balayage séquentiel alloue un tampon de cette taille à chaque table qu’il scanne.
Si vous faites beaucoup de scans séquentiels, vous voudrez peut-être augmenter cette valeur. La valeur par défaut est 131072 (128K)
wait_timeout :
Le nombre de secondes que le serveur attend pour une action sur une connexion avant de la fermer.
interactive_timeout :
Le nombre de secondes que le serveur attend pour une action sur une connexion interactive avant de la fermer.
Un client interactif est défini comme un client qui utilise l’option CLIENT_INTERACTIVE pour mysql_real_connect().
La valeur par défaut est 28800, vous pouvez la changer en 3600.
Sauter-nom-résoudre
Désactivez MySQL de la résolution DNS sur les connexions externes, en utilisant cette option, cela élimine le temps nécessaire à MySQL pour résoudre le DNS.
Cependant, il convient de noter que si cette option est activée, toute autorisation de connexion hôte distante doit utiliser la méthode de l’adresse IP, sinon MySQL ne pourra pas traiter la requête de connexion normalement !
log-requêtes lentes = slow.log
Enregistrez les requêtes lentes et optimisez-les une par une
skip-innodb
Skip-BDB
Fermez les types de tables indésirables et n’ajoutez pas cela si besoin
# > MONTRENT DES VARIABLES COMME ' %query_cache %' ;
# > AFFICHER LE STATUT COMME 'Qcache %' ;
Si la valeur de Qcache_lowmem_prunes est très élevée, cela indique qu’il y a souvent un tampon insuffisant ;
Si la valeur de la Qcache_hits est très grande, cela indique que le tampon de requête est utilisé très fréquemment, et si la valeur est faible mais affecte l’efficacité, alors vous pouvez envisager de ne pas utiliser de tampon de requête.
Si la valeur de Qcache_free_blocks est très élevée, cela indique qu’il y a beaucoup de débris dans le tampon.
##########################################
###### max_allowed_packet ######
##########################################
Un paquet de communication est une seule instruction SQL envoyée au serveur MySQL ou une seule ligne au client.
Le paquet maximum possible pouvant être envoyé entre le serveur MySQL 5.1 et le client est de 1 Go.
Lorsqu’un client MySQL ou un serveur mysqld reçoit un paquet de plus de max_allowed_packet octets, une erreur « paquet trop gros » est émise et la connexion est fermée. Pour certains clients, si le paquet de communication est trop volumineux, vous pouvez rencontrer l’erreur « Perte de connexion au serveur MySQL » lors de la requête.
Le client et le serveur ont chacun leurs propres variables max_allowed_packet, donc si vous prévoyez de gérer de gros paquets, vous devez ajouter cette variable à la fois sur le client et sur le serveur.
Si vous utilisez un programme client mysql, sa variable de max_allowed_packet est par défaut de 16 Mo. Pour définir une valeur plus grande, vous pouvez commencer mysql de la manière suivante :
mysql> mysql --max_allowed_packet=32M
Il règle la taille du paquet d’information à 32 Mo.
La valeur par défaut de max_allowed_packet du serveur est de 1 Mo. Si le serveur doit traiter de grandes requêtes, vous pouvez augmenter cette valeur (par exemple, si vous préparez à traiter de grandes colonnes de blob). Par exemple, pour la régler à 16 Mo, vous pouvez démarrer le serveur comme suit :
mysql> mysqld --max_allowed_packet=16M
Vous pouvez aussi utiliser des fichiers options pour définir max_allowed_packet. Pour définir cette variable pour le serveur à 16 Mo, ajoutez le contenu de la liaison descendante au fichier options :
[mysqld]
max_allowed_packet=16M
Il est sûr d’augmenter la valeur de cette variable car de la mémoire supplémentaire n’est allouée que lorsque nécessaire. Par exemple, mysqld n’allouera plus de mémoire que si vous émettez une requête longue ou mysqld doit retourner de grandes lignes de résultat. La petite valeur par défaut de cette variable est une mesure de précaution pour détecter les paquets d’erreur entre le client et le serveur et pour s’assurer que les débordements de mémoire ne soient pas causés par l’utilisation accidentelle de gros paquets.
Si vous utilisez de grandes valeurs de blob et que vous n’accordez pas la permission à mysqld d’accéder à suffisamment de mémoire pour traiter les requêtes, vous rencontrerez aussi des problèmes étranges liés aux paquets volumineux. Si vous soupçonnez cela, essayez de commencer à augmenter ulimit -d 256000 dans mysqld_safe script et redémarrez mysqld.
##########################################
##### Comment ouvrir et fermer des tables de base de données dans MySQL #####
##########################################
table_cache, max_connections et max_tmp_tables affectent le nombre maximal de fichiers que le serveur garde ouverts. Si vous augmentez une ou ces deux valeurs, vous pouvez rencontrer la limite imposée par votre système d’exploitation au nombre de descripteurs de fichiers que chaque processus ouvre. Cependant, vous pouvez augmenter la limite sur de nombreux systèmes. Demandez à la documentation de votre système d’exploitation de comprendre comment procéder, car les méthodes pour modifier les limites varient beaucoup d’un système à l’autre.
table_cache lié à max_connections. Par exemple, pour 200 jointures ouvertes, vous devriez avoir un tampon de table d’au moins 200 * n, où n est le nombre maximal de tables dans une jointure.
Le cache des tables ouvertes peut être augmenté jusqu’à un maximum d’un table_cache (64 par défaut ; Cela peut se faire avec le -O table_cache=#选项来改变) de mysqld. Une table n’est jamais fermée sauf lorsque le cache est plein et qu’un autre thread tente d’ouvrir une table ou si vous utilisez mysqladmin refresh ou mysqladmin flush-tables.
Lorsque le cache de table est plein, le serveur utilise la procédure suivante pour trouver une entrée de cache à utiliser :
Les tables qui ne sont pas actuellement utilisées sont publiées, dans l’ordre des moins utilisées (LRU).
Si le cache est plein et qu’il n’y a pas de tables à publier, mais qu’une nouvelle table doit être ouverte, le cache doit être temporairement agrandi.
Si le cache est en état temporairement étendu et qu’une table passe d’active à inactive, elle est fermée et libérée du cache.
Ouvrez une table pour chaque accès simultané. Cela signifie que si vous avez deux threads qui accèdent à la même table ou à la table deux fois dans la même requête (avec AS), la table doit être ouverte deux fois. La première ouverture de chaque tableau prend en compte 2 descripteurs de fichier ; Chaque utilisation supplémentaire de la table ne représente qu’un seul descripteur de fichier. Pour la première ouverture, un descripteur supplémentaire est utilisé pour indexer le fichier ; Cette description est partagée entre tous les fils de discussion
|
Publié sur 13/11/2017 11:55:59
|
|
|
