respaldar - ¿Cómo hago copias de seguridad en MySQL?
respaldar base de datos mysql consola (15)
Esta pregunta ya tiene una respuesta aquí:
¿Cómo hago copias de seguridad en MySQL?
Espero que haya algo mejor que ejecutar mysqldump cada "x" horas.
¿Hay algo así como SQL Server, donde puede realizar una copia de seguridad completa todos los días, y luego incrementos cada hora, por lo que si su base de datos muere puede restaurar hasta la última copia de seguridad?
Algo así como el registro de DB, donde mientras el registro no muera, puede restaurar hasta el punto exacto donde murió el DB.
Además, ¿cómo afectan estas cosas al bloqueo? Esperaría que las transacciones en línea se bloqueen por un tiempo si hago un mysqldump.
@ Daniel,
en caso de que todavía esté interesado, hay una solución nueva (nueva para mí) compartida por Paul Galbraith , una herramienta que permite la copia de seguridad en línea de las tablas innodb llamada ibbackup de Oracle, que para citar a Paul,
cuando se usa junto con inobackup , funcionó muy bien al crear una copia de seguridad nocturna, sin tiempo de inactividad durante la copia de seguridad
más detalles se pueden encontrar en el blog de Paul
@Jake,
Gracias por la info. Ahora, parece que solo la versión comercial tiene funciones de respaldo.
¿No hay ALGO CREADO en MySQL para hacer copias de seguridad decentes?
La página oficial de MySQL incluso recomienda cosas como "bueno, puedes copiar los archivos, SI NO ESTÁN ACTUALIZANDO" ...
El problema con una copia de seguridad directa de la carpeta de la base de datos mysql es que la copia de seguridad no será necesariamente consistente, a menos que realice un bloqueo de escritura durante la copia de seguridad.
Ejecuto un script que itera a través de todas las bases de datos, haciendo un mysqldump y gzip en cada una de ellas a una carpeta de respaldo, y luego hago una copia de seguridad de esa carpeta en cinta.
Esto, sin embargo, significa que no existe una copia de seguridad incremental , ya que el volcado nocturno es un volcado completo. Pero yo diría que esto podría ser algo bueno, ya que una restauración a partir de una copia de seguridad completa será un proceso significativamente más rápido que la restauración a partir de incrementos, y si realiza una copia de seguridad en cinta, probablemente sea necesario recopilar varias cintas antes que usted puede hacer una restauración completa.
En cualquier caso, cualquiera que sea el plan de copia de seguridad con el que vaya, asegúrese de realizar una restauración de prueba para asegurarse de que funciona, y tener una idea de cuánto tiempo podría tomar, y exactamente cuáles son los pasos que debe seguir.
Es posible que desee complementar su esquema actual de copia de seguridad fuera de línea con la replicación de MySQL .
Entonces, si tiene una falla de hardware puede simplemente intercambiar máquinas. Si detecta la falla rápidamente, los usuarios ni siquiera notarán el tiempo de inactividad o la pérdida de datos.
Es posible que desee ver las copias de seguridad incrementales .
Esta es una solución bastante sólida para shell de Linux. Lo he estado usando por años:
http://sourceforge.net/projects/automysqlbackup/
- ¿Realiza copias de seguridad de respaldo: diarias, mensuales, anuales
- Muchas opciones
Los registros binarios son probablemente la forma correcta de realizar copias de seguridad incrementales, pero si no confía en los formatos de archivo binarios para el almacenamiento permanente, aquí hay una forma ASCII de realizar copias de seguridad incrementales.
mysqldump no es un formato incorrecto, el problema principal es que genera cosas en una tabla como una gran línea. La siguiente sed trivial dividirá su salida a lo largo de las fronteras del registro:
mysqldump --opt -p | sed-e "s /, (/, / n (/ g"> database.dump
El archivo resultante es bastante amigable con las diferencias, y los he mantenido en un repositorio SVN estándar con bastante éxito. Eso también le permite mantener un historial de copias de seguridad, si encuentra que la última versión se ha corrompido y necesita la versión de la semana pasada.
Puede hacer volcados completos de bases de datos / tablas InnoDB sin bloqueo (tiempo de inactividad) a través de mysqldump con las opciones "--single-transaction --skip-lock-tables". Funciona bien para hacer instantáneas semanales + incrementos de registro binarios diarios / por hora (#Utilizar el registro binario para habilitar copias de seguridad incrementales).
Suena como si estuvieras hablando de deshacer las transacciones.
Entonces, en términos de lo que necesita, si tiene los registros que contienen todas las consultas históricas, ¿no es esa la copia de seguridad ya? ¿Por qué necesita una copia de seguridad incremental que es básicamente una copia redundante de toda la información en los registros de DB?
Si es así, ¿por qué no usa mysqldump y hace la copia de seguridad de vez en cuando?
Utilizo mysqlhotcopy, una rápida herramienta de copia de seguridad en línea para bases de datos y tablas locales de MySQL . Estoy muy feliz con eso.
Utilizo un script simple que volca la base de datos mysql en un archivo tar.gz, lo encripta usando gpg y lo envía a una cuenta de correo (Google Mail, pero eso es realmente irrelevante)
El script es un script de Python, que básicamente ejecuta el siguiente comando y envía un correo electrónico al archivo de salida.
mysqldump -u theuser -p mypassword thedatabase | gzip -9 - | gpg -e -r 12345 -r 23456 > 2008_01_02.tar.gz.gpg
Esta es toda la copia de seguridad. También tiene la parte de respaldo web, que solo tar / gzips / encripta los archivos. Es un sitio bastante pequeño, por lo que las copias de seguridad web son mucho menos de 20 MB, por lo que se pueden enviar a la cuenta de GMail sin problemas (los volcados de MySQL son pequeños, unos 300 KB comprimidos). Es extremadamente básico y no se escalará muy bien. Lo ejecuto una vez por semana usando cron.
No estoy muy seguro de cómo se supone que debemos poner scripts largos en las respuestas, así que simplemente lo empujaré como un bloque de código.
#!/usr/bin/env python
#encoding:utf-8
#
# Creates a GPG encrypted web and database backups, and emails it
import os, sys, time, commands
################################################
### Config
DATE = time.strftime("%Y-%m-%d_%H-%M")
# MySQL login
SQL_USER = "mysqluser"
SQL_PASS = "mysqlpassword"
SQL_DB = "databasename"
# Email addresses
BACKUP_EMAIL=["[email protected]", "[email protected]"] # Array of email(s)
FROM_EMAIL = "[email protected]" # Only one email
# Temp backup locations
DB_BACKUP="/home/backupuser/db_backup/mysite_db-%(date)s.sql.gz.gpg" % {''date'':DATE}
WEB_BACKUP="/home/backupuser/web_backup/mysite_web-%(date)s.tar.gz.gpg" % {''date'':DATE}
# Email subjects
DB_EMAIL_SUBJECT="%(date)s/db/mysite" % {''date'':DATE}
WEB_EMAIL_SUBJECT="%(date)s/web/mysite" % {''date'':DATE}
GPG_RECP = ["MrAdmin","MrOtherAdmin"]
### end Config
################################################
################################################
### Process config
GPG_RECP = " ".join(["-r %s" % (x) for x in GPG_RECP]) # Format GPG_RECP as arg
sql_backup_command = "mysqldump -u %(SQL_USER)s -p%(SQL_PASS)s %(SQL_DB)s | gzip -9 - | gpg -e %(GPG_RECP)s > %(DB_BACKUP)s" % {
''GPG_RECP'':GPG_RECP,
''DB_BACKUP'':DB_BACKUP,
''SQL_USER'':SQL_USER,
''SQL_PASS'':SQL_PASS,
''SQL_DB'':SQL_DB
}
web_backup_command = "cd /var/www/; tar -c mysite.org/ | gzip -9 | gpg -e %(GPG_RECP)s > %(WEB_BACKUP)s" % {
''GPG_RECP'':GPG_RECP,
''WEB_BACKUP'':WEB_BACKUP,
}
# end Process config
################################################
################################################
### Main application
def main():
"""Main backup function"""
print "Backing commencing at %s" % (DATE)
# Run commands
print "Creating db backup..."
sql_status,sql_cmd_out = commands.getstatusoutput(sql_backup_command)
if sql_status == 0:
db_file_size = round(float( os.stat(DB_BACKUP)[6] ) /1024/1024, 2) # Get file-size in MB
print "..successful (%.2fMB)" % (db_file_size)
try:
send_mail(
send_from = FROM_EMAIL,
send_to = BACKUP_EMAIL,
subject = DB_EMAIL_SUBJECT,
text = "Database backup",
files = [DB_BACKUP],
server = "localhost"
)
print "Sending db backup successful"
except Exception,errormsg:
print "Sending db backup FAILED. Error was:",errormsg
#end try
# Remove backup file
print "Removing db backup..."
try:
os.remove(DB_BACKUP)
print "...successful"
except Exception, errormsg:
print "...FAILED. Error was: %s" % (errormsg)
#end try
else:
print "Creating db backup FAILED. Output was:", sql_cmd_out
#end if sql_status
print "Creating web backup..."
web_status,web_cmd_out = commands.getstatusoutput(web_backup_command)
if web_status == 0:
web_file_size = round(float( os.stat(WEB_BACKUP)[6] ) /1024/1024, 2) # File size in MB
print "..successful (%.2fMB)" % (web_file_size)
try:
send_mail(
send_from = FROM_EMAIL,
send_to = BACKUP_EMAIL,
subject = WEB_EMAIL_SUBJECT,
text = "Website backup",
files = [WEB_BACKUP],
server = "localhost"
)
print "Sending web backup successful"
except Exception,errormsg:
print "Sending web backup FAIELD. Error was: %s" % (errormsg)
#end try
# Remove backup file
print "Removing web backup..."
try:
os.remove(WEB_BACKUP)
print "...successful"
except Exception, errormsg:
print "...FAILED. Error was: %s" % (errormsg)
#end try
else:
print "Creating web backup FAILED. Output was:", web_cmd_out
#end if web_status
#end main
################################################
################################################
# Send email function
# needed email libs..
import smtplib
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
def send_mail(send_from, send_to, subject, text, files=[], server="localhost"):
assert type(send_to)==list
assert type(files)==list
msg = MIMEMultipart()
msg[''From''] = send_from
msg[''To''] = COMMASPACE.join(send_to)
msg[''Date''] = formatdate(localtime=True)
msg[''Subject''] = subject
msg.attach( MIMEText(text) )
for f in files:
part = MIMEBase(''application'', "octet-stream")
try:
part.set_payload( open(f,"rb").read() )
except Exception, errormsg:
raise IOError("File not found: %s"%(errormsg))
Encoders.encode_base64(part)
part.add_header(''Content-Disposition'', ''attachment; filename="%s"'' % os.path.basename(f))
msg.attach(part)
#end for f
smtp = smtplib.SMTP(server)
smtp.sendmail(send_from, send_to, msg.as_string())
smtp.close()
#end send_mail
################################################
if __name__ == ''__main__'':
main()
ahora estoy empezando a sonar como un vendedor de este producto. Respondí una pregunta con esto aquí , luego respondí con otra aquí nuevamente.
En pocas palabras, pruebe sqlyog (enterprise en su caso) desde webyog para todos sus requisitos de mysql. no solo programa las copias de seguridad , sino que también programa la sincronización para que puedas replicar tu base de datos a un servidor remoto.
tiene una edición comunitaria gratuita, así como una edición empresarial. Te recomiendo lo último, aunque también te recomiendo que comiences con la edición de comunicación y primero veas cómo te gusta .
la forma correcta de ejecutar copias de seguridad incrementales o continuas de un servidor mysql es con registros binarios.
para empezar, bloquea todas las tablas o baja el servidor. use mysql dump para hacer una copia de seguridad, o simplemente copie el directorio de datos. solo tiene que hacer esto una vez o cada vez que quiera una copia de seguridad COMPLETA.
antes de volver a subir el servidor, asegúrese de que el registro binario esté habilitado.
para realizar una copia de seguridad incremental, inicie sesión en el servidor y emita un comando FLUSH LOGS. luego haga una copia de seguridad del archivo de registro binario cerrado más recientemente.
si tiene todas las tablas de innodb, es más sencillo usar la copia de seguridad inno hot (no gratuita) o mysqldump con la opción --single-transaction (será mejor que tenga mucha memoria para manejar las transacciones).
los chicos de Percona hicieron una altenative de código abierto para innobackup ...
Xtrabackup
https://launchpad.net/percona-xtrabackup/
Lea este artículo sobre XtraDB http://www.linux-mag.com/cache/7356/1.html
mysqldump es un enfoque razonable, pero tenga en cuenta que para algunos motores, esto bloqueará sus tablas durante el tiempo que dure el volcado, y esto tiene problemas de disponibilidad para grandes conjuntos de datos de producción.
Una alternativa obvia a esto es mk-parallel-dump de Maatkit ( http://www.maatkit.org/ ) que realmente debería verificar si es un administrador de MySQL. Esto descarga varias tablas o bases de datos en paralelo usando mysqldump, disminuyendo así la cantidad de tiempo total que tarda su volcado.
Si está ejecutando una configuración replicada (y si está utilizando MySQL para datos importantes en producción, no tiene excusas para no hacerlo), tomar volcados de un esclavo de replicación dedicado al propósito evitará que se produzcan problemas de bloqueo. causando problemas.
La siguiente alternativa obvia, al menos en Linux, es usar instantáneas LVM. Puede bloquear sus tablas, hacer una instantánea del sistema de archivos y desbloquear las tablas nuevamente; luego inicie un MySQL adicional usando un montaje de esa instantánea, volcando desde allí. Este enfoque se describe aquí: http://www.mysqlperformanceblog.com/2006/08/21/using-lvm-for-mysql-backup-and-replication-setup/