Condividi tramite

Eseguire il debug localmente delle Azure Functions di PowerShell

Funzioni di Azure consentono di sviluppare le funzioni come script di PowerShell.

È possibile eseguire il debug delle funzioni di PowerShell in locale come qualsiasi script di PowerShell usando gli strumenti di sviluppo standard seguenti:

  • Visual Studio Code: editor di testo gratuito, leggero e open source di Microsoft con l'estensione PowerShell che offre un'esperienza di sviluppo completa di PowerShell.
  • Una console di PowerShell: eseguire il debug usando gli stessi comandi usati per eseguire il debug di qualsiasi altro processo di PowerShell.

Azure Functions Core Tools supporta il debug locale di Funzioni di Azure, incluse le funzioni di PowerShell.

App di esempio per funzioni

L'app per le funzioni usata in questo articolo include una singola funzione attivata tramite HTTP e include i file seguenti:

PSFunctionApp
 | - HttpTriggerFunction
 | | - run.ps1
 | | - function.json
 | - local.settings.json
 | - host.json
 | - profile.ps1

Questa app per le funzioni è simile a quella che si ottiene quando si completa l'avvio rapido di PowerShell.

Il codice della funzione in run.ps1 è simile allo script seguente:

param($Request)

$name = $Request.Query.Name

if($name) {
    $status = 200
    $body = "Hello $name"
}
else {
    $status = 400
    $body = "Please pass a name on the query string or in the request body."
}

Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = $status
    Body = $body
})

Impostare il punto di collegamento

Per eseguire il debug di qualsiasi funzione di PowerShell, è necessario arrestare la funzione affinché il debugger sia collegato. Il Wait-Debugger cmdlet arresta l'esecuzione e attende il debugger.

Annotazioni

Quando si usa PowerShell 7, non è necessario aggiungere la Wait-Debugger chiamata nel codice.

È sufficiente aggiungere una chiamata al Wait-Debugger cmdlet appena sopra l'istruzione if , come indicato di seguito:

param($Request)

$name = $Request.Query.Name

# This is where we will wait for the debugger to attach
Wait-Debugger

if($name) {
    $status = 200
    $body = "Hello $name"
}
# ...

Il debug inizia dall'istruzione if .

Con Wait-Debugger in funzione, ora è possibile eseguire il debug delle funzioni usando Visual Studio Code o una console di PowerShell.

Debugging in Visual Studio Code

Per eseguire il debug delle funzioni di PowerShell in Visual Studio Code, è necessario avere installato quanto segue:

Dopo aver installato queste dipendenze, caricare un progetto di Funzioni di PowerShell esistente o creare il primo progetto di Funzioni di PowerShell.

Annotazioni

Se il progetto non dispone dei file di configurazione necessari, viene richiesto di aggiungerli.

Impostare la versione di PowerShell

PowerShell Core si installa affianco a Windows PowerShell. Impostare PowerShell Core come versione di PowerShell da usare con l'estensione PowerShell per Visual Studio Code.

  1. Premere F1 per visualizzare il pallet dei comandi, quindi cercare Session.

  2. Scegliere PowerShell: Mostra menu sessione.

  3. Se la sessione corrente non è PowerShell Core 6, scegliere Passa a: PowerShell Core 6.

Quando si apre un file di PowerShell, viene visualizzata la versione in verde nella parte inferiore destra della finestra. Selezionando questo testo viene visualizzato anche il menu della sessione. Per altre informazioni, vedere Scelta di una versione di PowerShell da usare con l'estensione.

Avviare l'app per le funzioni

Verificare che Wait-Debugger sia impostato nella funzione in cui si vuole collegare il debugger. Con l'aggiunta di Wait-Debugger, è possibile eseguire il debug della tua app per le funzioni utilizzando Visual Studio Code.

Scegliere il riquadro Debug e quindi Collega alla funzione PowerShell.

debugger

È anche possibile premere F5 per avviare il debug.

L'operazione di avvio del debug esegue le attività seguenti:

  • Viene eseguito func extensions install nel terminale per installare tutte le estensioni di Funzioni di Azure richieste dall'app per le funzioni.
  • Viene eseguito func host start nel terminale per avviare l'app per le funzioni nell'host funzioni.
  • Collegare il debugger di PowerShell allo spazio di esecuzione di PowerShell all'interno del runtime di Funzioni.

Annotazioni

È necessario assicurarsi che PSWorkerInProcConcurrencyUpperBound sia impostato su 1 per garantire un'esperienza di debug corretta in Visual Studio Code. Si tratta dell'impostazione predefinita.

Con l'app per le funzioni in esecuzione, è necessaria una console di PowerShell separata per chiamare la funzione attivata tramite HTTP.

In questo caso, la console di PowerShell è il client. Viene usato Invoke-RestMethod per attivare la funzione.

In una console di PowerShell eseguire il comando seguente:

Invoke-RestMethod "http://localhost:7071/api/HttpTrigger?Name=Functions"

Si noterà che una risposta non viene immediatamente restituita. Ciò è dovuto al fatto che il debugger Wait-Debugger è stato collegato e l'esecuzione di PowerShell è passata in modalità di interruzione non appena possibile. Questo è dovuto al concetto BreakAll, che viene spiegato più avanti. Dopo aver premuto il continue pulsante, il debugger ora si interrompe sulla riga subito dopo Wait-Debugger.

A questo punto, il debugger è collegato ed è possibile eseguire tutte le normali operazioni del debugger. Per altre informazioni sull'uso del debugger in Visual Studio Code, vedere la documentazione ufficiale.

Dopo aver continuato e richiamare completamente lo script, si noterà che:

  • La console di PowerShell che ha eseguito il Invoke-RestMethod ha restituito un risultato
  • La console integrata di PowerShell in Visual Studio Code è in attesa dell'esecuzione di uno script

Successivamente, quando si richiama la stessa funzione, il debugger nell'estensione di PowerShell si arresta subito dopo Wait-Debugger.

Debug in una console di PowerShell

Annotazioni

Questa sezione presuppone che la documentazione di Azure Functions Core Tools sia stata letta e che si sappia come usare il comando per avviare l'app func host start per le funzioni.

Aprire una console, cd nella directory dell'app per le funzioni ed eseguire il comando seguente:

func host start

Con l'applicazione per le funzioni attiva e il Wait-Debugger a posto, è possibile collegarsi al processo. Sono necessarie altre due console di PowerShell.

Una delle console funge da client. A questo scopo, si chiama Invoke-RestMethod per attivare la funzione. Ad esempio, è possibile eseguire il comando seguente:

Invoke-RestMethod "http://localhost:7071/api/HttpTrigger?Name=Functions"

Si noterà che non restituisce una risposta, che è il risultato di Wait-Debugger. Lo spazio di esecuzione di PowerShell è ora in attesa del collegamento di un debugger. Facciamolo allegare.

Nell'altra console di PowerShell eseguire il comando seguente:

Get-PSHostProcessInfo

Questo cmdlet restituisce una tabella simile all'output seguente:

ProcessName ProcessId AppDomainName
----------- --------- -------------
dotnet          49988 None
pwsh            43796 None
pwsh            49970 None
pwsh             3533 None
pwsh            79544 None
pwsh            34881 None
pwsh            32071 None
pwsh            88785 None

Prendere nota di ProcessId per l'elemento nella tabella con ProcessName come dotnet. Questo processo è la tua applicazione di funzioni.

Eseguire quindi il frammento di codice seguente:

# This enters into the Azure Functions PowerShell process.
# Put your value of `ProcessId` here.
Enter-PSHostProcess -Id $ProcessId

# This triggers the debugger.
Debug-Runspace 1

Dopo l'avvio, il debugger si interrompe e mostra un output simile al seguente:

Debugging Runspace: Runspace1

To end the debugging session type the 'Detach' command at the debugger prompt, or type 'Ctrl+C' otherwise.

At /Path/To/PSFunctionApp/HttpTriggerFunction/run.ps1:13 char:1
+ if($name) { ...
+ ~~~~~~~~~~~
[DBG]: [Process:49988]: [Runspace1]: PS /Path/To/PSFunctionApp>>

In questo momento, sei fermo a un punto di interruzione nel debugger di PowerShell. Da qui, è possibile eseguire tutte le abituali operazioni di debug: passo sopra, passo dentro, continua, termina e altre ancora. Per visualizzare il set completo di comandi di debug disponibili nella console, eseguire i h comandi o ? .

È anche possibile impostare punti di interruzione a questo livello con il Set-PSBreakpoint cmdlet .

Dopo aver continuato e richiamare completamente lo script, si noterà che:

  • La console di PowerShell in cui è stato eseguito Invoke-RestMethod ha ora restituito un risultato.
  • La console di PowerShell in cui è stato eseguito Debug-Runspace è in attesa di eseguire uno script.

È possibile richiamare di nuovo la stessa funzione (usando Invoke-RestMethod ad esempio) e il debugger si interrompe subito dopo il Wait-Debugger comando .

Considerazioni per il debug

Tenere presente i problemi seguenti durante il debug del codice di Funzioni.

BreakAll potrebbe causare l'interruzione del debugger in un punto imprevisto

L'estensione di PowerShell usa Debug-Runspace, che a sua volta si basa sulla funzionalità di BreakAll PowerShell. Questa funzionalità indica a PowerShell di arrestarsi al primo comando eseguito. Questo comportamento consente di impostare punti di interruzione all'interno dello spazio di esecuzione sottoposto a debug.

Il runtime di Funzioni di Azure esegue alcuni comandi prima di richiamare effettivamente lo script run.ps1, quindi è possibile che il debugger finisca per interrompersi all'interno di Microsoft.Azure.Functions.PowerShellWorker.psm1 o Microsoft.Azure.Functions.PowerShellWorker.psd1.

In caso di interruzione, eseguire il continue comando o c per ignorare questo punto di interruzione. Si ferma quindi al punto di interruzione previsto.

Risoluzione dei problemi

Se si verificano problemi durante il debug, verificare quanto segue:

Controllo Azione
Eseguire func --version dal terminale. Se viene visualizzato un errore che func non è stato trovato, Core Tools (func.exe) potrebbe non essere presente nella variabile locale path . Reinstallare Core Tools.
In Visual Studio Code il terminale predefinito deve avere accesso a func.exe. Assicurarsi di non usare un terminale predefinito in cui non è installato Core Tools, ad esempio Sottosistema Windows per Linux (WSL). Impostare la shell predefinita in Visual Studio Code su PowerShell 7 (scelta consigliata) o Su Windows PowerShell 5.1.

Passaggi successivi

Per altre informazioni sullo sviluppo di funzioni con PowerShell, vedere Guida per sviluppatori di PowerShell per Funzioni di Azure.

  • Last updated on