MySQL/Einstiegsleitfaden
Dieser Leitfaden umreißt grundlegende Anweisungen für Benutzer zum Einrichten und Verwenden von MySQL unter Linux.
Erste Schritte mit MySQL
Hintergrund
MySQL ist ein populärer Datenbankserver der in verschiedensten Programmen benutzt wird. SQL steht im Englischen für (S)tructured (Q)uery (L)anguage, auf Deutsch in etwa Strukturierte Abfrage Sprache. Dieses SQL wird für die Kommunikation zwischen Server und anderen Programmen benutzt. Zusätzlich hat MySQL eigene Erweiterungen der Standard SQL-Funktionen um extra Deatures bereit zu stellen. In diesem Dokument wird die minimale MySQL Installation beschrieben, sowie die Einrichtung von Datenbasen, Tabellen und neuen Benutzern. Starten wir mit der Installation.
MySQL Installation
Falls eine bestimmte Funktionalität von MySQL benötigt wird, überprüfen Sie die USE-Flags, die für MySQL verfügbar sind, bevor Sie das Paket emergen:
root #emerge --ask dev-db/mysqlAm Ende der Installation wird folgende Nachricht angezeigt:
You might want to run:
"emerge --config =dev-db/mysql-[version]"
if this is a new install.
Da dies eine neue Installation ist, führen wir den Befehl aus. Sie müssen bei der Konfiguration der MySQL-Datenbank Enter drücken, wenn Sie dazu aufgefordert werden. Die Konfiguration richtet die Haupt-MySQL-Datenbank ein, die administrative Informationen wie Datenbanken, Tabellen, Benutzer, Berechtigungen und vieles mehr enthält. Die Konfiguration empfiehlt, dass Sie Ihr Root-Passwort so schnell wie möglich ändern.
root #emerge --config =dev-db/mysql-[version]* MySQL DATADIR is /var/lib/mysql * Press ENTER to create the mysql database and set proper * permissions on it, or Control-C to abort now... Preparing db table Preparing host table Preparing user table Preparing func table Preparing tables_priv table Preparing columns_priv table Installing all prepared tables To start mysqld at boot time you have to copy support-files/mysql.server to the right place for your system PLEASE REMEMBER TO SET A PASSWORD FOR THE MySQL root USER ! To do so, issue the following commands to start the server and change the applicable passwords: /etc/init.d/mysql start /usr/bin/mysqladmin -u root -h pegasos password 'new-password' /usr/bin/mysqladmin -u root password 'new-password' Depending on your configuration, a -p option may be needed in the last command. See the manual for more details.
Wenn der obige Befehl abbricht, weil der Hostname auf localhost lautet, kann man diesen auf einen anderen Wert z.B. gentoo ändern. Dazu ist /etc/conf.d/hostname zu ändern und /etc/init.d/hostname neu zu starten.
Einige MySQL spezifische Informationen, die nicht den EBuild betreffen, wurden von hier entfertn, um dieses Dokument so konsistent wie möglich zu halten.
Ab mysql-4.0.24-r2 werden Passwörter während der config-Phase eingegeben, wodurch die Root-Passwort-Eingabe sicherer wird.
Das config-Skript hat bereits die Befehle ausgedruckt, die wir ausführen müssen, um unser Passwort einzurichten.
Wenn Sie OpenRC verwenden, geben Sie diesen Befehl ein:
root #rc-service mysql start* Re-caching dependency info (mtimes differ)... * Starting mysqld (/etc/mysql/my.cnf) ... [ ok ]
Bei der Benutzung von systemd kommt der folgende Befehl zur Anwendung:
root #systemctl restart mysqld.serviceMit >=dev-db/mariadb-10.1.18, verwenden Sie:
root #systemctl restart mariadb.serviceDanach ist das root Passwort zu setzen:
root #/usr/bin/mysqladmin -u root -h localhost password 'new-password'Sie können nun testen, dass Ihr Root-Passwort erfolgreich konfiguriert wurde, indem Sie versuchen, sich bei Ihrem MySQL-Server anzumelden:
user $mysql -u root -h localhost -pEnter password: Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 4 to server version: 4.0.25 Type 'help;' or '\h' for help. Type '\c' to clear the buffer. mysql>
Die Option -u gibt den Datenbank-Benutzer an, die Option -h spezifiert den Host. Wird kein Server angegeben wird localhost verwendet. Mit der Option -p wird die Passwortabfrage aktiviert. Nun erscheint die mysql Eingabeaufforderung. Hier werden die Kommandos an den mysql Server abgesetzt. Da wir nun als Root am Datenbankserver angemeldet sind, können wir mit dem setup des Servers beginnen.
Die voreingestellte mysql Installation ist für Entwicklungssysteme angelegt. Mit dem Skript
/usr/bin/mysql_secure_installation werden die Einstellungen etwas sicherer gemacht.Einrichten der Datenbank
Erstellen einer Datenbank
Wir sind eingeloggt und die mysql Eingabeaufforderung wird angezeigt. Zuerst lassen wir uns die aktuell vorhanden Datenbasen anzeigen. Dafür benutzen wir den SHOW DATABESES Befehl.
mysql>SHOW DATABASES;+----------+ | Database | +----------+ | mysql | | test | +----------+ 2 rows in set (0.09 sec)
MySQL Befehle enden immer mit einem Semikolon
;Obwohl schon eine Test-Datenbank eingerichtet ist, wollen wir troztdem unsere eigene Datenbank erstellen. Datenbanken werden mit dem Befehl CREATE DATABASE erzeugt. Unsere Datenbank soll den Namen "gentoo" erhalten.
mysql>CREATE DATABASE gentoo;Query OK, 1 row affected (0.08 sec)
Aus der Antwort des Datenbank Servers ist ersichtlich, dass der Befehl ohne Fehler ausgeführt wurde. In unserem Fall wurde 1 Zeile verändert. Die ist ein Verweis auf die Hauptdatenbank, welche eine Liste der vorhandenen Datenbanken vorhält. Sie müssen sich nicht zu viele Gedanken über die Hintergrunddetails machen. Die letzte Zahl ist, wie schnell die Abfrage ausgeführt wurde. Wir können überprüfen, ob die Datenbank erstellt wurde, indem Sie den Befehl SHOW DATABASES erneut ausführen.
mysql>SHOW DATABASES;+----------+ | Database | +----------+ | gentoo | | mysql | | test | +----------+ 3 rows in set (0.00 sec)
In der Tat wurde unsere Datenbank erstellt. Um mit dem Erstellen von Tabellen für unsere neue gentoo Datenbank arbeiten zu können, müssen wir sie als unsere aktuelle Datenbank auswählen. Dazu verwenden wir den Befehl USE. Der Befehl USE übernimmt den Namen der Datenbank, die Sie als aktuelle Datenbank verwenden möchten. Eine weitere Möglichkeit besteht darin, sie nach dem Schalter -D auf die Befehlszeile zu setzen. Gehen wir weiter und wechseln in die gentoo Datenbank.
mysql>USE gentoo;Database changed
Die aktuelle Datenbank ist nun unsere erzeugte Gentoo Datenbank und wir werden nun einige Tabellen erstellen und diese mit Daten füllen.
Arbeiten mit Tabellen in MySQL
Erzeugen einer Tabelle
Die Gliederung von MySQL ist wie folgt aufgebaut:
Datenbanken, Tabellen, Records und Felder. Datenbanken beinhalten Tabellen, Tabellen halten Records zusammen, Records sind aus Felder zusammen gesetzt. Die Felder enthalten die akutellen Informationen. Diese Gliederung lässt den Benutzer die Wahl wie auf die Informationen zugegriffen werden können. Bis hierher wurden nur Datenbanken benutzt, nun sind Tabellen an der Reihe. Eine Auflistung der Tabellen erhält man mit SHOW TABLES. Noch gibt es keine Tabellen in unserer Datenbank, wie die Ausgabe des Kommandos zeigen wird:
mysql>SHOW TABLES;Empty set (0.00 sec)
Das bedeutet, dass wir einige Tabellen erstellen müssen. Dazu verwenden wir den Befehl CREATE TABLE . Dieser Befehl unterscheidet sich jedoch deutlich von dem einfachen Befehl CREATE DATABASE . Dieser Befehl nimmt eine Liste von Argumenten entgegen. Das Formular ist wie folgt:
CREATE TABLE [table_name] ([field_name] [field_data_type]([size]));
table_name ist der Name der Tabelle, die wir erstellen möchten. In diesem Fall erstellen wir eine Tabelle mit dem Namen developers . Diese Tabelle enthält den Namen des Entwicklers, E-Mail-Adresse und Job.
field_name enthält den Namen des Feldes. In diesem Fall sind 3 Namen erforderlich: name, email und job. Außerdem wird ein PRIMARY KEY-Feld definiert, um die Beziehung zu anderen Tabellen zu vereinfachen, und es wird bei jeder Einfügung automatisch inkrementiert. Der PRIMARY KEY wird empfohlen, ist aber nicht erforderlich, da MySQL intern einen behält. Indizes, zu denen auch der PRIMARY KEY gehört, ermöglichen einen schnelleren Datenzugriff, wenn die Tabellen wachsen.
Der field_data_type legt fest, welche Art von Information in dem entsprechenden Feld gespeichert werden soll. Die verschiedenen verfügbaren Formate sind auf der MySQL Data Types Page zu finden. Für unsere Zwecke werden wir den Datentyp VARCHAR für alle unsere Datenfelder und INTEGER für das Schlüsselfeld verwenden. VARCHAR ist einer der einfachsten Datentypen, wenn es um die Arbeit mit Zeichenketten geht.
size gibt an, wie viel Daten ein einzelnes Feld speichern wird. In diesem Fall verwenden wir 128. Dies bedeutet, dass das Feld VARCHAR -Daten mit 128 Byte haben kann. Sie können sich dies vorläufig als 128 Zeichen vorstellen, obwohl es eine etwas technischere Erklärung gibt, die die obige Seite Ihnen bieten wird. Jetzt, wo wir wissen, wie wir die Tabelle erstellen werden, machen wir es.
mysql>CREATE TABLE developers ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, name VARCHAR(128), email VARCHAR(128), job VARCHAR(128));Query OK, 0 rows affected (0.11 sec)
Unsere Tabelle wurde erzeugt. Eine Liste der Tabellen zeigt uns der Befehl SHOW TABLES:
mysql>SHOW TABLES;+------------------+ | Tables_in_gentoo | +------------------+ | developers | +------------------+ 1 row in set (0.00 sec)
Da ist unsere Tabelle, es fehlen jedoch Informationen über die einzelnen Felder. Dafür verwenden wir den Befehl DESCRIBE (oder DESC ), der den Namen der Tabelle als Argument verwendet. Mal sehen, was uns das für unsere Entwicklertabelle bringt.
mysql>DESCRIBE developers;+-------+--------------+------+-----+---------+----------------+ | Field | Type | Null | Key | Default | Extra | +-------+--------------+------+-----+---------+----------------+ | id | int(11) | NO | PRI | NULL | auto_increment | | name | varchar(128) | YES | | NULL | | | email | varchar(128) | YES | | NULL | | | job | varchar(128) | YES | | NULL | | +-------+--------------+------+-----+---------+----------------+ 3 rows in set (0.00 sec)
Dies zeigt die verschiedenen Felder und ihre Typen. Sie zeigt auch einige zusätzliche Attribute, die den Rahmen dieser Anleitung sprengen würden. Für weitere Informationen können Sie das MySQL Reference Manual zu Rate ziehen. Wir haben jetzt eine Tabelle, mit der wir arbeiten können. Lassen Sie uns nun fortfahren und sie befüllen.
Füllen der MySQL Datenbank
Wir fügen Daten mittels INSERT Befehl ein. Ähnlich wie CREATE TABLE, hat er ein spezifisches Format.
INSERT INTO table (col1, col2, ...) VALUES('value1', 'value2', ...);
Dieser Befehl wird verwendet, um einen Datensatz in eine Tabelle einzufügen. table enthält die MySQL-Tabelle, in die die Informationen eingegeben werden sollen. Dem Tabellennamen kann eine Liste von Spalten folgen, in die Daten eingefügt werden sollen, und VALUES() enthält die Werte, die Sie in die Tabelle einfügen wollen. Sie können die Liste der Spalten weglassen, wenn Sie in jede Spalte einen Wert einfügen und wenn Sie die Werte in derselben Reihenfolge schreiben, in der die Spalten definiert wurden. Bei der automatisch inkrementierenden Spalte wird bei einem NULL-Wert der nächste verfügbare Wert verwendet. In diesem Fall wollen wir Daten in die Entwicklertabelle einfügen. Fügen wir Beispieldatensätze ein:
mysql>INSERT INTO developers VALUES(NULL, 'Joe Smith', 'joesmith@gentoo.org', 'toolchain');Query OK, 1 row affected (0.06 sec)
## (If you don't know the order of the columns in the table or want to insert an incomplete record)
mysql> INSERT INTO developers (job, name) VALUES('outsourced', 'Jane Doe');
Query OK, 1 row affected (0.01 sec)
Der Rückgabecode zeigt an, dass der Datensatz korrekt eingefügt worden ist. Was ist, wenn wir mehr Informationen eingeben möchten als nur einen Datensatz? Hier kommt der Befehl LOAD DATA ins Spiel. Dieser lädt Datensätze aus einer tabulatorgetrennten Datei. Versuchen wir das, indem wir eine Datei in unserem Home-Verzeichnis mit den Datensätzen bearbeiten. Wir nennen diese Datei records.txt. Hier ein Beispiel:
3 John Doe johndoe@gentoo.org portage
4 Chris White chriswhite@gentoo.org documentation
5 Sam Smith samsmith@gentoo.org amd64
Es ist wichtig die richtigen Daten zu verwenden, da mit fehlerhaften Daten in Verbindung mit
LOAD DATA unerwünschte Nebeneffekte auftreten können.Der Aufruf von LOAD DATA ist etwas umständlich, im folgenden Beispiel wird die einfachste Form verwendet.
LOAD DATA LOCAL INFILE '/pfad/zur/datei' INTO TABLE table;
/pfad/zur/Datei entspricht dem Verzeichnins und Dateiname der verwendet werden soll. table ist der Name der Tabelle. In diesem Beispiel ist ~/records.txt die Datei und developer ist die Tabelle.
mysql>LOAD DATA LOCAL INFILE '~/records.txt' INTO TABLE developers;Query OK, 3 rows affected (0.00 sec) Records: 3 Deleted: 0 Skipped: 0 Warnings: 0
Wenn Sie ein merkwürdiges Verhalten feststellen, vergewissern Sie sich, dass Ihre Felder durch Tabulatoren getrennt sind. Wenn Sie Informationen aus einer anderen Quelle in Ihre Datei einfügen, werden die Tabulatoren möglicherweise in Leerzeichen umgewandelt
Das hat gut funktioniert. Dies fügt jedoch einfach Datensätze ein und gibt Ihnen keinerlei Kontrolle über MySQL. Viele Webanwendungen verwenden SQL-Skripte, um MySQL schnell und einfach einzurichten. Wenn Sie ein SQL-Skript verwenden möchten, müssen Sie MySQL im Batch-Modus ausführen oder die Datei als Quelle verwenden. Hier ist ein Beispiel für die Ausführung von MySQL im Batch-Modus:
user $mysql -u root -h localhost -p < sqlfileWie bei LOAD DATA sollte man wissen was sqlfile tut. Anderenfalls kann Ihre Datenbank kompromittiert werden! Eine andere Möglichkeit, dies zu erreichen, ist die Verwendung des Befehls source . Dieser Befehl führt mysql-Befehle aus einer SQL-Datei im interaktiven Modus von mysql aus. So erhalten Sie eine SQL-Datei:
mysql>source sqlfile;Wenn Sie eine Webanwendung sehen, die eine SQL-Datei ausführen soll, können die beiden obigen Befehle zum Ausführen dieser Aufgabe verwendet werden. Wir haben unseren Tabellenaufbau, wollen wir also einaml unsere Felder überprüfen? Um unsere Tabelle zu durchsuchen benutzen wir Abfragen.
Durchsuchen von MySQL Tabellen mit Abfragen
Abfragen sind eines der Hauptmerkmale jeder SQL-Datenbank. Sie helfen uns, Daten in unseren Tabellen in etwas Nützliches zu verwandeln. Die meisten Abfragen werden mit dem Befehl SELECT ausgeführt. Der SELECT -Befehl ist ziemlich komplex, und wir werden nur drei Hauptformen des Befehls in diesem Dokument betrachten.
## (Select all entries in a table)
SELECT * FROM table;
## (Select specific entries in a table)
SELECT * FROM table WHERE field=value;
## (Select specific fields)
SELECT field1,field2,field3 FROM table [WHERE field=value];
Werfen wir einen Blick auf die erste Form. Es ist relativ einfach und gibt Ihnen ein Gesamtbild Ihrer Tabelle. Wir werden weitermachen, um zu sehen, welche Daten wir bisher haben.
mysql>SELECT * FROM developers;+----+-------------+-----------------------+----------------+ | id | name | email | job | +----+-------------+-----------------------+----------------+ | 1 | Joe Smith | joesmith@gentoo.org | toolchain | | 2 | Jane Doe | NULL | Outsourced job | | 3 | John Doe | johndoe@gentoo.org | portage | | 4 | Chris White | chriswhite@gentoo.org | documentation | | 5 | Sam Smith | samsmith@gentoo.org | amd64 | +----+-------------+-----------------------+----------------+ 5 rows in set (0.00 sec)
Wir sehen sowohl die Daten, die wir durch INSERT eingefügt haben, als auch diejenigen, die durch LOAD DATA eingefügt wurden. Sagen wir mal, wir wollen nur den Rekord für Chris White sehen. Wir können dies mit der zweiten Form von select tun, wie unten gezeigt.
mysql>SELECT * FROM developers WHERE name = 'Chris White';+----+-------------+-----------------------+---------------+ | id | name | email | job | +----+-------------+-----------------------+---------------+ | 3 | Chris White | chriswhite@gentoo.org | documentation | +----+-------------+-----------------------+---------------+ 1 row in set (0.08 sec)
Wie erwartet, wurde der von uns gesuchte Eintrag ausgewählt. Nehmen wir an, wir wollten nur den Job und die E-Mail-Adresse der Person kennen, nicht ihren Namen. Wir können dies mit der dritten Form von SELECT tun, wie hier gezeigt.
mysql>SELECT email,job FROM developers WHERE name = 'Chris White';+-----------------------+---------------+ | email | job | +-----------------------+---------------+ | chriswhite@gentoo.org | documentation | +-----------------------+---------------+ 1 row in set (0.04 sec)
Diese Art der Auswahl ist viel einfacher zu handhaben, vor allem bei größeren Datenmengen, wie wir später sehen werden. Im Moment haben wir als root-Benutzer unbegrenzte Rechte, um mit der MySQL-Datenbank zu tun, was wir wollen. In einer Serverumgebung kann ein Benutzer mit solchen Rechten ziemlich problematisch sein. Um zu kontrollieren, wer was mit den Datenbanken macht, richten wir Berechtigungen ein.
MySQL Berechtigungen
Privilegien sind die Art des Zugriffs, den Benutzer auf Datenbanken, Tabellen und so ziemlich alles haben. Im Moment ist in der gentoo-Datenbank der MySQL-Root-Account der einzige Account, der aufgrund seiner Rechte darauf zugreifen kann. Lassen Sie uns nun zwei etwas allgemeinere Benutzer erstellen, guest und admin, die auf die gentoo Datenbank zugreifen und mit den Informationen darin arbeiten können. Das Gastkonto wird ein eingeschränktes Konto sein. Alles, was er tun kann, ist, Informationen aus der Datenbank abzurufen, und das war's. admin hat die gleiche Kontrolle wie root, aber nur für die Gentoo-Datenbank (nicht für die Haupt-Mysql-Datenbanken).
Benutzer anlegen
Mit der SQL-Anweisung CREATE USER werden die Benutzer definiert und die Authentifizierungsmethode festgelegt, in der Regel durch ein Passwort, aber es können auch andere Plugins verfügbar sein.
Ein Beispiel für einen CREATE USER-Befehl lautet:
CREATE USER '[user]'@'[host]' IDENTIFIED BY '[password]';
user ist der Name des Benutzers und host ist der Hostname, von dem aus der Benutzer zugreifen wird. In den meisten Fällen wird dies localhost sein. Um unsere Benutzer für dieses Beispiel zu erstellen:
(admin)
mysql>CREATE USER 'admin'@'localhost' IDENTIFIED BY 'password';
(guest)
mysql>CREATE USER 'guest'@'localhost' IDENTIFIED BY 'password';
Ein Host von 'localhost' bedeutet für MySQL nicht DNS localhost (127.0.0.1). Stattdessen bezieht er sich auf die UNIX-Socket-Verbindung und nicht auf TCP/IP.
Gewähren von Berechtigungen mit GRANT
Schauen wir uns dieses etwas vereinfachte Format des GRANT-Befehls genauer an.
GRANT [privileges] ON database.* TO '[user]'@'[host]';
Mit dem was wir bisher gelernt haben, kennen wir schon einige Berechtigungen die wir vergeben können:
ALL- Gibt alle Berechtigungen für die DatenbankCREATE- Erlaubt es Usern Tabellen zu erstellenSELECT- Erlaubt es Usern Abfragen an Tabellen zu richtenINSERT- Erlaubt es Usern Daten in eine Tabelle einzufügenSHOW DATABASES- Erlaubt es Usern die Datenbasen aufzulistenUSAGE- Der Benutzer hat keine BerechtigungenGRANT OPTION- Erlaubt es Usern Rechte zu vergeben
Wenn Sie MySQL einsetzen, um Daten an eine Webanwendung zu übermitteln, sind
CREATE, SELECT, INSERT (hier besprochen), DELETE und UPDATE (weitere Informationen finden Sie im Abschnitt MySQL Reference Manual - GRANT and REVOKE Syntax) die einzigen Berechtigungen, die Sie höchstwahrscheinlich benötigen. Viele Leute machen den Fehler, alle Berechtigungen zu erteilen, obwohl dies nicht wirklich notwendig ist. Erkundigen Sie sich bei den Anwendungsentwicklern, ob solche Berechtigungen Probleme beim allgemeinen Betrieb verursachen.Für unseren Admin-Benutzer reicht ALL aus. Für den Gastbenutzer reicht SELECT für reinen Lesezugriff aus. database ist die Datenbank, auf die der Benutzer diese Berechtigungen haben soll. In diesem Beispiel ist gentoo die Datenbank. Das .* bedeutet alle Tabellen. Wenn Sie möchten, können Sie den Zugriff auf jede einzelne Tabelle anwenden.
mysql>GRANT ALL ON gentoo.* TO 'admin'@'localhost';mysql>GRANT SELECT ON gentoo.* TO 'guest'@'localhost';Nachdem wir die Benutzer eingerichtet haben, testen wir sie. Zuerst beenden wir mysql durch Eingabe von quit an der Eingabeaufforderung:
mysql>quitWir haben die Benutzer eingerichtet und sind zurück an der Konsole. Lassen Sie uns als diese Benutzer fortfahren.
Testen der Benutzer Zugriffsrechte
Wir werden uns nun als Gastbenutzer anmelden. Dieser kann nur die Berechtigung für SELECT , das bedeutet, dass nur Sucanfragen möglich sind. Melden Sie sihc mit dem Gastzugang an.
user $mysql -u guest -h localhost -pEnter password: Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 6 to server version: 4.0.25 Type 'help;' or '\h' for help. Type '\c' to clear the buffer. mysql>
Jetzt sollten wir die Benutzerbeschränkung(en) testen. Wechseln wir zur gentoo-Datenbank:
mysql>USE gentoo;Reading table information for completion of table and column names You can turn off this feature to get a quicker startup with -A Database changed
Zur Probe werden wir nun etwas tun, wofür wir keine Rechte haben. Wir werden versuchen, eine Tabelle zu erstellen.
mysql>CREATE TABLE test (test VARCHAR(20), foobar VARCHAR(2));ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'
Wie Sie sehen können, schlägt diese Funktion fehl, da unser Benutzer nicht über den entsprechenden Zugriff verfügt. Eine Berechtigung, die wir jedoch gewährt haben, ist die Anweisung SELECT . Lassen Sie es uns damit versuchen:
mysql>SELECT * FROM developers;+-------------+-----------------------+----------------+ | name | email | job | +-------------+-----------------------+----------------+ | 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 rows in set (0.00 sec)
Der Befehl ist erfolgreich und wir erhalten einen Einblick in die Möglichkeiten der Benutzerberechtigungen. Wir haben jedoch auch einen Administrator-Account erstellt. Dieser wurde erstellt, um zu zeigen, dass sogar alle Berechtigungen, die Benutzern gewährt werden, immer noch Einschränkungen haben können. Wir werden nun MySQL beenden und uns neu als Administrator einloggen.
mysql>quitBye
user $mysql -u admin -h localhost -pEnter password: Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 7 to server version: 4.0.25 Type 'help;' or '\h' for help. Type '\c' to clear the buffer. mysql>
Zu Beginn werden wir versuchen, eine neue Datenbank mit unserem Admin-Benutzer zu erstellen. Dieser Admin-Benutzer hat Zugriff auf das root-MySQL-Konto und kann jede Art von Änderung an der ausgewählten gentoo-Datenbank vornehmen. Dadurch wird der Zugriff des Benutzers auf die Hauptdatenbank von MySQL getestet. Denken Sie daran, dass wir nur Berechtigungen für eine bestimmte Datenbank festlegen.
mysql>CREATE DATABASE gentoo2;ERROR 1044: Access denied for user: 'admin@localhost' to database 'gentoo2'
Tatsächlich kann der Admin-Benutzer trotz aller Berechtigungen für die Gentoo-Datenbank keine Datenbanken in der MySQL-Hauptdatenbank erstellen. Wir können jedoch weiterhin das Admin-Konto verwenden, um die Gentoo-Datenbank zu ändern, wie hier anhand dieses Beispieldateneintrags gezeigt.
mysql>USE gentoo;Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A
Database changed
mysql> INSERT INTO developers VALUES('Bob Simmons', 'bobsimmons@gentoo.org', 'python');
Query OK, 1 row affected (0.08 sec)
Der Admin-Benutzer kann nach Belieben auf die Datenbank zugreifen. Jetzt müssen wir manchmal Benutzerrechte einschränken. Die Gründe hierfür können vielfältig sein, von einem problematischen Benutzer bis zu einem pensionierten Mitarbeiter. Werfen wir einen Blick darauf, wie Benutzerberechtigungen mit dem Befehl REVOKE widerrufen werden.
Entfernen von Benutzerrechten mittels REVOKE Befehl
Mit dem Befehl REVOKE können wir den Zugriff für einen Benutzer verweigern. Wir können entweder den vollen Zugang oder den spezifischen Zugang verweigern. In der Tat ähnelt das Format GRANT .
REVOKE [privileges] ON database.* FROM '[user]'@'[host]';
Im Abschnitt zum Befehl GRANT werden die Optionen erklärt. In diesem Abschnitt verweigern wir jedoch den vollen Zugriff auf einen Benutzer. Nehmen wir an, wir finden heraus, dass der Gastaccount einige Sicherheitsprobleme verursacht. Wir beschließen, alle Privilegien zu widerrufen. Wir loggen uns als root ein und führen die notwendigen Änderungen durch.
mysql>REVOKE ALL ON gentoo.* FROM 'guest'@'localhost';Query OK, 0 rows affected (0.00 sec)
In diesem Fall ist der Benutzerzugriff einfach, so dass das Widerrufen pro Datenbank kein Problem darstellt. In größeren Anwendungen würden Sie jedoch wahrscheinlich '*. *' . Anstelle von 'gentoo.*' verwenden, um den Benutzerzugriff auf alle anderen Datenbanken zu entfernen.
Wir loggen uns wieder aus und melden uns als Gastbenutzer an.
user $mysql -u guest -h localhost -pEnter password: Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 9 to server version: 4.0.25 Type 'help;' or '\h' for help. Type '\c' to clear the buffer. mysql>
Obwohl wir uns einloggen können, ist unser Zugang zu Gentoo jetzt nicht mehr möglich.
mysql>USE gentoo;ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'
Und unser problematischer Benutzer ist nicht mehr in der Lage, auf die Gentoo-Datenbank zuzugreifen. Bitte beachten Sie, dass sich der Benutzer noch anmelden konnte. Das liegt daran, dass er in der Haupt-MySQL-Datenbank verbleibt. Schauen wir uns nun an, wie man ein Konto mit <code<DROP USER vollständig entfernen kann.
Entfernen von Accounts
Vergewissern Sie sich, dass Sie als root eingeloggt sind.
DROP USER löscht den Datensatz in der Benutzertabelle und alle Berechtigungstabellen. Lassen Sie uns fortfahren und das tun:
mysql>DROP USER 'guest'@'localhost';Query OK, 1 row affected (0.07 sec)
Es scheint gut funktioniert zu haben. Testen wir, indem wir uns abmelden und versuchen, uns als Gastbenutzer anzumelden.
mysql>quitBye
user $mysql -u guest -h localhost -pEnter password: ERROR 1045: Access denied for user: 'guest@localhost' (Using password: YES)
Der Benutzer wurde erfolgreich gelöscht.
Fazit
Während sich dieses Handbuch hauptsächlich auf das Einrichten von MySQL auf der Befehlszeile konzentriert, sind einige Alternativen mit einer graphischen Benutzeroberfläche verfügbar:
- phpMyAdmin - Populäres PHP-basiertes MySQL Administrationswerkzeug.
Hier endet unser MySQL Einführungsleitfaden. Ich hoffe Sie haben nun ein besseres Verständnis der grundlegenden Funktionen von MySQL und dem Einrichten dieser Datenbank.
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.