theo/agence66-gitea
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Enhance backup/restore/update scripts with security and best practices

Browse Source 
- Security improvements: set -euo pipefail, secure .env loading, safe PGPASSWORD handling
- Add comprehensive logging to ./logs/ directory for all operations
- Implement SHA256 checksums for backup integrity verification
- Add lock file mechanism to prevent concurrent backups
- Improve error handling with detailed exit codes and cleanup functions
- Add safety backup of current DB before restore operations
- Backup docker-compose.yml before updates with auto-restore on failure
- Replace wget with curl for better reliability in health checks
- Use find -mindepth for safer data directory cleanup
- Add progress indicators with file sizes and operation statistics
- Validate paths and checksums before restore operations
- All operations now log to timestamped files with full traceability

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
BeauTroll
2025-12-17 05:42:54 +01:00
parent 930bb88417
commit eff651e720
3 changed files with 405 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
scripts/backup.sh
View File

@@ -8,17 +8,20 @@
# - Configuration Gitea # - Configuration Gitea
# - Données utilisateur # - Données utilisateur
set -e # Arrêter en cas d'erreur set -euo pipefail # Arrêter en cas d'erreur, variables non définies, erreurs dans pipes
# Couleurs pour l'affichage # Couleurs pour l'affichage
RED='\033[0;31m' RED='\033[0;31m'
GREEN='\033[0;32m' GREEN='\033[0;32m'
YELLOW='\033[1;33m' YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color NC='\033[0m' # No Color
# Charger les variables d'environnement # Charger les variables d'environnement de manière sécurisée
if [ -f .env ]; then if [ -f .env ]; then
set -a
source .env source .env
set +a
else else
echo -e "${RED}Erreur: Fichier .env non trouvé${NC}" echo -e "${RED}Erreur: Fichier .env non trouvé${NC}"
exit 1 exit 1
@@ -30,23 +33,48 @@ TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_NAME="gitea_backup_${TIMESTAMP}" BACKUP_NAME="gitea_backup_${TIMESTAMP}"
TEMP_DIR="${BACKUP_DIR}/${BACKUP_NAME}" TEMP_DIR="${BACKUP_DIR}/${BACKUP_NAME}"
RETENTION_DAYS=${BACKUP_RETENTION_DAYS:-7} RETENTION_DAYS=${BACKUP_RETENTION_DAYS:-7}
LOCK_FILE="/tmp/gitea_backup.lock"
LOG_DIR="./logs"
LOG_FILE="${LOG_DIR}/backup_${TIMESTAMP}.log"
# Vérifier que les variables nécessaires sont définies # Vérifier que les variables nécessaires sont définies
if [ -z "$POSTGRES_DATABASE" ] || [ -z "$POSTGRES_USER" ] || [ -z "$POSTGRES_PASSWORD" ]; then if [ -z "${POSTGRES_DATABASE:-}" ] || [ -z "${POSTGRES_USER:-}" ] || [ -z "${POSTGRES_PASSWORD:-}" ]; then
echo -e "${RED}Erreur: Variables PostgreSQL non définies dans .env${NC}" echo -e "${RED}Erreur: Variables PostgreSQL non définies dans .env${NC}"
exit 1 exit 1
fi fi
# Vérifier qu'une sauvegarde n'est pas déjà en cours
if [ -f "$LOCK_FILE" ]; then
echo -e "${RED}Erreur: Une sauvegarde est déjà en cours${NC}"
echo "Si aucune sauvegarde n'est en cours, supprimez le fichier: $LOCK_FILE"
exit 1
fi
# Créer le fichier de lock
touch "$LOCK_FILE"
# Fonction de nettoyage en cas d'erreur # Fonction de nettoyage en cas d'erreur
cleanup() { cleanup() {
local exit_code=$?
if [ -d "$TEMP_DIR" ]; then if [ -d "$TEMP_DIR" ]; then
echo -e "${YELLOW}Nettoyage des fichiers temporaires...${NC}" echo -e "${YELLOW}Nettoyage des fichiers temporaires...${NC}"
rm -rf "$TEMP_DIR" rm -rf "$TEMP_DIR"
fi fi
# Supprimer le fichier de lock
rm -f "$LOCK_FILE"
if [ $exit_code -ne 0 ]; then
echo -e "${RED}Sauvegarde échouée avec le code: $exit_code${NC}"
fi
} }
# Piège pour nettoyer en cas d'erreur # Piège pour nettoyer en cas d'erreur ou de fin
trap cleanup EXIT trap cleanup EXIT INT TERM
# Fonction de logging
log() {
echo -e "$@" | tee -a "$LOG_FILE"
}
echo -e "${GREEN}=== Début de la sauvegarde Gitea ===${NC}" echo -e "${GREEN}=== Début de la sauvegarde Gitea ===${NC}"
echo "Timestamp: $TIMESTAMP" echo "Timestamp: $TIMESTAMP"
@@ -54,52 +82,77 @@ echo "Timestamp: $TIMESTAMP"
# Créer les répertoires si nécessaire # Créer les répertoires si nécessaire
mkdir -p "$BACKUP_DIR" mkdir -p "$BACKUP_DIR"
mkdir -p "$TEMP_DIR" mkdir -p "$TEMP_DIR"
mkdir -p "$LOG_DIR"
# Initialiser le fichier de log
log "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')] Début de la sauvegarde${NC}"
log "Backup name: $BACKUP_NAME"
# Vérifier que les conteneurs sont en cours d'exécution # Vérifier que les conteneurs sont en cours d'exécution
if ! docker compose ps | grep -q "gitea.*running"; then if ! docker compose ps | grep -q 'gitea.*running'; then
echo -e "${RED}Erreur: Le conteneur Gitea n'est pas en cours d'exécution${NC}" log "${RED}Erreur: Le conteneur Gitea n'est pas en cours d'exécution${NC}"
exit 1 exit 1
fi fi
echo -e "${YELLOW}[1/4] Sauvegarde de la base de données PostgreSQL...${NC}" log "${YELLOW}[1/5] Sauvegarde de la base de données PostgreSQL...${NC}"
# Exporter la base de données # Exporter la base de données (PGPASSWORD passé de manière sécurisée)
export PGPASSWORD="$POSTGRES_PASSWORD" if ! docker compose exec -T -e PGPASSWORD="$POSTGRES_PASSWORD" db pg_dump \
docker compose exec -T db pg_dump -U "$POSTGRES_USER" -d "$POSTGRES_DATABASE" \ -U "$POSTGRES_USER" \
-d "$POSTGRES_DATABASE" \
--format=custom \ --format=custom \
--compress=9 \ --compress=9 \
--no-owner \ --no-owner \
--no-acl \ --no-acl \
> "${TEMP_DIR}/database.dump" > "${TEMP_DIR}/database.dump" 2>> "$LOG_FILE"; then
log "${RED}Erreur: pg_dump a échoué${NC}"
if [ ! -s "${TEMP_DIR}/database.dump" ]; then
echo -e "${RED}Erreur: Le dump de la base de données est vide${NC}"
exit 1 exit 1
fi fi
echo -e "${GREEN}✓ Base de données sauvegardée${NC}"
echo -e "${YELLOW}[2/4] Sauvegarde des dépôts Git et données...${NC}" if [ ! -s "${TEMP_DIR}/database.dump" ]; then
log "${RED}Erreur: Le dump de la base de données est vide${NC}"
exit 1
fi
DB_SIZE=$(du -h "${TEMP_DIR}/database.dump" | cut -f1)
log "${GREEN}✓ Base de données sauvegardée (${DB_SIZE})${NC}"
log "${YELLOW}[2/5] Sauvegarde des dépôts Git et données...${NC}"
# Créer une archive des dépôts et données # Créer une archive des dépôts et données
docker compose exec -T gitea tar czf - \ if ! docker compose exec -T gitea tar czf - \
-C /data \ -C /data \
--exclude='./log' \ --exclude='./log' \
--exclude='./cache' \ --exclude='./cache' \
--exclude='./tmp' \ --exclude='./tmp' \
--exclude='./sessions' \ --exclude='./sessions' \
. > "${TEMP_DIR}/gitea_data.tar.gz" . > "${TEMP_DIR}/gitea_data.tar.gz" 2>> "$LOG_FILE"; then
log "${RED}Erreur: Création de l'archive des données a échoué${NC}"
if [ ! -s "${TEMP_DIR}/gitea_data.tar.gz" ]; then
echo -e "${RED}Erreur: L'archive des données est vide${NC}"
exit 1 exit 1
fi fi
echo -e "${GREEN}✓ Dépôts et données sauvegardés${NC}"
echo -e "${YELLOW}[3/4] Création de l'archive finale...${NC}" if [ ! -s "${TEMP_DIR}/gitea_data.tar.gz" ]; then
log "${RED}Erreur: L'archive des données est vide${NC}"
exit 1
fi
DATA_SIZE=$(du -h "${TEMP_DIR}/gitea_data.tar.gz" | cut -f1)
log "${GREEN}✓ Dépôts et données sauvegardés (${DATA_SIZE})${NC}"
log "${YELLOW}[3/5] Création de l'archive finale...${NC}"
# Créer l'archive finale # Créer l'archive finale
cd "$BACKUP_DIR" if ! cd "$BACKUP_DIR"; then
tar czf "${BACKUP_NAME}.tar.gz" "${BACKUP_NAME}/" log "${RED}Erreur: Impossible d'accéder au répertoire $BACKUP_DIR${NC}"
exit 1
fi
if ! tar czf "${BACKUP_NAME}.tar.gz" "${BACKUP_NAME}/"; then
log "${RED}Erreur: Création de l'archive finale a échoué${NC}"
cd - > /dev/null
exit 1
fi
if [ ! -s "${BACKUP_NAME}.tar.gz" ]; then if [ ! -s "${BACKUP_NAME}.tar.gz" ]; then
echo -e "${RED}Erreur: L'archive finale est vide${NC}" log "${RED}Erreur: L'archive finale est vide${NC}"
cd - > /dev/null
exit 1 exit 1
fi fi
@@ -108,14 +161,39 @@ rm -rf "${BACKUP_NAME}"
cd - > /dev/null cd - > /dev/null
BACKUP_SIZE=$(du -h "${BACKUP_DIR}/${BACKUP_NAME}.tar.gz" | cut -f1) BACKUP_SIZE=$(du -h "${BACKUP_DIR}/${BACKUP_NAME}.tar.gz" | cut -f1)
echo -e "${GREEN}✓ Archive créée: ${BACKUP_NAME}.tar.gz (${BACKUP_SIZE})${NC}" log "${GREEN}✓ Archive créée: ${BACKUP_NAME}.tar.gz (${BACKUP_SIZE})${NC}"
log "${YELLOW}[4/5] Génération du checksum de sécurité...${NC}"
# Générer le checksum SHA256
if ! cd "$BACKUP_DIR"; then
log "${RED}Erreur: Impossible d'accéder au répertoire $BACKUP_DIR${NC}"
exit 1
fi
sha256sum "${BACKUP_NAME}.tar.gz" > "${BACKUP_NAME}.tar.gz.sha256"
CHECKSUM=$(cut -d' ' -f1 "${BACKUP_NAME}.tar.gz.sha256")
cd - > /dev/null
log "${GREEN}✓ Checksum: ${CHECKSUM:0:16}...${NC}"
log "${YELLOW}[5/5] Nettoyage des anciennes sauvegardes (>$RETENTION_DAYS jours)...${NC}"
# Supprimer les sauvegardes plus anciennes que RETENTION_DAYS (fichiers .tar.gz et .sha256)
DELETED_COUNT=0
while IFS= read -r -d '' old_backup; do
log " Suppression: $(basename "$old_backup")"
rm -f "$old_backup" "${old_backup}.sha256"
DELETED_COUNT=$((DELETED_COUNT + 1))
done < <(find "$BACKUP_DIR" -name "gitea_backup_*.tar.gz" -type f -mtime +"$RETENTION_DAYS" -print0)
echo -e "${YELLOW}[4/4] Nettoyage des anciennes sauvegardes (>$RETENTION_DAYS jours)...${NC}"
# Supprimer les sauvegardes plus anciennes que RETENTION_DAYS
find "$BACKUP_DIR" -name "gitea_backup_*.tar.gz" -type f -mtime +$RETENTION_DAYS -delete
REMAINING_BACKUPS=$(find "$BACKUP_DIR" -name "gitea_backup_*.tar.gz" -type f | wc -l) REMAINING_BACKUPS=$(find "$BACKUP_DIR" -name "gitea_backup_*.tar.gz" -type f | wc -l)
echo -e "${GREEN}✓ Sauvegardes restantes: $REMAINING_BACKUPS${NC}" log "${GREEN}✓ Sauvegardes supprimées: $DELETED_COUNT | Restantes: $REMAINING_BACKUPS${NC}"
echo -e "${GREEN}=== Sauvegarde terminée avec succès ===${NC}" # Statistiques finales
echo "Fichier: ${BACKUP_DIR}/${BACKUP_NAME}.tar.gz" END_TIME=$(date '+%Y-%m-%d %H:%M:%S')
echo "Taille: $BACKUP_SIZE" log ""
log "${GREEN}=== Sauvegarde terminée avec succès ===${NC}"
log "Fichier: ${BACKUP_DIR}/${BACKUP_NAME}.tar.gz"
log "Taille: $BACKUP_SIZE"
log "Checksum: ${BACKUP_DIR}/${BACKUP_NAME}.tar.gz.sha256"
log "Log: $LOG_FILE"
log "Terminé: $END_TIME"

235
scripts/restore.sh
View File

@@ -5,16 +5,17 @@
# Ce script restaure une sauvegarde complète de Gitea # Ce script restaure une sauvegarde complète de Gitea
# ATTENTION: Cette opération est destructive! # ATTENTION: Cette opération est destructive!
set -e # Arrêter en cas d'erreur set -euo pipefail # Arrêter en cas d'erreur, variables non définies, erreurs dans pipes
# Couleurs pour l'affichage # Couleurs pour l'affichage
RED='\033[0;31m' RED='\033[0;31m'
GREEN='\033[0;32m' GREEN='\033[0;32m'
YELLOW='\033[1;33m' YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color NC='\033[0m' # No Color
# Vérifier qu'un fichier de sauvegarde a été fourni # Vérifier qu'un fichier de sauvegarde a été fourni
if [ -z "$1" ]; then if [ -z "${1:-}" ]; then
echo -e "${RED}Erreur: Aucun fichier de sauvegarde spécifié${NC}" echo -e "${RED}Erreur: Aucun fichier de sauvegarde spécifié${NC}"
echo "Usage: $0 <fichier_sauvegarde.tar.gz>" echo "Usage: $0 <fichier_sauvegarde.tar.gz>"
echo "Exemple: $0 backups/gitea_backup_20240101_120000.tar.gz" echo "Exemple: $0 backups/gitea_backup_20240101_120000.tar.gz"
@@ -37,21 +38,48 @@ fi
# Validation du chemin (sécurité contre path traversal) # Validation du chemin (sécurité contre path traversal)
BACKUP_FILE=$(realpath "$BACKUP_FILE") BACKUP_FILE=$(realpath "$BACKUP_FILE")
if [[ "$BACKUP_FILE" == *".."* ]]; then BACKUPS_DIR=$(realpath "./backups" 2>/dev/null || echo "")
echo -e "${RED}Erreur: Chemin invalide (path traversal détecté)${NC}" if [ -n "$BACKUPS_DIR" ] && [[ "$BACKUP_FILE" != "$BACKUPS_DIR"* ]]; then
exit 1 echo -e "${YELLOW}Avertissement: Le fichier n'est pas dans le répertoire backups${NC}"
read -p "Continuer quand même? (oui/non) " -r
if [[ ! $REPLY =~ ^[Oo][Uu][Ii]$ ]]; then
echo "Restauration annulée."
exit 0
fi
fi fi
# Charger les variables d'environnement # Vérifier le checksum si disponible
CHECKSUM_FILE="${BACKUP_FILE}.sha256"
if [ -f "$CHECKSUM_FILE" ]; then
echo -e "${BLUE}Vérification du checksum...${NC}"
if cd "$(dirname "$BACKUP_FILE")" && sha256sum -c "$(basename "$CHECKSUM_FILE")" > /dev/null 2>&1; then
echo -e "${GREEN}✓ Checksum valide${NC}"
cd - > /dev/null
else
echo -e "${RED}Erreur: Checksum invalide! Le fichier peut être corrompu.${NC}"
cd - > /dev/null 2>&1 || true
read -p "Continuer quand même? (oui/non) " -r
if [[ ! $REPLY =~ ^[Oo][Uu][Ii]$ ]]; then
echo "Restauration annulée."
exit 0
fi
fi
else
echo -e "${YELLOW}Avertissement: Aucun fichier checksum trouvé${NC}"
fi
# Charger les variables d'environnement de manière sécurisée
if [ -f .env ]; then if [ -f .env ]; then
set -a
source .env source .env
set +a
else else
echo -e "${RED}Erreur: Fichier .env non trouvé${NC}" echo -e "${RED}Erreur: Fichier .env non trouvé${NC}"
exit 1 exit 1
fi fi
# Vérifier que les variables nécessaires sont définies # Vérifier que les variables nécessaires sont définies
if [ -z "$POSTGRES_DATABASE" ] || [ -z "$POSTGRES_USER" ] || [ -z "$POSTGRES_PASSWORD" ]; then if [ -z "${POSTGRES_DATABASE:-}" ] || [ -z "${POSTGRES_USER:-}" ] || [ -z "${POSTGRES_PASSWORD:-}" ]; then
echo -e "${RED}Erreur: Variables PostgreSQL non définies dans .env${NC}" echo -e "${RED}Erreur: Variables PostgreSQL non définies dans .env${NC}"
exit 1 exit 1
fi fi
@@ -59,55 +87,83 @@ fi
# Variables # Variables
TEMP_DIR=$(mktemp -d) TEMP_DIR=$(mktemp -d)
BACKUP_NAME=$(basename "$BACKUP_FILE" .tar.gz) BACKUP_NAME=$(basename "$BACKUP_FILE" .tar.gz)
LOG_DIR="./logs"
LOG_FILE="${LOG_DIR}/restore_$(date +%Y%m%d_%H%M%S).log"
# Créer le répertoire de logs
mkdir -p "$LOG_DIR"
# Fonction de logging
log() {
echo -e "$@" | tee -a "$LOG_FILE"
}
# Fonction de nettoyage # Fonction de nettoyage
cleanup() { cleanup() {
local exit_code=$?
if [ -d "$TEMP_DIR" ]; then if [ -d "$TEMP_DIR" ]; then
echo -e "${YELLOW}Nettoyage des fichiers temporaires...${NC}" log "${YELLOW}Nettoyage des fichiers temporaires...${NC}"
rm -rf "$TEMP_DIR" rm -rf "$TEMP_DIR"
fi fi
if [ $exit_code -ne 0 ]; then
log "${RED}Restauration échouée avec le code: $exit_code${NC}"
log "${YELLOW}Les services peuvent être dans un état incohérent.${NC}"
log "Consultez le log: $LOG_FILE"
fi
} }
# Piège pour nettoyer en cas d'erreur ou d'interruption # Piège pour nettoyer en cas d'erreur ou d'interruption
trap cleanup EXIT INT TERM trap cleanup EXIT INT TERM
echo -e "${RED}=== ATTENTION: Restauration de Gitea ===${NC}" log "${RED}=== ATTENTION: Restauration de Gitea ===${NC}"
echo "Fichier de sauvegarde: $BACKUP_FILE" log "Fichier de sauvegarde: $BACKUP_FILE"
echo -e "${RED}Cette opération va ÉCRASER toutes les données actuelles!${NC}" log "${RED}Cette opération va ÉCRASER toutes les données actuelles!${NC}"
echo "" echo ""
read -p "Êtes-vous sûr de vouloir continuer? (oui/non) " -r read -p "Êtes-vous sûr de vouloir continuer? (oui/non) " -r
if [[ ! $REPLY =~ ^[Oo][Uu][Ii]$ ]]; then if [[ ! $REPLY =~ ^[Oo][Uu][Ii]$ ]]; then
echo "Restauration annulée." log "Restauration annulée par l'utilisateur."
exit 0 exit 0
fi fi
echo -e "${GREEN}=== Début de la restauration ===${NC}" # Créer un backup de sécurité de la DB actuelle avant de la dropper
SAFETY_BACKUP_DIR="${TEMP_DIR}/safety_backup"
mkdir -p "$SAFETY_BACKUP_DIR"
echo -e "${YELLOW}[1/5] Extraction de l'archive...${NC}" log ""
tar xzf "$BACKUP_FILE" -C "$TEMP_DIR" log "${GREEN}=== Début de la restauration ===${NC}"
log "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')]${NC}"
log "${YELLOW}[1/6] Extraction de l'archive...${NC}"
if ! tar xzf "$BACKUP_FILE" -C "$TEMP_DIR" 2>> "$LOG_FILE"; then
log "${RED}Erreur: Échec de l'extraction de l'archive${NC}"
exit 1
fi
# Trouver le répertoire de sauvegarde # Trouver le répertoire de sauvegarde
BACKUP_DIR=$(find "$TEMP_DIR" -maxdepth 1 -type d -name "gitea_backup_*" | head -n 1) BACKUP_DIR=$(find "$TEMP_DIR" -maxdepth 1 -type d -name "gitea_backup_*" | head -n 1)
if [ -z "$BACKUP_DIR" ]; then if [ -z "$BACKUP_DIR" ]; then
echo -e "${RED}Erreur: Structure de sauvegarde invalide${NC}" log "${RED}Erreur: Structure de sauvegarde invalide${NC}"
exit 1 exit 1
fi fi
# Vérifier que les fichiers nécessaires existent # Vérifier que les fichiers nécessaires existent
if [ ! -f "$BACKUP_DIR/database.dump" ] || [ ! -f "$BACKUP_DIR/gitea_data.tar.gz" ]; then if [ ! -f "$BACKUP_DIR/database.dump" ] || [ ! -f "$BACKUP_DIR/gitea_data.tar.gz" ]; then
echo -e "${RED}Erreur: Fichiers de sauvegarde manquants${NC}" log "${RED}Erreur: Fichiers de sauvegarde manquants${NC}"
log "Contenu trouvé: $(ls -la "$BACKUP_DIR" 2>&1)"
exit 1 exit 1
fi fi
echo -e "${GREEN}✓ Archive extraite${NC}" log "${GREEN}✓ Archive extraite et vérifiée${NC}"
echo -e "${YELLOW}[2/5] Arrêt des services...${NC}" log "${YELLOW}[2/6] Arrêt des services...${NC}"
docker compose down if ! docker compose down 2>> "$LOG_FILE"; then
echo -e "${GREEN}✓ Services arrêtés${NC}" log "${YELLOW}Avertissement: Erreur lors de l'arrêt des services${NC}"
fi
log "${GREEN}✓ Services arrêtés${NC}"
echo -e "${YELLOW}[3/5] Démarrage de la base de données...${NC}" log "${YELLOW}[3/6] Démarrage de PostgreSQL et backup de sécurité...${NC}"
docker compose up -d db docker compose up -d db
echo "Attente du démarrage de PostgreSQL..." log "Attente du démarrage de PostgreSQL..."
sleep 10
# Attendre que PostgreSQL soit prêt # Attendre que PostgreSQL soit prêt
MAX_TRIES=30 MAX_TRIES=30
@@ -115,77 +171,124 @@ COUNTER=0
until docker compose exec -T db pg_isready -U "$POSTGRES_USER" > /dev/null 2>&1; do until docker compose exec -T db pg_isready -U "$POSTGRES_USER" > /dev/null 2>&1; do
COUNTER=$((COUNTER + 1)) COUNTER=$((COUNTER + 1))
if [ $COUNTER -gt $MAX_TRIES ]; then if [ $COUNTER -gt $MAX_TRIES ]; then
echo -e "${RED}Erreur: PostgreSQL ne démarre pas${NC}" log "${RED}Erreur: PostgreSQL ne démarre pas${NC}"
exit 1 exit 1
fi fi
echo "En attente de PostgreSQL... ($COUNTER/$MAX_TRIES)" log "En attente de PostgreSQL... ($COUNTER/$MAX_TRIES)"
sleep 2 sleep 2
done done
echo -e "${GREEN}✓ PostgreSQL prêt${NC}" log "${GREEN}✓ PostgreSQL prêt${NC}"
echo -e "${YELLOW}[4/5] Restauration de la base de données...${NC}" # Créer un backup de sécurité de la DB actuelle
log "${BLUE}Création d'un backup de sécurité de la DB actuelle...${NC}"
if docker compose exec -T -e PGPASSWORD="$POSTGRES_PASSWORD" db pg_dump \
-U "$POSTGRES_USER" \
-d "$POSTGRES_DATABASE" \
--format=custom \
> "$SAFETY_BACKUP_DIR/current_db.dump" 2>> "$LOG_FILE"; then
log "${GREEN}✓ Backup de sécurité créé${NC}"
else
log "${YELLOW}Avertissement: Impossible de créer le backup de sécurité (DB peut ne pas exister)${NC}"
fi
log "${YELLOW}[4/6] Restauration de la base de données...${NC}"
# Supprimer et recréer la base de données # Supprimer et recréer la base de données
export PGPASSWORD="$POSTGRES_PASSWORD" if ! docker compose exec -T -e PGPASSWORD="$POSTGRES_PASSWORD" db psql \
docker compose exec -T db psql -U "$POSTGRES_USER" -d postgres -c "DROP DATABASE IF EXISTS $POSTGRES_DATABASE;" -U "$POSTGRES_USER" -d postgres \
docker compose exec -T db psql -U "$POSTGRES_USER" -d postgres -c "CREATE DATABASE $POSTGRES_DATABASE OWNER $POSTGRES_USER;" -c "DROP DATABASE IF EXISTS $POSTGRES_DATABASE;" 2>> "$LOG_FILE"; then
log "${RED}Erreur: Échec de la suppression de la base de données${NC}"
exit 1
fi
if ! docker compose exec -T -e PGPASSWORD="$POSTGRES_PASSWORD" db psql \
-U "$POSTGRES_USER" -d postgres \
-c "CREATE DATABASE $POSTGRES_DATABASE OWNER $POSTGRES_USER;" 2>> "$LOG_FILE"; then
log "${RED}Erreur: Échec de la création de la base de données${NC}"
exit 1
fi
# Restaurer le dump # Restaurer le dump
docker compose exec -T db pg_restore \ if ! docker compose exec -T -e PGPASSWORD="$POSTGRES_PASSWORD" db pg_restore \
-U "$POSTGRES_USER" \ -U "$POSTGRES_USER" \
-d "$POSTGRES_DATABASE" \ -d "$POSTGRES_DATABASE" \
--clean \ --clean \
--if-exists \ --if-exists \
--no-owner \ --no-owner \
--no-acl \ --no-acl \
< "$BACKUP_DIR/database.dump" < "$BACKUP_DIR/database.dump" 2>> "$LOG_FILE"; then
log "${RED}Erreur: Échec de la restauration de la base de données${NC}"
echo -e "${GREEN}✓ Base de données restaurée${NC}" log "${YELLOW}Le backup de sécurité est disponible dans: $SAFETY_BACKUP_DIR/current_db.dump${NC}"
exit 1
echo -e "${YELLOW}[5/5] Restauration des données Gitea...${NC}"
# Démarrer Gitea
docker compose up -d gitea redis
# Attendre que Gitea soit prêt
echo "Attente du démarrage de Gitea..."
sleep 15
# Arrêter temporairement Gitea pour la restauration des fichiers
docker compose stop gitea
# Nettoyer les données existantes
if [ -d "./data" ]; then
echo "Suppression des anciennes données..."
rm -rf ./data/*
fi fi
log "${GREEN}✓ Base de données restaurée${NC}"
log "${YELLOW}[5/6] Restauration des données Gitea...${NC}"
# Arrêter Gitea s'il tourne
docker compose stop gitea 2>/dev/null || true
# Nettoyer les données existantes de manière sécurisée
DATA_DIR="./data"
if [ -d "$DATA_DIR" ]; then
# Vérifier que c'est bien le bon répertoire
if [ "$DATA_DIR" = "./data" ]; then
log "Suppression des anciennes données..."
# Utiliser find pour une suppression plus sûre
find "$DATA_DIR" -mindepth 1 -delete 2>> "$LOG_FILE" || {
log "${YELLOW}Avertissement: Échec du nettoyage partiel${NC}"
}
else
log "${RED}Erreur: Répertoire de données invalide: $DATA_DIR${NC}"
exit 1
fi
fi
# Créer le répertoire de données
mkdir -p "$DATA_DIR"
# Extraire les données depuis l'archive # Extraire les données depuis l'archive
mkdir -p ./data log "Extraction des données Gitea..."
tar xzf "$BACKUP_DIR/gitea_data.tar.gz" -C ./data if ! tar xzf "$BACKUP_DIR/gitea_data.tar.gz" -C "$DATA_DIR" 2>> "$LOG_FILE"; then
log "${RED}Erreur: Échec de l'extraction des données Gitea${NC}"
exit 1
fi
echo -e "${GREEN}✓ Données restaurées${NC}" # Vérifier les permissions
log "Vérification des permissions..."
if [ -d "$DATA_DIR/gitea" ]; then
log "${GREEN}✓ Données restaurées${NC}"
else
log "${YELLOW}Avertissement: Structure de données inattendue${NC}"
fi
echo -e "${YELLOW}Redémarrage de tous les services...${NC}" log "${YELLOW}[6/6] Redémarrage de tous les services...${NC}"
# Démarrer tous les services (db, redis, gitea)
docker compose up -d docker compose up -d
# Attendre que les services soient prêts # Attendre que les services soient prêts
log "Attente du démarrage complet..."
sleep 10 sleep 10
MAX_TRIES=30 MAX_TRIES=30
COUNTER=0 COUNTER=0
until docker compose ps | grep -q "gitea.*running"; do until docker compose ps | grep -q 'gitea.*running'; do
COUNTER=$((COUNTER + 1)) COUNTER=$((COUNTER + 1))
if [ $COUNTER -gt $MAX_TRIES ]; then if [ $COUNTER -gt $MAX_TRIES ]; then
echo -e "${YELLOW}Avertissement: Gitea met du temps à démarrer${NC}" log "${YELLOW}Avertissement: Gitea met du temps à démarrer${NC}"
break break
fi fi
echo "En attente de Gitea... ($COUNTER/$MAX_TRIES)" log "En attente de Gitea... ($COUNTER/$MAX_TRIES)"
sleep 2 sleep 2
done done
echo -e "${GREEN}=== Restauration terminée avec succès ===${NC}" log ""
echo "Gitea devrait être accessible sur: http://localhost:3000" log "${GREEN}=== Restauration terminée avec succès ===${NC}"
echo "" log "Gitea devrait être accessible sur: http://localhost:3000"
echo "Vérifications recommandées:" log ""
echo " - Vérifier l'accès web" log "Vérifications recommandées:"
echo " - Tester l'authentification" log " - Vérifier l'accès web"
echo " - Vérifier les dépôts" log " - Tester l'authentification"
echo " - Consulter les logs: docker compose logs -f gitea" log " - Vérifier les dépôts"
log " - Consulter les logs: docker compose logs -f gitea"
log ""
log "Log de restauration: $LOG_FILE"
log "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')] Restauration terminée${NC}"

175
scripts/update.sh
View File

@@ -5,102 +5,173 @@
# Ce script met à jour Gitea de manière sécurisée # Ce script met à jour Gitea de manière sécurisée
# avec une sauvegarde automatique avant la mise à jour # avec une sauvegarde automatique avant la mise à jour
set -e # Arrêter en cas d'erreur set -euo pipefail # Arrêter en cas d'erreur, variables non définies, erreurs dans pipes
# Couleurs pour l'affichage # Couleurs pour l'affichage
RED='\033[0;31m' RED='\033[0;31m'
GREEN='\033[0;32m' GREEN='\033[0;32m'
YELLOW='\033[1;33m' YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color NC='\033[0m' # No Color
# Charger les variables d'environnement # Charger les variables d'environnement de manière sécurisée
if [ -f .env ]; then if [ -f .env ]; then
set -a
source .env source .env
set +a
else else
echo -e "${RED}Erreur: Fichier .env non trouvé${NC}" echo -e "${RED}Erreur: Fichier .env non trouvé${NC}"
exit 1 exit 1
fi fi
# Fonction de nettoyage en cas d'erreur # Variables
cleanup() { LOG_DIR="./logs"
echo -e "${YELLOW}Une erreur s'est produite. Vérifiez l'état des services.${NC}" LOG_FILE="${LOG_DIR}/update_$(date +%Y%m%d_%H%M%S).log"
echo "Pour revenir à l'état précédent, utilisez la dernière sauvegarde:"
echo " make restore FILE=backups/gitea_backup_*.tar.gz" # Créer le répertoire de logs
mkdir -p "$LOG_DIR"
# Fonction de logging
log() {
echo -e "$@" | tee -a "$LOG_FILE"
} }
trap cleanup ERR # Fonction de nettoyage en cas d'erreur
cleanup() {
local exit_code=$?
if [ $exit_code -ne 0 ]; then
log "${RED}Erreur lors de la mise à jour (code: $exit_code)${NC}"
log "${YELLOW}Vérifiez l'état des services: docker compose ps${NC}"
log "Pour revenir à l'état précédent, utilisez la dernière sauvegarde:"
LATEST_BACKUP=$(ls -t backups/gitea_backup_*.tar.gz 2>/dev/null | head -n 1)
if [ -n "$LATEST_BACKUP" ]; then
log " make restore FILE=$LATEST_BACKUP"
fi
log "Log: $LOG_FILE"
fi
}
echo -e "${GREEN}=== Mise à jour de Gitea ===${NC}" trap cleanup EXIT INT TERM
echo ""
log "${GREEN}=== Mise à jour de Gitea ===${NC}"
log "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')] Début de la mise à jour${NC}"
log ""
# Sauvegarder la version actuelle
CURRENT_VERSION=""
if docker compose ps | grep -q 'gitea.*running'; then
CURRENT_VERSION=$(docker compose exec -T gitea gitea --version 2>/dev/null | head -n 1 || echo "Inconnue")
log "Version actuelle: $CURRENT_VERSION"
fi
# Vérifier que les services tournent # Vérifier que les services tournent
if ! docker compose ps | grep -q "gitea.*running"; then if ! docker compose ps | grep -q 'gitea.*running'; then
echo -e "${YELLOW}Avertissement: Gitea ne semble pas être en cours d'exécution${NC}" log "${YELLOW}Avertissement: Gitea ne semble pas être en cours d'exécution${NC}"
read -p "Continuer quand même? (oui/non) " -r read -p "Continuer quand même? (oui/non) " -r
if [[ ! $REPLY =~ ^[Oo][Uu][Ii]$ ]]; then if [[ ! $REPLY =~ ^[Oo][Uu][Ii]$ ]]; then
echo "Mise à jour annulée." log "Mise à jour annulée par l'utilisateur."
exit 0 exit 0
fi fi
fi fi
echo -e "${YELLOW}[1/6] Création d'une sauvegarde de sécurité...${NC}" log "${YELLOW}[1/7] Sauvegarde du docker-compose.yml...${NC}"
if ! bash scripts/backup.sh; then # Sauvegarder docker-compose.yml au cas où
echo -e "${RED}Erreur: La sauvegarde a échoué. Mise à jour annulée.${NC}" COMPOSE_BACKUP="docker-compose.yml.backup.$(date +%Y%m%d_%H%M%S)"
if [ -f docker-compose.yml ]; then
cp docker-compose.yml "$COMPOSE_BACKUP"
log "${GREEN}✓ docker-compose.yml sauvegardé: $COMPOSE_BACKUP${NC}"
else
log "${YELLOW}Avertissement: docker-compose.yml non trouvé${NC}"
fi
log "${YELLOW}[2/7] Création d'une sauvegarde de sécurité...${NC}"
if ! bash scripts/backup.sh 2>&1 | tee -a "$LOG_FILE"; then
log "${RED}Erreur: La sauvegarde a échoué. Mise à jour annulée.${NC}"
exit 1 exit 1
fi fi
echo -e "${GREEN}✓ Sauvegarde créée${NC}" log "${GREEN}✓ Sauvegarde créée${NC}"
echo -e "${YELLOW}[2/6] Téléchargement des nouvelles images...${NC}" log "${YELLOW}[3/7] Téléchargement des nouvelles images...${NC}"
docker compose pull if ! docker compose pull 2>&1 | tee -a "$LOG_FILE"; then
echo -e "${GREEN}✓ Images téléchargées${NC}" log "${RED}Erreur: Échec du téléchargement des images${NC}"
exit 1
fi
log "${GREEN}✓ Images téléchargées${NC}"
echo -e "${YELLOW}[3/6] Arrêt des services...${NC}" log "${YELLOW}[4/7] Arrêt des services...${NC}"
docker compose down if ! docker compose down 2>&1 | tee -a "$LOG_FILE"; then
echo -e "${GREEN}✓ Services arrêtés${NC}" log "${YELLOW}Avertissement: Erreur lors de l'arrêt des services${NC}"
fi
log "${GREEN}✓ Services arrêtés${NC}"
echo -e "${YELLOW}[4/6] Démarrage avec les nouvelles versions...${NC}" log "${YELLOW}[5/7] Démarrage avec les nouvelles versions...${NC}"
docker compose up -d if ! docker compose up -d 2>&1 | tee -a "$LOG_FILE"; then
echo -e "${GREEN}✓ Services démarrés${NC}" log "${RED}Erreur: Échec du démarrage des services${NC}"
exit 1
fi
log "${GREEN}✓ Services démarrés${NC}"
echo -e "${YELLOW}[5/6] Attente du démarrage complet...${NC}" log "${YELLOW}[6/7] Attente du démarrage complet et health check...${NC}"
sleep 10 sleep 10
# Attendre que Gitea soit prêt # Attendre que Gitea soit prêt (utiliser curl au lieu de wget)
MAX_TRIES=60 MAX_TRIES=60
COUNTER=0 COUNTER=0
until docker compose exec -T gitea wget -q --spider http://localhost:3000/api/healthz 2>/dev/null; do until docker compose exec -T gitea curl -sf http://localhost:3000/api/healthz >/dev/null 2>&1; do
COUNTER=$((COUNTER + 1)) COUNTER=$((COUNTER + 1))
if [ $COUNTER -gt $MAX_TRIES ]; then if [ $COUNTER -gt $MAX_TRIES ]; then
echo -e "${RED}Erreur: Gitea ne répond pas après la mise à jour${NC}" log "${RED}Erreur: Gitea ne répond pas après la mise à jour${NC}"
echo "Vérifiez les logs: docker compose logs gitea" log "Vérifiez les logs: docker compose logs gitea"
log "${YELLOW}Tentative de restauration automatique...${NC}"
# Essayer de restaurer le docker-compose.yml
if [ -f "$COMPOSE_BACKUP" ]; then
cp "$COMPOSE_BACKUP" docker-compose.yml
log "docker-compose.yml restauré"
fi
exit 1 exit 1
fi fi
echo "En attente de Gitea... ($COUNTER/$MAX_TRIES)" log "En attente de Gitea... ($COUNTER/$MAX_TRIES)"
sleep 2 sleep 2
done done
echo -e "${GREEN}✓ Gitea répond${NC}" log "${GREEN}✓ Gitea répond et est opérationnel${NC}"
echo -e "${YELLOW}[6/6] Vérification de l'état...${NC}" log "${YELLOW}[7/7] Vérification de l'état et de la version...${NC}"
# Afficher les versions
echo ""
echo "Versions actuelles:"
docker compose images
echo "" # Obtenir la nouvelle version
echo "État des services:" NEW_VERSION=$(docker compose exec -T gitea gitea --version 2>/dev/null | head -n 1 || echo "Inconnue")
docker compose ps log "Nouvelle version: $NEW_VERSION"
echo "" # Afficher les versions des images
echo -e "${GREEN}=== Mise à jour terminée avec succès ===${NC}" log ""
echo "" log "Images Docker:"
echo "Vérifications recommandées:" docker compose images 2>&1 | tee -a "$LOG_FILE"
echo " 1. Accéder à l'interface web: http://localhost:3000"
echo " 2. Vérifier les dépôts existants" log ""
echo " 3. Tester les fonctionnalités principales" log "État des services:"
echo " 4. Consulter les logs: docker compose logs -f gitea" docker compose ps 2>&1 | tee -a "$LOG_FILE"
echo ""
echo "En cas de problème, restaurez la sauvegarde:" # Supprimer l'ancien backup docker-compose.yml si tout s'est bien passé
if [ -f "$COMPOSE_BACKUP" ]; then
rm -f "$COMPOSE_BACKUP"
log "Backup temporaire docker-compose.yml supprimé"
fi
log ""
log "${GREEN}=== Mise à jour terminée avec succès ===${NC}"
log ""
log "Vérifications recommandées:"
log " 1. Accéder à l'interface web: http://localhost:3000"
log " 2. Vérifier les dépôts existants"
log " 3. Tester les fonctionnalités principales"
log " 4. Consulter les logs: docker compose logs -f gitea"
log ""
log "En cas de problème, restaurez la sauvegarde:"
LATEST_BACKUP=$(ls -t backups/gitea_backup_*.tar.gz 2>/dev/null | head -n 1) LATEST_BACKUP=$(ls -t backups/gitea_backup_*.tar.gz 2>/dev/null | head -n 1)
if [ -n "$LATEST_BACKUP" ]; then if [ -n "$LATEST_BACKUP" ]; then
echo " make restore FILE=$LATEST_BACKUP" log " make restore FILE=$LATEST_BACKUP"
fi fi
log ""
log "Log de mise à jour: $LOG_FILE"
log "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')] Mise à jour terminée${NC}"