Controlelijst voor het ontwerpen van resourceResource authoring checklist

Deze controlelijst is een lijst met aanbevolen procedures bij het ontwerpen van een nieuwe DSC-Resource.This checklist is a list of best practices when authoring a new DSC Resource.

Resource-module bevat .psd1-bestand en schema.mof voor elke resourceResource module contains .psd1 file and schema.mof for every resource

Controleer of de bron de juiste structuur heeft en alle vereiste bestanden bevat.Check that your resource has correct structure and contains all required files. Elke resource-module een .psd1-bestand moet bevatten en elke niet-samengestelde resource schema.mof bestand moet hebben.Every resource module should contain a .psd1 file and every non-composite resource should have schema.mof file. Resources die geen schema bevatten, niet worden weergegeven door Get-DscResource en gebruikers niet mogelijk de intellisense gebruiken bij het schrijven van code op basis van deze modules in ISE.Resources that do not contain schema will not be listed by Get-DscResource and users will not be able to use the intellisense when writing code against those modules in ISE. De mapstructuur voor xRemoteFile resource, die deel uitmaakt van de xPSDesiredStateConfiguration resource module, ziet er als volgt uit:The directory structure for xRemoteFile resource, which is part of the xPSDesiredStateConfiguration resource module, looks as follows:

xPSDesiredStateConfiguration
    DSCResources
        MSFT_xRemoteFile
            MSFT_xRemoteFile.psm1
            MSFT_xRemoteFile.schema.mof
    Examples
        xRemoteFile_DownloadFile.ps1
    ResourceDesignerScripts
        GenerateXRemoteFileSchema.ps1
    Tests
        ResourceDesignerTests.ps1
    xPSDesiredStateConfiguration.psd1

Bron en het schema zijn juistResource and schema are correct

Controleer of de resource-schema (*. schema.mof) bestand.Verify the resource schema (*.schema.mof) file. U kunt de Designer voor DSC-Resource voor het ontwikkelen en testen van uw schema.You can use the DSC Resource Designer to help develop and test your schema. Zorg ervoor dat:Make sure that:

  • Typen eigenschappen voor correct zijn (bijvoorbeeld tekenreeks niet gebruiken voor eigenschappen die numerieke waarden accepteert, moet u UInt32 of andere numerieke typen in plaats daarvan)Property types are correct (e.g. don’t use String for properties which accept numeric values, you should use UInt32 or other numeric types instead)
  • Eigenschapskenmerken correct zijn opgegeven als: ([-toets], [vereist], [schrijven], [lezen])Property attributes are specified correctly as: ([key], [required], [write], [read])
  • Ten minste één parameter in het schema moet worden gemarkeerd als [-toets]At least one parameter in the schema has to be marked as [key]
  • [meer] eigenschap niet samen voorkomen, samen met een van: (vereist), [key], [schrijven][read] property does not coexist together with any of: [required], [key], [write]
  • Als meerdere kwalificaties zijn opgegeven, met uitzondering [lezen], klikt u vervolgens prioriteit]If multiple qualifiers are specified except [read], then [key] takes precedence
  • Als [schrijven] en [vereist] zijn opgegeven, wordt heeft een hogere prioriteit (vereist)If [write] and [required] are specified, then [required] takes precedence
  • ValueMap is opgegeven voorbeeld indien van toepassing:ValueMap is specified where appropriate Example:

    [Read, ValueMap{"Present", "Absent"}, Values{"Present", "Absent"}, Description("Says whether DestinationPath exists on the machine")] String Ensure;
    
  • Beschrijvende naam is opgegeven en wordt bevestigd dat aan de naamgevingsconventies DSCFriendly name is specified and confirms to DSC naming conventions

    Voorbeeld: [ClassVersion("1.0.0.0"), FriendlyName("xRemoteFile")]Example: [ClassVersion("1.0.0.0"), FriendlyName("xRemoteFile")]

  • Elk veld heeft een duidelijke beschrijving.Every field has meaningful description. De PowerShell-GitHub-opslagplaats is een goede voorbeelden zoals de. schema.mof voor xRemoteFileThe PowerShell GitHub repository has good examples, such as the .schema.mof for xRemoteFile

Bovendien moet u Test xDscResource en Test xDscSchema -cmdlets van Designer voor DSC-Resource automatisch te controleren of de bron en het schema:Additionally, you should use Test-xDscResource and Test-xDscSchema cmdlets from DSC Resource Designer to automatically verify the resource and schema:

Test-xDscResource <Resource_folder>
Test-xDscSchema <Path_to_resource_schema_file>

Bijvoorbeeld:For example:

Test-xDscResource ..\DSCResources\MSFT_xRemoteFile
Test-xDscSchema ..\DSCResources\MSFT_xRemoteFile\MSFT_xRemoteFile.schema.mof

Resource zonder fouten wordt geladenResource loads without errors

Controleer of de resource-module is kan worden geladen.Check whether the resource module can be successfully loaded. Dit kan handmatig worden bereikt door het uitvoeren van Import-Module <resource_module> -force en bevestigen dat er geen fouten zijn opgetreden, of door schrijven test automation.This can be achieved manually, by running Import-Module <resource_module> -force and confirming that no errors occurred, or by writing test automation. U kunt deze structuur in uw testscenario volgen in het geval van de laatste:In case of the latter, you can follow this structure in your test case:

$error = $null
Import-Module <resource_module> –force
If ($error.count –ne 0) {
    Throw “Module was not imported correctly. Errors returned: $error”
}

Resource is idempotent zijn in het geval is positiefResource is idempotent in the positive case

Een van de basiskenmerken van DSC-resources is idempotence.One of the fundamental characteristics of DSC resources is be idempotence. Dit betekent dat het toepassen van een DSC-configuratie met die bron meerdere keren wordt altijd hetzelfde resultaat bereiken.It means that applying a DSC configuration containing that resource multiple times will always achieve the same result. Bijvoorbeeld, als we een configuratie waarin de resource van het volgende bestand maken:For example, if we create a configuration which contains the following File resource:

File file {
    DestinationPath = "C:\test\test.txt"
    Contents = "Sample text"
}

Na het toepassen van deze voor de eerste keer, bestand test.txt, moet worden weergegeven in C:\test map.After applying it for the first time, file test.txt should appear in C:\test folder. Volgende uitvoeringen van dezelfde configuratie moeten echter niet wijzigen de status van de machine (bijvoorbeeld geen kopieën van de test.txt -bestand moet worden gemaakt).However, subsequent runs of the same configuration should not change the state of the machine (e.g. no copies of the test.txt file should be created). Om te controleren of een resource is idempotent zijn, kunt u herhaaldelijk aanroepen Set-TargetResource bij het testen van de resource direct of bel Start-DscConfiguration meerdere keren bij het maken van end-to-end-testen.To ensure a resource is idempotent you can repeatedly call Set-TargetResource when testing the resource directly, or call Start-DscConfiguration multiple times when doing end to end testing. Het resultaat moet hetzelfde na elke uitvoering.The result should be the same after every run.

Testscenario gebruiker wijzigenTest user modification scenario

Door het wijzigen van de status van de machine en vervolgens opnieuw uit te voeren DSC, kunt u controleren of Set-TargetResource en Test-TargetResource laten functioneren.By changing the state of the machine and then rerunning DSC, you can verify that Set-TargetResource and Test-TargetResource function properly. Hier vindt u stappen die u moet uitvoeren:Here are steps you should take:

  1. Beginnen met de resource niet in de gewenste status.Start with the resource not in the desired state.
  2. Configuratie uitvoeren met de resourceRun configuration with your resource
  3. Controleer of Test-DscConfiguration resulteert in waarVerify Test-DscConfiguration returns True
  4. Wijzigen van de geconfigureerde item om te worden uit de gewenste statusModify the configured item to be out of the desired state
  5. Controleer of Test-DscConfiguration retourneert ' false 'Verify Test-DscConfiguration returns false

Hier volgt een meer concrete voorbeeld met behulp van registerresource:Here’s a more concrete example using Registry resource:

  1. Beginnen met de registersleutel niet in de gewenste statusStart with registry key not in the desired state
  2. Voer Start-DscConfiguration met een configuratie plaatst deze in de gewenste status en controleer of deze is geslaagd.Run Start-DscConfiguration with a configuration to put it in the desired state and verify it passes.
  3. Voer Test-DscConfiguration en controleer of deze retourneert ' True 'Run Test-DscConfiguration and verify it returns true
  4. De waarde van de sleutel wijzigen zodat deze zich niet in de gewenste statusModify the value of the key so that it is not in the desired state
  5. Voer Test-DscConfiguration en controleer of het resultaat falseRun Test-DscConfiguration and verify it returns false
  6. Get-TargetResource functionaliteit is geverifieerd met behulp van Get-DscConfigurationGet-TargetResource functionality was verified using Get-DscConfiguration

Get-TargetResource details van de huidige status van de resource moet worden geretourneerd.Get-TargetResource should return details of the current state of the resource. Zorg ervoor dat u deze testen door het aanroepen van Get-DscConfiguration nadat u de configuratie toepassen en verifiëren die correct uitvoer de huidige status van de machine geeft.Make sure to test it by calling Get-DscConfiguration after you apply the configuration and verifying that output correctly reflects the current state of the machine. Het is belangrijk dat de afzonderlijk testen omdat eventuele problemen op dit gebied wordt niet weergegeven bij het aanroepen van Start-DscConfiguration.It's important to test it separately, since any issues in this area won't appear when calling Start-DscConfiguration.

Bel Get/Set/Test-TargetResource rechtstreeks functiesCall Get/Set/Test-TargetResource functions directly

Zorg ervoor dat u test de Get/Set/Test-TargetResource functies die zijn geïmplementeerd in uw resource door ze voor het rechtstreeks aanroepen en verifiëren dat ze werken zoals verwacht.Make sure you test the Get/Set/Test-TargetResource functions implemented in your resource by calling them directly and verifying that they work as expected.

Controleer of met behulp van End-to-End Start-DscConfigurationVerify End to End using Start-DscConfiguration

Testen Get/Set/Test-TargetResource functies door ze rechtstreeks aan te roepen is belangrijk, maar niet alle problemen op deze manier worden gedetecteerd.Testing Get/Set/Test-TargetResource functions by calling them directly is important, but not all issues will be discovered this way. U moet erop zijn gericht aanzienlijk deel van de controle over het gebruik van Start-DscConfiguration of de pull-server.You should focus significant part of your testing on using Start-DscConfiguration or the pull server. Dit is in feite hoe gebruikers de resource, zodat de betekenis van dit type tests Onderschat niet wordt gebruikt.In fact, this is how users will use the resource, so don’t underestimate the significance of this type of tests. Mogelijke typen problemen:Possible types of issues:

  • Referentie/sessie mogelijk anders werken omdat de DSC-agent wordt uitgevoerd als een service.Credential/Session may behave differently because the DSC agent runs as a service. Zorg ervoor dat testen functies hier end-to-end.Be sure to test any features here end to end.
  • Fouten uitvoeren door Start-DscConfiguration mogelijk anders dan die worden weergegeven bij het aanroepen van de Set-TargetResource rechtstreeks werken.Errors output by Start-DscConfiguration may be different than those displayed when calling the Set-TargetResource function directly.

Ondersteunde platforms voor test-compatibiliteit op alle DSCTest compatability on all DSC supported platforms

Resource moet werken op alle DSC ondersteunde platforms (Windows Server 2008 R2 en hoger).Resource should work on all DSC supported platforms (Windows Server 2008 R2 and newer). Installeer de meest recente WMF (Windows Management Framework) van het besturingssysteem naar de meest recente versie van DSC.Install the latest WMF (Windows Management Framework) on your OS to get the latest version of DSC. Als uw resource standaard niet op sommige van deze platformen werkt, kan een specifiek foutbericht moet worden geretourneerd.If your resource does not work on some of these platforms by design, a specific error message should be returned. Zorg er ook dat uw resource controleert of de cmdlets die u aanroept op bepaalde machine aanwezig zijn.Also, make sure your resource checks whether cmdlets you are calling are present on particular machine. Windows Server 2012 toegevoegd een groot aantal nieuwe cmdlets die niet beschikbaar op Windows Server 2008R2, zelfs met WMF is geïnstalleerd zijn.Windows Server 2012 added a large number of new cmdlets that are not available on Windows Server 2008R2, even with WMF installed.

Controleer of op Windows-Client (indien van toepassing)Verify on Windows Client (if applicable)

Een heel normaal test tussenruimte met het controleren van de resource alleen op server-versies van Windows.One very common test gap is verifying the resource only on server versions of Windows. Veel resources ook zijn ontworpen om te werken op Client-SKU's, dus als dat is waar in uw geval, vergeet dan niet om dit te testen op deze platforms ook.Many resources are also designed to work on Client SKUs, so if that’s true in your case, don’t forget to test it on those platforms as well.

Sleutelwoorden Get-dscresource bieden geeft een lijst van de resourceGet-DSCResource lists the resource

Na de implementatie van de module aanroepen Get-DscResource uw resource onder andere als gevolg hiervan moet weergeven.After deploying the module, calling Get-DscResource should list your resource among others as a result. Als u de resource niet in de lijst vinden, ervoor zorgen dat bestand schema.mof voor die bron bestaat.If you can’t find your resource in the list, make sure that schema.mof file for that resource exists.

Resource-module bevat voorbeeldenResource module contains examples

Het maken van het kwaliteitsvoorbeelden waarmee anderen te begrijpen hoe u deze.Creating quality examples which will help others understand how to use it. Dit is essentieel, met name omdat veel gebruikers voorbeeldcode als documentatie behandelen.This is crucial, especially since many users treat sample code as documentation.

  • Eerst moet u de voorbeelden die wordt opgenomen met de module: ten minste bepalen, moet u belangrijkste use-cases dekking voor uw resource:First, you should determine the examples that will be included with the module – at minimum, you should cover most important use cases for your resource:
  • Als uw module verschillende bronnen die nodig is om samen te werken voor een end-to-end-scenario bevat, zou de eenvoudige end-to-end-voorbeeld in het ideale geval eerste.If your module contains several resources that need to work together for an end-to-end scenario, the basic end-to-end example would ideally be first.
  • De eerste voorbeelden zeer eenvoudig--moeten zijn aan de slag met uw resources in kleine beheerbare segmenten (bijvoorbeeld het maken van een nieuwe VHD)The initial examples should be very simple -- how to get started with your resources in small manageable chunks (e.g. creating a new VHD)
  • Opeenvolgende voorbeelden te bouwen op deze voorbeelden (bijvoorbeeld een virtuele machine maken vanaf een VHD, VM, het wijzigen van de virtuele machine verwijderen) en geavanceerde functionaliteit (bijvoorbeeld een virtuele machine maken met het dynamisch geheugen)Subsequent examples should build on those examples (e.g. creating a VM from a VHD, removing VM, modifying VM), and show advanced functionality (e.g. creating a VM with dynamic memory)
  • Van de voorbeeldconfiguraties als parameters moeten worden gebruikt (alle waarden moeten worden doorgegeven aan de configuratie als parameters en er mag geen waarden vastgelegd):Example configurations should be parameterized (all values should be passed to the configuration as parameters and there should be no hardcoded values):

    configuration Sample_xRemoteFile_DownloadFile
    {
      param
      (
          [string[]] $nodeName = 'localhost',
    
          [parameter(Mandatory = $true)]
          [ValidateNotNullOrEmpty()]
          [String] $destinationPath,
    
          [parameter(Mandatory = $true)]
          [ValidateNotNullOrEmpty()]
          [String] $uri,
    
          [String] $userAgent,
    
          [Hashtable] $headers
      )
    
      Import-DscResource -Name MSFT_xRemoteFile -ModuleName xPSDesiredStateConfiguration
    
      Node $nodeName
      {
          xRemoteFile DownloadFile
          {
              DestinationPath = $destinationPath
              Uri = $uri
              UserAgent = $userAgent
              Headers = $headers
          }
      }
    }
    
  • Het is raadzaam om op te nemen (opmerkingen van) voorbeeld van hoe u de configuratie met de werkelijke waarden aan het einde van de voorbeeld-script aanroept.It’s a good practice to include (commented out) example of how to call the configuration with the actual values at the end of the example script. Bijvoorbeeld, in de bovenstaande configuratie is niet altijd duidelijk dat de beste manier om op te geven van de UserAgent is:For example, in the configuration above it isn't necessarily obvious that the best way to specify UserAgent is:

    UserAgent = [Microsoft.PowerShell.Commands.PSUserAgent]::InternetExplorer Een opmerking kunt in dat geval de beoogde uitvoering van de configuratie te verduidelijken:UserAgent = [Microsoft.PowerShell.Commands.PSUserAgent]::InternetExplorer In which case a comment can clarify the intended execution of the configuration:

    <#
    Sample use (parameter values need to be changed according to your scenario):
    
    Sample_xRemoteFile_DownloadFile -destinationPath "$env:SystemDrive\fileName.jpg" -uri "http://www.contoso.com/image.jpg"
    
    Sample_xRemoteFile_DownloadFile -destinationPath "$env:SystemDrive\fileName.jpg" -uri "http://www.contoso.com/image.jpg" `
    -userAgent [Microsoft.PowerShell.Commands.PSUserAgent]::InternetExplorer -headers @{"Accept-Language" = "en-US"}
    #>
    
  • Voor elk voorbeeld een korte beschrijving waarin wordt uitgelegd wat het doet en de betekenis van de parameters te schrijven.For each example, write a short description which explains what it does, and the meaning of the parameters.

  • Zorg ervoor dat de voorbeelden voor de meeste belangrijke scenario's voor uw resource en als er niets ontbreekt, Controleer of ze al worden uitgevoerd en machine in de gewenste status geplaatst.Make sure examples cover most the important scenarios for your resource and if there’s nothing missing, verify that they all execute and put machine in the desired state.

Foutberichten zijn eenvoudig te begrijpen en oplossen van problemen met gebruikers helpenError messages are easy to understand and help users solve problems

Goede foutberichten moeten worden:Good error messages should be:

  • Er: Het grootste probleem met foutberichten is dat ze vaak niet bestaan, dus zorg ervoor dat ze zijn er.There: The biggest problem with error messages is that they often don’t exist, so make sure they are there.
  • Gemakkelijk te begrijpen: mens leesbaar, niet verborgen foutcodesEasy to understand: Human readable, no obscure error codes
  • Nauwkeurige: Is beschreven wat er precies het probleemPrecise: Describe what’s exactly the problem
  • Feitelijke: Advies over het oplossen van het probleemConstructive: Advice how to fix the issue
  • Beleefd: Geen gebruiker zal of ze beschadigde denktPolite: Don’t blame user or make them feel bad

Zorg ervoor dat u fouten in de End-to-End scenario's controleren (met behulp van Start-DscConfiguration), omdat ze van die afwijken kunnen bij het uitvoeren van functies van resource rechtstreeks geretourneerd.Make sure you verify errors in End to End scenarios (using Start-DscConfiguration), because they may differ from those returned when running resource functions directly.

Logboekberichten zijn gemakkelijk te begrijpen en informatieve (inclusief-verbose,-foutopsporing en ETW-Logboeken)Log messages are easy to understand and informative (including –verbose, –debug and ETW logs)

Zorg ervoor dat logboeken gegenereerd door de resource die eenvoudig te begrijpen en geef de waarde voor de gebruiker.Ensure that logs outputted by the resource are easy to understand and provide value to the user. Resources moeten alle informatie die nuttig voor de gebruiker zijn kan uitvoeren, maar meer logboeken is niet altijd beter.Resources should output all information which might be helpful to the user, but more logs is not always better. U moet voorkomen van redundantie en gegevens die niet worden uitgevoerd bieden een extra waarde: iemand anders gaat u door de honderden logboekvermeldingen om te zoeken wat ze zoekt niet maken.You should avoid redundancy and outputting data which does not provide additional value – don’t make someone go through hundreds of log entries in order to find what they're looking for. Er zijn geen logboeken is natuurlijk niet een aanvaardbare oplossing voor dit probleem ofwel.Of course, no logs is not an acceptable solution for this problem either.

Wanneer u test, u moet ook uitgebreide analyseren en fouten opsporen in Logboeken (door het uitvoeren van Start-DscConfiguration met –Verbose en –Debug op de juiste wijze verandert), ook als ETW-Logboeken.When testing, you should also analyze verbose and debug logs (by running Start-DscConfiguration with –Verbose and –Debug switches appropriately), as well as ETW logs. Als u wilt zien DSC ETW-Logboeken, gaat u naar Logboeken en opent u de volgende map: toepassingen en Services van Microsoft - Windows - Desired State Configuration.To see DSC ETW logs, go to Event Viewer and open the following folder: Applications and Services- Microsoft - Windows - Desired State Configuration. Er standaard worden operationele kanaal, maar zorg ervoor dat u inschakelt analytische en foutopsporing van kanalen voordat de configuratie wordt uitgevoerd.By default there will be Operational channel, but make sure you enable Analytic and Debug channels before running the configuration. Om in te schakelen analytische/Debug kanalen, kunt u onderstaande script uitvoeren:To enable Analytic/Debug channels, you can execute script below:

$statusEnabled = $true
# Use "Analytic" to enable Analytic channel
$eventLogFullName = "Microsoft-Windows-Dsc/Debug"
$commandToExecute = "wevtutil set-log $eventLogFullName /e:$statusEnabled /q:$statusEnabled   "
$log = New-Object System.Diagnostics.Eventing.Reader.EventLogConfiguration $eventLogFullName
if($statusEnabled -eq $log.IsEnabled)
{
    Write-Host -Verbose "The channel event log is already enabled"
    return
}
Invoke-Expression $commandToExecute

Resource-implementatie bevat geen vastgelegd padenResource implementation does not contain hardcoded paths

Zorg ervoor dat er zijn geen paden vastgelegd in de resource-implementatie, met name als ze gaan ervan uit taal (en-us), of wanneer er systeemvariabelen die kunnen worden gebruikt.Ensure there are no hardcoded paths in the resource implementation, particularly if they assume language (en-us), or when there are system variables that can be used. Als de bron nodig hebt voor toegang tot specifieke paden, omgevingsvariabelen gebruiken in plaats van hardcoderen het pad, omdat dit anders op andere computers zijn kan.If your resource need to access specific paths, use environment variables instead of hardcoding the path, as it may differ on other machines.

Voorbeeld:Example:

In plaats van:Instead of:

$tempPath = "C:\Users\kkaczma\AppData\Local\Temp\MyResource"
$programFilesPath = "C:\Program Files (x86)"

U kunt schrijven:You can write:

$tempPath = Join-Path $env:temp "MyResource"
$programFilesPath = ${env:ProgramFiles(x86)}

Resource-implementatie bevatten geen gebruikersgegevensResource implementation does not contain user information

Zorg ervoor dat er zijn geen e-namen, accountgegevens of namen van personen in de code.Make sure there are no email names, account information, or names of people in the code.

Resource is getest met de referenties geldig/ongeldigResource was tested with valid/invalid credentials

Als de resource een referentie als parameter:If your resource takes a credential as parameter:

  • Controleer of de resource-werkt als lokaal systeem (of het computeraccount voor de externe bronnen) heeft geen toegang.Verify the resource works when Local System (or the computer account for remote resources) does not have access.
  • Controleer of de resource werkt met een referentie opgegeven voor ophalen, instellen en testenVerify the resource works with a credential specified for Get, Set and Test
  • Als uw resource toegang heeft tot de shares, test u alle varianten die u ondersteunen wilt, zoals:If your resource accesses shares, test all the variants you need to support, such as:
    • Standaard windows-shares.Standard windows shares.
    • DFS-shares.DFS shares.
    • SAMBA-shares (als u ondersteuning voor Linux.)SAMBA shares (if you want to support Linux.)

Resource is niet vereist voor interactieve invoerResource does not require interactive input

Get/Set/Test-TargetResource functies automatisch moet worden uitgevoerd en moet u niet wachten voor de invoer van gebruiker tijdens elke fase van de uitvoering (bijv. Gebruik geen Get-Credential binnen deze functies).Get/Set/Test-TargetResource functions should be executed automatically and must not wait for user’s input at any stage of execution (e.g. you should not use Get-Credential inside these functions). Als u nodig hebt voor de invoer van gebruiker, moet u deze doorgeven aan de configuratie als parameter tijdens de compilatie-fase.If you need to provide user’s input, you should pass it to the configuration as parameter during the compilation phase.

Resourcefunctionaliteit is uitgebreid getest.Resource functionality was thoroughly tested

Deze controlelijst bevat de items die zijn belangrijk om te worden getest en/of vaak zijn gemist.This checklist contains items which are important to be tested and/or are often missed. Er is aantal tests, voornamelijk functionele labels die specifiek zijn voor de resource die u wilt testen en niet hier worden vermeld.There will be bunch of tests, mainly functional ones which will be specific to the resource you are testing and are not mentioned here. Vergeet niet over negatieve Testscenario's.Don’t forget about negative test cases.

Aanbevolen: Resource-module bevat de map Tests met ResourceDesignerTests.ps1 scriptBest practice: Resource module contains Tests folder with ResourceDesignerTests.ps1 script

Het is raadzaam om te maken van de map 'Test' in resource-module, maken ResourceDesignerTests.ps1 bestand en voeg toe met behulp van tests Test xDscResource en Test xDscSchema voor alle resources in bepaalde module.It’s a good practice to create folder “Tests” inside resource module, create ResourceDesignerTests.ps1 file and add tests using Test-xDscResource and Test-xDscSchema for all resources in given module. Op deze manier kunt u snel schema's van alle resources uit het opgegeven modules en voert u een sanity controleren voordat u publiceert valideren.This way you can quickly validate schemas of all resources from the given modules and do a sanity check before publishing. Voor xRemoteFile, ResourceTests.ps1 kan net zo eenvoudig als zoeken:For xRemoteFile, ResourceTests.ps1 could look as simple as:

Test-xDscResource ..\DSCResources\MSFT_xRemoteFile
Test-xDscSchema ..\DSCResources\MSFT_xRemoteFile\MSFT_xRemoteFile.schema.mof

Aanbevolen: Resource-map bevat de ontwerperscript resource voor het genereren van schemaBest practice: Resource folder contains resource designer script for generating schema

Elke bron moet een resource designer script een mof-schema van de resource genereert bevatten.Each resource should contain a resource designer script which generates a mof schema of the resource. Dit bestand moet worden geplaatst <ResourceName>\ResourceDesignerScripts en de naam genereren <ResourceName>Schema.ps1 voor xRemoteFile resource dit bestand kan worden aangeroepen GenerateXRemoteFileSchema.ps1 en bevatten:This file should be placed in <ResourceName>\ResourceDesignerScripts and be named Generate <ResourceName>Schema.ps1 For xRemoteFile resource this file would be called GenerateXRemoteFileSchema.ps1 and contain:

$DestinationPath = New-xDscResourceProperty -Name DestinationPath -Type String -Attribute Key -Description 'Path under which downloaded or copied file should be accessible after operation.'
$Uri = New-xDscResourceProperty -Name Uri -Type String -Attribute Required -Description 'Uri of a file which should be copied or downloaded. This parameter supports HTTP and HTTPS values.'
$Headers = New-xDscResourceProperty -Name Headers -Type Hashtable[] -Attribute Write -Description 'Headers of the web request.'
$UserAgent = New-xDscResourceProperty -Name UserAgent -Type String -Attribute Write -Description 'User agent for the web request.'
$Ensure = New-xDscResourceProperty -Name Ensure -Type String -Attribute Read -ValidateSet "Present", "Absent" -Description 'Says whether DestinationPath exists on the machine'
$Credential = New-xDscResourceProperty -Name Credential -Type PSCredential -Attribute Write -Description 'Specifies a user account that has permission to send the request.'
$CertificateThumbprint = New-xDscResourceProperty -Name CertificateThumbprint -Type String -Attribute Write -Description 'Digital public key certificate that is used to send the request.'

New-xDscResource -Name MSFT_xRemoteFile -Property @($DestinationPath, $Uri, $Headers, $UserAgent, $Ensure, $Credential, $CertificateThumbprint) -ModuleName xPSDesiredStateConfiguration2 -FriendlyName xRemoteFile

Aanbevolen: bron - WhatIf wordt ondersteundBest practice: Resource supports -WhatIf

Als uw resource 'gevaarlijke' bewerkingen uitvoert, is het raadzaam om te implementeren -WhatIf functionaliteit.If your resource is performing “dangerous” operations, it’s a good practice to implement -WhatIf functionality. Nadat dit voltooid, controleert u of -WhatIf uitvoer beschrijft correct bewerkingen die er gebeuren zou als de opdracht is uitgevoerd zonder -WhatIf overschakelen.After it’s done, make sure that -WhatIf output correctly describes operations which would happen if command was executed without -WhatIf switch. Controleer ook of bewerkingen wordt niet uitgevoerd (de status van het knooppunt worden niet gewijzigd) als –WhatIf switch aanwezig is.Also, verify that operations does not execute (no changes to the node’s state are made) when –WhatIf switch is present. Bijvoorbeeld, Stel dat we bestandsresource test.For example, let’s assume we are testing File resource. Hieronder vindt u eenvoudige configuratie die zorgt voor bestand test.txt met inhoud van 'test':Below is simple configuration which creates file test.txt with contents “test”:

configuration config
{
    node localhost
    {
        File file
        {
            Contents="test"
            DestinationPath="C:\test\test.txt"
        }
    }
}
config

Als we compileren en uitvoeren van de configuratie met de -WhatIf switch, de uitvoer is laat ons weten dat precies wat gebeurt er wanneer we de configuratie uitvoert.If we compile and then execute the configuration with the -WhatIf switch, the output is telling us exactly what would happen when we run the configuration. Tot wel is niet worden uitgevoerd door de configuratie zelf (test.txt bestand is niet gemaakt).The configuration itself however was not executed (test.txt file was not created).

Start-DscConfiguration -Path .\config -ComputerName localhost -Wait -Verbose -WhatIf
VERBOSE: Perform operation 'Invoke CimMethod' with following parameters, ''methodName' =
SendConfigurationApply,'className' = MSFT_DSCLocalConfigurationManager,'namespaceName' =
root/Microsoft/Windows/DesiredStateConfiguration'.
VERBOSE: An LCM method call arrived from computer CHARLESX1 with user sid
S-1-5-21-397955417-626881126-188441444-5179871.
What if: [X]: LCM:  [ Start  Set      ]
What if: [X]: LCM:  [ Start  Resource ]  [[File]file]
What if: [X]: LCM:  [ Start  Test     ]  [[File]file]
What if: [X]:                            [[File]file] The system cannot find the file specified.
What if: [X]:                            [[File]file] The related file/directory is: C:\test\test.txt.
What if: [X]: LCM:  [ End    Test     ]  [[File]file]  in 0.0270 seconds.
What if: [X]: LCM:  [ Start  Set      ]  [[File]file]
What if: [X]:                            [[File]file] The system cannot find the file specified.
What if: [X]:                            [[File]file] The related file/directory is: C:\test\test.txt.
What if: [X]:                            [C:\test\test.txt] Creating and writing contents and setting attributes.
What if: [X]: LCM:  [ End    Set      ]  [[File]file]  in 0.0180 seconds.
What if: [X]: LCM:  [ End    Resource ]  [[File]file]
What if: [X]: LCM:  [ End    Set      ]
VERBOSE: [X]: LCM:  [ End    Set      ]    in  0.1050 seconds.
VERBOSE: Operation 'Invoke CimMethod' complete.

Deze lijst is niet volledig, maar het geeft veel belangrijke problemen die kunnen worden aangetroffen tijdens het ontwerpen, ontwikkelen en testen van DSC-resources.This list is not exhaustive, but it covers many important issues which can be encountered while designing, developing and testing DSC resources.