TOC

Comment automatiser des sauvegardes avec des espaces DigitalOcean

introduction

La sauvegarde des données importantes est un élément essentiel de la gestion de toute infrastructure informatique. Bien que les besoins de chacun soient différents en ce qui concerne les sauvegardes, il est recommandé de conserver les données de sauvegarde à un emplacement hors site.

L'envoi de copies de données à un emplacement hors site constituait un défi logistique majeur. Mais avec l'avènement des services de stockage basés sur le cloud comme Crashplan et Dropbox, ainsi que le développement de solutions de stockage d'objets commeDigitalOcean Spaces, c'est devenu une tâche beaucoup plus simple. Malgré cela, se rappeler de sauvegarder des fichiers et de prendre le temps de les télécharger peut toujours être un obstacle pour certains.

C'est pourquoi les utilisateurs choisissent d'utiliser divers outils pour effectuer des sauvegardes de routine et automatiques de leurs données importantes. Dans ce tutoriel, nous allons construire un script autour de l'outil de ligne de commandes3cmd qui peut être utilisé pour télécharger rapidement des données vers DigitalOcean Spaces. Nous utiliserons ensuitecrontab pour invoquer régulièrement le script de sauvegarde et télécharger des fichiers sur notre espace.

Conditions préalables

Pour ce tutoriel, vous aurez besoin de:

Avoir une certaine familiarité avec les scripts shell et le planificateur de travaux decronpeut également être utile. Pour des conseils et un contexte supplémentaire, envisagez de lire “https://www.digitalocean.com/community/tutorial_series/an-introduction-to-shell-scripting[An Introduction to Shell Scripting]” et “https: //www.digitalocean .com / communauté / didacticiels / procédures-de-planification-de-routine-avec-cron-et-anacron-on-vps [Comment planifier des tâches de routine avec Cron et Anacron sur un VPS]. ”

Avec nos conditions préalables en place, nous sommes prêts à commencer notre processus d’automatisation de la sauvegarde.

Construire notre script de sauvegarde

De nombreux outils peuvent être utilisés pour télécharger des fichiers de sauvegarde sur un service de stockage d’objets automatiquement et à intervalles réguliers. Cependant, ceux-ci peuvent être difficiles à configurer et peuvent ne pas offrir beaucoup de flexibilité. L'utilisation d'un simple script shell peut constituer une approche beaucoup plus élégante et simple d'automatisation des sauvegardes du stockage d'objets.

Pour ce tutoriel, nous allons écrire un script bash de base qui créera une sauvegarde d'un fichier ou d'un répertoire en utilisanttar. Le script téléchargera ensuite cette sauvegarde vers Spaces à l'aide de l'utilitaire de ligne de commandes3cmd.

Pour commencer, connectez-vous à votre Droplet et accédez à votre dossier personnel: 

cd ~

Une fois dans le dossier de départ, nous utiliseronsnano pour créer un fichier vide dans lequel nous pourrons écrire dans notre script: 

nano bkupscript.sh

Nous sommes maintenant prêts à commencer à écrire notre script de sauvegarde dans l'éditeur de texte. Au fur et à mesure que nous construirons le script, nous en expliquerons chaque partie dans l’ordre, section par section.

Initier notre script

À ce stade,bkupscript.sh n'est qu'un fichier texte vide. Pour que notre ordinateur appelle notre fichier exécutable sous forme de commandes, nous devons commencer notre script par un hashbang. Unhashbang est une directive d'interprétation qui permet d'exécuter des scripts ou des fichiers de données en tant que commandes.

Dans notre cas, le hashbang ressemblera à ceci:

bkupscript.sh

#!/bin/bash

En incluant cela en haut du script, nous demandons au shell d’exécuter les commandes du fichier en bash.

Déclaration de variables

Ensuite, nous indiquerons à notre script les variables qu’il devra connaître pour fonctionner correctement. Nous pouvons les ajouter directement sous le hashbang en haut du fichier texte:

bkupscript.sh

...
DATETIME=`date +%y%m%d-%H_%M_%S`
SRC=$1
DST=$2
GIVENNAME=$3

Voyons ce que nous attribuons à chacune de ces variables:

  • DATETIME: Cette variable contient un horodatage à apposer sur le nom de fichier résultant afin que chaque fichier sauvegardé dans notre espace ait un nom unique. Cet horodatage est créé en appelant la commandedate et en formatant la sortie pour afficher les deux derniers chiffres de l'année (%y), les deux chiffres du mois (%m), les deux chiffres du jour (%d), de l'heure (%H), des minutes (%M) et des secondes (%S).

  • SRC: il s'agit du cheminsource du fichier ou du dossier que nous voulons sauvegarder. Le$1 indique que nous prenons cette valeur du premier paramètre passé au script.

  • DST: cette variable représente lesdestination du fichier. Dans notre cas, il s’agit du nom de l’espace sur lequel nous téléchargeons la sauvegarde. Ce nom proviendra du deuxième paramètre passé au script comme indiqué par les$2.

  • GIVENNAME: cette variable héberge le nom choisi par l'utilisateur pour le fichier de destination. Le nom de fichier résultant commencera parGIVENNAME et aura lesDATETIME concaténés dessus. Ce nom provient du troisième paramètre passé au script ($3).

Fournir de l'aide

Lors de la rédaction d’un script, il est utile d’ajouter quelques astuces ou conseils généraux qui peuvent aider les utilisateurs à résoudre les problèmes qui surviennent si leur tentative d’utilisation échoue.

Pour notre script de sauvegarde, nous ajouterons une fonction appeléeshowhelp() sous nos variables. Ceci imprimera une série de messages pour aider les utilisateurs à résoudre les problèmes en cas d'échec du script. Lors de l'ajout d'une fonction dans bash, notre syntaxe ressemblera à ceci:

bkupscript.sh

...
showhelp(){

}

Cette fonction fournira des messages d’aide en reprenant une série d’instructions d’utilisation à l’écran. Chaque instruction doit être présentée comme une chaîne entourée de guillemets doubles. Vous remarquerez dans notre exemple ci-dessous que certaines des chaînes ont ou écrits à leur début ou à leur fin. Ce sont desescape characters qui fournissent des instructions spécifiques sur la manière dont la chaîne doit apparaître dans la sortie du script:

  • indique un espace de tabulation

  • indique un saut de ligne

N'hésitez pas à ajouter tous les détails d'utilisation qui vous seraient utiles entre les accolades (n'oubliez pas de faire précéder toute chaîne deecho). À des fins de démonstration, nous ajouterons les éléments suivants:

bkupscript.sh

echo "\n\n############################################"
echo "# bkupscript.sh                            #"
echo "############################################"
echo "\nThis script will backup files/folders into a single compressed file and will store it in the current folder."
echo "In order to work, this script needs the following three parameters in the listed order: "
echo "\t- The full path for the folder or file you want to backup."
echo "\t- The name of the Space where you want to store the backup at."
echo "\t- The name for the backup file (timestamp will be added to the beginning of the filename)\n"
echo "Example: sh bckupscript.sh ./testdir testSpace backupdata\n"<^>

La fonction finale deshowhelp devrait ressembler à ceci:

bkupscript.sh

...
showhelp(
        echo "\n\n############################################"
        echo "# bkupscript.sh                            #"
        echo "############################################"
        echo "\nThis script will backup files/folders into a single compressed file and will store it in the current folder."
        echo "In order to work, this script needs the following three parameters in the listed order: "
        echo "\t- The full path for the folder or file you want to backup."
        echo "\t- The name of the Space where you want to store the backup at."
        echo "\t- The name for the backup file (timestamp will be added to the beginning of the filename)\n"
        echo "Example: sh bckupscript.sh ./testdir testSpace backupdata\n"
}

Avec notre texte d'aide en place, nous pouvons passer à la collecte des fichiers que nous aimerions sauvegarder dans notre espace.

Rassembler des fichiers

Avant que notre script puisse transférer quoi que ce soit sur notre espace, il doit d'abord rassembler les bons fichiers et les regrouper dans un seul package à télécharger. Nous pouvons accomplir cela en utilisant l'utilitairetar et une instruction conditionnelle. Comme nous utilisonstar pour créer un fichier archive (parfois appelé fichier «zip»), nous appellerons cette fonctiontarandzip().

Commençons par déclarer la fonction et ajouter une autre commandeecho pour indiquer aux utilisateurs que le script a commencé à collecter des fichiers:

bkupscript.sh

...
tarandzip(){
    echo "\n##### Gathering files #####\n"
}

Sous la commandeecho, nous pouvons ajouter une commandetar qui fera le travail de collecte et de compression des fichiers dans un seul fichier de sortie.

bkupscript.sh

tarandzip(){
    echo "\n##### Gathering files #####\n"
    tar -czvf $GIVENNAME-$DATETIME.tar.gz $SRC
}

Vous remarquerez que cette commandetar est appelée avec plusieurs options et variables:

  • c: cet indicateur indique àtar de compresser le fichier de sortie.

  • z: Ceci demande àtar de compresser le fichier en utilisantgzip.

  • v: cela signifie l'optionverbose, qui demande àtar d'afficher plus d'informations dans la sortie.

  • f: cet indicateur demande àtar d'enregistrer le fichier avec le nom de fichier indiqué ensuite.

  • $GIVENNAME-$DATETIME.tar.gz: Le script appelle ces variables que nous avons déclarées au début afin de créer le nouveau nom de fichier. Il le fait en combinant les variables$GIVENNAME et$DATETIME et en ajoutant l'extension.tar.gz à la fin pour former le nouveau nom de fichier.

  • $SRC: Cette variable représente les fichiers ou dossierssource que nous demandons àtar de sauvegarder.

Cette fonction devrait maintenant être capable de faire ce que nous voulons, mais nous pouvons ajouter quelques appels de plus àecho pour donner à l'utilisateur des informations supplémentaires sur le fonctionnement du script. Cela peut être fait en ajoutant quelques instructions conditionnelles, comme ceci:

bkupscript.sh

    if tar -czvf $GIVENNAME-$DATETIME.tar.gz $SRC; then
        echo "\n##### Done gathering files #####\n"
        return 0
    else
        echo "\n##### Failed to gather files #####\n"
        return 1
    fi

Lorsque la clauseif est appelée, elle exécutera la commandetar et attendra le résultat. Si le résultat de la commande est positif (c'est-à-dire qu'elle s'est exécutée avec succès), les lignes entrethen etelse seront exécutées. Ceux-ci sont:

  • Faire écho à un message indiquant que le script a terminé avec succès le processustar

  • Renvoyer un code d'erreur de0 pour que la partie du code qui invoque cette fonction sache que tout a fonctionné correctement.

La partieelse de cette fonction ne sera exécutée que si la commandetar trouve une erreur lors de l'exécution. Dans ce cas, la brancheelse de la clause:

  • Écho un message indiquant que la commandetar a échoué

  • Renvoie un code d'erreur de1, indiquant que quelque chose s'est mal passé

Enfin, nous terminons la clauseif/then/else par unfi, ce qui en langage bash signifie que la clauseif est terminée.

La fonctiontarandzip() terminée ressemblera à ceci:

bkupscript.sh

tarandzip(){
    echo "\n##### Gathering files #####\n"
    if tar -czvf $GIVENNAME-$DATETIME.tar.gz $SRC; then
        echo "\n##### Done gathering files #####\n"
        return 0
    else
        echo "\n##### Failed to gather files #####\n"
        return 1
    fi
}

Avec notre fonctiontarandzip() en place, nous sommes prêts à configurer le script pour déplacer nos sauvegardes.

Transfert de fichiers vers un stockage d'objets

À ce stade, nous pouvons demander à notre script de sauvegarde de transférer un fichier vers notre espace en utilisant la commandes3cmd. Comme avectarandzip, nous pouvons aussiecho quelques chaînes et utiliser une instructionif/then/else pour tenir les utilisateurs au courant de la façon dont le script fonctionne pendant son exécution.

Nous allons d'abord déclarer notre fonction. Restons simple et nommez-lemovetoSpace():

bkupscript.sh

...
movetoSpace(){

}

Maintenant, nous pouvons utilisers3cmd et les variables que nous avons déclarées précédemment pour construire la commande qui va pousser nos fichiers de sauvegarde dans notre espace:

bkupscript.sh

movetoSpace(){
    ~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST
}

Voici ce que chaque partie de cette commande signifie:

  • ~/s3cmd-2.0.1/s3cmd: Ceci appelles3cmd, acommand line tool used for managing object storage buckets.

  • put: il s'agit d'une commande utilisée pars3cmd pour télécharger des données dans un compartiment.

  • $GIVENNAME-$DATETIME.tar.gz: C'est le nom de la sauvegarde qui sera téléchargée sur notre espace. Il se compose des quatrième et première variables que nous avons déclarées, suivies de.tar.gz, et est créé par la fonctiontarandzip() précédemment.

  • s3://$DST;: C'est l'emplacement où nous voulons télécharger le fichier. s3:// est un schéma de type URI utilisé spécifiquement pour décrire les emplacements de stockage d'objets en ligne, tandis que$DST; est la troisième variable que nous avons déclarée précédemment.

Nous avons maintenant une fonction qui permet de télécharger vos fichiers archivés dans notre espace. Cependant, il n’informe pas l’utilisateur de son statut. Modifions cela en faisant écho à une chaîne avant la commande pour que l’utilisateur sache qu’elle a été démarrée et, une fois la fonction terminée, pour nous indiquer si elle a abouti.

Commençons par informer l’utilisateur que le processus a commencé:

bkupscript.sh

movetoSpace(){
    echo “\n##### MOVING TO SPACE #####\n”
    ~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST
}

Étant donné que la commande réussira ou échouera (ce qui signifie qu'elle téléchargera les fichiers dans notre espace ou non), nous pouvons indiquer aux utilisateurs si cela a fonctionné en faisant écho à l'une des deux chaînes contenues dans unif/then/else déclaration, comme ceci:

bkupscript.sh

...
if ~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST; then
    echo "\n##### Done moving files to s3://"$DST" #####\n"
    return 0
else
    echo "\n##### Failed to move files to the Space #####\n"
    return 1
fi

Cette instruction conditionnelle dit à bash «Si notre commandes3cmd fonctionne correctement, alors faites savoir à l'utilisateur que le script a terminé de déplacer des fichiers vers notre espace. Sinon, informez l'utilisateur que le processus a échoué. ”

Si le processuss3cmd se termine avec succès, la fonction imprime un message à l'écran (la première chaîneecho dans l'instructionthen) l'indique et renvoie une valeur de0 , qui informe la fonction appelante que l'opération est terminée. Si le processus échoue, la clausethen imprime simplement le message d'erreur (la deuxième chaîneecho) et renvoie un1 pour que le reste du script sache qu'une erreur s'est produite.

Au total, la fonctionmovetoSpace() devrait ressembler à ceci:

bkupscript.sh

movetoSpace(){
    echo "\n##### MOVING TO SPACE #####\n"
    if ~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST; then
        echo "\n##### Done moving files to s3://"$DST" #####\n"
        return 0
    else
        echo "\n##### Failed to move files to the Space #####\n"
        return 1
    fi
}

Avec la fonctionmovetoSpace() écrite, nous pouvons passer à nous assurer que le script est configuré pour appeler les fonctions dans l'ordre attendu en utilisant des instructions conditionnelles pour le contrôle de flux.

Configuration du contrôle de flux

Bien que nous ayons configuré notre script avec des fonctions, nous n’avons pas fourni d’ordre pour que le script complète ces fonctions. À ce stade, nous pouvons introduire une fonction d’appel qui indiquera au reste du script comment et quand exécuter les autres fonctions que nous avons écrites.

En supposant que tout a été configuré correctement, lorsque nous exécutons le script, il doit lire la commande d'entrée, en attribuer les valeurs à chaque variable, exécuter la fonctiontarandzip(), et suivre cela avec la fonctionmovetoSpace(). Si le script échoue entre l'un de ces points, il doit imprimer la sortie de notre fonctionshowhelp() pour aider les utilisateurs à résoudre les problèmes. Nous pouvons commander ceci et attraper les erreurs en ajoutant une série d'instructionsif/then/else au bas du fichier:

bkupscript.sh

...
if [ ! -z "$GIVENNAME" ]; then
    if tarandzip; then
        movetoSpace
    else
        showhelp
    fi
else
    showhelp
fi

La première instructionif de la section ci-dessus vérifie que la troisième variable transmise n'est pas vide. Cela se fait de la manière suivante:

  • [ ]: les crochets indiquent que ce qui se trouve entre eux est untest. Dans ce cas, le test consiste à vérifier qu'une variable spécifique n'est pas vide.

  • !: Dans ce cas, ce symbole signifienot.

  • -z: cette option indique unempty string. Donc, combiné avec les!, nous demandons desnot an empty string.

  • $GIVENNAME: Nous indiquons ici que la chaîne que nous ne voulons pas être vide est la valeur affectée à la variable$GIVENNAME. La raison pour laquelle nous avons choisi cette approche est que la valeur transmise par le troisième paramètre est attribuée à cette variable lors de l'appel du script à partir de la ligne de commande. Si nous transmettons moins de 3 paramètres au script, le code n'aura pas de troisième paramètre pour attribuer la valeur à$GIVENNAME, il affectera donc une chaîne vide et ce test échouera.

En supposant que ce premier test réussit, il passera ensuite à l'instructionif suivante et ainsi de suite. Si l'une des instructionsif renvoie une erreur, la clausethen appellera la fonctionshowhelp et un texte d'aide sera affiché dans la sortie. Cela permet essentiellement de réunir toutes les fonctions précédentes que nous avons écrites et de fournir à bash les informations nécessaires pour les exécuter dans le bon ordre.

Notre script est maintenant complet! Vous pouvez vérifier que votre script ressemble au script complet que nous avons créé dans la section ci-dessous.

Le script complet

Le script de sauvegarde terminé que nous avons créé devrait ressembler à ceci:

bkupscript.sh

#!/bin/bash
DATETIME=`date +%y%m%d-%H_%M_%S`
SRC=$1
DST=$2
GIVENNAME=$3
showhelp(){
        echo "\n\n############################################"
        echo "# bkupscript.sh                            #"
        echo "############################################"
        echo "\nThis script will backup files/folders into a single compressed file and will store it in the current folder."
        echo "In order to work, this script needs the following three parameters in the listed order: "
        echo "\t- The full path for the folder or file you want to backup."
        echo "\t- The name of the Space where you want to store the backup at (not the url, just the name)."
        echo "\t- The name for the backup file (timestamp will be added to the beginning of the filename)\n"
        echo "Example: sh bkupscript.sh ./testdir testSpace backupdata\n"
}
tarandzip(){
    echo "\n##### Gathering files #####\n"
    if tar -czvf $GIVENNAME-$DATETIME.tar.gz $SRC; then
        echo "\n##### Done gathering files #####\n"
        return 0
    else
        echo "\n##### Failed to gather files #####\n"
        return 1
    fi
}
movetoSpace(){
    echo "\n##### MOVING TO SPACE #####\n"
    if ~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST; then
        echo "\n##### Done moving files to s3://"$DST" #####\n"
        return 0
    else
        echo "\n##### Failed to move files to the Space #####\n"
        return 1
    fi
}
if [ ! -z "$GIVENNAME" ]; then
    if tarandzip; then
        movetoSpace
    else
        showhelp
    fi
else
    showhelp
fi

Une fois que vous avez vérifié votre script, assurez-vous de sauvegarder et de fermer le fichier (CTRL-x,y, puisENTER) avant de quitter nano.

Test du script

Maintenant que nous avons fini de construire le script, nous pouvons maintenant le tester. Non seulement cela nous dira si nous avons écrit le script correctement, mais cela nous donnera également l'occasion de nous entraîner à utiliser le script et de le voir en action.

Lorsque vous testez un script comme celui-ci, il est généralement préférable d’utiliser des fichiers factices. Bien que nous sachions qu’il n’est pas capable de détruire ou de supprimer des données, il est judicieux de le faire en toute sécurité en le testant avec des fichiers sans importance. Nous allons d'abord créer un répertoire à l'aide de la commandemkdir: 

mkdir backupthis

Ensuite, nous allons créer deux fichiers vides dans ce répertoire en utilisanttouch: 

sudo touch backupthis/file1.txt
sudo touch backupthis/file2.txt

Nous pouvons maintenant tester le script en téléchargeant le répertoirebackupthis et son contenu dans notre espace. C'est le format que nous devrons utiliser pour appeler le script: 

sh bkupscript.sh ./backupthis name_of_your_space testrun

[.Remarque]##

Note Étant donné que la fonctionmovetoSpace() ajoute automatiquements3:// à la variable de destination (c'est-à-dire le nom de votre espace), cette variable doit simplement être le nom de votre espace et non son URL complète. Par exemple, si l'URL de votre espace est "https: //example-space-name.nyc3.digitaloceanspaces.com", vous écrirez la commande de test comme ceci: 

sh bkupscript.sh ./backupthis example-space-name testrun

La commande ci-dessus mettra le script en mouvement et vous devriez voir une sortie comme ceci: 

Output
##### Gathering files #####

./backupthis/
./backupthis/file1.txt
./backupthis/file2.txt

##### Done gathering files #####


##### MOVING TO SPACE #####

upload: 'testrun-180119-15_09_36.tar.gz' -> 's3://name_of_your_space /testrun-180119-15_09_36.tar.gz'  [1 of 1]
 162 of 162   100% in    8s    19.81 B/s  done

##### Done moving files to s3://name_of_your_space #####

Si vous rencontrez des erreurs, veuillez revoir votre script pour vous assurer qu'il correspond à notre exemple. Assurez-vous également que votre installation des3cmd a été correctement configurée et que la clé d'accès et la clé secrète que vous utilisez sont correctes.

Automatiser les sauvegardes avec Crontab

Après avoir testé avec succès le script de sauvegarde, nous pouvons configurer un travailcron qui utilisera le script pour effectuer des sauvegardes régulières sur notre espace. Pour les besoins de ce tutoriel, nous allons le configurer pour exécuter notre script de sauvegardes toutes les minutes.

Premièrement, nous devons rendre le script exécutable: 

chmod +x bkupscript.sh

Maintenant que le script peut être exécuté en tant que commande, nous pouvons éditer le fichiercrontab pour exécuter le script toutes les minutes: 

crontab -e

La première fois que vous exécutezcrontab -e, il vous demandera de sélectionner un éditeur dans une liste: 

no crontab for root - using an empty one
Select an editor.  To change later, run 'select-editor'.
  1. /bin/ed
  2. /bin/nano        <---- easiest
  3. /usr/bin/vim.basic
  4. /usr/bin/vim.tiny
Choose 1-4 [2]:

Vous pouvez sélectionner le nano par défaut ou un autre éditeur de texte de votre choix.

Une fois danscrontab, nous ajouterons la ligne suivante en bas des valeurs qui y sont déjà:

/tmp/crontab.example/crontab

* * * * * ~/bkupscript.sh ~/backupthis nameofyourspace cronupload

Pour enregistrer les modifications, appuyez surCTRL-x, puis sury, puis surENTER.

Après environ une minute, vous verrez un nouveau fichier dans le tableau de bord de votre espace!

Si vous laissez le travail decron en cours d'exécution sans apporter de modifications, un nouveau fichier sera copié dans votre espace toutes les minutes. Une fois que vous avez confirmé quecron s'exécute avec succès, n'hésitez pas à reconfigurercrontab pour sauvegarder vos fichiers à l'intervalle souhaité.

Vous avez maintenant un script qui compresse et expédie périodiquement vos sauvegardes dans un espace DigitalOcean!

Conclusion

Dans ce didacticiel, nous avons expliqué comment créer des sauvegardes hors site régulièrement planifiées de vos fichiers importants à l'aide d'un script bash, decrontab et d'espaces DigitalOcean. Bien que le script présenté dans ce didacticiel ne soit destiné qu'à des fins de démonstration, il peut être utilisé comme base pour créer une version prête pour la production qui pourrait ultérieurement être intégrée à une solution CI / CD commeJenkins,Drone ouTravis CI.

Si vous souhaitez en savoir plus sur les outils CI / CD, vous pouvez le faire en lisant les tutoriels suivants:

Related