Comment obtenir tous les groupes dont un utilisateur est membre?
La commande Get-ADGroupMember de la cmdlet de PowerShell renvoie les membres d'un groupe spécifique. Existe-t-il une cmdlet ou une propriété pour obtenir tous les groupes dont un utilisateur particulier est membre?
J'ai corrigé mon erreur: Get-Member devrait être Get-ADGroupMember.
Get-ADPrincipalGroupMembership le fera.
Get-ADPrincipalGroupMembership username | select name
name
----
Domain Users
Domain Computers
Workstation Admins
Company Users
Company Developers
AutomatedProcessingTeam
Une seule ligne, aucun module nécessaire, utilise l’utilisateur actuellement connecté:
(New-Object System.DirectoryServices.DirectorySearcher("(&(objectCategory=User)(samAccountName=$($env:username)))")).FindOne().GetDirectoryEntry().memberOf
Merci pour cet article vbs/powershell: http://technet.Microsoft.com/en-us/library/ff730963.aspx
Une alternative plus concise à celle publiée par Canoas, pour obtenir l’appartenance à un groupe pour l’utilisateur actuellement connecté.
Je suis tombé sur cette méthode dans cet article de blog: http://www.travisrunyard.com/2013/03/26/auto-create-Outlook-map-user-profiles/
([ADSISEARCHER]"samaccountname=$($env:USERNAME)").Findone().Properties.memberof
Une version encore meilleure qui utilise une expression régulière pour supprimer le guff LDAP et laisse les noms de groupe uniquement:
([ADSISEARCHER]"samaccountname=$($env:USERNAME)").Findone().Properties.memberof -replace '^CN=([^,]+).+$','$1'
Vous trouverez plus de détails sur l’utilisation de l’accélérateur de type [ADSISEARCHER] sur le blog du scripteur: http://blogs.technet.com/b/heyscriptingguy/archive/2010/08/24/use-the-powershell-adsisearcher -type-accelerator-to-search-active-directory.aspx
(GET-ADUSER –Identity USERNAME –Properties MemberOf | Select-Object MemberOf).MemberOf
Chemin de la vieille école de CMD:
Net User mst999 /domain
Obtenir l'appartenance à un groupe pour un utilisateur:
$strUserName = "Primoz"
$strUser = get-qaduser -SamAccountName $strUserName
$strUser.memberof
Voir OBTENIR L'APPARTENANCE À UN GROUPE POUR UN UTILISATEUR.
Mais consultez également les commandes PowerShell gratuites pour Active Directory de Quest.
La commande [Edit: Get-ADPrincipalGroupMembership est incluse dans Powershell depuis v2 avec Windows 2008 R2. Voir la réponse de kstrauss ci-dessous.]
Get-Member ne vise pas à obtenir l'appartenance à un groupe d'utilisateurs. Si vous souhaitez obtenir une liste des groupes auxquels un utilisateur appartient sur le système local, vous pouvez le faire en:
$query = "ASSOCIATORS OF {Win32_Account.Name='DemoUser1',Domain='DomainName'} WHERE ResultRole=GroupComponent ResultClass=Win32_Account"
Get-WMIObject -Query $query | Select Name
Dans la requête ci-dessus, remplacez DemoUser1 par le nom d'utilisateur souhaité et le nom de domaine par votre nom d'ordinateur local ou votre nom de domaine.
Pas besoin de longs scripts quand il s'agit d'un simple liner ..
Commande QUEST
(Get-QADUser -Identity john -IncludedProperties MemberOf | Select-Object MemberOf).MemberOf
MS AD Command
(GET-ADUSER –Identity john –Properties MemberOf | Select-Object MemberOf).MemberOf
Je trouve que le MS AD cmd est plus rapide mais certaines personnes préfèrent les Quest.
Steve
Get-Member est une applet de commande permettant de répertorier les membres d'un .NET object. Cela n'a rien à voir avec l'appartenance à un utilisateur/groupe. Vous pouvez obtenir l'appartenance au groupe de l'utilisateur actuel de la manière suivante:
PS> [System.Security.Principal.WindowsIdentity]::GetCurrent().Groups |
Format-Table -auto
BinaryLength AccountDomainSid Value
------------ ---------------- -----
28 S-1-5-21-... S-1-5-21-2229937839-1383249143-3977914998-513
12 S-1-1-0
28 S-1-5-21-... S-1-5-21-2229937839-1383249143-3977914998-1010
28 S-1-5-21-... S-1-5-21-2229937839-1383249143-3977914998-1003
16 S-1-5-32-545
...
Si vous avez besoin d'accéder aux informations de groupe d'utilisateurs arbitraires, la suggestion de @tiagoinu d'utiliser les applets de commande Quest AD est une meilleure solution.
Utilisation:
Get-ADPrincipalGroupMembership username | select name | export-CSV username.csv
Cela dirige la sortie de la commande dans un fichier CSV .
C'est juste une ligne:
(get-aduser joe.bloggs -properties *).memberof
fin de :)
Commencez par importer le module activedirectory:
import-module activedirectory
Puis lancez cette commande:
Get-ADGroupMember -Identity $group | foreach-object {
Write-Host $_.SamAccountName
}
Cela affichera les membres du groupe spécifié.
Le ci-dessous fonctionne bien:
get-aduser $username -Properties memberof | select -expand memberof
Si vous avez une liste d'utilisateurs:
$list = 'administrator','testuser1','testuser2'
$list | `
%{
$user = $_;
get-aduser $user -Properties memberof | `
select -expand memberof | `
%{new-object PSObject -property @{User=$user;Group=$_;}} `
}
J'ai écrit une fonction PowerShell appelée Get-ADPrincipalGroupMembershipRecursive. Il accepte le DSN d'un utilisateur, d'un ordinateur, d'un groupe ou d'un compte de service. Il extrait une liste initiale de groupes de l'attribut memberOf du compte, puis vérifie de manière récursive les appartenances à ces groupes. Le code abrégé est ci-dessous. Le code source complet avec commentaires peut être trouvé ici .
function Get-ADPrincipalGroupMembershipRecursive( ) {
Param(
[string] $dsn,
[array]$groups = @()
)
$obj = Get-ADObject $dsn -Properties memberOf
foreach( $groupDsn in $obj.memberOf ) {
$tmpGrp = Get-ADObject $groupDsn -Properties memberOf
if( ($groups | where { $_.DistinguishedName -eq $groupDsn }).Count -eq 0 ) {
$groups += $tmpGrp
$groups = Get-ADPrincipalGroupMembershipRecursive $groupDsn $groups
}
}
return $groups
}
# Simple Example of how to use the function
$username = Read-Host -Prompt "Enter a username"
$groups = Get-ADPrincipalGroupMembershipRecursive (Get-ADUser $username).DistinguishedName
$groups | Sort-Object -Property name | Format-Table
Je ne pouvais pas obtenir ce qui suit pour un utilisateur particulier:
Get-ADPrincipalGroupMembership username
Il a jeté une erreur que je ne voulais pas résoudre.
Je suis toutefois parvenu à une solution différente en utilisant Get-ADUser. Je l'aime un peu mieux, car si vous ne connaissez pas le nom du compte, vous pouvez le créer à partir d'un caractère générique du nom réel de l'utilisateur. Il suffit de remplir PartOfUsersName et le tour est joué.
#Get the groups that list of users are the member of using a wildcard search
[string]$UserNameLike = "*PartOfUsersName*" #Use * for wildcards here
[array]$AccountNames = $(Get-ADUser -Filter {Name -like $UserNameLike}).SamAccountName
ForEach ($AccountName In $AccountNames) {
Write-Host "`nGETTING GROUPS FOR" $AccountName.ToUpper() ":"
(Get-ADUser -Identity $AccountName -Properties MemberOf|select MemberOf).MemberOf|
Get-ADGroup|select Name|sort name
}
Énormes accessoires à schmeckendeugler et 8DH pour m'avoir amené à cette solution. +1 à vous deux.
Get-QADUser -SamAccountName Identifiant de connexion | % {$ _. MemberOf} | Get-QADGroup | sélectionnez le nom
Get-ADPrincipalGroupMembership USERLOGON | sélectionnez le nom
Import-Module ActiveDirectory
Get-ADUser -SearchBase "OU=Users,DC=domain,DC=local" -Filter * | foreach-object {
write-Host "User:" $_.Name -foreground green
Get-ADPrincipalGroupMembership $_.SamAccountName | foreach-object {
write-Host "Member Of:" $_.name
}
}
Modifiez la valeur de -SearchBase afin de refléter l'unité d'organisation à partir de laquelle vous devez répertorier les utilisateurs :)
Cela listera tous les utilisateurs de cette unité d’organisation et vous montrera quels groupes ils sont membres.
Mettre cela ici pour référence future. Je suis en pleine migration de courrier électronique. Je dois connaître chaque compte d'utilisateur et son appartenance à un groupe respectif, ainsi que chaque groupe et ses membres respectifs.
J'utilise le bloc de code ci-dessous pour générer un fichier CSV pour l'appartenance à un groupe d'utilisateurs.
Get-ADUser -Filter * |`
ForEach-Object { `
$FileName = $_.SamAccountName + ".csv" ; `
$FileName ; `
Get-ADPrincipalGroupMembership $_ | `
Select-Object -Property SamAccountName, name, GroupScope, GroupCategory | `
Sort-Object -Property SamAccountName | `
Export-Csv -Path $FileName -Encoding ASCII ; `
}
Le processus d’exportation pour les groupes et leurs membres respectifs était un peu compliqué, mais le processus ci-dessous fonctionne. Les noms de fichiers en sortie incluent le type de groupe. Par conséquent, les groupes de distribution de courrier électronique dont j'ai besoin sont/devraient être les groupes de distribution universel et global. Je devrais pouvoir simplement supprimer ou déplacer les fichiers TXT résultants dont je n'ai pas besoin.
Get-ADGroup -Filter * | `
Select-Object -Property Name, DistinguishedName, GroupScope, GroupCategory | `
Sort-Object -Property GroupScope, GroupCategory, Name | `
Export-Csv -Path ADGroupsNew.csv -Encoding ASCII
$MyCSV = Import-Csv -Path .\ADGroupsNew.csv -Encoding ASCII
$MyCSV | `
ForEach-Object { `
$FN = $_.GroupScope + ", " + $_.GroupCategory + ", " + $_.Name + ".txt" ; `
$FN ; `
Get-ADGroupMember -Identity $_.DistinguishedName | `
Out-File -FilePath $FN -Encoding ASCII ; $FN=""; `
}
Pour le rendre récursif, vous pouvez utiliser:
<#
.SYNOPSIS
Get all the groups that a user is MemberOf.
.DESCRIPTION
This script retrieves all the groups that a user is MemberOf in a recursive way.
.PARAMETER SamAccountName
The name of the user you want to check #>
Param (
[String]$SamAccountName = 'test',
$DomainUsersGroup = 'CN=Domain Users,CN=Users,DC=domain,DC=net'
)
Function Get-ADMemberOf {
Param (
[Parameter(ValueFromPipeline)]
[PSObject[]]$Group,
[String]$DomainUsersGroup = 'CN=Domain Users,CN=Users,DC=grouphc,DC=net'
)
Process {
foreach ($G in $Group) {
$G | Get-ADGroup | Select -ExpandProperty Name
Get-ADGroup $G -Properties MemberOf| Select-Object Memberof | ForEach-Object {
Get-ADMemberOf $_.Memberof
}
}
}
}
$Groups = Get-ADUser $SamAccountName -Properties MemberOf | Select-Object -ExpandProperty MemberOf
$Groups += $DomainUsersGroup
$Groups | Get-ADMemberOf | Select -Unique | Sort-Object
Si vous ne pouvez pas utiliser Get-ADPrincipalGroupMembership, vous pouvez essayer de vous connecter en tant qu'utilisateur puis de l'utiliser.
$id = [Security.Principal.WindowsIdentity]::GetCurrent()
$groups = $id.Groups | foreach-object {$_.Translate([Security.Principal.NTAccount])}
$groups | select *
L'étude de tous les commentaires présentés m'a fourni un point de départ (merci pour cela) mais m'a laissé avec plusieurs problèmes non résolus. Comme résultat, voici ma réponse. L'extrait de code fourni fait un peu plus que ce qui est demandé, mais il fournit des informations de débogage utiles.
[array] $script:groupsdns = @()
function Get-ADPrincipalGroupMembershipRecursive()
{
Param( [string] $dn, [int] $level = 0, [array] $groups = @() )
#if(($groupsdns | where { $_.DistinguishedName -eq $dn }).Count -ne 0 ) { return $groups } # dependency on next statement
#$groupsdns += (Get-ADObject $dn -Properties MemberOf) # Get-ADObject cannot find an object with identity
if ($script:groupsdns.Contains($dn)) { return $groups }
$script:groupsdns += $dn
$mo = $Null
$mo = Get-ADObject $dn -Properties MemberOf # Get-ADObject cannot find an object with identity
$group = ($dn + " (" + $level.ToString())
if ($mo -eq $Null) { $group += "!" }
$group += ")"
$groups += $group
foreach( $groupdn in $mo.MemberOf )
{
$groups = Get-ADPrincipalGroupMembershipRecursive -dn $groupdn -level ($level+1) -groups $groups
}
if ($level -le 0)
{
$primarygroupdn = (Get-ADUser -Identity $dn -Properties PrimaryGroup).PrimaryGroup
$groups = Get-ADPrincipalGroupMembershipRecursive -dn $primarygroupdn -level ($level+1) -groups $groups
}
return $groups
}
$adusergroups = Get-ADPrincipalGroupMembershipRecursive -dn $aduser.DistinguishedName
$adusergroups | ft -AutoSize | `
Out-File -Width 512 Get-ADPrincipalGroupMembershipRecursive.txt #-Append #-Wrap # | Sort-Object -Property Name
Avec une entrée utilisateur et un formatage de sortie sophistiqué:
[CmdletBinding(SupportsShouldProcess=$True)]
Param(
[Parameter(Mandatory = $True)]
[String]$UserName
)
Import-Module ActiveDirectory
If ($UserName) {
$UserName = $UserName.ToUpper().Trim()
$Res = (Get-ADPrincipalGroupMembership $UserName | Measure-Object).Count
If ($Res -GT 0) {
Write-Output "`n"
Write-Output "$UserName AD Group Membership:"
Write-Output "==========================================================="
Get-ADPrincipalGroupMembership $UserName | Select-Object -Property Name, GroupScope, GroupCategory | Sort-Object -Property Name | FT -A
}
}
Bien qu'il y ait beaucoup d'excellentes réponses ici, il y en a une que je cherchais personnellement et qui manquait. Une fois que je l'ai compris - j'ai pensé que je devrais le poster au cas où je voudrais le trouver plus tard, ou qu'il parvienne à aider quelqu'un d'autre à un moment donné:
Get-ADPrincipalGroupMembership username | Format-Table -auto
Une deuxième approche consiste à spécifier les colonnes individuelles qui vous intéressent, par exemple:
Get-ADPrincipalGroupMembership username | select name, GroupScope, GroupCategory
Cela donne à tous les groupes AD auxquels appartient le nom d'utilisateur - mais présente également toutes les propriétés par défaut de chaque groupe correctement formatées sous forme de tableau.
L'avantage clé que cela vous donne est que vous pouvez voir en un coup d'œil quelles sont les listes de distribution et quels sont les groupes de sécurité. Vous pouvez voir en un coup d'œil quels sont les universels, ceux de DomainLocal et ceux de Global.
Pourquoi vous soucier de ce dernier morceau?
- Le groupe universel est un groupe de sécurité ou de distribution qui contient les utilisateurs, les groupes et les ordinateurs Appartenant à n'importe quel domaine de sa forêt en tant que membres Vous pouvez attribuer des droits et des autorisations Aux groupes de sécurité universels sur les ressources de n'importe quel domaine de la forêt.
- Le groupe global est un groupe qui peut être utilisé dans son propre domaine, dans les serveurs membres , Dans les postes de travail du domaine et dans les domaines de confiance Dans tous ces emplacements, vous pouvez attribuer à un groupe global les droits et permissions et le groupe global peuvent devenir membres de groupes locaux . Cependant, un groupe global peut contenir des comptes d'utilisateurs qui ne proviennent que de de son propre domaine.
- Le groupe local de domaine est un groupe de sécurité ou de distribution pouvant contenir, à partir de son propre domaine, des groupes universels, des groupes globaux, d'autres groupes locaux de domaine et des comptes à partir de n'importe quel domaine de la forêt. Vous Pouvez donner aux groupes de sécurité locaux du domaine des droits et des autorisations sur les ressources Qui résident uniquement dans le même domaine que le domaine localgroup.
C’est le moyen le plus simple d’obtenir les noms:
Get-ADPrincipalGroupMembership "YourUserName"
# Returns
distinguishedName : CN=users,OU=test,DC=SomeWhere
GroupCategory : Security
GroupScope : Global
name : testGroup
objectClass : group
objectGUID : 2130ed49-24c4-4a17-88e6-dd4477d15a4c
SamAccountName : testGroup
SID : S-1-5-21-2114067515-1964795913-1973001494-71628
Ajoutez une instruction select pour ajuster la réponse ou pour obtenir chaque utilisateur d'une unité d'organisation, chaque groupe dont ils sont l'utilisateur:
foreach ($user in (get-aduser -SearchScope Subtree -SearchBase $oupath -filter * -Properties samaccountName, MemberOf | select samaccountName)){
Get-ADPrincipalGroupMembership $user.samaccountName | select name}
Si vous n'avez pas le droit de consulter d'autres groupes membres mais que vous avez le droit de consulter les membres du groupe, vous pouvez procéder comme suit pour créer une carte indiquant quel utilisateur a accès à quels groupes.
$groups = get-adgroup -Filter * | sort name | select Name
$users = @{}
foreach($group in $groups) {
$groupUsers = @()
$groupUsers = Get-ADGroupMember -Identity $group.Name | Select-Object SamAccountName
$groupUsers | % {
if(!$users.ContainsKey($_.SamAccountName)){
$users[$_.SamAccountName] = @()
}
($users[$_.SamAccountName]) += ($group.Name)
}
}
Get-ADUser -Filter { memberOf -RecursiveMatch "CN=Administrators,CN=Builtin,DC=Fabrikam,DC=com" } -SearchBase "CN=Administrator,CN=Users,DC=Fabrikam,DC=com" -SearchScope Base
## NOTE: The above command will return the user object (Administrator in this case) if it finds a match recursively in memberOf attribute.