kitoy/kitoy.me
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Ajout de la page contact

Browse Source
This commit is contained in:
kitoy
2021-01-13 01:55:57 +01:00
parent 8e9b399d6a
commit 72da558449
28 changed files with 450 additions and 2500 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
content/blog/Base de données.md Normal file
View File

@@ -0,0 +1,60 @@
+++
title = "Sauvegarder sa BDD et la restaurer"
date = 2020-04-14
description = "Exporter/Importer une base de données avec mariadb :sourire:"
template = "articles.html"
+++
### D'abord l'export:
L'outil s'appelle mysqldump il est installé avec mariadb-server.
Donc on peut d'abord lister les base données pour être sûr de celle
que l'on veut exporter ?
```bash
$ mysql -u root -p
MariaDB [(none)]> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| test1 |
| information_schema |
| mysql |
| nextcloud |
| performance_schema |
| test |
+--------------------+
```
Si par exemple on veut exporter la base nextcloud on tapera ceci
dans notre shell:
``` bash
$ mysqldump -u root -p nextcloud > nextcloud_export.sql
``````
### Importer sa base de données
Pour importer notre fichier on va devoir créer la base et l'utilisateur qui aura
les droits sur la base.
```bash
$ mysql -u root -p
MariaDB [(none)]> CREATE DATABASE nextcloud;
MariaDB [(none)]> CREATE USER nextbase IDENTIFIED BY 'example';
MariaDB [(none)]> GRANT ALL PRIVILEGES ON nextcloud.* TO nextbase;
MariaDB [(none)]> FLUSH PRIVILEGES;
MariaDB [(none)]> exit;
```
Si tout se passe bien normalement à la fin de chaque commande mysql
vous verrez un message Query OK ... , c'est que c'est bon :).
Maintenant on va pouvoir importer notre fichiers comme ceci :
``` bash
$ mysql -u nextbase -p nextcloud < nextcloud_export.sql
```
Si vous n'avez aucun message d'erreur, c'est fini !

85
content/blog/Les logiciels libres.md Normal file
View File

@@ -0,0 +1,85 @@
+++
template = "articles.html"
title = "Les logiciels libres"
description = "Pourquoi utiliser des logiciels libres"
date = 2017-01-29
+++
Bonjour chers lecteurs·trices, comme vous ne le savez peut-être
pas; j'utilise **et recommande** autant que faire se peut des logiciels libres.
Ces derniers répondent a quatre lois de bases qui ont des
conséquences pour les utilisateurs. A travers divers exemples, je tenterai
de vous faire comprendre l'intérêt qu'a la licence d'un programme.
### La liberté d'exécuter le logiciel pour n'importe quel usage.
En effet, certaines licences vous interdisent d'utiliser le
programme comme vous l'entendez, par exemple : Vous installer un
antivirus et au bout d'une période d'essai il ne fonctionne plus car
il faut **activer/acheter** la licence ( ils ont des termes j'vous jure).
Quand vous acheter un programme comme Microsoft office, on vous
permet de l’installer sur un nombres d’ordinateurs définis par
Microsoft. Souvent il s’agit d’un ordinateur, si vous avez un
ordinateur de bureau et un portable hé bien vous aurez 2 licences
à acheter. Simple et efficace mais pour qui ?
### La liberté d'étudier le fonctionnement d'un programme et de l'adapter à ses besoins.
Cela implique que le code source du programme doit vous
être fourni sur demande ou directement à l’achat ou téléchargement
du logiciel. On peut vérifier ce qu'un programme fait quand on
lis son code pas quand on vois ce qu'il fait… Un exemple concret, l’application
Flashlight qui a été présente sur le Playstore, les gens voyaient que le flash
s’allumait mais que leur coordonnées bancaire était envoyées sur un
ordinateur à travers Internet.
Cela reste un cas rare, mais des cas de vol d’informations personnelles envoyer
par des applications sans en avertir les utilisateurs est très répandu
par contre. Vous pouvez aller voir [ce
projet](https://exodus-privacy.eu.org/fr) pour vous en convaincre.
Il se peut aussi que le logiciel vous intéresse mais il n'est pas
adapté à vos besoins ou votre infrastructure. Avec le logiciel libre,
vous pouvez payer un développeur pour adapter le programme a vos besoins.
Et en informatique adapter des programmes existant c'est assez répandu.
D'autre part si vous êtes une boîte de développement cela vous donne
l'occasion de montrer votre savoir-faire.
### La liberté de redistribuer des copies.
Bon là tout le monde connaît et sait de quoi on parle … Sachez que
quand vous partagez une logiciel, par exemple une application d’un
jeux sur Android le simple fait de partager une paquet (.apk) avec
vos amis peut-être interdit. Mine de rien quand on sait que l'on est
en tord de partager un logiciel avec un amis ou quelqu'un qu'on aime
bien car on sait pertinament que ca ne fonctionnera, cela ne pousse
pas a l'entraide entre les gens dans une société.
### L'obligation de faire bénéficier à la communauté des versions modifiées.
Alors sur ce point un petite explication s'impose. Si vous modifiezun
programme et que vous le gardez pour vous, pas de problème.
Par contre si vous partagez/vendez ce logiciel, alors vous devez
fournir le code source modifié.
Il y a de multiples exemples où le logiciel libre a beaucoup
d'avantages, qui découlent de ces quatre libertés. Les effets sur
la société sont aussi important bien que cela demande un article
complet le logiciel libre prône plus des valeurs de partages que les
valeurs de la possession. La transparence de l’éditeur du logiciel
face aux bénéfices de l’éditeur envers ces utilisateurs.
### Mais qui a eu cette idée folle ?
Ce n'est pas Charlemagne mais Richard Stallman qui le
4 octobre 1985 fonde la FSF et officialise du coup le projet GNU rassemblant
tout les programmes essentiels pour avoir un système d'exploitation libre
créé un an avant.
Aujourd'hui la Fondation s'emploie à promouvoir et faire respecter sa
licence: la GPL (en version 3 a l'heure actuelle). Elle finance aussi divers
projets dans des domaines où le logiciel libre manque de solution. [Ça se passe ici](https://www.fsf.org/campaigns/priority-projects)
Voila ! c'est fini pour cet article j'espère qu'il vous aura
fait découvrir pas mal de choses.

7
content/blog/_index.md Normal file
View File

@@ -0,0 +1,7 @@
+++
title = "kitoy.me"
description = "Le blog"
paginate_by = 10
sort_by = "date"
template = "section.html"
+++

48
content/blog/plugins firefox.md Normal file
View File

@@ -0,0 +1,48 @@
+++
template = "articles.html"
title = "Quelques plugins pratiques pour firefox"
description = "Une liste de plugins firefox qui sont pour moi indispensables."
date = 2019-12-15
+++
[Mozilla Firefox](https://www.mozilla.org/fr/firefox/new/) a l’avantage d’avoir pas mal de plugins sympathiques,
parmi eux quelques classiques qui vous aiderons à éviter quelques
ennuies quand vous allez naviguer sur internet.
Parmi ces plugins, il y en qui sont important si vous voulez un peu
moins de publicitées sur internet(cookie) et une connexion sécurisé(https).
Le premier plugin c’est [ublock origin](https://addons.mozilla.org/fr/firefox/addon/ublock-origin/),
quand vous consultez une page web, il fait le tri et ne charge pas
certains éléments de la page (généralement les publicités).
Il a le mérite de se faire discret et simple sans messages intempestifs.
Généralement la navigation est plus fluide et on perd rarement certaines
fonctionnalités du site enlui-même.
Un second que j’utilise pas mal car on oublie quelques-fois bêtement
de vérifier c’est [Https Everywhere](https://www.eff.org/fr/https-everywhere),
ce dernier s’assure qu’il y a bien une connexion chiffrer entre vous
et le site que consultez. C’est presque un incontournable.
Ces deux plugins ont l’avantage d’être disponible pour Mozilla Firefox
mais aussi pour chrome si vous préférez ce dernier sachant qu'il est
moins respectueux de la vie privée mais vous pouvez en savoir plus en
lisant les règles de confidentialités qui sont ici Bonne lecture.
Afin de protéger un peu mieux votre vie privée vous pouvez aussi
essayer de faire vos recherches sur [DuckDuckGo](https://duckduckgo.com/) par exemple; ou utiliser
plus fréquemment l’outil de recherche sur le site que vous consultez,
si vous cherchez quelques choses sur Wikipedia par exemple ; autant utiliser
la recherche directement sur le site, afin de ne pas laisser toutes vos recherches à un seul site.
Un site très pratique aussi c'est [tosdr](https://tosdr.org/) pour
Terms of Service; Didn't Read. Les conditions d'utilisation défini
par un service en ligne sont souvent longues et compliqués, et dans
la pratique peu de personnes prennent le temps de les lires.
Ils proposent sous forme de résumé ces textes juridiques pour savoir
très vite ce que vous acceptez en cliquant sur j'accepte lorsque vous
vous inscrivez sur un site.Le projet étant communautaire vous pouvez
participer a résumer des conditions d'utilisation et même l'intégrer
à Firefox grâce à leur plugin!

542
content/blog/sauvegarde orangepi.md Normal file
View File

@@ -0,0 +1,542 @@
+++
template = "articles.html"
title = "Sauvegarde système de l'Orangepi sous debian/yunohost."
description = "Sauvegarder le système de sa carte ARM OrangePi avec debian sur clé usb"
date = 2019-12-09
+++
### Le problème
Ou plutôt les problèmes, car il peut y en avoir plusieurs; par exemple le
système sur la carte ne boot plus. On a fait une bêtise, on la débranché car on
a voulu la déplacer ou le fil s'est débranché par accident, et aller cette fois
là c'est la galère. C'est généralement long et fastidieux de récupérer les
données sur sa carte SD ou autre, j'ai donc fait un script qui fait une
sauvegarde globale du système sur un disque ou une clé usb que l'on devra
autoriser auparavant, histoire que dès que l'on branche une clé usb, ça n'envoie
pas les données dessus. Il y a bien évidement des solutions de sauvegarde en
ligne mais ayant une connexion avec peu de débit, ça peut prendre beaucoup de
temps, la connexion peut couper et alors c'est des complications, pour moi ce n'était pas très adapté.
### Le principe
Le principe c'est que le script a deux fonctionnalitées
* Une pour ajouter les supports de stockages où la sauvegarde sera envoyé. Le script formate la partition et il ajoute l'UUID à la liste des clés ou disques autorisé a recevoir les données.
Pour l'utiliser on lancera la commande **saveonmedia create**
* Une pour écouter avec udev les medias branchés et réaliser la sauvegarde quand elle reconnaît L'UUID d'un disque.
c'est la commande **saveonmedia make** qui fera ça.
Pour la liste, un bête fichier texte suffit pour ajouter les supports de stockage ligne par ligne, on se basera sur les UUID des partitions sur le disque qui sont normalement identifier de manière unique. Pour réaliser la sauvegarde le script lancera un script bash qui est généralement plus pratique si l'on veut ajouter des taches à effectuer ou personnaliser le truc un peu comme on veut.
``` python
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import pyudev
import subprocess
import sys
import os
import socket
from email.mime.text import MIMEText
from subprocess import Popen, PIPE
def print_help():
print ("""
##### saveonusb Sauvergarde sur support USB ####
! A executer avec l'utilisateur avec des droits root (sudo) ou en root !
Pour autoriser un disque (clé usb, disque usb)
Lancez la commande :
./saveonusb create
Pour effectuer l'ecoute puis la sauvegarde:
./saveonusb make
""")
def send_msg(subject, message):
# Permet d'envoyer des mail a root via sendmail.
msg = MIMEText(message)
msg["From"] = "sauvegarde@"+socket.gethostname()
msg["To"] = "root@"+socket.gethostname()
msg["Subject"] = subject
p = Popen(["/usr/sbin/sendmail", "-t", "-oi"], stdin=PIPE, universal_newlines=True)
p.communicate(msg.as_string())
def clean_df_out(df_out):
# Ici on tri les enleve les partitions de la sortir de df qui ne sont pas des supports
# de stockages
#
df_out = df_out.split('\n')
lines=[]
for line in df_out:
if line[0:4] == '/dev':
lines.append(line)
line_clean = list()
lines_clean = list()
# On crée la liste des champs de df
for line in lines:
line = line.split(' ')
for champ in line:
if champ != '':
line_clean.append(champ)
lines_clean.append(line_clean.copy())
line_clean.clear()
return lines_clean
def getMinSpaceRequirement():
# df -k A ce schema de sorti
# Filesystem | 1K-blocks | Used | Avail | Capacity | Mounted on
#
# Pour obtenir l'espace minimum on suppose que l'on veut sauvegarder toutes les
# données de tout les supports de stockages.
df = subprocess.check_output(['/bin/df', '-k']).decode('utf8')
df_list = clean_df_out(df)
print (df_list)
space_used = 0
for line in df_list:
space_used = space_used + int(line[2])
return space_used
def get_uuid(device):
cmd = subprocess.check_output(['sudo', 'blkid', device])
cmd = cmd.decode('utf-8')
for line in cmd.split(' '):
if 'UUID=' == line[0:5]:
return line[6:len(line)-1]
return ''
def make_save(save_directory, storages):
context = pyudev.Context()
monitor = pyudev.Monitor.from_netlink(context)
monitor.filter_by('block')
done = False
with open (storages, 'r') as f:
medias_save = f.read().splitlines()
while not(done):
device = monitor.poll()
if 'ID_FS_TYPE' in device and device.action == "add":
print ("device: {0} medias: {1}".format(device.get('ID_FS_UUID'), medias_save))
if "ynh_save" == device.get('ID_FS_LABEL') and device.get('ID_FS_UUID') in medias_save:
print ("La sauvegarde a commencé")
send_msg("Une sauvegarde a été lancé","Ne retirez pas votre disque ou clé usb. Merçi.")
retcode = subprocess.call("mount " + device.device_node + " "+ save_directory, shell=True)
if retcode != 0:
subject = "Bon ... ça s'est mal passé"
message = """Impossible de monter le disque ou la clé USB :( """
send_msg(subject, message)
retcode = subprocess.call( save_script + " " + save_directory, shell=True)
if retcode != 0:
subject = "Bon ... ça s'est mal passé"
message = """Le script de sauvegarde a remonté une erreur, comment dire ... je le ferai autrement moi """
send_msg(subject, message)
retcode = subprocess.call("umount " + device.device_node, shell=True)
if retcode != 0:
subject = "Bon ... ça s'est a peu près bien passé"
message = """Ça a monté le support et tout, le script pas de problèmes, mais ca ne démonte pas la partition correctement le script ne peut rien faire seul vous pouvez voir ce qu'il se passe en vous connectant en admin à votre machine"""
else:
subject = "Confirmation de sauvegarde"
message = """Votre sauvegarde est prête vous pouvez retirer votre support de stockage en toute sécurité. Rebranchez ce même support quand vous souhaitez effectuer une sauvergarde. Attention! Toutes modifications de la partiton rendra le support invalide"""
send_msg(subject, message)
def create_key_save(storages):
context = pyudev.Context()
monitor = pyudev.Monitor.from_netlink(context)
monitor.filter_by('block')
with open (storages, 'r') as f:
medias_save = f.read().splitlines()
done = False
while not(done):
device = monitor.poll()
if device.device_type == "partition" and device.action == "add":
if "ynh_save" == device.get('ID_FS_LABEL') and device.get('ID_FS_UUID') in medias_save:
subject = "Ce support de stockage est déjà initialisé"
message = "Il n'est pas nécéssaire d'initialisé ce périphérique"
send_msg(subject, message)
else:
size = subprocess.check_output("fdisk -s " +
device.device_node,
shell=True)
size = int(size)
size_requirement = getMinSpaceRequirement()
if size > size_requirement:
done = True
retcode = subprocess.call("mkfs.ext4" + " -F -L ynh_save" +
" "+ device.device_node, shell=True)
if retcode != 0:
subject = "Impossible de formatter la clé"
message = """ Il y a eu un problème durant le formatage du support usb"""
send_msg(subject, message)
# On récupere le nouvel uuid
with open (storages, 'a') as f:
f.write(get_uuid(device.device_node)+ '\n')
subject = "Autorisation d'un support de sauvegarde"
message = """ Vous venez de créer un support pour votre sauvegarde.
Cela s'est deroulé normalement. Pour effectuer une sauvegarde maintenant
rebrancher votre support de stockage; un mail vous signalera quand vous pourrez enlevez votre support en toute sécurité."""
send_msg(subject, message)
done = True
else:
subject = "Votre support de stockage est de taille insufisante !"
message = """Il n'y a pas assez d'espace disque sur le support que
vous venez de brancher; essayer avec une media de plus grande capacité (minimum """ +
str(size_requirement/1000000) + "Gb)"
send_msg(subject, message)
save_directory = "/media/save"
save_script = "/etc/saveonusb/scripts/save.sh"
conf_path = "/etc/saveonusb/"
storages = conf_path+"storages"
if os.geteuid() != 0:
raise OSError("Ce programme doit s'executer avec les droits root")
if not(os.path.exists(save_directory)):
raise OSError("Le repertoire "+ save_directory +" n'existe pas")
if not(os.path.exists(conf_path)):
raise OSError("Le repertoire "+ conf_path +" n'existe pas")
if not(os.path.isfile(save_script)):
raise OSError("Le fichier "+ save_script +" n'existe pas")
if not(os.path.isfile(storages)):
raise OSError("Le fichier "+ storages +" n'existe pas")
if len(sys.argv) > 1:
if sys.argv[1] == 'create':
create_key_save(storages)
if sys.argv[1] == 'make':
make_save(save_directory, storages)
if sys.argv[1] == '--help' or sys.argv[1] == '-h':
print_help()
else:
print_help()
```
On installe pyudev:
``` bash
apt install python3-pyudev
```
On créé les répertoires et les fichiers nécessaires:
```bash
mkdir /media/save
mkdir -p /etc/saveonusb/scripts
touch /etc/saveonusb/storages && touch /etc/saveonusb/scripts/save.sh
chmod +x /etc/saveonusb/scripts/save.sh
```
Je me suis fait tout d'abord un petit script afin de générer
une image prête a être flasher sur une carte SD
``` bash
#!/bin/bash
set -e
#set -x
#Implementer un TRAC error avec exit qui clean quand ca foire
# Implementer des logs
#Fonction pour check les programmes nécéssaire.
#lance apt install quand les programmes manques
# modprobe loop
# Test les medias disponibles et passer en parametre le disk a monter pour mettre l'image
# Demande confirmation pour commencer tout les étapes ou a toutes les étapes
_apt_install_dep()
{
echo "on passe ici avec $1 comme argument"
case $1 in
truncate)
apt-get -y install --no-install-recommends coreutils
;;
mkfs.ext4)
apt-get -y install --no-install-recommends e2fsprogs
;;
*)
apt-get -y install --no-install-recommends $1
;;
esac
}
check_dep()
{
bins=(dd truncate rsync parted mkfs.ext4 )
for i in "${bins[@]}"; do
if ! which "${i}" &> /dev/null; then
echo "${i} command is required"
_apt_install_dep ${i}
fi
done
echo "check_dep ok"
}
create_img() {
local folder=$1
local image=$2
# Espace utilisé sur /
local usage=$(df -BM | grep ^/dev | head -1 | awk '{print $3}' | tr -cd '[0-9]. \n')
# Espace libre
local avaible=$(df -BM $folder | grep ^/dev | head -1 | awk '{print $4}' | tr -cd '[0-9]. \n')
if [[ $usage -gt $avaible ]]; then
echo "No space left"
echo "Required: $usage MB "
echo "Free space in $folder : $avaible MB "
exit 1
fi
#On laisse 1024M d'espace libre sur l'image
local image_size=$(($usage+1024))'M'
truncate -s $image_size $folder/$image
}
prepare_part() {
local loop=$1
local folder=$2
local image=$3
local mount_image=$4
losetup $loop $folder/$image
parted -s $loop -- mklabel msdos
parted -s $loop -- mkpart primary ext4 8192s -1s
#La carte ne boot pas avec la ligne en dessous
#parted -s $loop align-check optimal 1
partprobe $loop
mkfs.ext4 $loop"p1"
mkdir $mount_image
mount $loop"p1" $mount_image
}
copy_files() {
# Stopper les services avant de copie
# Vérifier que les partitions soient montées
# Afficher le point de montage de la partition
# On redirige la sortie du programme vers /dev/null et la sortie erreur (2) sur la sortie standard
# On ne verra que les erreurs des fichiers ou la copie a posé problème
local mount_image=$1
rsync -avrltD --delete --exclude={/dev/*,/proc/*,/sys/*,/media/*,/mnt/*,/run/*,/tmp/*} / $mount_image > /dev/null 2>&1
}
#Modify fstab
change_fstab() {
local mount_image=$1
local old_uuid=$(blkid -o export `mount | grep -w / | awk '{print $1}'` | grep ^UUID)
local new_uuid=$(blkid -o export `mount | grep -w /media/$IMAGE | awk '{print $1}'` | grep ^UUID)
echo "old_uuid: $old_uuid"
echo "new_uuid: $new_uuid"
sed -i s/$old_uuid/$new_uuid/ $MOUNT_IMAGE/etc/fstab
if [ -e $MOUNT_IMAGE/boot/armbianEnv.txt ]; then
sed -i s/$old_uuid/$new_uuid/ $MOUNT_IMAGE/boot/armbianEnv.txt
fi
}
write_mbr() {
# On cherche le uboot_sunxi_with_spl.bin selon si on est sur armbian ou non
local $uboot_mbr
local $loop
loop=$1
uboot_mbr=$2
if [ ! -f $uboot_mbr ]; then
exit 1;
fi
# on Efface la zone pour le mbr
dd if=/dev/zero of=$loop bs=1k count=1023 seek=1 status=noxfer > /dev/null 2>&1;
# on flash le mbr
dd if=$uboot_mbr of=$loop bs=1024 seek=8 status=noxfer > /dev/null 2>&1;
}
clean() {
local loop=$1
local mount_image=$2
sync
umount $mount_image
losetup -d $loop
rmdir $mount_image
}
## Début du script
show_usage() {
cat << EOF
Ce script génère une image qui peut être flasher sur une carte SD pour les cartes
Olimex LIME LIME2 et orange pi pc (plus)
$(basename $0)
-d Dossier où sera stocké l'image
-u uboot_sunxi_with_spl.bin
EOF
exit 1
}
if [ ! $(id -u) = 0 ]; then
echo "L'utilisateur doit être root"
exit 1
fi
## Possibilité d'aller chercher le uboot_sunxi_with_spl.bin sur une adresse http
#Check arguments
if [ $# -eq 0 ]; then
show_usage
fi
# Gérer les options https://www.tutorialspoint.com/unix_commands/getopt.htm
while getopts ":d:u:h" opt; do
case $opt in
d)
FOLDER=$OPTARG
;;
u)
UBOOT_MBR=$OPTARG
;;
h | *)
show_usage;
;;
esac
done
if [ -z $FOLDER ]; then
show_usage
fi
if [ ! -d $FOLDER ]; then
echo "$FOLDER isn't a directory";
#echo "Le dossier $FOLDER n'existe pas"
show_usage
fi
if [ -z $UBOOT_MBR ]; then
show_usage
fi
if [ ! -f $UBOOT_MBR ]; then
echo "This file $UBOOT_MBR doesn't exist";
show_usage
fi
IMAGE=snapshot_`date +%Y%m%d`.img
LOOP=$(losetup -f)
MOUNT_IMAGE="/media/"$IMAGE
check_dep
echo "check_dep : OK"
#On crée un image de la taille minimale avec 1024M de place disponible.
create_img $FOLDER $IMAGE
echo "create_img: OK"
#On crée l'interface Loop et les partitions qui vont bien
prepare_part $LOOP $FOLDER $IMAGE $MOUNT_IMAGE
echo "prepare_part: OK"
#On copie la /
copy_files $MOUNT_IMAGE
echo "copy_file: OK"
#
change_fstab $MOUNT_IMAGE
echo "change_fstab: OK"
#On écrit le MBR
write_mbr $LOOP $UBOOT_MBR
echo "write_uboot: OK"
#demonte l'image et detache l'interface loop
clean $LOOP $MOUNT_IMAGE
```
je copie ce script dans /usr/local/bin/make_img
``` bash
chmod +x /usr/local/bin/make_img
```
Puis dans mon fichier /etc/saveonusb/script/save.sh
```bash
DIR_SAVE=$1
if [ ! -d "$DIR_SAVE" ]; then
echo "Le repertoire $DIR_SAVE n'existe pas" 1>&2;
exit 1;
fi
/usr/local/bin/make_img -f $DIR_SAVE -u /usr/lib/linux-u-boot-next-orangepipcplus_5.90_armhf/u-boot-sunxi-with-spl.bin
if [ $? -eq 1 ]; then
echo "Il y a eu une erreur durant la copie des fichiers" 1>&2;
exit 1;
fi
```
Version pour les personnes qui sont sous yunohost:
``` bash
#!/bin/bash
DIR_SAVE=$1
if [ ! -d "$DIR_SAVE" ]; then
echo "Le repertoire $DIR_SAVE n'existe pas" 1>&2;
exit 1;
fi
/usr/bin/yunohost backup create -o $DIR_SAVE
if [ $? -eq 1 ]; then
echo "Il y a eu une erreur pendant l'exécution de yunohost backup" 1>&2;
exit 1;
fi
```
Il y a biensur des choses à améliorer, mais c'est fonctionnel. On pourrait par exemple avoir plusieurs scripts ou vérifier si le support de sauvergarde a encore la place suffisante. Mais pour mes besoins ça me suffit. Une fonction pour la restauration ça serait pas mal aussi :).