Backup remoto con rclone hacia Mega mediante Jenkins en Docker y GitLab

En este tutorial, te guiaré a través del proceso de configuración y ejecución de un pipeline automatizado utilizando Jenkins en Docker, un Jenkinsfile almacenado en GitLab, y la herramienta rclone para realizar backups de un servidor remoto hacia Mega. Este enfoque es ideal para quienes buscan implementar una solución de respaldo confiable y escalable sin intervención manual, asegurando que los datos importantes estén siempre disponibles en la nube. Al final de este tutorial, habrás creado un flujo de trabajo eficiente para gestionar backups automatizados desde un entorno Dockerizado con Jenkins.

Para este tutorial necesitaremos:

• 01 servidor vps con Jenkins en un contenedor docker
• 01 servidor con archivos en una carpeta para respaldar y rclone instalado
• 01 cuenta en gitlab
• 01 cuenta en mega

Este seria la arquitectura que vamos a implementar

1. Generar y Configurar Claves SSH

Lo primero es en consola, generar las credenciales SSH en tu server Jenkins

ssh-keygen -t rsa -b 4096 -C "tu@correo.com"

Esto generará dos archivos:

• ~/.ssh/id_rsa (clave privada)
• ~/.ssh/id_rsa.pub (clave pública)

Copia la clave pública al servidor destino:

ssh-copy-id root@servidor-remoto

Esto agregará tu clave pública al archivo ~/.ssh/authorized_keys del servidor remoto, lo que permitirá que te autentiques sin contraseña.

2. Copiar la clave SSH al contenedor de Jenkins

Aqui para no tener problemas de permisos, primero ingresaremos al contenedor de Jenkins

docker exec -it <nombre_del_contenedor> /bin/bash

crea el archivo id_rsa sin contenido

touch /var/jenkins_home/.ssh/id_rsa

Cambia los permisos del archivo para que Jenkins pueda escribir en él:

chown jenkins:jenkins /var/jenkins_home/.ssh/id_rsa

le aplicamos los permisos 600 de escritura y lectura

chmod 600 /var/jenkins_home/.ssh/id_rsa

verificamos el permiso

ls -l /var/jenkins_home/.ssh/id_rsa

debemos tener la siguiente salida

-rw------- 1 jenkins jenkins 3401 Sep 25 15:52 /var/jenkins_home/.ssh/id_rsa

salimos

exit

ahora copia el contenido del id_rsa del host al id_rsa del contenedor

cat ~/.ssh/id_rsa | docker exec -i jenkins-jenkins-1 sh -c 'cat > /var/jenkins_home/.ssh/id_rsa'

ingresa nuevamente al contenedor y verifica si puedes conectarte al servidor remoto desde el contenedor usando la clave publica sin contraseña

ssh -i ~/.ssh/id_rsa root@servidor-remoto

si ya puedes iniciar sesión en tu server remoto, puedes salir del contenedor con exit nuevamente y hasta aquí ya hemos terminado a nivel de consola

3. Preparar nuestro archivo Jenkinfile

Ahora prepararemos nuestro Jenkinsfile para publicarlo en nuestro repositorio de GitLab. Este archivo contiene tres etapas (stages) que nos permitirán realizar el backup en nuestro servidor remoto. El primer stage se encargará de hacer el backup de la base de datos MySQL en una carpeta. El segundo eliminará las copias que tengan más de 7 días, y finalmente, el tercero enviará las copias a Mega utilizando rclone.

pipeline {
    agent any

    stages {
        stage('Backup') {
            steps {
                script {
                    // Ejecuta el script de backup en el servidor remoto
                    sh 'ssh root@servidor-remoto "sh /ruta/backupBD/backup.sh"'
                }
            }
        }

        stage('Eliminar backups antiguos') {
            steps {
                script {
                    // Elimina archivos .sql.gz más antiguos de 7 días en el servidor remoto
                    sh 'ssh root@servidor-remoto "find /ruta/backupBD/*.sql.gz -mtime +7 -exec rm {} \\;"'
                }
            }
        }

        stage('Sincronizar archivos con Rclone') {
            steps {
                script {
                    // Sincroniza los archivos con el servidor remoto usando rclone
                    sh 'ssh root@servidor-remoto "rclone sync /ruta/backupBD remoto:carpeta_mega --ignore-existing --create-empty-src-dirs"'
                }
            }
        }
    }
}

4. Crear credenciales SSH en Jenkins

Regresamos a nuestra consola de Jenkins y obtenemos el contenido de nuestra key privada

cat ~/.ssh/id_rsa

Ahora ir al administrador de Jenkins y vamos a crear las credenciales de tipo: SSH Username with private key. Aqui pegaremos el contenido de nuestra key privada.

5. Crear y ejecutar una tarea tipo Pipeline en Jenkins

Ahora configuraremos una area de tipo pipeline con la url del repositorio y las credenciales de gitlab creadas en Jenkins

Continuamos configurando la rama del repositorio y la ruta del script jenkinsfile

Una vez configurado, vuelve a Jenkins y ejecuta la tarea que has creado. Jenkins utilizará las credenciales SSH para conectarse al servidor remoto y ejecutar el Jenkinsfile alojado en GitLab.

¡Y listo! Has configurado un pipeline funcional en Jenkins utilizando Docker y GitLab.

En conclusión, configurar un pipeline en Jenkins utilizando un Jenkinsfile en GitLab para realizar backups automáticos en un servidor remoto es una práctica esencial para garantizar la seguridad y la disponibilidad de nuestros datos. A través de los tres stages que implementamos, logramos no solo hacer copias de seguridad de nuestra base de datos MySQL, sino también gestionar eficientemente las copias antiguas y almacenarlas de manera segura en Mega utilizando rclone. Esta automatización no solo ahorra tiempo, sino que también minimiza el riesgo de pérdida de datos, lo que es crucial en cualquier entorno de producción. Con esta guía, ahora tienes las herramientas necesarias para implementar y personalizar tu propio pipeline de backups, asegurando la integridad de tu información en todo momento.