Copier des dossiers SharePoint vers un lecteur réseau : méthodes fiables, scripts PowerShell et Power Automate

Vous devez copier des dossiers entiers depuis une bibliothèque SharePoint Online vers un lecteur réseau ? Voici les méthodes fiables (manuel, OneDrive, PowerShell PnP, Power Automate) avec pas‑à‑pas, scripts prêts à l’emploi, arbre de décision et bonnes pratiques pour des transferts sûrs et reproductibles.

Problématique et limites natives

Dans SharePoint Online, il est facile de déplacer ou copier des fichiers vers un autre emplacement SharePoint ou OneDrive. En revanche, lorsqu’il s’agit d’exporter des dossiers complets vers un lecteur réseau SMB/UNC, l’interface web ne propose pas d’action directe. Le comportement observé par la plupart des utilisateurs est le suivant :

• Le glisser‑déposer depuis le navigateur fonctionne pour quelques fichiers, mais ne gère pas bien de grandes arborescences.
• La commande Copier vers cible d’autres bibliothèques SharePoint/OneDrive, pas un partage réseau.
• Il n’existe pas de bouton « Copier ce dossier vers \\serveur\partage » dans SharePoint Online.

Conclusion : pour envoyer des dossiers SharePoint vers un lecteur réseau, il faut introduire une étape intermédiaire (téléchargement local ou synchro), ou recourir à des outils d’automatisation (PowerShell, Power Automate, outils tiers).

Solutions comparées

Voici un comparatif synthétique des approches possibles, avec principes, étapes clés, avantages et limites.

Solution	Principe	Étapes clés	Avantages	Limites
Téléchargement local puis déplacement	Télécharger le dossier depuis SharePoint (archive .zip), l’extraire, puis le copier vers le lecteur réseau.	Sélectionner le dossier → Télécharger. Extraire l’archive localement. Copier/coller vers \\serveur\partage.	Très simple, aucune configuration supplémentaire, parfait pour un besoin ponctuel.	Processus manuel, non automatisé ; chronophage et source d’erreurs sur gros volumes.
Synchronisation OneDrive	Synchroniser la bibliothèque SharePoint via le client OneDrive pour obtenir une copie locale, puis copier vers le partage SMB.	Dans la bibliothèque SharePoint → cliquer Synchroniser. Attendre la fin de la synchro locale (icône verte). Copier le dossier synchronisé vers \\serveur\partage.	Convient aux arborescences importantes, conserve une copie locale tenue à jour.	Nécessite de l’espace disque ; peu adapté aux environnements RDS/VDI ou multi‑session.
Script PowerShell + PnP	Automatiser l’export des dossiers/fichiers SharePoint vers un chemin UNC, avec planification possible.	Installer le module PnP.PowerShell. Se connecter au site SharePoint. Récupérer récursivement les éléments et télécharger vers un dossier local ou un UNC. (Optionnel) Propager vers le partage avec Robocopy.	Automatisable, scriptable, robuste sur de grands volumes, journalisable.	Nécessite des permissions et des compétences PowerShell ; préparation requise (app, certificats si exécution sans assistance).
Flux Power Automate	Créer un flux planifié ou manuel qui lit les dossiers/fichiers SharePoint et écrit dans un partage SMB via la passerelle locale.	Déclencheur Planifié ou Instantané. Action Get files (properties only) sur la bibliothèque. Action File System → Create/Update file (via On‑premises Data Gateway).	No‑code/low‑code, supervision des exécutions, notifications d’échec.	Installation de la Gateway obligatoire ; débit limité par le service, logique à concevoir pour la récursivité.
Outils tiers (ShareGate, AvePoint, etc.)	Outils de migration/synchronisation offrant interfaces graphiques, jobs planifiés et rapports.	Configurer la source (SPO) et la destination (SMB), définir la portée et la planification, exécuter, examiner le rapport.	Expérience utilisateur soignée, reporting détaillé, scénarios avancés.	Coût de licence, compétences d’administration, dépendance éditeur.

Arbre de décision rapide

Contrainte principale	Volume/Fréquence	Recommandation	Pourquoi
Besoin unique, petit volume	< 5 Go, ponctuel	Téléchargement local	Rapide, sans déploiement.
Utilisateurs non techniques	Moyen, hebdomadaire	OneDrive Synchronisation	Simple à opérer, visibilité locale.
Automatisation IT‑ops	Gros volumes, planifié	PowerShell + PnP + Robocopy	Performant, contrôlable, journalisé.
Gouvernance & suivi métier	Récurrent, multi‑sites	Power Automate	No‑code, historiques d’exécutions, alertes.
Projet de migration	Très gros volumes	Outils tiers	Ergonomie, rapports, support éditeur.

Tutoriels détaillés

Méthode 1 — Téléchargement local puis déplacement

Quand l’utiliser : transfert ponctuel, faible complexité, utilisateur final.

1. Dans la bibliothèque SharePoint, cochez le dossier à exporter → Télécharger. SharePoint produit une archive .zip.
2. Extrayez le contenu localement dans un dossier de travail.
3. Copiez le dossier extrait vers \\serveur\partage\Chemin\Cible. Pour plus de fiabilité et pour conserver les horodatages, utilisez Robocopy depuis l’invite de commandes : robocopy "C:\Temp\ExportSPO" "\\serveur\partage\ExportSPO" /E /COPY:DAT /DCOPY:T /R:3 /W:5 /FFT /MT:16 /NP Astuce : lancez d’abord /L pour une simulation (aucune copie réelle) et contrôlez la liste d’actions.

Points d’attention : gestion des chemins longs, caractères non valides sur Windows (par ex. : dans un nom), fichiers verrouillés par des applications locales. En cas d’arborescences profondes, activez le support des chemins longs sous Windows.

Méthode 2 — Synchronisation OneDrive

Quand l’utiliser : utilisateurs qui souhaitent manipuler les dossiers SharePoint comme s’ils étaient locaux, avec un rafraîchissement continu.

1. Depuis la bibliothèque SharePoint, cliquez Synchroniser et suivez l’assistant OneDrive.
2. Attendez la synchronisation complète (icônes vertes). Vérifiez le statut de synchronisation sur chaque sous‑dossier.
3. Copiez les dossiers synchronisés vers le partage réseau ; pour de gros volumes, préférez Robocopy (voir commande ci‑dessus).

Bonnes pratiques : évitez cette approche sur des serveurs RDS/VDI multi‑session ; prévoyez l’espace disque suffisant ; définissez clairement qui est responsable des conflits de synchronisation.

Méthode 3 — Script PowerShell + PnP

Quand l’utiliser : besoin régulier et automatisé, intégration dans vos opérations IT, éligible à une planification.

Prérequis

• PowerShell 7.x (recommandé) ou Windows PowerShell 5.1.
• Module PnP.PowerShell installé : Install-Module PnP.PowerShell -Scope AllUsers.
• Accès au site SharePoint concerné et au partage SMB cible.
• Pour une exécution non interactive : application Entra ID (Azure AD) et authentification app‑only (certificat).

Script minimal (récursif) — export direct vers UNC

Ce script exporte un dossier SharePoint vers un chemin UNC en recréant l’arborescence.

# Paramètres
$SiteUrl = "https://contoso.sharepoint.com/sites/Projets"
$SiteRelativeFolder = "Shared Documents/ProjetA"   # chemin relatif au site
$TargetUNC = "\\srv-fichiers\Partage\Export\ProjetA"

# Connexion interactive

Connect-PnPOnline -Url $SiteUrl -Interactive

# Création du dossier cible

if (-not (Test-Path -LiteralPath $TargetUNC)) { New-Item -ItemType Directory -Path $TargetUNC | Out-Null }

# Obtenir la racine du site (pour convertir ServerRelativeUrl -> SiteRelative)

$web = Get-PnPWeb

function ConvertTo-SiteRelative {
param([string]$ServerRelativeUrl, [string]$WebServerRelativeUrl)
if ($WebServerRelativeUrl -eq "/") { return $ServerRelativeUrl.TrimStart("/") }
return $ServerRelativeUrl.Substring($WebServerRelativeUrl.Length).TrimStart("/")
}

function Export-PnPFolderRecursive {
param([string]$FolderSiteRelative, [string]$LocalTarget)

```
# Crée le dossier local cible si nécessaire
if (-not (Test-Path -LiteralPath $LocalTarget)) { New-Item -ItemType Directory -Path $LocalTarget | Out-Null }

# Récupère tous les éléments du dossier (fichiers + sous-dossiers)
$items = Get-PnPFolderItem -FolderSiteRelativeUrl $FolderSiteRelative -ItemType All -ErrorAction Stop

foreach ($it in $items) {
    if ($it.FileSystemObjectType -eq "Folder") {
        $childServerRel = $it.ServerRelativeUrl
        $childSiteRel   = ConvertTo-SiteRelative -ServerRelativeUrl $childServerRel -WebServerRelativeUrl $web.ServerRelativeUrl
        $childLocal     = Join-Path $LocalTarget $it.Name
        Export-PnPFolderRecursive -FolderSiteRelative $childSiteRel -LocalTarget $childLocal
    }
    else {
        # Fichier : télécharge si absent ou plus ancien
        $outFile = Join-Path $LocalTarget $it.Name
        if (-not (Test-Path -LiteralPath $outFile)) {
            Get-PnPFile -Url $it.ServerRelativeUrl -Path $LocalTarget -FileName $it.Name -AsFile -Force -ErrorAction Stop
        }
        else {
            # Compare la date de dernière modification SharePoint vs locale
            $spItem = Get-PnPFile -Url $it.ServerRelativeUrl -AsListItem -ErrorAction Stop
            $spDate = [DateTime]$spItem["Modified"]
            $loDate = (Get-Item -LiteralPath $outFile).LastWriteTime
            if ($spDate -gt $loDate) {
                Get-PnPFile -Url $it.ServerRelativeUrl -Path $LocalTarget -FileName $it.Name -AsFile -Force -ErrorAction Stop
            }
        }
    }
}
```

}

Export-PnPFolderRecursive -FolderSiteRelative $SiteRelativeFolder -LocalTarget $TargetUNC
Write-Host "Export terminé vers $TargetUNC"

Variante robuste avec zone de transit + Robocopy

Pour une meilleure résilience (reprises, résultats déterministes, journaux), téléchargez d’abord dans un répertoire local temporaire puis synchronisez vers le partage via Robocopy.

# Paramètres
$SiteUrl = "https://contoso.sharepoint.com/sites/Projets"
$SiteRelativeFolder = "Shared Documents/ProjetA"
$Stage = "C:\SPO-Stage\ProjetA"
$TargetUNC = "\\srv-fichiers\Partage\Export\ProjetA"
$LogPath = "C:\SPO-Stage\logs\export-$(Get-Date -Format yyyyMMdd-HHmmss).log"

# Connexion (app-only possible avec -ClientId / -Tenant / -CertificateThumbprint)

Connect-PnPOnline -Url $SiteUrl -Interactive

# Téléchargement récursif vers $Stage

$web = Get-PnPWeb
if (-not (Test-Path $Stage)) { New-Item -ItemType Directory -Path $Stage | Out-Null }

# (Réutilise Export-PnPFolderRecursive défini plus haut)

Export-PnPFolderRecursive -FolderSiteRelative $SiteRelativeFolder -LocalTarget $Stage

# Propagation vers le partage réseau avec Robocopy

if (-not (Test-Path $TargetUNC)) { New-Item -ItemType Directory -Path $TargetUNC | Out-Null }

$robo = @(
"`"$Stage`"", "`"$TargetUNC`"",
"/E", "/COPY:DAT", "/DCOPY:T", "/XO", "/R:3", "/W:5", "/FFT", "/MT:16", "/NP",
"/NFL", "/NDL", "/LOG+:`"$LogPath`""
) -join " "

cmd.exe /c "robocopy $robo"
$code = $LASTEXITCODE
Write-Host "Robocopy terminé avec code $code. Journal : $LogPath"

Journalisation & reprises : conservez le journal Robocopy, surveillez les codes de retour (0,1 → OK). Programmez le script via le Planificateur de tâches Windows avec un compte de service disposant des droits SharePoint et NTFS.

Méthode 4 — Power Automate

Quand l’utiliser : automatisation récurrente, besoin de suivi fonctionnel, sans écrire de code.

1. Installer et configurer la On‑premises Data Gateway sur un serveur ayant accès au partage SMB cible.
2. Créer un flux Planifié (par ex. toutes les nuits) ou Instantané (manuel).
3. Ajouter l’action SharePoint → Get files (properties only) ciblant la bibliothèque à exporter.
4. Ajouter une boucle Apply to each sur la liste de fichiers. Si vous devez gérer la récursivité, prévoyez une clé (par ex. stocker les sous‑chemins dans une colonne calculée, ou préparer une liste contenant l’inventaire).
5. Dans la boucle, récupérez le contenu via Get file content (ou Get file content using path).
6. Écrivez dans le partage avec File System → Create file en reconstituant le chemin (ex. concat('\\srv\share\Export\', triggerOutputs()?['headers']['x-ms-file-last-modified'] ...) selon votre logique).
7. Ajoutez une gestion des doublons (vérifier l’existence avant création, ou utiliser Create or update file), et des contrôles d’erreurs avec des scopes et notifications.

Limites & contournements : la gestion des très gros fichiers et la profondeur d’arborescence exigent des optimisations (pagination, filtrage, parallélisation raisonnable). La passerelle doit rester disponible et à jour.

Méthode 5 — Outils tiers

Idéaux pour des migrations structurées avec reporting avancé, prévisualisation, planification, et assistance éditeur. Conseillés si vous devez traiter des dizaines/centaines de sites, ou si vous souhaitiez des tableaux de bord lisibles par les métiers.

Points clés de gouvernance, performance et fiabilité

• Métadonnées et versions : un export vers un partage SMB perd les colonnes SharePoint (auteurs, choix, lookup, étiquettes de rétention, historique de versions). Si ces données sont nécessaires, exportez‑les en parallèle (CSV/JSON) avant la copie.
• Chemins longs & caractères interdits : activez le support des chemins > 260 caractères sous Windows (stratégie « Enable Win32 long paths ») et gérez la substitution de caractères non valides (<>:"/\|?*).
• Quotas et taille des fichiers : vérifiez les limitations de votre tenant et du partage cible avant un transfert massif ; segmentez par sous‑dossiers si besoin.
• Throttling SharePoint : en cas de limitation côté service, implémentez des pauses exponentielles ou utilisez les mécanismes de reprise automatique du module PnP.
• Sécurité et conformité : si les fichiers portent des labels de rétention, validez avec votre équipe conformité l’impact d’une copie vers un environnement SMB (perte de labels et de protections natives SharePoint).
• Journalisation et traçabilité : gardez des logs (Robocopy, Power Automate, outils tiers) pour prouver le périmètre et la réussite du transfert.

Exporter les métadonnées en CSV (option recommandé)

Avant l’export vers SMB, sauvegardez les colonnes SharePoint dans un CSV pour conserver un « instantané » documentaire.

# Exemple : export des métadonnées d'une bibliothèque
$SiteUrl = "https://contoso.sharepoint.com/sites/Projets"
$Library = "Shared Documents"
$OutCsv = "C:\SPO-Stage\ProjetA\metadata.csv"

Connect-PnPOnline -Url $SiteUrl -Interactive

$items = Get-PnPListItem -List $Library -PageSize 2000 `
-Fields "FileRef","FileLeafRef","Modified","Editor","Author","CustomColumn1","CustomColumn2"

$items | ForEach-Object {
[PSCustomObject]@{
Path        = $*["FileRef"]
Name        = $*["FileLeafRef"]
Modified    = $*["Modified"]
Editor      = $*["Editor"]
Author      = $*["Author"]
Custom1     = $*["CustomColumn1"]
Custom2     = $_["CustomColumn2"]
}
} | Export-Csv -NoTypeInformation -Encoding UTF8 -Path $OutCsv

Vous disposerez ainsi d’un fichier de référence pouvant être rapproché des fichiers copiés sur le partage.

Exemples concrets de scénarios

Transfert hebdomadaire d’un dossier « Projets actifs »

• Objectif : alimenter une application legacy lisant des documents depuis \\srv\appli\inbox.
• Solution : script PnP + Robocopy planifié quotidiennement, journalisé.
• Spécificités : copie incrémentale via comparaison de dates de modification ; export des métadonnées en CSV.

Miroir quotidien pour une équipe externe sans accès M365

• Objectif : déposer chaque nuit une copie à jour dans \\srv\externe\projets.
• Solution : flux Power Automate planifié (avec passerelle) ; notifications en cas d’échec.
• Spécificités : logique de reconstruction des chemins, gestion des mises à jour via « Create or update file ».

Bonnes pratiques essentielles

• Structurer les bibliothèques : si des transferts réguliers sont nécessaires, isolez les données à partager dans un site ou un dossier dédié, pour limiter le périmètre.
• Tester à blanc : avant toute exécution de masse, testez sur un sous‑ensemble représentatif (profondeur d’arborescence, types de fichiers variés).
• Nommer et tracer : normalisez les noms des jobs/scripts, conservez les journaux sur 90 jours minimum, centralisez les alertes (mail/Teams).
• Sécurité & NTFS : validez les ACL sur le partage, isolez la zone de transit, appliquez les droits du principe du moindre privilège.
• Reprise sur incident : privilégiez des outils/commandes capables de reprendre sans tout reconstruire (Robocopy, scripts idempotents).

Erreurs fréquentes et résolutions

Symptôme	Cause probable	Correctif
Chemin trop long / erreur de copie	Windows limitant les chemins, arborescence profonde	Activer les chemins longs, aplatir certains segments, raccourcir le nom de la bibliothèque.
Caractère non valide	Nom de fichier SharePoint ne respectant pas les contraintes NTFS	Mettre en place une règle de substitution (par ex. remplacer : par _) dans le script.
Accès refusé au partage	ACL NTFS ou droits de partage insuffisants	Accorder les droits au compte de service, vérifier les chemins et la résolution DNS.
Throttling / lenteurs	Limitation côté service lors de gros volumes	Implémenter des pauses, limiter la parallélisation, planifier hors heures de pointe.
Fichiers manquants	Filtrage involontaire, erreurs silencieuses	Activer la journalisation détaillée, comparer avec un inventaire (Get-PnPListItem + CSV).

Checklist de mise en production

• ✅ Périmètre exact défini (quel site, quelle bibliothèque, quels sous‑dossiers ?)
• ✅ Droits confirmés (SPO et NTFS)
• ✅ Chemins longs et caractères spéciaux gérés
• ✅ Stratégie de reprise (staging + Robocopy ou flux tolérant)
• ✅ Journalisation et rétention des logs
• ✅ Test à blanc réalisé et validé
• ✅ Planification et supervision mises en place

FAQ

Les permissions SharePoint sont‑elles conservées sur le partage ?
Non. Le partage SMB utilise des ACL NTFS. Dès que vous exportez des fichiers hors de SharePoint, vous sortez du modèle d’autorisations SharePoint.

Les versions des documents sont‑elles copiées ?
Non, l’export vers SMB produit un seul fichier « plat ». Conservez l’historique via un export métadonnées (CSV) ou des outils spécifiques si le besoin est critique.

Peut‑on mapper SharePoint comme un lecteur réseau et glisser le dossier ?
Le mappage WebDAV a historiquement existé, mais il est peu fiable et fortement déconseillé pour des migrations (problèmes de performance, compatibilité, dépendances navigateur). Privilégiez les approches ci‑dessus.

Comment éviter de re‑copier tout à chaque exécution ?
Utilisez une logique incrémentale : comparaison de date/ETag côté PowerShell, ou Create or update dans Power Automate, ou Robocopy /XO pour ignorer les fichiers plus anciens.

En résumé

SharePoint Online ne permet pas nativement de copier des dossiers vers un lecteur réseau. Pour y parvenir, il faut passer par un téléchargement intermédiaire (manuel ou via OneDrive), ou s’appuyer sur une automatisation (PowerShell PnP, Power Automate) ou des outils tiers. Choisissez l’approche en fonction du volume, de la fréquence et des contraintes de sécurité/gouvernance. En production, préférez une chaîne robuste : inventaire → téléchargement → staging → synchronisation SMB → journalisation & supervision.

---

Annexe : modèle de script paramétrable

param(
  [Parameter(Mandatory=$true)][string]$SiteUrl,
  [Parameter(Mandatory=$true)][string]$FolderSiteRelative,   # ex. "Shared Documents/ProjetA"
  [Parameter(Mandatory=$true)][string]$TargetUNC,            # ex. "\\srv\share\Export\ProjetA"
  [switch]$Staging,                                          # si présent, utilise C:\SPO-Stage avant Robocopy
  [string]$StageRoot = "C:\SPO-Stage",
  [int]$MaxThreads = 16
)

Import-Module PnP.PowerShell -ErrorAction Stop
Connect-PnPOnline -Url $SiteUrl -Interactive

$web = Get-PnPWeb

function ConvertTo-SiteRelative {
param([string]$ServerRelativeUrl, [string]$WebServerRelativeUrl)
if ($WebServerRelativeUrl -eq "/") { return $ServerRelativeUrl.TrimStart("/") }
return $ServerRelativeUrl.Substring($WebServerRelativeUrl.Length).TrimStart("/")
}

function Export-PnPFolderRecursive {
param([string]$FolderSiteRelative, [string]$LocalTarget)
if (-not (Test-Path -LiteralPath $LocalTarget)) { New-Item -ItemType Directory -Path $LocalTarget | Out-Null }
$items = Get-PnPFolderItem -FolderSiteRelativeUrl $FolderSiteRelative -ItemType All -ErrorAction Stop
foreach ($it in $items) {
if ($it.FileSystemObjectType -eq "Folder") {
$childSiteRel = ConvertTo-SiteRelative -ServerRelativeUrl $it.ServerRelativeUrl -WebServerRelativeUrl $web.ServerRelativeUrl
Export-PnPFolderRecursive -FolderSiteRelative $childSiteRel -LocalTarget (Join-Path $LocalTarget $it.Name)
}
else {
$outFile = Join-Path $LocalTarget $it.Name
$spItem = Get-PnPFile -Url $it.ServerRelativeUrl -AsListItem
$spDate = [DateTime]$spItem["Modified"]
if ((-not (Test-Path -LiteralPath $outFile)) -or ((Get-Item $outFile).LastWriteTime -lt $spDate)) {
Get-PnPFile -Url $it.ServerRelativeUrl -Path $LocalTarget -FileName $it.Name -AsFile -Force
}
}
}
}

$localTarget = if ($Staging) { Join-Path $StageRoot (([IO.Path]::GetFileName($TargetUNC))) } else { $TargetUNC }
if (-not (Test-Path $localTarget)) { New-Item -ItemType Directory -Path $localTarget | Out-Null }

Export-PnPFolderRecursive -FolderSiteRelative $FolderSiteRelative -LocalTarget $localTarget

if ($Staging) {
if (-not (Test-Path $TargetUNC)) { New-Item -ItemType Directory -Path $TargetUNC | Out-Null }
$args = @("`"$localTarget`"", "`"$TargetUNC`"", "/E","/COPY:DAT","/DCOPY:T","/XO","/R:3","/W:5","/FFT","/MT:$MaxThreads","/NP")
cmd /c ("robocopy " + ($args -join " "))
}

Paramétrez ce modèle dans vos jobs planifiés et versionnez‑le dans votre référentiel interne.

---

Astuce bonus : si vous devez valider qu’aucun fichier n’a été oublié, construisez un inventaire SharePoint (liste de tous les FileRef) et un inventaire SMB (via Get-ChildItem -Recurse), puis comparez les deux listes (opération Compare-Object) ; loggez les différences.

Avec ces recettes, vous disposez d’un guide complet pour transférer des dossiers SharePoint Online vers un lecteur réseau, de la solution la plus simple au pipeline automatisé de niveau production.