MySQL/Einstiegsleitfaden

From Gentoo Wiki
< MySQL
Jump to: navigation, search
This page is a translated version of the page MySQL/Startup Guide and the translation is 100% complete.

Other languages:
Deutsch • ‎English • ‎Türkçe • ‎français • ‎русский • ‎中文(中国大陆)‎ • ‎日本語 • ‎한국어

Dieses Dokument hilft die MySQL Datenbank einzurichten und zu benutzen.

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

Zuerst ist das Programmpaket MySQL auf dem Rechner zu installieren. Für spezielle Features sind die entsprechenden USE-Flags zu setzen.

root #emerge --ask mysql

Am Ende der Installation wird folgende Nachricht angezeigt:

CODE MySQL einfo message
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. Wir werden das definitiv tun, sonst könnte jemand zufällig kommen und unseren Standard-Setup MySQL Server hacken.

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

Wichtig
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 #/etc/init.d/mysql start
 * Re-caching dependency info (mtimes differ)...
 * Starting mysqld (/etc/mysql/my.cnf) ...        [ ok ]

Bei der Benutzung von systemd kommt das folgende Kommando zur Anwendung:

root #systemctl restart mysqld.service

With >=dev-db/mariadb-10.1.18, use:

root #systemctl restart mariadb.service

Danach 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 -p
Enter 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.

Wichtig
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)
Wichtig
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:

CODE CREATE TABLE Syntax
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. Wir haben in diesem Fall 3 erforderliche Namen: Name, E-Mail und Job.

Der field_data_type legt fest, welche Art von Information in dem entsprechenden Feld gespeichert werden soll. Die verschiedenen verfügbaren Formate finden Sie in der MySQL-Dokumentation. Für unsere Zwecke verwenden wir den Datentyp VARCHAR für alle unsere Felder. VARCHAR ist einer der einfachsten Datentypen, wenn es um die Arbeit mit Strings 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 ( 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 |
+-------+--------------+------+-----+---------+-------+
| 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. Es zeigt auch ein paar zusätzliche Attribute, die den Rahmen dieses Howto sprengen. Weitere Informationen finden Sie im MySQL Referenzhandbuch. Wir haben jetzt eine Tabelle, mit der wir arbeiten können. Lass uns im nächsten Schritt die Tabelle mit Daten füllen.

Füllen unserer MySQL Datenbank

Wir fügen Daten mittels INSERT Befehl ein. Ähnlich wie CREATE TABLE, hat er ein spezifisches Format.

CODE INSERT Syntax
INSERT INTO table (col1, col2, ...) VALUES('value1', 'value2', ...);

Dieser Befehl wird verwendet, um einen Datensatz in table einzufügen. Nach dem Tabellennamen kann die Aufzählung der Spalten folgen, in die Daten eingefügt werden sollen. Auf VALUES () folgen die Werte, die Sie in die Tabelle einfügen möchten. Sie können die Liste der Spalten weglassen, wenn Sie genau einen Wert für jede Spalte angeben, und wenn Sie die Werte in der gleichen Reihenfolge wie die Spalten aufführen. In diesem Fall möchten wir Daten in die Entwicklertabelle einfügen. Lassen Sie uns Beispieldatensätze einfügen:

mysql>INSERT INTO developers VALUES('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:

CODE ~/records.txt
John Doe	johndoe@gentoo.org	portage
Chris White	chriswhite@gentoo.org	documentation
Sam Smith	samsmith@gentoo.org	amd64
Wichtig
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.

CODE LOAD DATA Syntax
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
Wichtig
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 < sqlfile

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

Abfragen zum Durchsuchen von MySQL Tabellen

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.

CODE SELECT forms
## (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;
+-------------+-----------------------+----------------+
| 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)

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';
+-------------+-----------------------+---------------+
| name        | email                 | job           |
+-------------+-----------------------+---------------+
| 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 Methode der Auswahl ist viel einfacher zu verwalten, insbesondere mit größeren Mengen an Informationen, wie wir später sehen werden. Im Moment haben wir als mysql root-Benutzer unbegrenzte Rechte, um mit der MySQL-Datenbank das zu tun, was wir wollen. In einer Serverumgebung kann ein Benutzer mit solchen Berechtigungen ziemlich problematisch sein. Um zu kontrollieren, wer was mit den Datenbanken macht, richten wir Privilegien ein.

MySQL Berechtigungen

Privilegien erlauben welche Art von Zugriff Benutzer auf Datenbanken, Tabellen, etc haben. In der gentoo-Datenbank ist das MySQL root-Konto das einzige Konto, das aufgrund seiner Berechtigungen darauf zugreifen kann. Lassen Sie uns nun zwei etwas generische Benutzer, guest und admin, erstellen, die auf die gentoo-Datenbank zugreifen und mit den darin enthaltenen Informationen arbeiten. Das Gastkonto wird eingeschränkt. Alles, was man mit diesem konto machen kann, ist Informationen aus der Datenbank zu lesen. admin hat die selbe Kontrolle wie root, aber nur für die gentoo-Datenbank (nicht die Haupt-mysql-Datenbanken). Bevor wir damit beginnen, wollen wir uns das etwas vereinfachte Format des Befehls GRANT genauer ansehen.

Creating Users

The CREATE USER SQL statement will define users and set the authentication method, commonly by password but other plugins may be available.

An example CREATE USER command is:

CODE CREATE USER Syntax
CREATE USER '[user]'@'[host]' IDENTIFIED BY '[password]';

user is the name of the user and host is the hostname the user will be accessing from. In most cases, this will be localhost. To create our users for this example:

(admin)

mysql>CREATE USER 'admin'@'localhost' IDENTIFIED BY 'password';

(guest)

mysql>CREATE USER 'guest'@'localhost' IDENTIFIED BY 'password';
Wichtig
A host of 'localhost' does not mean DNS localhost (127.0.0.1) to MySQL. Instead, it refers to the UNIX socket connection and not TCP/IP.

Gewähren von Berechtigungen with GRANT

Let's have a closer look at this somewhat simplified format of the GRANT command.

CODE GRANT Syntax
GRANT [privileges] ON database.* TO '[user]'@'[host]' IDENTIFIED BY '[password]';

Mit dem was wir bisher gelernt haben, kennen wir schon einige Berechtigungen die wir vergeben können:

  • ALL - Gibt alle Berechtigungen für die Datenbank
  • CREATE - Erlaubt es Usern Tabellen zu erstellen
  • SELECT - Erlaubt es Usern Abfragen an Tabellen zu richten
  • INSERT - Erlaubt es Usern Daten in eine Tabelle einzufügen
  • SHOW DATABASES - Erlaubt es Usern die Datenbasen aufzulisten
  • USAGE - Der Benutzer hat keine Berechtigungen
  • GRANT OPTION - Erlaubt es Usern Rechte zu vergeben
Notiz

Benutzen Sie MySQL für das Verarbeiten von Daten aus einer Webanwendung, werden Sie hauptsächlich folgende Befehle benötigen: CREATE , SELECT , INSERT (hier besprochen), sowie DELETE und UPDATE erläutert in MySQL Referenzhandbuch - GRANT und REVOKE Syntax.

Viele Leute machen den Fehler, alle Berechtigungen zu erteilen, wenn es nicht wirklich notwendig ist. Erkundigen Sie sich bei den Anwendungsentwicklern, ob solche Berechtigungen Probleme mit dem allgemeinen Betrieb verursachen.

Der Benutzer 'admin' aus unserem Beispiel sollte alle Berechtigungen ALL erhalten. Der Benutzer 'guest' erhält nur einen schreibgeschützten Zugriff, definiert durch SELECT . 'gentoo' ist die Datenbank, für welche die Benutzer diese Berechtigungen erhalten sollen. Das * steht als Paltzhalter für alle Tabellen. Wenn Sie möchten, können Sie den Zugriff pro Tabelle zuteilen. 'user' ist der Name des Benutzers und 'host' ist der Hostname, auf den der Benutzer zugreift. In den meisten Fällen ist dies localhost. Schließlich ist 'password' das Passwort des Benutzers. Jetzt haben wir alle Informationen zusammen um die Benutzer zu erstellen.

mysql>GRANT ALL ON gentoo.* TO 'admin'@'localhost' IDENTIFIED BY 'password';
mysql>GRANT SELECT ON gentoo.* TO 'guest'@'localhost' IDENTIFIED BY 'password';

Nachdem wir die Benutzer eingerichtet haben, testen wir sie. Zuerst beenden wir mysql durch Eingabe von quit an der Eingabeaufforderung:

mysql>quit

Wir 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 -p
Enter 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>quit
Bye
user $mysql -u admin -h localhost -p
Enter 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 .

CODE REVOKE Syntax
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)
Notiz
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 -p
Enter 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 kann nicht mehr auf die Gentoo-Datenbank zugreifen. Bitte beachten Sie, dass sich der Benutzer noch anmelden konnte. Das liegt daran, dass sie in der Hauptdatenbank von MySQL bleiben. Werfen wir einen Blick darauf, wie man ein Konto mit DELETE und der MySQL-Benutzertabelle komplett entfernt.

Entfernen von Accounts mit DELETE

Die MySQL-Benutzertabelle ist eine Auflistung aller Benutzer und Informationen über sie. Stellen Sie sicher, dass Sie als root angemeldet sind und die MySQL-Hauptdatenbank verwenden.

DROP USER will delete the record in the user table and all privilege tables. Let's go ahead and do that:

mysql>DELETE FROM user WHERE User='guest';
Query OK, 1 row affected (0.07 sec)

Der Rechteentzug scheint funktioniert zu haben. Lassen Sie uns nun ausloggen und als Gastbenutzer einloggen.

mysql>quit
Bye
user $mysql -u guest -h localhost -p
Enter 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:

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.