Gestion des Images Disque sur macOS
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
fiCré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
| Format | Compression | Taille | Compatibilité | Cas d'Usage |
|---|---|---|---|---|
| UDRO | Aucune | Grande | Universelle | Tests, images temporaires |
| UDZO | zlib (bonne) | Moyenne | macOS 10.2+ | Usage général, bon équilibre |
| UDBZ | bzip2 (meilleure) | Petite | macOS 10.4+ | Stockage archive, accès plus lent |
| ULFO | lzfse (rapide) | Petite | macOS 10.11+ | Systèmes modernes, compression rapide |
| SPARSE | Aucune | Variable | macOS | Images grandissantes, développement |
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