रेक्टल टॉन्सिलटेक्टोमी: एडी के साथ पॉवर्सशेल में एडी cmdlets के बिना काम करना

Windows Server 2008 ने पहले ActiveDirectory के साथ काम करने के लिए उल्लेखनीय PowerShell cmdlets की शुरुआत की। इन सुंदर, तार्किक, सहज और अत्यंत शक्तिशाली साधनों ने मुझे दुखी कर दिया, अगर "कष्टप्रद" नहीं कहना है: वे मेरे लिए दुर्गम थे, गैर-मुख्य कार्यालय के enekeyschik। मेरे द्वारा सेवा किए गए सभी ग्यारह नेटवर्क विंडोज 2003 R2 पर बनाए गए थे।

ग्यारह सुदूर पूर्व में बिखरे विभिन्न शहरों में ग्यारह असंबद्ध नेटवर्क में ग्यारह असंबंधित डोमेन। और उनमें से किसी के पास यह तथ्य नहीं है कि "सेवेंस", यहां तक ​​कि "व्हिस" भी मौजूद नहीं हैं, जो दो हजार और तीन के साथ संयोजन के रूप में AD cmdlets का उपयोग करने के प्रयासों को समाप्त करता है।


कार्य निम्नानुसार तैयार किया गया था - "कोड बनाएँ जो Windows XP / 2003 पर चलने वाले PowerShell स्क्रिप्ट से बुनियादी AD प्रबंधन संचालन कर सकता है।" इसे कैसे हल किया गया, इसके बारे में पढ़ें, हैब्रैट के तहत पढ़ें ( ध्यान से, बैसाखी; बहुत अधिक पाठ और कोड )।

प्रसंग

हाल ही में, सुस्त, सामान्य रूप से, सिस्टम प्रशासकों और अन्य आईटी प्रबंधकों की असामान्य गतिविधि की अवधि तक एनाइकाइसिक का काम कुछ जटिल था: उन्होंने सर्वर सेवाओं, उपयोगकर्ता कार्यस्थानों और अन्य आईटी उद्यमों की सेटिंग्स में बहुत सारे बदलाव करने का फैसला किया। स्वाभाविक रूप से, enikeyshchikov के हाथों से, टी.के. उनके पास Altiris या MS SCCM जैसे सामान्य उपकरण नहीं थे।

कुछ बिंदु पर, मुझे एहसास हुआ कि मुझे शारीरिक रूप से मेरे द्वारा सौंपे गए नेटवर्क में उनके सरल विचारों को महसूस करने का समय नहीं था, और स्वचालन के बारे में सोचा। कार्य समय के विश्लेषण से पता चला कि, सबसे पहले, एडी में परिवर्तनों की प्रतिकृति की प्रक्रिया में तेजी लाने के लिए आवश्यक है। इसके लिए, यह मुझे तब लगा, जब एक्टिव डायरेक्टरी कोमंडलेट्स की आवश्यकता थी (काम के लिए जिसके लिए विंडोज 7 के लिए कम से कम एक लाइसेंस खरीदना आवश्यक था)।

व्यापार जगत के नेता और सिस्टम प्रशासक अनुभवहीन थे: “यदि पुराने ठीक काम करते हैं तो हमें नई प्रणाली की आवश्यकता क्यों है? आह, यह महान काम नहीं करता है? लेकिन वहाँ सब कुछ अद्भुत बनाने के लिए है! अन्यथा, आपको इतना भुगतान क्यों किया जाता है? हां, वैसे, अगर आपको वास्तव में एक नई प्रणाली की आवश्यकता है, तो इसे अपने स्वयं के पैसे से खरीदें और इसका उपयोग करें! और सामान्य तौर पर, यदि वह प्रस्तावित उपकरणों के ढांचे के भीतर व्यावसायिक समस्याओं को हल करने में सक्षम नहीं है, तो वह कंपनी से बाहर चला गया है! ”

"ठीक है," मैंने जवाब दिया: "मैं बाहर नहीं गया" बहुत बहुत। अंत में, प्रबंधन के "विशलिस्ट" के कार्यान्वयन में एनाइकसिक्क और रियल एस्टेट प्रशासक के बीच महत्वपूर्ण अंतर है। यह स्पष्ट हो गया कि एक बार फिर "सरलता लागू करना" और "बाहर निकलना" आवश्यक होगा। PowerShell को "ersatz-प्रबंधन AD " प्रणाली के निर्माण के लिए मंच के रूप में चुना गया था (मुख्यतः .NET और COM के साथ काम करने में आसानी के लिए)।

कोड

एक अद्वितीय इकाई नाम प्राप्त करना

यदि आपने ActiveDirectory के साथ काम किया है या एक अलग LDAP कार्यान्वयन से परिचित हैं, तो आप जानते हैं कि विभिन्न प्रकार के मामलों में व्यापक रूप से किस प्रकार उपयोग किया जाता है वे विशिष्ट (विशिष्ट) नाम हैं - DNs ( विशिष्ट नाम )।

विशिष्ट LDAP नाम में कई रिश्तेदार अद्वितीय नाम होते हैं - RDNs ( सापेक्ष विशिष्ट नाम ), जो "गुण = मान" जोड़े हैं। संगठन इकाई के लिए एक अद्वितीय नाम का एक उदाहरण:

ou=Managers 

एक ही इकाई के लिए एक अद्वितीय नाम का एक उदाहरण:

 ou=Managers,DC=example,dc=com 

यह प्रविष्टि इंगित करती है कि "example.com" नाम के AD डोमेन में पहले स्तर पर एक "प्रबंधक" इकाई है।

अपने स्वयं के अनुभव से मैं कह सकता हूं कि अद्वितीय LDAP नाम सहज नहीं हैं और शुरुआत के लिए कुछ कठिनाइयों का कारण बनते हैं। इसलिए, मुझे एक साधारण फ़ंक्शन लिखना आवश्यक लगा, जो फ़ॉर्म का सहज प्रतिनिधित्व "उदाहरण.com/Managers/Accounting/" को DN अंकन में परिवर्तित करता है:

 <# .SYNOPSIS    OU   "example.com/123/456",   Distinguished Name. .Description       ,       . :      DNS-,   NEIBIOS  (.. example.com,   EXAMPLE) .PARAMETER Path ,     DN .OUTPUTS System.String.  Distinguished Name,   . #> Function Convert-ADPath2DN([STRING]$Path) { $Res = "" $ResOU = $null #   OU  OU DN $P = Join-Path $Path "/" $P = $P.Replace("\","/") #,     -    if ($P -match "^(?<DNS_DOMAIN_NAME>(\w+\.\w+)+)\/.+$") { $i = 0 $DNS_DOMAIN_NAME = $Matches.DNS_DOMAIN_NAME #   OU While (-not ($P -eq $DNS_DOMAIN_NAME)) { $i++ $OU = Split-Path -Leaf $P $P = Split-Path -Parent $P If ($i -ne 1) { $ResOU = $ResOU + "," } $ResOU = $ResOU+ "OU=$OU" } } else { $DNS_DOMAIN_NAME = [System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain().Name } #   ,           $DNS_DOMAIN_NAME = $DNS_DOMAIN_NAME.Replace(".","\") $DC_NAMES = @() While ($DNS_DOMAIN_NAME -ne "") { $DC = Split-Path -Leaf $DNS_DOMAIN_NAME $DNS_DOMAIN_NAME = Split-Path -parent $DNS_DOMAIN_NAME $DC_NAMES = $DC_NAMES + $DC } $Count = $DC_NAMES.Count for ($i=$Count;$i -gt 0;$i--) { $DC = $DC_NAMES[$i - 1] If ($i -ne $Count) { $ResDC = $ResDC + "," } $ResDC = $ResDC+ "DC=$DC" if ($ResOU -ne $null) { $Res = $ResOU + "," + $ResDC } else { $Res = $ResDC } } Return $Res } 

उपयोग का उदाहरण:

 $Var = Convert-ADPath2DN -Path "example.com/Test/" $Var OU=Test,DC=example,DC=com 

यद्यपि यह फ़ंक्शन सीधे ActiveDirectory प्रबंधन से संबंधित नहीं है, लेकिन यह बहुत उपयोगी है और अन्य कार्यों में उपयोग किया जाता है।

संगठन इकाई संगठन

प्रत्येक enikeyschik को पता होना चाहिए कि आपको विशेष रूप से उद्यम के मुख्य नेटवर्क से डिस्कनेक्ट किए गए परीक्षण डोमेन पर ActiveDirectory के लिए स्क्रिप्ट का परीक्षण करने की आवश्यकता है।

समान रूप से महत्वपूर्ण आईटी लागत को कम करने के लिए कंपनी की नीति का अनुपालन है (मुझे लगता है कि कई गैर-प्रमुख संगठनों के पास ऐसे निर्देश हैं), जिसका अर्थ है कि कोई पीसी नहीं है जो विंडोज 2003 वर्चुअल मशीन, या यहां तक ​​कि एक अलग सर्वर को खींच सकता है, जिस पर परीक्षण के वातावरण को तैनात किया जा सकता है, एक नियम के रूप में, एनाइकेशिक, उसके निपटान में नहीं है।

इसलिए, हमारे नायक, वरिष्ठ कामरेडों के सख्त आदेशों के विपरीत, अपनी उपलब्धियों का सीधे "मुकाबला" ईस्वी में परीक्षण करते हैं। हम इसके लिए उसे दोषी नहीं ठहराएंगे, बल्कि मदद करने की कोशिश करेंगे।

पहली चीज जो उसे करनी चाहिए वह एक अलग संगठन इकाई का निर्माण करना है, जिसके भीतर पटकथा लेखन कौशल का और विकास होगा। खैर, और चूंकि विषय का विषय पॉवर्सहेल प्रोग्रामिंग से संबंधित है, इसलिए हम इस पर संबंधित फ़ंक्शन को लागू करते हैं।

ऐसा करने के लिए, हमें System.DirectoryServices.DirectoryEntry वर्ग के निर्माता का उपयोग करना होगा । अंतिम संस्करण, उदाहरण के लिए, इस तरह दिख सकता है:

 <# .SYNOPSIS     AD      . .Description       ,    .   - .       New-ADOrganizationUnit .PARAMETER Path    AD,     OU (.. ). .PARAMETER Name    (Organization Unit). .OUTPUTS $null.    . #> Function New-ADOrganizationUnit_simple([STRING]$Path,[STRING]$Name) { #   , ..     . #  -   OU,   . $ErrorActionPreference = "SilentlyContinue" #    DN (.   ) $OUDN = Convert-ADPath2DN -Path $Path #    ADsPath $OUDN = "LDAP://$OUDN" # ,    $objDomain = [ADSI]$OUDN #  $objOU = $objDomain.Create("organizationalUnit", "ou=$Name") $objOU.SetInfo() #  Trap { #   ,     ,    . if ($_.Exception.ErrorCode -eq $SYSTEM_ERROR_CODE_OU_ALREADY_EXISTS) { Write-Host "OU $Name  $Path  " } } } 

इस कार्यान्वयन का एक स्पष्ट दोष पूर्ण शाखा शाखा बनाने के लिए इस फ़ंक्शन की अक्षमता है: यदि आपको एक डोमेन में OU " example.com/Users/HR/Women " बनाने की आवश्यकता है जिसमें एक शाखा नहीं है " example.com/Users ", तो आप उपयोग नहीं कर सकते हैं उसे इस समस्या को हल करने के लिए।

अधिक सटीक, आप कर सकते हैं, लेकिन यह अत्यंत असुविधाजनक होगा, क्योंकि आपको पहले “यूजर्स”, फिर “एचआर” और उसके बाद केवल “महिला” बनाना होगा।

ऐसा परिदृश्य स्पष्ट रूप से नियमित स्वचालन के सिद्धांत का खंडन करता है, और इसलिए अस्वीकार्य है। इसके बजाय, एक फ़ंक्शन का उपयोग करना बहुत बेहतर है जो पूरी शाखा को स्वचालित रूप से बनाएगा, उदाहरण के लिए, यह:

 <# .SYNOPSIS     AD   . .Description      ,      (  ). .PARAMETER Path    . .OUTPUTS $null.    . #> Function New-ADOrganizationUnit ([STRING]$Path) { #,        (example.com/Unit1/Unit2...) If ($Path -match "^(?<DNS_DOMAIN_NAME>(\w+\.\w+)+)\/.+$") { $i = 0 #  ,    "*-Path" $Pth = Join-Path $Path "/" $Pth = $Pth.Replace("\","/") $OUs = @() # OU   While ($Pth -ne "") { $i++ $Pos = $Pth.IndexOf("/") If ($i -eq 1) { $DNS_DOMAIN_NAME = $Pth.Substring(0,$Pos) } else { $OU = $Pth.Substring(0,$Pos) $OUs = $OUs + $OU } $Pth = $Pth.Substring($Pos+1,($Pth.Length - $Pos -1)) } #   OU $Pth = $DNS_DOMAIN_NAME For ($i=0;$i -lt $OUs.Count;$i++) { $OU = $OUs[$i] #      OU. #  " ",    #     - . New-ADOrganizationUnit_simple -Name $OU -Path $Pth $Pth = $Pth + "/" + $OU } } } 

फ़ंक्शन का उपयोग करना तुच्छ है:

 #  "Test"  "MyFirstOU"   example.com New-ADOrganizationUnit -Path "example.com/Test/MyFirstOU/" | Out-Null 

सुरक्षा समूह जोड़ना

अनुभवी सिस्टम प्रशासक, गंभीर पुस्तकें पढ़ते हैं, सलाह देते हैं कि उनके Padawans किसी भी AD प्रशासन परिदृश्यों में एकल उपयोगकर्ता खातों के लिए सुरक्षा समूह पसंद करते हैं और विशेष रूप से, जब इसकी संरचना की योजना बनाते हैं (यदि, ज़ाहिर है, तो Padawans आमतौर पर इस समस्या को हल करने में भागीदारी की अनुमति देते हैं)।

तर्क आमतौर पर परिणामी निर्माणों की प्रतिकृति है: यदि, उदाहरण के लिए, आप कुछ समूह नीति को पढ़ने की अनुमति देते हैं जो निर्देशक को व्यक्तिगत रूप से (या उसके खाते को) मनमाना सॉफ्टवेयर चलाने की अनुमति देता है, तो जब किसी और को ऐसा अवसर प्रदान करना आवश्यक हो जाता है, तो आपको सभी कदम उठाने होंगे। दूसरे महत्वपूर्ण अंकल के लिए एक्सेस अधिकारों की सेटिंग को दोहराएं।

यदि आप एक समूह बनाते हैं, उदाहरण के लिए, " gAllowRunAnything " और इस समूह के सदस्यों को मनमानी निष्पादन योग्य फ़ाइलों को चलाने की अनुमति दें, तो प्रक्रिया बहुत सरल हो जाएगी: यह इस समूह में दूसरे कर्मचारी के खाते को शामिल करने के लिए पर्याप्त होगा। जाहिर है, यह विकल्प enikeyschik के लिए बहुत सरल है (जिन्हें इन जोड़तोड़ों को निष्पादित करना होगा) और सिस्टम प्रशासक के लिए अधिक पारदर्शी (जिन्हें बाद में पता लगाने की आवश्यकता होगी कि enikeyshiker ने वहां क्या किया है)।

हम समूहों के महत्व के बारे में वरिष्ठ सहयोगियों के साथ बहस नहीं करेंगे, लेकिन बस उन्हें पॉवरशेल फ़ंक्शन के रूप में बनाने की संभावना का एहसास करें:

 <# .SYNOPSIS   AD   OU. .Description         (Organization Unit). .PARAMETER Path    ,     . .PARAMETER Name    .PARAMETER Force   .   ,    OU   . .OUTPUTS $null.     . #> Function New-ADGroup([STRING]$Path, [STRING]$Name, [System.Management.Automation.SwitchParameter]$Force) { # ,     $ErrorActionPreference = "SilentlyContinue" If ($Force -eq $true) { New-ADOrganizationUnit -Path $Path } #      DN $OUDN = Convert-ADPath2DN -Path $Path #  -   $OUDN = "LDAP://$OUDN" $OU = [ADSI]"$OUDN" #       $Group = $OU.Create("group", "cn=$Name") $Group.Put("sAMAccountName", "$Name") $Group.SetInfo() #  Trap { #   ,   : # "   " if ($_.Exception.ErrorCode -eq $SYSTEM_ERROR_CODE_OU_ALREADY_EXISTS) { Write-Host " $Name  $Path  " } } } 

जैसा कि आप देख सकते हैं, System.DirectoryServices.DirectoryEntry वर्ग के निर्माता का एक संस्करण भी यहाँ उपयोग किया जाता है।

और फिर से, फ़ंक्शन का उपयोग करना प्राथमिक है (मैंने विशेष रूप से वाक्यविन्यास को सरल बनाने की कोशिश की ताकि मेरे सहकर्मी, समान enikeyshchiki जिन्हें AD / LDAP के संगठन और प्रशासन के क्षेत्र में विशेष ज्ञान नहीं है, वे जल्दी से इसका पता लगा सकते हैं:

 #  "gSales"   "Unit1".   -       . New-ADGroup -Path "example.com/Test/MySuperScriptingResults/Fatal/Unit1" -Name "gSales" -Force 

समूह नीति ऑब्जेक्ट बनाना और लिंक करना

ActiveDirectory क्या है ? विकिपीडिया का कहना है कि यह एमएस से एलडीएपी-अनुपालन निर्देशिका सेवा कार्यान्वयन है। सिस्टम व्यवस्थापक संभवतः जंगलों, डोमेन और ट्रस्टों को याद रखेगा, सुरक्षा गार्ड प्रमाणीकरण तंत्र को याद रखेगा, और eneykeyschik समूह नीतियों के बारे में बात करेगा।

उनके बारे में क्यों? उनके पास enikeyschik का पूरा पेशेवर जीवन है: कार्यस्थानों पर सॉफ़्टवेयर स्थापित करना , IE सेटिंग्स लॉक करना , उपयोगकर्ताओं को विभिन्न "* -बार" स्थापित करने की अनुमति नहीं देता, SRPs , काम के घंटों के दौरान गेम के साथ समस्या को हल करना, और यहां तक कि टास्कबार को लॉक करना , जिसे मारिवाना को बाईं ओर स्थानांतरित करना पसंद है। यह मांग करते हुए कि एनीकेसिक तुरंत "जैसा था वैसा ही लौटें, अन्यथा काम करना असंभव है।" हालाँकि, मैं यादों में बहुत गहराई तक गया। मुझे लगता है कि कोई भी विंडोज नेटवर्क में जीपीओ के महत्व के बारे में थीसिस के साथ बहस नहीं करेगा।

और जब से जीपीओ की आवश्यकता और महत्वपूर्ण है, तो आपको उनके साथ काम करने के लिए कुछ तंत्रों को शामिल करना चाहिए, जो पुस्तकालय बनाए जा रहे हैं। आपको पहले GPO के साथ क्या करने की आवश्यकता है? बेशक, इसे बनाएं (जाहिर है, कोई भी ऑपरेशन निर्माण से पहले नहीं हो सकता):

 <# .SYNOPSIS        . .Description        .    COM- GPMC (, GPMC   ). .PARAMETER DomainDNSName FQDN- ,       . .PARAMETER GPOName     . .OUTPUTS GPMGPO.     . #> Function New-GPO([STRING]$DomainDNSName,[STRING]$GPOName) { $GPM = New-Object -ComObject GPMgmt.GPM #   $GPMConstants = $GPM.GetConstants() #  $GPMDomain = $GPM.GetDomain($DNS_DOMAIN_NAME, $DNS_DOMAIN_NAME, $Constants.UseAnyDC) # GPO $GPMGPO = $GPMDomain.CreateGPO() $GPMGPO.DisplayName = $GPOName Return $GPMGPO } 

यह फ़ंक्शन ऑब्जेक्ट रिपॉजिटरी में GPO बनाता है, और अधिक कुछ नहीं। यह उपयोगी है, लेकिन व्यावहारिक उपयोग के लिए यह पर्याप्त नहीं है: बनाई गई वस्तु को अभी भी यूनिट से लिंक ( लिंक ) करने की आवश्यकता है। इसके बिना, यह ऐसा रहेगा जैसे "निष्क्रिय" (सख्ती से बोलना, यह सक्रिय है, प्रभाव का क्षेत्र बस इसके लिए परिभाषित नहीं है)। और OU को एक नीति संलग्न करने के लिए, आपको इसकी वस्तु प्रतिनिधित्व प्राप्त करने की आवश्यकता है। उदाहरण के लिए, GPO के नाम को जानते हुए, इसे प्राप्त करने का प्रयास करना तर्कसंगत है:

 <# .SYNOPSIS  COM-  GPO   . .Description       GPO,   . .PARAMETER DomainDNSName FQDN- ,     GPO. .PARAMETER GPOName  GPO,   . .OUTPUTS GPMGPO.    COM-  GPO (  $null,  GPO   ). #> Function Get-GPO([STRING]$DomainDNSName,[STRING]$GPOName) { $GPMGPO = $null #     $ErrorActionPreference = "SilentlyContinue" # ,  GPMC $GPM = New-Object -ComObject GPMgmt.GPM #   $GPMConstants = $GPM.GetConstants() #  GPMDomain,    $GPMDomain = $GPM.GetDomain($DomainDNSNAme, $DomainDNSNAme, $GPMConstants.UseAnyDC) #        $GPMGPO = $GPMDomain.SearchGPOs($GPM.CreateSearchCriteria()) | Where-Object{$_.DisplayName -eq $GPOName} #  GPO.     -  $null. Return $GPMGPO } 

शस्त्रागार में एक GPO नाम के लिए खोज करने के लिए एक तंत्र होने के बाद, आप बांधने की कोशिश कर सकते हैं:

 <# .SYNOPSIS   (Link)        (OU). .Description    GPO        . -   . .PARAMETER DomainDNSName FQDN- ,     . .PARAMETER GPOName    GPO.           . .PARAMETER OUPath    ,       GPO. .OUTPUTS $Null.     . #> Function Mount-GPOToOU ([STRING]$GPOName,[STRING]$OUPath,[STRING]$DomainDNSName) { #   GPO    $GPMGPO = Get-GPO -DomainDNSName $DomainDNSName -GPOName $GPOName #  ,    If ($GPMGPO -ne $Null) { #    DN $OUDN = Convert-ADPath2DN -Path $OUPath #     COM- GPMC $GPM = New-Object -ComObject GPMgmt.GPM $GPMConstants = $GPM.GetConstants() $GPMDomain = $GPM.GetDomain($DomainDNSName, $DomainDNSName, $Constants.UseAnyDC) #    $GPMSOM = $GPMDomain.GetSOM($OUDN) #  (Link)  GPO   $GPMSOM.CreateGPOLink(-1, $GPMGPO) | Out-Null trap { #   COM-.       . # ,    ,     .   continue } } #  GPO     ,      else { Write-Host "Cannot find a GPO object named $GPOName" Throw "Cannot_find_GPO" } } 

अंतिम फ़ंक्शन आपको न केवल नए सिरे से निर्मित, बल्कि रिपॉजिटरी में किसी भी जीपीओ को बांधने की अनुमति देता है। इस फ़ंक्शन के अनुप्रयोगों में से एक था, पहले से तैयार "उत्पादन में पेश करना" समूह नीति ऑब्जेक्ट्स: पहले उन्हें एक विशेष अलग इकाई (OU) में परीक्षण किया गया था, और फिर अचानक रात में परीक्षण और सिस्टम व्यवस्थापक से अनुमोदन प्राप्त करने के बाद, उन्होंने "मुकाबला" इकाइयों से संपर्क किया। यह सहज था।

एक सावधानीपूर्वक पाठक पूछ सकता है कि GPMC COM ऑब्जेक्ट का उपयोग किस लिए किया जाता है। यह बहुत सरल है: .NET बहुत अधिक स्तर प्रदान करता है और आपको कुछ ऑपरेशन करने की अनुमति नहीं देता है। उदाहरण के लिए, मुझे GPO को संगठनात्मक इकाई में बाँधने का कोई तरीका नहीं मिला, मैं System.DirectoryServices.DirectoryEntry का उपयोग करके GPO को आयात और निर्यात नहीं कर सकता (नीचे देखें)। GPMC का उपयोग करते हुए, इन चरणों का प्रदर्शन न केवल संभव है , बल्कि अपेक्षाकृत सरल भी है ।

GPO सेटिंग्स आयात और निर्यात करें

इसलिए, हमारे पास समूह नीति ऑब्जेक्ट और इकाइयों के लिए उनके बंधन बनाने का अवसर है। आइए लक्ष्यों को याद करें - हम इन सभी कार्यों को भी क्यों विकसित करते हैं? अपनी मेहनत में एनाइकसचिक की मदद करना। किस तरह की मदद की ज़रूरत है enikeyschik? नियमित संचालन के स्वचालन में जिसे उसे प्रदर्शन करना चाहिए। इनमें से कौन GPO से संबंधित हैं? एक नियम के रूप में, हम कई नेटवर्क (या एक ही डोमेन के अलग-अलग OUs) में सिस्टम व्यवस्थापक द्वारा GPO मापदंडों के लिए विकसित किए गए परिवर्तनों के बारे में बात कर रहे हैं।

आमतौर पर ऐसा होता है: सुरक्षा गार्ड यह तय करता है कि, उदाहरण के लिए, हटाने योग्य मीडिया पर जानकारी को "हटाने" पर रोक लगाने के लिए, इन का उपयोग निषिद्ध होना चाहिए। सिस्टम व्यवस्थापक संबंधित GPO सेटिंग्स (निर्देश) का विवरण तैयार करता है और अपने नेटवर्क में इन परिवर्तनों को दोहराने के लिए enikeyshchikov को निर्देश देता है।

कई परिवर्तन हो सकते हैं, और, और भी बदतर, नेटवर्क भी। नतीजतन, यह पता चल सकता है कि एनाइकसचिक पूरे दिन नकल करने में व्यस्त है, और प्रिंटर से जाम पेपर को बाहर नहीं निकाल सकता है, टॉयलेट में ऑडियो सिस्टम के लिए आवश्यक प्रदर्शनों की सूची प्रदान करें, वेब पर एकाउंटेंट की बेटी के छात्र के लिए एक निबंध ढूंढें, और, सबसे खराब, उपयोगकर्ता को दिखाएं जहां उपयोगकर्ता वही है "कोई भी कुंजी।"

और यहाँ सर्वशक्तिमान एमएस GPMC के ढांचे के भीतर कार्यान्वित जीपीओ सेटिंग्स आयात / निर्यात तंत्र के साथ एक कीबोर्ड और पेचकश के हमारे लड़ाकू की सहायता के लिए आता है। यह तंत्र आपको एक GPO में निर्दिष्ट सेटिंग्स को दूसरे में आयात करने की अनुमति देता है, भले ही ये दो GPO (दाता और प्राप्तकर्ता) अलग-अलग डोमेन में हों। खैर, पॉवर्सशेल आपको प्रक्रिया को पूर्ण स्वचालितता में लाने की अनुमति देता है।

हम सिस्टम व्यवस्थापक को संदर्भ नीति निर्यात करने के लिए प्रक्रिया छोड़ देंगे, और हम स्वयं आयात करेंगे। शुरू करने के लिए, विचार करें कि GPO बैकअप क्या है (MS स्वयं कहता है कि यह बैकअप है , निर्यात नहीं):


इस उदाहरण में फ़ोल्डर का नाम निर्यातित GPO का विशिष्ट पहचानकर्ता है। आयात करते समय हमें इसकी आवश्यकता होगी, इसलिए अब यह सीखना अच्छा होगा कि यह GUID कैसे प्राप्त करें। मैं नेटवर्क लोककथाओं के एक प्रसिद्ध चरित्र के लिए पास होने के लिए उद्यम करता हूं, लेकिन इस पहचानकर्ता को प्राप्त करने का सबसे आसान तरीका केवल फ़ोल्डर का नाम देखकर है, उदाहरण के लिए, जैसे:

 <# .SYNOPSIS   GUID   GPO   () . .Description         GPO,    ,   - GUID,       GUID'  .    ,     GPO        GUID'.     -   GUID'  . .PARAMETER Path Path -   ,      GPO. .OUTPUTS System.String. GUID   GPO,    . #> Function Get-ExportedBackupGUID([STRING]$Path) { #,    ,   -   If (-not (Test-Path $Path)) { Write-Host " $Path  " Throw "Backup dir path not found" } #   $Children = Get-ChildItem -Force -LiteralPath $Path #    ,   GUID' Foreach ($Child in $Children) { If ($Child.FullName -match "^*\{\w{8}\-(\w{4}\-){3}\w{12}\}$") { Return $Matches[0] } } # ,    GPO   . Write-Host "  $Path     " Throw "GPO Backup(s) not found" } 

निर्यात किए गए GPO के GUID ज्ञात हो जाने के बाद, आप इसकी सेटिंग्स को AD रिपॉजिटरी में एक मनमाने ढंग से GPO में लोड कर सकते हैं:

 <# .SYNOPSIS   GPO   . .Description        ,       GPO.     ,      ,       GPO.    GPO  ,   . .PARAMETER BackupPath       GPO .PARAMETER DNS_DOMAIN_NAME FQDN- ,      (). .PARAMETER MigrationTablePath  .    . .PARAMETER NewGPOName    ,        .     ,       (..     GPO    ,     GPO-). .OUTPUTS $null.    . #> Function Import-GPO ([STRING]$BackupPath, [STRING]$DNS_DOMAIN_NAME, [STRING]$MigrationTablePath, [STRING]$NewGPOName = "") { #      GPO.   ,   If (-not (Test-Path $BackupPath)) { Write-Host "     GPO: $BackupPath" Throw "GPO Backup path not found" } # COM- GPMC -   $GPM = New-Object -ComObject GPMgmt.GPM $GPMConstants = $GPM.GetConstants() $GPMDomain = $GPM.GetDomain($DNS_DOMAIN_NAME, $DNS_DOMAIN_NAME, $Constants.UseAnyDC) #  GPMBackupDir,      $GPMBackupDir = $GPM.GetBackupDir($BackupPath) # GUID  GPO $BackupGUID = Get-ExportedBackupGUID -Path $BackupPath #  -   GPO $GPMBackup = $GPMBackupDir.GetBackup($BackupGUID) # GPO,     :   ,     #  ,     If ($NewGPOName -eq "") { $TargetGPOName = $GPMBackup.GPODisplayName } else { $TargetGPOName = $NewGPOName } #    GPO,      $GPMGPO = Get-GPO -DomainDNSNAme $DNS_DOMAIN_NAME -GPOName $TargetGPOName # GPO     ,   If ($GPMGPO -eq $Null) { $GPMGPO = New-GPO -DomainDNSNAme $DNS_DOMAIN_NAME -GPOName $TargetGPOName } #  GPO $GPMGPO.Import(0, $GPMBackup) | Out-Null } 

GPO :

 ##:   "c:\good_gpo\"      ,    ,   . #:      (  ),    "example.com/TestUnits/OU1" ##: #     GPO   "Imported_good_GPO" (    ). Import-GPO -BackupPath "c:\good_gpo\" -Dns_Domain_Name "example.com" -NewGPOName "Imported_good_GPO" #     OU Mount-GPOToOU -GPOName "Imported_good_GPO" -OUPath "example.com/TestUnits/OU1" -DomainDNSName "example.com" 

GPO

, Windows AD, , , GPO, .

, OU «Users», .. () - .. () : " pAllow_Run_Any_Executable ", , , , , " pDisallow_Run_Anything_Except_HelpDesk ", , .

, GPO . , -, — . , GPO .

यानी , GPO. , , (OU) GPO, . , AD , .

( — ) , GPO . , , .

" gAllow_Run_Any_Executable ", GPO " pAllow_Run_Any_Executable " . — .

, , , GPO. , .

MSDN , GPO (, , AD) System.DirectoryServices.ExtendedRightAccessRule . : , :

 # PowerShell  ,    ACE,     $NewRule = New-Object -TypeName System.DirectoryServices.ActiveDirectoryAccessRule -ArgumentList $objTrustee, $objRihgt, $objACT 

, ArgumentList. : $objTrustee — , . , . , «, ». « sales.example.com» .

( , , ), . , : , Windows. , «» Windows «Administrator».

MS , . , , . System.Security.Principal.WellKnownSidType :

 # SID    $SID = [System.Security.Principal.WellKnownSidType]::AccountDomainAdminsSid 

Well-Known (.. ), System.Security.Principal.NTAccount :

 [STRING]$FQDN = [System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain().Name $objTrustee = New-Object -TypeName System.Security.Principal.NTAccount -ArgumentList "$FQDN", "$Trustee" 

, ( / ) . , $objRihgt ( ). " " [ sales.example.com].

, («», «», «» ..) — , System.DirectoryServices.ActiveDirectoryRights , , :

 <# .SYNOPSIS    System.DirectoryServices.ActiveDirectoryRights   . .Description     System.DirectoryServices.ActiveDirectoryRights.     . .PARAMETER StrRight     System.DirectoryServices.ActiveDirectoryRights. .OUTPUTS System.DirectoryServices.ActiveDirectoryRights  $null.    System.DirectoryServices.ActiveDirectoryRights,   ,  $null (      ) #> Function Convert-ToAccessRight([STRING]$StrRight) { $Res = $null $ErrorActionPreference = "SilentlyContinue" $Res = [System.DirectoryServices.ActiveDirectoryRights]::$StrRight $ErrorActionPreference = "Stop" Return $Res } 

( " "), $objACT — (, «» (Allow), «» (Deny)). , MSDN , System.Security.AccessControl.AccessControlType , ( ) :

 #  $objACT = [System.Security.AccessControl.AccessControlType]::Allow #  $objACT = [System.Security.AccessControl.AccessControlType]::Deny 

:

 <# :     "gForbidden_Users"   GPO "pForbidden_GPO"   "Example.com" #> #: #   ,    [STRING]$FQDN = [System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain().Name #   "gForbidden_Users",      $objTrustee = New-Object -TypeName System.Security.Principal.NTAccount -ArgumentList "$FQDN", "gForbidden_Users" #    $objActDeny = [System.Security.AccessControl.AccessControlType]::Deny #    $objRihgt = [System.DirectoryServices.ActiveDirectoryRights]::GenericRead #   "  'gForbidden_Users' ".       GPO 'gForbidden_Users' $NewRule = New-Object -TypeName System.DirectoryServices.ActiveDirectoryAccessRule -ArgumentList $objTrustee, $objRihgt, $objACT #   GPO   . $GPMGPO = Get-GPO -DomainDNSName "Example.com" -GPOName "pForbidden_GPO" #  COM-    .NET-  System.DirectoryServices.DirectoryEntry [STRING]$GPOPath = $GPMGPO.Path $objGPO = New-Object System.DirectoryServices.DirectoryEntry -ArgumentList "LDAP://$GPOPath" #         GPO #      ,      $objGPO.ObjectSecurity.AddAccessRule($NewRule) | Out-Null # . $objGPO.CommitChanges() | Out-Null 

, GPO AD . : , DFS ( \\domanname.example.com\SYSVOL\ ). , GPO. , , GPMC :


, , : GPO, . , , , SYSVOL, . , GPMC GPO. GPMC, () :

 #FQDN-  $DomainDNSName = "Example.com" #  GPO,       $GPOName = "pForbidden_GPO" #   GPO    $GPMGPO = Get-GPO -DomainDNSName $DomainDNSName -GPOName $GPOName #  $GPOSecurityInfo = $GPMGPO.GetSecurityInfo() #   ,    . # GPMC         SYSVOL. $GPMGPO.SetSecurityInfo($GPOSecurityInfo) | Out-Null 

निष्कर्ष

«» , ( ) AD — , . , , .

— , AD . , « », XML- ( , , , ..).

. , , CM_ActiveDirectory , PasteBin. , , CM_System , ( ) .

, . , 2012 , , , . , — ! , «» .

, !