Crear script para respaldo de base de datos PostgreSQL

Similar al post script para respaldo de bases de datos de MySQL podemos generar un bash en nuestro servidor para que genere un respaldo de nuestra base de datos deseada y posteriormente con el cron crear nuestra tarea automatizada.

Creamos un archivo con extensión .sh en la carpeta que deseemos, el script es el siguiente (le llamaremos /home/miusuario/scripts/backup.sh):

#!/bin/bash
# variables
directorio="/home/respaldos/postgresql";
database="dbbasedatos";
fecha="`date +%Y%m%d%H%M%S`";
usuario="miusuario"
host="11.1.1.1"
export PGPASSWORD=miclave

# generar el dump y crear el log
pg_dump -U $usuario -h $host -F t -d $database|gzip -9 > $directorio/$fecha.tar.gz && echo 'Respaldo realizado con exito.' >> $directorio/bitacora.log;
Aquí una breve explicación:
#Nuestras variables
directorio: el directorio donde generaremos nuestros respaldos.
database: la base de datos a respaldar.
fecha: la fecha y hora actual que la concatenaremos con nuestro nombre de archivo.
usuario: el usuario de postgresql para generar el respaldo (debe tener permisos sobre nuestra base).
host: servidor de base de datos, aquí muy importante si nuestro usuario no tiene acceso al host de localhost nos mostrara un error, deben verificar con que host fue creado.

#Nuestros comandos
export PGPASSWORD: la contraseña de nuestro usuario, en caso de no tener contraseña omitir esta linea.

Ahora viene nuestro comando que realiza toda la operación, para mas detalle puede consultar pg_dump --help a través de la consola.
-U el nombre de usuario
-h el servidor de base de datos
-F t el formato de salida, para nuestro caso es tar
-d la base de datos a respaldar
gzip -9 comprime nuestra salida con el parámetro de la mejor compresión
$directorio/$fecha.tar.gz con nuestros parametros de las variables es donde se generara nuestro respaldo (p.e. /home/respaldos/postgresql/1701191257.tar.gz).

Nota: si nuestro usuario no tiene contraseña, podemos agregar el parámetro de -w (o bien --no-password) a la linea de nuestro comando pg_dump.

Para probarlo podemos ejecutar nuestro bash y ver nuestro resultado.

$ sh backup.sh
Hasta este punto no debería existir algún problema, solo faltaría crear nuestro cron para automatizar nuestra tarea:

$ crontab -e 

nuestras lineas:

10 1 * * * /home/respaldos/scripts/backup.sh 1> /dev/null 2> /home/respaldos/errores.log

 y listo hemos terminado.

Crear usuario con minimos privilegios para realizar respaldo de MySQL

Este post es complemento del script para realizar respaldos mediante archivos crontab. Pero se puede utilizar de forma manual para realizar los respaldos.

1. Iniciar mysql y crear usuario

$ sudo mysql -u usuario -p 
mysql> CREATE USER usuario_respaldo@localhost IDENTIFIED BY "MiClave";

2. Asignamos los privilegios

mysql> GRANT SELECT, SHOW VIEW, RELOAD, REPLICATION CLIENT, EVENT, TRIGGER ON *.* TO usuario_respaldo@localhost;

Algunos privilegios no estan disponibles en versiones anteriores de MySQL:

• EVENT, este privilegio es requerido para crear, modificar, eliminar o ver eventos del EVENT SHEDULER. Este privilegio fue agregado en MySQL 5.1.6
• TRIGGER, este privilegio habilita las operaciones de los disparadores. Este privilegio fue agregado en MySQL 5.1.6
• REPLICATION_CLIENT, este privilegio habilita el uso de SHOW_MASTER_STATUS y SHOW_SLAVE_STATUS. En MySQL 5.1.6 y versiones superiores habilita ademas el uso de la sentencia SHOW_BINARY_LOGS

3. Agregamos el privilegio para bloquear las tablas

mysql> GRANT LOCK TABLES ON *.* TO usuario_respaldo@localhost;

4. Probamos el respaldo de una base de datos
 
Nos salimos de mysql y probamos el comando mysqldump

$ mysqldump -u usuario_respaldo -p --databases dbmibase > dbmibase.sql

Si todo fue correcto en nuestro directorio debe existir nuestro respaldo dbmibase.sql.

Script para generar respaldos MySQL mediante el CRON

Cuando tenemos varias bases de datos en nuestros servidor y ya por algun tiempo, es necesario contar con alguna herramienta que permita generar respaldos de forma automatica, con la finalidad de prevenir inconvenientes con la información que manejamos y poder recuperarnos de la eventualidad lo mas antes posible.

A continuación describiremos los pasos para poder generar nuestro script y asignarlos a las tareas automaticas de nuestro servidor.

1. Preparando todo

Generalmente el servicio de crond viene instalado por defecto en nuestro servidor y es el que se encarga de ejecutar programas, comandos o script en un horario determinado. Para saber el estado en el que se encuentra el servicio escriba la siguiente sentencia:

$ sudo service crond status

En caso de no contar con este servicio, sera necesario su instalación. Seguido sera necesario contar con una carpeta donde ingresaremos nuestros script, en mi caso dentro de la carpeta home

$ mkdir /home/miusuario/ejecutar

Creamos nuestra carpeta donde iremos guardando nuestros respaldos (lo ideal es contar con otro servidor donde tengamos estos respaldos)

$ mkdir /home/miusuario/respaldos

Para nuestro caso sera necesario contar con un usuario en MySQL que tenga los permisos suficientes para poder ejecutar los comando mysql y mysqldump, así como el permiso para generar los respaldos correspondientes a todas las bases de datos.

Verificamos que la fecha y hora de nuestro servidor sea la correcta para no tener algunos resultados no deseados,

$ date
mié ago 10 15:00:01 CDT 2015

y en caso de ser necesario definimos el horario correcto:

$ sudo date --set "2015-08-19 15:12:10"

Por ultimo, cuando ejecutemos el crond se ejecutara el editor por defecto, en la mayoría de los casos el editor vi es el que viene configurado, aquí dependerá de con cual se sienta uno más cómodo. En mi caso habilite el nano, he aquí la instrucción para habilitarlo momentáneamente:

$ sudo export EDITOR="nano"

Si deseamos que sea permanente habrá que agregarlo en el .bashrc o en el .bash_profile del usuario deseado.


2. Generamos nuestro script

Una vez que tenemos todo listo generamos nuestro script en la carpeta deseada (/home/miusuario/ejecutar):

$ nano /home/miusuario/ejecutar/respaldarMySQL.sh


#!/bin/bash

# Configurar variables de entorno
FECHA=`date +%d%m%Y-%H%M%S`
DIRECTORIO="/home/miusuario/respaldos"

# Obtener los nombres de las bases de datos
misbases=`mysql -uusuariomysql -pmiclave --skip-column-names -e'SHOW DATABASES'`

# Crear el respaldo de las bases de datos
for db in $misbases; do
    # Nombre del archivo de respaldo
    archivo="$db-$FECHA.sql.gz"
    if [ $db != "mysql" ] && [ $db != "information_schema" ]; then
        # Crear respaldo, comprimirlo
        # y si fue exitoso guardar una bitacora
        mysqldump -uusuariomysql -pmiclave --databases $db | gzip -9 > \
        $DIRECTORIO/$archivo && echo "Respaldo realizado con exito: \
        $archivo" >> $DIRECTORIO/bitacora.log
    fi
done

Nota: El caracter \ indica que la cadena continua con la linea inferior

Describiremos algunas lineas para que quede mas claro este script:

• La variable FECHA guardara la fecha y hora actual, que se concatenara para formar el nombre del archivo. (%d%m%Y-%H%M%S => 19082015-100001)
• DIRECTORIO sera la ruta donde guardaremos los respaldos
• misbases obtendra todas las bases de datos de nuestro servidor
• archivo tendra la concatenacion de la base de datos y la fecha y hora para formar el nombre de nuestro respaldo
• el if verificara que no sean las bases mysql e information_schema, las cuales no respaldaremos
• Ahora viene lo interesante:
• mysqldump generara el respaldo de cada una de las bases de datos
• el caracter | indica que una vez que se tenga el resultado de mysqldump sera como parametro del siguiente comando (gzip)
• gzip realiza la compresion del respaldo de la bd y con el caracter > se indica que se guardara en el archivo $DIRECTORIO/$archivo, si no existe el archivo se crea uno nuevo y si existe reemplazara al anterior.
• con el caracter && se indica que el siguiente comando se ejecutara solo si el anterior se ejecuto satisfactoriamente
• Si se ejecuto correctamente el respaldo y la compresion, se guarda el registro de que todo fue un exito en el archivo bitacora.log, con el caracter >> se indica que si el archivo bitacora.log no existe se creara uno nuevo y si existe se agregara una nueva linea al final del archivo
• Este proceso se realiza por cada una de las bases de datos

Para probar que funciona este script, simplemente lo ejecutamos y verificamos el resultado, no se olvide cambiar los permisos necesarios para que el archivo sea ejecutable.

3. Creamos el cron

Bueno hasta este momento ya tenemos listo el script  probado, procederemos a definir cuando se ejecutara para que se realicen los respaldos correspondientes, primero aqui una explicación de como se compone un archivo crontab:

.---------------------- Minuto (0 - 59)
| .-------------------- Hora (0 - 23)
| |  .----------------- Día del mes (1 - 31)
| |  | .--------------- Mes (1 - 12)
| |  | | .------------- Día de la semana (0 - 6) (0 = domingo)
| |  | | | .----------- Usuario
| |  | | | |    .------ Script o programa a ejecutar
↓ ↓  ↓ ↓ ↓ ↓    ↓
5 15 * * * user /home/user/ejecutar/miscript.sh
En este ejemplo se ejecutara miscript.sh a las 15:05 todos los días, todos los meses, cada dia de la semana como usuario user. Aqui se listan algunos caracteres especiales que se pueden usar:

• utilice un espacio para separar cada campo
• para varios valores separelos por comas
• para un rango de valores separelos por un guión
• el * se utiliza como comodin para incluir todos los valores
• el # al inicio de la linea se utiliza como comentario

Todos los comandos del archivo crontab deben ir en una sola linea por muy larga que sea esta, ya que no se reconocen los retorno de carros adicionales.

Ahora si creamos nuestro archivo crontab, el cual se ejectuara todos los dias de la semana de todos los meses a la 1:00am para realizar nuestro respaldo:

$ sudo crontab -e -u miusuario
00 1 * * * miusuario /home/miusuario/ejectuar/respaldarMySQL.sh

Guardamos nuestro archivo y listo, tenemos un archivo crontab preparado.

4. Algunos comentarios

Para consultar nuestros archivos crontab, utilicemos la siguiente instruccion

$ sudo crontab -l

Para editar el archivo crontab de algun usuario

$ sudo crontab -e -u miusuario

Los archivos crontab se guardan en la siguiente ruta /var/spool/cron, debe tener privilegios de root para consultar el listado.

5. Actualización (10/01/2019)

Para evitar que en nuestro script queden expuestas las credenciales de nuestro usuario que realizara el respaldo, podemos agregar las lineas de acceso al archivo my.cnf (generalmente esta en /etc/my.cnf) de la configuración del mysql, asi nuestro script solo tendra las lineas sin el usuario:

respaldarMySQL.sh

# Obtener los nombres de las bases de datos

misbases=`mysql --skip-column-names -e'SHOW DATABASES'`

.

.

.

# y si fue exitoso guardar una bitacora

        mysqldump --databases $db | gzip -9 > \

.

.

.

En nuestro archivo my.cnf agregamos las siguientes lineas:

[mysqldump]

# Usuario para el respaldo

user=usuariomysql

password=miclave

[mysql]

# Usuario para la consulta de las bases

user=usuariomysql

password=miclave

Reiniciamos nuestro servicio para que podamos ejecutar nuestro script, y listo.

Actualizar diferentes filas con una sola consulta en MySQL

Hace poco tiempo tuve la necesidad de actualizar varios registros a la vez, lo mas sencillo es crear una consulta y repetirla n veces de acuerdo a la cantidad de registros que deseo actualizar, he aquí la solución sencilla:

UPDATE Directorio SET Orden = 1 WHERE DirectorioId = 1021;
// Ejecutarla
UPDATE Directorio SET Orden = 0 WHERE DirectorioId = 1022;
// Ejecutarla
UPDATE Directorio SET Orden = 2 WHERE DirectorioId = 1023;
// Ejecutarla

Esto funcionaria sin problemas, sin embargo al tener mas registros esto consumiría demasiados recursos de nuestro servidor porque se ejecutarían n sentencias, la opción es simplificar todo a una sola consulta usando CASE, WHEN y THEN. A continuación como quedaría nuestra consulta:

UPDATE Directorio
   SET Orden = CASE DirectorioId
      WHEN 1021 THEN 1
      WHEN 1022 THEN 0
      WHEN 1023 THEN 2
   END
WHERE DirectorioId IN (1021, 1022, 1023) 

De esta forma nuestro servidor ejecutara una sola consulta. En este caso que vimos solo actualizamos un campo pero también es posible actualizar varios campos a la vez, he aquí el ejemplo:

UPDATE Directorio
    SET Orden = CASE DirectorioId
        WHEN 1021 THEN 1
        WHEN 1022 THEN 0
        WHEN 1023 THEN 3
    END,
    SET DepartamentoId = CASE DirectorioId
        WHEN 10 THEN 11
        WHEN 12 THEN 21
        WHEN 13 THEN 11
    END
WHERE DirectorioId IN (1021, 1022, 1023)

Ahora solo un poco de ingenio para incluirlo en nuestro código PHP ya sea con sentencias de control FOR, DO o While. Espero haya sido de utilidad este post.

Mostrar y Revocar privilegios de MySQL

Hace unos días me encontré en la necesidad de revisar que privilegios tenían los usuarios de MySQL, así que me di a la tarea de investigarlo y les comparto una breve guía de como realizarlo.

1. Mostrar privilegios de un usuario
Ingresamos a nuestro servidor MySQL como ya lo hemos hecho anteriormente y solo bastara con escribir el siguiente comando:

mysql> SHOW GRANTS FOR miUser@localhost;

y se nos desplegara la información de los privilegios de este usuario

GRANT USAGE ON *.* TO 'miUser'@'localhost' IDENTIFIED BY PASSWORD '*519FB...'
GRANT SELECT, INSERT, UPDATE, DELETE ON `dbDatos`.* TO 'miUser'@'localhost'
GRANT ALL PRIVILEGES ON `miBase`.* TO 'miUser'@'localhost' 

2. Revocar privilegios
Para revocar privilegios se emplea la función REVOKE, su sintaxis es muy parecida a la de GRANT, he aquí la forma de utilizarla.

mysql> REVOKE ALL ON miBase.* FROM miUser@localhost

Este comando quitara todos los privilegios sobre todos los elementos de la base de datos miBase al usuario miUser.

Con REVOKE se pueden quitar privilegios sobre elementos en particular de las bases de datos. Su sintaxis de acuerdo al manual oficial de MySQL es:

REVOKE
    priv_type [(column_list)]
      [, priv_type [(column_list)]] ...
    ON [object_type] priv_level
    FROM user [, user] ...

Para asignar privilegios y borrar usuarios, puedes consultar el siguiente enlace:
http://mgermano.blogspot.mx/2014/04/crear-y-borrar-usuarios-de-mysql-por.html

Sensibilidad de mayusculas y minusculas en nombres de tablas MySQL

Hace poco me encontré con un problema al pasar una base de datos de Windows a Linux, el problema fue que en Windows los nombres de las bases de datos y las tablas no son sensibles a mayúsculas y minúsculas, una posible solución seria manejar todo en minusculas para que no exista ese problema, pero sabemos que eso, sobre todo si se tiene un estandar de base de datos, no es una solución viable.

La solución es cambiar el valor a una variable de MySQL: lower_case_table_names. He aqui una explicación obtenida del manual de referencia de MySQL.

Valor	Significado
0	Los nombres de tablas y bases de datos se almacenan en disco usando el esquema de mayúsculas y minúsculas especificado en las sentencias CREATE TABLE o CREATE DATABASE. Las comparaciones de nombres son sensibles a mayúsculas. Esto es lo predeterminado en sistemas Unix. Nótese que si se fuerza un valor 0 con --lower-case-table-names=0 en un sistema de ficheros insensible a mayúsculas y se accede a tablas MyISAM empleando distintos esquemas de mayúsculas y minúsculas para el nombre, esto puede conducir a la corrupción de los índices.
1	Los nombres de tablas se almacenan en minúsculas en el disco y las comparaciones de nombre no son sensibles a mayúsculas. MySQL convierte todos los nombres de tablas a minúsculas para almacenamiento y búsquedas. En MySQL 5.0, este comportamiento también se aplica a nombres de bases de datos y alias de tablas. Este valor es el predeterminado en Windows y Mac OS X.
2	Los nombres de tablas y bases de datos se almacenan en disco usando el esquema de mayúsculas y minúsculas especificado en las sentencias CREATE TABLE o CREATE DATABASE, pero MySQL las convierte a minúsculas en búsquedas. Las comparaciones de nombres no son sensibles a mayúsculas.Nota: Esto funciona solamente en sistemas de ficheros que no son sensibles a mayúsculas. Los nombres de las tablas InnoDB se almacenan en minúsculas, como cuandolower_case_table_names vale 1.

1. Para verificar que valor tiene esta variable, podemos hacerlo de 3 formas:
  a) buscar la opción de mostrar variables (show variables) en nuestro cliente de MySQL
  b) en la pestaña variables mediante phpMyAdmin buscarla
  c) entrar mediante la consola de comandos a mysql y escribir el siguiente comando:
  mysql> show variables like "%lower%";

2. En Windows por defecto el valor es 1, para cambiar el valor podemos usar el phpMyAdmin, si es que tenemos un usuario con los suficientes privilegios, y mediante la pestaña variables podemos editarla cambiando su valor a 0, posterior a ello tendremos que reiniciar el servicio de MySQL.

En caso de no tener phpMyAdmin o el usuario, habrá que ubicar el archivo de configuración de MySQL (my.ini o my.cnf), la ubicación dependerá de la versión y como hayan instalado, he aquí algunas ubicaciones donde podría estar:

c:\Windows\my.ini
c:\ruta_de_mysql\MySQL\my.ini
c:\Program Data\MySQL\MySQLversion\my.ini

Editamos este archivo actualizando o agregando la siguiente linea en caso de que no exista:
[mysqld]
...
lower_case_table_names = 0

Guardamos y reiniciamos nuestro servicio MySQL. Verificamos que el valor de nuestra variable este en 0.

Posterior a ello tendremos que renombrar nuestras bases de datos y/o tablas sensibles a mayúsculas y minúsculas antes de hacer una migración a nuestro servidor en producción de Linux.

Instalar FreeTDS en Ubuntu para usar mssql en PHP

A partir de PHP 5.3 la extensión (mssql) para permitir el acceso a base de datos MS SQL Server ya no esta disponible en Windows, en lugar de ello tendremos que usar la extensión de ODBC pero ese es otro tema, aqui veremos una opción para acceder a bases de datos de SQL Server utilizando la libreria FreeTDS (Tabular Data Stream).

FreeTDS es un conjunto de librerias distribuidas libremente bajo licencia GNU/GPL, que nos permite comunicar PHP con bases de datos de SQL Server y Sybase.

1. Desde linea de comandos instalamos freeTDS asi como la libreria sybase de PHP

$ sudo apt-get install freetds-common freetds-bin tdsodbc php5-sybase

Reiniciamos nuestro servidor web y probamos en el navegador, creando un archivo php con la función phpinfo(), verificando que la libreria mssql se encuentra ya instalada.

2. Configuramos FreeTDS
Editamos el archivo freetds.conf que se encuentra en /etc/freetds

$ sudo nano /etc/freetds/freetds.conf

Dentro del archivo vienen algunos ejemplos de configuración, he aquí un ejemplo de como configurar:

[nombreservidor]
host = 100.100.100.1
port = 1433
tds version = 7.2

con [nombreservidor] es como haremos referencia a nuestro servidor , en host agregamos nuestra IP del servidor, el puerto (port) para servidores de SQL Server es el 1433, tds version es la versión del SQL que estaremos usando.

1.  7.0 -- Microsoft SQL Server 7
2.  7.1 -- Microsoft SQL Server 2000
3.  7.2 -- Microsoft SQL Server 2005 o posterior

Una vez terminado de configurar el archivo, lo guardamos.

3. Probando nuestra conexión
Para ver si todo esta correcto realizamos una prueba:

$ tsql -S nombreservidor -U usuariosql

en seguida se pedira el password, si no hay problema, habremos ingresado a nuestro servidor SQL. Recordemos que nombreservidor es nuestra referencia que ingresamos en nuestro archivo de configuración freetds.conf.

4. Probando nuestra conexión en PHP
Ya tenemos todo listo para comenzar a trabajar en php con mssql, podemos crear un archivo en php y probar nuestra conexion.

<?php
/** Conexión a SQL Server **/
$host    = "nombreservidor"; // esta es nuestra referencia
$usuario = "sa";
$pass    = "12345;
$bd      = "miBase";
$conexion = mssql_connect($host, $usuario, $pass);
if (!$conexion) die ("Error al conectar a SQL server");
mssql_select_db($bd) or die ("Error al seleccionar la Base de datos");
echo "Conexion establecida con éxito";
?>

Guardamos nuestro archivo y lo probamos en nuestro navegador, si no hubiese problemas debe mostrarse el mensaje de Conexión establecida con éxito.

Instalar Apache, PHP y MySQL en Ubuntu

Una vez que tenemos instalado Ubuntu, si deseamos tener un servidor Web, como Apache, con PHP y MySQL, he aquí explicaremos como realizar esta instalación mediante consola, cabe mencionar que es una instalación básica no tan segura y por lo tanto no recomendada para un servidor en producción, pero esto nos servirá para montar un servidor local para nuestros trabajos.

1. Instalamos el servidor Apache:

$ sudo apt-get install apache2 -y

El parametro -y no pregunta y asume que si a todo. Una vez que termina de instalar podemos probar en nuestro navegador con:

http://localhost ó http://127.0.0.1

nos aparecerá un mensaje que nuestro servidor se encuentra trabajando.

2. Instalamos PHP 5

$ sudo apt-get install php5 libapache2-mod-php5 -y

Una vez instalado, reiniciamos nuestro servidor web

$ sudo service apache2 restart

o bien

$ sudo /etc/init.d/apache restart

El directorio por default para subir todas nuestras aplicaciones de php sera en: /var/www, en lo posterior tendremos que tener un usuario que tenga permisos sobre esta carpeta, por el momento en esta carpeta podremos probar si el php esta función, creando un archivo con la función phpinfo(), por ejemplo

$ sudo nano info.php

dentro del archivo colocamos las lineas:

<?php    phpinfo();    ?>

Lo guardamos (ctrl + x), cargamos nuestra página en el navegador (http://localhost/info.php) y nos debe mostrar la configuración de nuestro servidor web.

3. Instalamos MySQL 5

$ sudo apt-get install mysql-server mysql-client -y

Casi al terminar la instalación se nos pedirá la contraseña del root y su confirmación, es muy importante recordar esta contraseña y no perderla. Para probar la instalación tendremos que accesar a nuestro servidor MySQL.

$ mysql -u root -p

Acto seguido se pedira la contraseña que será la que ingresamos en la instalación, la ingresamos y listo tenemos nuestro servidor MySQL instalado.

4. Instalar modulos faltantes de PHP
En seguida tendremos que instalar todos los módulos que hacen falta, entre ellos va el soporte de la librería GD, CURL, MySQL, etc.

$ sudo apt-get install php5-mysql php5-curl php5-gd php5-idn php-pear php5-imagick php5-imap php5-mcrypt php5-memcache php5-ming php5-ps php5-pspell php5-recode php5-snmp php5-sqlite php5-tidy php5-xmlrpc php5-xsl -y

Una vez terminada la instalación tendremos que reiniciar nuevamente nuestro servidor web, como ya se describio en las lineas anteriores, y listo ya tenemos instalado Apache, PHP y MySQL.

Importar y Exportar bases de datos MySQL por consola en Linux

Existen muchas formas de administrar el MySQL, desde la linea de comandos, usando el phpMyAdmin, hasta un software de terceros como HeidiSQL, SQLYog, MySQL Workbench entre otros, el utilizar cada una tiene sus ventajas y desventajas.

A continuación veremos como importar y exportar a través de la linea de comandos. Para ello necesitaremos iniciar una conexión remota con SSH y acceder como root o un usuario con suficientes privilegios.

Importar

---

Para importar una base de datos, primero es necesario subir el archivo sql que contiene la información (puede realizarse por FTP), y puede almacenarse en nuestra carpeta home. En seguida colocar el siguiente comando para importar la base de datos:

$ mysql -u miusuario -p nombreMiBd < miArchivoSQL.sql

Se pedirá a continuación la contraseña del usuario de MySQL, una vez introducida, comenzará el proceso de importación que será de pocos segundos. Esta forma es muy útil para subir base de datos de un tamaño grande.

Exportar

---

Para exportar una base de datos, primero tenemos que ubicarnos en la carpeta donde se realizará la exportación que puede ser nuestra carpeta home que después podremos bajar vía FTP. El comando para exportar es el siguiente:

$ mysqldump -u miusuario -p nombreMiBd > miArchivoSQL.sql

En seguida se pedirá la contraseña y acto seguido comenzara la exportación que igual durara unos pocos segundos.

Nota:
Se puede realizar tanto la importación como exportación a un servidor remoto desde nuestro servidor, para ello agregamos el parametro -h donde pondremos nuestro servidor remoto (ya sea por dominio o IP):

$ mysqldump -u miusuario -p -h www.miservidorremoto.net nombreMiBd > miArchivoSQL.sql

Este comando exportara la base de datos nombreMiBd del servidor www.miservidorremoto.net al archivo miArchivoSQL.sql en la carpeta de nuestro servidor. Para permitir esta acción tiene que estar habilitado el acceso remoto del servidor MySQL.

Si al importar la información llegase a salir el error de Got a packet bigger than 'max_allowed_packet' bytes, puedes checar la solución en mi siguiente post http://mgermano.blogspot.mx/2014/05/solucionar-el-error-got-packet-bigger.html