Guide

Gérez des archives de fichiers sécurisées sur vos appareils Roundfleet avec des outils de compression et chiffrement de niveau entreprise. Ce tutoriel couvre la création de ZIP protégés par mot de passe, les opérations d'archivage par lots, la conformité sécuritaire et la gestion complète d'archives à l'échelle de la flotte.

Comprendre la Gestion Sécurisée d'Archives

La gestion sécurisée d'archives sur macOS implique la création de fichiers compressés protégés pour le transfert, stockage et conformité des données :

Composants Principaux

• Compression ZIP - Format d'archive standard avec compatibilité étendue
• Protection Mot de Passe - Chiffrement AES pour sécurité d'archive
• Opérations Lot - Création et gestion d'archives en masse
• Vérification Intégrité - Validation d'archive et détection corruption
• Suivi Conformité - Pistes d'audit et rapports sécuritaires

Avantages Entreprise

• Sécurité Données - Transfert et stockage fichiers protégés
• Optimisation Stockage - Archives compressées économisent espace disque
• Exigences Conformité - Archivage sécurisé données pour réglementations
• Gestion Flotte - Opérations d'archive standardisées sur appareils
• Capacités Audit - Suivi complet opérations d'archive

Création Basique ZIP Protégé par Mot de Passe

Création ZIP Simple avec Mot de Passe

#!/bin/bash

# Création basique ZIP protégé par mot de passe
create_basic_password_zip() {
    local file_path="${1:-/Users/Shared/exemple.txt}"
    local zip_name="${2:-archive_securisee.zip}"
    local password="${3:-ChangezMoiMaintenant123!}"
    local content="${4:-Bonjour Roundfleet - Archive Sécurisée Créée}"
    
    echo "📦 Création Archive ZIP Protégée par Mot de Passe"
    echo "================================================"
    echo "Fichier : $file_path"
    echo "Archive : $zip_name"
    echo "Contenu : $content"
    echo ""
    
    # Créer le fichier avec contenu
    echo "Création fichier avec contenu..."
    touch "$file_path"
    printf '%s\n' "$content" > "$file_path"
    
    if [[ -f "$file_path" ]]; then
        echo "✅ Fichier créé avec succès : $file_path"
    else
        echo "❌ Échec création fichier : $file_path"
        return 1
    fi
    
    # Naviguer vers répertoire fichier
    local file_dir=$(dirname "$file_path")
    local file_name=$(basename "$file_path")
    
    echo "Navigation vers répertoire : $file_dir"
    cd "$file_dir" || return 1
    
    # Créer ZIP protégé par mot de passe
    echo "Création archive ZIP protégée par mot de passe..."
    if zip -r "$zip_name" "$file_name" --password "$password" >/dev/null 2>&1; then
        echo "✅ Archive ZIP créée avec succès : $file_dir/$zip_name"
        
        # Vérifier archive
        if [[ -f "$zip_name" ]]; then
            local zip_size=$(du -h "$zip_name" | cut -f1)
            echo "Taille archive : $zip_size"
            echo "Emplacement archive : $file_dir/$zip_name"
        fi
    else
        echo "❌ Échec création archive ZIP"
        return 1
    fi
    
    # Nettoyer fichier original (optionnel)
    echo ""
    read -p "Supprimer fichier original ? (o/n) : " remove_original
    if [[ "$remove_original" =~ ^[Oo]$ ]]; then
        rm "$file_path"
        echo "✅ Fichier original supprimé"
    fi
    
    return 0
}

# Exécuter création ZIP basique
create_basic_password_zip "/Users/Shared/test_roundfleet.txt" "roundfleet_securise.zip" "MotDePasseSecurise123!" "Archive Entreprise Roundfleet"

Convertir Fichier Existant en ZIP Protégé par Mot de Passe

#!/bin/bash

# Convertir fichier existant en ZIP protégé par mot de passe
convert_file_to_secure_zip() {
    local source_file="$1"
    local zip_name="${2:-}"
    local password="${3:-}"
    local compression_level="${4:-6}"
    
    echo "🔄 Conversion Fichier en ZIP Sécurisé"
    echo "===================================="
    echo ""
    
    # Valider fichier d'entrée
    if [[ ! -f "$source_file" ]]; then
        echo "❌ Fichier source non trouvé : $source_file"
        echo "Veuillez fournir un chemin fichier valide"
        return 1
    fi
    
    # Obtenir informations fichier
    local file_dir=$(dirname "$source_file")
    local file_name=$(basename "$source_file")
    local file_ext="${file_name##*.}"
    local file_base="${file_name%.*}"
    
    # Générer nom ZIP si non fourni
    if [[ -z "$zip_name" ]]; then
        zip_name="${file_base}_securise.zip"
    fi
    
    # Générer mot de passe sécurisé si non fourni
    if [[ -z "$password" ]]; then
        password=$(openssl rand -base64 12 | tr -d "=+/" | cut -c1-12)
        echo "🔐 Mot de passe sécurisé généré : $password"
        echo "⚠️ Sauvegardez ce mot de passe - il ne peut être récupéré !"
    fi
    
    echo "Fichier source : $source_file"
    echo "Nom archive : $zip_name"
    echo "Niveau compression : $compression_level (1-9)"
    echo ""
    
    # Obtenir taille fichier avant compression
    local original_size=$(du -h "$source_file" | cut -f1)
    echo "Taille fichier original : $original_size"
    
    # Naviguer vers répertoire fichier
    cd "$file_dir" || return 1
    
    # Créer ZIP sécurisé avec compression spécifiée
    echo "Création archive ZIP sécurisée..."
    if zip -"$compression_level" -r "$zip_name" "$file_name" --password "$password" >/dev/null 2>&1; then
        echo "✅ ZIP sécurisé créé avec succès"
        
        # Obtenir taille compressée et calculer ratio compression
        local compressed_size=$(du -h "$zip_name" | cut -f1)
        local original_bytes=$(du -b "$source_file" | cut -f1)
        local compressed_bytes=$(du -b "$zip_name" | cut -f1)
        local compression_ratio=$(echo "scale=1; (($original_bytes - $compressed_bytes) * 100) / $original_bytes" | bc 2>/dev/null || echo "N/A")
        
        echo ""
        echo "=== Résumé Archive ==="
        echo "Taille originale : $original_size"
        echo "Taille compressée : $compressed_size"
        echo "Ratio compression : ${compression_ratio}%"
        echo "Emplacement archive : $file_dir/$zip_name"
        echo "Mot de passe : $password"
        
        # Tester intégrité archive
        echo ""
        echo "Test intégrité archive..."
        if unzip -t "$zip_name" >/dev/null 2>&1; then
            echo "✅ Intégrité archive vérifiée"
        else
            echo "⚠️ Vérification intégrité archive échouée"
        fi
        
    else
        echo "❌ Échec création archive ZIP sécurisée"
        return 1
    fi
    
    return 0
}

# Exemple d'utilisation
echo "Exemple : Convertir fichier existant en ZIP sécurisé"
# convert_file_to_secure_zip "/Users/Shared/document.pdf" "document_securise.zip" "MonMotDePasseSecurise123!"

Gestion d'Archives d'Entreprise

Système de Création d'Archives Complet

#!/bin/bash

# Système de gestion d'archives d'entreprise
enterprise_archive_manager() {
    local operation="${1:-create}"
    local source_path="$2"
    local archive_config="${3:-default}"
    local output_dir="${4:-/tmp/roundfleet_archives}"
    
    echo "🏢 Gestionnaire d'Archives Entreprise Roundfleet"
    echo "=============================================="
    echo "Opération : $operation"
    echo "Source : $source_path"
    echo "Config : $archive_config"
    echo "Sortie : $output_dir"
    echo ""
    
    # Assurer que répertoire sortie existe
    mkdir -p "$output_dir"
    
    # Préréglages configuration
    declare -A archive_configs
    archive_configs[default]="zip:6:AES256"
    archive_configs[haute_securite]="zip:9:AES256"
    archive_configs[rapide]="zip:1:AES128"
    archive_configs[maximum]="zip:9:AES256"
    
    # Analyser configuration
    local config_string="${archive_configs[$archive_config]:-${archive_configs[default]}}"
    IFS=':' read -r format compression encryption <<< "$config_string"
    
    # Générer métadonnées sécurisées
    local timestamp=$(date +"%Y%m%d_%H%M%S")
    local hostname=$(hostname)
    local user=$(whoami)
    local archive_id=$(openssl rand -hex 8)
    
    case "$operation" in
        "create")
            create_enterprise_archive "$source_path" "$output_dir" "$format" "$compression" "$encryption" "$timestamp" "$archive_id"
            ;;
        "batch")
            batch_archive_creation "$source_path" "$output_dir" "$format" "$compression" "$encryption"
            ;;
        "verify")
            verify_archive_integrity "$source_path"
            ;;
        "extract")
            secure_archive_extraction "$source_path" "$output_dir"
            ;;
        *)
            echo "❌ Opération inconnue : $operation"
            echo "Opérations disponibles : create, batch, verify, extract"
            return 1
            ;;
    esac
}

# Créer archive de niveau entreprise
create_enterprise_archive() {
    local source="$1"
    local output_dir="$2"
    local format="$3"
    local compression="$4"
    local encryption="$5"
    local timestamp="$6"
    local archive_id="$7"
    
    echo "📦 Création Archive Entreprise"
    echo "=============================="
    
    # Valider source
    if [[ ! -e "$source" ]]; then
        echo "❌ Source non trouvée : $source"
        return 1
    fi
    
    # Générer mot de passe sécurisé
    local password=$(openssl rand -base64 16 | tr -d "=+/" | cut -c1-16)
    
    # Déterminer nom archive
    local source_name=$(basename "$source")
    local archive_name="roundfleet_${archive_id}_${timestamp}.${format}"
    local archive_path="$output_dir/$archive_name"
    local metadata_file="$output_dir/${archive_name}.metadata.json"
    local password_file="$output_dir/${archive_name}.password"
    
    echo "ID Archive : $archive_id"
    echo "Source : $source"
    echo "Archive : $archive_path"
    echo "Compression : Niveau $compression"
    echo "Chiffrement : $encryption"
    echo ""
    
    # Obtenir informations source
    local source_size=""
    local source_type=""
    local file_count=0
    
    if [[ -f "$source" ]]; then
        source_type="fichier"
        source_size=$(du -h "$source" | cut -f1)
        file_count=1
    elif [[ -d "$source" ]]; then
        source_type="répertoire"
        source_size=$(du -sh "$source" | cut -f1)
        file_count=$(find "$source" -type f | wc -l | xargs)
    fi
    
    echo "Type source : $source_type"
    echo "Taille source : $source_size"
    echo "Nombre fichiers : $file_count"
    echo ""
    
    # Créer archive
    echo "Création archive..."
    local start_time=$(date +%s)
    
    if zip -r -"$compression" "$archive_path" "$source" --password "$password" >/dev/null 2>&1; then
        local end_time=$(date +%s)
        local duration=$((end_time - start_time))
        
        echo "✅ Archive créée avec succès"
        echo "Temps création : ${duration}s"
        
        # Obtenir statistiques archive
        local archive_size=$(du -h "$archive_path" | cut -f1)
        local checksum=$(shasum -a 256 "$archive_path" | cut -d' ' -f1)
        
        # Sauvegarder mot de passe de manière sécurisée
        echo "$password" > "$password_file"
        chmod 600 "$password_file"
        
        # Générer métadonnées
        cat > "$metadata_file" << EOF
{
    "info_archive": {
        "id": "$archive_id",
        "nom": "$archive_name",
        "cree": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")",
        "nom_hote": "$(hostname)",
        "utilisateur": "$(whoami)",
        "version_roundfleet": "2025.07"
    },
    "info_source": {
        "chemin": "$source",
        "type": "$source_type",
        "taille": "$source_size",
        "nombre_fichiers": $file_count
    },
    "details_archive": {
        "format": "$format",
        "niveau_compression": $compression,
        "chiffrement": "$encryption",
        "taille": "$archive_size",
        "checksum_sha256": "$checksum",
        "duree_creation": ${duration}
    },
    "securite": {
        "protege_mot_de_passe": true,
        "fichier_mot_de_passe": "${archive_name}.password",
        "algorithme_chiffrement": "AES-256"
    }
}
EOF
        
        echo ""
        echo "=== Résumé Archive ==="
        echo "Archive : $archive_path"
        echo "Taille : $archive_size"
        echo "Checksum : $checksum"
        echo "Fichier mot de passe : $password_file"
        echo "Métadonnées : $metadata_file"
        
    else
        echo "❌ Échec création archive"
        return 1
    fi
}

# Création archives par lots
batch_archive_creation() {
    local source_dir="$1"
    local output_dir="$2"
    local format="$3"
    local compression="$4"
    local encryption="$5"
    
    echo "📦 Création Archives par Lots"
    echo "============================="
    echo "Répertoire source : $source_dir"
    echo ""
    
    if [[ ! -d "$source_dir" ]]; then
        echo "❌ Répertoire source non trouvé : $source_dir"
        return 1
    fi
    
    local processed=0
    local failed=0
    
    # Traiter chaque élément dans répertoire source
    for item in "$source_dir"/*; do
        if [[ -e "$item" ]]; then
            local item_name=$(basename "$item")
            echo "Traitement : $item_name"
            
            local timestamp=$(date +"%Y%m%d_%H%M%S")
            local archive_id=$(openssl rand -hex 4)
            
            if create_enterprise_archive "$item" "$output_dir" "$format" "$compression" "$encryption" "$timestamp" "$archive_id"; then
                echo "✅ Archivage réussi : $item_name"
                ((processed++))
            else
                echo "❌ Échec archivage : $item_name"
                ((failed++))
            fi
            echo ""
        fi
    done
    
    echo "=== Résumé Lot ==="
    echo "Traités : $processed"
    echo "Échoués : $failed"
    echo "Total : $((processed + failed))"
}

# Vérification intégrité archive
verify_archive_integrity() {
    local archive_path="$1"
    
    echo "🔍 Vérification Intégrité Archive"
    echo "================================="
    echo "Archive : $archive_path"
    echo ""
    
    if [[ ! -f "$archive_path" ]]; then
        echo "❌ Archive non trouvée : $archive_path"
        return 1
    fi
    
    # Vérifier si c'est un fichier ZIP
    if ! file "$archive_path" | grep -q "Zip archive"; then
        echo "❌ Pas une archive ZIP valide"
        return 1
    fi
    
    # Tester intégrité archive
    echo "Test intégrité archive..."
    if unzip -t "$archive_path" >/dev/null 2>&1; then
        echo "✅ Intégrité archive vérifiée"
        
        # Obtenir informations archive
        local archive_size=$(du -h "$archive_path" | cut -f1)
        local file_count=$(unzip -l "$archive_path" 2>/dev/null | tail -1 | awk '{print $2}' || echo "Inconnu")
        
        echo ""
        echo "=== Informations Archive ==="
        echo "Taille : $archive_size"
        echo "Fichiers : $file_count"
        echo "Format : ZIP"
        
        # Vérifier métadonnées
        local metadata_file="${archive_path}.metadata.json"
        if [[ -f "$metadata_file" ]]; then
            echo "Métadonnées : Disponibles"
            local creation_date=$(jq -r '.info_archive.cree' "$metadata_file" 2>/dev/null || echo "Inconnue")
            local archive_id=$(jq -r '.info_archive.id' "$metadata_file" 2>/dev/null || echo "Inconnu")
            echo "Créée : $creation_date"
            echo "ID Archive : $archive_id"
        else
            echo "Métadonnées : Non disponibles"
        fi
        
    else
        echo "❌ Vérification intégrité archive échouée"
        echo "Archive peut être corrompue ou protégée par mot de passe"
        return 1
    fi
}

# Exemples d'utilisation
echo "Exemples Gestionnaire d'Archives Entreprise :"
echo "============================================="
echo ""

echo "1. Créer archive entreprise :"
enterprise_archive_manager "create" "/Users/Shared/documents" "haute_securite" "/tmp/archives"
echo ""

echo "2. Création archives par lots :"
enterprise_archive_manager "batch" "/Users/Shared/source_lot" "default" "/tmp/archives_lot"
echo ""

echo "3. Vérifier intégrité archive :"
enterprise_archive_manager "verify" "/tmp/archives/exemple.zip"

Fonctionnalités Sécurité et Conformité

Système d'Archives Sécurité Avancée

#!/bin/bash

# Système d'archives sécurité et conformité avancées
secure_compliance_archiver() {
    local operation="${1:-audit}"
    local archive_path="$2"
    local compliance_level="${3:-standard}"
    
    echo "🔒 Archiveur Conformité Sécurisé"
    echo "================================"
    echo "Opération : $operation"
    echo "Niveau conformité : $compliance_level"
    echo ""
    
    case "$operation" in
        "audit")
            perform_security_audit "$archive_path" "$compliance_level"
            ;;
        "encrypt")
            apply_advanced_encryption "$archive_path" "$compliance_level"
            ;;
        "validate")
            validate_compliance_requirements "$archive_path" "$compliance_level"
            ;;
        "report")
            generate_compliance_report "$compliance_level"
            ;;
        *)
            echo "❌ Opération inconnue : $operation"
            echo "Opérations disponibles : audit, encrypt, validate, report"
            return 1
            ;;
    esac
}

# Audit sécurité pour archives
perform_security_audit() {
    local archive_path="$1"
    local compliance_level="$2"
    
    echo "🔍 Audit Sécurité"
    echo "=================="
    echo ""
    
    local audit_passed=0
    local audit_warnings=0
    local audit_failures=0
    
    # Vérifier permissions fichier
    if [[ -f "$archive_path" ]]; then
        local permissions=$(stat -f "%A" "$archive_path" 2>/dev/null || echo "inconnues")
        echo "Permissions fichier : $permissions"
        
        if [[ "$permissions" =~ ^[67][0-4][0-4]$ ]]; then
            echo "✅ Permissions sont sécurisées"
            ((audit_passed++))
        else
            echo "⚠️ Permissions peuvent être trop permissives"
            ((audit_warnings++))
        fi
    fi
    
    # Vérifier statut chiffrement
    if file "$archive_path" | grep -q "password-protected\|encrypted"; then
        echo "✅ Archive est protégée par mot de passe"
        ((audit_passed++))
    else
        echo "❌ Archive n'est pas protégée par mot de passe"
        ((audit_failures++))
    fi
    
    # Vérifier intégrité métadonnées
    local metadata_file="${archive_path}.metadata.json"
    if [[ -f "$metadata_file" ]]; then
        echo "✅ Fichier métadonnées présent"
        ((audit_passed++))
        
        # Valider JSON
        if jq empty "$metadata_file" 2>/dev/null; then
            echo "✅ Format métadonnées valide"
            ((audit_passed++))
        else
            echo "❌ Format métadonnées invalide"
            ((audit_failures++))
        fi
    else
        echo "⚠️ Fichier métadonnées manquant"
        ((audit_warnings++))
    fi
    
    # Vérifications spécifiques à la conformité
    case "$compliance_level" in
        "haute"|"entreprise")
            # Vérifier fichier mot de passe sécurisé
            local password_file="${archive_path}.password"
            if [[ -f "$password_file" ]]; then
                local pass_permissions=$(stat -f "%A" "$password_file" 2>/dev/null || echo "inconnues")
                if [[ "$pass_permissions" == "600" ]]; then
                    echo "✅ Permissions fichier mot de passe sécurisées"
                    ((audit_passed++))
                else
                    echo "❌ Permissions fichier mot de passe non sécurisées"
                    ((audit_failures++))
                fi
            fi
            ;;
    esac
    
    # Générer résumé audit
    echo ""
    echo "=== Résumé Audit Sécurité ==="
    echo "Réussis : $audit_passed"
    echo "Avertissements : $audit_warnings"
    echo "Échecs : $audit_failures"
    
    local total_checks=$((audit_passed + audit_warnings + audit_failures))
    if [[ "$audit_failures" -eq 0 ]]; then
        echo "🎉 Audit sécurité RÉUSSI"
        return 0
    else
        echo "❌ Audit sécurité ÉCHOUÉ"
        return 1
    fi
}

# Générer rapport conformité
generate_compliance_report() {
    local compliance_level="$1"
    local report_file="/tmp/roundfleet_archive_compliance_$(date +%Y%m%d_%H%M%S).json"
    
    echo "📊 Génération Rapport Conformité"
    echo "================================="
    echo ""
    
    # Scanner toutes archives Roundfleet
    local archive_dirs=("/tmp/roundfleet_archives" "/tmp/archives" "/tmp/archives_lot")
    local total_archives=0
    local compliant_archives=0
    local non_compliant_archives=0
    
    {
        echo "{"
        echo "  \"rapport_conformite\": {"
        echo "    \"genere\": \"$(date -u +"%Y-%m-%dT%H:%M:%SZ")\","
        echo "    \"nom_hote\": \"$(hostname)\","
        echo "    \"niveau_conformite\": \"$compliance_level\","
        echo "    \"archives\": ["
        
        local first_archive=true
        
        for dir in "${archive_dirs[@]}"; do
            if [[ -d "$dir" ]]; then
                for archive in "$dir"/*.zip; do
                    if [[ -f "$archive" ]]; then
                        if [[ "$first_archive" == "false" ]]; then
                            echo ","
                        fi
                        
                        local archive_name=$(basename "$archive")
                        local archive_size=$(du -h "$archive" | cut -f1)
                        local is_compliant="false"
                        
                        # Vérifier conformité
                        if perform_security_audit "$archive" "$compliance_level" >/dev/null 2>&1; then
                            is_compliant="true"
                            ((compliant_archives++))
                        else
                            ((non_compliant_archives++))
                        fi
                        
                        echo "      {"
                        echo "        \"nom\": \"$archive_name\","
                        echo "        \"chemin\": \"$archive\","
                        echo "        \"taille\": \"$archive_size\","
                        echo "        \"conforme\": $is_compliant"
                        echo -n "      }"
                        
                        first_archive=false
                        ((total_archives++))
                    fi
                done
            fi
        done
        
        echo ""
        echo "    ],"
        echo "    \"resume\": {"
        echo "      \"total_archives\": $total_archives,"
        echo "      \"conformes\": $compliant_archives,"
        echo "      \"non_conformes\": $non_compliant_archives,"
        echo "      \"taux_conformite\": \"$(echo "scale=1; ($compliant_archives * 100) / $total_archives" | bc 2>/dev/null || echo "0")%\""
        echo "    }"
        echo "  }"
        echo "}"
    } > "$report_file"
    
    echo "✅ Rapport conformité généré : $report_file"
    echo ""
    echo "=== Résumé ==="
    echo "Total archives : $total_archives"
    echo "Conformes : $compliant_archives"
    echo "Non conformes : $non_compliant_archives"
    
    if [[ "$total_archives" -gt 0 ]]; then
        local compliance_rate=$(echo "scale=1; ($compliant_archives * 100) / $total_archives" | bc 2>/dev/null || echo "0")
        echo "Taux conformité : ${compliance_rate}%"
    fi
}

# Exécuter opérations conformité
echo "Exemples Sécurité et Conformité :"
echo "================================="
echo ""

echo "1. Générer rapport conformité :"
secure_compliance_archiver "report" "" "entreprise"

Notes Importantes

Fonctionnalités Entreprise

• Sécurité Avancée - Chiffrement AES-256 avec génération mot de passe sécurisé
• Gestion Métadonnées - Suivi et documentation archives complets
• Opérations Lot - Création et gestion archives en masse
• Vérification Intégrité - Validation archive et détection corruption
• Rapports Conformité - Audit sécurité et suivi conformité
• Déploiement Flotte - Opérations archives standardisées sur appareils

Meilleures Pratiques Sécurité

• Mots de Passe Forts - Génération mots de passe cryptographiquement sécurisés
• Stockage Sécurisé - Fichiers mots de passe protégés avec permissions restreintes
• Standards Chiffrement - Chiffrement AES-256 pour sécurité maximale
• Pistes Audit - Journalisation et suivi opérations complets
• Contrôles Accès - Permissions fichiers et mesures sécurité appropriées

Opérations Supportées

• Créer - Création archive fichier unique ou répertoire
• Lot - Création archives multiples depuis contenu répertoire
• Vérifier - Test et validation intégrité archive
• Extraire - Extraction archive sécurisée avec vérification
• Audit - Vérification conformité sécurité et rapports

Exemples d'Utilisation

# ZIP basique protégé par mot de passe
touch /Users/Shared/fichier.txt
printf 'Bonjour monde\n' > /Users/Shared/fichier.txt
cd /Users/Shared
zip -r fichier.zip fichier.txt --password 1234

# Archive entreprise Roundfleet améliorée
create_basic_password_zip "/Users/Shared/document.pdf" "doc_securise.zip" "MotDePasseSecurise123!"

# Archive entreprise avec métadonnées
enterprise_archive_manager "create" "/Users/Shared/projets" "haute_securite" "/tmp/archives"

# Création archives par lots
enterprise_archive_manager "batch" "/Users/Shared/documents" "default" "/tmp/archives_lot"

# Audit sécurité
secure_compliance_archiver "audit" "/tmp/archives/exemple.zip" "entreprise"