MySQL/Guide de démarrage
Ce guide présente la configuration et l'utilisation de MySQL sur Linux.
Démarrer avec MySQL
Fondamentaux
MySQL est un serveur de bases de données utilisé dans des applications variées. SQL signifie (S)tructured (Q)uery (L)anguage (Langage de requêtes structuré), langage que MySQL utilise pour communiquer avec d'autres programmes. Par dessus tout cela, MySQL possède ses propres fonctions SQL étendues pour offrir à l'utilisateur des fonctionnalités additionnelles. Dans ce document, nous allons voir comment procéder à l'installation initiale de MySQL, configurer des bases de données et des tables puis créer de nouveaux utilisateurs. Commençons par l'installation.
Installation de MySQL
Assurez-vous d'abord que MySQL est installé sur votre système. Dans le cas où vous auriez besoin de fonctionnalités spécifiques de MySQL, vérifiez que vous avez activé les options requises de la variable USE qui vous permettent de peaufiner votre installation.
root #emerge --ask dev-db/mysqlÀ la fin de l'installation vous recevrez la notification suivante :
You might want to run:
"emerge --config =dev-db/mysql-[version]"
if this is a new install.
Comme il s'agit d'une nouvelle installation, exécutez la commande. Vous devez presser la touche ENTREE lorsque vous y êtes invité durant la configuration de la base de données MySQL. La configuration met en place la base de données MySQL principale qui contient les informations administratives telles que les bases de données, les tables, les utilisateurs, les droits et plus encore. La configuration vous recommande de changer le mot de passe root dès que possible. Vous devez absolument le faire, sinon quelqu'un pourrait arriver par hasard et hacker la configuration de votre serveur MySQL.
root #emerge --config =dev-db/mysql-[version]* MySQL DATADIR is /var/lib/mysql * Pressez ENTREE pour créer la base de données mysql et définir les * permissions adéquates sur elles, ou Control-C pour abandonner maintenant... Preparing db table Preparing host table Preparing user table Preparing func table Preparing tables_priv table Preparing columns_priv table Installing all prepared tables Pour lancer mysqld au démarrage vous devez copier support-files/mysql.server au bon emplacement pour votre système. PENSEZ À DÉFINIR UN MOT DE PASSE MySQL POUR L'UTILISATEUR root ! Pour cela, exécutez les commandes suivantes pour démarrer le serveur et changer le mot de passe : /etc/init.d/mysql start /usr/bin/mysqladmin -u root -h pegasos password 'new-password' /usr/bin/mysqladmin -u root password 'new-password' Selon votre configuration, une option -p peut être nécessaire dans la dernière commande. Reportez-vous au manuel pour les détails.
Si la commande précédente échoue à cause d'un nom d'hôte fixé à localhost, alors changez le nom d'hôte, par exemple en gentoo. Mettez à jour le fichier /etc/conf.d/hostname et redémarrez /etc/init.d/hostname.
Quelques informations MySQL, non spécifiques à l'ebuild, ont été retirées de manière à conserver autant de cohérence que possible dans ce document.
Depuis mysql-4.0.24-r2, les mots de passe sont entrés pendant la phase de configuration rendant la saisie du mot de passe root plus sûre.
Le script de configuration a déjà imprimé les commandes dont vous avez besoin pour définir votre mot de passe. Exécutez les.
Si OpenRC est utilisé, lancer la commande suivante :
root #rc-service mysql start* Re-caching dependency info (mtimes differ)... * Starting mysqld (/etc/mysql/my.cnf) ... [ ok ]
Si systemd est utilisé, lancer la commande suivante :
root #systemctl restart mysqld.serviceAvec >=dev-db/mariadb-10.1.18, utilisez:
root #systemctl restart mariadb.serviceAprès cela définissez le mot de passe de root :
root #/usr/bin/mysqladmin -u root -h localhost password 'new-password'Vous pouvez désormais tester votre mot de passe root en essayant de vous connecter au serveur MySQL :
user $mysql -u root -h localhost -pEntrez le mot de passe: Bienvenue dans le surveillant MySQL. Les commandes se terminent par ; ou \g. Votre identifiant de connexion MySQL est 4 pour la version du serveur : 4.0.25 Tapez 'help;' ou '\h' pour de l'aide. Tapez '\c' pour effacer le tampon mysql>
L'option -u définit le nom de l'utilisateur qui désire se connecter. L'option -h définit l'hôte. C'est en général localhost sauf si vous êtes en train de configurer un serveur distant. Pour finir, l'option -p informe le client mysql que vous aller saisir le mot de passe d'accès à la base de données. Notez l'apparition de l'invite de commande mysql>. C'est dans ce contexte que vous saisissez toutes les commandes mysql. Maintenant que vous avez l'invite de commande mysql en tant que root, vous pouvez commencer à configurer votre base de données.
L'installation par défaut de mysql installation est prévue pour les systèmes de développement. Vous pouvez désirer exécuter /usr/bin/mysql_secure_installation pour fixer quelques valeurs par défaut plus sûres.
Configurer la base de données
Créer une base de données
Vous vous êtes connecté et vous disposez d'une invite de commande mysql. Commençons par regarder les bases de données dont vous disposez. Pour cela, utilisez la commande SHOW DATABASES.
mysql>SHOW DATABASES+----------+ | Database | +----------+ | mysql | | test | +----------+ 2 rows in set (0.09 sec)
Rappelez-vous que les commandes MySQL doivent se terminer par un point-virgule --
;Bien qu'une base de données de test soit déjà créée, nous allons créer la notre. Les bases de données sont créées en utilisant la commande CREATE DATABASE. Nous allons en créer une appelée gentoo.
mysql>CREATE DATABASE gentoo;Query OK, 1 row affected (0.08 sec)
La réponse nous fait savoir que la commande a été exécutée sans erreur. Dans ce cas, une ligne a été modifiée. Ceci se réfère à la base de données principale, qui contient la liste de toutes les bases de données. Vous n'avez pas à trop vous préoccuper des détails d'arrière-plan. Le dernier nombre indique combien de temps l'exécution de le requête a nécessité. Vous pouvez vérifier que la base de données a été créée en exécutant la commande SHOW DATABASES à nouveau.
mysql>SHOW DATABASES;+----------+ | Database | +----------+ | gentoo | | mysql | | test | +----------+ 3 rows in set (0.00 sec)
Votre base de données a bien été créée. Afin de commencer à créer des tables dans votre nouvelle base gentoo, vous devez la sélectionner comme base de données courante en utilisant la commande USE. La commande USE prend comme argument le nom de la base de données que vous voulez utiliser comme base de données courante. Une autre possibilité est de la définir dans les commandes avec l'option -D. Définissez maintenant votre base de données courante.
mysql>USE gentoo;Database changed
La base de données courante est maintenant votre base de données gentoo fraîchement créée. Maintenant que vous l'utilisez, vous pouvez commencer à créer des tables et y placer des informations.
Travailler avec des tables dans MySQL
Créer une table
Dans la structure de MySQL, il y a les bases de données, les tables, les enregistrements et les champs. Les bases de données contiennent les tables, les tables contiennent les enregistrements et les enregistrements contiennent les champs qui contiennent, pour leur part, les informations réelles. Cette structure permet aux utilisateurs de préciser comment ils veulent accéder à leurs données. Jusqu'à maintenant vous avez manipulé des bases de données, passez maintenant aux tables. Tout d'abord, les tables peuvent être listées comme les bases de données avec la commande SHOW TABLES. Actuellement, il n'y a pas de table dans la base gentoo, et la sortie de la commande indique :
mysql>SHOW TABLES;Empty set (0.00 sec) (Jeu vide)
Ceci signifie qu'il faut créer quelques tables. Pour cela utilisez la commande CREATE TABLE. Cette commande est très différente de la commande CREATE DATABASE en ce sens qu'elle demande une liste d'arguments. Elle a la forme suivante :
CREATE TABLE [nom_de_table] ([nom_de_champ] [type_de_données_de_champ]([taille]));
nom_de_table est le nom de la table que vous voulez créer. Dans notre cas créez une table nommée développeurs . Cette table contiendra le nom des développeurs, leur adresse de courriel et leur travail.
nom_de_champ contiendra le nom du champ. Nous avons 3 noms requis dans ce cas : nom, courriel et travail. En plus, un champ PRIMARY KEY (clef primaire) est défini pour utiliser facilement des relations avec d'autre tables et s'auto-incrémentera à chaque insertion de donnée. La clef primaire est vivement recommandée mais n'est pas nécessaire car MySQL en garde une en interne. Les indexes, dont la clef primaire appartient, permet un accès plus rapide aux données à mesure que les tables grandissent.
Le field_data_type est le type d'information qui sera stocké. Les différents formats disponibles peuvent être trouvés sur MySQL Column Types Page. Pour notre objectif, nous utiliserons le type de données VARCHAR pour tous nos champs et INTEGER pour le champ de clef primaire. VARCHAR est l'un des types de données les plus simples dès lors qu'il s'agit de travailler avec des chaînes de caractères.
size représente la quantité de données qu'un simple champ contiendra. Dans ce cas, nous utiliserons 128. Ceci signifie que le champ peut avoir une donnée VARCHAR de 128 octets. Vous pouvez sans crainte considérer cela comme 128 caractères pour le moment, bien qu'il y ait une explication quelque peu plus technique que le site mentionné ci-dessus vous fournira. Maintenant que nous savons comment nous allons créer la table, allons-y :
mysql>CREATE TABLE développeurs ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, nom VARCHAR(128), courriel VARCHAR(128), travail VARCHAR(128));Query OK, 0 rows affected (0.11 sec)
Il semble que votre table ait bien été créée. Vérifions cela avec la commande SHOW TABLES :
mysql>SHOW TABLES;+------------------+ | Tables_in_gentoo | +------------------+ | développeurs | +------------------+ 1 row in set (0.00 sec)
Bien ! Notre table est là ! Néanmoins, elle ne semble pas contenir la moindre information sur les types de champs que nous avons définis. Pour cela, utilisez la commande DESCRIBE (ou DESC en forme raccourcie), qui prend le nom de la table en argument. Regardons à quoi cela ressemble avec notre table développeurs.
mysql>DESCRIBE développeurs;+----------+--------------+------+-----+-----------+-----------------+ | Champ | Type | Null | Key | Defaut | Extra | +----------+--------------+------+-----+------------+----------------+ | id | int(11) | NO | PRI | NULL | auto_increment | | nom | varchar(128) | YES | | NULL | | | courriel | varchar(128) | YES | | NULL | | | travail | varchar(128) | YES | | NULL | | +----------+--------------+------+-----+------------+----------------+ 3 rows in set (0.00 sec)
Ceci montre les différents champs et leur type ainsi que quelques attributs supplémentaires qui sont au delà du champ de ce document. Reportez-vous au Manuel de référence de MySQL pour une information plus complète. Vous disposez maintenant d'une table avec laquelle travailler. Nous allons la remplir.
Remplir la base de données MySQL
Nous remplissons une table (ou y ajoutons des données) avec la commande INSERT. Comme la commande CREATE TABLE, elle utilise un format spécifique :
INSERT INTO table (col1, col2, ...) VALUES('valeur1', 'valeur2', ...);
Cette commande est utilisée pour insérer un enregistrement dans une table. table contient le nom de la table dans laquelle nous désirons entrer des informations. Le nom de la table peut être suivi par une liste des colonnes dans lesquelles nous voulons insérer des données et VALEURS() contiennent les valeurs à insérer dans la table. Vous pouvez ne pas fournir la liste des colonnes si vous écrivez dans toutes les colonnes et que si vous fournissez les valeurs dans l'ordre dans lequel vous avez défini les colonnes. Pour les colonnes auto-incrémentées, la valeur NULL va utiliser la prochaine valeur disponible. Dans ce cas, nous voulons insérer des données dans la table développeurs. Insérons un enregistrement :
mysql>INSERT INTO développeurs VALUES(NULL, 'Joe Smith', 'joesmith@gentoo.org', 'toolchain');Query OK, 1 row affected (0.06 sec)
## (Si vous ne connaissez pas l'ordre des colonnes dans la table ou voulez insérer un enregistrement incomplet.)
mysql> INSERT INTO développeurs (travail, nom) VALUES('outsourced', 'Jane Doe');
Query OK, 1 row affected (0.01 sec)
Si on se réfère au résultat retourné, il apparaît que l'enregistrement a été correctement inséré. Mais comment faire pour insérer plus qu'un seul enregistrement ? C'est là que la commande LOAD DATA entre en scène. Elle charge les enregistrements depuis un fichier. Essayons en éditant un tel fichier dans notre répertoire home. Nous appellerons ce fichier records.txt. En voici un échantillon :
3 John Doe johndoe@gentoo.org portage
4 Chris White chriswhite@gentoo.org documentation
5 Sam Smith samsmith@gentoo.org amd64
Vous devez absolument connaître les données que vous manipulez. Il est très dangereux d'utiliser
LOAD DATA sans une parfaite maîtrise des données du fichier !La commande LOAD DATA a une définition beaucoup plus longue, mais nous utiliserons ici une forme simplifiée.
LOAD DATA LOCAL INFILE '/chemin/vers/fichier' INTO TABLE table;
/chemin/vers/fichier représente le chemin et le nom du fichier à charger. table est le nom de la table concernée. Dans ce cas, le fichier est ~/records.txt et la table est développeurs.
mysql>LOAD DATA LOCAL INFILE '~/records.txt' INTO TABLE développeurs;Query OK, 3 rows affected (0.00 sec) Records: 3 Deleted: 0 Skipped: 0 Warnings: 0
Si vous obtenez un comportement étrange, assurez-vous que vous champs sont séparés par des tabulations. Si vous copiez-collez vous données dans le fichier à partir d'une autre source, cela pourrait changer vous tabulations en espaces.
Ça a marché ! Cependant, ceci insère seulement des enregistrements et ne vous donne aucun contrôle sur MySQL. Beaucoup d'applications du Web utilisent des scripts sql afin de configurer MySQL rapidement et facilement. Si vous voulez utiliser un script sql, vous devez lancer mysql en mode batch, ou « sourcer » le fichier. Voici un exemple où mysql est utilisé en mode batch :
user $mysql -u root -h localhost -p < sqlfileComme avec LOAD DATA , vous devez savoir précisément ce que sqlfile contient. Dans le cas contraire votre base peut être compromise ! Une autre façon de faire la même chose consiste à utiliser la commande source. Cette commande exécutera les commandes mysql trouvées dans un fichier sql tout en étant en mode mysql interactif. Voici comment « sourcer » un fichier sql :
mysql>source sqlfile;Si vous rencontrez une application Web vous demandant d'exécuter un fichier sql, les deux commandes vues ci-dessus peuvent être utilisées pour le faire. Nous avons configuré notre table, mais comment vérifier nos champs ? Nous pouvons le faire en exécutant des requêtes de recherche sur la table.
Parcourir une table MySQL avec des requêtes
Les requêtes sont l'une des fonctionnalités principales de toute base SQL. Elles permettent de transformer les données dans les tables en quelque chose d'utile. La plupart des requêtes sont faites avec la commande SELECT. La commande SELECT est très complexe, et nous allons nous limiter à trois formes principales de cette commande dans ce document.
## (Sélectionne toutes les entrées dans une table )
SELECT * FROM table;
## (Sélectionne des entrées spécifiques dans une table )
SELECT * FROM table WHERE champ=valeur;
## (Sélectionne des champs spécifiques)
SELECT champ1,champ2,champ3 FROM table [WHERE champ=valeur];
Jetons un coup d'œil rapide à la première forme. Elle est relativement simple et retourne une vue d'ensemble de la table. Nous allons avancer et la lancer pour voir de quelles données nous disposons jusqu'à maintenant.
mysql>SELECT * FROM développeurs;+----+-------------+-----------------------+----------------+ | id | nom | courriel | travail | +----+-------------+-----------------------+----------------+ | 1 | Joe Smith | joesmith@gentoo.org | toolchain | | 2 | John Doe | johndoe@gentoo.org | portage | | 3 | Chris White | chriswhite@gentoo.org | documentation | | 4 | Sam Smith | samsmith@gentoo.org | amd64 | | 5 | Jane Doe | NULL | Outsourced job | +----+-------------+-----------------------+----------------+ 5 rows in set (0.00 sec)
Nous pouvons voir à la fois les données que nous avons insérées via INSERT et celles que nous avons insérées via LOAD DATA. Maintenant, supposons que nous ne voulions voir que l'enregistrement par Chris White. Nous pouvons le faire en utilisant la deuxième forme de SELECT. Comme ceci :
mysql>SELECT * FROM développeurs WHERE nom = 'Chris White';+----+-------------+-----------------------+---------------+ | id | nom | courriel | travail | +----+-------------+-----------------------+---------------+ | 3 | Chris White | chriswhite@gentoo.org | documentation | +----+-------------+-----------------------+---------------+ 1 row in set (0.08 sec)
Comme attendu, l'entrée spécifique que nous cherchons a été sélectionnée et est affichée. Maintenant, supposons que nous ne voulions voir que le travail et le courriel des personnes et pas leur nom. Nous pouvons pour cela utiliser la troisième forme de SELECT comme ceci :
mysql>SELECT courriel,travail FROM développeurs WHERE nom = 'Chris White';+-----------------------+---------------+ | courrie | travail | +-----------------------+---------------+ | chriswhite@gentoo.org | documentation | +-----------------------+---------------+ 1 row in set (0.04 sec)
Cette méthode de sélection est beaucoup plus facile à gérer, en particulier avec une grande quantité d'informations, comme nous allons le voir. Tout de suite, étant utilisateur root de mysql, nous avons des droits illimités pour faire tout ce que nous voulons dans la base MySQL. Dans un environnement de serveur, un utilisateur avec de tels privilèges peut être source de gros problèmes. Afin de définir qui fait quoi dans la base, nous devons définir les privilèges.
Privilèges MySQL
Les privilèges définissent le type d'accès que les utilisateurs ont sur les bases de données, les tables,etc., en fait sur presque tout. Pour l'instant, le compte root de MySQL est le seul à pouvoir accéder à notre base de données gentoo. Créons maintenant deux utilisateurs génériques, invité et administrateur, qui recevront des droits d'accès à la base gentoo pour travailler avec ses données. Le compte invité sera un compte restreint. Tout ce qu'il pourra faire sera d'obtenir des informations de la base, rien d'autre. Le compte administrateur aura les mêmes privilèges que root, mais uniquement pour la base gentoo (pas pour les bases MySQL principales).
Création d'utilisateurs
La requête SQL CREATE USER va créer un utilisateur et définir un moyen d'authentification, souvent par mot de passe mais d'autre moyens peuvent être disponibles.
Un exemple de commande CREATE USER est:
CREATE USER '[utilisateur]'@'[host]' IDENTIFIED BY '[mot_de_passe]';
utilisateur est le nom de l'utilisateur et host est le nom d'hote à partir duquel l'utilisateur a le droit d'accéder. Dans la plupart des cas ce sera localhost (la machine locale). Pour créer les utilisateurs de notre exemple:
(administrateur)
mysql>CREATE USER 'administrateur'@'localhost' IDENTIFIED BY 'password';
(invité)
mysql>CREATE USER 'invité'@'localhost' IDENTIFIED BY 'password';
L'hôte localhost ne veut pas dire que la connection sera établie par le nom de domaine localhost (127.0.0.1), mais par un socket de connexion UNIX.
Accorder des privilèges avec la commande GRANT
Examinons de plus près l'utilisation simplifié de la commande GRANT.
GRANT [privileges] ON database.* TO '[utilisateur]'@'[host]';
Tout d'abord, il y a les privilèges que nous voulons donner. Avec ce que nous avons appris jusqu'à maintenant, voici quelques privilèges que nous pouvons accorder :
ALL-Donne tous les privilèges sur la base de donnéesCREATE- Autorise l'utilisateur à créer des tablesSELECT- Autorise l'utilisateur à interroger les tablesINSERT- Autorise l'utilisateur à insérer des données dans la tableSHOW DATABASES- Autorise l'utilisateur à voir la liste des tablesUSAGE- L'utilisateur n'a aucun privilègeGRANT OPTION- Autorise l'utilisateur à octroyer des privilèges
Si vous exécutez MySQL pour transmettre des données à une application Web,
CREATE , SELECT , INSERT (discuté ici ), DELETE et UPDATE (pou une plus ample information, consultez la syntaxe de GRANT et REVOKE du Manuel de référence de MySQL ) sont les seules autorisations dont vous aurez probablement besoin. Beaucoup de gens commettent l'erreur d'octroyer toutes les autorisations alors que ce n'est pas réellement nécessaire. Vérifiez auprès des développeurs des applications si de telles autorisations peuvent compromettre le fonctionnement général.Pour notre utilisateur administrateur, ALL fera l'affaire. Pour l'utilisateur invité,SELECT conviendra pour un accès en lecture seule. database est la base de données sur laquelle nous voulons octroyer des privilèges à l'utilisateur. Dans cet exemple, la base de donnée est gentoo. Le .* signifie toutes les tables. Si vous le désirez vous pouvez octroyer des droits par table.
mysql>GRANT ALL ON gentoo.* TO 'administrateur'@'localhost';mysql>GRANT SELECT ON gentoo.* TO 'invité'@'localhost';Maintenant que nos utilisateurs sont définis, testons les. Tout d'abord il nous faut quitter MySQL en tapant quit à l'invite de commande :
mysql>quitNous sommes de retour sur la console. Maintenant que nos utilisateurs sont définis, avançons et regardons ce qu'ils peuvent faire.
Vérifier les autorisations de l'utilisateur
Nous allons essayer de nous connecter en tant qu'utilisateur invité. À cet instant, l'utilisateur invité a seulement les privilèges SELECT. Ce qui l'autorise seulement à interroger la base, rien d'autre. Allons-y, connectons-nous !
user $mysql -u invité -h localhost -pEntrez le mot de passe : Bienvenue dans le surveillant de MySQL. Les commandes se terminent par ; ou \g. Votre identifiant de connexion MySQL est 6 pour le serveur version 4.0.25. Tapez 'help;' ou '\h' pour de l'aide. Tapez '\c' pour vider le tampon. mysql>
Maintenant nous devrions tester les restrictions de l'utilisateur. Commutons sur la base gentoo :
mysql>USE gentoo;Lecture des informations sur les tables pour constructions de noms de tables et de colonnes. Vous pouvez désactiver cette fonctionnalité pour avoir un démarrage plus rapide avec -A Base de données changée
Maintenant essayons de faire quelque chose que nous ne sommes pas supposé faire. Essayons de créer une table.
mysql>CREATE TABLE test (test VARCHAR(20), foobar VARCHAR(2));ERROR 1044: Accès refusé pour utilisateur: 'invité@localhost' sur la base de données 'gentoo'
Comme vous pouvez le constater, cette fonction échoue, car notre utilisateur n'a pas les droits appropriés. Cependant, un accès permis est la commande SELECT. Essayons-la :
mysql>SELECT * FROM développeurs;+-------------+-----------------------+----------------+ | nom | courril | travail | +-------------+-----------------------+----------------+ | Joe Smith | joesmith@gentoo.org | toolchain | | John Doe | johndoe@gentoo.org | portage | | Chris White | chriswhite@gentoo.org | documentation | | Sam Smith | samsmith@gentoo.org | amd64 | | Jane Doe | NULL | Outsourced job | +-------------+-----------------------+----------------+ 5 lignes dans le jeu (0.00 sec)
La commande réussit, et nous avons un aperçu de ce que les autorisations utilisateur peuvent faire. Nous avons cependant créé un compte administrateur également. Ceci cherche à montrer que même les utilisateurs recevant les autorisations 'All' sont limités. Avançons, quittons MySQL et reconnectons-nous en tant qu'utilisateur administrateur.
mysql>quitBye
user $mysql -u administateur -h localhost -pEntrez le mot de passe : Bienvenue dans le surveillant de MySQL. Les commandes se terminent par ; ou \g. Votre identifiant de connexion MySQL est 6 pour le serveur version 4.0.25. Tapez 'help;' ou '\h' pour de l'aide. Tapez '\c' pour vider le tampon. mysql>
Pour commencer nous allons créer une nouvelle base de données en tant qu'utilisateur administrateur. Cet utilisateur administrateur aura un accès similaire à celui du compte root de MySQL, et sera capable de faire toute sorte de modifications de son choix sur la base de données gentoo. Ceci permettra de tester l'accès de l'utilisateur à la base principale MySQL. Rappelez-vous que nous avons seulement défini les autorisations pour une base de données spécifique.
mysql>CREATE DATABASE gentoo2;ERROR 1044: Accès refusé pour l'utilisateur : 'administrateur@localhost' to database 'gentoo2'
En effet l'utilisateur administrateur ne peut pas créer de base de données sur la base MySQL principale., malgré les autorisations ALL sur la base gentoo. Néanmoins, nous pouvons utiliser le compte administrateur pour modifier la base de données gentoo, comme l'illustre l'exemple d'insertion de données qui suit.
mysql>USE gentoo;
Lecture des informations de la table pour création des noms de table et de colonnes.
Vous pouvez désactiver cette fonctionnalité pour obtenir un démarrage plus rapide avec -A
Base de données changée
mysql> INSERT INTO développeurs VALUES('Bob Simmons', 'bobsimmons@gentoo.org', 'python');
Query OK, 1 row affected (0.08 sec)
L'utilisateur administrateur peut accéder à la base de données comme il l'entend. Maintenant, quelques fois, nous avons besoin de retirer des autorisations à un utilisateur. La raison peut être qu'il s'agit d'un utilisateur à problèmes ou d'un employé retraité. Regardons comment désactiver les autorisations d'un utilisateur avec la commande REVOKE.
Retirer des droits à un utilisateur avec la commande REVOKE
La commande REVOKE nous permet de retirer des droits d'accès à un utilisateur. Nous pouvons, soit lui retirer tout droit d'accès, soit lui retirer un droit d'accès spécifique. En fait, le format est très semblable à celui de la commande GRANT.
REVOKE [privileges] ON database.* FROM '[user]'@'[host]';
Les options sont les mêmes que pour la commande aGRANT. Ici cependant, nous allons retirer tous les droits d'accès à un utilisateur. Supposons que le compte invité crée des problèmes de sécurité. Nous décidons de lui retirer tous ses privilèges. Nous nous connectons en tant que root pour faire :
mysql>REVOKE ALL ON gentoo.* FROM 'invité'@'localhost';Query OK, 0 rows affected (0.00 sec)
Dans ce cas, les droits d'accès de l'utilisateur sont simples, et retirer tout droit sur une base est facile. Néanmoins, dans des cas plus complexes, vous devrez probablement utiliser *.* au lieu de gentoo.* pour retirer les droits d'accès à toutes les bases de données.
Maintenant quittons et essayons de nous reconnecter en tant qu'utilisateur invité.
user $mysql -u invité -h localhost -pEntrez le mot de passe: Bienvenue dans le surveillant de MySQL. les commandes se terminent par ; ou \g. Votre identifiant de connexion MySQL est 9 pour le serveur version: 4.0.25 Tapez 'help;' ou '\h' pour de l'aide. Tapez '\c' pour efface le tampon. mysql>
Bien que nous parvenions à nous connecter, notre accès à gentoo est désormais révoqué.
mysql>USE gentoo;ERROR 1044: Accès refusé à l'utilisateur : 'invité@localhost' à la base de données 'gentoo'
Ainsi, notre utilisateur à problèmes ne peut plus accéder à la base gentoo. Notez que l'utilisateur peut encore se connecter. C'est parce qu'il est resté dans la base de données principale de MySQL. Regardons maintenant comment supprimer définitivement un compte dans la base principale avec la commande DROP USER.
Supprimer un compte
Vérifiez que vous êtes connectés en tant que root.
DROP USER va supprimer l'enregistrement dans la table utilisateur et dans toutes les tables de privilèges. Allons-y et faisons-le:
mysql>DROP USER 'guest'@'localhost';Query OK, 1 row affected (0.07 sec)
Tout semble avoir fonctionné. Testons en nous déconnectant et tentant de nous reconnecter en tant qu'utilisateur invité.
mysql>quitBye
user $mysql -u invité -h localhost -pEntrez le mot de passe: ERROR 1045: Accès refusé à l'utilisateur : 'invité@localhost' (Utilisant le mot de passe: YES)
Notre utilisateur a bien été effacé !
Conclusion
Bien que ce guide se focalise essentiellement sur la configuration de MySQL en ligne de commande, il existe quelques alternatives graphiques :
- phpMyAdmin - Outil en php pour l'administration de MySQL.
Ceci achève le tutoriel d'introduction à MySQL. J'espère qu'il vous aura permis une meilleure compréhension des fondamentaux de MySQL et appris comment configurer une base de données.
This page is based on a document formerly found on our main website gentoo.org.
The following people contributed to the original document: Chris White, Shyam Mani, Xavier Neys
They are listed here because wiki history does not allow for any external attribution. If you edit the wiki article, please do not add yourself here; your contributions are recorded on each article's associated history page.