1195 lines
36 KiB
Markdown
1195 lines
36 KiB
Markdown
---
|
||
categories: databases
|
||
title: Howto MySQL : installation et utilisation courante.
|
||
---
|
||
|
||
* Documentation : <http://dev.mysql.com/doc/refman/5.5/en/>
|
||
* Rôle Ansible : <https://forge.evolix.org/projects/ansible-roles/repository/show/mysql>
|
||
|
||
[MySQL](https://www.mysql.com/) est une base de données très populaire au sein des infrastructures web. Nous utilisons au choix la version libre de MySQL distribuée par Oracle, et [MariaDB](https://mariadb.org/) un fork créé en 2009 par le créateur initial de MySQL.
|
||
|
||
## Installation
|
||
|
||
Pour la version libre de MySQL distribuée par Oracle :
|
||
|
||
~~~
|
||
# apt install mysql-server
|
||
|
||
$ mysql --version
|
||
mysql Ver 14.14 Distrib 5.5.53, for debian-linux-gnu (x86_64) using readline 6.3
|
||
~~~
|
||
|
||
Pour MariaDB :
|
||
|
||
~~~
|
||
# apt install mariadb-server-10.0
|
||
|
||
$ mysql --version
|
||
mysql Ver 15.1 Distrib 10.0.28-MariaDB, for debian-linux-gnu (x86_64) using readline 5.2
|
||
~~~
|
||
|
||
L'installation sous Debian demande un mot de passe pour le superutilisateur (par défaut *root*) de MySQL.
|
||
En laissant un mot de passe vide, on peut se connecter sans mot de passe :
|
||
|
||
~~~
|
||
$ mysql -u root
|
||
Welcome to the MySQL monitor. Commands end with ; or \g.
|
||
Your MySQL connection id is 45
|
||
Server version: 5.5.53-0+deb8u1 (Debian)
|
||
|
||
Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
|
||
|
||
Oracle is a registered trademark of Oracle Corporation and/or its
|
||
affiliates. Other names may be trademarks of their respective
|
||
owners.
|
||
|
||
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
|
||
|
||
mysql>
|
||
~~~
|
||
|
||
Il faut ensuite mettre un mot de passe pour le superutilisateur de MySQL, on conseille d'utiliser l'identifiant *adminmysql* car *root* peut prêter à confusion :
|
||
|
||
~~~{ .sql }
|
||
mysql> GRANT ALL PRIVILEGES ON *.* TO adminmysql@localhost IDENTIFIED BY 'PASSWORD' WITH GRANT OPTION;
|
||
mysql> DELETE FROM mysql.user where User='root';
|
||
~~~
|
||
|
||
On notera sous Debian la présence d'un utilisateur *debian-sys-maint* qui sert à certains scripts Debian :
|
||
il ne doit pas être supprimé ! Au niveau sécurité, le mot de passe est généré à l'installation
|
||
(stocké dans `/etc/mysql/debian.cnf` lisible que par *root*) par la commande :
|
||
|
||
~~~
|
||
perl -e 'print map{("a".."z","A".."Z",0..9)[int(rand(62))]}(1..16)'
|
||
~~~
|
||
|
||
Enfin, on peut utiliser un fichier `.my.cnf` pour conserver l'identifiant et le mot de passe.
|
||
Par exemple pour *root*, dans `/root/.my.cnf` :
|
||
|
||
~~~{.ini}
|
||
[client]
|
||
user = adminmysql
|
||
password = PASSWORD
|
||
~~~
|
||
|
||
Pour changer le mot de passe, on fera simplement :
|
||
|
||
~~~
|
||
# mysqladmin password PASSWORD
|
||
~~~
|
||
|
||
## Configuration
|
||
|
||
Les fichiers de configuration se trouvent dans `/etc/mysql/` et notamment `my.cnf` qui centralise les directives par défaut.
|
||
|
||
Le fichier `/etc/mysql/conf.d/z_evolinux.cnf` contient nos optimisations basiques :
|
||
|
||
~~~{.ini}
|
||
[mysqld]
|
||
|
||
###### Connexions
|
||
# Maximum de connexions concurrentes (defaut = 100)... provoque un "Too many connections"
|
||
max_connections = 250
|
||
# Maximum de connexions en attente en cas de max_connections atteint (defaut = 50)
|
||
back_log = 100
|
||
# Maximum d'erreurs avant de blacklister un hote
|
||
max_connect_errors = 10
|
||
# Loguer les requetes trop longues
|
||
log_slow_queries = /var/log/mysql/mysql-slow.log
|
||
long_query_time = 10
|
||
|
||
###### Tailles
|
||
# Taille reservee au buffer des index MyIsam
|
||
# A ajuster selon les resultats
|
||
key_buffer_size = 512M
|
||
# Taille max des paquets envoyés/reçus … provoque un "Packet too large"
|
||
max_allowed_packet = 64M
|
||
# Taille de la memoire reserve pour un thread
|
||
thread_stack = 192K
|
||
# A mettre le nombre de threads CPU alloues pour MySQL
|
||
thread_cache_size = 1
|
||
# Taille maximum des tables de type MEMORY
|
||
max_heap_table_size = 64M
|
||
|
||
###### Cache
|
||
# max_connections x nbre max de tables dans une jointure (defaut = 64)
|
||
table_cache = 4096
|
||
table_open_cache = 4096
|
||
table_definition_cache = 4096
|
||
# Taille max des requetes cachees (defaut = 1M)
|
||
query_cache_limit = 8M
|
||
# Taille reservee pour le cache (defaut = 0)
|
||
query_cache_size = 256M
|
||
# Type de requetes a cacher (defaut = 1 : tout peut etre cache)
|
||
query_cache_type = 1
|
||
# Cache tables
|
||
max_heap_table_size = 128M
|
||
tmp_table_size = 128M
|
||
|
||
###### InnoDB
|
||
# Si InnoDB n'est pas utilise... le desactiver
|
||
#skip-innodb
|
||
# En general, il est plus optimum d'avoir un fichier par table
|
||
innodb_file_per_table
|
||
# Taille memoire allouee pour le cache des datas et index
|
||
# A ajuster en fonction de sa RAM (si serveur dedie a MySQL, on peut aller jusqu'a 80%)
|
||
innodb_buffer_pool_size = 512M
|
||
# Taille buffer memoire pour structures internes InnoDB
|
||
innodb_additional_mem_pool_size = 16M
|
||
# Nombre maximum de threads systeme concurents
|
||
innodb_thread_concurrency = 16
|
||
# Ajuste la valeur des logs InnoDB
|
||
# (attention, il faut ensuite stopper MySQL et effacer les fichiers ib_logfile*)
|
||
#innodb_log_file_size = 128M
|
||
#innodb_log_files_in_group = 2
|
||
|
||
###### Misc
|
||
# charset utf8 par defaut
|
||
default-character-set = utf8
|
||
collation-server = utf8_unicode_ci
|
||
~~~
|
||
|
||
Le fichier `/etc/mysql/conf.d/zzz_evolinux.cnf` contient nos optimisations spécifiques.
|
||
|
||
Par défaut, MySQL écoute en réseau sur `127.0.0.1` (port TCP/3306) et sur la socket Unix `/var/run/mysqld/mysqld.sock`
|
||
Pour activer les connexions réseau à distance, il faut ajouter la configuration suivante dans `zzz_evolinux.cnf` :
|
||
|
||
~~~{.ini}
|
||
[mysqld]
|
||
bind-address = 0.0.0.0
|
||
~~~
|
||
|
||
Selon les ressources de la machine, il faut optimiser davantage les options (par défaut, la configuration est adaptée pour une machine avec très peu de mémoire vive !). Sous Debian, on trouvera quelques exemples dans le répertoire `/usr/share/doc/mysql-server-5.5/examples/`
|
||
|
||
On conseille au minimum d'ajuster *thread_cache_size* et *innodb_buffer_pool_size* :
|
||
|
||
~~~{.ini}
|
||
[mysqld]
|
||
# Nombre de threads CPU alloués pour MySQL
|
||
thread_cache_size = 2
|
||
# Mémoire allouée pour le cache InnoDB (si serveur dédié, on peut aller jusqu'à 80% de la RAM)
|
||
innodb_buffer_pool_size = 2G
|
||
~~~
|
||
|
||
Pour plus d'informations sur l'optimisation avancée de MySQL, consultez le guide [/HowtoMySQL/Optimize]().
|
||
|
||
## datadir / tmpdir
|
||
|
||
Par défaut, le *datadir* (le répertoire où sont stockées les données brutes) est `/var/lib/mysql/`.
|
||
|
||
Pour diverses raisons il peut être intéressant de le déplacer (partition ou disque dédié etc.).
|
||
|
||
Pour des raisons de compatibilité, on conseille de conserver un lien symbolique :
|
||
|
||
~~~
|
||
# systemctl stop mysql
|
||
# mv /var/lib/mysql /srv/mysql-datadir
|
||
# ln -s /srv/mysql-datadir /var/lib/mysql
|
||
# systemctl start mysql
|
||
~~~
|
||
|
||
Pour certaines opérations lourdes, MySQL a besoin d'un *tmpdir* (répertoire où il va écrire des tables temporaires).
|
||
Par défaut il utilise `/tmp` mais vu qu'il est parfois nécessaire d'avoir plusieurs Go de libre, on pourra utiliser un répertoire différents :
|
||
|
||
~~~{.ini}
|
||
[mysqld]
|
||
tmpdir = /srv/mysql-tmpdir
|
||
~~~
|
||
|
||
## Logs
|
||
|
||
Sous Debian, les journaux de MySQL (démarrage, arrêt, erreurs, informations) sont envoyés via *syslog*.
|
||
Par défaut, ils seront donc visibles dans `/var/log/syslog`.
|
||
|
||
Le répertoire `/var/log/mysql/` contient les *binlogs* (trace de toutes les requêtes INSERT/UPDATE/DELETE exécutées).
|
||
|
||
## Utilisation courante
|
||
|
||
### Créer
|
||
|
||
Créer une nouvelle base de données nommée _foo_ :
|
||
|
||
~~~{.sql}
|
||
mysql> CREATE DATABASE foo;
|
||
~~~
|
||
|
||
Créer une table nommée _bar_ avec différents champs :
|
||
|
||
~~~{.sql}
|
||
mysql> CREATE TABLE bar (id INT not null AUTO_INCREMENT, prenom VARCHAR
|
||
(50) not null , nom VARCHAR (50) not null , ne_le DATE not null ,
|
||
ville VARCHAR (90), enfants INT, PRIMARY KEY (id));
|
||
~~~
|
||
|
||
Ajouter un champ à une table :
|
||
|
||
~~~{.sql}
|
||
mysql> ALTER TABLE bar ADD another VARCHAR(100) DEFAULT NULL;
|
||
~~~
|
||
|
||
Ajouter un champ à une table en précisant sa place :
|
||
|
||
~~~{.sql}
|
||
mysql> ALTER TABLE bar ADD another VARCHAR(100) DEFAULT NULL AFTER prenom;
|
||
~~~
|
||
|
||
### Lister
|
||
|
||
Voir les bases de données créées :
|
||
|
||
~~~{.sql}
|
||
mysql> SHOW DATABASES;
|
||
~~~
|
||
|
||
Utiliser la base de données _foo_ :
|
||
|
||
~~~{.sql}
|
||
mysql> USE foo
|
||
~~~
|
||
|
||
Voir les tables créées :
|
||
|
||
~~~{.sql}
|
||
mysql> SHOW TABLES;
|
||
~~~
|
||
|
||
Décrire une table :
|
||
|
||
~~~{.sql}
|
||
mysql> DESC bar;
|
||
~~~
|
||
|
||
Sélectionner tous les champs d'une table :
|
||
|
||
~~~{.sql}
|
||
mysql> SELECT * FROM bar;
|
||
~~~
|
||
|
||
Lancer des commandes bash depuis l'invite de commande :
|
||
|
||
~~~{ .sql }
|
||
mysql> \! ls -l
|
||
-rw-r----- 1 user user 208774 Jan 11 14:31 dump_base.sql
|
||
~~~
|
||
|
||
Lister les droits pour tous les accès MySQL créés :
|
||
|
||
~~~
|
||
# mysql -e "select concat('\'',User,'\'@\'',Host,'\'') as '' from mysql.user" | sort | \
|
||
( while read user; do [ -z "$user" ] && continue; echo "-- $user :"; mysql -e "show grants for $user"; done )
|
||
|
||
-- 'accesbase'@'localhost' :
|
||
Grants for accesbase@localhost
|
||
GRANT USAGE ON *.* TO 'accesbase'@'localhost' IDENTIFIED BY PASSWORD '*XXXX'
|
||
GRANT ALL PRIVILEGES ON `base`.* TO 'accesbase'@'localhost'
|
||
~~~
|
||
|
||
~~~
|
||
# mysql -e "select * from information_schema.user_privileges;"
|
||
~~~
|
||
|
||
### Supprimer
|
||
|
||
Supprimer un champ à une table :
|
||
|
||
~~~{.sql}
|
||
mysql> ALTER TABLE bar DROP another;
|
||
~~~
|
||
|
||
Effacer des données d'une table :
|
||
|
||
~~~{.sql}
|
||
mysql> DELETE FROM bar WHERE nom='waddle';
|
||
~~~
|
||
|
||
Effacer TOUTES les données d'une table :
|
||
|
||
~~~{.sql}
|
||
mysql> DELETE FROM bar;
|
||
~~~
|
||
|
||
Supprimer une table :
|
||
|
||
~~~{.sql}
|
||
mysql> DROP TABLE bar;
|
||
~~~
|
||
|
||
Supprimer une base de données :
|
||
|
||
~~~{ .sql }
|
||
mysql> DROP DATABASE foo;
|
||
~~~
|
||
|
||
Supprimer les différents privilèges pour un utilisateur mysql :
|
||
|
||
~~~{ .sql }
|
||
mysql> REVOKE ALL PRIVILEGES ON base.* FROM 'user'@'localhost';
|
||
~~~
|
||
|
||
Supprimer un accès (utilisateur) :
|
||
|
||
~~~{ .sql }
|
||
mysql> DROP USER 'user'@'localhost';
|
||
~~~
|
||
|
||
### Renommer
|
||
|
||
#### Base
|
||
|
||
- Créer une base vide
|
||
- Renommer toutes les tables vers cette dernière (utilisation script ci-dessous)
|
||
|
||
~~~{.bash}
|
||
BASE_FROM=db1; BASE_TO=db2
|
||
for table in $(mysql -e "use $BASE_FROM; show tables\G;" | grep -v '^\*\*\*' | cut -d':' -f2 | sed 's/^ //'); do echo $table; mysql -e "RENAME TABLE ${BASE_FROM}.${table} TO ${BASE_TO}.${table};"; done
|
||
~~~
|
||
|
||
#### Table
|
||
|
||
Renommer un champ :
|
||
|
||
~~~{.sql}
|
||
mysql> ALTER TABLE bar CHANGE COLUMN another anotherone TEXT;
|
||
~~~
|
||
|
||
Changer le type d'un champ :
|
||
|
||
~~~{.sql}
|
||
mysql> ALTER TABLE bar CHANGE another another enum('foo',bar');
|
||
~~~
|
||
|
||
### Insérer
|
||
|
||
Insertion de données dans une table :
|
||
|
||
~~~{.sql}
|
||
mysql> INSERT INTO bar VALUES (1,'jp','papin','2005-06-12','Marseille',2);
|
||
INSERT INTO test (id,prenom,nom,ne_le) VALUES (2,'c','waddle','2004-06-17');
|
||
~~~
|
||
|
||
## Administration
|
||
|
||
On crée une base de données et un utilisateur associé :
|
||
|
||
~~~
|
||
# mysqladmin create foo
|
||
# mysql
|
||
mysql> GRANT ALL PRIVILEGES ON foo.* TO 'jdoe'@localhost IDENTIFIED BY 'PASSWORD';
|
||
~~~
|
||
|
||
Cette opération revient à insérer des lignes suivante dans les tables `mysql.user` et `mysql.db` :
|
||
|
||
~~~{.sql}
|
||
mysql> INSERT INTO mysql.user VALUES ('localhost','jdoe',password('PASSWORD'),'N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','N','','','','',0,0,0,0,'',NULL);
|
||
mysql> INSERT INTO mysql.db VALUES ('localhost','foo','jdoe','Y','Y','Y','Y','Y','Y','N','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y');
|
||
mysql> FLUSH PRIVILEGES;
|
||
~~~
|
||
|
||
*À savoir* :
|
||
|
||
Pour migrer de Debian 6 à 7 :
|
||
- 3 colonnes ont été ajoutées dans `mysql.user` : Create_tablespace_priv, plugin et authentication_string (pour migrer il faut ajouter 'N' en 32ème position + '' et NULL à la fin)
|
||
- 2 colonnes ont été ajoutées dans `mysql.db` : Event_priv et Trigger_priv (pour migrer il faut ajouter 'Y' et 'Y' à la fin)
|
||
|
||
On pourra ainsi régler finement les droits d'un utilisateur en connaissant la signification de chaque colonne :
|
||
|
||
~~~{.sql}
|
||
mysql> desc user;
|
||
+------------------------+-----------------------------------+------+-----+---------+-------+
|
||
| Field | Type | Null | Key | Default | Extra |
|
||
+------------------------+-----------------------------------+------+-----+---------+-------+
|
||
| Host | char(60) | NO | PRI | | |
|
||
| User | char(16) | NO | PRI | | |
|
||
| Password | char(41) | NO | | | |
|
||
| Select_priv | enum('N','Y') | NO | | N | |
|
||
| Insert_priv | enum('N','Y') | NO | | N | |
|
||
| Update_priv | enum('N','Y') | NO | | N | |
|
||
| Delete_priv | enum('N','Y') | NO | | N | |
|
||
| Create_priv | enum('N','Y') | NO | | N | |
|
||
| Drop_priv | enum('N','Y') | NO | | N | |
|
||
| Reload_priv | enum('N','Y') | NO | | N | |
|
||
| Shutdown_priv | enum('N','Y') | NO | | N | |
|
||
| Process_priv | enum('N','Y') | NO | | N | |
|
||
| File_priv | enum('N','Y') | NO | | N | |
|
||
| Grant_priv | enum('N','Y') | NO | | N | |
|
||
| References_priv | enum('N','Y') | NO | | N | |
|
||
| Index_priv | enum('N','Y') | NO | | N | |
|
||
| Alter_priv | enum('N','Y') | NO | | N | |
|
||
| Show_db_priv | enum('N','Y') | NO | | N | |
|
||
| Super_priv | enum('N','Y') | NO | | N | |
|
||
| Create_tmp_table_priv | enum('N','Y') | NO | | N | |
|
||
| Lock_tables_priv | enum('N','Y') | NO | | N | |
|
||
| Execute_priv | enum('N','Y') | NO | | N | |
|
||
| Repl_slave_priv | enum('N','Y') | NO | | N | |
|
||
| Repl_client_priv | enum('N','Y') | NO | | N | |
|
||
| Create_view_priv | enum('N','Y') | NO | | N | |
|
||
| Show_view_priv | enum('N','Y') | NO | | N | |
|
||
| Create_routine_priv | enum('N','Y') | NO | | N | |
|
||
| Alter_routine_priv | enum('N','Y') | NO | | N | |
|
||
| Create_user_priv | enum('N','Y') | NO | | N | |
|
||
| Event_priv | enum('N','Y') | NO | | N | |
|
||
| Trigger_priv | enum('N','Y') | NO | | N | |
|
||
| Create_tablespace_priv | enum('N','Y') | NO | | N | |
|
||
| ssl_type | enum('','ANY','X509','SPECIFIED') | NO | | | |
|
||
| ssl_cipher | blob | NO | | NULL | |
|
||
| x509_issuer | blob | NO | | NULL | |
|
||
| x509_subject | blob | NO | | NULL | |
|
||
| max_questions | int(11) unsigned | NO | | 0 | |
|
||
| max_updates | int(11) unsigned | NO | | 0 | |
|
||
| max_connections | int(11) unsigned | NO | | 0 | |
|
||
| max_user_connections | int(11) unsigned | NO | | 0 | |
|
||
| plugin | char(64) | YES | | | |
|
||
| authentication_string | text | YES | | NULL | |
|
||
+------------------------+-----------------------------------+------+-----+---------+-------+
|
||
42 rows in set (0.00 sec)
|
||
~~~
|
||
|
||
Par exemple, pour permettre à un utilisateur (ici *debian-sys-maint*) de faire des `SHOW VIEW` :
|
||
|
||
~~~{.sql}
|
||
mysql> UPDATE user SET Show_view_priv='Y' WHERE User='debian-sys-maint';
|
||
mysql> FLUSH PRIVILEGES;
|
||
~~~
|
||
|
||
…que l'on peut aussi faire via :
|
||
|
||
~~~{.sql}
|
||
mysql> GRANT SHOW VIEW on *.* to `debian-sys-maint`@localhost;
|
||
~~~
|
||
|
||
Pour créer un utilisateur sans droit particulier, par exemple pour du monitoring :
|
||
|
||
~~~{.sql}
|
||
mysql> create user nagios@localhost identified by 'PASSWORD';
|
||
~~~
|
||
|
||
On peut aussi gérer des droits sur les tables :
|
||
|
||
~~~{.sql}
|
||
mysql> GRANT Select,Insert,Update ON foo.bar TO 'jdoe'@localhost;
|
||
~~~
|
||
|
||
Pour révoquer des droits sur une table, on utilisera `REVOKE` :
|
||
|
||
~~~{.sql}
|
||
mysql> REVOKE ALL PRIVILEGES ON foo.bar FROM 'jdoe'@localhost;
|
||
~~~
|
||
|
||
/!\\ Un droit est particulier : pour utiliser LOAD DATA INFILE ou SELECT INTO OUTFILE, il faut avoir le droit `FILE` … mais il est global (et dangereux) !
|
||
On le positionnera ainsi :
|
||
|
||
~~~{.sql}
|
||
mysql> GRANT FILE ON *.* TO 'jdoe'@localhost;
|
||
~~~
|
||
|
||
### Vérifications et réparations
|
||
|
||
Pour vérifier et réparer toutes les tables (une sorte de *fsck* pour les tables), on lancera :
|
||
|
||
~~~
|
||
# mysqlcheck --auto-repair --check --all-databases
|
||
~~~
|
||
|
||
On peut aussi réparer qu'une base en particulier :
|
||
|
||
~~~
|
||
# mysqlcheck --auto-repair --check foo
|
||
~~~
|
||
|
||
> *Note* : ceci peut être à faire en cas d'arrêt inopiné du service.
|
||
|
||
On pourra également ajouter l'option `--optimize` pour ajouter une optimisation des tables :
|
||
|
||
~~~
|
||
# mysqlcheck --auto-repair --check --optimize --all-databases
|
||
~~~
|
||
|
||
Pour réparer une seule table :
|
||
|
||
~~~{.sql}
|
||
mysql> CHECK TABLE foo.bar;
|
||
mysql> REPAIR TABLE foo.bar;
|
||
mysql> OPTIMIZE TABLE foo.bar;
|
||
~~~
|
||
|
||
Dans le cas des tables MyISAM, si le REPAIR échoue, une réparation est aussi possible via `myisamchk`… à faire avec
|
||
le service MySQL arrêté :
|
||
|
||
~~~
|
||
# myisamchk -r -q /var/lib/mysql/foo/bar.MYD
|
||
~~~
|
||
|
||
En cas d'échec (*segfault* par exemple), on peut tenter :
|
||
|
||
~~~
|
||
# myisamchk --safe-recover -v -f --key_buffer_size=512M --sort_buffer_size=512M --read_buffer_size=4M --write_buffer_size=4M /var/lib/mysql/BASE/TABLE.MYD
|
||
~~~
|
||
|
||
### routines MySQL
|
||
|
||
~~~{.sql}
|
||
mysql> select * from INFORMATION_SCHEMA.routines;
|
||
~~~
|
||
|
||
### Changement mot de passe utilisateur
|
||
|
||
~~~{.sql}
|
||
mysql> SET PASSWORD FOR 'jdoe'@'localhost' = PASSWORD('PASSWORD');
|
||
~~~
|
||
|
||
Par rapport à un autre utilisateur :
|
||
|
||
~~~{.sql}
|
||
mysql> use mysql;
|
||
mysql> UPDATE mysql.user SET Password='PASSWORD' WHERE User='jdoe' and Host='localhost';
|
||
~~~
|
||
|
||
### Changer variables global d'environnement
|
||
|
||
~~~{.sql}
|
||
mysql> SET GLOBAL max_connect_errors=50;
|
||
~~~
|
||
|
||
ou
|
||
|
||
~~~{.sql}
|
||
mysql> SET @@max_connect_errors=50;
|
||
~~~
|
||
|
||
### Log des requêtes lentes
|
||
|
||
Pour débugger les applications lentes, c'est une fonctionnalité intéressante de trouver quelle requête est longue.
|
||
Pour cela on peut spécifier quand une requête est considérée comme longue, le chemin où stocker les requêtes, et l'activation des logs.
|
||
|
||
~~~{.ini}
|
||
[mysqld]
|
||
long_query_time = 5
|
||
slow_query_log = 1
|
||
slow_query_log_file = /var/log/mysql/slow.log
|
||
~~~
|
||
|
||
Ou à chaud :
|
||
|
||
~~~{.sql}
|
||
mysql> SET GLOBAL slow_query_log=ON;
|
||
mysql> SET GLOBAL long_query_time=5;
|
||
mysql> SET GLOBAL slow_query_log_file= "/var/log/mysql/slow.log";
|
||
~~~
|
||
|
||
### Lister les variables de configuration
|
||
|
||
Pour voir la liste de toutes les variables :
|
||
|
||
~~~{.sql}
|
||
mysql> show variables;
|
||
~~~
|
||
|
||
Pour ne voir qu'un sous-ensemble de variables :
|
||
|
||
~~~{.sql}
|
||
mysql> show variables like 'read_only';
|
||
mysql> show variables like '%thread%';
|
||
~~~
|
||
|
||
### Lecture de log des requêtes lentes
|
||
|
||
Pour avoir une meilleure lecture des slow query, on peut utilisé la commande mysqldumpslow :
|
||
|
||
~~~
|
||
mysqldumpslow /var/log/mysql/mysql-slow.log
|
||
~~~
|
||
|
||
Doc pour un usage plus fin : [mysqldumpslow](https://dev.mysql.com/doc/refman/5.7/en/mysqldumpslow.html)
|
||
|
||
### Log des dead lock
|
||
|
||
> *Note* : Seulement possible depuis MySQL 5.6 ou MariaDB 10.
|
||
|
||
~~~{.ini}
|
||
[mysqld]
|
||
innodb_print_all_deadlocks = on
|
||
~~~
|
||
|
||
À chaud :
|
||
|
||
~~~{.sql}
|
||
mysql> SET GLOBAL innodb_print_all_deadlocks=on;
|
||
~~~
|
||
|
||
### Lecture seule
|
||
|
||
Si on veut qu'une instance de MySQL soit démarrée en lecture seule, on peut ajouter la variable `read_only = 1` dans la section `[mysqld]`. Seules les requêtes faites par des utilisateurs ayant le privilège SUPER seront alors exécutées.
|
||
|
||
C'est par exemple utile dans une situation où une instance "slave" doit pouvoir être utilisée en lecture seule, tout en utilisant les mêmes comptes utilisateurs qui ont accès en écriture sur le "master". La réplication en elle-même n'est pas impactée.
|
||
|
||
## Sauvegarde
|
||
|
||
Pour sauvegarder une base de données dans un seul fichier (sans et avec compression) :
|
||
|
||
~~~
|
||
$ mysqldump --hex-blob foo > foo.sql
|
||
$ mysqldump --hex-blob foo | gzip > foo.sql.gz
|
||
~~~
|
||
|
||
> *Note* : l'option *--hex-blob* est importante pour ne pas risquer de perdre certains caractères dans les colonnes de type BINARY/BLOB/BIT
|
||
|
||
Pour sauvegarder une base de données au format *tab-separated data files*, avec - pour chaque table - un fichier .sql contenant la structure de la table (CREATE TABLE) et un fichier .txt contenant les données brutes (ré-injectable avec `LOAD DATA INFILE`) :
|
||
|
||
~~~
|
||
# mkdir /tmp/foo && chown mysql:mysql /tmp/foo
|
||
$ mysqldump -T --hex-blob foo > /tmp/foo
|
||
~~~
|
||
|
||
> *Note* : le répertoire de destination doit exister et *mysqld* doit avoir les droits d'écrire dedans.
|
||
|
||
Pour restaurer une base de données (sans et avec compression) :
|
||
|
||
~~~
|
||
$ mysqladmin create foo
|
||
$ mysql foo < foo.sql
|
||
$ gunzip < foo.sql.gz | mysql foo
|
||
~~~
|
||
|
||
Sauvegarder toutes les bases (exemples en mode classique et en mode `-T`) :
|
||
|
||
~~~
|
||
$ mysqldump --opt --all-databases --events --hex-blob > all.sql
|
||
$ for db in $(mysql -P3308 -e "SHOW DATABASES" | egrep -v "^(Database|information_schema|performance_schema)") \
|
||
mkdir /backupmysql/$db && chown mysql:mysql /backupmysql/$db && \
|
||
mysqldump --events --hex-blob -T /backupmysql/$db $db; done
|
||
~~~
|
||
|
||
Pour sauvegarder uniquement certaines tables :
|
||
|
||
~~~
|
||
$ mysqldump --hex-blob foo TABLE0 [TABLE1…] > foo_tables.sql
|
||
~~~
|
||
|
||
Pour presque faire un `--exclude` (qui manque cruellement à *mysqldump*):
|
||
|
||
~~~
|
||
$ mysql -B -N -e 'show databases' | \
|
||
perl -ne 'print unless /\b(?:phpmyadmin|mysql|information_schema)\b/' | \
|
||
xargs echo mysqldump --hex-blob -B
|
||
~~~
|
||
|
||
Et pour sauvegarder des tables correspondant à un motif (préfixe le plus souvent) :
|
||
|
||
~~~
|
||
$ mysqldump --hex-blob foo $(mysql foo -B --column-names=False -e "show tables like 'exemple_%'") > foo_motif.sql
|
||
~~~
|
||
|
||
Pour dumper avec une condition particulière :
|
||
|
||
~~~
|
||
$ mysqldump -t foo bar --hex-blob --where="id='66666666'"
|
||
~~~
|
||
|
||
Ce qui permet de réinjecter des données résultantes d'un `SELECT * FROM foo.bar WHERE id='66666666'`.
|
||
|
||
Il est évidement possible de faire toutes ces opérations sur une instance en
|
||
précisant son port avec l'option `--port` (valable pour *mysqldump* et *mysql*).
|
||
|
||
Pour obtenir une liste des utilisateurs mysql, on peut utiliser cette fonction (glanée sur [serverfault](http://serverfault.com/questions/8860/how-can-i-export-the-privileges-from-mysql-and-then-import-to-a-new-server/)) :
|
||
|
||
~~~{.bash}
|
||
mygrants()
|
||
{
|
||
mysql -B -N -e "SELECT DISTINCT CONCAT(
|
||
'SHOW GRANTS FOR *, user, _'@'_, host, *;'
|
||
) AS query FROM mysql.user" | \
|
||
mysql | \
|
||
sed 's/\(GRANT .*\)/\1;/;s/^\(Grants for .*\)/## \1 ##/;/##/{x;p;x;}'
|
||
}
|
||
~~~
|
||
|
||
### Restaurer
|
||
|
||
Pour avoir un dump avec un seul insert par ligne, pratique pour restaurer partiellement les bases `mysql.user` et `mysql.db` par exemple :
|
||
|
||
~~~
|
||
$ mysqldump --skip-extended-insert --events mysql > mysql.sql
|
||
~~~
|
||
|
||
Pour restaurer uniquement la base _foo_ à partir d'un dump complet on peut utiliser :
|
||
|
||
~~~
|
||
$ mysql -o foo < all.sql
|
||
~~~
|
||
|
||
Pour restaurer une base avec un dump de type "tab-separated data files" (`mysqldump -T`, voir plus haut) :
|
||
|
||
~~~{.bash}
|
||
db=test1
|
||
|
||
for file in *.sql; do
|
||
mysql $db <$file
|
||
done
|
||
|
||
grep CHARSET= *txt
|
||
|
||
for file in *.txt; do
|
||
tablename=`basename $file .txt` #tablename=${file%.*}
|
||
echo "LOAD DATA INFILE '$PWD/$file' INTO TABLE $tablename" CHARACTER SET utf8 | mysql $db
|
||
done
|
||
~~~
|
||
|
||
Pour le CHARACTER SET, se baser au character_set_database de la base :
|
||
|
||
~~~{.bash}
|
||
$ mysql -e 'show variables;' | grep character_set_database
|
||
character_set_database utf8
|
||
~~~
|
||
|
||
Si cela concerne plusieurs bases répartis dans différents répertoires :
|
||
|
||
\<se placer sur le répertoire en question (/home/mysqltmp/)\>
|
||
|
||
~~~{.bash}
|
||
for dir in *
|
||
do
|
||
echo "=======base $dir========="
|
||
db=$dir
|
||
mysql -e "create database ${dir};"
|
||
ls $dir/*.sql || continue
|
||
for file in $dir/*.sql
|
||
do
|
||
mysql $db <$file
|
||
done
|
||
grep CHARSET= $dir/*txt
|
||
ls $dir/*.txt || continue
|
||
for file in $dir/*.txt
|
||
do
|
||
tablename=$(basename $file .txt)
|
||
echo "LOAD DATA INFILE '$PWD/$file' INTO TABLE $tablename" CHARACTER SET utf8 | mysql $db
|
||
done
|
||
done
|
||
~~~
|
||
|
||
> *Note 1* : Attention, l'utilisateur MySQL doit avoir le droit de lecture sur les fichiers .txt
|
||
Se positionner dans un répertoire où mysql a les droits (mysqltmp - /home/mysqltmp par ex).
|
||
|
||
> *Note 2* : Si vous n'avez pas toutes vos tables en utf8 (par exemple du `CHARSET=LATIN1`), ce n'est pas bien… et vous devrez pour la peine adapter le script (en détectant le charset utilisé avec « file » si nécessaire)
|
||
|
||
> *Note 3* : Si erreur 150 : «Can't create table» voir du côté des foreign keys :
|
||
>
|
||
>~~~{.bash}
|
||
>$ mysql -e 'SHOW ENGINE INNODB STATUS\G;' | grep LATEST\ FOREIGN -A3
|
||
>~~~
|
||
>
|
||
>et ignorer les erreurs pour pouvoir recréer les tables :
|
||
>
|
||
>~~~{.bash}
|
||
>$ mysql -e "set GLOBAL foreign_key_checks=OFF;"
|
||
>~~~
|
||
|
||
Il est possible d'exporter le contenu d'une base au format CSV :
|
||
|
||
~~~
|
||
$ mysqldump --hex-blob -T /tmp --fields-enclosed-by=\" --fields-terminated-by=, --no-create-db --no-create-info foo
|
||
~~~
|
||
|
||
> *Note* : il est nécessaire que MySQL ait les droits d'écriture dans le répertoire de destination (ici `/tmp`).
|
||
|
||
On peut également restaurer un dump _foo.sql_ (ou tout script au format SQL) de façon interactive via la commande `source` :
|
||
|
||
~~~{.sql}
|
||
mysql> source foo.sql
|
||
~~~
|
||
|
||
> *Note 1* : il est nécessaire que MySQL ait les droits de lecture sur le fichier _foo.sql_
|
||
|
||
> *Note 2* : les sorties des requêtes sont renvoyées sur la sortie standard (au contraire de la restauration avec `mysql < foo.sql`)
|
||
|
||
|
||
## Monitoring
|
||
|
||
Pour surveiller un service MySQL en production, on pourra faire :
|
||
|
||
~~~
|
||
# mysqladmin status
|
||
# mysqladmin extended-status
|
||
# mysqladmin processlist
|
||
~~~
|
||
|
||
### mytop
|
||
|
||
Pour avoir une version conviviale et dynamique des process en cours, on utilisera l'outil *mytop*.
|
||
|
||
~~~
|
||
# apt install mytop
|
||
~~~
|
||
|
||
On édite le fichier `/root/.mytop` ainsi :
|
||
|
||
~~~{.ini}
|
||
user = debian-sys-maint
|
||
pass = PASSWORD
|
||
db = mysql
|
||
~~~
|
||
|
||
Reste plus qu'à lancer la commande `mytop -s1` (pour un rafraichissement toutes les secondes) : on appréciera les raccourcis `p` (mettre en pause l'affichage), `o` (pour voir en 1er les requêtes les plus longues), `k` (pour killer une requête… par exemple celle qui bloque toutes les autres) et `?` (pour voir les autres raccourcis possibles).
|
||
|
||
L'outil *mytop* se sert principalement de la requête `SHOW PROCESSLIST` que l'on pourra bien sûr lancer manuellement. Tout comme `KILL` :
|
||
|
||
~~~{.sql}
|
||
mysql> SHOW PROCESSLIST;
|
||
mysql> KILL <id_requête>;
|
||
~~~
|
||
|
||
Pour lister les requêtes qui durent plus de 30 secondes pour pouvoir les tuer facilement :
|
||
|
||
~~~
|
||
# mysql -e 'select group_concat(concat("kill ",ID) separator ";") from information_schema.processlist where TIME>=30;'
|
||
~~~
|
||
|
||
Puis exécuter le résultat avec la commande *mysql*, exemple :
|
||
|
||
~~~
|
||
# mysql -e 'kill 1854;kill 1853;kill 1852;kill 1851;kill 1850;kill 1848'
|
||
~~~
|
||
|
||
Pour surveiller le moteur InnoDB, on utilisera la commande suivante :
|
||
|
||
~~~{.sql}
|
||
mysql> SHOW ENGINE INNODB STATUS;
|
||
~~~
|
||
|
||
### Munin
|
||
|
||
Pour activer les plugins MySQL pour Munin :
|
||
|
||
~~~
|
||
# cd /etc/munin/plugins
|
||
# ln -s /usr/share/munin/plugins/mysql_bytes
|
||
# ln -s /usr/share/munin/plugins/mysql_queries
|
||
# ln -s /usr/share/munin/plugins/mysql_slowqueries
|
||
# ln -s /usr/share/munin/plugins/mysql_threads
|
||
~~~
|
||
|
||
On pourra aussi activer le plugin *mysql_* avec des liens symboliques nommés connections, files_tables, innodb_bpool, innodb_bpool_act, innodb_io, innodb_log, innodb_rows, innodb_semaphores, myisam_indexes, qcache, qcache_mem, sorts ou tmp_tables.
|
||
|
||
Pour tester le bon fonctionnement des plugins MySQL pour Munin :
|
||
|
||
~~~
|
||
# munin-run mysql_bytes
|
||
~~~
|
||
|
||
### log2mail
|
||
|
||
Afin d'être alerté en cas de souci, il est conseillé d'ajouter la configuration suivante au logiciel `log2mail` :
|
||
|
||
~~~
|
||
file = /var/log/syslog
|
||
pattern = "is marked as crashed and should be repaired"
|
||
mailto = monitoring@example.com
|
||
template = /etc/log2mail/template.mysql
|
||
|
||
file = /var/log/syslog
|
||
pattern = "init function returned error"
|
||
mailto = monitoring@example.com
|
||
template = /etc/log2mail/template.mysql
|
||
|
||
file = /var/log/syslog
|
||
pattern = "try to repair it"
|
||
mailto = monitoring@example.com
|
||
template = /etc/log2mail/template.mysql
|
||
|
||
file = /var/log/syslog
|
||
pattern = "InnoDB: Fatal error"
|
||
mailto = monitoring@example.com
|
||
template = /etc/log2mail/template.mysql
|
||
|
||
file = /var/log/syslog
|
||
pattern = "as a STORAGE ENGINE failed"
|
||
mailto = monitoring@example.com
|
||
template = /etc/log2mail/template.mysql
|
||
~~~
|
||
|
||
Le fichier `/etc/log2mail/template.mysql` contenant :
|
||
|
||
~~~
|
||
From: %f
|
||
To: %t
|
||
Subject: MySQL problem
|
||
|
||
Hello!
|
||
|
||
We have matched your pattern "%m" in "%F" %n times:
|
||
|
||
%l
|
||
|
||
Yours,
|
||
log2mail.
|
||
~~~
|
||
|
||
> *Note* : il faut ajouter l'utilisateur `log2mail` dans le groupe `adm`.
|
||
|
||
|
||
## binlogs
|
||
|
||
Par défaut, MySQL stocke chaque requête en écriture dans des fichiers appelés *binlogs*.
|
||
|
||
### Configuration
|
||
|
||
Par défaut les binlogs sont conservés sur 10 jours, avec des fichiers n'excédant pas 100 Mo :
|
||
|
||
~~~{.ini}
|
||
[mysqld]
|
||
#log_bin = /var/log/mysql/mysql-bin.log
|
||
expire_logs_days = 10
|
||
max_binlog_size = 100M
|
||
#binlog_do_db = include_database_name
|
||
#binlog_ignore_db = include_database_name
|
||
binlog_format = mixed
|
||
~~~
|
||
|
||
### Format
|
||
|
||
<http://dev.mysql.com/doc/refman/5.5/en/binary-log-setting.html>
|
||
|
||
On peut choisir 3 types de format pour les binlogs :
|
||
|
||
* **statement** : les requêtes INSERT / UPDATE sont conservées
|
||
* **row** : les modifications de chaque ligne sont conservées (via une sorte de code « binaire » propre à MySQL)
|
||
* **mixed** : en mode statement… sauf dans certains cas où cela passe en mode row
|
||
|
||
Avantages et inconvénients :
|
||
|
||
Le mode **statement** est utile pour conserver en clair toutes les requêtes. Il permet aussi de meilleures performances quand des UPDATE contiennent des clauses WHERE qui modifient de nombreuses lignes.
|
||
Pour de la réplication, il peut être non fiable car le résultat d'un UPDATE peut donner des résultats différents sur un serveur SLAVE. Cela peut aussi poser des soucis avec les transactions InnoDB.
|
||
|
||
Le mode **row** a l'inconvénient de rendre illisibles toutes les requêtes. Dans certains cas particuliers (UPDATE contiennent des clauses WHERE qui modifient de nombreuses lignes), il peut être moins performant.
|
||
Il a l'avantage d'être plus fiable pour de la réplication.
|
||
|
||
Le mode **mixed** est un bon compromis pour de la réplication : il permet de voir la plupart des requêtes en clair, mais évite le problème de fiabilité en passant en mode row quand c'est nécessaire.
|
||
|
||
### Suppression
|
||
|
||
Pour supprimer les binlogs antérieurs à `mysql-bin.00NNNN` :
|
||
|
||
~~~{.sql}
|
||
mysql> PURGE BINARY LOGS TO 'mysql-bin.00NNNN';
|
||
~~~
|
||
|
||
ou par rapport à une date :
|
||
|
||
~~~{.sql}
|
||
mysql> PURGE BINARY LOGS BEFORE "2011-12-07 00:00:00";
|
||
~~~
|
||
|
||
### Désactivation
|
||
|
||
Pour désactiver les binlogs, on ajoutera l'option suivante dans la configuration :
|
||
|
||
~~~{.ini}
|
||
[mysqld]
|
||
disable-log-bin
|
||
~~~
|
||
|
||
### Lecture
|
||
|
||
On pourra lire en ligne de commande le contenu d'un binlog via la commande :
|
||
|
||
~~~
|
||
# mysqlbinlog /var/log/mysql/mysql-bin.001789 | less
|
||
~~~
|
||
|
||
> * Note* : si vous obtenez une erreur `mysqlbinlog: unknown variable 'default-character-set=utf8'` c'est que la directive `default-character-set` a été placée dans la configuration MySQL (`/etc/mysql` ou `.my.cnf`) dans la mauvaise section : `[client]` au lieu de `[mysql]` (ou `[mysqldump]`).
|
||
|
||
### Replay
|
||
|
||
/!\\ **ATTENTION, CES MANIPULATIONS PEUVENT ÊTRE DANGEREUSES VOS DONNÉES, BIEN SAVOIR CE QUE L'ON FAIT ! **
|
||
|
||
On pourra ainsi injecter le contenu d'un binlog dans une base… tout simplement avec une commande du type :
|
||
|
||
~~~
|
||
# mysqlbinlog /var/log/mysql/mysql-bin.001789 | mysql -P3307
|
||
~~~
|
||
|
||
À noter que si une partie des données étaient déjà présentes (cas d'un binlog corrompu lors d'incident lors d'une réplication), on pourra procéder ainsi :
|
||
|
||
~~~
|
||
# mysqlbinlog /var/log/mysql/mysql-bin.001789 > mysql-bin.001789.txt
|
||
# sed -i 's/INSERT INTO/INSERT IGNORE INTO/gi' mysql-bin.001789.txt
|
||
# cat mysql-bin.001789.txt | mysql -P3307
|
||
~~~
|
||
|
||
### SET sql_log_bin = 0
|
||
|
||
On peut effectuer des requêtes SQL qui ne seront pas écrites dans le binlog. Pour cela on positionne la variable _sql_log_bin_ à 0 et les requêtes interactives suivantes ne seront pas prises en compte dans le binlog (bien sûr, si l'on quitte le CLI MySQL, cela ne sera plus valable) :
|
||
|
||
~~~{.sql}
|
||
mysql> SET sql_log_bin = 0;
|
||
~~~
|
||
|
||
> *Note* : cela nécessite le droit MySQL _SUPER_
|
||
|
||
## Multiples instances MySQL
|
||
|
||
Il est possible de faire fonctionner plusieurs instances de MySQL sur un serveur ; chacune avec ses propres données et sa propre configuration.
|
||
|
||
### Installation
|
||
|
||
Avant toute opération, **il est nécessaire de commenter cette ligne** dans le `/etc/mysql/my.cnf` :
|
||
|
||
~~~{.ini}
|
||
#user = mysql
|
||
~~~
|
||
|
||
Et de rajouter ces lignes :
|
||
|
||
~~~{.ini}
|
||
[mysqld_multi]
|
||
user = mysqladmin
|
||
~~~
|
||
|
||
Créer un utilisateur pour l'instance (il doit avoir un shell valide comme `/bin/sh`) :
|
||
|
||
~~~
|
||
# useradd mysql-foo
|
||
~~~
|
||
|
||
Créer ensuite le *datadir* :
|
||
|
||
~~~
|
||
# mysql_install_db --user=mysql-foo --datadir=/srv/mysql-instances/foo
|
||
# chmod 700 /srv/mysql-instances/foo
|
||
~~~
|
||
|
||
Ajouter ces lignes dans `/etc/mysql/conf.d/zzz_evolinux.cnf` :
|
||
|
||
~~~{.ini}
|
||
[mysqld1]
|
||
mysqld = /usr/bin/mysqld_safe
|
||
user = mysql-foo
|
||
port = 3307
|
||
socket = /var/run/mysqld-foo/mysqld.sock
|
||
pid-file = /var/run/mysqld-foo/mysqld.pid
|
||
datadir = /home/mysql-foo
|
||
~~~
|
||
|
||
> *Note 1* : même si l'on ne prévoit pas de faire tourner le mysqld principal sur le port 3306,
|
||
on préfère tout de même utiliser le port 3307 pour la première instance afin de ne pas
|
||
confondre une configuration avec et sans instance.
|
||
|
||
> *Note 2* : dans le cas où une réplication est déjà active sur l'instance principale, la nouvelle instance créée va automatiquement hériter des paramètres de réplication.
|
||
Pour éviter ça, il suffit de rajouter :
|
||
|
||
~~~{.ini}
|
||
[mysqld1]
|
||
skip-slave-start
|
||
~~~
|
||
|
||
Créer le répertoire qui contiendra le socket et le fichier PID :
|
||
|
||
~~~
|
||
# mkdir /var/run/mysqld-foo
|
||
# chown mysql-foo:mysql-foo /var/run/mysqld-foo
|
||
~~~
|
||
|
||
Puis lancer la nouvelle instance :
|
||
|
||
~~~
|
||
# mysqld_multi start 1
|
||
~~~
|
||
|
||
Enfin, n'oubliez pas de définir un mot de passe root/mysqladmin pour la nouvelle instance !
|
||
|
||
Pour voir l'état des instances :
|
||
|
||
~~~
|
||
# mysqld_multi report
|
||
~~~
|
||
|
||
Et pour stopper une instance, on évite la commande « mysqld_multi stop 1 » qui n'est que rarement fiable et peut laisser l'instance dans un état incorrect, difficile à récupérer.
|
||
|
||
On préfère passer la commande « shutdown » en interne :
|
||
|
||
~~~
|
||
# mysqladmin -P3307 shutdown
|
||
~~~
|
||
|
||
> **Note** : a priori cela revient à envoyer un signal SIGTERM (kill -15) au process mysqld
|
||
|
||
### Nettoyage
|
||
|
||
Si le *mysqld* principal n'est pas utilisé, on désactivera le script d'init.d /etc/init.d/mysql (en ajoutant `exit 0`
|
||
au début du script) et on pourra se créer un script `/etc/init.d/mysql-instance` du type :
|
||
|
||
~~~{.bash}
|
||
#!/bin/sh
|
||
#
|
||
### BEGIN INIT INFO
|
||
# Provides: mysql-instance
|
||
# Required-Start: $remote_fs $syslog
|
||
# Required-Stop: $remote_fs $syslog
|
||
# Should-Start: $network $time
|
||
# Should-Stop: $network $time
|
||
# Default-Start: 2 3 4 5
|
||
# Default-Stop: 0 1 6
|
||
# Short-Description: Start and stop the mysql database server daemon
|
||
# Description: Controls the main MySQL database server daemon "mysqld"
|
||
# and its wrapper script "mysqld_safe".
|
||
### END INIT INFO
|
||
#
|
||
set -e
|
||
set -u
|
||
|
||
case "$1" in
|
||
start)
|
||
mysqld_multi start
|
||
;;
|
||
stop)
|
||
mysqld_multi stop
|
||
;;
|
||
restart)
|
||
mysqld_multi stop
|
||
mysqld_multi start
|
||
;;
|
||
*)
|
||
echo "Usage: $0 {start|stop}"
|
||
exit 1
|
||
esac
|
||
|
||
exit 0
|
||
~~~
|
||
|
||
### Administration
|
||
|
||
Pour voir le statut de l'instance n°1, logiquement nommée mysqld1 (GNR=1) et tournant sur le port 3307 :
|
||
|
||
~~~
|
||
# mysqld_multi report 1
|
||
Reporting MySQL servers
|
||
MySQL server from group: mysqld1 is running
|
||
~~~
|
||
|
||
Pour l'arrêter/redémarrer, même principe (attention, `mysqld_multi` est peu verbeux) :
|
||
|
||
~~~
|
||
# ps auwx | grep 3307
|
||
# mysqladmin -P 3307 shutdown
|
||
# ps auwx | grep 3307
|
||
# mysqld_multi start 1
|
||
# ps auwx | grep 3307
|
||
~~~
|
||
|
||
## Augmenter le nombre de max_connections à chaud :
|
||
|
||
~~~
|
||
set global max_connections = 350;
|
||
~~~
|
||
|
||
## Optimisation avancée
|
||
|
||
Voir [/HowtoMySQL/Optimize]().
|
||
|
||
## Réplication MySQL
|
||
|
||
Voir [/HowtoMySQL/Replication]().
|
||
|
||
## FAQ et erreurs courantes
|
||
|
||
Voir [/HowtoMySQL/Troubleshooting]().
|