Backup folosind scripturi. Exemplu de script pentru crearea unei copii de rezervă MySQL

Prefaţă

Ideea de a crea un script care să poată face o copie de rezervă a unui site (toate fișierele + dump bază de date) în câteva clicuri a apărut în timp ce lucram la mai multe proiecte și făceam și testam la server web local. Chiar și atunci, am avut Denver, care de-a lungul timpului a fost înlocuit cu o combinație locală de servicii web în dezvoltare mai rapidă - OpenServer.

Proiectele au fost vizitate, așa că mai întâi s-a făcut o copie locală a întregului site și abia după aceea s-a putut lucra și experimenta cu el, evitând întreruperile în lucrul proiectului live. Am făcut o copie de rezervă astfel: m-am autentificat prin SSH și am împachetat folderul de proiect cu arhivatorul 7Zip sau TGZ, am făcut un dump folosind mysqldump și am descărcat toate aceste lucruri prin web sau SCP/WinSCP.

Imediat lenea s-a făcut simțită și a apărut gândul la automatizare: „ar fi grozav dacă tot ce scriu în consolă s-ar face automat pentru fiecare site și ar fi fost necesare doar câteva clicuri de la mine.” Prima mea căutare a unei soluții de automatizare SSH pentru Windows m-a condus imediat la un utilitar pe care îl folosesc de mult timp pentru a lucra cu fișiere de pe servere - .

Cum funcționează scriptul de rezervă

Deci, esența scriptului de backup automat este următoarea:

1. Citim date din fisierul ini, unde stocam setarile pentru site (nume, login, parola, cont mysql...);
2. Pe baza datelor, generăm un script pentru WinSCP, care va efectua toate operațiunile necesare în consola de pe server;
3. Lansăm programul WinSCP, care se conectează la server și face o copie de rezervă a site-ului + baza de date și, de asemenea, arhivează toate datele folosind un arhivator cu un raport de compresie ridicat - 7Zip sau TAR + GZip;
4. Descărcați arhiva;
5. Închideți WinSCP și ștergeți jurnalele + ștergeți scriptul generat temporar pentru WinSCP cu comenzi;
6. Gata! Ai nevoie de o copie a altui site? - GOTO 1!

Pot exista mai multe site-uri, deci este posibil să utilizați mai multe fișiere ini cu setări separate pentru fiecare site.

Toate operațiunile de procesare și gestionare WinSCP vor fi efectuate de script. scris în limbajul de scripting al fișierelor bat pentru Windows. De asemenea, oferă o interfață simplă de consolă care vă permite să efectuați toate operațiunile necesare.

Pentru această sarcină, pe baza simplității sale, limbajul de scripting al fișierelor bat este destul de suficient, dar totuși nimeni nu se deranjează să implementeze acest sistem în Autoit sau într-unul dintre limbajele de programare nivel inalt, cum ar fi C#, Delphi etc.

Atenţie! Scriptul este relevant doar dacă aveți acces la consola serverului prin SSH.

Interfață și meniu de rezervă

După rularea scriptului, avem acces la un meniu simplu:

Primul element (apăsați 1 și enter) este responsabil pentru procesul de backup și afișează o listă de fișiere de configurare șablon disponibile pentru site-uri.

Al doilea punct este generarea unui șablon de fișier de configurare și deschiderea acestuia pentru editare.

Al treilea punct este un scurt ghid pentru scrierea fișierelor șablon.

În figura de mai jos, este deschis un meniu cu o selecție de site-uri disponibile pentru rezervare:

Aici sub-elementul „0. Toate site-urile enumerate mai jos” este responsabil pentru pornirea unei copii de rezervă a tuturor site-urilor cu fișierele de configurare enumerate mai jos. Astfel, puteți face copii de rezervă pentru un site sau pe toate simultan.

Exemplu de fișier de configurare pentru un script

Iată un exemplu de fișier de configurare somesite.com.ini pentru copierea de rezervă a somesite.com:

Sitename_string=somesite_com store_path=D:\Backup\ archive_method=7z archive_password=StrOngp@sswOrd hostname=000.111.222.333 ssh_user=rădăcină ssh_password=p@ssmetotheserver mysql_userword=mysql_userword=Wql_userword=ssql_usergWql_usergWql_USerg Hh d185g mysql_db_name=site1_db dirs_to_backup=/var/www/somesite. com /www/* /var/www/somesite.com/www/.htaccess

După cum puteți vedea, totul este simplu și nimic de prisos. Vă voi spune în detaliu despre fiecare linie de setări:

sitename_string - atribuiți un nume clar site-ului (numai latină și simbolul _).

store_path - calea către calculator local, de unde va fi descărcată arhiva de rezervă.

archive_method - metoda de arhivare a fisierelor site-ului.

• 7z - va fi folosit arhivatorul cu același nume, ieșirea va fi o arhivă cu extensia „zip”.
• gz - arhivare folosind TAR+GZip, rezultatul va fi o arhivă cu extensia „tgz” .

archive_password - parola de arhivare, funcționează numai când archive_method=7z .

hostname - adresa IP externă sau domeniul serverului pe care sunt găzduite site-ul web și baza de date.

ssh_user - nume de utilizator pentru conectarea prin SSH. În cele mai multe cazuri, aveți nevoie de root pentru a efectua toate operațiunile, deși puteți încerca să îl configurați pentru un alt utilizator neprivilegiat.

ssh_parola!! - parola pentru utilizatorul de mai sus.

mysql_user * - nume de utilizator pentru conectarea la baza de date a site-ului de pe serverul MySQL.

mysql_password - parola pentru utilizatorul MySQL de mai sus. Trebuie instalat!

mysql_db_name - numele bazei de date a site-ului pentru care vom face un dump complet.

dirs_to_backup ** - scrieți o listă, separată de spațiu, de căi complete, directoare și fișiere care trebuie arhivate.

Note:

Dacă lăsați valoarea goală, parola va fi solicitată ulterior în modul interactiv (recomand să nu păstrați parola).

* Se presupune că scripturile și baza de date Date MySQL găzduit pe același server. Adică adresa serverului MySQL este 127.0.0.1 (localhost).

** În mod implicit, arhivatorii nu împachetează fișiere .htaccess, așa că trebuie să specificați suplimentar calea completă către ele!

** Asigurați-vă că indicați complet și nu căi relative la foldere sau fișiere.

Puteți crea câte fișiere de configurare doriți; când rulați scriptul, numele fiecăruia va fi afișat cu un număr alocat. Pentru a începe lucrul, trebuie să introduceți numărul de configurare (numărul) și atât (dacă aveți nu ați specificat o parolă, apoi introduceți o altă parolă).

Pregătirea pentru muncă și utilizarea scenariului

Totul este foarte simplu!

Primul pas este să decidem unde vom stoca scriptul cu toate configurațiile sale. Recomand să nu stocați astfel de programe și date pe mașină locală V formă deschisă, deoarece nu este sigur, mai ales dacă parolele pentru accesul root la servere sunt stocate în configurații. Complexul poate fi stocat undeva pe un mediu criptat sau undeva unde viruși sau străini. În ceea ce privește siguranța, alegerea vă aparține, să mergem mai departe.

Lăsați întregul complex să fie situat de-a lungul căii:

• D:\Backup\ - arhivele de rezervă vor fi încărcate aici.
• D:\Backup\script\ - scriptul nostru și programul WinSCP vor fi localizate aici.

1) Descărcați cea mai recentă versiune configurată și portabilă a programului WinSCP de pe site-ul web PortableApps - WinSCP Portable. Instalăm programul în folderul D:\Backup\script\ - folderul WinSCPPortable va fi creat acolo și va fi un fișier WinSCPPortable.exe în el.

2) Descărcați arhiva cu scriptul și șabloanele aici - backup_sites_v1.2 și despachetați-o în folderul D:\Backup\script\.

3) Deschideți fișierul backup_sites_v1.2.bat pentru editare și editați căile în secțiunea „Configurare WinSCP”:

• „D:\Backup\script\WinSCPPortable\WinSCPPortable.exe” - calea către programul WinSCP Portable;
• „D:\Backup\script\WinSCPPortable\Data\settings\winscp.log” - calea în care este creat fișierul jurnal al programului WinSCP Portable.

Ne asigurăm că căile scrise în script corespund cu cele în care se află programul WinSCP, altfel pur și simplu nu va porni.

4) Creăm fișiere șablon pentru backup site-ului. Există mai multe dintre ele în arhivă - redenumiți-le în funcție de numele de domenii ale site-urilor dvs. și ștergeți-le pe cele inutile.

Crea șablon nou site-ul web pentru script în următoarele moduri:

1. Doar copiați fișierul INI, redenumindu-l în numele corect, iar apoi edităm setările din el;
2. Generăm șablonul folosind un script. Rulați scriptul, apăsați 2 și introduceți numele domeniului sau numele site-ului (doar caractere latine și simbolul _). Se va deschide un bloc de note cu fișierul nou creat; după ce ați făcut modificări, salvați-l și închideți-l.

Ce opțiune este mai convenabilă - alegeți singur.

5) Totul este gata, puteți rula scriptul și puteți încerca să faceți o copie de rezervă a unuia dintre site-urile dvs.

După confirmarea selecției unui site pentru backup, vi se poate cere parola de utilizator SSH dacă nu a fost specificată în Fișier de configurare. Se va deschide imediat o fereastră cu un jurnal al programului WinSCP, care va afișa progresul acțiunilor pe server, precum și progresul descărcării arhivei finalizate de pe server.

Când WinSCP termină descărcarea arhivei, fereastra se va închide; pentru a termina scriptul, trebuie doar să apăsați orice tastă din fereastră.

Despre securitatea datelor

Scriptul în timpul funcționării sale generează fișier temporar„.tmp” cu un set de comenzi pentru WinSCP. Acest fișier conține login și parola pentru accesarea serverului prin SSH.

Șabloanele INI cu setările site-ului conțin și informații importante - aceștia sunt parametrii de acces la baza de date.

NU recomand cu tărie stocarea acestui script și fișiere de setări pe discuri care pot fi accesate direct în orice moment după lansare și manipulări simple cu computerul. Pentru stocare, puteți crea un disc criptat sau puteți cumpăra medii separate.

Acest script este doar un instrument care economisește timp în efectuarea acțiunilor de rutină și similare. Fă-ți timp și îngrijorează-te cu privire la siguranța și securitatea datelor tale!

Toată responsabilitatea pentru utilizarea acestui script revine dvs., fiți extrem de atenți!

Concluzie

Scriptul poate fi ajustat și modificat astfel încât să devină mai funcțional și să efectueze acțiunile de care aveți nevoie pe site-urile dvs.

De asemenea aceasta metoda Automatizarea WinSCP poate fi folosită pentru a construi alte scripturi care vor îndeplini diferite sarcini pe VPS sau serverul dvs. dedicat prin consolă.

Există o mulțime de metode de backup, dar pentru mine personal au dezavantajele lor, motiv pentru care nu le folosesc. Este mai ușor să scrieți câteva scripturi simple, de exemplu, folosind așa-numita poreclă de liliac sau PowerShell. În acest articol vă voi spune cum puteți configura backup folosind scripturi, le combin și creez pachete.

Schema de backup

În cele mai multe cazuri, backup-ul se reduce la salvarea anumitor fișiere. Pot fi imagini mașini virtuale, fișiere utilizator, backup baze de date SQL, descărcarea bazei de informații 1C:Enterprise etc. Este mai corect să stocați toate aceste copii de rezervă ale fișierelor într-o altă locație, acesta ar putea fi un folder de rețea, o unitate externă, unitate de banda, ftp etc. Pentru comoditate, folosesc un server ftp.

Să ne uităm la diagrama cum se întâmplă toate acestea:

1. Copiați sau mutați-le într-un folder pentru a le trimite la arhivă
2. Verificați folderul pentru copii de rezervă noi
3. Trimitem fișiere la arhivă pe server FTP
4. Ștergerea fișierelor de rezervă vechi

În primul pas, am creat fișierele pe care trebuie să le copiam pe serverul nostru FTP. Acum trebuie să le copiem într-un folder, pe care, la rândul său, îl vom trimite la FTP. Pentru a face acest lucru, puteți folosi o comandă simplă:

Copiați „PATH_TO_SOURCE_FOLDER\* C:\Backup\

Prin rularea acestei comenzi, toate fișierele noastre vor fi copiate în C:\Backup\. Îndeplini această comandă Are sens dacă vă colectați copiile de rezervă din diferite locuri. Acum avem nevoie de un script care va verifica folderul pentru fișiere noi și le va trimite la serverul FTP. Creați dosar gol backup.ps1 și scrieți următorul script în el.

$a = (Get-Host).UI.RawUI $a.WindowTitle = "Sync Folder To Ftp" $ftp = "ftp://АДРЕС_FTP_СЕРВЕРА/" $localDirectory = "C:\Backup" $user = "ИМЯ_ПОЛЬЗОВАТЕЛЯ" $pass = "ПАРОЛЬ" $webclient = New-Object System.Net.WebClient $webclient.Credentials = New-Object System.Net.NetworkCredential($user,$pass) $Files = Get-ChildItem $localDirectory | Where {$_.LastWriteTime -gt (Get-Date).AddDays(-1)} foreach ($File in $Files) { $LocalFile = $File.FullName Write-Host "Getting $File from $localDirectory" -Foreground "Red" $webclient.UploadFile($ftp + $File, $LocalFile) Write-Host "Puting $File to $ftp" -Foreground "Yellow" } Write-Host "Finished Sync to $ftp" -Foreground "Green" !}

Să vedem cum funcționează acest script. În primul rând, sunt setate variabile care indică serverul, numele de utilizator, parola și folderul sursă. Apoi, în linia $Files = Get-ChildItem $localDirectory | Unde ($_.LastWriteTime -gt (Get-Date).AddDays(-1)) selectează toate fișierele a căror dată de modificare este mai mare (-qt) decât data curentă minus 1 zi. Aici îl puteți ajusta în funcție de programul dvs. Fac copii de siguranță în fiecare zi. Apoi, în buclă, parcurgem fiecare fișier care îndeplinește condițiile și îl trimitem către serverul FTP.

Pentru a nu ocupa spațiu pe disc, șterg copiile de rezervă mai vechi de 30 de zile. În principiu, după ce le-ai trimis pe FTP, le poți șterge imediat, le las doar pentru ca dacă ai nevoie brusc de ele, să nu mai pierd timpul descarcându-le de pe FTP, iar o copie suplimentară a backup-urilor nu ar strica , nu știi niciodată ce s-ar putea întâmpla cu FTP, așa că, dacă spațiul tău îți permite, recomand să le stocezi și pe serverul original.

Pentru a curăța folderul, folosesc scriptul removeOldBackups.ps1

$fullTargetPath = "C:\Backup" $deleteFiles = Get-Childitem $fullTargetPath -Recurse | Unde ($_.LastWriteTime -lt (Get-Date).AddDays(-30)) | Foreach ( Remove-Item $_.FullName -Force -Recurse)

Un script extrem de simplu, voi explica doar o singură linie Where ($_.LastWriteTime -lt (Get-Date).AddDays(-30)) | Această linie compară data modificării fișierului cu data curentă minus 30 de zile; această comparație va include fișierele a căror LastWriteTime este mai mică decât data curentă minus 30 de zile. Dacă este necesar, îl puteți ajusta în funcție de nevoile dvs.

Faceți backup pentru informațiile importante - toată lumea Administrator de sistem se confruntă cu această provocare. Sarcina ar părea banală și nu va trezi interesul multor cititori. Dar, de exemplu, un astfel de articol m-ar ajuta foarte mult la un moment dat, așa că cred că acest articol ar trebui să existe.

Sarcină: Copia de rezerva a datelor la un director local și la un server separat, folosind minim software de la terți, logând și anunțând administratorul în Jabber în caz de eșec. Toate funcțiile de bază ale majorității software-ului de backup automat, dar fără a-l instala și, prin urmare, fără erorile sale (care, de fapt, au condus la această idee).

Acum să trecem la treabă.

Mai întâi, să creăm și să deschidem un script
nano backup-script
Acum să adăugăm linia la script
#!/bin/bash
Să declarăm câteva variabile.
TN - TASKNAME - numele sarcinii. Folosit pentru a ieși în jurnal și pentru a determina numele fișierului.
Deoarece sunt mai multe sarcini (lunare, săptămânale, zilnice) și mi-a fost prea lene să scriu un script pentru fiecare caz, am creat unul universal în care trebuie doar să decomentezi rândurile necesare. Numele sarcinilor trebuie scrise fără spații, de preferință în latină, dacă nu doriți probleme cu codificarea și parametrii de comandă incorecți.
TN=docs-lunar
#TN=docs-săptămânal
#TN=docs-zilnic
OF - Fișier de ieșire - numele fișierului de ieșire. Obținut din variabila TN, adică numele jobului.
OF=$TN.tar.gz
Declarăm o variabilă cu calea către fișierul jurnal și apoi toate mesajele de eroare și alte lucruri vor fi afișate în jurnal.
LOGFILE=/var/log/backup.log
Să facem o intrare în jurnal despre începutul copiei de rezervă (data, ora, numele sarcinii)
echo >>$LOGFILE echo "============================================ ============== ==========" >>$LOGFILE ecou "$(data +"%d-%b-%Y %R")" > >$LOGFILE echo „Sarcina \"$TN\" a început... >>$LOGFILE
Există o problemă că, dacă specificați nume de directoare cu spații în parametrii comenzii (de exemplu tar), scriptul va eșua. Soluția a fost găsită pe Internet - sala de operație sistem linux folosește spațiul ca separator standard al parametrilor de comandă. Să redefinim separatorul standard (stocat în variabila $IFS) ca altceva decât un spațiu, de exemplu \n ca o întrerupere de linie.
Amintiți-vă de vechea valoare a separatorului standard
OLD_IFS=$IFS
Înlocuiți separatorul standard cu al dumneavoastră
IFS=$"\n"
SRCD - Director sursă - director cu date de rezervă
Acum puteți enumera mai multe directoare, separatorul va fi întreruperi de linie, așa cum am indicat noi înșine în rândul de mai sus
SRCD="/mnt/source/folder_1 /mnt/source/folder_2 /mnt/source/folder_N"
TGTD - TarGeT Directory - directorul în care vor fi stocate backup-urile
TGTD="/var/backups/"
Desigur, înțelegem că stocarea copiilor de rezervă importante doar la sursă este cel puțin frivolă. Prin urmare, vom lăsa o copie pe resursa de la distanță, pe care o vom monta separat folosind mount și fstab. Voi explica imediat de ce am folosit mount și fstab, și nu doar mount - montez acest director în celelalte scripturi ale mele și, așa cum a spus unul dintre prietenii mei programatori - bun programator nu voi scrie același cod de două ori (cumva, nu îmi amintesc literal, dar sper că am înțeles sensul).
TGTD2="/mnt/archive/"
Procesul de arhivare în sine în opțiunea „Creare”. arhiva noua"
tar -czf $TGTD$OF $SRCD &>>$LOGFILE
și în opțiunea „Actualizați fișierele din arhiva veche”
tar -u -f $TGTD$OF $SRCD &>>$LOGFILE
În al doilea caz, este mai bine să folosiți un anumit nume de fișier în loc de $OF deoarece, de exemplu, arhiva mea săptămânală este actualizată zilnic, iar $TN (numele sarcinilor) lor nu se potrivesc și, prin urmare, $OF.

În variabila "?" Starea de execuție a ultimei comenzi este distrusă. Să-l salvăm pentru a-l folosi mai târziu.
STARE=$?
Restituirea separatorului standard la valoarea sa inițială
IFS=$OLD_IFS
Acum să adăugăm o condiție - dacă procesul de ambalare este în arhiva tar s-a încheiat cu o eroare, trimiteți un mesaj administratorului, ștergeți fișierul de rezervă nereușit. În caz contrar, continuăm mai departe - montem o partajare de rețea și aruncăm o copie a arhivei în ea. După fiecare operație, verificăm rezultatul execuției, scriem jurnalele și fie continuăm, fie anunțăm administratorul și întrerupem procedura.
dacă [[ $STATUS != 0 ]]; apoi rm $TGTD$OF &>>$LOGFILE ecou „############################################################## ######" >>$LOGFILE echo "### A apărut o eroare! Backup-ul a eșuat. ###" >>$LOGFILE echo "################ # ###########################" >>$LOGFILE echo "$(data +"%d-%b-%Y % R%nFișier ") Backup $OF nu a fost creat" | sendxmpp -t -f /usr/local/etc/XMPP_settings recipient_login@domain &>>$LOGFILE else echo „Fișierul de rezervă a fost salvat ca \”$TGTD$OF\”” >>$LOGFILE echo „Copia de rezervă a fost finalizată cu succes la $(data +"%R %d-%b-%Y")!" >>$LOGFILE echo "Montarea sistemului de fișiere pentru arhiva de rezervă $TGTD_archive" >>$LOGFILE montează $TGTD2 &>>$LOGFILE dacă [[ $? != 0 ]]; apoi ecou „############################################### ##############" >>$LOGFILE echo "### A apărut o eroare la montarea resursei de rezervă ###" >>$LOGFILE echo "######## ## ################################################ ## #" >>$LOGFILE echo "$(data +"%d-%b-%Y %R%nFile") al backupului $OF nu a fost copiat în resursa de rezervă" | sendxmpp -t -f /usr/local/etc/XMPP_settings recipient_login@domain &>>$LOGFILE exit fi echo „Copierea fișierului în resursa de rezervă a început” >>$LOGFILE cp -f $TGTD$OF $TGTD_archive$OF &>> $LOGFILE dacă [[ $? != 0 ]]; apoi ecou „############################################### ##############" >>$LOGFILE echo "### A apărut o eroare la copierea în resursa de rezervă ###" >>$LOGFILE echo "####### ## ################################################ ## ##" >>$LOGFILE echo "$(data +"%d-%b-%Y %R%nFile") a copiei de rezervă $OF nu a fost copiată în resursa de rezervă" | sendxmpp -t -f /usr/local/etc/XMPP_settings recipient_login@domain &>>$LOGFILE else echo „Copierea fișierului a fost finalizată cu succes la $(data +"%R %d-%b-%Y")!" >>$LOGFILE echo "Fișier copiat ca \"$TGTD_archive$OF\"" >>$LOGFILE fi echo "Demontarea sistemului de fișiere pentru arhiva de rezervă $TGTD_archive" >>$LOGFILE umount $TGTD2 &>>$LOGFILE echo " Toate operațiunile au fost finalizate cu succes!” >>$LOGFILE fi ieșire

În acest proces, copiem arhiva din stocarea locală în cea de la distanță. Desigur, verificăm că fiecare operațiune a fost finalizată cu succes și scriem totul în jurnalele.
Pentru a trimite un mesaj administratorului, folosesc un mesaj XMPP, deoarece organizația are un server Jabber și prefer să primesc mesaj rapid despre un eșec, mai degrabă decât să intru în e-mailul meu, să scriu parole, să dau clic pe linkuri și să aștept ca browserul să-mi afișeze totul. În orice caz, nimeni nu vă împiedică să utilizați sendmail în loc de sendxmpp.
Fișierul /usr/local/etc/XMPP_settings conține următoarele:

#sender_login@domain;jabber_server_IP:jabber_server_port sender_password login@domen;127.0.0.1:5222 parola
ÎN fișier fstab un șir care descrie conexiunea la partajările Windows
//192.168.0.250/arhiv /mnt/archive cifs noauto,rw,iocharset=utf8,cp866,file_mod=0666,dir_mod=0777,noexec,_netdev,credentials=/root/.passwd_to_archive_directory 0 0
Acum tot ce rămâne este să adăugați jobul la cron. Acest lucru se poate face folosind fișierul /etc/crontab, dar datorită obiceiului meu de GUI, moștenit de la Windows, folosesc interfețe web pentru astfel de cazuri. Comanda trebuie executată cu drepturi root, adică, de exemplu, sudo bash backup_script. Adăugând o comandă la cron, puteți determina că va fi imediat executată ca root

În timpul discuțiilor s-a pus problema creșterii buștenilor. Am urmat calea cea mai simplă (după părerea mea): vom stoca doar ultimele N linii ale jurnalului, de exemplu 300. Două linii vor fi adăugate la script, în care vom salva ultimele 300 de linii ale jurnalului într-un fișier temporar, apoi vom șterge jurnalul cu acesta
coada -n 300 $LOGFILE >/tmp/unique_fantastic_filename.tmp mv -f /tmp/unique_fantastic_filename.tmp $LOGFILE
Iată textul integral al scenariului:
#!/bin/bash TN=docs-monthly #TN=docs-weekly #TN=docs-daily OF=$TN.tar.gz LOGFILE=/var/log/backup.log echo >>$LOGFILE echo "== ==================================================== === =" >>$LOGFILE echo "$(data +"%d-%b-%Y %R")" >>$LOGFILE echo "Sarcina \"$TN\" a început..." >>$ LOGFILE OLD_IFS= $IFS IFS=$"\n" SRCD="/mnt/source/folder_1 /mnt/source/folder_2 /mnt/source/folder_N" TGTD="/var/backups/" TGTD2="/mnt/archive /" tar -czf $TGTD$OF $SRCD &>>$LOGFILE #tar -u -f $TGTD$OF $SRCD &>>$LOGFILE STATUS=$? IFS=$OLD_IFS dacă [[ $STATUS != 0 ]]; apoi rm $TGTD$OF &>>$LOGFILE ecou „############################################################## ######" >>$LOGFILE echo "### A apărut o eroare! Backup-ul a eșuat. ###" >>$LOGFILE echo "################ # ###########################" >>$LOGFILE echo "$(data +"%d-%b-%Y % R%nFișier ") Backup $OF nu a fost creat" | sendxmpp -t -f /usr/local/etc/XMPP_settings recipient_login@domain &>>$LOGFILE else echo „Fișierul de rezervă a fost salvat ca \”$TGTD$OF\”” >>$LOGFILE echo „Copia de rezervă a fost finalizată cu succes la $(data +"%R %d-%b-%Y")!" >>$LOGFILE echo "Montarea sistemului de fișiere pentru arhiva de rezervă $TGTD_archive" >>$LOGFILE montează $TGTD2 &>>$LOGFILE dacă [[ $? != 0 ]]; apoi ecou „############################################### ##############" >>$LOGFILE echo "### A apărut o eroare la montarea resursei de rezervă ###" >>$LOGFILE echo "######## ## ################################################ ## #" >>$LOGFILE echo "$(data +"%d-%b-%Y %R%nFile") al backupului $OF nu a fost copiat în resursa de rezervă" | sendxmpp -t -f /usr/local/etc/XMPP_settings recipient_login@domain &>>$LOGFILE exit fi echo „Copierea fișierului în resursa de rezervă a început” >>$LOGFILE cp -f $TGTD$OF $TGTD_archive$OF &>> $LOGFILE dacă [[ $? != 0 ]]; apoi ecou „############################################### ##############" >>$LOGFILE echo "### A apărut o eroare la copierea în resursa de rezervă ###" >>$LOGFILE echo "####### ## ################################################ ## ##" >>$LOGFILE echo "$(data +"%d-%b-%Y %R%nFile") a copiei de rezervă $OF nu a fost copiată în resursa de rezervă" | sendxmpp -t -f /usr/local/etc/XMPP_settings recipient_login@domain &>>$LOGFILE else echo „Copierea fișierului a fost finalizată cu succes la $(data +"%R %d-%b-%Y")!" >>$LOGFILE echo "Fișier copiat ca \"$TGTD_archive$OF\"" >>$LOGFILE fi echo "Demontarea sistemului de fișiere pentru arhiva de rezervă $TGTD_archive" >>$LOGFILE umount $TGTD2 &>>$LOGFILE echo " Toate operațiunile au fost finalizate cu succes!” >>$LOGFILE fi tail -n 300 $LOGFILE >/tmp/unique_fantastic_filename.tmp mv -f /tmp/unique_fantastic_filename.tmp $LOGFILE exit

Vă mulțumim tuturor pentru atenție!

Și așa, un scurt rezumat al cunoștințelor teoretice de care avem nevoie:

Puteți efectua copii de siguranță pe resursă de rețea sau la un volum separat. Copierea într-o partajare de rețea are un cuplu neajunsuri semnificative: în primul rând, dacă există probleme de rețea (în timp ce se execută arhivarea), siguranța dvs. de rezervă nu va fi creată, iar în al doilea rând, folderul de rețea poate conține doar o singură copie de rezervă (prin realizarea de copii de rezervă în același folder de rețea, ca și înainte, distrugeți backup anterior).

Copierea pe un volum separat se efectuează după cum urmează: folderul WindowsImageBackup\ este creat pe volumul țintă<Numele calculatorului>\. În acest folder, la rândul său, va fi creat discuri virtuale(câte unul pentru fiecare dintre volumele de rezervă), la care se va efectua backupul. La finalizarea copierii, starea discurilor virtuale care stochează copiile de rezervă va fi salvată folosind serviciul copiere umbră. Data viitoare când arhivați, vor fi efectuate aceleași acțiuni, rezultând ca fiecare arhivă specifică să fie disponibilă atunci când accesați o anumită copie umbră. Mai mult, din punct de vedere al programului de arhivare, fiecare astfel de arhivă va fi o arhivă completă, iar din punct de vedere al spațiului utilizat, aceasta va fi incrementală (copia shadow stochează informații doar despre blocurile de date modificate).

Informațiile despre procesul de arhivare finalizat sunt stocate în mai multe locuri în sistemul de operare, care se poate întâmpla să conțină informații inconsistente. Este clar că numărul real de copii de rezervă care sunt stocate local pe computer nu poate fi mai mare decât numărul de copii umbră ale volumului pe care a fost efectuată copia de rezervă. Puteți vizualiza informații despre numărul de copii umbră, de exemplu, în Linie de comanda folosind comanda umbra discului(și subcomenzile sale listează toate umbrele). In orice caz, copii umbră nu conțin suficiente informații necesare pentru a crea o listă de copii de rezervă, astfel încât aceste informații sunt preluate din alte locuri. Deci, de exemplu, sistemul de operare păstrează înregistrări copii de arhivăîn catalogul global de arhive, precum și în revistă evenimente Windows Jurnal de backup al serverului. Informațiile din aceste surse sunt afișate în snap-in-ul „Sistem de arhivare a datelor”. Windows Server" Ca urmare, poate apărea o situație ca echipamentul să ne arate informații contradictorii care nu au nicio legătură cu realitatea.

Uită-te la captura de ecran. A fost realizat într-un sistem pentru care disc local au fost stocate doar două arhive (au fost doar două copii umbră) și nu a fost creată o singură arhivă de rețea. Cu toate acestea, echipamentul ne spune în secțiunea „Toate arhivele” că se presupune că avem 6 arhive, iar în fereastra de mesaje vedem un raport despre crearea a doar 3 arhive. Pentru a forța sistemul de operare să afișeze informații consistente care să corespundă realității, va trebui să inițializam toate componentele sistemului de arhivare care stochează informații despre backup-urile sau despre backup-urile în sine. Pentru a face acest lucru, va trebui să ștergem jurnalul de backup din Windows, să ștergem directorul arhivei globale (folosind comanda wbadmin șterge catalogul) și ștergeți toate copiile umbră (folosind comanda diskshadow șterge toate umbrele). În general, informațiile stocate în backup Windows log, este de natură pur informațională și nu afectează în niciun fel procesul de restaurare a informațiilor din arhivă, dacă este necesar, ceea ce nu se poate spune despre informațiile stocate în catalogul global. Dacă catalogul global este deteriorat, atunci nu vom putea restaura informații folosind instrumente standard de arhivare a sistemului de operare Windows. Cu toate acestea, un catalog de arhivă globală deteriorat sau șters poate fi restaurat din copie de rezervă, care este creat de fiecare dată când se arhivează în folderul WindowsImageBackup\<Numele calculatorului>\. Pentru a restaura un catalog de arhivă globală deteriorat, trebuie mai întâi să-l ștergeți (folosind comanda wbadmin șterge catalogul), apoi restaurați din backup (folosind comanda catalogul de restaurare wbadmin).

Ei bine, acum, de fapt, voi publica scriptul de rezervă:

Scriere-Verbose „Start...” #Salvează valoarea variabilei de mediu $VerbosePreference $tmpVerbpref=$VerbosePreference $VerbosePreference="Continuare" #Cale către folderul de rețea în care vom copia arhiva $NetworkBackupPath="\\SRV66 \Backup$\SRV02 \BMR" #Numele partiției pe care vom crea arhiva $VolumeTarget="D:" # Numărul de copii de rezervă care trebuie salvate pe mediul local $BackupQuantity=3 # Numărul de copii de rezervă care trebuie să fie salvate pe stocarea de rețea $NetBackupQuantity=5 # Calea către fișierul listei de rezervă $csvFile="D:\Backup\ProfileBackup.csv" #Calea către folderul în care vom crea arhiva 7zip $Path2Arc="D: \Backup" # conectați programul de conectare Server Backup Add-PSSnapin Windows.Serverbackup -ErrorAction SilentlyContinue # creați o sarcină de rezervă $policy = New-WBPolicy<# # создаём и добавляем в задание бэкапа о бэкапируемых файлах $source = New-WBFileSpec -FileSpec "C:\Users" Add-WBFileSpec -Policy $policy -FileSpec $source #># #Get list of critic volumes $VolSources = Get-WBVolume -CriticalVolumes #Add volumes to be backed up Add-WBVolume -Policy $policy -Volume $VolSources #Define VSS Backup Options Set-WBVssBackupOptions -policy $Copy SystemBackups #Enable SystemBackups backup Add-WBSystemState -policy $policy #Activare Bare Metal Recovery Add-WBBareMetalRecovery -Policy $policy # # specificați volumul local în care arhiva va fi copiată $target = New-WBBackupTarget -VolumePath $VolumeTarget Add-WBBackupTarget -Policy -Target $target Scriere-Verbose „Începem procesul de creare a unei copii de rezervă” # efectuați o copie de rezervă Start-WBBackup -Policy $policy # verificați codul de returnare cu rezultatul copiei de rezervă dacă ((Get-WBSummary).LastBackupResultHR -eq 0) ( # redenumiți arhiva cu un nume mai prietenos $newname = "_Backup_$(Get-Date -f aaaaMMddHHmm)" Write-Verbose "Redenumiți folderul cu arhiva nou creată în $newname ..." Ren $VolumeTarget\ WindowsImageBackup -NewName $newname # Arhivați arhiva folosind 7zip $arc="C:\Program Files\7-Zip\7z.exe" $arc_params="a -t7z -m0=LZMA2 -mmt -mx9" $arc_source="$ VolumeTarget\$newname" $arc_dest="$Path2Arc \$newname.7z" Write-Verbose "Ambalați folderul $newname folosind 7zip în $newname.7z" Start-Process $arc -ArgumentList "$arc_params $arc_dest $arc_source" - Așteptați # copiați arhiva într-un folder de rețea #copy $VolumeTarget \$newname $NetworkBackupPath -Recurse Write-Verbose „Copiați fișierul $arc_dest în folderul de rețea...” copieți „$arc_dest” $NetworkBackupPath dacă ($?) ( #dacă copierea a fost finalizată fără erori, ștergeți fișierul arhivă și folderul care a fost împachetat în această arhivă del „$arc_dest” -Force -Verbose del $VolumeTarget\$newname -Recurse -Force #-Verbose ) # ștergeți arhivele vechi din folderul de rețea, excluzând cele mai recente arhive $BackupQuantity $NetBackups=dir $NetworkBackupPath | ?($_.Name -match „_.+(\d)+\.7z$”) $NetBackupsCount=$NetBackups.count dacă (($NetBackupsCount - $NetBackupQuantity) -gt 0) ( $NetBackups | sort lastwritetime | select -First ($NetBackupsCount - $NetBackupQuantity) | del -Force -Verbose #-Recurse -WhatIf ) # citiți propriul nostru director de rezervă $csv=@() if (Test-Path $csvFile) ($csv = @(Import- Csv $csvFile)) # citește datele despre cea mai recentă copie de rezervă $current = Get-WBBackupSet | selectați -Ultimul 1 | selectați VersionID, SnapshotId # și adăugați-l la matricea de obiecte ale backup-urilor existente $csv += $current # pentru a evita confuzia, sortați din nou obiectele și scrieți înapoi în fișierul CSV $csv | sortează @(Expresie=(($_.VersionId)))| selectați -Last $BackupQuantity | Export-Csv $csvFile -NoTypeInformation # și numărați câte înregistrări există $count = $csv.count # dacă există mai multe înregistrări BackupQuantity, apoi numărați câte arhive suplimentare trebuie șterse. # dacă există mai puține intrări BackupQuantity, atunci nu este nevoie să ștergeți nimic și să adăugați o nouă intrare dacă ($count -gt $BackupQuantity) ( $old = $count - $BackupQuantity # generează un nume aleatoriu pentru scriptul care va fi utilizat în diskshadow $file = : :GetRandomFileName() # selectați toate arhivele inutile și treceți-le prin conducta de ștergere $csv | sort @(Expression=(($_.VersionId)))| select -First $old | %( #Read-Host „Apăsați Enter pentru a continua...” | Out-Null #Write-Verbose $file ##Read-Host „Apăsați Enter pentru a continua...” | Out-Null # scrieți comanda într-un fișier temporar „ ștergeți ID-ul umbrelor ($($_.SnapshotID ))"|Out-File -FilePath $Env:TEMP\$file -Coding OEM #gc $Env:TEMP\$file #Read-Host "Apăsați Enter pentru a continua... " | Out-Null # și rulați diskshadow în modul script diskshadow /s $Env:TEMP\$file | Out-Default ) del $Env:TEMP\$file ) ) else ( # jură că backup-ul nu a fost finalizat cu succes Scrie- Verbose „Eroare la executarea copiei de rezervă” ) Scriere-Verbose „Scriptul s-a terminat de rulat” #Restabilirea valorii variabilei de mediu $VerbosePreference $VerbosePreference=$tmpVerbpref

Actualizat: 21.07.2017 Publicat: 15.08.2016

Acest script este scris în Unix Shell care rulează sistem de operare CentOS. Va funcționa pe majoritatea sistemelor Familiile Linuxși BSD.

Exemplu de script

Scriptul își va crea propriul dump pentru fiecare bază de date. Acest lucru este necesar pentru recuperare rapida date.

1. #!/bin/bash
2. PATH=/etc:/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin
3. destinație="/backup/mysql"
4. userDB="backup"
5. parolaDB="backup"
6. fdate=`data +%Y-%m-%d`
7. find $destination -type d \(-name "*-1[^5]" -o -name "*-?" \) -ctime +30 -exec rm -R () \; 2>&1
8. find $destination -type d -name "*-*" -ctime +180 -exec rm -R () \; 2>&1
9. mkdir $destinație/$fdate 2>&1
10. pentru dbname în `echo arata bazele de date| mysql -u$userDB -p$parolaDB | grep -v Baza de date`; do
11. caz $dbname în
12. information_schema)
13. continua ;;
14. mysql)
15. continua ;;
16. schema_performanței)
17. continua ;;
18. Test)
19. continua ;;
20. *) mysqldump --databases --skip-comments -u$userDB -p$passwordDB $dbname | gzip > $destinație/$fdate/$dbname.sql.gz ;;
21. Terminat;

Descrierea scriptului

Pregătirea sistemului

Conectați-vă la baza de date și creați cont cu dreptul de a crea copii de rezervă:

> GRANT SELECT, SHOW VIEW, RELOAD, REPLICATION CLIENT, EVENIMENT, TRIGGER, BLOCARE TABELE PE *.* LA backup@localhost IDENTIFICAT DE „backup”;

* în acest exemplu creăm un cont backup cu parola backup.

Creați un director în care vor fi stocate copiile de siguranță:

mkdir -p /backup/mysql

Salvarea datelor pe un computer la distanță

Backup-urile trebuie create pe computer la distanță sau unitate externă astfel încât acestea să fie disponibile dacă serverul eșuează. Acest exemplu folosește un folder partajat activat server la distanta, care va conține fișiere de rezervă.

Pentru a simplifica procesul de montare a unui folder de rețea, să deschidem următorul fișier pentru editare:

și adăugați următoarea linie la el:

//192.168.0.1/backup /mnt cifs user,rw,noauto,credentials=/root/.smbclient 0 0

* în acest exemplu, folderul partajat este montat backup pe un server cu o adresă IP 192.168.0.1 la catalog /mnt. Folosit ca sistem de fișiere de rețea cif(Protocol SMB: server samba sau folder partajat Windows). Parametrii de conectare - utilizator: permite oricărui utilizator să-l monteze, rw: cu permisiunea de citire și scriere, noauto: nu se montează automat la pornirea sistemului, acreditările: un fișier în care sunt scrise autentificarea și parola pentru conectarea la folderul partajat.

Acum să creăm un fișier cu autentificare și parolă:

# vi /root/.smbclient

și aduceți-l în următoarea formă:

username=backup
parola=backup

* nume de utilizator: Nume de utilizator, parola: parola. Desigur, în cazul dvs., indicați datele dvs.

Acum introduceți următoarea comandă.