> For the complete documentation index, see [llms.txt](https://docs.devolutions.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.devolutions.net/powershell-universal/da/platform/modules.md).

# Moduler

Administrer PowerShell-moduler i PowerShell Universal, herunder Gallery-installationer, pakkekilder, oprettelse af brugerdefinerede moduler og konfiguration af root-modulet.

Siden Modules giver oplysninger om de moduler, der er installeret i systemet.

## Visning af moduler

De kan få vist og søge i de moduler, som PowerShell Universal har adgang til, under **Manage > Modules > Installed**. Søgning giver et resultat med jokertegn for de moduler, der findes i hvert af de miljøer, der er defineret i PowerShell Universal.

## Installer moduler fra Gallery

Moduler kan installeres fra PowerShell Gallery under **Manage > Modules > Discover**. Vælg en kilde ved siden af søgefeltet for at søge i den kilde i stedet for lokalt.

Når et modul er fundet, kan De klikke på knappen Install for at gemme det lokalt. Moduler, der installeres på denne måde, installeres i kataloget Repository under Modules.

## Pakkekilder

PowerShell Universal integrerer med modulet `PackageManagement v3` og opfanger automatisk registrerede pakkekilder. De kan f.eks. registrere en pakkekilde med kommandoen nedenfor.

```powershell
Register-PSResourceRepository -Name MyNuGet -Uri https://www.nuget.org/api/v2
```

Registrerede pakkekilder er angivet under **Manage > Modules > Sources** og er tilgængelige, når der søges efter moduler.

## Oprettelse af moduler

De kan også oprette moduler direkte i PowerShell Universal. Disse moduler oprettes i lagerkataloget under Modules.

Disse moduler vil være tilgængelige i alle miljøer.

For at oprette et nyt modul skal De gå til **Manage > Modules > Custom Modules** og klikke på Create New Module. Definer modulets navn og version.

Når modulet er oprettet, vises det under Universal Modules med mulighed for at redigere egenskaber og indhold samt slette modulet.

Når De redigerer modulet, åbnes en kodeeditor, hvor De kan definere funktioner, variabler og aliaser, der skal eksporteres.

## Moduler med Universal-ressourcer

{% hint style="info" %}
Et eksempelmodul kan [findes her](https://github.com/ironmansoftware/universal-modules).
{% endhint %}

### Installer

Moduler kan indeholde PowerShell Universal-ressourcer som scripts, API'er og apps. Når De tilføjer disse moduler til Deres miljø, tilføjes disse ressourcer automatisk til Deres PowerShell Universal-instans. Disse ressourcer vil være skrivebeskyttede i miljøet. For at fjerne dem skal De fjerne modulet.

Åbn **Manage > Modules > Installed** i Admin Console.

Klik på downloadknappen i venstre side af modulet for at installere det. Når det er installeret, føjes skrivebeskyttede ressourcer til Deres miljø.

De kan også gemme moduler direkte i PowerShell Universal-lagermappen.

```powershell
Save-Module Universal.Apps.WindowsSystemInformation -Path $Env:ProgramData\UniversalAutomation\Repository\Modules
```

### Opret

Nedenfor er et eksempel på layoutet af et Universal-modul. Hvis modulet indeholder mappen `.universal`, indlæses ressourcer automatisk fra den.

```
.universal 
    scripts.ps1
PSUModule.psd1
PSUModule.psm1
```

Ressourcer kan ikke bruge stier og skal bruge modul- og kommandonavnet til at knytte ressourcer til deres respektive scripts.

For eksempel skulle ovenstående `scripts.ps1`-fil skrives som følger.

```powershell
New-PSUScript -Module 'PSUModule' -Command 'Start-MyScript'
```

I `PSUModule.psm1` skal De definere funktionen `Start-MyScript`. Dette er den funktion, der kaldes, når scriptet køres.

```powershell
function Start-MyScript {

}
```

### Publicer

Når De opretter moduler, der udvider PowerShell Universal, kan De medtage mærket `PowerShellUniversal` i Deres modulmanifest, så de vises på [PowerShell Universal-modulsiden](/powershell-universal/da/readme.md) og i PSU admin console.

[Publicer moduler til PowerShell Gallery](https://jeffbrown.tech/how-to-publish-your-first-powershell-gallery-package/) for at dele dem med andre.

## Rodmodul

De kan definere et rodmodul som PowerShell Universal-konfigurationen. Det giver mulighed for reproducerbare konfigurationer baseret på publicerede moduler. Et rodmodul defineres i programindstillingerne for PowerShell Universal-serveren. Når PowerShell Universal starter, indlæser det dette modul og eventuelle afhængigheder automatisk. Rodmodulet skal findes i PSModulePath eller i lagerets Modules-mappe.

### Eksempel

Nedenfor er et eksempel på brug af et rootmodul og afhængigheder til at definere en PowerShell Universal-konfiguration. Ressourcer, der leveres af moduler, er skrivebeskyttede på platformen. Ved at bruge moduler kan De sikre, at bestemte versioner af ressourcer pakkes og udrulles til Deres PowerShell Universal-instanser.

{% hint style="success" %}
Rodmodulet kan ligge hvor som helst i den registrerede PSModulePath for Deres server eller tjenestekonto. Modulerne kan også ligge i modulmappen i Deres lager. Eksemplet nedenfor bruger relative stier.
{% endhint %}

#### ARD.Core

Modulet ARD.Core definerer nogle få funktioner og et miljø, der bruges af andre moduler. Her er et eksempel på et grundlæggende miljø, der defineres.

{% code title="Modules\ARD.Core\1.0.0.universal\environments.ps1" %}

```powershell
New-PSUEnvironment -Name 'ARD.Core' -Path pwsh.exe -Type PowerShell7
```

{% endcode %}

Funktionerne er defineret i modulets PSM1-fil.

{% code title="Modules\ARD.Core\1.0.0\ARD.Core.psm1" %}

```powershell
function Get-ARDCore {
    @{
        Name = "ARD.Core"
        Description = "This is a test function result"
    }
}
```

{% endcode %}

Modulmanifestet eksporterer funktionen og leverer nogle grundlæggende metadata.

{% code title="Modules\ARD.Core\1.0.0\ARD.Core.psd1" %}

```powershell
@{
    RootModule = "ARD.Core.psm1"
    Description = "ARD.Core is the base module for other modules"
    Version = "1.0.0"
    FunctionsToExport = @("Get-ARDCore")
}
```

{% endcode %}

#### ARD.Endpoints

Modulet ARD.Endpoints har en struktur, der ligner modulet ARD.Core, men eksponerer et slutpunkt i stedet for et miljø. Dette eksempel på et slutpunkt kalder funktionen `Get-ARDResponse`, når URL'en `ard.endpoint` kaldes. Bemærk, at slutpunktet bruger det ARD.Core-slutpunkt, som modulet ovenfor leverer.

{% code title="Modules\ARD.Endpoints\1.0.0.universal\endpoints.ps1" %}

```powershell
New-PSUEndpoint -Url /ard.endpoint -Module 'ARD.Endpoints' -Command "Get-ARDResponse" -Environment 'ARD.Core'
```

{% endcode %}

Filen ARD.Endpoints.psm1 definerer den funktion, der skal eksporteres, og som vi også kan bruge til slutpunktet. Slutpunktet bruger funktionen fra ARD.Core til at returnere et svar. Det virker, fordi de alle blot er almindelige PowerShell-moduler.

{% code title="Modules\ARD.Endpoints\1.0.0\ARD.Endpoints.psm1" %}

```powershell
function Get-ARDResponse {
    Get-ARDCore
}
```

{% endcode %}

Filen ARD.Endpoints.psd1 eksporterer funktionen og tager også en afhængighed af ARD.Core for at sikre, at modulet indlæses først, fordi slutpunktet er afhængigt af, at både funktionen og miljøet findes.

{% code title="Modules\ARD.Endpoints\1.0.0\ARD.Endpoints.psd1" %}

```powershell
@{
    RootModule = "ARD.Endpoints.psm1"
    Description = "Sample endpoints"
    Version = "1.0.0"
    RequiredModules = @("ARD.Core")
    FunctionsToExport = @("Get-ARDResponse")
}
```

{% endcode %}

#### ARD.Root

Rodmodulet indlæses først af PowerShell Universal. Det har en afhængighed af både kernemodulet og slutpunktsmodulet, men definerer ikke selv nogen funktionalitet. PowerShell Universal fastlægger den korrekte indlæsningsrækkefølge og indlæser derefter ressourcer under opstart.

```powershell
@{
    Description = "A PowerShell Universal configuration"
    Version = "1.0.0"
    RequiredModules = @("ARD.Core", "ARD.Endpoints")
}
```

I programindstillingerne kan De vælge root-modulet og versionen.

{% code title="appsettings.json" %}

```json
{
    "Data": {
        "Module": "ARD.Root",
        "ModuleVersion": "1.0.0"
    }
}
```

{% endcode %}

De kan også konfigurere via miljøvariabler. Ændring af enten filen eller miljøvariablerne kræver en genstart af PowerShell Universal.

```powershell
$ENV:Data__Module = "ARD.Root"
$ENV:Data__ModuleVersion = "1.0.0"
```

## Installer moduler manuelt

PowerShell Universal vil føje lagerets `Modules`-katalog til `$ENV:PSModulePath` for alle miljøer. Tilføjelse af moduler til dette katalog sikrer, at modulet er tilgængeligt for enhver PowerShell-proces, der kører med PowerShell Universal.

## Modulinformation

Dette afsnit indeholder oplysninger om visse moduler og deres brug i PowerShell Universal.

### ActiveDirectory

Modulet `ActiveDirectory` har oprindelig understøttelse af PowerShell 7, når version 1.0.1.0 bruges. Når version 1.0.0.0 bruges, anvendes Windows-kompatibilitetslaget, når kommandoerne køres i PowerShell 7 og det integrerede miljø. Dette kan forårsage problemer i PowerShell Universal. Vores vejledning for dette modul er som følger.

#### Windows Server 2019 og nyere

Opdater modulet `ActiveDirectory` til version 1.0.1.0, som har understøttelse af PowerShell Core

#### Windows Server 2016 og tidligere

Vælg blandt 1 af 2 tilgængelige midlertidige løsninger:

* Medtag parameteren `-SkipEditionCheck` sammen med **Import-Module**, når De importerer modulet ActiveDirectory
* Brug Windows PowerShell 5.1-miljøet i stedet for Integrated/PowerShell Core

#### Yderligere læsning

{% embed url="<https://devblogs.microsoft.com/powershell/increased-windows-modules-coverage-with-powershell-core-6-1/>" %}

### Exchange

Microsoft Exchange i det lokale miljø kan administreres ved hjælp af fjernsessioner i PowerShell. Hvis De bruger sessioner i apps, bør De overveje at administrere sessionen på en måde, så De undgår at skulle åbne en ny session for hver anmodning. Dette forbedrer ydeevnen betydeligt. Nedenstående eksempel bruger omfanget `$Cache:` til at bevare sessionen på tværs af anmodninger.

Selvom dette eksempel bruger PSSessions og Exchange, kan De bruge det samme mønster til andre typer persistente forbindelser.

```powershell
$Cache:ExchangeServer = ''
$Cache:ExchangeCredential = ''
$Cache:ExchangeSessionInfo = @{

    Authentication    = 'Kerberos'
    ConfigurationName = 'Microsoft.Exchange'
    ConnectionUri     = 'https://{0}/PowerShell/' -f $Cache:ExchangeServer
    Credential        = $Cache:ExchangeCredential
    WarningAction     = 'SilentlyContinue'
}

#region PRIVATE FUNCTIONS

Function Script:Connect-ExchServer {
    $exchSession = New-PSSession @Cache:ExchangeSessionInfo
    Import-PSSession $exchSession -WarningAction 'SilentlyContinue'
}

Function Script:Test-ExchConnected {
    $Current = Get-PSSession | Where-Object { $_.ConfigurationName -eq 'Microsoft.Exchange' }
    if ($Current.State -eq 'Opened' -and $Current.Availability -eq 'Available') {
        $true
    }
    else {
        $false
    }
}

#endregion

#region PUBLIC FUNCTIONS 

Function Clear-ExchConnection {
    # called publicly in "End{}" blocks.
    Get-PSSession | Where-Object { $_.ConfigurationName -eq 'Microsoft.Exchange' } | Remove-PSSession -ErrorAction $Cache:ErrorAction
    Get-Module | Where-Object { $_.Description -match $Cache:ExchangeServer } | Remove-Module -Force -ErrorAction $Cache:ErrorAction
}

Function Confirm-ExchConnected {
     # called publicly in "Begin{}" blocks, or just before Exhange actions in functions or scripts.
    if (!( Test-ExchConnected )) {
        Clear-ExchConnection
        Connect-ExchServer
    }
}

#endregion

function Invoke-ExampleExchFunction {
    Param (
        $something
    )

    Begin {
        $null = Confirm-ExchConnected
    }
    
    Process {
        return $something
    }
    
    End {
        Clear-ExchConnection
    }
}
```

## Validerede modulversioner

Nedenstående modulversioner er valideret mod PowerShell Universal. Modulvalidering sikrer, at disse moduler indlæses og interagerer med deres respektive tjenester.

| Modul                          | Modulversion | PSU-version | PSU-miljøer              |
| ------------------------------ | ------------ | ----------- | ------------------------ |
| Microsoft.Graph.Authentication | 2.26.1       | 5.5.2       | PowerShell 7             |
| ExchangeOnlineManagement       | 3.7.2        | 5.5.2       | PowerShell 7             |
| MicrosoftTeams                 | 6.9.0        | 5.5.2       | PowerShell 7             |
| Az.Accounts                    | 4.1.0        | 5.5.2       | PowerShell 7, Integrated |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.devolutions.net/powershell-universal/da/platform/modules.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.