Migration mail POP et IMAP vers IMAP

Conventions et cadre d'intervention

Toutes les valeurs propres au client sont notées en placeholders : [email protected], MDP, imap.serveur.tld. Sur un mutualisé cPanel, le nom d'hôte IMAP est celui affiché dans votre propre panneau (forme xxxx.hebergeur.tld), en 993/SSL, SMTP 465/SSL. Ne jamais laisser les identifiants d'un client dans un script partagé.

Arbre de décision

Les phases à jouer dépendent de où vivent réellement les mails du client. On additionne les voies nécessaires.

• Identifiants source (ancien serveur, chaque boîte) et cible (nouveau serveur, panneau d'hébergement).
• Accès poste : outil de prise en main à distance. Retenir que son shell tourne souvent en SYSTEM (session 0), ce qui change tout par la suite.
• État du poste : espace disque C: (souvent le point de blocage), taille de la boîte, Outlook classique ou « nouveau ».
• Un disque de travail avec de la place (disque externe) pour les extractions et les sauvegardes.
• Quota cible : le défaut d'une boîte fraîchement créée est souvent 1 Go. Passer en illimité dans le panneau avant toute migration, sinon EXIT_OVERQUOTA.

Copie serveur à serveur, boîte par boîte. Sur un hébergement mutualisé sans droits root, imapsync s'installe en local::lib ; les modules XS qui ne compilent pas (Unicode::String, Sys::MemInfo…) se rendent optionnels en patchant la source et en posant un stub.

# passfiles par boîte
printf '%s' 'MDP_SOURCE' > ~/pf/BOX.src
printf '%s' 'MDP_CIBLE'  > ~/pf/BOX.dst

perl -I$HOME/perl5/lib/perl5 $HOME/imapsync-2.314/imapsync \
  --host1 imap.source.tld --user1 [email protected] --passfile1 ~/pf/BOX.src --ssl1 \
  --host2 localhost        --user2 [email protected] --passfile2 ~/pf/BOX.dst --ssl2 \
  --automap --syncinternaldates --pidfile ~/pid/BOX.pid

On convertit le .pst en .eml avec readpst (natif Windows, aucun WSL), puis on téléverse en IMAP avec un script Python reprenable et dédoublonné.

Déployer readpst en natif Windows, sans droits admin

# MSYS2 en dossier utilisateur (sans admin, sans redémarrage)
curl.exe -L -o F:\m\msys2.sfx.exe https://github.com/msys2/msys2-installer/releases/download/nightly-x86_64/msys2-base-x86_64-latest.sfx.exe
F:\m\msys2.sfx.exe -y -oF:\
F:\msys64\usr\bin\bash.exe -lc "pacman -Sy --noconfirm mingw-w64-ucrt-x86_64-libpst"
F:\msys64\ucrt64\bin\readpst.exe -V   # doit afficher la version

Extraire puis téléverser, en dédoublonnant

F:\msys64\ucrt64\bin\readpst.exe -e -o F:\out "C:\...\archive.pst"
F:\m\py\python.exe F:\m\pst2imap.py F:\out

Le script pst2imap.py (voir les scripts) parcourt l'arborescence .eml, mappe vers INBOX.*, crée les dossiers manquants, et fait un APPEND de chaque message avec un en-tête X-Migrate-UID (sha256) plus une réconciliation côté serveur : on peut le relancer sans créer de doublon.

readpst plante sur les gros .ost corrompus (Out Of memory) et sur les chemins de plus de 260 caractères (Cannot open file). La parade : pypff lit le .ost directement et pousse en IMAP en mémoire, sans écrire un seul fichier sur disque (donc plus de limite de chemin), avec un try/except par message : un item corrompu est sauté, jamais de crash global.

# Python embeddable : l'installeur .exe "réussit" sans rien poser sous SYSTEM
curl.exe -L -o F:\m\py.zip https://www.python.org/ftp/python/3.12.7/python-3.12.7-embed-amd64.zip
Expand-Archive -Force F:\m\py.zip F:\m\py
# activer pip, puis :
F:\m\py\python.exe -m pip install libpff-python-windows imapclient

# copie de sécurité du .ost, puis extraction directe vers IMAP
Copy-Item "C:\Users\U\AppData\Local\Microsoft\Outlook\...ost" F:\ost_actif.ost
F:\m\py\python.exe F:\m\ost2imap.py "F:\ost_actif.ost" preview   # vérifier le mapping
F:\m\py\python.exe F:\m\ost2imap.py "F:\ost_actif.ost"           # run réel

MX

@ vers mail.serveur.tld, en retirant les anciens MX. Le champ « serveur de messagerie » attend le nom d'hôte : il ne va pas dans le champ Name.

SPF

v=spf1 include:spf.hebergeur.tld -all, en gardant les include légitimes déjà présents (routeur transactionnel par exemple).

DKIM

default._domainkey repris du panneau d'hébergement ; supprimer les anciens sélecteurs.

Ordre

SPF et DKIM d'abord, puis resync rapide (--maxage 2), puis changement du MX, puis rattrapages (--maxage 1 à H+1h, H+4h, J+1).

• Si le shell distant tourne en SYSTEM, viser le SID de l'utilisateur connecté (Win32_ComputerSystem.UserName, puis SID, puis HKU\<SID>), jamais %APPDATA% ni HKCU : ce sont ceux de SYSTEM, et on configure un profil que personne n'ouvrira.
• Outlook classique obligatoire : les fichiers .prf ne s'appliquent pas au « nouveau Outlook ».
• Ajout du compte IMAP par .prf en mode OverwriteProfile=Append (ajoute sans retirer l'ancien), lancé par outlook.exe /importprf.
• Les signatures sont de simples fichiers locaux, dans le dossier Signatures du bon SID : elles survivent à la migration sans rien faire.

Méthode en deux temps, jamais destructive d'un coup, toujours dédoublonnée par Message-ID :

1. Fusion (COPY) : on copie dans le dossier « propre » les mails qui y manquent, identifiés par Message-ID. Non destructif, la source reste intacte.
2. Vérification puis suppression : on ne supprime un dossier « doublon » que si l'intégralité de son contenu est retrouvée dans la cible. Script en mode aperçu par défaut, go pour exécuter.

Cas typiques rencontrés : les dossiers X - Copie et X (2) (artefacts Outlook), et les doublons entre l'arbre Archive.* (issu du .pst) et les dossiers vivants (issus du .ost).

1. Libérer le disque : supprimer ou déplacer le .pst local, son contenu étant désormais sur le serveur et sauvegardé. Le .pst « par défaut » ne se retire pas directement : créer un petit .pst vide, le définir par défaut, puis retirer le gros du profil, puis supprimer le fichier. Fermer Outlook si Windows le déclare « utilisé ».
2. Limiter le cache : sur le compte IMAP, régler le curseur « Courrier à conserver hors connexion » sur 1 à 6 mois. Le récent reste local et rapide, l'ancien reste sur le serveur et se télécharge à l'ouverture. Effet de bord utile : ça reconstruit un .ost neuf et léger, ce qui règle au passage un .ost corrompu.

Les pièges et leurs parades

Chaque ligne est ancrable : le lien de la ligne pointe directement dessus.

Les scripts

Trois outils, tous rejouables sans créer de doublon : la déduplication repose sur un en-tête injecté X-Migrate-UID (sha256 des octets d'origine) croisé avec le Message-ID, réconciliés côté serveur avant chaque APPEND. En tête de chaque script : HOST, USER, PWD et les chemins.

HOST, PORT = "imap.serveur.tld", 993
USER, PWD  = "[email protected]", "MDP"
SEP = "."
LOCAL_SUF = (" (uniquement cet ordinateur)", " (This computer only)")

def isinbox(s):
    f = "".join(c for c in unicodedata.normalize("NFKD", s or "")
                if not unicodedata.combining(c)).lower()
    return "ception" in f or "inbox" in f       # ancre sur la Boite de reception

def maptgt(path):                               # noms .ost -> INBOX.x.y
    idx = next((i for i, seg in enumerate(path) if isinbox(_strip(seg))), None)
    if idx is None: return None
    rest = [_san(_strip(s)) for s in path[idx+1:]]
    rest = [s for s in rest if s]
    if not rest: return None                    # on ne deverse pas l'inbox brut
    if rest[0].lower() == "archive": return None
    return "INBOX" + SEP + SEP.join(rest)

def _strip(s):
    for suf in LOCAL_SUF:
        if s.endswith(suf): return s[:-len(suf)]
    return s

# build_rfc822(msg) : transport_headers | plain/html (bytes) | pieces jointes
# connect() / ensure() / existing() : APPEND dedup par Message-ID + X-Migrate-UID
# walk() : recursion pypff, saute les dossiers vides, try/except par message

def demojibake(s):                    # noms de dossiers readpst
    try: return s.encode("cp1252").decode("utf-8")
    except (UnicodeEncodeError, UnicodeDecodeError):
        try: return s.encode("latin1").decode("utf-8")
        except (UnicodeEncodeError, UnicodeDecodeError): return s

def dest(rel):
    p = [x for x in rel.split(os.sep) if x and x != "."]
    if p: p = p[1:]                   # retire la racine du .pst
    p = [demojibake(x).replace(".", "_") for x in p]
    return "INBOX.Archive." + ".".join(p) if p else "INBOX.Archive"

# APPEND : sha256 des octets ORIGINAUX, avant injection = idempotent au re-run
k = hashlib.sha256(raw).hexdigest()
if seen(f, k) or k in present: continue
c.append(f, b"X-Migrate-UID: " + k.encode() + eol + raw, flags=[b"\\Seen"], msg_time=dt)

DO = len(sys.argv) > 1 and sys.argv[1] == "go"

for cop in doublons:
    orig = original_de(cop)
    manquants = mids_tree(cop) - mids_tree(orig)
    if manquants:
        print("GARDE", cop, len(manquants), "non couverts")   # on ne touche pas
        continue
    if DO:
        # bottom-up : un dossier parent ne part qu'apres ses enfants
        for f in sorted(sous_dossiers(cop), key=lambda x: -x.count(".")):
            supprimer(f)

Je peux la jouer pour vous

Cette procédure est publiée telle qu'elle est appliquée en intervention réelle. Si vous préférez la déléguer, ou si votre cas sort du cadre décrit ici, écrivez-moi : je reprends la migration de bout en bout, boîtes et postes compris.

Décrire mon cas  ·  Les autres procédures