Come faccio a eseguire i backup in MySQL?[duplicare]
https://stackoverflow.com/questions/46545
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Questa domanda ha già una risposta qui:
Come faccio a eseguire i backup in MySQL?
Spero che ci sia qualcosa di meglio che eseguire semplicemente mysqldump ogni "x" ore.
Esiste qualcosa come SQL Server, in cui puoi eseguire un backup completo ogni giorno e quindi incrementali ogni ora, quindi se il tuo DB muore puoi ripristinare fino all'ultimo backup?
Qualcosa come il registro del DB, dove finché il registro non muore, puoi ripristinare fino al punto esatto in cui il DB è morto?
Inoltre, in che modo queste cose influiscono sul blocco?Mi aspetto che le transazioni online vengano bloccate per un po' se eseguo un mysqldump.
Soluzione
Potresti voler dare un'occhiata backup incrementali.
Altri suggerimenti
mysqldump è un approccio ragionevole, ma tieni presente che per alcuni motori ciò bloccherà le tue tabelle per la durata del dump e ciò comporta problemi di disponibilità per set di dati di produzione di grandi dimensioni.
Un'ovvia alternativa a questo è mk-parallel-dump di Maatkit (http://www.maatkit.org/) che dovresti davvero verificare se sei un amministratore mysql.Ciò esegue il dump di più tabelle o database in parallelo utilizzando mysqldump, diminuendo così la quantità di tempo totale impiegato dal dump.
Se stai utilizzando una configurazione replicata (e se stai utilizzando MySQL per dati importanti in produzione, non hai scuse per non farlo), prendere i dump da uno slave di replica dedicato allo scopo eviterà eventuali problemi di blocco causando problemi.
La prossima ovvia alternativa, almeno su Linux, è utilizzare gli snapshot LVM.Puoi bloccare le tue tabelle, eseguire uno snapshot del filesystem e sbloccare nuovamente le tabelle;quindi avvia un MySQL aggiuntivo utilizzando un montaggio di quella istantanea, scaricando da lì.Questo approccio è descritto qui: http://www.mysqlperformanceblog.com/2006/08/21/using-lvm-for-mysql-backup-and-replication-setup/
ora comincio a sembrare un commerciante di questo prodotto.ho risposto a una domanda con esso Qui, poi ho risposto di nuovo a un altro Qui.
in poche parole, prova sqlyog (enterprise nel tuo caso) da webyog per tutti i tuoi requisiti MySQL.non solo pianifica i backup, ma anche sincronizzazione degli orari così puoi effettivamente replicare il tuo database su un server remoto.
ha un'edizione community gratuita e un'edizione aziendale.ti consiglio quest'ultima, anche se ti consiglio anche di iniziare prima con l'edizione comm vedi come ti piace.
Utilizzo mysqlhotcopy, a veloce utilità di backup a caldo on-line per database e tabelle MySQL locali.Ne sono abbastanza felice.
i ragazzi di Percona hanno realizzato un'alternativa open source a innobackup...
Xtrabackup
https://launchpad.net/percona-xtrabackup/
Leggi questo articolo su XtraDBhttp://www.linux-mag.com/cache/7356/1.html
Potresti voler integrare il tuo attuale schema di backup offline con Replica MySQL.
Quindi, se si verifica un guasto hardware, puoi semplicemente scambiare le macchine.Se rilevi rapidamente l'errore, gli utenti non noteranno nemmeno tempi di inattività o perdita di dati.
Utilizzo un semplice script che scarica il database mysql in un file tar.gz, lo crittografa utilizzando gpg e lo invia a un account di posta (Google Mail, ma in realtà è irrilevante)
Lo script è uno script Python, che sostanzialmente esegue il comando seguente e invia tramite email il file di output.
mysqldump -u theuser -p mypassword thedatabase | gzip -9 - | gpg -e -r 12345 -r 23456 > 2008_01_02.tar.gz.gpg
Questo è l'intero backup.Ha anche la parte di backup web, che si limita a tar/gzip/crittografare i file.È un sito abbastanza piccolo, quindi i backup web sono molto inferiori a 20 MB, quindi possono essere inviati all'account GMail senza problemi (i dump MySQL sono piccoli, circa 300 KB compressi).È estremamente semplice e non si adatta molto bene.Lo eseguo una volta alla settimana usando cron.
Non sono del tutto sicuro di come dovremmo inserire script più lunghi nelle risposte, quindi lo inserirò semplicemente come blocco di codice..
#!/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=["email1@example.com", "email2@example.com"] # Array of email(s)
FROM_EMAIL = "root@myserver.com" # 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()
È possibile eseguire dump completi di database/tabelle InnoDB senza blocco (tempi di inattività) tramite mysqldump con le opzioni "--single-transaction --skip-lock-tables".Funziona bene per creare istantanee settimanali + giornaliere/orarie incrementi del log binario (#Utilizzo del registro binario per abilitare i backup incrementali).
@Jake,
Grazie per le informazioni.Ora sembra che solo la versione commerciale abbia funzionalità di backup.
Non c'è NIENTE integrato in MySQL per eseguire backup decenti?
La pagina ufficiale di MySQL consiglia anche cose del tipo "beh, puoi copiare i file, PURCHÉ NON VENGONO AGGIORNATI"...
Il problema con un backup diretto della cartella del database mysql è che il backup non sarà necessariamente coerente, a meno che non si esegua un blocco da scrittura durante il backup.
Eseguo uno script che scorre tutti i database, eseguendo un mysqldump e un gzip su ciascuno in una cartella di backup, quindi esegui il backup di quella cartella su nastro.
Ciò, tuttavia, significa che non esiste qualcosa come incrementale backup, poiché il dump notturno è un dump completo.Ma direi che questa potrebbe essere una buona cosa, dal momento che un ripristino da a backup completo sarà un processo notevolmente più rapido rispetto al ripristino da unità incrementali e, se si esegue il backup su nastro, probabilmente significherà raccogliere un numero di nastri prima di poter eseguire un ripristino completo.
In ogni caso, qualunque sia il piano di backup che scegli, assicurati di eseguire un ripristino di prova per assicurarti che funzioni e avere un'idea di quanto tempo potrebbe richiedere e quali sono esattamente i passaggi che devi eseguire.
il modo corretto per eseguire backup incrementali o continui di un server MySQL è con i log binari.
per cominciare, blocca tutti i tavoli o disattiva il server.usa mysql dump per fare un backup o semplicemente copia la directory dei dati.devi farlo solo una volta o ogni volta che desideri un backup COMPLETO.
prima di ripristinare il server, assicurati che la registrazione binaria sia abilitata.
per eseguire un backup incrementale, accedere al server ed eseguire un comando FLUSH LOGS.quindi eseguire il backup del file di registro binario chiuso più recentemente.
se hai tutte le tabelle innodb, è più semplice usare semplicemente inno hot backup (non gratuito) o mysqldump con l'opzione --single-transaction (è meglio avere molta memoria per gestire le transazioni).
I log binari sono probabilmente il modo corretto per eseguire backup incrementali, ma se non ti fidi dei formati di file binari per l'archiviazione permanente, ecco un modo ASCII per eseguire backup incrementali.
mysqldump non è un cattivo formato, il problema principale è che restituisce una tabella come un'unica grande riga.Il seguente banale sed dividerà il suo output lungo i confini del record:
mysqldump --opt -p | sed -e "s/, (/, n (/g"> database.dump
Il file risultante è abbastanza intuitivo per i diff e li ho conservati in un repository SVN standard con discreto successo.Ciò ti consente anche di conservare una cronologia dei backup, se scopri che l'ultima versione si è danneggiata e hai bisogno della versione della settimana scorsa.
Questa è una soluzione piuttosto solida per la shell Linux.L'ho utilizzato per anni:
http://sourceforge.net/projects/automysqlbackup/
- Esegue i backup in sequenza:giornaliero, mensile, annuale
- Molte opzioni
@Daniele,
nel caso tu sia ancora interessato, c'è una soluzione nuova (nuova per me) condivisa da Paolo Galbraith, uno strumento che consente il backup online delle tabelle innodb chiamate ibbackup dall'oracolo che per citare Paolo,
se utilizzato insieme a innobackup, ha funzionato benissimo per creare un backup notturno, senza tempi di inattività durante il backup
maggiori dettagli possono essere trovati su Il blog di Paolo
Sembra che tu stia parlando del rollback delle transazioni.
Quindi, in termini di ciò di cui hai bisogno, se disponi dei registri contenenti tutte le query storiche, non è già quello il backup?Perché è necessario un backup incrementale che è fondamentalmente una copia ridondante di tutte le informazioni nei registri DB?
Se è così, perché non usi semplicemente mysqldump ed esegui il backup ogni tanto?
