Esta es la tercera entrega de la serie Clonar una web en un servidor local, por lo que te recomiendo leer las entregas previas. No obstante, este artículo puede ser tratado como un artículo atómico asumiendo que perdemos ciertos matices.

Una de las ventajas del proceso de clonado de los archivos frente al de clonado de una base de datos es que si bien con la base de datos podíamos encontrarnos muchas limitaciones en función de los diferentes proveedores y planes de hostings, para clonar los archivos el único requisito que debemos cumplir con respecto a nuestro host remoto es tener acceso mediante ftp, algo que todos los hosting ofrecen.

Descarga de archivos

Para descargar los archivos nos serviremos del comando wget. Comenzaremos el proceso creando un script de consola y le asignándole los permisos necesarios:

mkdir ~/scripts
vim ~/scripts/cloneWebFiles.sh
chmod 0755 ~/scripts/clonWebFiles.sh

Con el siguiente contenido:

#!/bin/bash

wget -r -N -q --level=15 --user=user --password='password' --directory-prefix=~/webBackUp fttp://ftp.url.com

Dónde:

• -r, indica recursividad
• -N, indica que descargue solo archivos nuevos y/o modificados
• -q, oculta los mensajes de salida del comando
• –level=15, es el numero de niveles de recursividad
• –user=user, es el usuario ftp
• –password=’password’, es la contraseña del ftp
• –directory-prefix=~/webBackUp, es el directorio dónde copiaremos los archivos
• fttp://ftp.url.com, es el ftp con el path del que queremos descargar los archivos

Esto realizará una copia de los archivos de nuestra web en la carpeta ~/webBackUp/ftp.url.com. Esta operación suele tardar bastante tiempo, así que para agilizarla hemos optado por descargar únicamente los archivos nuevos y/o modificados recientemente, aun así con una web de tamaño medio tardará un buen rato.

Debemos destacar que no descargamos los archivos directamente a nuestro entorno de pruebas, sino que los descargamos a una carpeta intermedia. Esto lo hacemos por dos motivos:

1. Modificaremos algunos archivos antes de copiarlos en nuestro entorno de pruebas.
2. Podemos crear un segundo script que omita la descarga y que restaure nuestra copia mucho más rápido, muy útil en caso de querer descartar los cambios realizados y comenzar desde 0.

Modificación de datos relativos al entorno

Una vez hecha la descarga de los archivos deberemos modificar los que contienen datos relativos a nuestro host. En nuestro ejemplo, el archivo wp-config.php almacena la inforación de la conexión a la base de datos. En vuestro caso debereis localizar que archivos contienen este tipo de información antes de seguir avanzando.

La estrategia que seguiremos para ello sera la de realizar una copia inicial de forma manual de los archivos sensibles al entorno de pruebas. Una vez hecha actualizaremos los datos necesarios.

Por otro lado, automatizaremos una tarea que renombra estos archivos en la ubicación intermedia, de forma que cuando realicemos la copia al entorno de pruebas no se sobrescriban. Así que agregamos estas dos líneas a nuestro script:

rm ~/webBackUp/ftp.url.com/w-config.php.renamed
mv ~/webBackUp/ftp.url.com/w-config.php ~/webBackUp/ftp.url.com/w-config.php.renamed

Copia de archivos a la ubicación definitiva

Ya con los archivos descargados y una vez resuelta la problemática de la información sensible al entorno copiamos los archivos:

cp -r ~/webBackUp/ftp.url.com/* /var/www/targetVHost

Como vemos, este sistema solo copia los archivos nuevos y/o que han sufrido cambios, pero si hemos eliminado un archivo de nuestro host remoto no lo eliminará de nuestro host local. Para mi esta situación no supone un problema a día de hoy, así que simplemente no hago nada, pero siempre se puede preparar algún sistema que busque la diferencia de archivos entre la copia intermedia y el entorno de prueba y elimine los sobrantes de esta segunda ubicación.

El script

Y todo el rollazo que os he soltado se traduce básicamente en el siguiente script:

#!/bin/bash

wget -r -N -q --level=15 --user=user --password='password' --directory-prefix=~/webBackUp fttp://ftp.url.com
rm ~/webBackUp/ftp.url.com/w-config.php.renamed
mv ~/webBackUp/ftp.url.com/w-config.php ~/webBackUp/ftp.url.com/w-config.php.renamed
cp -r ~/webBackUp fttp://ftp.url.com/* /var/www/targetVHost

Programar la ejecución de la copia

Al igual que hicimos con la clonación de la base de datos programamos la ejecución del script con Cron:

crontab -e

E incluimos la siguiente línea en el archivo crontab:

0 2 * * 5 ~/scripts/clonWebFiles.sh

Aunque en principio ambos script podrían ejecutarse a la misma vez, hemos sido precavidos retrasando una hora la ejecución de la copia de los archivos, de forma que se ejecute cada viernes a las 02:00 de la madrugada.

Créditos y Referencias

• Articulo de la serie: Clonar una web en un servidor local.
• Entrega previa de la seie: Clonar una web: la base de datos.
• Imagen de portada: Martin Harry.

Esta entrada pertenece a la serie Clonar una web en un servidor local. Por ese motivo te recomiendo que leas dicho artículo para darle perspectiva a este. Sea como sea, este artículo puede ser leído sin la referencia anterior, pero perderemos ciertos matices que quizás resulten interesantes.

Backup de la base de datos remota

En función del hosting que tengamos contratado dispondremos de una serie de funcionalidades. Por norma general si has contratado un VPS o servidor dedicado tendrás la posibilidad de ejecutar scripts de consola, lo cual ofrece muchas posibilidades para la tarea que queremos realizar.

Si por el contrario dispones de un hosting compartido no sueles tener acceso a esta opción, así que para dar respuesta a la mayor cantidad de situaciones posibles realizaremos el backup con PHP, más concretamente haremos uso de la clase MySql Backup Lite que introducimos en la entrada Backup de base de datos MySQL con PHP. Y para programar la ejecución de esta tarea nos ayudaremos de nuestro servidor local, dónde programaremos la ejecución de un script que acceda a la url que realiza el respaldo.

Para no extendernos demasiado y no repetirnos, no copiaremos la clase en esta entrada, puedes encontrarla en los enlaces del párrafo anterior.

Así que crearemos un script en PHP en nuestro servidor remoto que llamaremos backUpDb.php en el directorio scripts que tras ser ejecutado generará una copia de la base de datos en el archivo backups/wordpressBackUp.sql.

include('MySqlBackup.php');

$arrayDbConf['host'] = 'dbHost';
$arrayDbConf['user'] = 'dbUser';
$arrayDbConf['pass'] = 'dbPassword';
$arrayDbConf['name'] = 'wordpressDbName';

try {

  $bck = new MySqlBackupLite($arrayDbConf);
  $bck->backUp();
  $bck->setFileDir('../backups/');
  $bck->setFileName('wordpressBackUp.sql');
  $bck->saveToFile();

}
catch(Exception $e) {

  die($e);

}

Si nuestro hosting tiene habilitada la conexión remota a la base de datos este paso podríamos ejecutarlo en el servidor local. Como no siempre tendremos esta opción, nos hemos decantado por la alternativa más universal.

Y puesto que en este ejemplo el backup es de una plataforma WordPress, y que por ese motivo los datos de conexión a la base de datos ya están especificados en un archivo de configuración escrito en PHP, sería más interesante hacer un include del archivo wp-config.php y obtenerlos desde ahí. De nuevo, en pro de mantener esta entrada lo más genérica posible hemos decidido hacerlo así.

Programar la ejecución del backup de la base de datos

Una vez más existen múltiples opciones para programar esta tarea, unas más elegantes que otras. En un VPS programar una tarea con Cron sería lo más lógico y eficiente, pero tal y como hemos comentado, tomaremos la opción que podemos aplicar independientemente del hosting que tengamos: utilizaremos Cron en nuestro servidor local para programar una tarea que ejecute el script de backup de base de datos que acabamos de crear en el host remoto.

Para ello creamos un script de consola y le asignamos los permisos necesarios:

mkdir ~/scripts
vim ~/scripts/cloneWebDb.sh
chmod 0755 ~/scripts/clonWebDb.sh

Con el siguiente contenido:

#!/bin/bash

curl -Is https://url.com/scripts/backUpDb.php

Y programamos la ejecución del script con Cron:

crontab -e

E incluimos la siguiente línea en el archivo crontab:

0 1 * * 5 ~/scripts/clonWebDb.sh

Asegurándonos de que el script se ejecuta cada Viernes a la 1 de la madrugada. Evidentemente puedes programar la periodicidad que más te convenga. Puedes visitar la entrada Programar tareas en Ubuntu con Cron para profundizar en la programación de tareas con Cron.

Descargar el backup de la base de datos

Lo siguiente es descargar el backup que acabamos de realizar. Lo haremos mediante el protocolo ftp, sirviéndonos del comando wget. Para ello agregamos una línea más a nuestro script clonWeb.sh, de forma que quede así:

#!/bin/bash

curl -Is https://url.com/scrpts/backUpDb.php
wget -q --user=user --password='password' --directory-prefix=~/webBackUp fttp://ftp.url.com/backups/wordpressBackUp.sql

Dónde:

• -q, oculta los mensajes de salida del comando
• –user=user, es el usuario ftp
• –password=’password’, es la contraseña del ftp
• –directory-prefix=~/webBackUp, es el directorio dónde copiaremos los archivos
• fttp://ftp.url.com/backups/wordpressBackUp.sql, es el ftp con el path del que queremos descargar los archivos

Con esto ya habremos descargado nuestra base de datos en el directorio ~/webBackUp/ftp.url.com/backups/wordpressBackUp.sql. El siguiente paso será restaurarla.

Restauración de la base de datos

Y para restaurar la base de datos en nuestro servidor local la estrategia que seguiremos será:

1. Eliminamos la base de datos.
2. Volvemos a crear base de datos vacía.
3. Restauramos la base de datos desde el backup.

Como puedes ver el proceso es bastante crítico pues elimina completamente la copia existente. Además hará que durante el tiempo que toma el proceso nuestro clon local no esté accesible. En mi caso el uso que le voy a dar es disponer de una réplica de una web en productivo en un servidor local para realizar pruebas. Para este uso el riesgo es perfectamente asumible, y en todo el tiempo que llevo utilizándola no he tenido ningún tipo de problema. Evidentemente, tú deberás evaluar si este riego y esta parada de servicio son asumibles para ti.

Así que crearemos un script SQL que elimine completamente la base de datos y vuelva a crearla. De nuevo lo haremos dentro de la carpeta ~/scripts y lo llamaremos dropAndCreateDb.sql. El contenido será el siguiente:

DROP DATABASE localDbName;
CREATE DATABASE localDbName;

Y agregamos dos líneas más a nuestro script de consola para ejecutar

#!/bin/bash

curl -Is https://urlToScript.com/backUpDb.php
wget -N -q --user=user --password='password' --directory-prefix=~/webBackUp ftp://ftp.miweb.com/path/backups/wordpressBackUp.sql
mysql -u localDbUserName -plocalDbPassword localDbName < ~/scripts/dropAndCreateDb.sql
mysql -u localDbUserName -plocalDbPassword localDbName < ~/webBackUp/ftp.url.com/backups/wordpressBackUp.sql

Actualización de los datos relativos al entorno

El último paso para dar por completado el proceso de clonación de nuestra base de datos será reemplazar todos los datos datos necesarios para que nuestro clon funcione perfectamente. Este paso es el que más puede variar de un entorno a otro, a continuación os dejo un ejemplo bastante básico para un blog realizado en wordpress:

update wp_options set option_value='http://192.168.1.10' where option_name='siteurl';
update wp_options set option_value='http://192.168.1.10' where option_name='home';
update wp_posts set guid=REPLACE(guid, 'blog.ahierro.es', '192.168.1.146:8085') where guid like '%blog.ahierro.es%';

Vosotros tendréis que localizar las tablas, campos y registro a modificar en vuestras plataformas. En el ejemplo expuesto las dos primeras líneas hacen referencia a datos de configuración y son imprescindible, pues de no actualizar estos campos nuestro wordpress local siempre redirigiría al remoto.

Créditos y Referencias

• Articulo de la serie: Clonar una web en un servidor local.
• Siguiente entrega de la serie: Clonar una web: los archivos.
• Clase MySql Backup Lite.
• Imagen de portada: Martin Harry.

Otra de esas posibilidades de las que hablamos es realizar el respaldo con PHP, lo que nos permitirá hacerlo con casi todos los hostings, además de que es fácilmente automatizable. La principal desventaja, por contra, es que es una opción algo más laboriosa, pues tendremos que programar el script. Pero como la rueda casi siempre está inventada, en internet tienes muchas soluciones que te facilitarán la labor.

MySQL BackUp Lite

Yo os propongo esta sencilla solución que he desarrollado, de la que os dejo el código a continuación. En cualquier momento puedes acceder a la versión más actualizada de MySQL Backup Lite en Github.

/**
*
* MySql Backup Lite Class
*
* @author     Andres Hierro
* @copyright  2019 Andres Hierro
* @license    http://www.apache.org/licenses/LICENSE-2.0  Apache License, Version 2.0
* @version    0.0.1
* @link       http://ahierro.es/
*
*
*
* Copyright 2019 Andrés Hierro
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/

class MySqlBackupLite {

  private $host;
  private $user;
  private $pass;
  private $name;

  private $fileName = "mySqlBackup.sql";
  private $fileDir = "./";
  private $fileCompression = false;

  private $timeZone = '+00:00';

  private $mySqli;
  private $sqlString = "";
  private $arrayTables;

  private $tableFieldCount = 0;
  private $tableNumberOfRows = 0;
  private $queryResult;



  public function __construct(array $arrayConnConfig) {

      if (
        (!isset($arrayConnConfig['host'])) ||
        (!isset($arrayConnConfig['user'])) ||
        (!isset($arrayConnConfig['pass'])) ||
        (!isset($arrayConnConfig['name']))
      ) {
          throw new Exception('Missing connection data.');

      }
      $this->setHost($arrayConnConfig['host']);
      $this->setUser($arrayConnConfig['user']);
      $this->setPass($arrayConnConfig['pass']);
      $this->setName($arrayConnConfig['name']);

  }



  public function backUp() {

    $this->connectMySql();
    $this->getTables();
    $this->generateSqlHeader();
    $this->createTableStaments();
    $this->insertStaments();
    $this->generateSqlFooter();

  }



  private function setHost($host) {
    $this->host = $host;
  }



  private function setUser($user) {
    $this->user = $user;
  }



  private function setPass($password) {
    $this->pass = $password;
  }



  private function setName($name) {
    $this->name = $name;
  }



  public function setFileName($name) {
    $this->fileName = $name;
  }



  public function setFileDir($dir) {
    $this->fileDir = $dir;
  }



  public function setFileCompression($compression) {
    $this->fileCompression = $compression;
  }



  private function connectMySql() {

    $this->mySqli = new mysqli($this->host, $this->user, $this->pass, $this->name);
    $this->mySqli->select_db($this->name);
    $this->mySqli->query("SET NAMES 'utf8'");

  }



  private function getTables() {

    $queryTables = $this->mySqli->query('SHOW TABLES');
    while($row = $queryTables->fetch_row()) {
      $this->arrayTables[] = $row[0];
    }

  }



  private function generateSqlHeader() {

    $this->sqlString  = 'SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";' . "\r\n";
    $this->sqlString .= 'SET time_zone = "' . $this->timeZone . '";' . "\r\n\r\n\r\n";
    $this->sqlString .= '/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;' . "\r\n";
    $this->sqlString .= '/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;' . "\r\n";
    $this->sqlString .= '/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;' . "\r\n";
    $this->sqlString .= '/*!40101 SET NAMES utf8 */;' . "\r\n";
    $this->sqlString .= '--' . "\r\n";
    $this->sqlString .= '-- Database: `' . $this->name . '`' . "\r\n";
    $this->sqlString .= '--' . "\r\n\r\n\r\n";

    return;

  }



  private function createTableStaments() {

    foreach($this->arrayTables as $table){
      $this->sqlCreateTableStament($table);
    }

  }



  private function sqlCreateTableStament($table) {

    $res = $this->mySqli->query('SHOW CREATE TABLE '.$table);
    $temp = $res->fetch_row();
		$this->sqlString .= "\n\n" . str_ireplace('CREATE TABLE `','CREATE TABLE IF NOT EXISTS `', $temp[1]) . ";\n\n";

  }



  private function insertStaments() {

    foreach($this->arrayTables as $table){
      $this->sqlInsertStaments($table);
    }

  }



  private function sqlInsertStaments($table) {

		$this->getTableData($table);

    if($this->tableFieldCount == 0) {
      return;
    }


    $i = 0;
		while($row = $this->queryResult->fetch_row())	{

      $this->insertResultHeader($table, $i);
      $this->insertSingleResult($row);

      $i++;
      $this->sqlString .= (($i != 0) && ($i % 100 == 0) || ($i == $this->tableNumberOfRows)) ? ";" : ",";

		}

    $this->sqlString .= "\n\n\n";

  }



  private function getTableData($table) {

  	$this->queryResult	= $this->mySqli->query('SELECT * FROM `' . $table . '`');
    $this->tableFieldCount = $this->queryResult->field_count;
    $this->tableNumberOfRows = $this->mySqli->affected_rows;

  }



  private function insertResultHeader($table, $currentRowNumber) {

  	if ($currentRowNumber % 100 == 0 || $currentRowNumber == 0 )	{
      $this->sqlString .= "\nINSERT INTO " . $table . " VALUES";
    }

  }



  private function insertSingleResult($row) {

    $this->sqlString .= "\n(";

    for($i = 0; $i < $this->tableFieldCount; $i++){

      $row[$i] = str_replace("\n","\\n", addslashes($row[$i]));

      $this->sqlString .= (isset($row[$i])) ? '"'.$row[$i].'"' : '""';
      if($i < ($this->tableFieldCount-1)){
        $this->sqlString.= ',';
      }

    }

    $this->sqlString .=")";

  }



  private function generateSqlFooter() {

    $this->sqlString .=  "\r\n\r\n";
    $this->sqlString .=  '/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;';
    $this->sqlString .=  "\r\n";
    $this->sqlString .=  '/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;';
    $this->sqlString .=  "\r\n";
    $this->sqlString .=  '/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;';

  }



  public function downloadFile() {

      ob_get_clean();
      header('Content-Type: application/octet-stream');
      header("Content-Transfer-Encoding: Binary");
      header('Content-Length: '. (function_exists('mb_strlen') ? mb_strlen($this->sqlString, '8bit'): strlen($this->sqlString)) );
      header("Content-disposition: attachment; filename=\"".$this->fileName."\"");
    	echo $this->sqlString; exit;

  }



  public function saveToFile() {

    if (!$backupFile = fopen($this->fileDir . $this->fileName, "w+")) {
        throw new Exception('Imposible to create file.');
    }
    fwrite($backupFile, $this->sqlString);
    fclose($backupFile);

  }


}

Realizar la copia de seguridad

La solución propuesta nos proporciona dos opciones que podemos utilizar según nuestras necesidades:

1. Realizar el backup y descargarlo.
2. Realizar el backup y guardarlo en un archivo.

En ambos casos incluimos la clase y le pasaremos al método constructor los datos de la conexión a la base de datos en un array como el que ves a continuación:

include('MySqlBackup.php');

$arrayDbConf['host'] = 'dbHost';
$arrayDbConf['user'] = 'dbUser';
$arrayDbConf['pass'] = 'dbPassword';
$arrayDbConf['name'] = 'dbName';

Respaldar y descargar

Para realizar el backup y descargarlo serán suficientes unas pocas líneas:

try {

  $bck = new MySqlBackupLite($arrayDbConf);
  $bck->backUp();
  $bck->downloadFile();

}
catch(Exception $e) {

  echo $e;

}

Respaldar y guardar en un archivo

Para guardar el resultado en un archivo además deberemos de indicarle el nombre del archivo y el directorio dónde guardarlo.

try {

  $bck = new MySqlBackupLite($arrayDbConf);
  $bck->backUp();
  $bck->setFileDir('./backups/');
  $bck->setFileName('backupFileNae.sql');
  $bck->saveToFile();

}
catch(Exception $e) {

  echo $e;

}

Solo una parte del proceso

Pero en muchas situaciones, este respaldo sera solo una parte del proceso. Nosotros hemos propuesto un escenario mayor en el que clonamos nuestra web en un servidor local, en breve publicaremos el artículo.

Créditos y rerefencias

• Imagen principal: Tumisu en Pixabay.
• Solución Mysql Backup Lite: Andrés Hierro, github.