it-swarm.com.de

So exportieren und importieren Sie vorhandene Benutzer (mit ihren Privilegien!)

Ich habe eine MySQL-Instanz (Test), die 2 Datenbanken und einige Benutzer mit jeweils unterschiedlichen Zugriffsrechten für jede Datenbank enthält.

Ich muss jetzt eine der Datenbanken (in die Produktion) und die damit verbundenen Benutzer duplizieren.

Das Duplizieren der Datenbank war easy :

Export:

mysqldump --no-data --tables -u root -p secondb >> secondb_schema.sql

Einführen:

mysql -u root -p -h localhost secondb < secondb_schema.sql

Ich habe jedoch keine einfache Möglichkeit gefunden, users von der Befehlszeile (entweder innerhalb oder außerhalb von mysql) zu exportieren und zu importieren.

Wie exportiere und importiere ich ein user von der Kommandozeile aus?


Update: Bisher habe ich manuelle (und damit fehleranfällige) Schritte gefunden, um dies zu erreichen:

-- lists all users
select user,Host from mysql.user;

Dann finden Sie die Zuschüsse:

-- find privilege granted to a particular user
show grants for 'root'@'localhost'; 

Dann erstellen Sie mit manuell einen Benutzer mit den Berechtigungen, die im Ergebnis des Befehls 'show Grant' oben aufgeführt sind. 

Ich bevorzuge einen sichereren, automatisierten Weg. Ist dort eines?

30
Withheld

Eine der einfachsten Methoden, die ich für den Export von Benutzern gefunden habe, ist die Verwendung von Perconas Werkzeug pt-show-grant. Das Percona-Toolkit ist kostenlos, einfach zu installieren und einfach zu verwenden. Es enthält viele Dokumentationen .. _. Es ist eine einfache Möglichkeit, alle Benutzer oder bestimmte Benutzer anzuzeigen. Es listet alle Zuweisungen und Ausgaben im SQL-Format auf. Ich gebe ein Beispiel, wie ich alle Berechtigungen für test_user anzeigen würde:

Shell> pt-show-grants --only test_user

Beispielausgabe dieses Befehls:

GRANT USAGE ON *.* TO 'test_user'@'%' IDENTIFIED BY PASSWORD '*06406C868B12689643D7E55E8EB2FE82B4A6F5F4';
GRANT ALTER, INSERT, LOCK TABLES, SELECT, UPDATE ON `test`.* TO 'test_user'@'%';

Normalerweise redere ich die Ausgabe in eine Datei um, damit ich bearbeiten kann, was ich brauche, oder es in mysql laden.

Wenn Sie alternativ das Percona-Tool nicht verwenden möchten und einen Speicherauszug aller Benutzer erstellen möchten, können Sie mysqldump folgendermaßen verwenden:

Shell> mysqldump mysql --tables user db > users.sql

Hinweis: --flush-privileges funktionieren damit nicht, da nicht die gesamte Datenbank abgelegt wird. Dies bedeutet, dass Sie es manuell ausführen müssen.

Shell> mysql -e "FLUSH PRIVILEGES"
29
Matthew Carey
mysql -u<user> -p<password> -h<Host> -e"select concat('show grants for ','\'',user,'\'@\'',Host,'\'') from mysql.user" > user_list_with_header.txt
sed '1d' user_list_with_header.txt > ./user.txt
while read user; do  mysql u<user> -p<password> -h<Host> -e"$user" > user_grant.txt; sed '1d' user_grant.txt >> user_privileges.txt; echo "flush privileges" >> user_privileges.txt; done < user.txt
awk '{print $0";"}'  user_privileges.txt >user_privileges_final.sql
rm user.txt user_list_with_header.txt user_grant.txt user_privileges.txt

Das obige Skript wird in einer Linux-Umgebung ausgeführt und die Ausgabe wird user_privileges_final.sql sein, die Sie in einen neuen MySQL-Server importieren können, auf den Sie die Benutzerrechte kopieren möchten.

18
Vardan Gupta

Noch ein weiterer Einzeiler für Linux, der anstelle von Percona verwendet werden soll

mysql -u<user> -p<password> -h<Host> -N mysql -e "select concat(\"'\", user, \"'@'\", Host, \"'\"), authentication_string from user where not user like 'mysql.%'" | while read usr pw ; do echo "GRANT USAGE ON *.* TO $usr IDENTIFIED BY PASSWORD '$pw';" ; mysql -u<user> -p<password> -h<Host> -N -e "SHOW GRANTS FOR $usr" | grep -v 'GRANT USAGE' | sed 's/\(\S\)$/\1;/' ; done
1

Ein PHP -Skript, das Ihre Benutzer durchläuft, um die Grant-Befehle zu erhalten, wäre so:

// Set up database root credentials
$Host = 'localhost';
$user = 'root';
$pass = 'YOUR PASSWORD';
// ---- Do not edit below this ----
// Misc settings
header('Content-type: text/plain; Charset=UTF-8');
// Final import queries goes here
$export = array();
// Connect to database
try {
    $link = new PDO("mysql:Host=$Host;dbname=mysql", $user, $pass);
} catch (PDOException $e) {
    printf('Connect failed: %s', $e->getMessage());
    die();
}

// Get users from database
$statement = $link->prepare("select `user`, `Host`, `password` FROM `user`");
$statement->execute();
while ($row = $statement->fetch())
{
    $user   = $row[0];
    $Host   = $row[1];
    $pass   = $row[2];
    $export[] = 'CREATE USER \''. $user .'\'@\''. $Host .'\' IDENTIFIED BY \''. $pass .'\'';
    // Fetch any permissions found in database
    $statement2 = $link->prepare('SHOW GRANTS FOR \''. $user .'\'@\''. $Host .'\'');
    $statement2->execute();
    if ($row2 = $statement2->fetch())
    {
        $export[] = $row2[0];
    }
}

$link = null;
echo implode(";\n", $export);

Gist: https://Gist.github.com/zaiddabaeen/e88a2d10528e31cd6692

0
zed

PhpMyAdmin Sie können phpMyAdmin verwenden.

Melden Sie sich an und gehen Sie zu Ihrer Datenbank oder einer Tabelle, auf die der Benutzer Zugriff hat.

Wählen Sie Privilegien aus

Alle Benutzer mit Zugriff sind da.

Wählen Sie Export. Und ein kleines Fenster mit allen GRANTS steht zum Kopieren und Einfügen bereit.

0
Mysql MariaDB

Ich hatte das gleiche Problem. Die Lösung besteht darin, dass Sie nach dem Import des Backups "Flush-Privilegien" durchführen müssen. Dann sind die Berechtigungen der Benutzer wie in der Originaldatenbank aktiv.

SO 

mysql -u root -p -h localhost secondb <secondb_schema.sql

mysql -u root; dann in MySQL: "Flush Privilegien;"

0

In Ergänzung zu @ Sergey-Podushkins Antwort funktioniert dieser Shell-Skriptcode für mich:

mysql -u<user> -p<password> -N mysql -e "select concat(\"'\", user, \"'@'\", Host, \"'\"), authentication_string from user where not user like 'root'" | while read usr pw ; do mysql -u<user> -p<password> -N -e "SHOW GRANTS FOR $usr" | sed 's/\(\S\)$/\1;/'; done 
0
shgnInc

Folgendes verwende ich derzeit als Teil meiner täglichen Sicherungsskripts (erfordert Root-Shell- und MySQL-Zugriff, Linux-Shell und verwendet das in mysql integrierte Schema:

Zuerst erstelle ich eine Datei /var/backup/mysqlroot.cnf mit dem Root-Passwort, damit ich meine Skripte automatisieren und keine Passwörter darin fest codieren kann:

[client]
password=(put your password here)

Dann erstelle ich ein Exportskript, mit dem Dumps Benutzerbefehle erstellen und wie folgt gewähren:

touch /var/backup/backup_sql.sh
chmod 700 /var/backup/backup_sql.sh
vi /var/backup/backup_sql.sh

Und dann schreibe den folgenden Inhalt:

#!/bin/bash

mysql --defaults-extra-file=/var/backup/mysqlroot.cnf -sNe " \
  SELECT \
    CONCAT( 'CREATE USER \'', User, '\'@\'', Host, '\' IDENTIFIED BY ', authentication_string, '\;' ) AS User \
  FROM mysql.user \
  WHERE \
    User NOT LIKE 'mysql.%' AND CONCAT( User, Host ) <> 'rootlocalhost' AND User <> 'debian-sys-maint' \
"

mysql --defaults-extra-file=/var/backup/mysqlroot.cnf -sNe " \
  SELECT \
    CONCAT( '\'', User, '\'@\'', Host, '\'' ) as User FROM mysql.user \
  WHERE \
    User NOT LIKE 'mysql.%' \
    AND CONCAT( User, Host ) <> 'rootlocalhost' \
    AND User <> 'debian-sys-maint' \
" | sort | while read u ; 
 do echo "-- $u"; mysql --defaults-extra-file=/var/backup/mysqlroot.cnf -sNe "show grants for $u" | sed 's/$/;/'
done

Dann muss ich es einfach so ausführen: /var/backup/backup_sql.sh> /tmp/exportusers.sql

0
RedScourge

Ich habe das mit einem kleinen C # -Programm angegangen. Hier gibt es Code, um ein Skript zu generieren oder die Zuweisungen direkt von der Quelle bis zum Ziel anzuwenden. Bei der Portierung aus einer Windows -> * nix-Umgebung müssen Sie möglicherweise die Groß- und Kleinschreibung berücksichtigen. 

using System;
using MySql.Data.MySqlClient;
using System.Configuration;
using System.IO;
using System.Collections.Generic;

namespace GenerateUsersScript
{
    class Program
    {
        static void Main(string[] args)
        {
            List<string> grantsQueries = new List<string>();

            // Get A Show Grants query for each user
            using (MySqlConnection sourceConn = OpenConnection("sourceDatabase"))
            {
                using (MySqlDataReader usersReader = GetUsersReader(sourceConn))
                {
                    while (usersReader.Read())
                    {
                        grantsQueries.Add(String.Format("SHOW GRANTS FOR '{0}'@'{1}'", usersReader[0], usersReader[1]));
                    }
                }

                Console.WriteLine("Exporting Grants For {0} Users", grantsQueries.Count);

                using (StreamWriter writer = File.CreateText(@".\UserPermissions.Sql"))
                {
                    // Then Execute each in turn 
                    foreach (string grantsSql in grantsQueries)
                    {
                        WritePermissionsScript(sourceConn, grantsSql, writer);
                    }

                    //using (MySqlConnection destConn = OpenConnection("targetDatabase"))
                    //{
                    //    MySqlCommand command = destConn.CreateCommand();

                    //    foreach (string grantsSql in grantsQueries)
                    //    {
                    //        WritePermissionsDirect(sourceConn, grantsSql, command);
                    //    }
                    //}
                }
            }

            Console.WriteLine("Done - Press A Key to Continue");

            Console.ReadKey();
        }

        private static void WritePermissionsDirect(MySqlConnection sourceConn, string grantsSql, MySqlCommand writeCommand)
        {
            MySqlCommand cmd = new MySqlCommand(grantsSql, sourceConn);

            using (MySqlDataReader grantsReader = cmd.ExecuteReader())
            {
                while (grantsReader.Read())
                {
                    try
                    {
                        writeCommand.CommandText = grantsReader[0].ToString(); 

                        writeCommand.ExecuteNonQuery();
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(grantsReader[0].ToString());

                        Console.WriteLine(ex.Message);
                    }
                }
            } 
        }

        private static void WritePermissionsScript(MySqlConnection conn, string grantsSql, StreamWriter writer)
        {
            MySqlCommand command = new MySqlCommand(grantsSql, conn);

            using (MySqlDataReader grantsReader = command.ExecuteReader())
            {
                while (grantsReader.Read())
                {
                    writer.WriteLine(grantsReader[0] + ";");
                }
            }

            writer.WriteLine();
        }

        private static MySqlDataReader GetUsersReader(MySqlConnection conn)
        {
            string queryString = String.Format("SELECT User, Host FROM USER");
            MySqlCommand command = new MySqlCommand(queryString, conn);
            MySqlDataReader reader = command.ExecuteReader();
            return reader;
        }

        private static MySqlConnection OpenConnection(string connName)
        {
            string connectionString = ConfigurationManager.ConnectionStrings[connName].ConnectionString;
            MySqlConnection connection = new MySqlConnection(connectionString);
            connection.Open();
            return connection; 

        }
    }
}

mit einer app.config mit ...

    <connectionStrings>
        <add name="sourceDatabase" connectionString="server=localhost;user id=hugh;password=xxxxxxxx;persistsecurityinfo=True;database=MySql" />
        <add name="targetDatabase" connectionString="server=queeg;user id=hugh;password=xxxxxxxx;persistsecurityinfo=True;database=MySql" />
    </connectionStrings> 
0
Hugh Jones