Le blog technique

Toutes les astuces #tech des collaborateurs de PI Services.

#openblogPI

Voir tous les articles

Retrouvez les articles à la une

[REX] Erreur lors de l’import d’un module : gérer les versions multiples

par | 29 Jan 2026 |

PowerShell repose largement sur des modules pour étendre ses fonctionnalités, que ce soit pour l’administration système, la gestion Microsoft 365 ou des scripts internes. Dans de nombreux environnements, il arrive qu’un même module soit présent en plusieurs versions sur la machine, ce qui peut générer des conflits lors de l’import dans un script.

Ce problème se manifeste souvent lorsque l’on écrit ou exécute des scripts sur différentes machines ou environnements, par exemple :

  • un script utilisant Exchange Online ou Microsoft.Graph sur des serveurs différents
  • plusieurs versions d’un module interne développé en interne pour automatiser l’inventaire ou la configuration
  • des mises à jour partielles qui laissent des versions anciennes et nouvelles sur la machine

Dans ces cas, l’exécution d’un Import-Module peut échouer ou charger la mauvaise version, entraînant des erreurs inattendues ou des comportements incompatibles.

Exemples typiques :

  • Import-Module : Module 'PnP.PowerShell' is already loaded.
  • Des cmdlets manquantes ou modifiées entre versions
  • Conflits de dépendances entre modules
  • Scripts fonctionnant en test mais échouant en production

Ces erreurs surviennent car PowerShell charge par défaut la première version trouvée dans le $env:PSModulePath, sans vérifier la compatibilité de version avec le script.

La gestion des versions de module est un élément souvent sous-estimé :

  • Chaque version peut contenir des cmdlets différentes, ou modifier le comportement existant
  • Certains modules ne supportent pas la cohabitation de plusieurs versions dans la même session
  • Les scripts automatisés peuvent être sensibles à la version exacte pour des raisons de compatibilité ou de sécurité

Solutions et bonnes pratiques

  1. Spécifier la version souhaitée lors de l’import

Pour éviter les conflits, utilisez -RequiredVersion pour charger exactement la version nécessaire :

Import-Module -Name PnP.PowerShell -RequiredVersion 1.12.0

Si le script peut tolérer plusieurs versions récentes, utilisez -MinimumVersion et/ou -MaximumVersion pour définir une plage compatible :

Import-Module -Name PnP.PowerShell -MinimumVersion 1.10.0 -MaximumVersion 1.12.0
  1. Vérifier les versions installées avant import
Get-InstalledModule -Name PnP.PowerShell -AllVersions

Cela permet d’identifier les versions présentes et de planifier une mise à jour ou un nettoyage si nécessaire.

  1. Forcer le rechargement si un module est déjà chargé

Lorsque PowerShell détecte une version chargée, certaines cmdlets peuvent provoquer des erreurs. -Force permet de recharger la version spécifiée :

Import-Module -Name PnP.PowerShell -RequiredVersion 1.12.0 -Force
  1. Importer via le chemin complet du module

Pour un contrôle absolu et éviter tout conflit avec d’autres versions présentes dans $env:PSModulePath :

Import-Module "C:\Program Files\WindowsPowerShell\Modules\PnP.PowerShell\1.12.0\PnP.PowerShell.psd1"
  1. Limiter le scope de l’import

En utilisant -Scope CurrentUser ou -Scope LocalSession, on peut isoler le module à la session ou à l’utilisateur, réduisant les conflits avec d’autres scripts ou administrateurs :

Import-Module -Name PnP.PowerShell -RequiredVersion 1.12.0 -Scope CurrentUser

[Entra ID / Hybrid Identity] Mot de passe valide en AD On-Prem mais expiré dans Entra ID

par | 28 Jan 2026 | , , ,

Le problème est apparu avec des comptes de service on-premises, configurés avec une PSO Active Directory autorisant une validité de mot de passe étendue (1 an). Ces comptes étaient synchronisés vers Entra ID via Azure AD Connect, ce qui est une pratique courante pour des scripts, services ou tâches hybrides.

Côté Entra ID, en revanche, la politique de mot de passe par défaut impose une expiration à 90 jours. Contrairement à AD on-prem, il n’est pas possible d’appliquer une politique de mot de passe spécifique à un utilisateur ou un groupe sans impacter l’ensemble du tenant.

Résultat : le mot de passe reste parfaitement valide on-prem, mais Entra ID le considère comme expiré.

Les symptômes sont trompeurs :

  • le compte n’est pas bloqué
  • l’authentification on-prem fonctionne
  • mais toute tentative d’accès cloud (M365, Graph, Exchange Online, SharePoint, etc.) échoue

Ce scénario devient critique lorsque le compte de service on-prem initie une connexion vers le cloud : scripts PowerShell, tâches planifiées, flux hybrides.., tout casse silencieusement à cause de l’expiration côté Entra ID.

Après analyse, le comportement est logique : Entra ID ne tient pas compte des PSO on-premises pour l’expiration du mot de passe. L’état du mot de passe est évalué selon les règles cloud, indépendamment de sa validité dans AD.

La solution consiste donc à désactiver explicitement l’expiration du mot de passe côté Entra ID pour ces comptes spécifiques. Cela se fait via Microsoft Graph en positionnant la propriété, passwordPolicies à DisablePasswordExpiration.

Commande PowerShell :

Update-MgUser -UserId $UserId -PasswordPolicies "DisablePasswordExpiration"

Cette configuration permet :

  • de conserver une PSO stricte et contrôlée on-prem
  • d’éviter toute expiration côté cloud
  • de sécuriser les scénarios hybrides et automatisés

Cette approche doit évidemment rester limitée aux comptes de service et documentée clairement, mais elle s’avère indispensable dans de nombreux environnements hybrides réels.

[PowerShell] Envoi d’e-mails : Send-MailMessage vs Send-MgUserMail

par | 27 Jan 2026 | , ,

L’envoi d’e-mails est une fonctionnalité centrale dans de nombreux scripts PowerShell : rapports d’audit, alertes, notifications ou comptes rendus automatisés. Historiquement, la cmdlet Send-MailMessage a longtemps été la solution privilégiée. Avec l’évolution de Microsoft 365 et l’arrivée de Microsoft Graph, de nouvelles approches ont émergé, notamment via Send-MgUserMail.

Ces deux méthodes répondent au même besoin fonctionnel, mais reposent sur des modèles très différents, avec des impacts importants en matière de sécurité, d’authentification et de pérennité.

Send-MailMessage repose sur le protocole SMTP. Il s’agit d’une cmdlet simple à mettre en œuvre, largement utilisée dans les scripts historiques. Elle nécessite toutefois l’accès à un serveur SMTP, souvent avec une authentification basique ou un compte technique.

Avec le durcissement de la sécurité Microsoft 365 et la fin progressive de l’authentification basique, cette méthode devient de plus en plus contraignante. Elle est aujourd’hui marquée comme obsolète par Microsoft et n’est plus recommandée pour de nouveaux développements.

À l’inverse, Send-MgUserMail s’appuie sur Microsoft Graph et fonctionne via des API modernes. L’envoi du message est réalisé au nom d’un utilisateur ou d’une application, en respectant les mécanismes d’authentification modernes (OAuth 2.0).

Cette approche s’intègre naturellement aux environnements Microsoft 365 sécurisés, mais demande une configuration initiale plus structurée, notamment au niveau des permissions Graph.

Envoi d’e-mail via Send-MailMessage (SMTP)

$SmtpParams = @{
    From       = $SmtpFrom
    To         = $SmtpTo
    Cc         = $SmtpCc
    Subject    = $Subject
    Body       = $Body
    BodyAsHtml = $True
    SmtpServer = $SmtpServer
}

Send-MailMessage @SmtpParams -Attachments $FilePath_1, $FilePath_2

Note: le paramètre "Attachments » est là pour rajouter des pièces jointes au mail, ici les arguments représente le chemin du fichier.

Envoi d’e-mail via Send-MgUserMail (Microsoft Graph)

Prérequis:

  • Module Microsoft Graph
  • Utilisateur ou une application autorisée à envoyer des e-mails (Mail.Send)

Deux modèles d’authentification possibles:

Connexion en mode déléguée :

Connect-MgGraph -Scopes "Mail.Send"

Connexion en mode applicative (avec un certificat ou un secret) :

Connect-MgGraph -TenantId "<TenantId>" -ClientId "<AppId>" -CertificateThumbprint "<Thumbprint>"

Une fois la connexion à Graph faite, ci-dessous un template pour envoyer un mail avec un .csv en pièce jointe:

$SmtpFrom = "sender@contoso.com"
$To_Recipients = "mail1@contoso.com", "mail2@contoso.com"
$Cc_Recipients = "mail3@contoso.com", "mail4@contoso.com"
$EmailSubject = "Mail Subject"

# Lit un fichier, le convertit en Base64 et récupère son nom pour une pièce jointe.
$AttachmentContentBytes_1 = [System.IO.File]::ReadAllBytes($FilePath_1)
$AttachmentBase64_1 = [System.Convert]::ToBase64String($AttachmentContentBytes_1)
$AttachmentName_1 = [System.IO.Path]::GetFileName($FilePath_1)

# Formatage nécessaire pour l'envoie à plusieurs destinataire
$To_Recipients_List = @()
foreach ($To_Recipient in $To_Recipients) {
    $To_Recipients_List += @{
        EmailAddress = @{
            Address = $To_Recipient
        }
    }
}

$Cc_Recipients_List = @()
foreach ($Cc_Recipient in $Cc_Recipients) {
    $Cc_Recipients_List += @{
        EmailAddress = @{
            Address = $Cc_Recipient
        }
    }
}

$EmailProperties = @{
    ToRecipients = $To_Recipients_List
    CcRecipients = $Cc_Recipients_List
    Subject      = $EmailSubject
    Body         = @{
        ContentType = "HTML"
        Content     = $Body
    }
    Attachments  = @(
        @{
            "@odata.type" = "#microsoft.graph.fileAttachment"
            Name          = $AttachmentName_1
            ContentBytes  = $AttachmentBase64_1
            ContentType   = "text/csv"
        }
    )
}

Send-MgUserMail -UserId $SmtpFrom -Message $EmailProperties

Note : le paramètre UserId représente la boîte aux lettres émettrice, il faut s’assurer qu’elle existe réellement sinon l’envoie ne fonctionnera pas.

Derniers articles

Catégories

Archives

Auteurs/Autrices