borgbackup/borgbackup.sh

#!/bin/bash
#
# Borg-Backup taeglich, siehe Obsidian für Einrichtung
# Anregungen von Artur und 
# https://www.4rr0wx.com/borgbackup-mit-hetzner-storage-box-verwenden/
#
# 2025-05-14, misc

# !!!!!!!!!!!!!!!!!!!!--------------------!!!!!!!!!!!!!!!!!!!!!
# !!! Unbedingt anpassen in .env (wird beim ersten Start erzeugt)!!!
# Anschliessend die include-Datei auf nicht vorhandene Verzeichnisse untersuchen
# !!! und anpassen. Die exclude-Datei ist in der Regel ok.
# !!!!!!!!!!!!!!!!!!!!--------------------!!!!!!!!!!!!!!!!!!!!!


# Wenn nicht vorhanden werden include und exclude geschrieben. Ab da nur noch dort aendern.
# ---------------------------------------------------------------------
# Ab hier normalerweise nichts anpassen
export BORG_REPO="ssh://storagebox/./backup"
LOGTIME=`date +%d`
BORG=/usr/bin/borg
BORG_PATH=/root/sc
BORG_INCLUDEFILE="$BORG_PATH/include.lst"
BORG_EXCLUDEFILE="$BORG_PATH/exclude.lst"
BORG_MOUNTPOINT=$BORG_PATH/mountpoint
BORG_COMPRESSION=lz4
BORG_ENCRYPTION=repokey
LOG="$BORG_PATH/workdir/borgbackup-$LOGTIME.log"
HOST="$(hostname)"

include_list() {

	cat <<EOF
/data
/data1
/etc
/home
/opt
/root
/srv
/usr/local
/var/spool/cron
/var/www
/var/www-vhosts
EOF
}

exclude_list() {

	cat <<EOF
/home/*/.cache
/home/*/.irssi/irclogs/
**/.Trash-*
**/[Cc]ache/*
*.vmdk
**/build-area/*
/mnt/*
/usr/*
/proc/*
/dev/*
/sys/*
/tmp/*
/var/cache/*
/var/log/*
/var/tmp/*
/root/sc/workdir/borgbackup*
EOF
}

#Default-Werte für $BORG_SCRIPT
#Variablen sollten in $BORG_PATH/.env anpasst werden
borg_env() {

        cat <<EOF
### Variablen an eigene Umgebung und Wuensche anpassen
###
#\$HOST - ein vom hostname und DNS abweichender Name
HOST="$HOST"
#Passphrase eintragen, wenn verschlüsselt gesichert werden soll
export BORG_PASSPHRASE=""
# # Nach welchem Schema sollen alte Archive gelöscht werden?
# # Die Vorgabe behält alle Sicherungen des aktuellen Tages. Zusätzlich das aktuellste Archiv der
# # letzten 7 Sicherungstage, der letzten 4 Wochen sowie der letzten 12 Monate.
export BORG_PRUNING="--keep-within=1d --keep-daily=7 --keep-weekly=4 --keep-monthly=12"
# URL to call when backup is successful, useful i.e. for uptime kuma push monitor. Deaktivieren: localhost
SUCCESS_URL="localhost"
# URL to call when backup is _not_ successful. Deaktivieren: localhost
ERROR_URL="localhost"
# Mailadresse für Log - bitte anpassen!
FROM_EMAIL="$(hostname)@kueckshaus.de" 
# An wen soll die Mail geschickt werden? Bitte anpassen!
TO_EMAIL="michael@schaarwaechter.de"
EOF

}


die() { echo "$*" 1>&2 ; exit 1; }

## neues Backup erzeugen
borg_create() {
   echo "###### Starting $0 $* on $(date) ######"
   $BORG create -v \
      --warning \
      --filter AME \
      --list \
      --stats \
      --show-rc \
      --compression $BORG_COMPRESSION \
      --exclude-caches \
      --exclude-if-present ".nobackup" \
      --keep-exclude-tags \
      --exclude-from $BORG_EXCLUDEFILE \
      $BORG_REPO::'{now:%Y-%m-%d_%H:%M}' \
      $(cat ${BORG_INCLUDEFILE})
   if [ $? -eq 0 ] || [ $? -eq 1 ]; then
      echo Calling Success_URL
      curl -o /dev/null -s $SUCCESS_URL
   else
      echo Calling Error_URL
      curl -o /dev/null -s $ERROR_URL
   fi
   echo "###### Finished backup on $(date) ######"
}

# Hilfe zur Nutzung des Skripts
usage() {
cat <<EOF
Aufruf $0 
    check|init      - prüft, ob \\\$BORG_REPO eingerichtet ist
    info            - zeigt ausführliche Informationen zu \\\$BORG_REPO
    create|run      - legt neues Backup an
    list            - listet vorhandene Backups 
    mount           - bindet vorhandenes Backup unter $BORG_MOUNTPOINT ein
    umount          - entfernt eingebundenes Backup unter $BORG_MOUNTPOINT
    prune           - löscht alte Backups aus dem \\\$BORG_REPO
    keyexport       - exportiert Repokey in lokale Datei

EOF

}

#Repokey zusätzlich lokal speichern
borg_keyexport() {
	[ "$BORG_ENCRYPTION" == "repokey" ] && $BORG key export "$BORG_REPO" $BORG_PATH/encrypted-repokey && \
		return 0 ||
		return 1
}

# überprüfen, ob borg-Repository initialisiert wurde
# und ausführen, falls nötig
borg_check() {
   echo "Überprüfe, ob das Repository initialisiert ist..."
	if $BORG check ${BORG_REPO}; then
		echo "Das Repository ist bereits initialisiert."
		return 0
	else
		echo "Das Repository ist nicht initialisiert. Initialisiere jetzt..."
		if $BORG init --encryption="$BORG_ENCRYPTION" "$BORG_REPO"; then
			echo "Repository erfolgreich initialisiert."
			#Repokey zusätzlich lokal speichern
			[ "$BORG_ENCRYPTION" == "repokey" ] && borg_keyexport
			return 0
		else
			echo "Repository konnte nicht initialisiert werden."
			return 1
		fi
	fi
}

# This command displays detailed information about the specified archive or repository.
borg_info() {

	echo "Informationen zum Repository:"
	borg info "$BORG_REPO"
	if [ $? -ne 0 ]; then
		echo "Fehler beim Zugriff."
		return 1
	fi
}

# Borg-Sicherungen aufräumen
# Anzahl der Sicherungen wird in $BORG_PRUNING festgelegt
borg_prune() {
   echo "Bereinige das Backup-Repository..."
	$BORG prune -v --list $BORG_PRUNING "$BORG_REPO"

   BORG_VERSION=$($BORG -V 2>/dev/null | grep -oE '[0-9]+\.[0-9]+')
   MAJOR=$(echo $BORG_VERSION | cut -d. -f1)
   MINOR=$(echo $BORG_VERSION | cut -d. -f2)
   if [ "$MAJOR" -gt 1 ] || ([ "$MAJOR" -eq 1 ] && [ "$MINOR" -ge 2 ]); then
      echo "Borg $BORG_VERSION: führe compact aus"
      $BORG compact "$BORG_REPO" 
   fi

}

# auflisten von Borg-Sicherungen
borg_list() {
	# Auflisten der Sicherungen
	echo "Vorhandene Sicherungen im Repository:"
	borg list "$BORG_REPO"
	if [ $? -ne 0 ]; then
		echo "Fehler beim Auflisten der Sicherungen."
		return 1
	fi
}

## mount repo restore to defined directory
##This command mounts an archive as a FUSE filesystem.
borg_mount() {

   if mountpoint -q "$BORG_MOUNTPOINT"; then
      echo "Already mounted or already a mountpoint!"
   else
      mkdir -p ${BORG_MOUNTPOINT}
     	chmod a-w ${BORG_MOUNTPOINT}

      if $BORG mount ${BORG_REPO} ${BORG_MOUNTPOINT}; then

         echo "Mounting Repository to ${BORG_MOUNTPOINT}"
         echo "Switch to ${BORG_MOUNTPOINT} to browse backup archives!"
         echo
         echo "--- Showing list of available backups ---"
         echo
         ls -al ${BORG_MOUNTPOINT}
         echo
         echo
         echo "-------------------------------------------"
         echo "MAKE SURE TO UNMOUNT REPO WHEN FINISHED WITH"
         echo "$ $BORG_SCRIPT umount"
         echo "-------------------------------------------"
         return 0
      else
         echo "ERROR mounting Repository to ${BORG_MOUNTPOINT}"
         return 1
      fi
   fi
}

#eingebundene Borg-Sicherungen wieder lösen
borg_umount() {
   if mountpoint -q "$BORG_MOUNTPOINT"; then
      if $BORG umount ${BORG_MOUNTPOINT}; then
         echo "Restore folder unmounted"
      else
         echo "No restore folder mounted!"
      fi
   else 
      echo "Nothing is mounted in $BORG_MOUNTPOINT..."
   fi
}

# ------------------- MAIN

## Write output to logfile
exec > >(tee -i ${LOG})
exec 2>&1

# Include/Exclude
[ -f $BORG_INCLUDEFILE ] || include_list >$BORG_INCLUDEFILE
[ -f $BORG_EXCLUDEFILE ] || exclude_list >$BORG_EXCLUDEFILE

# beim ersten Aufruf .env anlegen
[ -f $BORG_PATH/.env ] || borg_env >$BORG_PATH/.env
# Variablen aus .env einlesen
source "$BORG_PATH/.env"

case "$1" in

check | init)
	# überprüfen, ob borg-Repository bereits initialisiert wurde
	# und führen borg init aus, falls nötig
	borg_check
	;;

run | create)
	borg_umount #eventuell eingebundene Backups entfernen
	borg_check || die "$BORG_REPO kann nicht angelegt werden"
	borg_create
	borg_prune
	#send_log
	;;

info)
	#zeige ausführliche Informationen zum Repo
	borg_info
	;;

list)
	#zeige vorhanden Sicherungen
	borg_list
	;;

prune)
	#bereinige das Backup-Repo
	borg_prune
	;;

mount)
	#stelle Backups als Verzeichnisbaum zur Verfügung
	borg_mount
	;;

umount)
	#entferne das Backup-Repo aus dem Dateisystem
	borg_umount
	;;

keyexport)
	#exportiert Repokey in lokale Datei
	borg_keyexport
	;;

*)
	#Hilfe anzeigen
	usage
	;;
esac