Recibí este tutorial de Internet. Pero ni siquiera tengo un conocimiento básico sobre cómo funcionaría la copia de seguridad de una base de datos MySQL a través de PHP.¿Cómo hacer una copia de seguridad de la base de datos MySQL en PHP?
Using PHP to Backup MySQL Databases
puede recomendar algunos sitios que puedo usar como referencia para que pueda estudiarlo?
Si bien puede ejecutar comandos de copia de seguridad desde PHP, en realidad no tienen nada que ver con PHP. Se trata de MySQL.
Sugeriría utilizar la utilidad mysqldump para hacer una copia de seguridad de su base de datos. La documentación se puede encontrar aquí: http://dev.mysql.com/doc/refman/5.1/en/mysqldump.html.
El uso básico de mysqldump es
mysqldump -u user_name -p name-of-database >file_to_write_to.sql
A continuación, puede restaurar la copia de seguridad con un comando como
mysql -u user_name -p <file_to_read_from.sql
¿Tiene acceso a cron? Sugeriría hacer un script PHP que ejecute mysqldump como un trabajo cron. Eso sería algo así como
<?php
$filename='database_backup_'.date('G_a_m_d_y').'.sql';
$result=exec('mysqldump database_name --password=your_pass --user=root --single-transaction >/var/backups/'.$filename,$output);
if($output==''){/* no output is good */}
else {/* we have something to log the output here*/}
Si mysqldump no está disponible, el artículo describe otro método, utilizando los comandos SELECT INTO OUTFILE y LOAD DATA INFILE. La única conexión con PHP es que estás usando PHP para conectarte a la base de datos y ejecutar los comandos SQL. También puede hacer esto desde la línea de comando del programa MySQL, el monitor MySQL.
Es bastante simple, está escribiendo un archivo SQL con un comando, y lo carga/ejecuta cuando es hora de restaurarlo.
Puede encontrar los documentos para seleccionar en el archivo de salida here (solo busque en la página de archivo de salida). LOAD DATA INFILE es esencialmente el reverso de esto. Ver here para los documentos.
Aquí es una clase PHP puro para realizar copias de seguridad de bases de datos MySQL que no utilizan los comandos mysqldump o MySQL: Backing up MySQL databases with pure PHP
Si desea copia de seguridad de una base de datos de script php se puede utilizar una clase, por ejemplo, llamémosle MySQL. Esta clase usará PDO (build en la clase php que manejará la conexión a la base de datos). Esta clase podría tener este aspecto:
<?php /*defined in your exampleconfig.php*/
define('DBUSER','root');
define('DBPASS','');
define('SERVERHOST','localhost');
?>
<?php /*defined in examplemyclass.php*/
class MySql{
private $dbc;
private $user;
private $pass;
private $dbname;
private $host;
function __construct($host="localhost", $dbname="your_databse_name_here", $user="your_username", $pass="your_password"){
$this->user = $user;
$this->pass = $pass;
$this->dbname = $dbname;
$this->host = $host;
$opt = array(
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
);
try{
$this->dbc = new PDO('mysql:host='.$this->host.';dbname='.$this->dbname.';charset=utf8', $user, $pass, $opt);
}
catch(PDOException $e){
echo $e->getMessage();
echo "There was a problem with connection to db check credenctials";
}
} /*end function*/
public function backup_tables($tables = '*'){ /* backup the db OR just a table */
$host=$this->host;
$user=$this->user;
$pass=$this->pass;
$dbname=$this->dbname;
$data = "";
//get all of the tables
if($tables == '*')
{
$tables = array();
$result = $this->dbc->prepare('SHOW TABLES');
$result->execute();
while($row = $result->fetch(PDO::FETCH_NUM))
{
$tables[] = $row[0];
}
}
else
{
$tables = is_array($tables) ? $tables : explode(',',$tables);
}
//cycle through
foreach($tables as $table)
{
$resultcount = $this->dbc->prepare('SELECT count(*) FROM '.$table);
$resultcount->execute();
$num_fields = $resultcount->fetch(PDO::FETCH_NUM);
$num_fields = $num_fields[0];
$result = $this->dbc->prepare('SELECT * FROM '.$table);
$result->execute();
$data.= 'DROP TABLE '.$table.';';
$result2 = $this->dbc->prepare('SHOW CREATE TABLE '.$table);
$result2->execute();
$row2 = $result2->fetch(PDO::FETCH_NUM);
$data.= "\n\n".$row2[1].";\n\n";
for ($i = 0; $i < $num_fields; $i++)
{
while($row = $result->fetch(PDO::FETCH_NUM))
{
$data.= 'INSERT INTO '.$table.' VALUES(';
for($j=0; $j<$num_fields; $j++)
{
$row[$j] = addslashes($row[$j]);
$row[$j] = str_replace("\n","\\n",$row[$j]);
if (isset($row[$j])) { $data.= '"'.$row[$j].'"' ; } else { $data.= '""'; }
if ($j<($num_fields-1)) { $data.= ','; }
}
$data.= ");\n";
}
}
$data.="\n\n\n";
}
//save filename
$filename = 'db-backup-'.time().'-'.(implode(",",$tables)).'.sql';
$this->writeUTF8filename($filename,$data);
/*USE EXAMPLE
$connection = new MySql(SERVERHOST,"your_db_name",DBUSER, DBPASS);
$connection->backup_tables(); //OR backup_tables("posts");
$connection->closeConnection();
*/
} /*end function*/
private function writeUTF8filename($filenamename,$content){ /* save as utf8 encoding */
$f=fopen($filenamename,"w+");
# Now UTF-8 - Add byte order mark
fwrite($f, pack("CCC",0xef,0xbb,0xbf));
fwrite($f,$content);
fclose($f);
/*USE EXAMPLE this is only used by public function above...
$this->writeUTF8filename($filename,$data);
*/
} /*end function*/
public function recoverDB($file_to_load){
echo "write some code to load and proccedd .sql file in here ...";
/*USE EXAMPLE this is only used by public function above...
recoverDB("some_buck_up_file.sql");
*/
} /*end function*/
public function closeConnection(){
$this->dbc = null;
//EXAMPLE OF USE
/*$connection->closeConnection();*/
}/*end function*/
} /*END OF CLASS*/
?>
Ahora usted puede simplemente utilizar esto en su backup.php:
include ('config.php');
include ('myclass.php');
$connection = new MySql(SERVERHOST,"your_databse_name_here",DBUSER, DBPASS);
$connection->backup_tables(); /*Save all tables and it values in selected database*/
$connection->backup_tables("post_table"); /*Saves only table name posts_table from selected database*/
$connection->closeConnection();
Lo que significa que la visita a esta página dará lugar a copias de seguridad de su archivo de ... Por supuesto, no tiene que ser así :) puedes llamar este método en cada publicación para que esté actualizado todo el tiempo, sin embargo, te recomendaría escribirlo en un archivo todo el tiempo en lugar de crear nuevos archivos con time() ... como está arriba.
Espero que ayude y buena suerte!:>
ejemplo:
EXPORT_TABLES("localhost","user","pass","db_name");
código:
<?php
// https://github.com/tazotodua/useful-php-scripts
//optional: 5th parameter - backup specific tables only: array("mytable1","mytable2",...)
//optional: 6th parameter - backup filename
// NOTE! to adequatelly replace strings in DB, MUST READ: goo.gl/nCwWsS
function EXPORT_TABLES($host,$user,$pass,$name, $tables=false, $backup_name=false){
set_time_limit(3000); $mysqli = new mysqli($host,$user,$pass,$name); $mysqli->select_db($name); $mysqli->query("SET NAMES 'utf8'");
$queryTables = $mysqli->query('SHOW TABLES'); while($row = $queryTables->fetch_row()) { $target_tables[] = $row[0]; } if($tables !== false) { $target_tables = array_intersect($target_tables, $tables); }
$content = "SET SQL_MODE = \"NO_AUTO_VALUE_ON_ZERO\";\r\nSET time_zone = \"+00:00\";\r\n\r\n\r\n/*!40101 SET @[email protected]@CHARACTER_SET_CLIENT */;\r\n/*!40101 SET @[email protected]@CHARACTER_SET_RESULTS */;\r\n/*!40101 SET @[email protected]@COLLATION_CONNECTION */;\r\n/*!40101 SET NAMES utf8 */;\r\n--\r\n-- Database: `".$name."`\r\n--\r\n\r\n\r\n";
foreach($target_tables as $table){
if (empty($table)){ continue; }
$result = $mysqli->query('SELECT * FROM `'.$table.'`'); $fields_amount=$result->field_count; $rows_num=$mysqli->affected_rows; $res = $mysqli->query('SHOW CREATE TABLE '.$table); $TableMLine=$res->fetch_row();
$content .= "\n\n".$TableMLine[1].";\n\n";
for ($i = 0, $st_counter = 0; $i < $fields_amount; $i++, $st_counter=0) {
while($row = $result->fetch_row()) { //when started (and every after 100 command cycle):
if ($st_counter%100 == 0 || $st_counter == 0) {$content .= "\nINSERT INTO ".$table." VALUES";}
$content .= "\n("; for($j=0; $j<$fields_amount; $j++){ $row[$j] = str_replace("\n","\\n", addslashes($row[$j])); if (isset($row[$j])){$content .= '"'.$row[$j].'"' ;} else{$content .= '""';} if ($j<($fields_amount-1)){$content.= ',';} } $content .=")";
//every after 100 command cycle [or at last line] ....p.s. but should be inserted 1 cycle eariler
if ((($st_counter+1)%100==0 && $st_counter!=0) || $st_counter+1==$rows_num) {$content .= ";";} else {$content .= ",";} $st_counter=$st_counter+1;
}
} $content .="\n\n\n";
}
$content .= "\r\n\r\n/*!40101 SET [email protected]_CHARACTER_SET_CLIENT */;\r\n/*!40101 SET [email protected]_CHARACTER_SET_RESULTS */;\r\n/*!40101 SET [email protected]_COLLATION_CONNECTION */;";
$backup_name = $backup_name ? $backup_name : $name."___(".date('H-i-s')."_".date('d-m-Y').")__rand".rand(1,11111111).".sql";
ob_get_clean(); header('Content-Type: application/octet-stream'); header("Content-Transfer-Encoding: Binary"); header("Content-disposition: attachment; filename=\"".$backup_name."\"");
echo $content; exit;
} //see import.php too
?>
// actualizado por @ consejo de Mohammad.
Oye, gracias, eso es útil, pero ¿y si no queremos la inserción y solo necesitamos estructuras de base de datos? –
lo hice solo, acabo de comentar '' $ content. = "\ NINSERT INTO". $ Table. "VALUES"; '' y solo produjo estructura, no insertar consultas –
Aquí está el archivo php que le permitirá crear/descargar su copia de seguridad de la base de datos de manera eficiente Este único archivo con funcionalidad de seguridad en la página. solo tiene que descargar ese lugar de archivo en su carpeta pública o carpeta de proyecto y llamarlo a través del navegador.
Descargar URL- https://github.com/vkt005/php-mysql-db-backup
@tazo respuesta de Todua anterior
Aunque he votado a-la respuesta anterior, ya que era la única solución con la aplicación PHP 'puro' que no produjo trabajar 0 archivos de longitud, y los archivos se ven bien a primera vista, sin embargo, tenga en cuenta que falló en algunas teclas EXTRANJERAS cuando traté de volver a importar mi base de datos desde el archivo de copia de seguridad.
Las soluciones basadas en mysqldump en PHP son mucho más seguras de usar.
solución para sacar de seguridad de su base de datos en "dbBackup" Carpeta/Directorio
<?php
error_reporting(E_ALL);
/* Define database parameters here */
define("DB_USER", 'root');
define("DB_PASSWORD", '');
define("DB_NAME", 'YOUR_DATABASE _NAME');
define("DB_HOST", 'localhost');
define("OUTPUT_DIR", 'dbBackup'); // Folder/Directory Name
define("TABLES", '*');
/* Instantiate Backup_Database and perform backup */
$backupDatabase = new Backup_Database(DB_HOST, DB_USER, DB_PASSWORD, DB_NAME);
$status = $backupDatabase->backupTables(TABLES, OUTPUT_DIR) ? 'OK' : 'KO';
echo "Backup result: " . $status . " - By Irshad Khan";
/* The Backup_Database class */
class Backup_Database {
/* Host where database is located */
var $host = 'localhost';
var $username = 'root';
var $passwd = '';
var $dbName = 'YOUR_DATABASE _NAME';
var $charset = '';
/* Constructor initializes database */
function Backup_Database($host, $username, $passwd, $dbName, $charset = 'utf8') {
$this->host = $host;
$this->username = $username;
$this->passwd = $passwd;
$this->dbName = $dbName;
$this->charset = $charset;
$this->initializeDatabase();
}
protected function initializeDatabase() {
$conn = @mysql_connect($this->host, $this->username, $this->passwd); // Ik Added @ to Hide PDO Error Message
mysql_select_db($this->dbName, $conn);
if (!mysql_set_charset($this->charset, $conn)) {
mysql_query('SET NAMES ' . $this->charset);
}
}
/* Backup the whole database or just some tables Use '*' for whole database or 'table1 table2 table3...' @param string $tables */
public function backupTables($tables = '*', $outputDir = '.') {
try {
/* Tables to export */
if ($tables == '*') {
$tables = array();
$result = mysql_query('SHOW TABLES');
while ($row = mysql_fetch_row($result)) {
$tables[] = $row[0];
}
} else {
$tables = is_array($tables) ? $tables : explode(',', $tables);
}
$sql = 'CREATE DATABASE IF NOT EXISTS ' . $this->dbName . ";\n\n";
$sql .= 'USE ' . $this->dbName . ";\n\n";
/* Iterate tables */
foreach ($tables as $table) {
echo "Backing up " . $table . " table...";
$result = mysql_query('SELECT * FROM ' . $table);
$numFields = mysql_num_fields($result);
$sql .= 'DROP TABLE IF EXISTS ' . $table . ';';
$row2 = mysql_fetch_row(mysql_query('SHOW CREATE TABLE ' . $table));
$sql.= "\n\n" . $row2[1] . ";\n\n";
for ($i = 0; $i < $numFields; $i++) {
while ($row = mysql_fetch_row($result)) {
$sql .= 'INSERT INTO ' . $table . ' VALUES(';
for ($j = 0; $j < $numFields; $j++) {
$row[$j] = addslashes($row[$j]);
// $row[$j] = ereg_replace("\n", "\\n", $row[$j]);
if (isset($row[$j])) {
$sql .= '"' . $row[$j] . '"';
} else {
$sql.= '""';
}
if ($j < ($numFields - 1)) {
$sql .= ',';
}
}
$sql.= ");\n";
}
}
$sql.="\n\n\n";
echo " OK <br/><br/>" . "";
}
} catch (Exception $e) {
var_dump($e->getMessage());
return false;
}
return $this->saveFile($sql, $outputDir);
}
/* Save SQL to file @param string $sql */
protected function saveFile(&$sql, $outputDir = '.') {
if (!$sql)
return false;
try {
$handle = fopen($outputDir . '/db-backup-' . $this->dbName . '-' . date("Ymd-His", time()) . '.sql', 'w+');
fwrite($handle, $sql);
fclose($handle);
} catch (Exception $e) {
var_dump($e->getMessage());
return false;
}
return true;
}
}
?>
Sobre la base de la buena solución que proporciona tazo todua, he hecho algunos cambios desde mysql_connect ha desaprobado y no compatibles con el Nueva versión de php. He usado mysqli_connect lugar y el aumento del rendimiento de la inserción de los valores de la base de datos:
<?php
/**
* Updated: Mohammad M. AlBanna
* Website: MBanna.info
*/
//MySQL server and database
$dbhost = 'localhost';
$dbuser = 'my_user';
$dbpass = 'my_pwd';
$dbname = 'database_name';
$tables = '*';
//Call the core function
backup_tables($dbhost, $dbuser, $dbpass, $dbname, $tables);
//Core function
function backup_tables($host, $user, $pass, $dbname, $tables = '*') {
$link = mysqli_connect($host,$user,$pass, $dbname);
// Check connection
if (mysqli_connect_errno())
{
echo "Failed to connect to MySQL: " . mysqli_connect_error();
exit;
}
mysqli_query($link, "SET NAMES 'utf8'");
//get all of the tables
if($tables == '*')
{
$tables = array();
$result = mysqli_query($link, 'SHOW TABLES');
while($row = mysqli_fetch_row($result))
{
$tables[] = $row[0];
}
}
else
{
$tables = is_array($tables) ? $tables : explode(',',$tables);
}
$return = '';
//cycle through
foreach($tables as $table)
{
$result = mysqli_query($link, 'SELECT * FROM '.$table);
$num_fields = mysqli_num_fields($result);
$num_rows = mysqli_num_rows($result);
$return.= 'DROP TABLE IF EXISTS '.$table.';';
$row2 = mysqli_fetch_row(mysqli_query($link, 'SHOW CREATE TABLE '.$table));
$return.= "\n\n".$row2[1].";\n\n";
$counter = 1;
//Over tables
for ($i = 0; $i < $num_fields; $i++)
{ //Over rows
while($row = mysqli_fetch_row($result))
{
if($counter == 1){
$return.= 'INSERT INTO '.$table.' VALUES(';
} else{
$return.= '(';
}
//Over fields
for($j=0; $j<$num_fields; $j++)
{
$row[$j] = addslashes($row[$j]);
$row[$j] = str_replace("\n","\\n",$row[$j]);
if (isset($row[$j])) { $return.= '"'.$row[$j].'"' ; } else { $return.= '""'; }
if ($j<($num_fields-1)) { $return.= ','; }
}
if($num_rows == $counter){
$return.= ");\n";
} else{
$return.= "),\n";
}
++$counter;
}
}
$return.="\n\n\n";
}
//save file
$fileName = 'db-backup-'.time().'-'.(md5(implode(',',$tables))).'.sql';
$handle = fopen($fileName,'w+');
fwrite($handle,$return);
if(fclose($handle)){
echo "Done, the file name is: ".$fileName;
exit;
}
}
También tuve una situación y me cansaría encontrar una herramienta para satisfacerme. Por lo tanto, para hacer copias de seguridad/restaurar los datos de mysql de PHP, he creado un programa que puede comprimir los datos en un archivo comprimido que puede descargar. Más tarde puede cargar y restaurar la base de datos completa. Puede encontrarlo en mi página Github https://github.com/JoshyFrancis/mysql_backup_restore_php
Aunque este es un hilo viejo, no pude hacer uso de las respuestas publicadas aquí (Lo siento, mi mal). Pero aquí está el script que utilizo para las bases de datos de copia de seguridad de MySQL,
Tome una mirada here! Es una solución nativa escrita en php. No necesitarás ejecutar mysqldump, o lidiar con scripts incompletos. Este es un clon completo de mysqldump, sin dependencias, compresión de salida y valores por defecto.
Fuera de la caja, mysqldump-php admite la copia de seguridad de estructuras de tablas, los datos en sí, vistas, desencadenantes y eventos.
mysqldump-PHP es la única biblioteca que soporta:
Se puede instalar usando el compositor, o simplemente descargar el archivo php, y es tan fácil como hacer:
use Ifsnop\Mysqldump as IMysqldump;
try {
$dump = new IMysqldump\Mysqldump('database', 'username', 'password');
$dump->start('storage/work/dump.sql');
} catch (\Exception $e) {
echo 'mysqldump-php error: ' . $e->getMessage();
}
Todas las opciones se explican en la página de GitHub, pero más o menos está auto-explicativo:
$dumpSettingsDefault = array(
'include-tables' => array(),
'exclude-tables' => array(),
'compress' => Mysqldump::NONE,
'init_commands' => array(),
'no-data' => array(),
'reset-auto-increment' => false,
'add-drop-database' => false,
'add-drop-table' => false,
'add-drop-trigger' => true,
'add-locks' => true,
'complete-insert' => false,
'databases' => false,
'default-character-set' => Mysqldump::UTF8,
'disable-keys' => true,
'extended-insert' => true,
'events' => false,
'hex-blob' => true, /* faster than escaped content */
'net_buffer_length' => self::MAXLINESIZE,
'no-autocommit' => true,
'no-create-info' => false,
'lock-tables' => true,
'routines' => false,
'single-transaction' => true,
'skip-triggers' => false,
'skip-tz-utc' => false,
'skip-comments' => false,
'skip-dump-date' => false,
'skip-definer' => false,
'where' => '',
/* deprecated */
'disable-foreign-keys-check' => true
);
¿Quieres hacerlo con phpmyadmin o directamente en PHP? –
en php, tratamos con usuarios, así que lo más probable es que hagamos uso de la copia de seguridad automática usando scripts php. – user225269
Tenga en cuenta que las soluciones de PHP puro que figuran a continuación suponen que el orden de las tablas no es importante. Si tiene claves externas en su base de datos, el orden de la restauración ES importante. Pero no encontré una solución para ese problema específico ... MysqlDump hace eso, y phpmyadmin también. Aunque no son soluciones PHP puras. – jehon