À partir de Windows 10 version 1809, les fonctionnalités à la demande (FOD) et les packs de langues ne peuvent être installés que via Windows Update et non par WSUS. Étant donné que RSAT est une fonctionnalité optionnelle (c'est-à-dire un FOD), ça ne sera plus possible de l'installer sur une machine ayant la stratégie qui empêche le téléchargement depuis les serveurs Windows update.

Voici un script PowerShell qui modifie temporairement les paramètres de votre poste de travail pour cesser d'utiliser WSUS, téléchargera et installera RSAT, puis rétablira les paramètres pour revenir à l'utilisation de WSUS par la suite :

#Modification de la clé de registre pour installer le module sans passer par WSUS mais directement par les serveurs Windows Update

Add-ToLog -Text "Modification de la clé de registre pour utiliser Windows Update et non WSUS..." -logFile $logFile

Set-ItemProperty "REGISTRY::HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" UseWUserver -Value 0

Set-ItemProperty "REGISTRY::HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate" DisableWindowsUpdateAccess -Value 0
 

#Restart du service Windows Update pour prise en compte

Add-ToLog -Text "Redémarrage du service Windows Update" -logFile $logFile

Get-Service wuauserv | Restart-Service

 

#Installation du module PowerShell RSAT-AD

Add-ToLog -Text "Installation du module PowerShell Active Directory (RSAT)..." -logFile $logFile

Get-WindowsCapability -Name "Rsat.ActiveDirectory.DS-LDS.Tools~~~~0.0.1.0" -Online | Add-WindowsCapability -Online | Out-Null

Add-WindowsCapability –Online –Name "Rsat.ActiveDirectory.DS-LDS.Tools~~~~0.0.1.0"

#Remise par défaut de la clé de registre pour repasser par le WSUS

Add-ToLog -Text "Remise par défaut de la clé de registre pour à nouveau passer par le WSUS..." -logFile $logFile

Set-ItemProperty "REGISTRY::HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" UseWUserver -Value 1

Introduction

Microsoft Entra autorise les droits d’accès aux ressources sécurisées via le contrôle d’accès en fonction du rôle Azure (Azure RBAC).Lorsqu’un rôle Azure est attribué à un principal de sécurité Microsoft Entra, Azure octroie l’accès à ces ressources pour ce principal de sécurité. Un principal de sécurité Microsoft Entra peut être un utilisateur, un groupe, un principal de service d’application ou une identité managée pour les ressources Azure.

Besoin

La gestion des permissions Azure RBAC au niveau des abonnements Azure se fait de façon centralisée par les administrateur ayant des permissions privilégiées Aussi, les rôles RBAC s'attribue sur des scopes souvent larges.

Dans certains scénario, un contrôle d'accès plus fin que celui offert par RBAC est nécessaire. Par exemple, il peut être indispensable d'accorder l'accès à certaines ressources, mais pas à toutes, dans une hiérarchie. Ou encore accorder les permission uniquement à des ressources ayant des tags spécifiques.

Aussi, des utilisateurs ont parfois besoin de gérer les permissions d'une service principal sur le scope pour lequel ils ont des droits.

Solution 

Azure ABAC (Attribute Based Access Control) c'est les conditions qui se rajoutent au moment de l'attribution de rôle RBAC permettant ainsi une autre vérification que vous pouvez ajouter à votre attribution de rôle pour fournir un contrôle d’accès encore plus précis. 

Exemple d'utilisation : Attribuer à un groupe Entra ID un rôle permettant d'assigner toutes les permissions RBAC à tout type d'identité (utilisateur, groupe, SPN ou identités managées) à l'exception de certaines permissions privilégiées.

Problème :

Il existe une limitation à la commande "Get-ADGroupMember" et cette dernière est de 5000, ce qui veut dire que si le groupe détient plus de 5000 membres vous obtiendrez un joli message d'erreur du type :

Get-ADGroupMember : The size limit for this resquest was exceeded

Solution :

Voici une fonction Powershell qui vous permettra de récupérer l'intégralité des membres d'un groupe même s'il y en a 10 000 dedans.

Vous pourrez choisir de retourner :

• Les utilisateurs
• Les groupes
• Le tout

Function Get-AllMembers {
     <#
    .SYNOPSIS
    Return a list of members for a group.

    .DESCRIPTION
    Get-AllMembers is a function that returns a list of members for a specific group.
    
    .PARAMETER Name
    The name of the group you want to get the member list.

    .EXAMPLE
    Get-AllMembers "Domain Admins", "DNS Admins"

    .INPUTS
    String

    .OUTPUTS
        PSCustomObject

    .NOTES
        Author:  ADELAIDE Mathieu
    #>
    PARAM (
        [Parameter(Mandatory = $true, ValueFromPipeline = $true, Position = 0)]
        [STRING]$Name,
        [Parameter(Mandatory = $true, ValueFromPipeline = $true, Position = 1)]
        [ValidateSet("UsersOnly","GroupsOnly","All")]
        [STRING]$Return
        )
    Process {
        $Name | Foreach {
            $GroupName = $_
            $ArrayUsers = @()
            $ArrayGroups = @()
            $ArrayAll = @()
            Try {
                $DistinguishedName = Get-ADGroup -Identity $GroupName -ErrorAction Stop | select -ExpandProperty DistinguishedName
                # Searching all Users who's member of current Group
                Try {
                    $AllUsersMembers = Get-ADUser -LDAPFilter "(&(objectCategory=user)(memberOf=$DistinguishedName))" -ErrorAction Stop
                    $AllUsersMembers | foreach {
                        $ArrayUsers += New-Object psobject -Property @{
                            GroupName = $GroupName
                            DistinguishedName = $_.DistinguishedName
                            Enabled = $_.Enabled
                            GivenName = $_.GivenName
                            Name = $_.Name
                            ObjectClass = $_.ObjectClass
                            ObjectGUID = $_.ObjectGUID
                            SamAccountName = $_.SamAccountName
                            SID = $_.SID
                            Surname = $_.Surname
                            UserPrincipalName = $_.UserPrincipalName
                            }

                        # Collect All
                        $ArrayAll += New-Object psobject -Property @{
                            GroupName = $GroupName
                            DistinguishedName = $_.DistinguishedName
                            Enabled = $_.Enabled
                            GivenName = $_.GivenName
                            Name = $_.Name
                            ObjectClass = $_.ObjectClass
                            ObjectGUID = $_.ObjectGUID
                            SamAccountName = $_.SamAccountName
                            SID = $_.SID
                            Surname = $_.Surname
                            UserPrincipalName = $_.UserPrincipalName
                            }
                        }
                    }
                Catch {
                    Write-Warning -Message "Unable to find all users member of $Name"
                    }
                # Searching all Groups who's member of current Group
                Try {
                    $AllGroupsMembers = Get-ADGroup -LDAPFilter "(&(objectCategory=group)(memberOf=$DistinguishedName))" -ErrorAction Stop
                    $AllGroupsMembers | foreach {
                        $ArrayGroups += New-Object psobject -Property @{
                            GroupName = $GroupName
                            DistinguishedName = $_.DistinguishedName
                            GroupCategory = $_.GroupCategory
                            GroupScope = $_.GroupScope
                            Name = $_.Name
                            ObjectClass = $_.ObjectClass
                            ObjectGUID = $_.ObjectGUID
                            SamAccountName = $_.SamAccountName
                            SID = $_.SID
                            }

                        # Collect All
                        $ArrayAll += New-Object psobject -Property @{
                            GroupName = $GroupName
                            DistinguishedName = $_.DistinguishedName
                            Enabled = $_.Enabled
                            GivenName = $_.GivenName
                            Name = $_.Name
                            ObjectClass = $_.ObjectClass
                            ObjectGUID = $_.ObjectGUID
                            SamAccountName = $_.SamAccountName
                            SID = $_.SID
                            Surname = $_.Surname
                            UserPrincipalName = $_.UserPrincipalName
                            }
                        }
                    }
                Catch {
                    # Return an error message if member not found.
                    Write-Warning -Message "Unable to find all groups member of $Name"
                    }
                }
            Catch {
                # Return an error message if Group was not found.
                Write-Warning -Message "Unable to find $Name"
                }
            
            Switch ($Return) {
                "UsersOnly" {Return $ArrayUsers}
                "GroupsOnly" {Return $ArrayGroups}
                "All" {Return $ArrayAll}
                }

            # Release
            $GroupName = $null
            $DistinguishedName = $null
            $AllUsersMembers = $null
            $AllGroupsMembers = $null
            }
        }
    }

Le script ci-dessous requete la base SQL de SCCM pour lister et exporter en CSV, les points de distribution SCCM

########################################################################################################
### REQUETE LA BASE SQL DE SCCM POUR OBTENIR LA LISTE DES POINTS DE DISTRIBUTION SCCM.
### EXPORT DES RESULTAT EN FICHIER CSV  #####
######################################################################################################## 

# AUTHOR: CJOURDAN

<# 

    .SYNOPSIS 
        REQUETE LA BASE SQL DE SCCM POUR OBTENIR LA LISTE DES POINTS DE DISTRIBUTION SCCM
        EXPORT DU RESULTAT EN FICHIER CSV.

    .PARAMETER  
        SQLInstance : Instance SQL
        SQLDB : Instance SQL
        SQLQuery : Requete SQL
        ExportFolder : Dossier d'export du fichier CSV
        LogFolder : Chemin du dossier où creer le log du script

 
    .EXAMPLE 
     .\SCCM_SCCM_Distribution_Points.ps1 -SQLInstance SQLSCCM\SCCM -SQLDB CM_BIM -ExportFolder C:\MyExport -LogFolder C:\MyLogs
#>


[CmdletBinding()]
param(
[Parameter(Mandatory=$true,HelpMessage="Instance SQL")]
[string]$SQLInstance,

[Parameter(Mandatory=$true,HelpMessage="Base SQL")]
[string]$SQLDB,

[Parameter(Mandatory=$false,HelpMessage="Requete SQL")] 
[string]$SQLQuery= $("/* --- ALL SCCM DISTRIBUTION POINTS --- */

Declare @UserSIDs As Varchar(25); 
Set @UserSIDs = 'Disabled'

SELECT DISTINCT                 
        dp.ServerName AS Distribution_Point 
        
from fn_rbac_SystemResourceList(@UserSIDs)  as sys 
join fn_rbac_DistributionPointInfo(@UserSIDs)  as dp 
on sys.NALPath = dp.NALPath 
where sys.RoleName = 'SMS Distribution Point'

"),


[Parameter(Mandatory=$true,HelpMessage="Dossier d'export du fichier CSV")]
[string]$ExportFolder,

[Parameter(Mandatory=$true,HelpMessage="Chemin du dossier où creer le log du script")] 
[string]$LogFolder

)


# SCRIPT NAME
$ScriptName = "SCCM_SCCM_Distribution_Points.ps1"


# LogName = ScriptName without extension
$Log = $ScriptName.Split('.')[0]


### FUNCTIONS

# Function Write-Log



function Write-Log 
{ 
    <# 
    .SYNOPSIS 
        This function creates or appends a line to a log file. 
 
    .PARAMETER  Message 
        The message parameter is the log message you'd like to record to the log file. 
 
    .EXAMPLE 
        PS C:\> Write-Log -Message 'Value1' 
        This example shows how to call the Write-Log function with named parameters. 
    #> 
    [CmdletBinding()] 
    param ( 
        [Parameter(Mandatory)] 
        [string]$Message,
        [Parameter(Mandatory)] 
        [string]$LogPath, 
        [Parameter(Mandatory)] 
        [string]$LogName
        
    ) 
     
    try 
    { 
        $DateTime = Get-Date -Format ‘MM-dd-yy HH:mm:ss’ 
        Add-Content -Value "$DateTime # $Message" -Path "$LogPath\$LogName.log" 
    } 
    catch 
    { 
        Write-Error $_.Exception.Message 
    } 
} 


Function GetSQLData {

<# 
    .SYNOPSIS 
        This function query SQL Database and get Data 
 
    .PARAMETER  
        SQLInstance: Instance SQL.
        SQLDB: Base SQL.
        SQLQuery: Requete SQL.

 
    .EXAMPLE 
        GetSQLData -SQLInstance "MyInstance" -SQLDB "MyDB" -SQLQuery "Select * from MyView"
    #> 


[CmdletBinding()] 
    Param( 
        [Parameter(Mandatory=$false)] 
        [string[]] 
        $SQLInstance,
        [Parameter(Mandatory=$false)] 
        [string[]] 
        $SQLDB,
        [Parameter(Mandatory=$false)] 
        [string[]] 
        $SQLQuery
        
        )

$connectionString = "Data Source=$SQLInstance;"+"Integrated Security=SSPI;"+"Initial Catalog=$SQLDB"

$connection = new-object system.data.SqlClient.SQLConnection($connectionString)
$command = new-object system.data.sqlclient.sqlcommand($SQLQuery,$connection)
$connection.Open()

$adapter = New-Object System.Data.sqlclient.sqlDataAdapter $command
$dataset = New-Object System.Data.DataSet
$adapter.Fill($dataSet) | Out-Null

$connection.Close()
$dataSet.Tables

}






# EXECUTE Query ($SQLQuery)
    Write-Log -Message "Execution of GetSQLData on $SQLDB" -LogPath $LogFolder -LogName $Log
    $Result = 
    Try {
        GetSQLData -SQLInstance $SQLInstance -SQLDB $SQLDB -SQLQuery $SQLQuery
        }
    Catch
        {
        $Message = "ERROR DURING EXECUTION OF QUERY"
        Write-Host -F Red $Message
        Write-Log -Message "$Message - $($Error[0].Exception)" -LogPath $LogFolder -LogName $Log
        Exit 1
        }


########################################
# SOUS-REGROUPEMENTS
########################################


# All SCCM DP
$AllSCCMDP = $Result | ConvertTo-Csv -Delimiter ';' -NoTypeInformation | foreach {$_.replace('"','')}

$AllSCCMDP

# EXPORTS TO TXT FILES
$AllSCCMDP  |  Out-File -FilePath "$ExportFolder\All_SCCMDP.txt" -Force



# DISPLAY SUCCESS
$Message = "--- EXECUTION OK ---"
Write-Host -F Green $Message
Write-Log -Message $Message -LogPath $LogFolder -LogName $Log

Besoin :

Supprimer en masse des devices Autopilot d'un tenant source (Intune) pour pouvoir les migrer vers un tenant cible.

N.B : Un device Autopilot qu'on intègre dans Intune en utilisant son Hash ID ne peut pas co-exister dans deux tenants.

Solution :

1- Extraire les numéros de série des devices Autopilot à supprimer depuis Intune et les mettre dans un fichier texte nommé "Autopilot_Device_SN_list.txt" et le placer sous "c:\Windows\Temp".

2- Exécuter le script PowerShell ci-dessous afin de supprimer des devices Autopilot :

#STEP 1: Install WindowsAutopilotIntune Powershell module (if required, need ot run PowerShell as admin)
    Install-module WindowsAutopilotIntune -Force -AllowClobber

#STEP 2: Install WindowsAutopilotIntune Powershell module
    Import-module WindowsAutopilotIntune

#STEP 3: Connect to Microsoft Graph
    Connect-MgGraph -scopes "Group.ReadWrite.All, Device.ReadWrite.All, DeviceManagementManagedDevices.ReadWrite.All, DeviceManagementServiceConfig.ReadWrite.All, GroupMember.ReadWrite.All"

#STEP 4: Get the Autopilot devices Serial Numbers in a variable $DeviceSNs
    $DeviceSNs = Get-Content "C:\Windows\Temp\Autopilot_Device_SN_list.txt"
    $Counter = 0

#STEP 5: Delete the Autopilot devices based on serial number list
    foreach ($DeviceSN in $DeviceSNs)
    {
        $Counter++
        #Get Autopilot device ID
        $DeviceID = (Get-AutopilotDevice -serial $DeviceSN).id
        #Get current device information
        $CurrentDevice = Get-AutopilotDevice -id $DeviceID
        Write-host "Working on device $DeviceSN" -ForegroundColor Cyan
        #Delete device from Intune Windows Autopilot devices
        try
        {
            Remove-AutopilotDevice -id $DeviceID
            Write-host "- Device $DeviceSN is deleted" -ForegroundColor Green
        }
        catch{
            $ErrorMessage = $_.Exception.message; Write-Host $ErrorMessage -ForegroundColor Red
        }
        #Counter for PowerShell execution progress
        Write-Progress -Activity "Processing $($Counter) of $($DeviceSNs.count)" -CurrentOperation $DeviceSN -PercentComplete (($Counter / $DeviceSNs.count) * 100)
        Start-Sleep -Milliseconds 200
    }

N.B : le chemin vers le fichier texte qui contient les numéros de série des devices Autopilot "C:\Windows\Temp\Autopilot_Device_SN_list.txt" peut être modifié.

Besoin :

On ne peut pas identifier simplement les noms de groupes qui sont membres du groupe local "Administrateurs" sur une machine joint à l'Azure AD.

Si on fait Windows+R et on tape "lusrmgr.msc" pour afficher les utilisateurs et groupes locaux d'une machine, on souhaite par exemple afficher les membres du groupe Administrateurs, on n'aura pas les noms des groupes membres mais plutôt leurs SID.

Ces SID doivent être convertis en GUID pour pouvoir chercher les noms des groupes dans Azure AD.

Solution :

J'ai utilisé ce script PowerShell pour convertir le SID en GUID :

function Convert-AzureAdSidToObjectId {
<#
.SYNOPSIS
Convert a Azure AD SID to Object ID
 
.DESCRIPTION
Converts an Azure AD SID to Object ID.
Author: Oliver Kieselbach (oliverkieselbach.com)
The script is provided "AS IS" with no warranties.
 
.PARAMETER ObjectID
The SID to convert
#>

    param([String] $Sid)

    $text = $sid.Replace('S-1-12-1-', '')
    $array = [UInt32[]]$text.Split('-')

    $bytes = New-Object 'Byte[]' 16
    [Buffer]::BlockCopy($array, 0, $bytes, 0, 16)
    [Guid]$guid = $bytes

    return $guid
}

$sid = "S-1-12-1-1943430372-1249052806-2496021943-3034400218"
$objectId = Convert-AzureAdSidToObjectId -Sid $sid
Write-Output $objectId


# Output:

# Guid
# ----
# 73d664e4-0886-4a73-b745-c694da45ddb4

N.B : Il faut renseigner le SID dans la variable $sid pour que le script retourne son GUID

Dans un précédent article j'expliquais comment réaliser un hard match (https://blog.piservices.fr/post/2021/04/01/o365-realiser-un-hard-match).

J'ai récemment eu à me servir de nouveau des cmdlets et ces dernières ne fonctionnaient pas correctement, il est possible de le faire via API Graph, mais les commande Azure AD permettent encore de le faire si besoin.

# Get GUID for User
$User = Get-ADUser jdupont | select ObjectGUID,UserPrincipalName
$Upn = $User.UserPrincipalName
$Guid = $User.ObjectGUID.Guid
 
# Convert GUID to ImmutableID
$ImmutableId = [System.Convert]::ToBase64String(([GUID]($User.ObjectGUID)).tobytearray())
 
# Connect Azure AD
Connect-AzureAD

# Retrieve my user
$User = Get-AzureADUser -SearchString "jdupont @mydomain.com"

# Set ImmutableID to user
Set-AzureADUser -ObjectId $User.ObjectID -ImmutableId $ImmutableId

Microsoft a ajouté la prise en charge de l'envoi à partir d'une adresse mail en alias dans Office 365/Microsoft 365. Toutefois, la fonctionnalité Envoyer en tant qu'alias ne fonctionnera que pour les boîtes aux lettres Exchange Online et ne fonctionnera pas pour les boîtes aux lettres Exchange Onpremise.

Cet article explique comment activer la fonctionnalité Envoyer depuis un alias dans un tenant Microsoft O365 et comment envoyer des e-mails en tant qu'alias dans Outlook et Outlook sur le Web. Le paramètre s’applique à l’ensemble du tenant. Il n’y a aucun moyen de restreindre la possibilité l'envoi des e-mails à partir d’alias vers certaines boîtes aux lettres.

Activer l'option SendFromAliasEnabled dans O365 

1. Se connecter à Exchange Online PowerShell:

Import-Module ExchangeOnlineManagement

Connect-ExchangeOnline -UserPrincipalName 'UPNO365'

2. Une fois connecté, exécuter la commande ci-dessous pour vérifier l'état actuel de l'option SendFromAliasEnabled 

Get-OrganizationConfig | Format-Table SendFromAliasEnabled

 Puis exécuter la commande:

Set-OrganizationConfig -SendFromAliasEnabled $True

 Activer l’envoi à partir d’un alias dans le centre d’administration Exchange

Vous pouvez également activer cette option à partir du Centre d’administration Exchange:

1. Se connecter au centre d’administration Exchange.
2. Cliquer sur Paramètres > Flux de messagerie.
3. Cocher la case Activer l’envoi à partir d’alias.
4. Cliquer sur Enregistrer.

Envoyer à partir d’un alias dans Outlook

Pour envoyer à partir d’une adresse d’alias dans Outlook:

1. Démarrer l’application Outlook puis cliquer sur Nouvel e-mail.
2. Cliquer sur Options > de Cela affichera le champ De dans Outlook.
3. Cliquer sur À partir de > autre adresse e-mail....puis renseigner l’adresse de l’alias et cliquez sur OK.

Envoyer à partir d’un alias dans Outlook sur le web

Pour envoyer à partir d’un alias dans Outlook sur le web:

1. Se connecter à Outlook sur le web.
2. Cliquer sur Nouveau message > ... > montrer à partir de Cela affichera le champ De dans Outlook web
3. Cliquer sur À partir de > autre adresse e-mail... et renseigner l’adresse de l’alias.

Sous ce titre, le cas de l'utilisation du Widget Powershell Grid dans la console Monitoring de SCOM pour afficher certaines alertes spécifiques.

On commence par creer une vue Dashboard

On choisit le template Grid Layout

On nomme le dashboard

On selectionne 1 cell

Cliquer Create

Cliquer "Click to add widget"

Selectionner Powershell Grid Widget

Nommer le widget, par exemple avec le meme nom que le dashboard

Copier coller le script suivant dans le champ Script

# Get SCOM Alert Related to Discovery and Monitoring Error
$Alerts = Get-SCOMAlert -Criteria "ResolutionState <> 255 AND Name matches '.*(Discovery|Monitoring) (failed|error).*'" #| select name,MonitoringObjectDisplayName,MonitoringObjectPath,LastModified,Description | ft -AutoSize

foreach ($alert in $Alerts)
{

$AlertName = $alert.name

$AlertLastModified = $alert.lastmodified

$MonObjDisplayName = $alert.MonitoringObjectDisplayName.ToString()

$MonObjPath = $alert.MonitoringObjectPath.ToString()

$AlertDesc = $alert.Description.ToString()

$dataObject = $ScriptContext.CreateInstance('xsd://foo!bar/baz')

#Create an ID used for sorting the output - Must be a string value - Used to sort the grid
$dataObject['Id'] = $MonObjDisplayName
$dataObject['name'] = $AlertName
$dataObject['MonitoringPath'] = $MonObjPath
$dataObject['LastModified'] = $AlertLastModified
$dataObject['Description'] = $AlertDesc


# Add the data object to be displayed in the dashboard
  $ScriptContext.ReturnCollection.Add($dataObject)

}

Dans ce script on recupere les alertes dont le nom correspond a des erreur de Discovery ou Monitoring.

Ne pas hesiter a faire évoluer les critères pour inclures d'autres cas propre a votre environnement.

Get-SCOMAlert -Criteria "ResolutionState <> 255 AND Name matches '.*(Discovery|Monitoring) (failed|error).*'"

Cliquer Create

Cliquer Close

La liste des alertes s'affiche

L'authentification multifacteur (MFA) est une méthode d'authentification permettant de renforcer la sécurité de votre mot de passe: L'utilisateur devra définir une seconde méthode d'authentification afin de se connecter à son compte : le mot de passe seul ne suffira plus. Par exemple, l'utilisateur devra saisir son mot de passe puis un code reçu par SMS (en guise de second facteur d'authentification).

Au fil du temps, l'utilisateur peut perdre ou remplacer son dispositif d'authentification ou passer à un nouveau numéro de téléphone mobile. Il est donc nécessaire d'Exiger la réinscription du MFA ce qui fera en sorte que lorsque l'utilisateur se connectera la prochaine fois, il lui sera demandé de configurer une nouvelle méthode d'authentification MFA.

Les étapes ci-dessous permettent de réinitialiser l’authentification multifacteur d’un compte utilisateur dans Azure AD. Les actions doivent être faite en tant qu'administrateur doté du rôle d'administrateur d'authentification ou d'administrateur global:

1. Se connecter sur https://portal.azure.com ,dans la zone de recherche, rechercher Azure Active Directory puis cliquer sur Users

   

2. Une liste de Tous les utilisateurs apparaît, renseigner le nom ou l’adresse mail du compte pour qui réinitialiser le MFA puis sélectionner le

3. La page Profil de l'utilisateur sélectionné apparaît, sélectionner Méthode d'Authentification 
4. Dans la page Méthodes d’authentification, supprimer toutes les méthodes d’authentification enregistrées
5. Cliquer par la suite sur Exiger une réinscription de l’authentification multifacteur      

Note: Si l'appareil de l'utilisateur a été perdu ou volé, cliquer également sur Révoquer les sessions MFA. Cela réinitialise les détails MFA de l'utilisateur qui doit désormais réenregistrer ses méthodes MFA lors de sa prochaine connexion.