Guide

Créez et gérez des images disque sur vos appareils Roundfleet pour un empaquetage efficace des données, la distribution de logiciels et le déploiement système. Ce tutoriel couvre la création d'images disque à partir de dossiers, les options de formatage avancées, le chiffrement, la compression et les workflows de gestion d'images à l'échelle de l'entreprise.

Comprendre les Images Disque

Les images disque sont des conteneurs de fichiers qui répliquent la structure exacte et le contenu des volumes de stockage, offrant des capacités puissantes pour le déploiement d'entreprise :

Avantages des Images Disque

• Distribution de Logiciels - Empaqueter applications et configurations pour le déploiement
• Sauvegarde de Données - Créer des instantanés portables du contenu des dossiers
• Déploiement Système - Standardiser les configurations sur plusieurs appareils
• Transport Sécurisé - Images chiffrées pour le transfert de données sensibles
• Contrôle de Version - Maintenir différentes versions de paquets logiciels
• Efficacité Réseau - Images compressées réduisent le temps de transfert

Types d'Images Disque

• .dmg - Apple Disk Image (format principal)
• .iso - Format ISO 9660 pour compatibilité multi-plateforme
• .sparseimage - Images sparse qui grandissent selon les besoins
• .sparsebundle - Format bundle pour stockage réseau

Création Basique d'Images Disque

Dossier Simple vers Image Disque

#!/bin/bash

# Créer une image disque basique à partir d'un dossier
SOURCE_FOLDER="$1"
IMAGE_NAME="$2"
OUTPUT_PATH="$3"

if [[ -z "$SOURCE_FOLDER" || -z "$IMAGE_NAME" || -z "$OUTPUT_PATH" ]]; then
    echo "❌ Utilisation : $0 <dossier_source> <nom_image> <chemin_sortie>"
    echo "Exemple : $0 /Users/Shared MonImage /Users/username/Documents"
    exit 1
fi

# Valider que le dossier source existe
if [[ ! -d "$SOURCE_FOLDER" ]]; then
    echo "❌ Le dossier source n'existe pas : $SOURCE_FOLDER"
    exit 1
fi

# Créer le répertoire de sortie s'il n'existe pas
mkdir -p "$OUTPUT_PATH"

echo "💿 Création d'une image disque à partir du dossier..."
echo "Source : $SOURCE_FOLDER"
echo "Nom de l'image : $IMAGE_NAME"
echo "Sortie : $OUTPUT_PATH/$IMAGE_NAME.dmg"

# Créer l'image disque
if hdiutil create -fs HFS+ -srcfolder "$SOURCE_FOLDER" -volname "$IMAGE_NAME" "$OUTPUT_PATH/$IMAGE_NAME.dmg"; then
    echo "✅ Image disque créée avec succès"
    
    # Obtenir la taille de l'image
    IMAGE_SIZE=$(du -h "$OUTPUT_PATH/$IMAGE_NAME.dmg" | cut -f1)
    echo "Taille de l'image : $IMAGE_SIZE"
    
    # Obtenir la taille du dossier source pour comparaison
    SOURCE_SIZE=$(du -sh "$SOURCE_FOLDER" | cut -f1)
    echo "Taille du dossier source : $SOURCE_SIZE"
else
    echo "❌ Échec de création de l'image disque"
    exit 1
fi

Création d'Image Disque Avancée

#!/bin/bash

# Création d'image disque avancée avec options
create_advanced_disk_image() {
    local source_folder="$1"
    local image_name="$2"
    local output_path="$3"
    local filesystem="${4:-HFS+}"
    local compression="${5:-UDBZ}"
    local encryption="${6:-false}"
    
    if [[ ! -d "$source_folder" ]]; then
        echo "❌ Dossier source non trouvé : $source_folder"
        return 1
    fi
    
    mkdir -p "$output_path"
    
    echo "💿 Création d'une image disque avancée..."
    echo "Source : $source_folder"
    echo "Système de fichiers : $filesystem"
    echo "Compression : $compression"
    echo "Chiffrement : $encryption"
    
    # Construire la commande hdiutil
    local cmd="hdiutil create"
    cmd="$cmd -fs $filesystem"
    cmd="$cmd -srcfolder '$source_folder'"
    cmd="$cmd -volname '$image_name'"
    
    # Ajouter la compression si spécifiée
    if [[ "$compression" != "none" ]]; then
        cmd="$cmd -format $compression"
    fi
    
    # Ajouter le chiffrement si demandé
    if [[ "$encryption" == "true" ]]; then
        cmd="$cmd -encryption AES-256"
        cmd="$cmd -stdinpass"
        echo "🔐 Chiffrement activé - vous serez invité à saisir un mot de passe"
    fi
    
    cmd="$cmd '$output_path/$image_name.dmg'"
    
    # Exécuter la commande
    if [[ "$encryption" == "true" ]]; then
        echo "Entrez le mot de passe pour le chiffrement de l'image disque :"
        read -s password
        echo "$password" | eval "$cmd"
    else
        eval "$cmd"
    fi
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Image disque avancée créée avec succès"
        
        # Afficher les informations de l'image
        echo ""
        echo "=== Informations de l'Image ==="
        hdiutil imageinfo "$output_path/$image_name.dmg" | grep -E "Format|Compressed|Encrypted|Checksum"
        
        return 0
    else
        echo "❌ Échec de création de l'image disque"
        return 1
    fi
}

# Exemples d'utilisation
# create_advanced_disk_image "/Users/Shared" "DonneesPartagees" "/tmp" "HFS+" "UDBZ" "false"
# create_advanced_disk_image "/Applications/MonApp.app" "MonApp" "/tmp" "HFS+" "UDZO" "true"

Options de Système de Fichiers et Format

Systèmes de Fichiers Supportés

#!/bin/bash

# Afficher les options de système de fichiers et format disponibles
show_disk_image_options() {
    echo "=== Systèmes de Fichiers Disponibles ==="
    echo "HFS+     - Mac OS Extended (par défaut)"
    echo "HFS+J    - Mac OS Extended (Journalisé)"
    echo "HFSX     - Mac OS Extended (Sensible à la casse)"
    echo "JHFS+X   - Mac OS Extended (Sensible à la casse, Journalisé)"
    echo "MS-DOS   - FAT32 (compatible avec Windows)"
    echo "UDF      - Universal Disk Format"
    echo "APFS     - Apple File System (macOS 10.13+)"
    echo ""
    
    echo "=== Options de Format d'Image ==="
    echo "UDRO     - Lecture seule, taille plus petite"
    echo "UDCO     - Compression ADC (obsolète)"
    echo "UDZO     - Compression zlib (plus commun)"
    echo "UDBZ     - Compression bzip2 (meilleure compression)"
    echo "ULFO     - Compression lzfse (macOS 10.11+)"
    echo "ULMO     - Compression lzma"
    echo "UFBI     - Appareil entier"
    echo "SPARSE   - Image sparse (grandit selon les besoins)"
    echo "SPARSEBUNDLE - Bundle sparse (convivial réseau)"
    echo ""
    
    echo "=== Options de Chiffrement ==="
    echo "AES-128  - Chiffrement AES 128 bits"
    echo "AES-256  - Chiffrement AES 256 bits (recommandé)"
}

# Créer une image disque avec des options spécifiques
create_custom_disk_image() {
    local source="$1"
    local name="$2"
    local output="$3"
    local fs="$4"
    local format="$5"
    local encrypt="$6"
    
    echo "Création d'une image disque personnalisée avec :"
    echo "  Système de fichiers : $fs"
    echo "  Format : $format"
    echo "  Chiffrement : $encrypt"
    
    local cmd="hdiutil create -fs '$fs' -format '$format'"
    
    if [[ "$encrypt" != "none" ]]; then
        cmd="$cmd -encryption '$encrypt' -stdinpass"
    fi
    
    cmd="$cmd -srcfolder '$source' -volname '$name' '$output/$name.dmg'"
    
    if [[ "$encrypt" != "none" ]]; then
        echo "Entrez le mot de passe de chiffrement :"
        read -s password
        echo "$password" | eval "$cmd"
    else
        eval "$cmd"
    fi
}

# Exemple d'utilisation
# show_disk_image_options
# create_custom_disk_image "/chemin/vers/dossier" "MonImage" "/chemin/sortie" "HFS+" "UDBZ" "AES-256"

Opérations par Lots sur les Images Disque

Création par Lots

#!/bin/bash

# Créer des images disque par lots à partir de plusieurs dossiers
batch_create_disk_images() {
    local base_path="$1"
    local output_dir="$2"
    local filesystem="${3:-HFS+}"
    local format="${4:-UDBZ}"
    
    if [[ ! -d "$base_path" ]]; then
        echo "❌ Chemin de base non trouvé : $base_path"
        return 1
    fi
    
    mkdir -p "$output_dir"
    
    echo "🔄 Démarrage de la création d'images disque par lots..."
    echo "Chemin de base : $base_path"
    echo "Répertoire de sortie : $output_dir"
    echo "Système de fichiers : $filesystem"
    echo "Format : $format"
    echo ""
    
    local success_count=0
    local failed_count=0
    local total_size=0
    
    # Traiter chaque sous-répertoire
    find "$base_path" -type d -mindepth 1 -maxdepth 1 | while read -r folder; do
        local folder_name=$(basename "$folder")
        local image_path="$output_dir/${folder_name}.dmg"
        
        echo "Traitement : $folder_name"
        
        # Ignorer si l'image existe déjà
        if [[ -f "$image_path" ]]; then
            echo "  ⏭️  L'image existe déjà, ignorer"
            continue
        fi
        
        # Créer l'image disque
        if hdiutil create -fs "$filesystem" -format "$format" \
           -srcfolder "$folder" -volname "$folder_name" \
           "$image_path" >/dev/null 2>&1; then
            
            local size=$(du -h "$image_path" | cut -f1)
            echo "  ✅ Créée avec succès ($size)"
            ((success_count++))
            
            # Ajouter au calcul de taille totale
            local size_bytes=$(du -b "$image_path" | cut -f1)
            total_size=$((total_size + size_bytes))
        else
            echo "  ❌ Échec de création de l'image"
            ((failed_count++))
        fi
    done
    
    echo ""
    echo "=== Résumé de l'Opération par Lots ==="
    echo "Réussies : $success_count"
    echo "Échouées : $failed_count"
    echo "Taille totale : $(numfmt --to=iec $total_size)"
}

# Exemple d'utilisation
# batch_create_disk_images "/Users/Shared/Projets" "/tmp/images_projets" "HFS+" "UDBZ"

Vérification et Analyse d'Images

#!/bin/bash

# Vérifier et analyser les images disque
verify_disk_image() {
    local image_path="$1"
    
    if [[ ! -f "$image_path" ]]; then
        echo "❌ Fichier image non trouvé : $image_path"
        return 1
    fi
    
    echo "🔍 Vérification de l'image disque : $(basename "$image_path")"
    
    # Informations basiques de l'image
    echo ""
    echo "=== Informations Basiques ==="
    echo "Taille du fichier : $(du -h "$image_path" | cut -f1)"
    echo "Type de fichier : $(file "$image_path" | cut -d: -f2- | xargs)"
    
    # Informations détaillées de l'image
    echo ""
    echo "=== Informations Détaillées de l'Image ==="
    hdiutil imageinfo "$image_path" | grep -E "Format|Partition|Compressed|Encrypted|Checksum|Total"
    
    # Vérifier l'intégrité de l'image
    echo ""
    echo "=== Vérification d'Intégrité ==="
    if hdiutil verify "$image_path" >/dev/null 2>&1; then
        echo "✅ Intégrité de l'image vérifiée avec succès"
    else
        echo "❌ Échec de vérification d'intégrité de l'image"
        return 1
    fi
    
    # Test de capacité de montage
    echo ""
    echo "=== Test de Montage ==="
    local mount_point=$(mktemp -d)
    
    if hdiutil attach "$image_path" -mountpoint "$mount_point" -nobrowse -quiet; then
        echo "✅ L'image se monte avec succès"
        
        # Obtenir les informations du volume
        echo "Info du volume : $(df -h "$mount_point" | tail -1 | awk '{print $2 " total, " $3 " utilisé, " $4 " disponible"}')"
        
        # Compter le contenu
        local file_count=$(find "$mount_point" -type f | wc -l | xargs)
        local dir_count=$(find "$mount_point" -type d | wc -l | xargs)
        echo "Contenu : $file_count fichiers, $dir_count répertoires"
        
        # Démonter
        hdiutil detach "$mount_point" -quiet
        rmdir "$mount_point"
    else
        echo "❌ Échec de montage de l'image"
        rmdir "$mount_point"
        return 1
    fi
    
    echo ""
    echo "✅ Vérification de l'image terminée avec succès"
    return 0
}

# Vérification par lots
verify_multiple_images() {
    local image_dir="$1"
    
    if [[ ! -d "$image_dir" ]]; then
        echo "❌ Répertoire d'images non trouvé : $image_dir"
        return 1
    fi
    
    echo "🔍 Vérification de toutes les images disque dans : $image_dir"
    echo ""
    
    local verified=0
    local failed=0
    
    find "$image_dir" -name "*.dmg" -type f | while read -r image; do
        echo "Vérification : $(basename "$image")"
        if verify_disk_image "$image" >/dev/null 2>&1; then
            echo "  ✅ Vérifiée"
            ((verified++))
        else
            echo "  ❌ Échouée"
            ((failed++))
        fi
    done
    
    echo ""
    echo "Vérification terminée : $verified réussies, $failed échouées"
}

Gestion d'Images Disque d'Entreprise

#!/bin/bash

# Outil de Gestion d'Images Disque Roundfleet
# Création et gestion complètes d'images disque pour environnements d'entreprise

# Configuration
LOG_FILE="/var/log/roundfleet_diskimage.log"
BACKUP_DIR="/var/backups/roundfleet/images"
REPORT_DIR="/var/reports/roundfleet/images"
CONFIG_FILE="/etc/roundfleet/image_policy.conf"
TEMP_DIR="/tmp/roundfleet_images"

# Paramètres par défaut
DEFAULT_FILESYSTEM="HFS+"
DEFAULT_FORMAT="UDBZ"
DEFAULT_ENCRYPTION="AES-256"
ENABLE_COMPRESSION=true
ENABLE_VERIFICATION=true
MAX_IMAGE_SIZE="10G"
CLEANUP_TEMP_FILES=true

# Fonction de journalisation
log_action() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Configurer les répertoires
setup_directories() {
    for dir in "$BACKUP_DIR" "$REPORT_DIR" "$(dirname "$CONFIG_FILE")" "$TEMP_DIR"; do
        if [[ ! -d "$dir" ]]; then
            sudo mkdir -p "$dir"
            log_action "Répertoire créé : $dir"
        fi
    done
}

# Vérifier l'espace disque disponible
check_disk_space() {
    local target_dir="$1"
    local required_space="$2"  # en octets
    
    local available_space=$(df "$target_dir" | tail -1 | awk '{print $4}')
    available_space=$((available_space * 1024))  # Convertir en octets
    
    if [[ "$available_space" -lt "$required_space" ]]; then
        echo "❌ Espace disque insuffisant"
        echo "Requis : $(numfmt --to=iec $required_space)"
        echo "Disponible : $(numfmt --to=iec $available_space)"
        return 1
    fi
    
    return 0
}

# Créer une image disque d'entreprise avec journalisation et validation complètes
create_enterprise_disk_image() {
    local source_path="$1"
    local image_name="$2"
    local output_dir="$3"
    local filesystem="${4:-$DEFAULT_FILESYSTEM}"
    local format="${5:-$DEFAULT_FORMAT}"
    local encrypt="${6:-false}"
    local description="$7"
    
    log_action "Démarrage de la création d'image disque d'entreprise : $image_name"
    
    # Validation
    if [[ ! -d "$source_path" ]]; then
        echo "❌ Chemin source non trouvé : $source_path"
        log_action "ERREUR : Chemin source non trouvé : $source_path"
        return 1
    fi
    
    # Calculer la taille source
    local source_size_bytes=$(du -sb "$source_path" | cut -f1)
    local source_size_human=$(du -sh "$source_path" | cut -f1)
    
    echo "📁 Analyse source :"
    echo "  Chemin : $source_path"
    echo "  Taille : $source_size_human ($source_size_bytes octets)"
    
    # Vérifier l'espace disque (estimer 2x la taille source pour sécurité)
    local estimated_space=$((source_size_bytes * 2))
    if ! check_disk_space "$output_dir" "$estimated_space"; then
        log_action "ERREUR : Espace disque insuffisant pour la création d'image"
        return 1
    fi
    
    # Créer le répertoire de sortie
    mkdir -p "$output_dir"
    
    local output_path="$output_dir/$image_name.dmg"
    local start_time=$(date +%s)
    
    echo ""
    echo "💿 Création de l'image disque..."
    echo "  Nom : $image_name"
    echo "  Système de fichiers : $filesystem"
    echo "  Format : $format"
    echo "  Sortie : $output_path"
    
    # Construire la commande
    local cmd="hdiutil create -fs '$filesystem' -format '$format'"
    cmd="$cmd -srcfolder '$source_path' -volname '$image_name'"
    
    # Ajouter le chiffrement si demandé
    if [[ "$encrypt" == "true" ]]; then
        cmd="$cmd -encryption '$DEFAULT_ENCRYPTION' -stdinpass"
        echo "  Chiffrement : Activé ($DEFAULT_ENCRYPTION)"
    fi
    
    cmd="$cmd '$output_path'"
    
    # Exécuter la création d'image
    local creation_success=false
    
    if [[ "$encrypt" == "true" ]]; then
        echo ""
        echo "🔐 Entrez le mot de passe pour le chiffrement de l'image disque :"
        read -s password
        if echo "$password" | eval "$cmd" >/dev/null 2>&1; then
            creation_success=true
        fi
    else
        if eval "$cmd" >/dev/null 2>&1; then
            creation_success=true
        fi
    fi
    
    local end_time=$(date +%s)
    local duration=$((end_time - start_time))
    
    if [[ "$creation_success" == "true" ]]; then
        local image_size_bytes=$(du -b "$output_path" | cut -f1)
        local image_size_human=$(du -h "$output_path" | cut -f1)
        local compression_ratio=$(echo "scale=2; $image_size_bytes * 100 / $source_size_bytes" | bc)
        
        echo ""
        echo "✅ Image disque créée avec succès"
        echo "  Temps de création : ${duration}s"
        echo "  Taille de l'image : $image_size_human"
        echo "  Ratio de compression : ${compression_ratio}%"
        
        # Vérifier l'image si activé
        if [[ "$ENABLE_VERIFICATION" == "true" ]]; then
            echo ""
            echo "🔍 Vérification de l'intégrité de l'image..."
            if hdiutil verify "$output_path" >/dev/null 2>&1; then
                echo "✅ Vérification d'image réussie"
                log_action "Image créée et vérifiée : $image_name ($image_size_human)"
            else
                echo "❌ Échec de vérification d'image"
                log_action "ERREUR : Échec de vérification d'image : $image_name"
                return 1
            fi
        fi
        
        # Générer les métadonnées de l'image
        create_image_metadata "$output_path" "$source_path" "$description"
        
        return 0
    else
        echo "❌ Échec de création de l'image disque"
        log_action "ERREUR : Échec de création de l'image disque : $image_name"
        return 1
    fi
}

# Créer un fichier de métadonnées pour l'image
create_image_metadata() {
    local image_path="$1"
    local source_path="$2"
    local description="$3"
    
    local metadata_file="${image_path%.dmg}.json"
    
    cat > "$metadata_file" << EOF
{
    "nom_image": "$(basename "$image_path")",
    "date_creation": "$(date -Iseconds)",
    "chemin_source": "$source_path",
    "chemin_image": "$image_path",
    "description": "$description",
    "taille_fichier": $(du -b "$image_path" | cut -f1),
    "taille_fichier_lisible": "$(du -h "$image_path" | cut -f1)",
    "somme_controle_md5": "$(md5 -q "$image_path")",
    "somme_controle_sha256": "$(shasum -a 256 "$image_path" | cut -d' ' -f1)",
    "info_format": $(hdiutil imageinfo "$image_path" -plist | plutil -convert json -o - -)
}
EOF
    
    echo "📄 Métadonnées sauvegardées : $metadata_file"
}

# Générer un rapport d'images complet
generate_image_report() {
    local image_dir="${1:-$BACKUP_DIR}"
    local report_file="$REPORT_DIR/rapport_images_$(date +%Y%m%d_%H%M%S).txt"
    
    echo "📊 Génération du rapport d'images disque..."
    
    {
        echo "Rapport de Gestion d'Images Disque Roundfleet"
        echo "Généré : $(date)"
        echo "Répertoire d'Images : $image_dir"
        echo "======================================"
        echo ""
        
        if [[ ! -d "$image_dir" ]]; then
            echo "❌ Répertoire d'images non trouvé : $image_dir"
            return 1
        fi
        
        # Compter et analyser les images
        local total_images=$(find "$image_dir" -name "*.dmg" -type f | wc -l)
        local total_size_bytes=0
        local verified_count=0
        local failed_count=0
        
        echo "=== Résumé ==="
        echo "Total d'images disque : $total_images"
        
        if [[ "$total_images" -eq 0 ]]; then
            echo "Aucune image disque trouvée dans le répertoire"
            return 0
        fi
        
        echo ""
        echo "=== Détails des Images ==="
        printf "%-30s %-10s %-15s %-10s\n" "Nom" "Taille" "Format" "Statut"
        printf "%-30s %-10s %-15s %-10s\n" "----" "------" "------" "------"
        
        find "$image_dir" -name "*.dmg" -type f | sort | while read -r image_path; do
            local image_name=$(basename "$image_path")
            local image_size=$(du -h "$image_path" | cut -f1)
            local image_size_bytes=$(du -b "$image_path" | cut -f1)
            
            # Obtenir les infos de format
            local format_info=$(hdiutil imageinfo "$image_path" 2>/dev/null | grep "Format Description" | cut -d: -f2- | xargs)
            if [[ -z "$format_info" ]]; then
                format_info="Inconnu"
            fi
            
            # Vérifier l'intégrité
            local status="Inconnu"
            if hdiutil verify "$image_path" >/dev/null 2>&1; then
                status="✅ Valide"
                ((verified_count++))
            else
                status="❌ Échouée"
                ((failed_count++))
            fi
            
            printf "%-30s %-10s %-15s %-10s\n" "$image_name" "$image_size" "$format_info" "$status"
            
            total_size_bytes=$((total_size_bytes + image_size_bytes))
        done
        
        echo ""
        echo "=== Statistiques ==="
        echo "Taille totale : $(numfmt --to=iec $total_size_bytes)"
        echo "Images vérifiées : $verified_count"
        echo "Vérification échouée : $failed_count"
        echo "Taille moyenne : $(numfmt --to=iec $((total_size_bytes / total_images)))"
        
        # Recommandations de stockage
        echo ""
        echo "=== Recommandations ==="
        if [[ "$failed_count" -gt 0 ]]; then
            echo "⚠️  $failed_count images ont échoué la vérification - enquêter et recréer"
        fi
        
        if [[ "$total_size_bytes" -gt $((50 * 1024 * 1024 * 1024)) ]]; then  # 50GB
            echo "💡 Considérez archiver les anciennes images pour libérer de l'espace"
        fi
        
        echo "💡 Vérification régulière recommandée pour les images critiques"
        
    } > "$report_file"
    
    echo "📊 Rapport sauvegardé dans : $report_file"
    log_action "Rapport d'images généré : $report_file"
}

# Fonction d'exécution principale
main() {
    local action="${1:-aide}"
    local source="${2:-}"
    local name="${3:-}"
    local output="${4:-$BACKUP_DIR}"
    
    log_action "=== Gestion d'Images Disque Roundfleet Démarrée ==="
    
    setup_directories
    
    case "$action" in
        "creer")
            if [[ -n "$source" && -n "$name" ]]; then
                create_enterprise_disk_image "$source" "$name" "$output"
            else
                echo "❌ Utilisation : $0 creer <dossier_source> <nom_image> [repertoire_sortie]"
                echo "Exemple : $0 creer /Users/Shared MonImage /tmp"
            fi
            ;;
        "lot")
            if [[ -n "$source" ]]; then
                batch_create_disk_images "$source" "$output"
            else
                echo "❌ Utilisation : $0 lot <dossier_base> [repertoire_sortie]"
                echo "Exemple : $0 lot /Users/Shared/Projets /tmp/images"
            fi
            ;;
        "verifier")
            if [[ -n "$source" ]]; then
                if [[ -f "$source" ]]; then
                    verify_disk_image "$source"
                elif [[ -d "$source" ]]; then
                    verify_multiple_images "$source"
                else
                    echo "❌ Chemin non trouvé : $source"
                fi
            else
                echo "❌ Utilisation : $0 verifier <fichier_image_ou_repertoire>"
            fi
            ;;
        "rapport")
            generate_image_report "$source"
            ;;
        "info")
            if [[ -n "$source" && -f "$source" ]]; then
                echo "=== Informations de l'Image ==="
                hdiutil imageinfo "$source"
            else
                echo "❌ Utilisation : $0 info <fichier_image>"
            fi
            ;;
        "options")
            show_disk_image_options
            ;;
        "aide"|*)
            echo "Outil de Gestion d'Images Disque Roundfleet"
            echo "Utilisation : $0 [action] [options]"
            echo ""
            echo "Actions :"
            echo "  creer <source> <nom> [sortie]    - Créer image disque à partir du dossier"
            echo "  lot <repertoire_base> [sortie]   - Créer images à partir de tous les sous-répertoires"
            echo "  verifier <image_ou_rep>          - Vérifier l'intégrité de l'image"
            echo "  rapport [repertoire_images]      - Générer rapport complet"
            echo "  info <fichier_image>             - Afficher informations détaillées de l'image"
            echo "  options                          - Afficher options de système de fichiers et format disponibles"
            echo "  aide                             - Afficher ce message d'aide"
            echo ""
            echo "Exemples :"
            echo "  $0 creer /Users/Shared MesDonnees  # Créer MesDonnees.dmg à partir de /Users/Shared"
            echo "  $0 lot /Applications /tmp          # Créer images pour toutes les apps"
            echo "  $0 verifier /tmp/MesDonnees.dmg    # Vérifier une seule image"
            echo "  $0 rapport /tmp                    # Générer rapport pour toutes les images dans /tmp"
            echo ""
            echo "Configuration :"
            echo "  Système de fichiers par défaut : $DEFAULT_FILESYSTEM"
            echo "  Format par défaut : $DEFAULT_FORMAT"
            echo "  Chiffrement par défaut : $DEFAULT_ENCRYPTION"
            echo "  Vérification activée : $ENABLE_VERIFICATION"
            ;;
    esac
    
    log_action "=== Gestion d'Images Disque Roundfleet Terminée ==="
}

# Exécuter la fonction principale
main "$@"

Comparaison des Formats d'Image

Sécurité et Chiffrement

Création d'Image Chiffrée

# Créer une image disque chiffrée avec politiques d'entreprise
create_secure_image() {
    local source="$1"
    local name="$2"
    local output="$3"
    local encryption_level="${4:-AES-256}"
    
    echo "🔐 Création d'une image disque chiffrée..."
    echo "Chiffrement : $encryption_level"
    
    # Générer un mot de passe sécurisé si non fourni
    if [[ -z "$IMAGE_PASSWORD" ]]; then
        echo "Entrez le mot de passe de chiffrement (ou définissez la variable IMAGE_PASSWORD) :"
        read -s IMAGE_PASSWORD
    fi
    
    echo "$IMAGE_PASSWORD" | hdiutil create \
        -fs HFS+ \
        -format UDBZ \
        -encryption "$encryption_level" \
        -stdinpass \
        -srcfolder "$source" \
        -volname "$name" \
        "$output/$name.dmg"
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Image chiffrée créée avec succès"
        echo "🔒 L'image est protégée avec un chiffrement $encryption_level"
    else
        echo "❌ Échec de création de l'image chiffrée"
        return 1
    fi
}

Notes Importantes

• Espace Disque - Assurez-vous d'avoir suffisamment d'espace pour la création d'image (2x la taille source recommandée)
• Performance - La compression échange la taille contre la vitesse de création/accès
• Sécurité - Utilisez le chiffrement AES-256 pour les données sensibles
• Compatibilité - Choisissez le système de fichiers approprié pour les systèmes cibles
• Vérification - Vérifiez toujours les images critiques après création
• Déploiement d'Entreprise - Testez le montage d'image sur les systèmes cibles avant le déploiement en lot