Voir la démo×
×

Voir NinjaOne en action !

Utiliser Powershell pour ajouter ou supprimer des utilisateurs Active Directory et des groupes d’ordinateurs locaux

Aggiungere o rimuovere utenti da gruppi con PowerShell

La gestion et la modification de l’appartenance des utilisateurs à des groupes (ajouter ou supprimer des utilisateurs) que ce soit sur une machine locale ou dans Active Directory, est une tâche courante pour les professionnels de l’informatique. Une gestion efficace de ces opérations peut grandement améliorer l’administration du système, en simplifiant les processus et en évitant les erreurs. Le pouvoir des scripts prend tout son sens dans ce contexte, car il permet l’automatisation et la précision.

Contexte

Le script fourni plonge dans l’essence même de la gestion informatique en permettant aux administrateurs d’ajouter ou supprimer des utilisateurs de groupes spécifiques. Il est conçu pour être polyvalent, fonctionnant à la fois dans le domaine d’un ordinateur local et dans Active Directory. Au fur et à mesure que les entreprises et les fournisseurs de services gérés (MSP) se développent, la gestion manuelle des utilisateurs peut devenir très compliquée. Ces scripts permettent non seulement de réduire le temps consacré aux tâches de routine, mais aussi de minimiser les erreurs humaines.

Le script

#Requires -Version 2.0

<#
.SYNOPSIS
    Add or remove a user to a group in Active Directory or the local computer.
.DESCRIPTION
    Add or remove a user to a group in Active Directory or the local computer.
.EXAMPLE
     -Group "MyGroup" -UserName "MyUser" -Action Add -IsDomainUser
    Adds MyUser to the group MyGroup in AD.
.EXAMPLE
     -Group "MyGroup" -UserName "MyUser" -Action Remove -IsDomainUser
    Removes MyUser from the group MyGroup in AD.
.EXAMPLE
     -Group "MyGroup" -UserName "MyUser" -Action Add
    Adds MyUser to the group MyGroup on the local computer.
.EXAMPLE
    PS C:\> Modify-User-Membership.ps1 -Group "MyGroup" -UserName "MyUser" -Action Remove
    Removes MyUser from the group MyGroup on the local computer.
.OUTPUTS
    String[]
.NOTES
    Minimum OS Architecture Supported: Windows 7, Windows Server 2012
    This will require RSAT with the AD feature to be installed to function.
    Release Notes:
    Initial Release
By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
    Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
    Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
    Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
    Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
    Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
    Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
    EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
.COMPONENT
    ManageUsers
#>

[CmdletBinding()]
param (
    # Specify one Group
    [Parameter(Mandatory = $true)]
    [String]
    $Group,
    # Specify one User
    [Parameter(Mandatory = $true)]
    [String]
    $UserName,
    # Add or Remove user from group
    [Parameter(Mandatory = $true)]
    [ValidateSet("Add", "Remove")]
    [String]
    $Action,
    # Modify a domain user's membership
    [Parameter(Mandatory = $false)]
    [Switch]
    $IsDomainUser
)

begin {
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        if ($p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator))
        { Write-Output $true }
        else
        { Write-Output $false }
    }
}

process {
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }
    if (-not $IsDomainUser) {
        # Modify Local User
        if ($Action -like "Remove") {
            if ($PSVersionTable.PSVersion.Major -lt 3) {
                # Connect to localhost
                try {
                    $ADSI = [ADSI]("WinNT://$env:COMPUTERNAME")
                }
                catch {
                    Write-Error -Message "Failed to connect to $env:COMPUTERNAME via ADSI object"
                    exit 1
                }
                # Find the group
                try {
                    $ASDIGroup = $ADSI.Children.Find($Group, 'group')
                }
                catch {
                    Write-Error -Message "Failed to find $Group via ADSI object"
                    exit 1
                }
                # Remove the user from the group
                try {
                    $ASDIGroup.Remove(("WinNT://$env:COMPUTERNAME/$UserName"))
                }
                catch {
                    Write-Error -Message "Failed to remove User $UserName from Group $Group"
                    exit 529 # ERROR_MEMBER_NOT_IN_GROUP
                }
                
            }
            else {
                if (
                    # Check that the group exists
                (Get-LocalGroup -Name $Group -ErrorAction SilentlyContinue) -and
                    # Check that the user exists in the group
                (Get-LocalGroupMember -Group $Group -Member $UserName -ErrorAction SilentlyContinue)
                ) {
                    Write-Output "Found $UserName in Group $Group, removing."
                    try {
                        # Remove user from Group, -Confirm:$false used to not prompt and stop the script
                        Remove-LocalGroupMember -Group $Group -Member $UserName -Confirm:$false
                        Write-Output "Removed User $UserName from Group $Group"
                    }
                    catch {
                        Write-Error -Message "Failed to remove User $UserName from Group $Group"
                        exit 529 # ERROR_MEMBER_NOT_IN_GROUP
                    }
                }
                elseif (-not (Get-LocalGroup -Name $Group -ErrorAction SilentlyContinue)) {
                    Write-Error -Message "Group $Group does not exist"
                    exit 528 # ERROR_NO_SUCH_GROUP
                }
                elseif (-not (Get-LocalGroupMember -Group $Group -Member $UserName -ErrorAction SilentlyContinue)) {
                    Write-Error -Message "User does not exist in Group $Group"
                    exit 529 # ERROR_MEMBER_NOT_IN_GROUP
                }
            }
            
        }
        elseif ($Action -like "Add") {
            if ($PSVersionTable.PSVersion.Major -lt 3) {
                # Connect to localhost
                try {
                    $ADSI = [ADSI]("WinNT://$env:COMPUTERNAME")
                }
                catch {
                    Write-Error -Message "Failed to connect to $env:COMPUTERNAME via ADSI object"
                    exit 1
                }
                # Find the group
                try {
                    $ASDIGroup = $ADSI.Children.Find($Group, 'group')
                }
                catch {
                    Write-Error -Message "Failed to find $Group via ADSI object"
                    exit 1
                }
                # Get the members of the group
                $GroupResults = try {
                    $ASDIGroup.psbase.invoke('members')  | ForEach-Object {
                        $_.GetType().InvokeMember("Name", "GetProperty", $Null, $_, $Null)
                    }
                }
                catch {
                    $null
                }
                # Check if the user is in the group
                if ($UserName -in $GroupResults) {
                    # User already in Group
                    Write-Output "User $UserName already in Group $Group"
                    exit 1320 # ERROR_MEMBER_IN_GROUP
                }
                else {
                    # User not in group, add them to the group
                    try {
                        $ASDIGroup.Add(("WinNT://$env:COMPUTERNAME/$UserName"))
                    }
                    catch {
                        Write-Error -Message "Failed to add User $UserName to Group $Group"
                        exit 1388 # ERROR_INVALID_MEMBER
                    }
                    
                    # We can verify the membership by running the following  command:
                    if ($UserName -in (
                            $ASDIGroup.psbase.invoke('members')  | ForEach-Object {
                                $_.GetType().InvokeMember("Name", "GetProperty", $Null, $_, $Null)
                            }
                        )
                    ) {
                        # User in Group
                        Write-Output "Added User $UserName to Group $Group"
                    }
                    else {
                        Write-Error -Message "Failed to add User $UserName to Group $Group"
                        exit 1388 # ERROR_INVALID_MEMBER
                    }
                }
                
            }
            else {
                # Verify that the user and group exist
                if (
                    # Check that the user exists
                (Get-LocalUser -Name $UserName -ErrorAction SilentlyContinue) -and
                    # Check that the group exists
                (Get-LocalGroup -Name $Group -ErrorAction SilentlyContinue)
                ) {
                    # Check if user is already in group
                    if (-not (Get-LocalGroupMember -Group $Group -Member $UserName -ErrorAction SilentlyContinue)) {
                        # User not in group, good to add
                        try {
                            # Add user to group
                            Add-LocalGroupMember -Group $Group -Member (Get-LocalUser -Name $UserName)
                            Write-Output "Added User $UserName to Group $Group"
                        }
                        catch {
                            Write-Error -Message "Failed to add User $UserName to Group $Group"
                            exit 1388 # ERROR_INVALID_MEMBER
                        }
                    }
                    else {
                        # User already in Group
                        Write-Output "User $UserName already in Group $Group"
                        exit 1320 # ERROR_MEMBER_IN_GROUP
                    }
                
                }
            }
        }
    }
    else {
        if ((Get-Module -Name ActiveDirectory -ListAvailable -ErrorAction SilentlyContinue)) {
            try {
                Import-Module -Name ActiveDirectory
                # Get most of our data needed for the logic, and to reduce the number of time we need to talk to AD
                $ADUser = (Get-ADUser -Identity $UserName -Properties SamAccountName -ErrorAction SilentlyContinue).SamAccountName
                $ADGroup = Get-ADGroup -Identity $Group -ErrorAction SilentlyContinue
                $ADInGroup = Get-ADGroupMember -Identity $Group -ErrorAction SilentlyContinue | Where-Object { $_.SamAccountName -like $ADUser }
            }
            catch {
                Write-Error -Message "Ninja Agent could not access AD, please check that the agent has permissions to add and remove users from groups."
                exit 5 # Access Denied exit code
            }
            
            # Modify AD User
            if ($Action -like "Remove") {
                # Verify that the user and group exist, and if the user is in the group
                if (
                    $ADUser -and
                    # Check that the group exists
                    $ADGroup -and
                    # Check that the user exists in the group
                    $ADInGroup
                ) {
                    Write-Output "Found $UserName in Group $Group, removing."
                    try {
                        # Remove user from Group, -Confirm:$false used to not prompt and stop the script
                        Remove-ADGroupMember -Identity $Group -Members $ADUser -Confirm:$false
                        Write-Output "Removed User $UserName from Group $Group"
                    }
                    catch {
                        Write-Error -Message "Failed to remove User $UserName from Group $Group"
                        exit 529 # ERROR_MEMBER_NOT_IN_GROUP
                    }
                }
                elseif (-not $ADGroup) {
                    Write-Error -Message "Group $Group does not exist"
                    exit 528 # ERROR_NO_SUCH_GROUP
                }
                elseif (-not $ADInGroup) {
                    Write-Error -Message "User does not exist in Group $Group"
                    exit 529 # ERROR_MEMBER_NOT_IN_GROUP
                }
            }
            elseif ($Action -like "Add") {
                # Verify that the user and group exist
                if (
                    # Check that the user exists
                    $ADUser -and
                    # Check that the group exists
                    $ADGroup
                ) {
                    # Check if user is already in group
                    if (-not $ADInGroup) {
                        # User not in group, good to add
                        try {
                            # Add user to group
                            Add-ADGroupMember -Identity $Group -Members $ADUser
                            Write-Output "Added User $UserName to Group $Group"
                        }
                        catch {
                            Write-Error -Message "Failed to add User $UserName to Group $Group"
                            exit 1388 # ERROR_INVALID_MEMBER
                        }
                    }
                    else {
                        # User already in Group
                        Write-Output "User $UserName already in Group $Group"
                        exit 1320 # ERROR_MEMBER_IN_GROUP
                    }
                }
            }
        }
        else {
            # Throw error that RSAT: ActiveDirectory isn't installed
            Write-Error -Message "RSAT: ActiveDirectory is not installed or not found on this computer. The PowerShell Module called ActiveDirectory is needed to proceed." -RecommendedAction "https://docs.microsoft.com/en-us/powershell/module/activedirectory/?view=windowsserver2019-ps"
            exit 2 # File Not Found exit code
        }
    }
}

end {}

Accédez à plus de 700 scripts dans le Dojo NinjaOne

Obtenez l’accès

Description détaillée

Le script commence par un message qui donne un aperçu de ses fonctionnalités, des exemples et des exigences. Des paramètres essentiels tels que Group, UserName, Action, et un commutateur facultatif IsDomainUser sont définis, qui contrôlent la logique principale. Une fonction d’aide, Test-IsElevated, vérifie si le script s’exécute avec des droits d’administrateur. La logique principale commence par une vérification de l’élévation, puis indique si la tâche concerne un utilisateur local ou un utilisateur Active Directory. En fonction de la version de PowerShell et de l’action souhaitée (ajouter ou supprimer des utilisateurs), le script s’interface avec Active Directory Service Interfaces (ADSI) ou utilise des cmdlets PowerShell natifs. Pour les utilisateurs Active Directory, le module Active Directory est utilisé, ce qui permet une intégration et une gestion optimale.

Cas d’utilisation potentiels

Étude de cas:

Sarah, administratrice informatique dans une entreprise en pleine expansion, doit intégrer 50 nouveaux employés. Les départements et les rôles variant, l’attribution manuelle des utilisateurs aux groupes AD respectifs prendrait beaucoup de temps. Grâce à ce script, Sarah affecte rapidement les utilisateurs à leurs groupes respectifs, ce qui garantit que les contrôles d’accès sont respectés. Lors des audits informatiques trimestriels, elle utilise également le script pour supprimer des utilisateurs de groupes spécifiques ou des machines locales des anciens employés.

Comparaisons

La gestion traditionnelle des utilisateurs s’appuie généralement sur des outils à interface graphique tels que Active Directory Users and Computers (ADUC) ou Computer Management pour les utilisateurs locaux. Bien qu’ils soient faciles à utiliser, ils ne sont pas efficaces pour les opérations à grande échelle. Ce script, qui s’appuie sur PowerShell, permet d’effectuer en quelques minutes des tâches qui prendraient des heures. Cependant, contrairement aux outils d’interface graphique qui fournissent un retour d’information visuel, le script nécessite des tests approfondis pour s’assurer qu’aucune action involontaire ne se produit.

FAQ

  • Puis-je utiliser ce script sur des versions plus anciennes de PowerShell ?
    Oui, le script prend en charge les versions de PowerShell à partir de 2.0. Toutefois, les fonctionnalités peuvent varier en fonction de la version.
  • Le module Active Directory est-il obligatoire ?
    Pour les actions concernant les utilisateurs du domaine, le module Active Directory est nécessaire.
  • Comment puis-je m’assurer que je dispose des droits d’administrateur ?
    Le script contient des contrôles intégrés des droits d’administrateur et fournit un message d’erreur s’il n’est pas exécuté avec les droits requis.

Implications

Le script peut réduire considérablement les erreurs dans la gestion des groupes d’utilisateurs, ce qui peut avoir des conséquences importantes pour la sécurité informatique. Le fait de s’assurer que les utilisateurs ne font partie que des groupes nécessaires permet d’appliquer le principe du moindre privilège, un élément essentiel de la sécurité informatique. Toutefois, l’automatisation s’accompagne de la responsabilité de veiller à ce que les scripts ne fournissent pas par inadvertance un accès trop élevé, ce qui pourrait entraîner des failles de sécurité.

Recommandations

  • Testez toujours le script dans un environnement contrôlé avant de le déployer dans celui de production.
  • Conservez un journal de toutes les modifications effectuées à l’aide du script à des fins d’audit.
  • Assurez-vous de disposer de sauvegardes d’Active Directory ou des bases de données d’utilisateurs locales afin de pouvoir annuler toute modification involontaire.

Conclusion

Les environnements informatiques devenant de plus en plus complexes, des outils tels que NinjaOne sont essentiels pour fournir des solutions complètes. Pour des tâches telles que la gestion des groupes d’utilisateurs, des scripts tels que celui décrit ci-dessus peuvent être intégrés dans des plateformes comme NinjaOne, ce qui permet aux administrateurs informatiques de disposer des meilleurs outils, d’automatiser et de simplifier les processus tout en maintenant une sécurité optimale.

Prochaines étapes

Pour créer une équipe informatique efficace et performante, il est essentiel d’avoir une solution centralisée qui joue le rôle de noyau principal pour vos services. NinjaOne permet aux équipes informatiques de surveiller, gérer, sécuriser et prendre en charge tous leurs appareils, où qu’ils soient, sans avoir besoin d’une infrastructure complexe sur site.

Pour en savoir plus sur NinjaOne Endpoint Management, participez à une visite guidée en direct ou profitez d’un essai gratuit de la plateforme NinjaOne.

Vous pourriez aussi aimer

Prêt à devenir un Ninja de l’informatique ?

Découvrez comment NinjaOne peut vous aider à simplifier les opérations informatiques.

By clicking the “I Accept” button below, you indicate your acceptance of the following legal terms as well as our Terms of Use:

  • Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms.
  • Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party.
  • Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library belonging to or under the control of any other software provider.
  • Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations.
  • Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks.
  • Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script.
  • EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).