Made a simple archive website for the allsky page.

[JBakers]

My Rpi with 32GB is prone to fail sometimes, so I made a website and automatic upload scripts to upload 100 captures, keogram, timelaps and the startrail to this website.

check https://www.all-sky.nl if your interested and let me know what you think.

[JBakers]

BTW Made a small hidden easteregg on the site. can you find it?

[Alex-developer]

BTW Made a small hidden easteregg on the site. can you find it?

Nice site

Is 'About' the Easter egg?

As Eric mentioned there is a backup manager in the next release which may help you, a few screenshots ....

[JBakers]

Yea the easter egg is the about page (blinking star).
New site looks amazing!

Wondering if a rpi4b 8GBram with 32GB sdcard will still be sufficient?
Scratch that question: is there a place where I can read up on about the new release?

Ive been contemplating long time before installing the 2025.x branch, but I went for the stable version and based the website upon that.

[EricClaeys]

@JBakers,
Good job.
The next release of Allsky will allow users to backup Allsky, its settings, and images. This is useful ith unreliable Pi's.

[brianboru82]

That will be very nice. I just had my SD card fail, with all my settings 😭

[JBakers]

I have multiple rpi's running with different services, pihole, minecraft servers for the kids, allsky.

I'm using a backup-script that runs once a week that backups a complete image of the SD-card to a NAS.
Its based upon https://github.com/lzkelley/bkup_rpimage bkup_rpimage.

#!/bin/bash

# Script Name:   bkup_rpimage.sh
# Version:       V2.8
# Date:          2026-04-16
# Description:   Incremental RPi backup with visual progress during archiving.
#                V2.7: Safety check on mount before backup + strict unmount verification.
#                V2.8: Auto-recreate if image is too small + 3000 MB buffer + 4 rotations.
#
# Usage:         bkup_rpimage.sh start [-c] [-l] /path/to/image.img
#                bkup_rpimage.sh umount /path/to/image.img
#
# Cronjob:       0 4 * * 1  /path/to/bkup_rpimage.sh start -c /mnt/backup/backup.img >> /path/to/backup.log 2>&1
#                Adjust path and schedule per Pi.
#
# Requirements:  - Target directory must be a mounted NAS/USB (not the SD card)
#                - Script must run as root

# --- Configuration ---
export PATH="/usr/sbin:/usr/bin:/sbin:/bin:$PATH"
BUFFER_MB=3000       # Free space in image on top of current rootfs
MAX_BACKUPS=4        # Number of dated copies to keep

# --- Messages ---
msgok()   { echo -e "[ok] ${1}"; }
msg()     { echo -e "     ${1}"; }
msgwarn() { echo -e "[w]  ${1}"; }
msgfail() { echo -e "[X]  ${1}" >&2; exit 1; }

# --- Rotation ---
do_rotate() {
    local backup_file="$1"
    local dir=$(dirname "$backup_file")
    local base=$(basename "$backup_file")
    local today=$(date +%Y-%m-%d)

    if ! mountpoint -q "$dir"; then
        msgfail "Safety stop: $dir is not mounted. Rotation cancelled."
    fi

    msg "Starting archival (keeping ${MAX_BACKUPS} versions)..."

    if [ -f "$backup_file" ]; then
        msg " - Copying master to ${base}.${today}..."
        dd if="$backup_file" of="${dir}/${base}.${today}" bs=4M conv=sparse status=progress
        sync
    fi

    local count=$(find "$dir" -maxdepth 1 -name "${base}.[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]" | wc -l)
    if [ "$count" -gt "$MAX_BACKUPS" ]; then
        find "$dir" -maxdepth 1 -name "${base}.[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]" \
            | sort | head -n -${MAX_BACKUPS} | while read -r oldest; do
            rm "$oldest"
            msg " - Old archive removed: $(basename "$oldest")"
        done
    fi
}

# --- Create image ---
do_create() {
    msg "Creating sparse ${IMAGE}, ${SIZE}M"
    dd if=/dev/zero of="${IMAGE}" bs=${BLOCKSIZE} count=0 seek=${SIZE}
    losetup "${LOOPBACK}" "${IMAGE}"
    if [ "${PARTSCHEME}" == "GPT" ]; then
        parted -s "${LOOPBACK}" mktable gpt
        parted -s "${LOOPBACK}" mkpart "BOOT" fat32 4MiB ${BOOTSIZE}MiB
        parted -s "${LOOPBACK}" mkpart "ROOT" ext4 ${BOOTSIZE}MiB 100%
        parted -s "${LOOPBACK}" set 1 legacy_boot on
    else
        parted -s "${LOOPBACK}" mktable msdos
        parted -s "${LOOPBACK}" mkpart primary fat32 4MiB ${BOOTSIZE}MiB
        parted -s "${LOOPBACK}" mkpart primary ext4 ${BOOTSIZE}MiB 100%
        parted -s "${LOOPBACK}" set 1 boot on
    fi
    partx --add "${LOOPBACK}" &>/dev/null
    mkfs.vfat -n BOOT -F32 "${LOOPBACK}p1"
    mkfs.ext4 "${LOOPBACK}p2"
}

# --- Adjust boot environment ---
change_bootenv() {
    local fstab_tmp=/tmp/fstab.$$
    local cmdline_tmp=/tmp/cmdline.$$
    cp /etc/fstab $fstab_tmp

    local -r BOOTDEV=$(findmnt --uniq --canonicalize --noheadings --output=SOURCE "${BOOTMP}")
    local -r ROOTDEV=$(findmnt --uniq --canonicalize --noheadings --output=SOURCE /)
    local -r BootPARTUUID=$(lsblk -n -o PARTUUID "${BOOTDEV}")
    local -r RootPARTUUID=$(lsblk -n -o PARTUUID "${ROOTDEV}")
    local -r dstBootPARTUUID=$(lsblk -n -o PARTUUID "${LOOPBACK}p1")
    local -r dstRootPARTUUID=$(lsblk -n -o PARTUUID "${LOOPBACK}p2")

    sed -i "s/PARTUUID=${BootPARTUUID}/PARTUUID=${dstBootPARTUUID}/" "$fstab_tmp"
    sed -i "s/PARTUUID=${RootPARTUUID}/PARTUUID=${dstRootPARTUUID}/" "$fstab_tmp"
    cp "$fstab_tmp" "${MOUNTDIR}/etc/fstab"

    cp "${BOOTMP}/cmdline.txt" "$cmdline_tmp" 2>/dev/null || cp "${BOOTMP}/firmware/cmdline.txt" "$cmdline_tmp" 2>/dev/null
    sed -i "s/PARTUUID=${RootPARTUUID}/PARTUUID=${dstRootPARTUUID}/" "$cmdline_tmp"
    cp "$cmdline_tmp" "${MOUNTDIR}/${BOOTMP}/cmdline.txt"
}

# --- Mount ---
do_mount() {
    [ "$(losetup -f)" = "${LOOPBACK}" ] && { losetup "${LOOPBACK}" "${IMAGE}"; partx --add "${LOOPBACK}"; }
    mkdir -p "${MOUNTDIR}" &>/dev/null
    mount "${LOOPBACK}p2" "${MOUNTDIR}"
    mkdir -p "${MOUNTDIR}/${BOOTMP}" &>/dev/null
    mount "${LOOPBACK}p1" "${MOUNTDIR}/${BOOTMP}"
}

# --- Unmount with verification ---
do_umount() {
    sync

    umount "${MOUNTDIR}/${BOOTMP}" 2>/dev/null
    umount "${MOUNTDIR}" 2>/dev/null

    sleep 3

    if mountpoint -q "${MOUNTDIR}/${BOOTMP}" 2>/dev/null; then
        msgfail "ERROR: Unmount of ${MOUNTDIR}/${BOOTMP} failed! Loopback remains active."
    fi
    if mountpoint -q "${MOUNTDIR}" 2>/dev/null; then
        msgfail "ERROR: Unmount of ${MOUNTDIR} failed! Loopback remains active."
    fi

    [ -d "${MOUNTDIR}" ] && rmdir "${MOUNTDIR}" 2>/dev/null

    partx --delete "${LOOPBACK}" 2>/dev/null
    losetup -d "${LOOPBACK}" 2>/dev/null

    if losetup -j "${IMAGE}" | grep -q "${LOOPBACK}"; then
        msgfail "ERROR: Loopback ${LOOPBACK} still active after unmount! Manual fix: losetup -d ${LOOPBACK}"
    fi

    msgok "Unmount successful. Loopback released."
}

# --- FIX V2.8: Check image size, remove if too small ---
do_size_check() {
    if [ ! -f "${IMAGE}" ]; then
        return 1  # Image does not exist
    fi

    local current_size_mb=$(( $(stat -c%s "${IMAGE}") / 1024 / 1024 ))

    if [ "${current_size_mb}" -ge "${SIZE}" ]; then
        msgok "Image OK (${current_size_mb}M >= ${SIZE}M required)"
        return 0
    fi

    msgwarn "Image too small: ${current_size_mb}M, required: ${SIZE}M"
    msgwarn "Image will be removed and recreated (one-time full rsync)."

    # Detach loopback if still attached
    local existing_loop=$(losetup -j "${IMAGE}" | grep -o '^[^:]*')
    if [ -n "${existing_loop}" ]; then
        partx --delete "${existing_loop}" 2>/dev/null
        losetup -d "${existing_loop}" 2>/dev/null
    fi

    rm -f "${IMAGE}"
    LOOPBACK=$(losetup -f)
    return 1  # Needs to be recreated
}

# --- Backup ---
do_backup() {
    local rsyncopt="-aEvx --del --stats"
    [ -n "${opt_log}" ] && rsyncopt="$rsyncopt --log-file ${LOG}"
    rsync ${rsyncopt} "${BOOTMP}/" "${MOUNTDIR}/${BOOTMP}/"
    rsync ${rsyncopt} --exclude={'.gvfs/**','tmp/**','proc/**','run/**','sys/**','mnt/**','lost+found/**','var/swap/**','var/log/**','home/*/.cache/**','root/.cache/**','var/cache/apt/archives/**','home/*/.vscode-server/**'} / "${MOUNTDIR}/"
}

#####################################################################################################
# Main
#####################################################################################################
exec &> >(tee "${0%%.sh}.out")
[ ${EUID} -eq 0 ] || msgfail "Must run as root!"

opt_command=${1}
shift 1
while getopts ":cl" opt; do
    case ${opt} in
        c) opt_create=1 ;;
        l) opt_log=1 ;;
    esac
done
shift $((OPTIND - 1))

declare -gxr BOOTSIZE=550
declare -gxr ROOTSIZE=$(df -m --output=used / | tail -1)
declare -gxr SIZE=$((BOOTSIZE + ROOTSIZE + BUFFER_MB))
declare -gxr BLOCKSIZE=1M
mountpoint -q "/boot/firmware" && BOOTMP="/boot/firmware" || BOOTMP="/boot"

IMAGE="${1}"
[ -z "${IMAGE}" ] && { echo "Usage: $0 start [-c] [-l] image.img"; exit 1; }

LOOPBACK=$(losetup -j "${IMAGE}" | grep -o ^[^:]*)
[ -z "${LOOPBACK}" ] && LOOPBACK=$(losetup -f)
MOUNTDIR="/mnt/$(basename "${IMAGE}")"

case ${opt_command} in
    start)
        msg "--- START BACKUP V2.8 ---"

        IMAGE_DIR=$(dirname "${IMAGE}")
        if ! mountpoint -q "${IMAGE_DIR}"; then
            msgfail "ABORT: ${IMAGE_DIR} is not mounted. Backup cancelled to protect the SD card."
        fi
        msgok "Mount ${IMAGE_DIR} verified."

        if ! do_size_check; then
            if [ -n "${opt_create}" ]; then
                do_create
            else
                msgfail "Image not found and -c not specified."
            fi
        fi

        do_mount
        do_backup
        change_bootenv
        do_umount
        do_rotate "${IMAGE}"
        msgok "Process completed."
        ;;
    umount)
        do_umount
        ;;
    *)
        echo "Usage: $0 start [-c] [-l] image.img"
        ;;
esac

Incremental backup script for my Raspberry Pi's. Uses rsync over a loopback-mounted sparse image to create bootable .img backups on my NAS. Automatically sizes the image to current disk usage, adjusts PARTUUIDs so the image boots standalone, and keeps 4 dated rotations. The script aborts if the target directory isn't mounted, to prevent accidental writes to the SD card. Requires root and standard tools (rsync, parted, losetup, dd, mkfs.vfat, mkfs.ext4).

# First run (creates image):
sudo ./bkup_rpimage.sh start -c /mnt/nas/backup.img

# Subsequent runs (incremental):
sudo ./bkup_rpimage.sh start /mnt/nas/backup.img

# With rsync logging:
sudo ./bkup_rpimage.sh start -c -l /mnt/nas/backup.img

# Cronjob (weekly, Monday 4AM):
0 4 * * 1  /path/to/bkup_rpimage.sh start -c /mnt/nas/backup.img >> /path/to/backup.log 2>&1

# Manual unmount (if needed):
sudo ./bkup_rpimage.sh umount /mnt/nas/backup.img