Links

Backup Klipper

Siempre es aconsejable disponer de una copia de seguridad de nuestro sistema o ficheros de configuración para, en caso de desastre, poder restaurarlo rápidamente.
Algo muy aconsejable es disponer de un backup de los ficheros de configuración de nuestra impresora, os vamos a enseñar la forma en que nosotros lo hacemos para tener un backup que nos pueda salvar en caso de un desastre con nuestra SD teniendo siempre disponibles.
Os vamos a sugerir dos formas diferentes que pueden ser complementarias:
  • Copia/imagen de nuestra SD que nos permita recuperar exactamente nuestra instalación de Klipper, suele ser un proceso aconsejable cuando hagamos una actualización importante en nuestros componentes de Klipper.
  • Copia con gestión de versiones en Github de nuestros ficheros de configuración, en este caso solamente realizamos una copia de los ficheros críticos pero, por otro lado, el proceso será tan sencillo como lanzar una macro además de disponer de este backup online y con gestión de cambios.

Copia/Imagen de nuestra SD

Tal como os adelantábamos podemos hacer un respaldo completo de nuestra SD ya sea creando una imagen o clonando directamente en otra SD.
Aunque esta enfocado al uso en hosts de Klipper con una SD donde se encuentre todo el sistema algunas partes pueden aplicarse a otro tipo de hosts.

Imagen usando Windows

Dado que suele ser el sistema operativo más extendido, empezaremos por Windows. En este caso vamos a utilizar una herramienta llamada Win32DiskImager que nos va a facilitar el proceso:
  • Apagaremos de forma correcta nuestro host Klipper, esto lo podremos hacer directamente desde nuestra UI o desde SSH.
SSH Terminal
sudo shutdown now
  • Insertaremos la SD en nuestro equipo Windows y abriremos Win32DiskImager. Nos aseguraremos que seleccionamos el Device: correcto (1) y pulsaremos en el icono de carpeta (2) para seleccionar donde guardar nuestra imagen a la cual debemos de usar .img como extensión... por ejemplo: KlipperBaclup.img
  • Ahora tan solo tendremos que pulsar sobre el botón Read
Para restaurar la imagen deberemos de usar uno de los métodos explicados en el apartado restaurando nuestra imagen SD

Imagen usando MacOS

Si usamos MacOS como nuestro sistema operativo podremos realizar directamente el proceso de backup sin necesitad de instalar otras herramientas.
  • Insertaremos nuestra SD en nuestro Mac
  • Abriremos la utilidad Disk Utility, ya sea usando el Launchpad... buscando dentro de Applications desde el finder... o usando la tecla CMD+SPACE para usar Spotlight
  • Desde el menú File elegiremos la opción de crear New Image y seleccionaremos From... nuestra unidad SD. A continuación en la siguiente imagen tenéis los pasos numerados
  • Seleccionaremos la ubicación y nombre de nuestro backup asegurándonos que no marquemos la imagen como encriptada y pulsaremos Save. Es imporatante aceptar cualquier aviso de seguridad de acceso para que se realice el proceso.
Para restaurar la imagen deberemos de usar uno de los métodos explicados en el apartado restaurando nuestra imagen SD

Imagen usando Raspberry

Podemos hacer el proceso directamente desde nuestra Raspberry haciendolo sobre un pendrive USB.
  • Insertaremos nuestro pendrive USB en nuestro host Klipper Raspberry y, conectando por SSH, lanzaremos el comando df -h para identificar el punto de montaje de nuestro pendrive.
Es aconsejable lanzar el comando df -h antes de insertar el pendrive para ver que filesystems tenemos antes y después de insertarlo.
df -h
Filesystem Size Used Avail Use% Mounted on
/dev/root 15G 4.0G 9.6G 29% /
devtmpfs 458M 0 458M 0% /dev
/dev/mmcblk0p1 41M 21M 21M 52% /boot
/dev/sda1 3.7G 75M 3.6G 3% /media/pi/MYBACKUPDRIVE
  • Para simplificar el proceso vamos a usar un script del compañero Jinx para realizar y automatizar el proceso. Este script básicamente utiliza la utilidad rsync para crear una imagen. Comenzaremos por instalarlo:
SSH Terminal
cd ~
git clone https://github.com/lzkelley/bkup_rpimage.git
  • Ahora ya podremos lanzar nuestro backup lanzando el siguiente comando donde indicaremos la ruta y nombre de la imagen... en nuestro caso /media/pi/MYBACKUPDRIVE/klipper_backup.:
SSH Terminal
sudo sh bkup_rpimage.sh start -c /media/pi/MYBACKUPDRIVE/klipper_backup.img
  • Podemos automatizar el backup abriremos el fichero de configuración de la utilidad Crontab:
SSH Terminal
sudo crontab -e
  • Dependiendo de nuestras necesidades ajustaremos la frecuencia y si queremos un único backup incremental o multiples backups. Para más información sobre ajustar la frecuencia podéis revisar la documentación de Crontab aquí.
SSH Terminal
// Incremental backup use...
0 0 * * * sudo sh /home/pi/bkup_rpimage/bkup_rpimage.sh start -c /media/pi/MYBACKUPDRIVE/rpi_backup.img
// Multiples backup use...
0 0 * * * sudo sh /home/pi/bkup_rpimage/bkup_rpimage.sh start -c /media/pi/MYBACKUPDRIVE/rpi_$(date +%Y-%m-%d).img
  • Presionaremos CTRL+X y después Y y ENTER para guardar los cambios
Puede ser muy interesante mejorar el proceso realizando una compresión de la imagen que reduzca significativamente el espacio y facilitar la transferencia a otra SD o incluso usar una de menor tamaño:
Para ello os aconsejamos utilizar la utilidad PiShrink, del compañero Drewsif, la cual nos va a permitir comprimir la imagen.
SSH Terminal
wget https://raw.githubusercontent.com/Drewsif/PiShrink/master/pishrink.sh
sudo chmod +x pishrink.sh
sudo mv pishrink.sh /usr/local/bin
Una vez ya la tenemos instalada y creada nuestra imagen con el sistema anterior realizaremos un post-procesado de esta con PiShrink. PiShrink revisará y comprimirá la imagen reduciendo, si es posible, su tamaño.
SSH Terminal
sudo pishrink.sh -z /media/pi/MYBACKUPDRIVE/klipper_backup.img
Para restaurar la imagen deberemos de usar uno de los métodos explicados en el apartado restaurando nuestra imagen SD

Restaurando nuestra imagen SD

Raspberry Pi Imager (Win/MacOS)
balenaEtcher (Win/MacOS)
Win32DiskImager (Win)
  • Instalaremos si no lo tenemos instalado desde aquí
  • Seleccionaremos Use Custom como OS
  • Seleccionamos nuestra imagen y la SD card nueva
  • Pulsaremos sobre el botón Write y esperaremos a que finalice el proceso
  • Instalaremos en este caso balenaEtcher
  • Insertaremos nuestra nueva SD y abriremos balenaEtcher usando la opción Flash From File
  • Seleccionaremos la imagen previamente creada, es aconsejable antes cambiar su extensión de cdr a iso en el caso que se crease por defecto, y en Select target nuestra nueva SD
  • Pulsaremos Flash y esperaremos que finalice el proceso, en el caso que nos aparezca cualquier aviso de seguridad durante el proceso deberemos aceptarlo
  • abriremos de nuevo Win32DiskImager , asegurando antes de insertar la nueva SD, y seleccionaremos en Device: (1) esta. A continuación pulsaremos sobre el icono de carpeta (2) y seleccionaremos nuestra imagen previamente generada.
  • En este caso pulsaremos sobre el boton Write para restaurar nuestra imagen en la nueva SD

Copia de ficheros de configuración sobre GitHub

Otra forma más rápida y enfocada a tener un historial y backup externo de nuestros ficheros de configuración es, mediante una macro Shell, efectuar este backup en GitHub. Para nosotros el método, que complementario con el anterior, más usamos antes de aplicar ciertos cambios en nuestra configuración.
Este procedimiento puede servir para hosts de Klipper que usen Raspberry como base o no.
También se puede adaptar para aquellos sistemas donde no se puedan usar las macro shell desde Klipper pudiendo automatizar el backup en el proceso de arranque o apagado de ser necesario

Creando nuestro repositorio en GitHub

En nuestro caso utilizamos GitHub para tener un backup de nuestras impresoras, así que primero, y si no lo tenemos ya, iremos a crear una cuenta gratuita en GitHub.
  • haremos login en nuestra cuenta Github
  • crearemos un repositorio para el backup de nuestra impresora haciendo click en el botón de New
  • ajustaremos los detalles de nuestro repositorio:
    • En nuestro caso lo llamaremos voron0_klipper_3dwork que usaremos para guardar la configuración de nuestro directorio ~/printer_data/config
    • Seleccionaremos el tipo de repositorio entre Public o Private, va a vuestra elección si queréis que sea accesible o no

Creando nuestro token de acceso

La autenticación que vamos a usar en nuestros scripts de backup necesita que creemos un token de acceso a nuestro repositorio de backup creado.
  • desde el siguiente enlace podremos acceder a Personal Access Tokens
  • seleccionaremos Generate new token (classic), normalmente nos va a solicitar que volvamos a confirmar nuestro login por seguridad
  • daremos un nombre a nuestro token, idealmente algo que sea bastante descriptivo, usando No expiration como Expiration date y marcamos workflow y read:ord en la sección admin.org
  • Pulsaremos el botón Generate token y nos aparecerá el token en nuestra lista... es muy importante que guardemos este en un lugar seguro ya que si lo perdemos no tendremos forma de recuperarlo y tendremos que crear uno nuevo

Plugin Gcode Shell Command y script de backup

Habilitamos las extensiones G-Code Shell Command de Klipper

Antes de nada necesitamos instalar las G-Code Shell Command que es una extensión de Klipper y que podréis encontrar más información aquí.
Instalación automática desde Kiauh
La forma más sencilla y cómoda es usar el interfaz de Kiauh para instalarlo:
[Main Menu] --> 4)[Advanced] --> 9)[Shell Command]
Instalación manual
Podemos también instalar de forma manual copiando gcode_shell_command.py desde el directorio de fuentes de KIAUH a klipper/klippy/extras.
touch ~/klipper/klippy/extras/gcode_shell_command.py
nano ~/klipper/klippy/extras/gcode_shell_command.py
Pegaremos el contenido del plugin que podéis obtener aquí y guardaremos los cambios.
Por último y para que nuestro plugin funcione reiniciaremos Klipper:
sudo service klipper restart

Creando nuestro script de backup a Github

Una vez instalada la extensión G-Code Shell Command tendremos que crear nuestro script de bakcup a Github.
Podremos hacer este paso desde la propia iterfaz de Klipper (Mainsail/Fluidd) añadiendo un nuevo archivo de configuracion con el nombre antes indicado en nuestro directorio config.
En nuestro caso de ejemplo realizamos la instalación en una distribución para Raspberry Pi basada en MainsailOS, os aconsejamos que ajustéis los path a vuestra instalación en el caso que no coincidan con los ejemplos mostrados a continuación.
  • por SSH, nos colocaremos en nuestro directorio config:
cd ~/printer_data/config
  • descargaremos el script a nuestro directorio config:
wget -O /home/pi/printer_data/config/3dwork-autocommit.sh https://raw.githubusercontent.com/3dwork-io/3dwork-klipper/master/scripts/3dwork-autocommit.sh
El siguiente fragmento de código es el contenido de lo descargado en el punto anterior.
  • una vez descargado ajusteremos la configuración del script para nuestro caso. En nuestro ejemplo que no usamos Fluidd comentaremos la línea fluidd_folder. Normalente dejaremos habilitado nuestro config_folder, klipper_folder y moonraker_folder... dependiendo de la UI que usemos habilitaremos mainsail_folder o fluidd_folder.
Presta atención al valor usado en branch ya que ha de coincidir con el que usemos al crear nuestro repositorio... por defecto suele ser main aunque en ocasiones puede usarse master
nano /home/pi/printer_data/config/3dwork-autocommit.sh
#!/bin/bash
#####################################################################
### Please set the paths accordingly. In case you don't have all ###
### the listed folders, just keep that line commented out. ###
#####################################################################
### Path to your config folder you want to backup
config_folder=~/printer_data/config
### Path to your Klipper folder, by default that is '~/klipper'
klipper_folder=~/klipper
### Path to your Moonraker folder, by default that is '~/moonraker'
moonraker_folder=~/moonraker
### Path to your Mainsail folder, by default that is '~/mainsail'
mainsail_folder=~/mainsail
### Path to your Fluidd folder, by default that is '~/fluidd'
#fluidd_folder=~/fluidd
### The branch of the repository that you want to save your config
### By default that is 'master'
branch=main
#####################################################################
#####################################################################
#####################################################################
################ !!! DO NOT EDIT BELOW THIS LINE !!! ################
#####################################################################
...
  • finalizados nuestros ajustes guardaremos los cambio con CTRL+X y Y para salir y guardar cambios
  • como último paso vamos a dar permisos de ejecución en nuestro script
chmod +x 3dwork-autocommit.sh
Si hemos creado o modificado el script desde nuestra UI, Mainsail... Fluidd..., estos permisos pueden desaparecer por lo que tendremos que volver a realizar este paso.
Dado que nuestro script de backup se basa en el que contiene Kiauh encontrar la última versión del script de estos aquí para comparar o en caso de problemas si fuera necesario, aunque no deberían variar en mucho salvo cualquier posible modificación por nuestra parte para adaptarlo a nuestro bundle.

Configurando el repositorio local

  • Accediendo a nuestrop host por SSH nos aseguraremos de que tenemos el cliente git instalado:
sudo apt-get install git -y
  • Iremos a nuestra carpeta printer_data y montaremos nuestro git
cd /home/pi/printer_data/config
git init
  • con nuestro repositorio local inicializado correctamente configuraremos nuestro repositio remoto (Github) usando vuestro token y la URL de nuestro repositorio
git remote add origin https://[email protected]/3dwork-io/voron0_klipper_3dwork.git
  • verificaremos que se añadieron correctamente nuestro repositorio remote
git remote -v
  • continuaremos configurando nuestro mail y nombre que usaremos, si no lo hacemos en este paso nos lo solicitará más tarde
git config --global user.email "[email protected]"
git config --global user.name "Mi nombre"
  • inicializaremos nuestros repositorios
git branch -M main # change to main branch
git add . # prepare first commit
git commit -m "First Backup!!!" #add first commit
git push -u origin main #push local contents to github repository on main branch
sh 3dwork-autocommit.sh #testing the script usually nothing to commit
  • ahora si volvemos a nuestro Github, y todo funcionó correctamente, ya tendremos el contenido de nuestra configuración de Klipper en Github!!!

Configurando las macros de Klipper

Añadiremos las macros de backup

El último paso es crear la macro G-Code Shell Command en nuestro fichero CFG de macros o en nuestro printer.cfg
[gcode_shell_command backup_cfg_github]
command: sh /home/pi/printer_data/config/3dwork-autocommit.sh
timeout: 30.
verbose: True
[gcode_macro BACKUP_CFG_GITHUB]
gcode:
RUN_SHELL_COMMAND CMD=backup_cfg_github
  • command: sh <path nuestro script shell> deberá a apuntar a la localización de nuestro script previamente creado... debería ser /home/pi/printer_data/config/backup_cfg_github.sh
  • recuerda que el script debe ser ejecutable -> chmod +x <script> desde SSH
  • el timeout de 30 segundos es solamente un ejemplo, en cualquier caso no uses un tiempo muy corto ya que dependiendo del tiempo de proceso puede hacer que falle

Lanzar Backups

Ahora que ya tenemos todo listo ya solamente nos queda lanzar nuestros backups cuando queramos y tener siempre una copia de seguridad con gestión de versiones de nuestros ficheros de configuración de Klipper.
Para lanzarlos es tan sencillo como ir a nuestra sección de Macros y simplemente lanzar BACKUP CFG o el nombre que le dimos anteriormente:
En la consola podremos ver información del proceso:
Ejemplo de logs actualizando el backup
Ejemplo de logs con backup actualizado
También podremos desde Github ver nuestras configuraciones y control de cambios:

Utilizando KGB

Si utilizas KGB, aunque compatible con el explicado en puntos anteriores, te aconsejamos eliminar el anterior.
La comunidad siempre trabaja duro para mejorar los procesos, en este caso el compañero Low-Frequency ha creado unos scripts y procesos al estilo Kiauh llamados KGB (Klipper Git Backup) para poder realizar backups de nuestro Klipper a Github.
Básciamente KGB ejecuta sus scripts al iniciar nuestro host Klipper, o si configuramos que se realice cada x tiempo, espera a disponer de conexión y hace un push a Github del contenido del directorio de configuración que configuremos.
  • Revisar que disponemos de git en nuestra instalación
sudo apt-get install git -y
  • Descargaremos el repositorio KGB
cd ~ && git clone https://github.com/Low-Frequency/Klipper-Git-Backup.git
  • Iniciamos KGB
chmod +x ~/Klipper-Git-Backup/*.sh && ./Klipper-Git-Backup/kgb.sh
  • Si todo ha ido bien accederemos al menú de gestión de opciones de KGB desde el cual seleccionando el número de opción podremos realizar los siguientes pasos... por lo menos deberemos seguir la opción 1) Configure para ajustar nuestro nombre de usuario de Github, nuestro mail, nuestro repositorio de Github para el backup y la carpeta de configuración de Klipper a realizar el backup
Añadir una llave SSH a tu cuenta Github:
Durante el proceso de configuración el script te va a facilitar una "private key" que deberemos añadir a nuestra cuenta de Github. Desde Github iremos a Profile/Settings/SSH and GPG keys y añadiremos una nueva key copiando la que nos facilitó el proceso de configuración de KGB.

Restaurando el backup

Esperemos que no lo necesites!!! pero en caso que necesites restaurar tus ficheros tenemos las siguientes opciones...

Restaurando a mano

Podemos ir a nuestro repositorio en Github y copiar linea a linea cada fichero o descargar en zip nuestro repositorio y copiarlos a nuestra SD desde el ordenador o transfiriendo por SSH usando una herramienta estilo WinSCP o similar.

Restaurando desde Git

  • En el caso de querer restaurar completamente nuestra configuración por la que tenemos en Github y disponemos del directorio original klipper_config realizaremos el siguiente proceso:
cd ~/printer_data/config
git fetch -all
### Depende de como creases tu repositorio en Github la rama remota puede ser master o main
git reset --hard origin/master
IMPORTANTE!!! esto va a borrar todo el contenido que tengas en el directorio ~/printer_data/config por lo que tengas en tu Github, asegurate que antes tienes una copia por si acaso.
  • Si queremos reinstalar desde una nueva instalación realizaremos los siguientes pasos
cd ~
git clone <URL-Repositorio-GitHub>