Manuelle GitLab Backups: Ein komplettes Skript für faule Leute

In diesem Artikel zeige ich dir, wie du auf einfache Weise manuelle Backups deiner GitLab-Instanz erstellen kannst, um die Sicherheit und Verfügbarkeit deiner Daten zu gewährleisten. Dabei werden nicht nur die GitLab-Daten selbst, sondern auch wichtige Konfigurationsdateien und Logs gesichert. Diese Anleitung bietet dir ein umfassendes Skript, das dir die Arbeit abnimmt und die Backups automatisch auf deinem Server erstellt und auf deinen lokalen Rechner herunterlädt.

Voraussetzungen

• Verzeichnis auf dem lokalen Rechner zum Speichern der Backups
• Zugriff auf den GitLab-Server mit Administratorrechten
• SSH-Schlüsselauthentifizierung zwischen lokalem Rechner und GitLab-Server
• Grundlegende Kenntnisse in der Bedienung der Konsole

Backup von GitLab

Um die Sicherheit und Verfügbarkeit deiner GitLab-Instanz zu gewährleisten, ist es wichtig, regelmäßige Backups durchzuführen. Dabei sollten nicht nur die GitLab-Daten selbst, sondern auch wichtige Konfigurationsdateien gesichert werden. Zu den essenziellen Konfigurationsdateien gehören:

• /etc/gitlab/gitlab-secrets.json
• /etc/gitlab/gitlab.rb

Das Backup der GitLab-Daten wird durch das integrierte Backup-Tool von GitLab durchgeführt. Dieses sichert alle relevanten Datenbanken und Repositories. Hier ist ein Skript, das die Konfigurationsdateien, GitLab-Daten und Logs sichert und die Backups auf den lokalen Rechner herunterlädt.

Beschreibung des Skripts:

• Wahl der zu sichernden Teile: Das Skript fordert den Benutzer auf, auszuwählen, welche Teile gesichert werden sollen: Konfigurationsdateien, GitLab-Daten, Logs oder alles zusammen.
• Überprüfung der Pfade: Es wird überprüft, ob die zu sichernden Verzeichnisse auf dem Server existieren.
• Backup-Erstellung: Basierend auf der Benutzerauswahl werden die Konfigurationsdateien und Logs in tar-Archive gepackt und die GitLab-Daten mit dem integrierten Backup-Tool gesichert.
• Erstellen eines lokalen Backup-Ordners: Auf dem lokalen Rechner wird ein Ordner mit dem aktuellen Datum und der Uhrzeit erstellt.
• Herunterladen der Backups: Die erstellten Backups werden vom Server in den lokalen Backup-Ordner kopiert.
• Option zum Löschen der Backups auf dem Server: Nach dem Herunterladen wird der Benutzer gefragt, ob die Backups auf dem Server gelöscht werden sollen.
• Ausführliche Konsolenausgaben: Das Skript gibt an, welche Schritte es gerade durchführt, um den Fortschritt zu verfolgen.

#!/bin/bash

# Define variables
SERVER_USER="server_user"
SERVER_HOST="server_host"
BACKUP_DIR="/var/opt/gitlab/backups"
LOG_DIR="/var/log/gitlab"
CONFIG_FILES="/etc/gitlab/gitlab-secrets.json /etc/gitlab/gitlab.rb"
LOCAL_BACKUP_BASE_DIR="/path/to/local/backup/directory"

TIMESTAMP=$(date +%s)
DATE_STR=$(date +%Y_%m_%d)
TIME_STR=$(date +%H%M%S)
VERSION=$(ssh ${SERVER_USER}@${SERVER_HOST} "cat /opt/gitlab/embedded/service/gitlab-rails/VERSION")

CONFIG_BACKUP_FILENAME="${TIMESTAMP}_${DATE_STR}_${VERSION}_gitlab_backup_config.tar"
LOG_BACKUP_FILENAME="${TIMESTAMP}_${DATE_STR}_${VERSION}_gitlab_backup_logs.tar"
LOCAL_BACKUP_DIR="${LOCAL_BACKUP_BASE_DIR}/${DATE_STR}_${TIME_STR}_gitlab_backup"

# Create local backup directory
mkdir -p "${LOCAL_BACKUP_DIR}"

# Function to check if a path exists
check_path() {
    ssh ${SERVER_USER}@${SERVER_HOST} "[ -d $1 ]"
}

# Prompt user for backup options
echo "Select which parts to backup:"
echo "1) Configuration files"
echo "2) GitLab data"
echo "3) Logs"
echo "4) All of the above"
read -p "Enter your choice (1/2/3/4): " choice

# Execute the backup commands on the remote server based on the user's choice
case $choice in
    1)
        echo "Backing up configuration files..."
        check_path /etc/gitlab && ssh ${SERVER_USER}@${SERVER_HOST} "cd /etc/gitlab && sudo tar -czf ${BACKUP_DIR}/${CONFIG_BACKUP_FILENAME} gitlab-secrets.json gitlab.rb"
        ;;
    2)
        echo "Backing up GitLab data..."
        check_path /var/opt/gitlab && ssh ${SERVER_USER}@${SERVER_HOST} "sudo gitlab-backup create STRATEGY=copy"
        ;;
    3)
        echo "Backing up logs..."
        check_path /var/log/gitlab && ssh ${SERVER_USER}@${SERVER_HOST} "cd /var/log && sudo tar -czf ${BACKUP_DIR}/${LOG_BACKUP_FILENAME} gitlab"
        ;;
    4)
        echo "Backing up configuration files..."
        check_path /etc/gitlab && ssh ${SERVER_USER}@${SERVER_HOST} "cd /etc/gitlab && sudo tar -czf ${BACKUP_DIR}/${CONFIG_BACKUP_FILENAME} gitlab-secrets.json gitlab.rb"
        echo "Backing up GitLab data..."
        check_path /var/opt/gitlab && ssh ${SERVER_USER}@${SERVER_HOST} "sudo gitlab-backup create STRATEGY=copy"
        echo "Backing up logs..."
        check_path /var/log/gitlab && ssh ${SERVER_USER}@${SERVER_HOST} "cd /var/log && sudo tar -czf ${BACKUP_DIR}/${LOG_BACKUP_FILENAME} gitlab"
        ;;
    *)
        echo "Invalid choice, exiting."
        exit 1
        ;;
esac

# Download backups from server to local machine
echo "Downloading backups from server to local machine..."
scp "${SERVER_USER}@${SERVER_HOST}:${BACKUP_DIR}/${CONFIG_BACKUP_FILENAME}" "${LOCAL_BACKUP_DIR}"
scp "${SERVER_USER}@${SERVER_HOST}:${BACKUP_DIR}/${LOG_BACKUP_FILENAME}" "${LOCAL_BACKUP_DIR}"
scp "${SERVER_USER}@${SERVER_HOST}:${BACKUP_DIR}/*_gitlab_backup.tar" "${LOCAL_BACKUP_DIR}"

echo "Backups downloaded from server to local machine: ${LOCAL_BACKUP_DIR}"

# Ask user if they want to delete the backups on the server
read -p "Do you want to delete the backups on the server? (y/n): " delete_choice
if [ "$delete_choice" = "y" ]; then
    echo "Deleting all backups in the backup directory on the server..."
    ssh ${SERVER_USER}@${SERVER_HOST} "rm -f ${BACKUP_DIR}/*"
    echo "All backups deleted in the backup directory on the server."
else
    echo "Backups retained on the server."
fi

echo "Script completed."

Hinweis zur Anpassung des Skripts

Das oben stehende Skript bietet eine grundlegende Funktionalität zur Sicherung der GitLab-Daten und Konfigurationsdateien. Es ist jedoch wichtig, das Skript an deine spezifischen Anforderungen und Umgebungen anzupassen. Hier sind einige Punkte, die du berücksichtigen solltest:

1. Pfad-Anpassungen:
   • Stelle sicher, dass die definierten Pfade für die Backups sowohl auf dem Server als auch auf deinem lokalen Rechner korrekt sind.
   • Passe die Variablen SERVER_USER, SERVER_HOST, BACKUP_DIR, LOCAL_BACKUP_BASE_DIR etc. an deine Umgebung an.
2. Benutzerberechtigungen:
   • Stelle sicher, dass der Benutzer, der das Skript ausführt, die erforderlichen Berechtigungen zum Erstellen von Backups und zum Löschen von Dateien auf dem Server hat.
3. Zusätzliche Sicherheitsmaßnahmen:
   • Füge zusätzliche Sicherheitsmaßnahmen hinzu, wie z.B. das Verschlüsseln der Backups vor dem Download oder das Einrichten von Benachrichtigungen bei erfolgreicher oder fehlgeschlagener Ausführung.
4. Erweiterte Fehlerbehandlung:
   • Implementiere eine erweiterte Fehlerbehandlung, um sicherzustellen, dass Fehler während des Backup-Prozesses korrekt erkannt und behandelt werden.
5. Automatisierung und Planung:
   • Überlege, das Skript in einem regelmäßigen Intervall automatisch auszuführen, z.B. durch Einrichten eines Cron-Jobs auf deinem lokalen Rechner.

Durch die Anpassung des Skripts an deine speziellen Bedürfnisse kannst du sicherstellen, dass die Backups zuverlässig und sicher erstellt und verwaltet werden.

Links

• https://docs.gitlab.com/ee/administration/backup_restore/backup_gitlab.html