Invoke-Command

Modul:

Microsoft.PowerShell.Core

Kör kommandon på lokala datorer och fjärrdatorer.

Syntax

Invoke-Command
      [-ScriptBlock] <ScriptBlock>
      [-NoNewScope]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [[-Session] <PSSession[]>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [[-Session] <PSSession[]>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [[-ComputerName] <String[]>]
      [-Credential <PSCredential>]
      [-Port <Int32>]
      [-UseSSL]
      [-ConfigurationName <String>]
      [-ApplicationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-InDisconnectedSession]
      [-SessionName <String[]>]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-CertificateThumbprint <String>]
      [<CommonParameters>]

Invoke-Command
      [[-ComputerName] <String[]>]
      [-Credential <PSCredential>]
      [-Port <Int32>]
      [-UseSSL]
      [-ConfigurationName <String>]
      [-ApplicationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-InDisconnectedSession]
      [-SessionName <String[]>]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [-Credential <PSCredential>]
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [[-ConnectionUri] <Uri[]>]
      [-AsJob]
      [-InDisconnectedSession]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-AllowRedirection]
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-CertificateThumbprint <String>]
      [<CommonParameters>]

Invoke-Command
      [-Credential <PSCredential>]
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [[-ConnectionUri] <Uri[]>]
      [-AsJob]
      [-InDisconnectedSession]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-AllowRedirection]
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-ScriptBlock] <ScriptBlock>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-VMId] <Guid[]>
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-ScriptBlock] <ScriptBlock>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -VMName <String[]>
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-FilePath] <String>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-VMId] <Guid[]>
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-FilePath] <String>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -VMName <String[]>
      [<CommonParameters>]

Invoke-Command
      [-Port <Int32>]
      [-AsJob]
      [-HideComputerName]
      -ScriptBlock <ScriptBlock>
      -HostName <String[]>
      [-UserName <String>]
      [-KeyFilePath <String>]
      [-SSHTransport]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-Subsystem <String>]
      [<CommonParameters>]

Invoke-Command
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-RunAsAdministrator]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -ContainerId <String[]>
      [<CommonParameters>]

Invoke-Command
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-RunAsAdministrator]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -ContainerId <String[]>
      [<CommonParameters>]

Invoke-Command
      [-AsJob]
      [-HideComputerName]
      -ScriptBlock <ScriptBlock>
      -SSHConnection <Hashtable[]>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [-AsJob]
      [-HideComputerName]
      -FilePath <String>
      -HostName <String[]>
      [-UserName <String>]
      [-KeyFilePath <String>]
      [-SSHTransport]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [-AsJob]
      [-HideComputerName]
      -FilePath <String>
      -SSHConnection <Hashtable[]>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Description

Cmdleten Invoke-Command kör kommandon på en lokal dator eller fjärrdator och returnerar alla utdata från kommandona, inklusive fel. Med ett enda Invoke-Command kommando kan du köra kommandon på flera datorer.

Om du vill köra ett enda kommando på en fjärrdator använder du parametern ComputerName . Om du vill köra en serie relaterade kommandon som delar data använder du cmdleten New-PSSession för att skapa en PSSession (en beständig anslutning) på fjärrdatorn och använder sedan parametern Invoke-CommandSession för för att köra kommandot i PSSession. Om du vill köra ett kommando i en frånkopplad session använder du parametern InDisconnectedSession . Om du vill köra ett kommando i ett bakgrundsjobb använder du asjob-parametern .

Du kan också använda Invoke-Command på en lokal dator till ett skriptblock som ett kommando. PowerShell kör skriptblocket omedelbart i ett underordnat omfång för det aktuella omfånget.

Läs about_Remote innan du använder Invoke-Command för att köra kommandon på en fjärrdator.

Från och med PowerShell 6.0 kan du använda Secure Shell (SSH) för att upprätta en anslutning till och anropa kommandon på fjärrdatorer. SSH måste vara installerat på den lokala datorn och fjärrdatorn måste konfigureras med en PowerShell SSH-slutpunkt. Fördelen med en SSH-baserad PowerShell-fjärrsession är att den fungerar på flera plattformar (Windows, Linux, macOS). För SSH-baserad session använder du parametrarna HostName eller SSHConnection för att ange fjärrdatorn och relevant anslutningsinformation. Mer information om hur du konfigurerar PowerShell SSH-fjärrkommunikation finns i PowerShell-fjärrkommunikation via SSH.

Vissa kodexempel använder splatting för att minska radlängden. Mer information finns i about_Splatting.

Exempel

Exempel 1: Kör ett skript på en server

Det här exemplet kör skriptet Test.ps1 på Server01-datorn.

Invoke-Command -FilePath c:\scripts\test.ps1 -ComputerName Server01

Parametern FilePath anger ett skript som finns på den lokala datorn. Skriptet körs på fjärrdatorn och resultatet returneras till den lokala datorn.

Exempel 2: Kör ett kommando på en fjärrserver

Det här exemplet kör ett Get-Culture kommando på fjärrdatorn Server01.

Invoke-Command -ComputerName Server01 -Credential Domain01\User01 -ScriptBlock { Get-Culture }

Parametern ComputerName anger namnet på fjärrdatorn. Parametern Credential används för att köra kommandot i säkerhetskontexten för Domain01\User01, en användare som har behörighet att köra kommandon. Parametern ScriptBlock anger vilket kommando som ska köras på fjärrdatorn.

Som svar begär PowerShell lösenordet och en autentiseringsmetod för User01-kontot. Den kör sedan kommandot på Server01-datorn och returnerar resultatet.

Exempel 3: Kör ett kommando i en beständig anslutning

Det här exemplet kör samma Get-Culture kommando i en session med hjälp av en beständig anslutning på fjärrdatorn med namnet Server02.

$s = New-PSSession -ComputerName Server02 -Credential Domain01\User01
Invoke-Command -Session $s -ScriptBlock {Get-Culture}

Cmdleten New-PSSession skapar en session på server02-fjärrdatorn och sparar den i variabeln $s . Vanligtvis skapar du bara en session när du kör en serie kommandon på fjärrdatorn.

Cmdleten Invoke-CommandGet-Culture kör kommandot på Server02. Parametern Session anger den session som sparats i variabeln $s .

Som svar kör PowerShell kommandot i sessionen på Server02-datorn.

Exempel 4: Använd en session för att köra en serie kommandon som delar data

I det här exemplet jämförs effekterna av att använda parametrarna ComputerName och Session för Invoke-Command. Den visar hur du använder en session för att köra en serie kommandon som delar samma data.

Invoke-Command -ComputerName Server02 -ScriptBlock {$p = Get-Process PowerShell}
Invoke-Command -ComputerName Server02 -ScriptBlock {$p.VirtualMemorySize}
$s = New-PSSession -ComputerName Server02
Invoke-Command -Session $s -ScriptBlock {$p = Get-Process PowerShell}
Invoke-Command -Session $s -ScriptBlock {$p.VirtualMemorySize}

17930240

De två första kommandona använder parametern Invoke-CommandComputerName för för att köra kommandon på server02-fjärrdatorn. Det första kommandot använder cmdleten Get-Process för att hämta PowerShell-processen på fjärrdatorn och för att spara den i variabeln $p . Det andra kommandot hämtar värdet för egenskapen VirtualMemorySize för PowerShell-processen.

När du använder parametern ComputerName skapar PowerShell en ny session för att köra kommandot. Sessionen stängs när kommandot har slutförts. Variabeln $p skapades i en anslutning, men den finns inte i anslutningen som skapades för det andra kommandot.

Problemet löses genom att skapa en beständig session på fjärrdatorn och sedan köra båda kommandona i samma session.

Cmdleten New-PSSession skapar en beständig session på datorn Server02 och sparar sessionen i variabeln $s . Raderna Invoke-Command som följer använder parametern Session för att köra båda kommandona i samma session. Eftersom båda kommandona körs i samma session förblir $p värdet aktivt.

Exempel 5: Ange ett kommando som lagras i en lokal variabel

Det här exemplet visar hur du skapar ett kommando som lagras som ett skriptblock i en lokal variabel. När skriptblocket sparas i en lokal variabel kan du ange variabeln som värdet för parametern ScriptBlock .

$command = { Get-WinEvent -LogName PowerShellCore/Operational |
  Where-Object {$_.Message -like "*certificate*"} }
Invoke-Command -ComputerName S1, S2 -ScriptBlock $command

Variabeln $command lagrar kommandot Get-WinEvent som är formaterat som ett skriptblock. Invoke-Command kör kommandot som lagras i $command på S1- och S2-fjärrdatorerna.

Exempel 6: Kör ett enda kommando på flera datorer

Det här exemplet visar hur du använder Invoke-Command för att köra ett enda kommando på flera datorer.

$parameters = @{
  ComputerName = "Server01", "Server02", "TST-0143", "localhost"
  ConfigurationName = 'MySession.PowerShell'
  ScriptBlock = { Get-WinEvent -LogName PowerShellCore/Operational }
}
Invoke-Command @parameters

Parametern ComputerName anger en kommaavgränsad lista med datornamn. Listan över datorer innehåller värdet localhost, som representerar den lokala datorn. Parametern ConfigurationName anger en alternativ sessionskonfiguration. Parametern ScriptBlock körs Get-WinEvent för att hämta powershellcore-/drifthändelseloggarna från varje dator.

Exempel 7: Hämta versionen av värdprogrammet på flera datorer

Det här exemplet hämtar versionen av PowerShell-värdprogrammet som körs på 200 fjärrdatorer.

$version = Invoke-Command -ComputerName (Get-Content Machines.txt) -ScriptBlock {(Get-Host).Version}

Eftersom endast ett kommando körs behöver du inte skapa beständiga anslutningar till var och en av datorerna. I stället använder kommandot parametern ComputerName för att ange datorerna. För att ange datorerna använder den cmdleten Get-Content för att hämta innehållet i den Machine.txt filen, en fil med datornamn.

Cmdleten Invoke-Command kör ett Get-Host kommando på fjärrdatorerna. Den använder punktnotation för att hämta egenskapen Version för PowerShell-värden.

De här kommandona kör ett i taget. När kommandona har slutförts sparas utdata från kommandona från alla datorer i variabeln $version . Utdata innehåller namnet på den dator som data kommer från.

Exempel 8: Kör ett bakgrundsjobb på flera fjärrdatorer

Det här exemplet kör ett kommando på två fjärrdatorer. Kommandot Invoke-Command använder asjob-parametern så att kommandot körs som ett bakgrundsjobb. Kommandona körs på fjärrdatorerna, men jobbet finns på den lokala datorn. Resultaten överförs till den lokala datorn.

$s = New-PSSession -ComputerName Server01, Server02
Invoke-Command -Session $s -ScriptBlock {Get-EventLog system} -AsJob

Id   Name    State      HasMoreData   Location           Command
---  ----    -----      -----         -----------        ---------------
1    Job1    Running    True          Server01,Server02  Get-EventLog system

$j = Get-Job
$j | Format-List -Property *

HasMoreData   : True
StatusMessage :
Location      : Server01,Server02
Command       : Get-EventLog system
JobStateInfo  : Running
Finished      : System.Threading.ManualResetEvent
InstanceId    : e124bb59-8cb2-498b-a0d2-2e07d4e030ca
Id            : 1
Name          : Job1
ChildJobs     : {Job2, Job3}
Output        : {}
Error         : {}
Progress      : {}
Verbose       : {}
Debug         : {}
Warning       : {}
StateChanged  :

$results = $j | Receive-Job

Cmdleten New-PSSession skapar sessioner på fjärrdatorerna Server01 och Server02. Cmdleten Invoke-Command kör ett bakgrundsjobb i var och en av sessionerna. Kommandot använder asjob-parametern för att köra kommandot som ett bakgrundsjobb. Det här kommandot returnerar ett jobbobjekt som innehåller två underordnade jobbobjekt, ett för vart och ett av jobben som körs på de två fjärrdatorerna.

Kommandot Get-Job sparar jobbobjektet i variabeln $j . Variabeln $j skickas sedan till cmdleten Format-List för att visa alla egenskaper för jobbobjektet i en lista. Det sista kommandot hämtar resultatet av jobben. Den skickar jobbobjektet $j till cmdleten Receive-Job och lagrar resultatet i variabeln $results .

Exempel 9: Inkludera lokala variabler i en kommandokörning på en fjärrdator

Det här exemplet visar hur du inkluderar värdena för lokala variabler i en kommandokörning på en fjärrdator. Kommandot använder omfångsmodifieraren Using för att identifiera en lokal variabel i ett fjärrkommando. Som standard antas alla variabler vara definierade i fjärrsessionen. Omfångsmodifieraren Using introducerades i PowerShell 3.0. Mer information om omfångsmodifieraren Using finns i about_Remote_Variables och about_Scopes.

$Log = "PowerShellCore/Operational"
Invoke-Command -ComputerName Server01 -ScriptBlock {Get-WinEvent -LogName $Using:Log -MaxEvents 10}

Variabeln $Log lagrar namnet på händelseloggen, PowerShellCore/Operational. Cmdleten Invoke-Command körs Get-WinEvent på Server01 för att hämta de tio senaste händelserna från händelseloggen. Värdet för parametern LogName är variabeln $Log som föregås av Using omfångsmodifieraren för att indikera att den skapades i den lokala sessionen, inte i fjärrsessionen.

Exempel 10: Dölj datornamnet

Det här exemplet visar effekten av att använda parametern HideComputerName för Invoke-Command. HideComputerName ändrar inte det objekt som den här cmdleten returnerar. Den ändrar bara visningen. Du kan fortfarande använda cmdletarna Format för att visa egenskapen PsComputerName för något av de berörda objekten.

Invoke-Command -ComputerName S1, S2 -ScriptBlock {Get-Process PowerShell}

PSComputerName    Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id   ProcessName
--------------    -------  ------    -----      ----- -----   ------     --   -----------
S1                575      15        45100      40988   200     4.68     1392 PowerShell
S2                777      14        35100      30988   150     3.68     67   PowerShell

Invoke-Command -ComputerName S1, S2 -ScriptBlock {Get-Process PowerShell} -HideComputerName

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id   ProcessName
-------  ------    -----      ----- -----   ------     --   -----------
575      15        45100      40988   200     4.68     1392 PowerShell
777      14        35100      30988   150     3.68     67   PowerShell

De första två kommandona använder Invoke-Command för att köra ett Get-Process kommando för PowerShell-processen. Utdata från det första kommandot innehåller egenskapen PsComputerName , som innehåller namnet på den dator där kommandot kördes. Utdata från det andra kommandot, som använder HideComputerName, innehåller inte kolumnen PsComputerName .

Exempel 11: Använd nyckelordet Param i ett skriptblock

Nyckelordet Param och parametern ArgumentList används för att skicka variabelvärden till namngivna parametrar i ett skriptblock. Det här exemplet visar filnamn som börjar med bokstaven a och har .pdf tillägget.

Mer information om nyckelordet finns i Paramabout_Language_Keywords.

$parameters = @{
    ComputerName = "Server01"
    ScriptBlock = { Param ($param1,$param2) Get-ChildItem -Name $param1 -Include $param2 }
    ArgumentList = "a*", "*.pdf"
}
Invoke-Command @parameters

aa.pdf
ab.pdf
ac.pdf
az.pdf

Invoke-Command använder parametern ScriptBlock som definierar två variabler och $param1$param2. Get-ChildItem använder de namngivna parametrarna, Namn och Inkludera med variabelnamnen. ArgumentList skickar värdena till variablerna.

Exempel 12: Använd den $args automatiska variabeln i ett skriptblock

Den $args automatiska variabeln och parametern ArgumentList används för att skicka matrisvärden till parameterpositioner i ett skriptblock. I det här exemplet visas en servers kataloginnehåll i .txt filer. Parametern Get-ChildItemPath är position 0 och filterparametern är position 1.

Mer information om variabeln finns i $argsabout_Automatic_Variables

$parameters = @{
    ComputerName = "Server01"
    ScriptBlock = { Get-ChildItem $args[0] $args[1] }
    ArgumentList = "C:\Test", "*.txt*"
}
Invoke-Command @parameters

Directory: C:\Test

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a---           6/12/2019    15:15            128 alog.txt
-a---           7/27/2019    15:16            256 blog.txt
-a---           9/28/2019    17:10             64 zlog.txt

Invoke-Command använder en ScriptBlock-parameter och Get-ChildItem anger matrisvärdena $args[0] och $args[1] . ArgumentList skickar $args matrisvärdena till parameterpositionerna Get-ChildItem för Sökväg och Filter.

Exempel 13: Kör ett skript på alla datorer som anges i en textfil

I det här exemplet används cmdleten Invoke-Command för att köra skriptet Sample.ps1 på alla datorer som anges i Servers.txt filen. Kommandot använder parametern FilePath för att ange skriptfilen. Med det här kommandot kan du köra skriptet på fjärrdatorerna, även om skriptfilen inte är tillgänglig för fjärrdatorerna.

Invoke-Command -ComputerName (Get-Content Servers.txt) -FilePath C:\Scripts\Sample.ps1 -ArgumentList Process, Service

När du skickar kommandot kopieras innehållet i Sample.ps1 filen till ett skriptblock och skriptblocket körs på var och en av fjärrdatorerna. Den här proceduren motsvarar att använda parametern ScriptBlock för att skicka innehållet i skriptet.

Exempel 14: Kör ett kommando på en fjärrdator med hjälp av en URI

Det här exemplet visar hur du kör ett kommando på en fjärrdator som identifieras av en URI (Uniform Resource Identifier). Det här exemplet kör ett Set-Mailbox kommando på en fjärransluten Exchange-server.

$LiveCred = Get-Credential
$parameters = @{
  ConfigurationName = 'Microsoft.Exchange'
  ConnectionUri = 'https://ps.exchangelabs.com/PowerShell'
  Credential = $LiveCred
  Authentication = 'Basic'
  ScriptBlock = {Set-Mailbox Dan -DisplayName "Dan Park"}
}
Invoke-Command @parameters

Den första raden använder cmdleten Get-Credential för att lagra Windows Live ID-autentiseringsuppgifter i variabeln $LiveCred . PowerShell uppmanar användaren att ange Windows Live ID-autentiseringsuppgifter.

Variabeln $parameters är en hash-tabell som innehåller de parametrar som ska skickas till cmdleten Invoke-Command . Cmdleten Invoke-Command kör ett Set-Mailbox kommando med microsoft.Exchange-sessionskonfigurationen . Parametern ConnectionURI anger URL:en för Exchange-serverslutpunkten. Parametern Credential anger de autentiseringsuppgifter som lagras i variabeln $LiveCred . Parametern AuthenticationMechanism anger användningen av grundläggande autentisering. Parametern ScriptBlock anger ett skriptblock som innehåller kommandot .

Exempel 15: Använd ett sessionsalternativ

Det här exemplet visar hur du skapar och använder en SessionOption-parameter .

$so = New-PSSessionOption -SkipCACheck -SkipCNCheck -SkipRevocationCheck
Invoke-Command -ComputerName server01 -UseSSL -ScriptBlock { Get-HotFix } -SessionOption $so -Credential server01\user01

Cmdleten New-PSSessionOption skapar ett sessionsalternativobjekt som gör att fjärrsluten inte verifierar certifikatutfärdare, kanoniskt namn och återkallningslistor när den inkommande HTTPS-anslutningen utvärderas. SessionOption-objektet sparas i variabeln$so.

Anteckning

Det är praktiskt att inaktivera dessa kontroller för felsökning, men uppenbarligen inte säkert.

Cmdleten Invoke-Command kör ett Get-HotFix kommando via fjärranslutning. Parametern SessionOption får variabeln $so .

Exempel 16: Hantera URI-omdirigering i ett fjärrkommando

Det här exemplet visar hur du använder parametrarna AllowRedirection och SessionOption för att hantera URI-omdirigering i ett fjärrkommando.

$max = New-PSSessionOption -MaximumRedirection 1
$parameters = @{
  ConnectionUri = "https://ps.exchangelabs.com/PowerShell"
  ScriptBlock = { Get-Mailbox dan }
  AllowRedirection = $true
  SessionOption = $max
}
Invoke-Command @parameters

Cmdleten New-PSSessionOption skapar ett PSSessionOption-objekt som sparas i variabeln $max . Kommandot använder parametern MaximumRedirection för att ange egenskapen MaximumConnectionRedirectionCount för PSSessionOption-objektet till 1.

Cmdleten Invoke-Command kör ett Get-Mailbox kommando på en fjärransluten Microsoft Exchange Server. Parametern AllowRedirection ger uttrycklig behörighet att omdirigera anslutningen till en alternativ slutpunkt. Parametern SessionOption använder sessionsobjektet som lagras i variabeln $max .

Om fjärrdatorn som anges av ConnectionURI returnerar ett omdirigeringsmeddelande omdirigerar PowerShell anslutningen, men om det nya målet returnerar ett annat omdirigeringsmeddelande överskrids omdirigeringsvärdet 1 och Invoke-Command returnerar ett icke-avslutande fel.

Exempel 17: Få åtkomst till en nätverksresurs i en fjärrsession

Det här exemplet visar hur du får åtkomst till en nätverksresurs från en fjärrsession. Tre datorer används för att demonstrera exemplet. Server01 är den lokala datorn, Server02 är fjärrdatorn och Net03 innehåller nätverksresursen. Server01 ansluter till Server02 och sedan gör Server02 ett andra hopp till Net03 för att få åtkomst till nätverksresursen. Mer information om hur PowerShell-fjärrkommunikation stöder hopp mellan datorer finns i Göra det andra hoppet i PowerShell-fjärrkommunikation.

Den nödvändiga credential Security Support Provider (CredSSP) delegering är aktiverad i klientinställningarna på den lokala datorn och i tjänstinställningarna på fjärrdatorn. Om du vill köra kommandona i det här exemplet måste du vara medlem i gruppen Administratörer på den lokala datorn och fjärrdatorn.

Enable-WSManCredSSP -Role Client -DelegateComputer Server02
$s = New-PSSession Server02
Invoke-Command -Session $s -ScriptBlock {Enable-WSManCredSSP -Role Server -Force}
$parameters = @{
  Session = $s
  ScriptBlock = { Get-Item \\Net03\Scripts\LogFiles.ps1 }
  Authentication = "CredSSP"
  Credential = "Domain01\Admin01"
}
Invoke-Command @parameters

Cmdleten Enable-WSManCredSSP aktiverar CredSSP-delegering från den lokala Server01-datorn till server02-fjärrdatorn. Parametern Roll anger klienten för att konfigurera CredSSP-klientinställningen på den lokala datorn.

New-PSSession skapar ett PSSession-objekt för Server02 och lagrar objektet i variabeln $s .

Cmdleten Invoke-Command använder variabeln $s för att ansluta till fjärrdatorn Server02. Parametern ScriptBlock körs Enable-WSManCredSSP på fjärrdatorn. Parametern Roll anger Server för att konfigurera CredSSP-serverinställningen på fjärrdatorn.

Variabeln $parameters innehåller parametervärdena för att ansluta till nätverksresursen. Cmdleten Invoke-Command kör ett Get-Item kommando i sessionen i $s. Det här kommandot hämtar ett skript från nätverksresursen \\Net03\Scripts . Kommandot använder parametern Authentication med värdet CredSSP och parametern Credential med värdet Domain01\Admin01.

Exempel 18: Starta skript på många fjärrdatorer

Det här exemplet kör ett skript på fler än hundra datorer. För att minimera påverkan på den lokala datorn ansluter den till varje dator, startar skriptet och kopplar sedan från varje dator. Skriptet fortsätter att köras i de frånkopplade sessionerna.

$parameters = @{
  ComputerName = (Get-Content -Path C:\Test\Servers.txt)
  InDisconnectedSession = $true
  FilePath = "\\Scripts\Public\ConfigInventory.ps1"
  SessionOption = @{OutputBufferingMode="Drop";IdleTimeout=43200000}
}
Invoke-Command @parameters

Kommandot använder Invoke-Command för att köra skriptet. Värdet för parametern ComputerName är ett Get-Content kommando som hämtar namnen på fjärrdatorerna från en textfil. Parametern InDisconnectedSession kopplar från sessionerna så snart kommandot startas. Värdet för FilePath-parametern är skriptet som Invoke-Command körs på varje dator.

Värdet för SessionOption är en hash-tabell. Värdet OutputBufferingMode är inställt på Släpp och värdet IdleTimeout är inställt på 43200000 millisekunder (12 timmar).

Använd cmdleten Receive-PSSession för att hämta resultatet av kommandon och skript som körs i frånkopplade sessioner.

Exempel 19: Kör ett kommando på en fjärrdator med hjälp av SSH

Det här exemplet visar hur du kör ett kommando på en fjärrdator med hjälp av Secure Shell (SSH). Om SSH har konfigurerats på fjärrdatorn för att fråga efter lösenord får du en lösenordsprompt. Annars måste du använda SSH-nyckelbaserad användarautentisering.

Invoke-Command -HostName UserA@LinuxServer01 -ScriptBlock { Get-MailBox * }

Exempel 20: Kör ett kommando på en fjärrdator med hjälp av SSH och ange en användarautentiseringsnyckel

Det här exemplet visar hur du kör ett kommando på en fjärrdator med hjälp av SSH och anger en nyckelfil för användarautentisering. Du uppmanas inte att ange ett lösenord om inte nyckelautentiseringen misslyckas och fjärrdatorn har konfigurerats för att tillåta grundläggande lösenordsautentisering.

Invoke-Command -HostName UserA@LinuxServer01 -ScriptBlock { Get-MailBox * } -KeyFilePath /UserA/UserAKey_rsa

Exempel 21: Kör en skriptfil på flera fjärrdatorer med SSH som jobb

Det här exemplet visar hur du kör en skriptfil på flera fjärrdatorer med hjälp av SSH och parameteruppsättningen SSHConnection . Parametern SSHConnection tar en matris med hash-tabeller som innehåller anslutningsinformation för varje dator. Det här exemplet kräver att mål-fjärrdatorerna har SSH konfigurerat för att stödja nyckelbaserad användarautentisering.

$sshConnections =
@{ HostName="WinServer1"; UserName="Domain\UserA"; KeyFilePath="C:\Users\UserA\id_rsa" },
@{ HostName="UserB@LinuxServer5"; KeyFilePath="/Users/UserB/id_rsa" }
$results = Invoke-Command -FilePath c:\Scripts\CollectEvents.ps1 -SSHConnection $sshConnections

Parametrar

-AllowRedirection

Tillåter omdirigering av den här anslutningen till en alternativ URI (Uniform Resource Identifier).

När du använder parametern ConnectionURI kan fjärrmålet returnera en instruktion för att omdirigera till en annan URI. Som standard omdirigerar PowerShell inte anslutningar, men du kan använda den här parametern för att omdirigera anslutningen.

Du kan också begränsa antalet gånger som anslutningen omdirigeras genom att ändra sessionsalternativvärdet MaximumConnectionRedirectionCount . Använd parametern MaximumRedirection för cmdleten New-PSSessionOption eller ange egenskapen MaximumConnectionRedirectionCount för inställningsvariabeln $PSSessionOption . Standardvärdet är 5.

Type:	SwitchParameter
Position:	Named
Default value:	False
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-ApplicationName

Anger programnamnsegmentet för anslutnings-URI:n. Använd den här parametern för att ange programnamnet när du inte använder parametern ConnectionURI i kommandot .

Standardvärdet är värdet för $PSSessionApplicationName inställningsvariabeln på den lokala datorn. Om den här inställningsvariabeln inte har definierats är standardvärdet WSMAN. Det här värdet är lämpligt för de flesta användningsområden. Mer information finns i about_Preference_Variables.

WinRM-tjänsten använder programnamnet för att välja en lyssnare som ska betjäna anslutningsbegäran. Värdet för den här parametern ska matcha värdet för egenskapen URLPrefix för en lyssnare på fjärrdatorn.

Type:	String
Position:	Named
Default value:	$PSSessionApplicationName if set on the local computer, otherwise WSMAN
Required:	False
Accept pipeline input:	True
Accept wildcard characters:	False

-ArgumentList

Tillhandahåller värdena för lokala variabler i kommandot . Variablerna i kommandot ersätts av dessa värden innan kommandot körs på fjärrdatorn. Ange värdena i en kommaavgränsad lista. Värden är associerade med variabler i den ordning som de visas. Aliaset för ArgumentList är Args.

Värdena i parametern ArgumentList kan vara faktiska värden, till exempel 1024, eller så kan de vara referenser till lokala variabler, till exempel $max.

Använd följande kommandoformat för att använda lokala variabler i ett kommando:

{param($<name1>[, $<name2>]...) <command-with-local-variables>} -ArgumentList <value> -eller- <local-variable>

Nyckelordet param visar de lokala variabler som används i kommandot . ArgumentList tillhandahåller värdena för variablerna i den ordning de visas. Mer information om beteendet för ArgumentList finns i about_Splatting.

Type:	Object[]
Aliases:	Args
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-AsJob

Anger att den här cmdleten kör kommandot som ett bakgrundsjobb på en fjärrdator. Använd den här parametern för att köra kommandon som tar lång tid att slutföra.

När du använder asjob-parametern returnerar kommandot ett objekt som representerar jobbet och visar sedan kommandotolken. Du kan fortsätta att arbeta i sessionen medan jobbet är klart. Om du vill hantera jobbet använder du *-Job cmdletarna. Använd cmdleten för att hämta jobbresultatet Receive-Job .

AsJob-parametern liknar att använda cmdleten Invoke-Command för att köra en Start-Job cmdlet via en fjärranslutning. Men med AsJob skapas jobbet på den lokala datorn, även om jobbet körs på en fjärrdator. Resultatet av fjärrjobbet returneras automatiskt till den lokala datorn.

Mer information om PowerShell-bakgrundsjobb finns i about_Jobs och about_Remote_Jobs.

Type:	SwitchParameter
Position:	Named
Default value:	False
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-Authentication

Anger den mekanism som används för att autentisera användarens autentiseringsuppgifter. CredSSP-autentisering är endast tillgängligt i Windows Vista, Windows Server 2008 och senare versioner av Windows-operativsystemet.

Godkända värden för den här parametern är följande:

• Standardvärde
• Basic
• Credssp
• Sammandrag
• Kerberos
• Negotiate
• NegotiateWithImplicitCredential

Standardvärdet är Standard.

Mer information om värdena för den här parametern finns i AuthenticationMechanism Enumeration.

Varning

CredSSP-autentisering (CredSSP), där användarens autentiseringsuppgifter skickas till en fjärrdator som ska autentiseras, är utformad för kommandon som kräver autentisering på mer än en resurs, till exempel åtkomst till en fjärrnätverksresurs. Den här mekanismen ökar säkerhetsrisken för fjärråtgärden. Om fjärrdatorn komprometteras kan de autentiseringsuppgifter som skickas till den användas för att styra nätverkssessionen. Mer information finns i Provider för säkerhetssupport för autentiseringsuppgifter.

Type:	AuthenticationMechanism
Accepted values:	Basic, Default, Credssp, Digest, Kerberos, Negotiate, NegotiateWithImplicitCredential
Position:	Named
Default value:	Default
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-CertificateThumbprint

Anger det digitala offentliga nyckelcertifikatet (X509) för ett användarkonto som har behörighet att ansluta till den frånkopplade sessionen. Ange certifikatets tumavtryck.

Certifikat används i klientcertifikatbaserad autentisering. De kan endast mappas till lokala användarkonton och de fungerar inte med domänkonton.

Om du vill hämta ett certifikats tumavtryck använder du ett Get-Item eller Get-ChildItem -kommando i PowerShell Cert: -enheten.

Type:	String
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-ComputerName

Anger de datorer som kommandot körs på. Standard är den lokala datorn.

När du använder parametern ComputerName skapar PowerShell en tillfällig anslutning som endast används för att köra det angivna kommandot och stängs sedan. Om du behöver en beständig anslutning använder du parametern Session .

Ange NETBIOS-namn, IP-adress eller fullständigt domännamn för en eller flera datorer i en kommaavgränsad lista. Om du vill ange den lokala datorn skriver du datornamnet, localhost eller en punkt (.).

Om du vill använda en IP-adress i värdet för ComputerName måste kommandot innehålla parametern Credential . Datorn måste konfigureras för HTTPS-transporten, eller så måste IP-adressen för fjärrdatorn finnas med i den lokala datorns WinRM TrustedHosts-lista . Anvisningar om hur du lägger till ett datornamn i listan TrustedHosts finns i Så här lägger du till en dator i listan Betrodd värd.

I Windows Vista och senare versioner av Windows-operativsystemet måste du köra PowerShell med alternativet Kör som administratör för att inkludera den lokala datorn i värdet ComputerName.

Type:	String[]
Aliases:	Cn
Position:	0
Default value:	Local computer
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-ConfigurationName

Anger sessionskonfigurationen som används för den nya PSSessionen.

Ange ett konfigurationsnamn eller en fullständigt kvalificerad resurs-URI för en sessionskonfiguration. Om du bara anger konfigurationsnamnet läggs följande schema-URI till: https://schemas.microsoft.com/PowerShell.

När den här parametern används med SSH anger den delsystem som ska användas på målet enligt definitionen i sshd_config. Standardvärdet för SSH är powershell undersystemet.

Sessionskonfigurationen för en session finns på fjärrdatorn. Om den angivna sessionskonfigurationen inte finns på fjärrdatorn misslyckas kommandot.

Standardvärdet är värdet för $PSSessionConfigurationName inställningsvariabeln på den lokala datorn. Om den här inställningsvariabeln inte har angetts är standardvärdet Microsoft.PowerShell. Mer information finns i about_Preference_Variables.

Type:	String
Position:	Named
Default value:	$PSSessionConfigurationName if set on the local computer, otherwise Microsoft.PowerShell
Required:	False
Accept pipeline input:	True
Accept wildcard characters:	False

-ConnectionUri

Anger en URI (Uniform Resource Identifier) som definierar sessionens anslutningsslutpunkt. URI:n måste vara fullständigt kvalificerad.

Formatet för den här strängen är följande:

<Transport>://<ComputerName>:<Port>/<ApplicationName>

Standardvärdet är följande:

https://localhost:5985/WSMAN

Om du inte anger en anslutnings-URI kan du använda parametrarna UseSSL och Port för att ange anslutnings-URI-värdena.

Giltiga värden för transportsegmentet för URI:n är HTTP och HTTPS. Om du anger en anslutnings-URI med ett transportsegment, men inte anger någon port, skapas sessionen med standardportarna: 80 för HTTP och 443 för HTTPS. Om du vill använda standardportarna för PowerShell-fjärrkommunikation anger du port 5985 för HTTP eller 5986 för HTTPS.

Om måldatorn omdirigerar anslutningen till en annan URI förhindrar PowerShell omdirigeringen om du inte använder parametern AllowRedirection i kommandot.

Type:	Uri[]
Aliases:	URI, CU
Position:	0
Default value:	https://localhost:5985/WSMAN
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-ContainerId

Anger en matris med container-ID:t.

Type:	String[]
Position:	Named
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-Credential

Anger ett användarkonto som har behörighet att utföra den här åtgärden. Standard är den aktuella användaren.

Ange ett användarnamn, till exempel User01 eller Domain01\User01, eller ange ett PSCredential-objekt som genereras av cmdleten Get-Credential . Om du skriver ett användarnamn uppmanas du att ange lösenordet.

Autentiseringsuppgifter lagras i ett PSCredential-objekt och lösenordet lagras som en SecureString.

Anteckning

Mer information om SecureString-dataskydd finns i Hur säker är SecureString?.

Type:	PSCredential
Position:	Named
Default value:	Current user
Required:	False
Accept pipeline input:	True
Accept wildcard characters:	False

-EnableNetworkAccess

Anger att den här cmdleten lägger till en interaktiv säkerhetstoken i loopback-sessioner. Med den interaktiva token kan du köra kommandon i loopback-sessionen som hämtar data från andra datorer. Du kan till exempel köra ett kommando i sessionen som kopierar XML-filer från en fjärrdator till den lokala datorn.

En loopback-session är en PSSession som kommer från och slutar på samma dator. Om du vill skapa en loopback-session utelämnar du parametern ComputerName eller anger dess värde till punkt (.), localhost eller namnet på den lokala datorn.

Som standard skapas loopback-sessioner med hjälp av en nätverkstoken, vilket kanske inte ger tillräcklig behörighet för att autentisera till fjärrdatorer.

Parametern EnableNetworkAccess gäller endast i loopback-sessioner. Om du använder EnableNetworkAccess när du skapar en session på en fjärrdator lyckas kommandot, men parametern ignoreras.

Du kan tillåta fjärråtkomst i en loopback-session med credSSP-värdet för parametern Authentication , som delegerar sessionsautentiseringsuppgifterna till andra datorer.

För att skydda datorn mot skadlig åtkomst kan frånkopplade loopback-sessioner som har interaktiva token, som är de som skapats med EnableNetworkAccess, endast återanslutas från den dator där sessionen skapades. Frånkopplade sessioner som använder CredSSP-autentisering kan återanslutas från andra datorer. Mer information finns i Disconnect-PSSession.

Den här parametern introducerades i PowerShell 3.0.

Type:	SwitchParameter
Position:	Named
Default value:	False
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-FilePath

Anger ett lokalt skript som den här cmdleten körs på en eller flera fjärrdatorer. Ange sökvägen och filnamnet för skriptet eller skicka en skriptsökväg till Invoke-Command. Skriptet måste finnas på den lokala datorn eller i en katalog som den lokala datorn kan komma åt. Använd ArgumentList för att ange värden för parametrar i skriptet.

När du använder den här parametern konverterar PowerShell innehållet i den angivna skriptfilen till ett skriptblock, överför skriptblocket till fjärrdatorn och kör det på fjärrdatorn.

Type:	String
Aliases:	PSPath
Position:	1
Default value:	None
Required:	True
Accept pipeline input:	False
Accept wildcard characters:	False

-HideComputerName

Anger att denna cmdlet utelämnar datornamnet för varje objekt från utdatavisningen. Som standard visas namnet på den dator som genererade objektet i displayen.

Den här parametern påverkar endast utdatavisningen. Objektet ändras inte.

Type:	SwitchParameter
Aliases:	HCN
Position:	Named
Default value:	False
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-HostName

Anger en matris med datornamn för en SSH-baserad anslutning (Secure Shell). Detta liknar parametern ComputerName förutom att anslutningen till fjärrdatorn görs med hjälp av SSH i stället för Windows WinRM.

Den här parametern introducerades i PowerShell 6.0.

Type:	String[]
Position:	Named
Default value:	None
Required:	True
Accept pipeline input:	False
Accept wildcard characters:	False

-InDisconnectedSession

Anger att den här cmdleten kör ett kommando eller skript i en frånkopplad session.

När du använder parametern Invoke-CommandInDisconnectedSession skapar du en beständig session på varje fjärrdator, startar kommandot som anges av parametern ScriptBlock eller FilePath och kopplar sedan från sessionen. Kommandona fortsätter att köras i de frånkopplade sessionerna. Med InDisconnectedSession kan du köra kommandon utan att upprätthålla en anslutning till fjärrsessionerna. Och eftersom sessionen är frånkopplad innan några resultat returneras ser InDisconnectedSession till att alla kommandoresultat returneras till den återanslutna sessionen i stället för att delas upp mellan sessioner.

Du kan inte använda InDisconnectedSession med parametern Session eller asjob-parametern .

Kommandon som använder InDisconnectedSession returnerar ett PSSession-objekt som representerar den frånkopplade sessionen. De returnerar inte kommandoutdata. Om du vill ansluta till den frånkopplade sessionen använder du Connect-PSSession cmdletarna eller Receive-PSSession . Använd cmdleten Receive-PSSession för att hämta resultatet av kommandon som kördes i sessionen. Om du vill köra kommandon som genererar utdata i en frånkopplad session anger du värdet för sessionsalternativet OutputBufferingMode till Släpp. Om du tänker ansluta till den frånkopplade sessionen anger du tidsgränsen för inaktivitet i sessionen så att det ger tillräckligt med tid för att ansluta innan du tar bort sessionen.

Du kan ange utdatabuffertningsläget och tidsgränsen för inaktivitet i parametern SessionOption eller i inställningsvariabeln $PSSessionOption . Mer information om sessionsalternativ finns i New-PSSessionOption och about_Preference_Variables.

Mer information om funktionen Frånkopplade sessioner finns i about_Remote_Disconnected_Sessions.

Den här parametern introducerades i PowerShell 3.0.

Type:	SwitchParameter
Aliases:	Disconnected
Position:	Named
Default value:	False
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-InputObject

Anger indata till kommandot. Ange en variabel som innehåller objekten eller skriv ett kommando eller uttryck som hämtar objekten.

När du använder parametern InputObject använder du den $Input automatiska variabeln i värdet för parametern ScriptBlock för att representera indataobjekten.

Type:	PSObject
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	True
Accept wildcard characters:	False

-JobName

Anger ett eget namn för bakgrundsjobbet. Som standard heter Job<n>jobb , där <n> är ett ordningstal.

Om du använder jobname-parametern i ett kommando körs kommandot som ett jobb och Invoke-Command returnerar ett jobbobjekt, även om du inte inkluderar AsJob i kommandot .

Mer information om PowerShell-bakgrundsjobb finns i about_Jobs.

Type:	String
Position:	Named
Default value:	Job<n>
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-KeyFilePath

Anger en nyckelfilsökväg som används av Secure Shell (SSH) för att autentisera en användare på en fjärrdator.

Med SSH kan användarautentisering utföras via privata och offentliga nycklar som ett alternativ till grundläggande lösenordsautentisering. Om fjärrdatorn har konfigurerats för nyckelautentisering kan den här parametern användas för att ange nyckeln som identifierar användaren.

Den här parametern introducerades i PowerShell 6.0.

Type:	String
Aliases:	IdentityFilePath
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-NoNewScope

Anger att den här cmdleten kör det angivna kommandot i det aktuella omfånget. Kör som standard Invoke-Command kommandon i sitt eget omfång.

Den här parametern är endast giltig i kommandon som körs i den aktuella sessionen, dvs. kommandon som utelämnar både parametrarna ComputerName och Session .

Den här parametern introducerades i PowerShell 3.0.

Type:	SwitchParameter
Position:	Named
Default value:	False
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-Port

Anger nätverksporten på fjärrdatorn som används för det här kommandot. För att ansluta till en fjärrdator måste fjärrdatorn lyssna på porten som anslutningen använder. Standardportarna är 5985 (WinRM-port för HTTP) och 5986 (WinRM-port för HTTPS).

Innan du använder en alternativ port konfigurerar du WinRM-lyssnaren på fjärrdatorn för att lyssna på den porten. Om du vill konfigurera lyssnaren skriver du följande två kommandon i PowerShell-prompten:

Remove-Item -Path WSMan:\Localhost\listener\listener* -Recurse

New-Item -Path WSMan:\Localhost\listener -Transport http -Address * -Port \<port-number\>

Använd inte portparametern om du inte måste. Porten som anges i kommandot gäller för alla datorer eller sessioner där kommandot körs. En alternativ portinställning kan förhindra att kommandot körs på alla datorer.

Type:	Int32
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-RemoteDebug

Används för att köra det anropade kommandot i felsökningsläge i powershell-fjärrsessionen.

Type:	SwitchParameter
Position:	Named
Default value:	False
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-RunAsAdministrator

Anger att den här cmdleten anropar ett kommando som administratör.

Type:	SwitchParameter
Position:	Named
Default value:	False
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-ScriptBlock

Anger vilka kommandon som ska köras. Omslut kommandona i klammerparenteser { } för att skapa ett skriptblock. Den här parametern krävs.

Som standard utvärderas alla variabler i kommandot på fjärrdatorn. Om du vill inkludera lokala variabler i kommandot använder du ArgumentList.

Type:	ScriptBlock
Aliases:	Command
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	False
Accept wildcard characters:	False

-Session

Anger en matris med sessioner där den här cmdleten kör kommandot. Ange en variabel som innehåller PSSession-objekt eller ett kommando som skapar eller hämtar PSSession-objekt , till exempel ett New-PSSession eller Get-PSSession ett kommando.

När du skapar en PSSession upprättar PowerShell en beständig anslutning till fjärrdatorn. Använd en PSSession för att köra en serie relaterade kommandon som delar data. Om du vill köra ett enda kommando eller en serie orelaterade kommandon använder du parametern ComputerName . Mer information finns i about_PSSessions.

Type:	PSSession[]
Position:	0
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-SessionName

Anger ett eget namn för en frånkopplad session. Du kan använda namnet för att referera till sessionen i efterföljande kommandon, till exempel ett Get-PSSession kommando. Den här parametern är endast giltig med parametern InDisconnectedSession .

Den här parametern introducerades i PowerShell 3.0.

Type:	String[]
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-SessionOption

Anger avancerade alternativ för sessionen. Ange ett SessionOption-objekt , till exempel ett objekt som du skapar med hjälp av cmdleten New-PSSessionOption eller en hash-tabell där nycklarna är sessionsalternativnamn och värdena är sessionsalternativvärden.

Standardvärdena för alternativen bestäms av värdet för $PSSessionOption inställningsvariabeln, om den har angetts. Annars upprättas standardvärdena av de alternativ som anges i sessionskonfigurationen.

Sessionsalternativvärdena har företräde framför standardvärden för sessioner som anges i inställningsvariabeln $PSSessionOption och i sessionskonfigurationen. De har dock inte företräde framför maximala värden, kvoter eller gränser som angetts i sessionskonfigurationen.

En beskrivning av sessionsalternativen som innehåller standardvärdena finns i New-PSSessionOption. Information om inställningsvariabeln $PSSessionOption finns i about_Preference_Variables. För ytterligare information om sessionskonfigurationer, se about_Session_Configurations.

Type:	PSSessionOption
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-SSHConnection

Den här parametern tar en matris med hash-tabeller där varje hash-tabell innehåller en eller flera anslutningsparametrar som behövs för att upprätta en SSH-anslutning (Secure Shell). Parametern SSHConnection är användbar för att skapa flera sessioner där varje session kräver olika anslutningsinformation.

Hashtabellen har följande medlemmar:

• ComputerName (eller HostName)
• Port
• Användarnamn
• KeyFilePath (eller IdentityFilePath)

ComputerName (eller HostName) är det enda nyckel/värde-par som krävs.

Den här parametern introducerades i PowerShell 6.0.

Type:	Hashtable[]
Position:	Named
Default value:	None
Required:	True
Accept pipeline input:	False
Accept wildcard characters:	False

-SSHTransport

Anger att fjärranslutningen upprättas med secure shell (SSH).

Som standard använder PowerShell Windows WinRM för att ansluta till en fjärrdator. Den här växeln tvingar PowerShell att använda parametern HostName för att upprätta en SSH-baserad fjärranslutning.

Den här parametern introducerades i PowerShell 6.0.

Type:	SwitchParameter
Accepted values:	true
Position:	Named
Default value:	False
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-Subsystem

Anger det SSH-undersystem som används för den nya PSSessionen.

Detta anger det undersystem som ska användas på målet enligt definitionen i sshd_config. Undersystemet startar en specifik version av PowerShell med fördefinierade parametrar. Om det angivna undersystemet inte finns på fjärrdatorn misslyckas kommandot.

Om den här parametern inte används är standardvärdet undersystemet "powershell".

Type:	String
Position:	Named
Default value:	powershell
Required:	False
Accept pipeline input:	True
Accept wildcard characters:	False

-ThrottleLimit

Anger det maximala antalet samtidiga anslutningar som kan upprättas för att köra det här kommandot. Om du utelämnar den här parametern eller anger värdet 0 används standardvärdet 32.

Begränsningsgränsen gäller endast för det aktuella kommandot, inte för sessionen eller datorn.

Type:	Int32
Position:	Named
Default value:	32
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-UserName

Anger användarnamnet för kontot som används för att köra ett kommando på fjärrdatorn. Användarautentiseringsmetoden beror på hur Secure Shell (SSH) konfigureras på fjärrdatorn.

Om SSH har konfigurerats för grundläggande lösenordsautentisering uppmanas du att ange användarlösenordet.

Om SSH har konfigurerats för nyckelbaserad användarautentisering kan en nyckelfilsökväg anges via parametern KeyFilePath och ingen lösenordsprompt inträffar. Om klientanvändarnyckelfilen finns på en känd SSH-plats behövs inte parametern KeyFilePath för nyckelbaserad autentisering, och användarautentisering sker automatiskt baserat på användarnamnet. Mer information finns i din plattforms SSH-dokumentation om nyckelbaserad användarautentisering.

Det här är inte en obligatorisk parameter. Om parametern UserName inte har angetts används det aktuella inloggade användarnamnet för anslutningen.

Den här parametern introducerades i PowerShell 6.0.

Type:	String
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-UseSSL

Anger att den här cmdleten använder SSL-protokollet (Secure Sockets Layer) för att upprätta en anslutning till fjärrdatorn. Som standard används inte SSL.

WS-Management krypterar allt PowerShell-innehåll som överförs via nätverket. Parametern UseSSL är ett ytterligare skydd som skickar data över en HTTPS i stället för HTTP.

Om du använder den här parametern, men SSL inte är tillgängligt på porten som används för kommandot, misslyckas kommandot.

Type:	SwitchParameter
Position:	Named
Default value:	False
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-VMId

Anger en matris med ID:t för virtuella datorer.

Type:	Guid[]
Aliases:	VMGuid
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-VMName

Anger en matris med namn på virtuella datorer.

Type:	String[]
Position:	Named
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

Indata

ScriptBlock

Du kan skicka ett kommando i ett skriptblock till Invoke-Command. Använd den $Input automatiska variabeln för att representera indataobjekten i kommandot.

Utdata

System.Management.Automation.PSRemotingJob, System.Management.Automation.Runspaces.PSSession, or the output of the invoked command

Den här cmdleten returnerar ett jobbobjekt om du använder asjob-parametern . Om du anger parametern Invoke-CommandInDisconnectedSession returnerar ett PSSession-objekt. Annars returneras utdata från det anropade kommandot, vilket är värdet för parametern ScriptBlock .

Kommentarer

Om du vill använda parametern Invoke-CommandComputerName för att köra ett kommando på den lokala datorn måste du köra PowerShell med alternativet Kör som administratör i Windows Vista och senare versioner av Windows-operativsystemet.

När du kör kommandon på flera datorer ansluter PowerShell till datorerna i den ordning de visas i listan. Kommandoutdata visas dock i den ordning som de tas emot från fjärrdatorerna, vilket kan vara annorlunda.

Fel som uppstår från kommandot som Invoke-Command körs ingår i kommandoresultatet. Fel som skulle avsluta fel i ett lokalt kommando behandlas som icke-avslutande fel i ett fjärrkommando. Den här strategin ser till att avslutande fel på en dator inte stänger kommandot på alla datorer där den körs. Den här metoden används även när ett fjärrkommando körs på en enda dator.

Om fjärrdatorn inte finns i en domän som den lokala datorn litar på kanske datorn inte kan autentisera användarens autentiseringsuppgifter. Om du vill lägga till fjärrdatorn i listan över betrodda värdar i WS-Management använder du följande kommando i providern WSMAN , där <Remote-Computer-Name> är namnet på fjärrdatorn:

Set-Item -Path WSMan:\Localhost\Client\TrustedHosts -Value \<Remote-Computer-Name\>

När du kopplar från en PSSession med parametern InDisconnectedSession är sessionstillståndet Frånkopplat och tillgängligheten är Ingen. Värdet för egenskapen State är i förhållande till den aktuella sessionen. Värdet Frånkopplad innebär att PSSession inte är ansluten till den aktuella sessionen. Det betyder dock inte att PSSession är frånkopplad från alla sessioner. Den kan vara ansluten till en annan session. Om du vill avgöra om du kan ansluta eller återansluta till sessionen använder du egenskapen Tillgänglighet .

Ett tillgänglighetsvärdepå Ingen anger att du kan ansluta till sessionen. Värdet Upptagen anger att du inte kan ansluta till PSSession eftersom den är ansluten till en annan session. Mer information om värdena för egenskapen State för sessioner finns i RunspaceState. Mer information om värdena för egenskapen Tillgänglighet för sessioner finns i RunspaceAvailability.

Parametrarna HostName och SSHConnection inkluderades från och med PowerShell 6.0. De har lagts till för att tillhandahålla PowerShell-fjärrkommunikation baserat på Secure Shell (SSH). PowerShell och SSH stöds på flera plattformar (Windows, Linux, macOS) och PowerShell-fjärrkommunikation fungerar på dessa plattformar där PowerShell och SSH installeras och konfigureras. Detta är separat från den tidigare Windows-fjärrkommunikationen som baseras på WinRM och många av WinRM-specifika funktioner och begränsningar gäller inte. WinRM-baserade kvoter, sessionsalternativ, konfiguration av anpassade slutpunkter och funktioner för frånkoppling/återanslutning stöds för närvarande inte. Mer information om hur du konfigurerar PowerShell SSH-fjärrkommunikation finns i PowerShell-fjärrkommunikation via SSH.

Relaterade länkar

• about_PSSessions
• about_Remote
• about_Remote_Disconnected_Sessions
• about_Remote_Troubleshooting
• about_Remote_Variables
• about_Scopes
• Enter-PSSession
• Exit-PSSession
• Get-PSSession
• Invoke-Item
• New-PSSession
• Remove-PSSession
• WSMan-provider