none
Script zum Ordner & Gruppen anlegen und die Gruppen auf Ordner legen RRS feed

  • Frage

  • Hallo,

    das Ordner und Gruppen anlegen funktioniert aber er legt die Gruppen nicht auf den jeweiligen Ordner.

    Was ist falsch und übersehe ich?

    Schon mal Danke für jeden Tip :)

    <#
    .Synopsis
    Script zum Anlegen von mehreren Ordnern und Gruppen aus der Liste .\Text.txt .
    
    .Description
    Was ist zu machen?
    1. Die Text.txt in dem Ordner mit dem Modul ablegen.
    2. "Import-Module New-GroupsFolder" im PowerShell ausführen
    3. Example 1 ausführen und die Eingaben zu den Abfragen machen oder Example 2 verwenden:
    Path: "\\vFilerha11\share$\Ordner"
    Owner: "User"
    GroupBegin: "Gruppenname"
    ADPath = "OU"
    Domain = "domain"
    
    .Parameter Path
    Gib den Pfad an.
    
    .Parameter Owner
    Gib den Herr der Daten an.
    
    .Parameter GroupBegin
    Gib den an wie der Anfang der Gruppe heisen soll.
    
    .Parameter ADPath
    Gib den an wo die Gruppen abgelegt werden sollen.
    
    .Parameter Domain
    Gib die Domain an.
    
    .Example
    Get-NewGroupFolder
    
    .Example
    New-GroupsFolder -Path "\\vFilerha11\share$\Ordner" -Owner "user" -GroupBegin "Gruppenname" -ADPath "OU" -Domain "domain"
    #>
    function New-GroupsFolder {
        [CmdletBinding()]
        Param( <##
            [Parameter(Mandatory=$true,HelpMessage='Den Anfang des Pfades angeben. Bsp: \\vFilerha11\share$\Ordner')]
            [string]$Path,
            [Parameter(Mandatory=$true,HelpMessage='Benutzername des Herrn der Daten. Bsp: User')]
            [string]$Owner,
            [Parameter(Mandatory=$true,HelpMessage='Den Anfang der Gruppe vorgeben. Bsp: Gruppenname')]
            [string]$GroupBegin,
            [Parameter(Mandatory=$true,HelpMessage='Wo sollen die Gruppen abgelegt werden. Bsp: OU')]
            [string]$ADPath,
            [Parameter(Mandatory=$true,HelpMessage='Die Domain angeben. Bsp: domain')]
            [string]$Domain ##>
        )
        if (!(Get-Module ActiveDirectory)) {Import-Module ActiveDirectory}
        <## Manuell zu bearbeitende Variablen ##>
        $Path = "\\vfilerha11\share$\ordner"
        $Owner = "user"
        $GroupBegin = "gruppenname"
        $ADPath = "OU"
        $Domain = "domain"
        
        $AclFolder = ""
        $AclGroupR = ""
        $AclGroupW = ""
        $ManagedBy = Get-ADUser -Identity $Owner -server $Domain
        
        <## Ordner einlesen ##>
        $cache = Get-Content -Path "C:\Users\user\Documents\WindowsPowerShell\Modules\New-GroupsFolder\Text.txt"
        foreach ($c in $cache)
        {
            <## Ordner anlegen ##>
            $r = $c 
            $r = $r -Replace "\\",""
            $r = $r -Replace "\:",""
            $r = $r -Replace "\*",""
            $r = $r -Replace "\?",""
            $r = $r -Replace "\<",""
            $r = $r -Replace "\>",""
            $r = $r -Replace "\|",""
            $Folder = $r
            $NewFolder = $Path + "\" + $Folder
            md $NewFolder
            
            <## Gruppe anlegen ##>
            $n = $c 
            $n = $n -Replace " ","_"
            $n = $n -Replace "\(",""
            $n = $n -Replace "\)",""
            $n = $n -Replace "\.",""
            $n = $n -Replace "\/",""
            $n = $n -Replace "\&",""
            $n = $n -Replace "_",""
            $n = $n -Replace "\\",""
            $n = $n -Replace "\:",""
            $n = $n -Replace "\*",""
            $n = $n -Replace "\?",""
            $n = $n -Replace "\<",""
            $n = $n -Replace "\>",""
            $n = $n -Replace "\|",""
            $n = $n -Replace "ä","ae"
            $n = $n -Replace "ö","oe"
            $n = $n -Replace "ü","ue"
            $NameR = $GroupBegin + $n + "_R"
            $NameW = $GroupBegin + $n + "_W"
            $NameT = $GroupBegin + $n + "_T"
            if ($NameR.length -lt 65)
            {
                New-ADGroup -Name $NameR -SamAccountName $NameR -GroupCategory Security -GroupScope Global -DisplayName $NameR -Path $ADPath -Description $NewFolder -ManagedBy $ManagedBy -Server $Domain
                New-ADGroup -Name $NameW -SamAccountName $NameW -GroupCategory Security -GroupScope Global -DisplayName $NameW -Path $ADPath -Description $NewFolder -ManagedBy $ManagedBy -Server $Domain
                $AclGroupR += $NameR
                $AclGroupW += $NameW
                $AclGroupT += $NameT
                $AclFolder += $NewFolder
            } else {
                $log += $NameR + ";" + $NameW + ";" + $NameT
            }
        }
    
        for ($i=0; $i -lt $AclFolder.Count; $i++)
        {
            $FileSystemRights_R = [System.Security.AccessControl.FileSystemRights]"Read"
            $FileSystemRights_W = [System.Security.AccessControl.FileSystemRights]"Modify"
            $FileSystemRights_D = [System.Security.AccessControl.FileSystemRights]"Delete"
            $InheritanceFlags = [System.Security.AccessControl.InheritanceFlags]::ContainerInherit -bor [System.Security.AccessControl.InheritanceFlags]::ObjectInherit
            $InheritanceFlags_D = [System.Security.AccessControl.InheritanceFlags]::None
            $PropagationFlags = [System.Security.AccessControl.PropagationFlags]::InheritOnly
            $PropagationFlags_D = [System.Security.AccessControl.PropagationFlags]::NoPropagateInherit
            $AccessControlType = [System.Security.AccessControl.AccessControlType]::Allow
            $AccessControlType_D = [System.Security.AccessControl.AccessControlType]::Deny
    
            $Folder = $AclFolder[$i]
            <## Write ##>
            $SIDW = Get-ADGroup -Filter $AclGroupW[$i] | select SID
            $acl = Get-Acl $Folder
            $AccessRuleW = New-Object System.Security.AccessControl.FilesystemAccessRule ($SIDW.SID, $FileSystemRights_W, $InheritanceFlags, $PropagationFlags, $AccessControlType)
            $acl.AddAccessRule($AccessRuleW)
            Set-Acl $Folder -AclObject $acl
            
            <## Delete ##>
            $acl = Get-Acl $Folder
            $AccessRuleW = New-Object System.Security.AccessControl.FilesystemAccessRule ($SIDW.SID, $FileSystemRights_D, $InheritanceFlags_D, $PropagationFlags_D, $AccessControlType_D)
            $acl.AddAccessRule($AccessRuleW)
            Set-Acl $Folder -AclObject $acl -ea Stop
            
            <## READ ##>
            $SIDR = Get-ADGroup -Filter $AclGroupR[$i] | select SID
            $acl = Get-Acl $Folder
            $AccessRuleR = New-Object System.Security.AccessControl.FilesystemAccessRule ($SIDR.SID, $FileSystemRights_R, $InheritanceFlags_D, $PropagationFlags_D, $AccessControlType)
            $acl.AddAccessRule($AccessRuleR)
            Set-Acl $Folder -AclObject $acl -ea Stop
    
            <## T ##>
            $acl = Get-Acl $Folder
            $AccessRuleT = New-Object System.Security.AccessControl.FilesystemAccessRule ($SIDR.SID, $FileSystemRights_R, $InheritanceFlags, $PropagationFlags, $AccessControlType)
            $acl.AddAccessRule($AccessRuleT)
            Set-Acl $Folder -AclObject $acl -ea Stop
        }
        if ($log)
        {
            $LogDate = Get-Date -Format "yyyy.MM.dd_HH.mm"
            $LogFile = "E:\user\WindowsPowerShell\logs\" + $LogDate + ".csv"
            $log|Export-Csv -encoding UNICODE -Path $LogFile -force
        }
    }


    Freitag, 25. August 2017 06:35

Antworten

  •              $AclGroupR += $NameR

    Bin zwar erst nen Tag wieder aus dem Urlaub da, aber wenn ich das richtig lese, erzeugst Du hier kein Array, sondern einen laaaaangen String. Könntest ja mal Write-Verbose nutzen :-)

             $SIDR = Get-ADGroup -Filter $AclGroupR[$i] | select SID

    Und well $AclGroupR ein laaanger String ist, dann ist $SIDR jetzt schlicht "nichts".

             $AccessRuleR = New-Object System.Security.AccessControl.FilesystemAccessRule ($SIDR.SID, $FileSystemRights_R, $InheritanceFlags_D, $PropagationFlags_D, $AccessControlType)

    Das ist dann auch "nichts".

             Set-Acl $Folder -AclObject $acl -ea Stop

    Und das schreibt genau die ACL wieder rein, die vorher schon da war.

    Write-Verbose ist Dein Freund :)

    Mittwoch, 6. September 2017 10:00

Alle Antworten

  • Hallo,

    debugging ist eine der wichtigsten Disziplinen bei der Entwicklung und funktioniert z.B. so:

    • Was ist das gewünschte Ergebnis?
    • Was ist das erzielte Ergebnis?
    • Gibt es eine Fehlermeldung? Zeilenangabe?
      - Wenn nein: Welche Teile des Codes sind an dem Ergebnis beteiligt?
    • Teile den Code (im Kopf) in zwei Teile:
      - Vorbereitender Teil: also oben z.B. Lesen von Dateien, Füllen von Variablen, Zusammenbauen von Strings, Schleifen etc..
      - Ausführender Teil: oben z.B. anlegen der Ordner, schreiben der ACLs etc.
    • Prüfe zuerst den (meist kürzeren) ausführenden Teil:
      - Funktionieren die ausführenden Befehle so wie sie dastehen, mit direkt manuell zugewiesenen Werten?
        (prüfe den Code genau so wie er im Script steht, keine "ähnlichen" Befehle auf der Console testen. Es
         geht hier auch um genaue Syntax und Vertipper)
    • Ist der ausführende Teil ok, prüfe den vorbereitenden Teil
      - Verfolge deine Variablen durch dein Script, wann müssen sie welche(n) Wert(e) haben?
      - Erstelle Breakpoints und prüfe die Variablen an den entsprechenden Stellen oder füge z.b. write-debug an diesen Stellen ein um die Variablenwerte während der Ausführung zu prüfen.
    • Wenn du dabei auf unerklärliches Verhalten stösst, versuche diesen Teil zu isolieren und getrennt vom eigentlich Script zu reproduzieren

    Wenn du geduldig und sorgfältig vorgehst, wird bei diesem Prozess das Problem in 99% aller Fälle sehr schnell offensichtlich. Wenn nicht: poste das Problem hier. :)

    Viel Erfolg!

    Grüße, Denniver


    Blog: http://bytecookie.wordpress.com

    Kostenloser Powershell Code Manager v5: Link
    (u.a. Codesnippets verwalten + komplexe Scripte graphisch darstellen)

    Hilf mit und markiere hilfreiche Beiträge mit dem "Abstimmen"-Button (links) und Beiträge die eine Frage von dir beantwortet haben, als "Antwort" (unten).
    Warum das Ganze? Hier gibts die Antwort.

    Freitag, 25. August 2017 09:24
    Moderator
  • Einen konkreten Tip hätte ich allerdings bezüglich der ganzen -replace Operationen. Du kannst alle diese Zeilen zusammen in einen Ausdruck bzw. Gruppe [] packen, also z.b für die Ordner:
     
    -replace '[/\\*?"<>|]',""
     

     

    Blog: http://bytecookie.wordpress.com

    Kostenloser Powershell Code Manager v5: Link
    (u.a. Codesnippets verwalten + komplexe Scripte graphisch darstellen)

    Hilf mit und markiere hilfreiche Beiträge mit dem "Abstimmen"-Button (links) und Beiträge die eine Frage von dir beantwortet haben, als "Antwort" (unten).
    Warum das Ganze? Hier gibts die Antwort.

    Freitag, 25. August 2017 10:56
    Moderator
  • Danke

    Jetzt müsste ich nur noch wissen ob ich noch irgend wo in der for Schleife einen Fehler habe.

    Montag, 28. August 2017 10:42
  • Bist du denn mal so vorgegangen wie oben beschrieben?

    Blog: http://bytecookie.wordpress.com

    Kostenloser Powershell Code Manager v5: Link
    (u.a. Codesnippets verwalten + komplexe Scripte graphisch darstellen)

    Hilf mit und markiere hilfreiche Beiträge mit dem "Abstimmen"-Button (links) und Beiträge die eine Frage von dir beantwortet haben, als "Antwort" (unten).
    Warum das Ganze? Hier gibts die Antwort.

    Dienstag, 29. August 2017 08:38
    Moderator
  • Es kommt keine Fehlermeldung und habe es auch einzeln getestet.

    Ordner und Gruppen legt er an aber die Berechtigungen legt er nicht drauf und es kommt auch keine Fehlermeldung.

    Mittwoch, 30. August 2017 06:09
  • Hallo BarchieLpz,

    vermutlich habe ich das gleiche Problem wie du.

    In einem Script lege ich Ordner auf einem Fileserver an, davon abhängig werden AD-Gruppen erstellt. Dann wird die Gruppe auf den Ordner entsprechend berechtigt. Ich erhalte dabei allerdings eine Fehlermeldung, zwar nur sporadisch, aber ich bekomme eine Fehlermeldung. Habe gerade kein Beispiel dafür, aber der set-acl Befehl meckert dann bei mir.

    Das Problem konnte ich so gut wie es geht beseitigen, indem ich den Logonserver des Fileservers, auf dem der Ordner erstellt wird, auslese und die AD-Gruppe auf genau diesem DC erstelle. 
    Mein Hintergedanke dabei: Fileserver fragt seinen Logonserver nach der AD-Gruppe, im worst-case kennt dieser diese Gruppe aufgrund der Replizierungsdauer aber noch nicht, da der Client, wo das Script läuft, einen anderen DC beauftragt hat, die Gruppe anzulegen.
    Dazu packe ich noch einen Timeout von 5 Sekunden, um sicher zu gehen.

    Seitdem funktioniert das Script ordnungsgemäß in etwa 90/100 Fällen. Für die restlichen Cases habe ich eine Überprüfung eingebaut, ob die Gruppe auch wirklich berechtigt wurde. Falls dem nicht so ist, kommt eine Meldung und das Script wartet nochmal ein paar Sekunden (Endlosschleife mit Abbruchmöglichkeit).

    Kannst Du ja auch mal ausprobieren, hier der Code, um den LogonServer auszulesen:

    $LogonServer = (Get-WmiObject -Class Win32_ntdomain -Filter "DomainName = 'XXX'" -ComputerName $Server).DomainControllerName.Replace("\\","")

    Beim New-Adgroup dann einfach den Parameter "-Server" mitgeben.

    MfG, Jannik

    Mittwoch, 30. August 2017 06:38
  • Hallo,

    ich warte auf Grund der Informationen der folgenden Seite 15 Sekunden nach dem anlegen der Gruppe, bevor ich sie verwende und habe seit dem keine Probleme mehr mit Gruppen die angeblich noch nicht vorhanden sind. :-)

    Click

    Beste Gruesse
    brima

    Mittwoch, 30. August 2017 07:51
  • Das warten hat bei mir auch nichts gebracht.
    Dienstag, 5. September 2017 05:34
  •              $AclGroupR += $NameR

    Bin zwar erst nen Tag wieder aus dem Urlaub da, aber wenn ich das richtig lese, erzeugst Du hier kein Array, sondern einen laaaaangen String. Könntest ja mal Write-Verbose nutzen :-)

             $SIDR = Get-ADGroup -Filter $AclGroupR[$i] | select SID

    Und well $AclGroupR ein laaanger String ist, dann ist $SIDR jetzt schlicht "nichts".

             $AccessRuleR = New-Object System.Security.AccessControl.FilesystemAccessRule ($SIDR.SID, $FileSystemRights_R, $InheritanceFlags_D, $PropagationFlags_D, $AccessControlType)

    Das ist dann auch "nichts".

             Set-Acl $Folder -AclObject $acl -ea Stop

    Und das schreibt genau die ACL wieder rein, die vorher schon da war.

    Write-Verbose ist Dein Freund :)

    Mittwoch, 6. September 2017 10:00
  • Danke das ist ein sehr guter Tipp und jetzt bin ich schon einen Schritt weiter. :)
    Montag, 11. September 2017 08:26