Question Script de backup

Voici une petite contribution, un script de backup.
Je poste ici dans un premier temps, car loin d'être un pro, les spécialistes en powershell verront peut-être comment optimiser ce script.

Je l'ai conçu car il me manquait un \"juste milieu\" au niveau backup.
Le logiciel qu'on utilise dans mon entreprise est super complet, mais beaucoup trop usine à gaz.
Il existe pas mal de soft gratuits, mais pas forcément utilisable légalement en entreprise, ou pas assez complet.

Ce scipt nécessite 7Zip. Si un autre logiciel de zippage est utilisé, le script reste facilement modifiable.
Il faut aussi MySqlConnector, téléchargeable ici : dev.mysql.com/downloads/mirror.php?id=412152
Il faut également de quoi faire tourner une base MySql. Personellement j'ai utilisé WAMP dans un premier temps, et la ma base se trouve sur une machine linux.
(pour une base sur Linux, j'ai commenté la ligne bind-Address = 127.0.0.1 du fichier /etc/mysql/my.cnf)

Il prend en charge les chemins réseaux, type mon_serveurmon partage, voir attaquer un c$ si on a les droits.

Pour info, pour le SMTP, j'utilise une machine interne qui fait du relaying. Attention donc à votre conf !


J'ai 2 scripts : un grand avec toutes les fonctions, et un petit, qu'on clone/modifie pour y mettre les variables nécessaires. C'est le petit qui est utilisé via un BAT en tache planifiée pour démarrer le tout.
Il y a également un script ci-dessous pour créer la base \"vierge\" :


[code:1]
CREATE TABLE `contenu` (
`ID` int(11) NOT NULL auto_increment,
`IdBackup` int(11) NOT NULL,
`Nom` longtext NOT NULL,
`Extension` varchar(15) NOT NULL,
`Chemin` longtext NOT NULL,
`Poids` decimal(16,0) NOT NULL,
`Date` datetime NOT NULL,
PRIMARY KEY (`ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

CREATE TABLE `repertoire` (
`ID` int(11) NOT NULL auto_increment,
`BackupName` varchar(50) NOT NULL,
PRIMARY KEY (`ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

[/code:1]



Script appelé dans un .bat pour tache planifiée :
[code:1]
########################################################################################
#Points à respecter OBLIGATOIREMENT pour le bon fonctionnement du script :
#Le type de Backup -> Full ou Increment
#Le Name doit être IDENTIQUE entre vos full et vos increment
#Toujours mettre un \ pour finir les chemins source et destination
#Le type et les chemins doivent être entre \", mais PAS le délais.
#Le délais correspond à la durée de stockage de vos sauvegardes. Idi 30 veut dire 30 jours.
########################################################################################
. D:\Scripts\backup\Backup.PS1

CallBackup -type \"Full\" -Name \"Documents\" -CheminSource \"\\serveur\partage\dossier\\" -CheminDesti \"c:\backup\\" -Delais 30
[/code:1]



Script contenant toutes les fonctions nécessaire au processus de sauvegarde :
[code:1]
# Auteur : JA
# Date : 21/05/2013
# Version : 2.0
# V1 -> exploit XML
# V2 -> exploit MySql
# MaJ : 05/06/2013

#######################Paramétrages#######################
# Paramétrage Dossier
$Cheminscript = \"D:\scripts\backup\\"
$CheminLog = \"D:\scripts\backup\Erreurs\\"
#Déclaration 7Zip
set-alias sz \"C:\Program Files\7-Zip\7z.exe\"
#Date
$Date = (get-date).tostring(‘yyyyMMdd’)
$Heure = (get-date).tostring(‘HH:mm:«»ss’)
#####Informations relative à l'envoi de mail
$expediteur = \"no-reply@mondomaine.com\"
$serveur = \"xxx.xxx.xxx.xxx\"
$SMTPAuthUsername = \"no-reply@mondomaine.local\"
$SMTPAuthPassword = \"Mot_De_Passe\"
$SMTPclient = new-object System.Net.Mail.SmtpClient $serveur
$SMTPClient.Credentials = New-Object System.Net.NetworkCredential($SMTPAuthUsername, $SMTPAuthPassword)
#bibliothèque MySQL Connector /Net :
[void][System.Reflection.Assembly]::LoadWithPartialName(\"MySql.Data\"«»)
#Variables de connexion :
$port = \"3306\"
$srv= \"localhost\"
$user = \"root\"
$mdp = \"\"
$bdd = \"backup\"

function CallBackup($Type,$Name,$CheminSource,$CheminDesti,$Delais)
{
function Mail($RapportZip,$Name,$PJ,$objetMail,$TexteMail)
{
foreach ($email1 in ${D:\scripts\backup\mail.txt})
{
$destinataire = \"$email1\"
$objet = $objetMail
$texte = $TexteMail
$texte = $texte | foreach { $_;\"<BR \>\" }
$message = new-object System.Net.Mail.MailMessage $expediteur, $destinataire, $objet, $texte
$message.isbodyhtml = $True
$attachment = new-object System.Net.Mail.Attachment $PJ
$message.Attachments.Add($attachment)
$SMTPclient.Send($message)
}
}

function Zippage($selectionExtension,$DateBackup,$NomFichiersASauver,$RapportZip)
{
$SplitName = Split-Path $NomFichiersASauver -noQualifier #On enlève le C:\ du chemin trouvé, si présent
$SplitParent = Split-Path $SplitName -Parent #On enlève le nom du fichier
if ($selectionExtension -eq \".zip\" -or $selectionExtension -eq \".rar\" -or $selectionExtension -eq \".7z\" -or $selectionExtension -eq \".iso\"«»)
{
$backup = $DateBackup + $SplitParent + \"\\"
xcopy $NomFichiersASauver $backup /C /Y
}
#S'il n'est pas compressé, on le zip et on l'envoi dans son dossier de destination
else
{
$zip = $DateBackup + $SplitName + \".zip\"
sz a -tzip $Zip $NomFichiersASauver >> $RapportZip
}
}

function BackupDiff($FichiersASauver,$DateBackup,$Journal,$ID)
{
\"Début du travail INCREMENT le \" + (get-date).tostring(‘dd-MM-yyyy’) + \" à \" + (get-date).tostring(‘HH:mm:«»ss’) >> $Journal

#On liste tout ce qui se trouve dans la base
$RequeteSelectContenu = \"select * from contenu\"
$command = New-Object MySql.Data.MySqlClient.MySqlCommand($RequeteSelectContenu, $connection)
$dataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter($command)
$DataSet = new-object System.Data.DataSet
$DataAdapter.Fill($DataSet)
$tableauSQL = $DataSet.Tables[0].Rows
$CheminBdd = $tableauSQL.chemin

#On met en variable le chemin Full des fichiers présents sur disque
$selectionDossier1 = $FichiersASauver.FullName

#On compare nos deux listes, Bdd et fichiers réels
$CompFullName = Compare-Object $selectionDossier1 $CheminBdd -includeequal

#Fichiers présents sur le disque mais pas dans la base -> à sauver intégralement
$CompFullNameAbsBdd = $CompFullName | where {$_.SideIndicator -eq '<='}
$CompFullNameAbsBddInputObject = $CompFullNameAbsBdd.InputObject
$CompFullNameAbsBddInfo = get-childitem $CompFullNameAbsBddInputObject
foreach ($file in $CompFullNameAbsBddInfo)
{
$selectionNom1 = $FichierBDD.Name
$selectionNom = $selectionNom1.Replace(\"'\", \"''\"«»)
$selectionExtension = $file.Extension
$selectionDossier1 = $file.FullName
$selectionDossier =$selectionDossier1.Replace('\', '\\').Replace(\"'\", \"''\"«»)
$selectionPoids = $file.length
$selectionDate = $file.LastWriteTime.tostring(‘yyyy-MM-dd HH:mm:«»ss’)
#On zippe ou on copie si déjà zippé
Zippage -selectionExtension $selectionExtension -DateBackup $DateBackup -NomFichiersASauver $selectionDossier1 -RapportZip $RapportZip
#On ajoute ensuite l'entrée dans le Bdd
$RequeteInsertContenu = \"INSERT INTO contenu(ID,IdBackup,Nom,Extension,Chemin,Poids,Date) VALUES('','$ID','$selectionNom','$selectionExtension','$selectionDossier','$selectionPoids','$selectionDate')\"
$command = New-Object MySql.Data.MySqlClient.MySqlCommand($RequeteInsertContenu, $connection)
$dataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter($command)
$DataSet = new-object System.Data.DataSet
$DataAdapter.Fill($DataSet)
$tableauSQL = $DataSet.Tables[0].Rows
\"J'ai ajouté $selectionDossier1\" >> $Journal
\"

---

\" >> $Journal
}

#Fichiers présents sur le disque ET dans la base
$CompFullNameEgal = $CompFullName | where {$_.SideIndicator -eq '=='} | select -exp InputObject

foreach ($file in $CompFullNameEgal)
{
$CompFullNameEgalDouble = $file.Replace('\', '\\').Replace(\"'\", \"''\"«»)

#Récup Info sur vrai fichier
$donnee = get-childitem $file
$selectionDate1 = $donnee.LastWritetime
$selectionDate = $selectionDate1.tostring(‘yyyy-MM-dd HH:mm:«»ss’)
#Recup Info dans BDD
$RequeteSelectContenuExistant = \"select * from contenu where chemin = '$CompFullNameEgalDouble'\"
$command = New-Object MySql.Data.MySqlClient.MySqlCommand($RequeteSelectContenuExistant, $connection)
$dataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter($command)
$DataSet = new-object System.Data.DataSet
$DataAdapter.Fill($DataSet)
$tableauSQL = $DataSet.Tables[0].Rows
$CheminBdd = $tableauSQL.Chemin
$DateBdd1 = $tableauSQL.date
$DateBdd = $DateBdd1.tostring(‘yyyy-MM-dd HH:mm:«»ss’)
if ($selectionDate -eq $DateBdd)
{
\"Je ne fais rien avec $file\"
}
else
{
#On zippe ou on copie si déjà zippé
Zippage -selectionExtension $selectionExtension -DateBackup $DateBackup -NomFichiersASauver $file -RapportZip $RapportZip
#On met la base à jour
$RequeteUpdateDate = \"update contenu SET date = '$selectionDate' WHERE chemin = '$CheminBdd'\"
$command = New-Object MySql.Data.MySqlClient.MySqlCommand($RequeteUpdateDate, $connection)
$dataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter($command)
$DataSet = new-object System.Data.DataSet
$DataAdapter.Fill($DataSet)
$tableauSQL = $DataSet.Tables[0].Rows
\"J'ai modifié $file\" >> $Journal
\"

---

\" >> $Journal
}
}

\"Fin du travail INCREMENT le \" + (get-date).tostring(‘dd-MM-yyyy’) + \" à \" + (get-date).tostring(‘HH:mm:«»ss’) >> $Journal
}

function BackupFull($FichiersASauver,$DateBackup,$Journal,$ID)
{
\"Debut du travail FULL le \" + (get-date).tostring(‘dd-MM-yyyy’) + \" à \" + (get-date).tostring(‘HH:mm:«»ss’) >> $Journal
\"On vide d'abord l'ancienne base à \" + (get-date).tostring(‘HH:mm:«»ss’) >> $Journal
\"

---

\" >> $Journal
#vider la base avant chaque FULL
$RequeteDeleteContenu = \"DELETE FROM contenu where IdBackup = '$ID'\"
$command = New-Object MySql.Data.MySqlClient.MySqlCommand($RequeteDeleteContenu, $connection)
$dataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter($command)
$DataSet = new-object System.Data.DataSet
$DataAdapter.Fill($DataSet)
$tableauSQL = $DataSet.Tables[0].Rows

#Remplissage de la BDD :
\"On rempli la base avec les données actuelles à \" + (get-date).tostring(‘HH:mm:«»ss’) >> $Journal
\"

---

\" >> $Journal
foreach ($FichierBDD in $FichiersASauver)
{
#On met en variable le nom, l'extention, lechemin, le poids et la date de derniere écriture
$selectionNom1 = $FichierBDD.Name
$selectionNom = $selectionNom1.Replace(\"'\", \"''\"«»)
$selectionExtension = $FichierBDD.Extension
$selectionDossier1 = $FichierBDD.FullName
$selectionDossier =$selectionDossier1.Replace('\', '\\').Replace(\"'\", \"''\"«»)
$selectionPoids = $FichierBDD.length
$selectionDate = $FichierBDD.LastWriteTime.tostring(‘yyyy-MM-dd HH:mm:«»ss’)
#On zippe ou on copie si déjà zippé
Zippage -selectionExtension $selectionExtension -DateBackup $DateBackup -NomFichiersASauver $selectionDossier1 -RapportZip $RapportZip
#On ajoute ensuite l'entrée dans la BDD
$RequeteInsertContenu = \"INSERT INTO contenu(ID,IdBackup,Nom,Extension,Chemin,Poids,Date) VALUES('','$ID','$selectionNom','$selectionExtension','$selectionDossier','$selectionPoids','$selectionDate')\"
$command = New-Object MySql.Data.MySqlClient.MySqlCommand($RequeteInsertContenu, $connection)
$dataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter($command)
$DataSet = new-object System.Data.DataSet
$DataAdapter.Fill($DataSet)
$tableauSQL = $DataSet.Tables[0].Rows
}

\"Fin du travail FULL le \" + (get-date).tostring(‘dd-MM-yyyy’) + \" à \" + (get-date).tostring(‘HH:mm:«»ss’) >> $Journal
}

function Action($Delais,$cheminDesti,$CheminSource,$Type,$Name,$FichiersASauver,$Journal)
{
#Creation du dossier de sauvegarde, daté du jour
$CheminDestination = $cheminDesti + $Type + \"\\"
$DateBackup = $CheminDestination + $date
if(!(test-path -path \"$DateBackup\"«»))
{
md $DateBackup
\"Création du dossier $DateBackup\" >> $Journal
\"

---

\" >> $Journal
\"

---

\" >> $Journal
}

#Mise en variable de la date de fin d'ancienneté des sauvegardes
$DateDelais = (get-date).AddDays(-$Delais).tostring(‘yyyyMMdd’)
[int]$DateDelaisInt = $DateDelais

#Suppression des backups plus anciens que le délais indiqué
$Asupprimer = ls $CheminDestination
foreach ($ListeASuppr in $Asupprimer)
{
[int]$ListeASupprInt = $ListeASuppr.name
$DossierAsupprimer = $CheminDestination + $ListeASuppr
if($ListeASupprInt -lt $DateDelaisInt)
{
\"Suppression du backup $DossierAsupprimer \" >> $Journal
\"

---

\" >> $Journal
\"

---

\" >> $Journal
Remove-Item -recurse $DossierAsupprimer -force
}
}

#On lance la connexion à la BDD :
$connection = New-Object MySql.Data.MySqlClient.MySqlConnection
$connection.ConnectionString = “server=$srv;port=$port;uid=$user;pwd=$mdp;database=$bdd;Pooling=False”
$connection.Open()

#On vérifie si le nom de la sauvegarde existe bien en base
$RequeteVerifNom = \"select * from repertoire where backupname = '$Name'\"
$command = New-Object MySql.Data.MySqlClient.MySqlCommand($RequeteVerifNom, $connection)
$dataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter($command)
$DataSet = new-object System.Data.DataSet
$DataAdapter.Fill($DataSet)
$tableauSQL = $DataSet.Tables[0].Rows
$SelectExist = $tableauSQL.BackupName
#\"Nom select : $SelectExist - nom manuel : $Name\"
#S'il existe déjà, on note seulement l'ID
if (!($selectExist -eq $Name))
{
\"$Name n'existe pas dans la BDD, on le rajoute\" >> $Journal
\"

---

\" >> $Journal
\"

---

\" >> $Journal
$RequeteInsertRepertoire = \"INSERT INTO repertoire(ID,BackupName) VALUES('','$Name')\"
$command = New-Object MySql.Data.MySqlClient.MySqlCommand($RequeteInsertRepertoire, $connection)
$dataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter($command)
$DataSet = new-object System.Data.DataSet
$DataAdapter.Fill($DataSet)
$tableauSQL = $DataSet.Tables[0].Rows
}

#Mise en variable de l'ID
$RequeteSelectRepertoire = \"select * from repertoire where repertoire.backupname = '$Name'\"
$command = New-Object MySql.Data.MySqlClient.MySqlCommand($RequeteSelectRepertoire, $connection)
$dataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter($command)
$DataSet = new-object System.Data.DataSet
$DataAdapter.Fill($DataSet)
$tableauSQL = $DataSet.Tables[0].Rows
$ID = $tableauSQL.ID

#Selon le type de backup demandé -> appel de la fonction.
if ($type -eq \"Full\"«»)
{
BackupFull -FichiersASauver $FichiersASauver -DateBackup $DateBackup -Journal $Journal -ID $ID
}
else
{
BackupDiff -FichiersASauver $FichiersASauver -DateBackup $DateBackup -Journal $Journal -ID $ID
}

#Création d'un fichier texte avec les éventuelles erreurs.
$Erreur = $Cheminscript + \"Erreurs\erreur_\" + $Type +\"_\" + $Name + \"_\" + $Date + \"_\" + (get-date).tostring(‘HH.mm.ss’) + \".txt\"
Get-Content -Path $RapportZip | Select-String \"Le processus ne peut pas accéder\" > $Erreur
$var = Get-Item $Erreur
$Warning = $var.length
if ($Warning -gt \"0\"«»)
{
#Envoi du mail s'il y a eu des erreurs
$objetErreur = \"Rapport d'erreurs de la sauvegarde $Type de $Name, le $Date à $Heure\"
mail -RapportZip $RapportZip -name $Name -PJ $Erreur -objetMail $objetErreur
}
else
{
del $Erreur
}
}

function Verif($CheminSource,$CheminDesti,$Journal,$Name)
{
\"Début du travail le \" + (get-date).tostring(‘dd-MM-yyyy’) + \" à \" + (get-date).tostring(‘HH:mm:«»ss’) > $Journal
\"\" >> $Journal
\"

---

\" >> $Journal
\"

---

\" >> $Journal
\"

---

\" >> $Journal
\"\" >> $Journal

if ((-not (test-Path ($CheminSource))) -or (-not (test-Path ($CheminDesti))))
{
\"Je ne lance pas la sauvegarde, le dossier $CheminSource ou $CheminDesti n'existe pas\" >> $Journal
\"

---

\" >> $Journal
$objetSource = \"Sauvegarde $Type de $Name non faite le $Date à $Heure\"
$TexteSource = \"Je ne lance pas la sauvegarde, le dossier $CheminSource ou $CheminDesti n'existe pas\"
mail -RapportZip $RapportZip -name $Name -PJ $Journal -objetMail $objetsource -TexteMail $Textesource
exit
}
else
{
Action -Delais $Delais -cheminDesti $cheminDesti -CheminSource $CheminSource -Type $Type -Name $Name -FichiersASauver $FichiersASauver -Journal $Journal
}
}

#conception des fichiers texte
$Journal = $Cheminscript + \"journal\" + $Name + \".txt\"
$RapportZip = $Cheminscript + \"RapportZip\" + $Name + \".txt\"
#suppression des vieux journaux
if ($Journal) {del $Journal} else {\"pas de journal existant\"}
if ($RapportZip) {del $RapportZip} else {\"pas de RapportZip existant\"}
#Supression des vieux journaux d'erreurs
$datefullLog = (get-date).AddDays(-$Delais)
cd $cheminLog #On se place dans le bon dossier
Get-ChildItem | Where-Object { $_.CreationTime.date -lt $datefullLog} | foreach {Remove-Item -Recurse $CheminLog$_ -force} #On supprimer les dossiers antérieurs au délais choisi

#Mise en variable du listing des fichiers et dossiers à sauver
$FichiersASauver = get-childitem $CheminSource -recurse -force | where {!$_.PSIsContainer}

#Vérification des données passées en variable par l'utilisateur
Verif -CheminSource $CheminSource -CheminDesti $CheminDesti -Journal $Journal -Name $Name
}

#############Fin du script###############
[/code:1]


Cdt,

zedd

Message édité par: Zedd, à: 5/06/13 11:22

Message édité par: Zedd, à: 5/06/13 11:28<br><br>Message édité par: Zedd, à: 5/06/13 14:38

Ben voila, il suffit de poster pour s'apercevoir des boulettes

Premier bug : Le fichier Listing.xml porte toujours ce nom. Pas pratique quand on veut sauver des sources différentes. Je corrige ca et j'édite le post original.

Cdt,

zedd

Voila, pb corrigé, script du post initial mis à jour.

Cdt,

Zedd

Bonjour,

Deux petites corrections apportées.
Selon le système, le formatage des dates pouvait poser problème. J'ai corrigé ça.
Aussi un bug dans la partie incrémentielle, corrigée.

Le post initial a été mis à jour.

Cdt,
Zedd

Avec un peu de recul, je m'aperçois que le process d'une incrémentielle est super long (la comparaison entre le XML et les propriétés actuelles des fichiers scannés).

Auriez-vous une idée de comment améliorer ça ?

cdt,

zedd

Bonjour,

Pour le problème de perf, je tente de remplacer le XML par une Bdd MySql, histoire de voir si c'est plus rapide.

J'ai un \&quot;léger\&quot; problème.. Il semblerait que je doive doubler les backslash dans les chemins, genre C:\\toto\\toto.xls au lieu de C:\toto\toto.xls, car la BDD n'aime pas les \&quot;\\&quot;

si vous avez une bonne idée la dessus, et si votre clic est plus rapide que ma recherche google, vous êtes les bienvenus !

cdt,

Zedd

PS : il semblerait que ce forum non plus n'aime pas les backslash, je ne les vois pas apparaitre ici non plus <br><br>Message édité par: Zedd, à: 29/05/13 14:49