Azure Functions PowerShell fejlesztői útmutatóAzure Functions PowerShell developer guide

Ez a cikk részletesen ismerteti, hogyan írhat Azure Functions a PowerShell használatával.This article provides details about how you write Azure Functions using PowerShell.

Megjegyzés

PowerShell az Azure Functions jelenleg előzetes verzióban érhető el.PowerShell for Azure Functions is currently in preview. Feliratkozás fontos a frissítések fogadásához a Azure App Service közlemények tárházban a Githubon.To receive important updates, subscribe to the Azure App Service announcements repository on GitHub.

A PowerShell Azure-függvény (Function) egy PowerShell-parancsfájlként jelenik meg, amely az aktiváláskor fut.A PowerShell Azure function (function) is represented as a PowerShell script that executes when triggered. Mindegyik függvény parancsfájl egy kapcsolódó function.json fájllal rendelkezik, amely meghatározza, hogy a függvény hogyan viselkedik, például hogyan aktiválódik, valamint a bemeneti és kimeneti paramétereket.Each function script has a related function.json file that defines how the function behaves, such as how it's triggered and its input and output parameters. További információt az Eseményindítók és a kötések című cikkbentalál.To learn more, see the Triggers and binding article.

Más típusú függvényekhez hasonlóan a PowerShell-parancsfájlok is a function.json fájlban meghatározott összes bemeneti kötés nevével egyező paramétereket fogadnak.Like other kinds of functions, PowerShell script functions take in parameters that match the names of all the input bindings defined in the function.json file. Egy TriggerMetadata paraméter is át lett adva, amely további információkat tartalmaz a függvényt elindító triggerről.A TriggerMetadata parameter is also passed that contains additional information on the trigger that started the function.

Ez a cikk azt feltételezi, hogy már elolvasta a Azure functions fejlesztői referenciát.This article assumes that you have already read the Azure Functions developer reference. Az első PowerShell-függvény létrehozásához a PowerShell functions rövid útmutatóját is be kell fejeznie.You should have also completed the Functions quickstart for PowerShell to create your first PowerShell function.

Mappa szerkezeteFolder structure

Egy PowerShell-projekthez szükséges mappastruktúrát a következőhöz hasonlóan néz ki.The required folder structure for a PowerShell project looks like the following. Ez az alapértelmezett érték módosítható.This default can be changed. További információért lásd az alábbi scriptFile szakaszt.For more information, see the scriptFile section below.

PSFunctionApp
 | - MyFirstFunction
 | | - run.ps1
 | | - function.json
 | - MySecondFunction
 | | - run.ps1
 | | - function.json
 | - Modules
 | | - myFirstHelperModule
 | | | - myFirstHelperModule.psd1
 | | | - myFirstHelperModule.psm1
 | | - mySecondHelperModule
 | | | - mySecondHelperModule.psd1
 | | | - mySecondHelperModule.psm1
 | - local.settings.json
 | - host.json
 | - requirements.psd1
 | - profile.ps1
 | - extensions.csproj
 | - bin

A projekt gyökerében található egy megosztott host.json fájl, amely a Function alkalmazás konfigurálására használható.At the root of the project, there's a shared host.json file that can be used to configure the function app. Minden függvényhez tartozik egy mappa, amely a saját kódjával (. ps1) és a kötési konfigurációs fájllal (function.json) rendelkezik.Each function has a folder with its own code file (.ps1) and binding configuration file (function.json). A function. JSON fájljának szülő könyvtárának neve mindig a függvény neve.The name of the function.json file's parent directory is always the name of your function.

Bizonyos kötések extensions.csproj fájl jelenlétét igénylik.Certain bindings require the presence of an extensions.csproj file. A functions futtatókörnyezet 2. x verziójában szükséges kötési kiterjesztések a extensions.csproj fájlban vannak definiálva, a bin mappában található tényleges függvénytár-fájlokkal.Binding extensions, required in version 2.x of the Functions runtime, are defined in the extensions.csproj file, with the actual library files in the bin folder. Helyi fejlesztés esetén regisztrálnia kell a kötési bővítményeket.When developing locally, you must register binding extensions. A Azure Portal funkcióinak fejlesztésekor ez a regisztráció történik.When developing functions in the Azure portal, this registration is done for you.

A PowerShell-függvény alkalmazásaiban lehet, hogy profile.ps1, amely akkor fut le, amikor egy Function alkalmazás elindul (más néven a hidegindító kezdete ).In PowerShell Function Apps, you may optionally have a profile.ps1 which runs when a function app starts to run (otherwise know as a cold start. További információ: PowerShell- profil.For more information, see PowerShell profile.

PowerShell-parancsfájl definiálása függvénykéntDefining a PowerShell script as a function

Alapértelmezés szerint a functions futtatókörnyezet run.ps1 értékben keresi a függvényt, ahol a run.ps1 a hozzá tartozó function.json.By default, the Functions runtime looks for your function in run.ps1, where run.ps1 shares the same parent directory as its corresponding function.json.

A szkript több argumentumot adott meg a végrehajtás során.Your script is passed a number of arguments on execution. A paraméterek kezeléséhez adjon hozzá egy param blokkot a parancsfájl elejéhez, ahogy az alábbi példában látható:To handle these parameters, add a param block to the top of your script as in the following example:

# $TriggerMetadata is optional here. If you don't need it, you can safely remove it from the param block
param($MyFirstInputBinding, $MySecondInputBinding, $TriggerMetadata)

TriggerMetadata paraméterTriggerMetadata parameter

A TriggerMetadata paraméterrel további információkat adhat meg a triggerről.The TriggerMetadata parameter is used to supply additional information about the trigger. A további metaadatok a kötéstől függenek, de mindegyikük tartalmaz egy sys tulajdonságot, amely a következő adatokat tartalmazza:The additional metadata varies from binding to binding but they all contain a sys property that contains the following data:

$TriggerMetadata.sys
TulajdonságProperty DescriptionDescription TypeType
UtcNowUtcNow Ha UTC-ben a függvény aktiválva lettWhen, in UTC, the function was triggered DateTimeDateTime
MethodNameMethodName Az aktivált függvény neveThe name of the Function that was triggered Karakterláncstring
RandGuidRandGuid a függvény végrehajtásának egyedi GUID azonosítójaa unique guid to this execution of the function Karakterláncstring

Minden trigger típushoz eltérő metaadatok vannak megadva.Every trigger type has a different set of metadata. Például a QueueTrigger $TriggerMetadata a következőt tartalmazza: InsertionTime, Id, DequeueCount, többek között.For example, the $TriggerMetadata for QueueTrigger contains the InsertionTime, Id, DequeueCount, among other things. Az üzenetsor-eseményindító metaadataival kapcsolatos további információkért nyissa meg a várólista-eseményindítók hivatalos dokumentációját.For more information on the queue trigger's metadata, go to the official documentation for queue triggers. Tekintse meg a dokumentációt azon Eseményindítók használatával kapcsolatban, amelyekkel megtudhatja, mi történik az eseményindító metaadatainak között.Check the documentation on the triggers you're working with to see what comes inside the trigger metadata.

KötésekBindings

A PowerShellben a kötések konfigurálva és definiálva vannak egy függvény function. JSON fájljában.In PowerShell, bindings are configured and defined in a function's function.json. A függvények számos módon működnek együtt a kötésekkel.Functions interact with bindings a number of ways.

Trigger-és bemeneti adatok olvasásaReading trigger and input data

Az trigger és a bemeneti kötések a függvénynek átadott paraméterekként lesznek beolvasva.Trigger and input bindings are read as parameters passed to your function. A bemeneti kötések direction készlettel rendelkeznek a function. JSON fájlban in értékre.Input bindings have a direction set to in in function.json. Az function.json értékben definiált name tulajdonság a paraméter neve, a param blokkban.The name property defined in function.json is the name of the parameter, in the param block. Mivel a PowerShell nevesített paramétereket használ a kötéshez, a paraméterek sorrendje nem számít.Since PowerShell uses named parameters for binding, the order of the parameters doesn't matter. Az ajánlott eljárás azonban a function.json által meghatározott kötések sorrendjét követi.However, it's a best practice to follow the order of the bindings defined in the function.json.

param($MyFirstInputBinding, $MySecondInputBinding)

Kimeneti adatokat írunkWriting output data

A functions-ben egy kimeneti kötés direction értékkel rendelkezik, amely a function. JSON fájlban out.In Functions, an output binding has a direction set to out in the function.json. A Push-OutputBinding parancsmaggal írhat egy kimeneti kötést, amely a functions Runtime számára érhető el.You can write to an output binding by using the Push-OutputBinding cmdlet, which is available to the Functions runtime. A kötés name tulajdonsága minden esetben a function.json paraméterben meghatározottak szerint megfelel a Push-OutputBinding parancsmag Name paraméterének.In all cases, the name property of the binding as defined in function.json corresponds to the Name parameter of the Push-OutputBinding cmdlet.

A következő bemutatja, hogyan hívható meg Push-OutputBinding a függvény parancsfájljában:The following shows how to call Push-OutputBinding in your function script:

param($MyFirstInputBinding, $MySecondInputBinding)

Push-OutputBinding -Name myQueue -Value $myValue

A folyamaton keresztül egy adott kötés értékét is átadhatja.You can also pass in a value for a specific binding through the pipeline.

param($MyFirstInputBinding, $MySecondInputBinding)

Produce-MyOutputValue | Push-OutputBinding -Name myQueue

a Push-OutputBinding a (z) -Name számára megadott érték alapján eltérően viselkedik:Push-OutputBinding behaves differently based on the value specified for -Name:

  • Ha a megadott név nem oldható fel érvényes kimeneti kötésre, akkor hiba történik.When the specified name cannot be resolved to a valid output binding, then an error is thrown.

  • Ha a kimeneti kötés fogadja az értékek gyűjteményét, többször is meghívhatja a Push-OutputBinding értéket a több érték leküldéséhez.When the output binding accepts a collection of values, you can call Push-OutputBinding repeatedly to push multiple values.

  • Ha a kimeneti kötés csak egyszeres értéket fogad el, a Push-OutputBinding második alkalommal meghívja a hibát.When the output binding only accepts a singleton value, calling Push-OutputBinding a second time raises an error.

@no__t – 0 szintaxisPush-OutputBinding syntax

A következő érvényes paraméterek a Push-OutputBinding hívásához:The following are valid parameters for calling Push-OutputBinding:

Name (Név)Name TypeType PozícióPosition LeírásDescription
-Name SztringString 11 A beállítani kívánt kimeneti kötés neve.The name of the output binding you want to set.
-Value ObjectObject 22 A beállítani kívánt kimeneti kötés értéke, amelyet a rendszer a folyamat ByValue fogad el.The value of the output binding you want to set, which is accepted from the pipeline ByValue.
-Clobber SwitchParameterSwitchParameter ElemziNamed Választható Ha meg van adva, a megadott kimeneti kötéshez beállított értéket kényszeríti ki.(Optional) When specified, forces the value to be set for a specified output binding.

A következő közös paraméterek is támogatottak:The following common parameters are also supported:

  • Verbose
  • Debug
  • ErrorAction
  • ErrorVariable
  • WarningAction
  • WarningVariable
  • OutBuffer
  • PipelineVariable
  • OutVariable

További információ: About általánosparaméterek.For more information, see About CommonParameters.

Leküldéses OutputBinding – példa: HTTP-válaszokPush-OutputBinding example: HTTP responses

Egy HTTP-trigger egy response nevű kimeneti kötést használó választ ad vissza.An HTTP trigger returns a response using an output binding named response. A következő példában a response kimeneti kötésének értéke "output #1":In the following example, the output binding of response has the value of "output #1":

PS >Push-OutputBinding -Name response -Value ([HttpResponseContext]@{
    StatusCode = [System.Net.HttpStatusCode]::OK
    Body = "output #1"
})

Mivel a kimenet a HTTP, amely csak egy egyedi értéket fogad el, a rendszer hibát jelez, ha a Push-OutputBinding neve második alkalommal történik.Because the output is to HTTP, which accepts a singleton value only, an error is thrown when Push-OutputBinding is called a second time.

PS >Push-OutputBinding -Name response -Value ([HttpResponseContext]@{
    StatusCode = [System.Net.HttpStatusCode]::OK
    Body = "output #2"
})

Az olyan kimenetek esetében, amelyek csak egyszeres értékeket fogadnak el, a -Clobber paraméterrel felülbírálhatja a régi értéket, ahelyett, hogy hozzá szeretne adni egy gyűjteményhez.For outputs that only accept singleton values, you can use the -Clobber parameter to override the old value instead of trying to add to a collection. Az alábbi példa azt feltételezi, hogy már hozzáadott egy értéket.The following example assumes that you have already added a value. @No__t-0 használatával a következő példa válasza felülbírálja a meglévő értéket, hogy a "kimeneti #3" értéket adja vissza:By using -Clobber, the response from the following example overrides the existing value to return a value of "output #3":

PS >Push-OutputBinding -Name response -Value ([HttpResponseContext]@{
    StatusCode = [System.Net.HttpStatusCode]::OK
    Body = "output #3"
}) -Clobber

Leküldéses OutputBinding – példa: Üzenetsor kimeneti kötésePush-OutputBinding example: Queue output binding

a Push-OutputBinding az adatokat kimeneti kötésekre küldi, például egy Azure üzenetsor-tároló kimeneti kötését.Push-OutputBinding is used to send data to output bindings, such as an Azure Queue storage output binding. A következő példában a várólistára írt üzenet "output #1" értékkel rendelkezik:In the following example, the message written to the queue has a value of "output #1":

PS >Push-OutputBinding -Name outQueue -Value "output #1"

A tárolási várólista kimeneti kötése több kimeneti értéket is elfogad.The output binding for a Storage queue accepts multiple output values. Ebben az esetben a következő példát hívja meg a várólistára való első írás után, amely két elemből áll: "output #1" és "output #2".In this case, calling the following example after the first writes to the queue a list with two items: "output #1" and "output #2".

PS >Push-OutputBinding -Name outQueue -Value "output #2"

A következő példa, amikor az előző kettő után meghívja, két további értéket ad hozzá a kimeneti gyűjteményhez:The following example, when called after the previous two, adds two more values to the output collection:

PS >Push-OutputBinding -Name outQueue -Value @("output #3", "output #4")

A várólistába íráskor az üzenet a következő négy értéket tartalmazza: "output #1," output #2 "," output #3 "és" output #4 ".When written to the queue, the message contains these four values: "output #1", "output #2", "output #3", and "output #4".

@no__t – 0 parancsmagGet-OutputBinding cmdlet

A Get-OutputBinding parancsmaggal kérheti le a kimeneti kötésekhez jelenleg beállított értékeket.You can use the Get-OutputBinding cmdlet to retrieve the values currently set for your output bindings. Ez a parancsmag egy olyan szórótábla kérdez le, amely tartalmazza a kimeneti kötések nevét a megfelelő értékekkel.This cmdlet retrieves a hashtable that contains the names of the output bindings with their respective values.

Az alábbi példa a Get-OutputBinding használatával ad vissza aktuális kötési értékeket:The following is an example of using Get-OutputBinding to return current binding values:

Get-OutputBinding
Name                           Value
----                           -----
MyQueue                        myData
MyOtherQueue                   myData

a Get-OutputBinding egy -Name nevű paramétert is tartalmaz, amely a visszaadott kötés szűrésére használható, ahogy az alábbi példában is látható:Get-OutputBinding also contains a parameter called -Name, which can be used to filter the returned binding, as in the following example:

Get-OutputBinding -Name MyQ*
Name                           Value
----                           -----
MyQueue                        myData

A helyettesítő karakterek (*) a Get-OutputBinding esetében támogatottak.Wildcards (*) are supported in Get-OutputBinding.

NaplózásLogging

A PowerShell-függvények naplózása ugyanúgy működik, mint a rendszeres PowerShell-naplózás.Logging in PowerShell functions works like regular PowerShell logging. A naplózási parancsmagok segítségével írhat az egyes kimeneti adatfolyamokhoz.You can use the logging cmdlets to write to each output stream. Minden parancsmag a függvények által használt naplózási szintre mutat.Each cmdlet maps to a log level used by Functions.

Függvények naplózási szintjeFunctions logging level Naplózási parancsmagLogging cmdlet
HibaError Write-Error
FigyelmeztetésWarning Write-Warning
InformationInformation Write-Information
Write-Host
Write-Output
InformationInformation Az adatszint naplózásának megírása.Writes to Information level logging.
HibakeresésDebug Write-Debug
NyomkövetésTrace Write-Progress
Write-Verbose

Ezen parancsmagok mellett a folyamatba írt összes adat át lesz irányítva a Information naplózási szintre, és az alapértelmezett PowerShell-formázással jelenik meg.In addition to these cmdlets, anything written to the pipeline is redirected to the Information log level and displayed with the default PowerShell formatting.

Fontos

A Write-Verbose vagy Write-Debug parancsmagok használata nem elegendő a részletes és hibakeresési szintű naplózás megjelenítéséhez.Using the Write-Verbose or Write-Debug cmdlets is not enough to see verbose and debug level logging. A naplózási szint küszöbértékét is be kell állítania, amely kijelenti, hogy milyen szintű naplókra van szüksége.You must also configure the log level threshold, which declares what level of logs you actually care about. További információ: az alkalmazás naplózási szintjének konfigurálása.To learn more, see Configure the function app log level.

A Function app naplózási szintjének konfigurálásaConfigure the function app log level

Azure Functions segítségével meghatározhatja a küszöbértéket, hogy könnyen szabályozható legyen a függvények írási módja a naplókba.Azure Functions lets you define the threshold level to make it easy to control the way Functions writes to the logs. A konzolra írt összes nyomkövetés küszöbértékének megadásához használja a logging.logLevel.default tulajdonságot a host.json file.To set the threshold for all traces written to the console, use the logging.logLevel.default property in the host.json file. Ez a beállítás a Function alkalmazás összes függvényére érvényes.This setting applies to all functions in your function app.

A következő példa beállítja a küszöbértéket az összes függvény részletes naplózásának engedélyezéséhez, de a küszöbértéket úgy állítja be, hogy engedélyezze a hibakeresési naplózást egy MyFunction nevű függvénynél:The following example sets the threshold to enable verbose logging for all functions, but sets the threshold to enable debug logging for a function named MyFunction:

{
    "logging": {
        "logLevel": {
            "Function.MyFunction": "Debug",
            "default": "Trace"
        }
    }
}  

További információ: a Host. JSON dokumentációja.For more information, see host.json reference.

A naplók megtekintéseViewing the logs

Ha az függvényalkalmazás az Azure-ban fut, akkor a Application Insights használatával figyelheti.If your Function App is running in Azure, you can use Application Insights to monitor it. Olvassa el a figyelési Azure functions , ha többet szeretne megtudni a függvények naplóinak megtekintéséről és lekérdezéséről.Read monitoring Azure Functions to learn more about viewing and querying function logs.

Ha a függvényalkalmazást helyileg futtatja fejlesztésre, a a naplófájlok alapértelmezése a fájlrendszer.If you're running your Function App locally for development, logs default to the file system. A naplók a konzolon való megjelenítéséhez állítsa a AZURE_FUNCTIONS_ENVIRONMENT környezeti változót Development értékre a függvényalkalmazás elindítása előtt.To see the logs in the console, set the AZURE_FUNCTIONS_ENVIRONMENT environment variable to Development before starting the Function App.

Eseményindítók és kötések típusaiTriggers and bindings types

Számos eseményindító és kötés érhető el a Function alkalmazással való használathoz.There are a number of triggers and bindings available to you to use with your function app. Az eseményindítók és kötések teljes listája itt található.The full list of triggers and bindings can be found here.

Az összes eseményindító és kötés a kódban szerepel néhány valós adattípus formájában:All triggers and bindings are represented in code as a few real data types:

  • SzórótáblaHashtable
  • Karakterláncstring
  • bájt []byte[]
  • intint
  • doubledouble
  • HttpRequestContextHttpRequestContext
  • HttpResponseContextHttpResponseContext

A lista első öt típusa a standard .NET-típusok.The first five types in this list are standard .NET types. Az utolsó kettőt csak a HttpTrigger triggerhasználja.The last two are used only by the HttpTrigger trigger.

A függvények minden kötési paraméterének a következő típusok egyikének kell lennie.Each binding parameter in your functions must be one of these types.

HTTP-eseményindítók és-kötésekHTTP triggers and bindings

A HTTP-és webhook-eseményindítók és a HTTP-kimeneti kötések a HTTP-üzenetküldést a kérelmek és válaszok objektumok használatával jelölik.HTTP and webhook triggers and HTTP output bindings use request and response objects to represent the HTTP messaging.

Kérelem objektumRequest object

A parancsfájlba átadott kérelem-objektum HttpRequestContext típusú, amely a következő tulajdonságokkal rendelkezik:The request object that's passed into the script is of the type HttpRequestContext, which has the following properties:

TulajdonságProperty DescriptionDescription TypeType
Body Egy objektum, amely tartalmazza a kérelem törzsét.An object that contains the body of the request. a Body a legjobb típusra van szerializálva az adathalmaz alapján.Body is serialized into the best type based on the data. Ha például az adatfájl JSON, a rendszer szórótábla adja át.For example, if the data is JSON, it's passed in as a hashtable. Ha az érték karakterlánc, akkor karakterláncként adja át a rendszer.If the data is a string, it's passed in as a string. objectobject
Headers A kérések fejléceit tartalmazó szótár.A dictionary that contains the request headers. Szótár < karakterlánc, karakterlánc >*Dictionary<string,string>*
Method A kérelem HTTP-metódusa.The HTTP method of the request. Karakterláncstring
Params Egy objektum, amely a kérelem útválasztási paramétereit tartalmazza.An object that contains the routing parameters of the request. Szótár < karakterlánc, karakterlánc >*Dictionary<string,string>*
Query Egy objektum, amely tartalmazza a lekérdezési paramétereket.An object that contains the query parameters. Szótár < karakterlánc, karakterlánc >*Dictionary<string,string>*
Url A kérelem URL-címe.The URL of the request. Karakterláncstring

@no__t – 1 Az összes Dictionary<string,string> kulcs kis-és nagybetűk megkülönböztetése.* All Dictionary<string,string> keys are case-insensitive.

VálaszobjektumResponse object

A visszaküldeni kívánt válasz objektum HttpResponseContext típusú, amely a következő tulajdonságokkal rendelkezik:The response object that you should send back is of the type HttpResponseContext, which has the following properties:

TulajdonságProperty DescriptionDescription TypeType
Body Egy objektum, amely tartalmazza a válasz törzsét.An object that contains the body of the response. objectobject
ContentType Egy rövid kéz a válasz tartalomtípusának beállításához.A short hand for setting the content type for the response. Karakterláncstring
Headers Egy objektum, amely tartalmazza a válasz fejléceit.An object that contains the response headers. Szótár vagy szórótáblaDictionary or Hashtable
StatusCode A válasz HTTP-állapotkódot.The HTTP status code of the response. karakterlánc vagy intstring or int

A kérelem és válasz eléréseAccessing the request and response

Ha HTTP-eseményindítókkal dolgozik, ugyanúgy érheti el a HTTP-kérést, mint bármely más bemeneti kötést.When you work with HTTP triggers, you can access the HTTP request the same way you would with any other input binding. A param blokkban van.It's in the param block.

Egy HttpResponseContext objektummal választ adhat vissza, ahogy az az alábbi képen is látható:Use an HttpResponseContext object to return a response, as shown in the following:

function.json

{
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "authLevel": "anonymous"
    },
    {
      "type": "http",
      "direction": "out"
    }
  ]
}

run.ps1

param($req, $TriggerMetadata)

$name = $req.Query.Name

Push-OutputBinding -Name res -Value ([HttpResponseContext]@{
    StatusCode = [System.Net.HttpStatusCode]::OK
    Body = "Hello $name!"
})

A függvény meghívásának eredménye a következő:The result of invoking this function would be:

PS > irm http://localhost:5001?Name=Functions
Hello Functions!

Triggerek és kötések típusa – öntésType-casting for triggers and bindings

Bizonyos kötésekhez, például a blob-kötésekhez, meg tudja adni a paraméter típusát.For certain bindings like the blob binding, you're able to specify the type of the parameter.

Ha például a blob Storage-ból karakterláncként megadott adatokkal szeretne rendelkezni, adja hozzá a következő típust a param blokkhoz:For example, to have data from Blob storage supplied as a string, add the following type cast to my param block:

param([string] $myBlob)

PowerShell-profilPowerShell profile

A PowerShellben van egy PowerShell-profil fogalma.In PowerShell, there's the concept of a PowerShell profile. Ha még nem ismeri a PowerShell-profilokat, tekintse meg a következő témakört: About Profiles.If you're not familiar with PowerShell profiles, see About profiles.

A PowerShell-függvények esetében a profil parancsfájlja a Function alkalmazás indításakor végrehajtódik.In PowerShell Functions, the profile script executes when the function app starts. A Function apps az első üzembe helyezéskor kezdődik, és az üresjárat után (Cold Start).Function apps start when first deployed and after being idled (cold start).

Ha olyan eszközökkel hoz létre Function alkalmazást, mint például a Visual Studio Code és a Azure Functions Core Tools, akkor a rendszer az alapértelmezett profile.ps1 értéket hozza létre.When you create a function app using tools, such as Visual Studio Code and Azure Functions Core Tools, a default profile.ps1 is created for you. Az alapértelmezett profil a GitHub-tárház alapvető eszközein marad, és a következőket tartalmazza:The default profile is maintained on the Core Tools GitHub repository and contains:

  • Automatikus MSI-hitelesítés az Azure-ba.Automatic MSI authentication to Azure.
  • Ha szeretné, bekapcsolhatja a Azure PowerShell AzureRM PowerShell-aliast.The ability to turn on the Azure PowerShell AzureRM PowerShell aliases if you would like.

PowerShell-verzióPowerShell version

A következő táblázat a függvények futtatókörnyezetének egyes főbb verziói által használt PowerShell-verziót mutatja be:The following table shows the PowerShell version used by each major version of the Functions runtime:

Függvények verziójaFunctions version PowerShell-verzióPowerShell version
1. x1.x Windows PowerShell 5,1 (a futtatókörnyezet zárolta)Windows PowerShell 5.1 (locked by the runtime)
2. x2.x 6. PowerShell-magPowerShell Core 6

Az aktuális verziót úgy tekintheti meg, hogy bármely függvényből kinyomtatja a $PSVersionTable értéket.You can see the current version by printing $PSVersionTable from any function.

FüggőségkezelésDependency management

A PowerShell-függvények támogatják a szolgáltatásban a PowerShell -katalógus moduljainak letöltését és felügyeletét.PowerShell functions support downloading and managing PowerShell gallery modules by the service. Ha módosítja a Host. JSON fájlt, és a managedDependency enabled tulajdonságot True értékre állítja, a rendszer feldolgozza a követelmények. psd1 fájlját.By modifying the host.json and setting the managedDependency enabled property to true, the requirements.psd1 file will be processed. A rendszer automatikusan letölti és elérhetővé teszi a megadott modulokat a függvény számára.The specified modules will be automatically downloaded and made available to the function.

A jelenleg támogatott modulok maximális száma 10.The maximum number of modules currently supported is 10. A támogatott szintaxis a MajorNumber. * vagy a modul pontos verziója, ahogy az alább látható.The supported syntax is MajorNumber.* or exact module version as shown below. Az Azure az modul alapértelmezés szerint az új PowerShell-függvény alkalmazás létrehozásakor szerepel.The Azure Az module is included by default when a new PowerShell function app is created.

A nyelvi feldolgozó a frissített modulokat is felveszi az újraindításra.The language worker will pick up any updated modules on a restart.

host.jsonhost.json

{
  "managedDependency": {
          "enabled": true
       }
}

követelmények. psd1requirements.psd1

@{
    Az = '1.*'
    SqlServer = '21.1.18147'
}

A következő beállítások állnak rendelkezésre a felügyelt függőségek letöltésének és telepítésének megváltoztatásához.The following settings are available to change how the managed dependencies are downloaded and installed. Az alkalmazás frissítése a MDMaxBackgroundUpgradePeriod-on belül indul el, és a frissítési folyamat körülbelül MDNewSnapshotCheckPeriod belül elvégezhető.Your app upgrade will start within MDMaxBackgroundUpgradePeriod, and the upgrade process will complete within approximately MDNewSnapshotCheckPeriod.

függvényalkalmazás beállításFunction App setting Alapértelmezett értékDefault value LeírásDescription
MDMaxBackgroundUpgradePeriodMDMaxBackgroundUpgradePeriod "7.00:00:00" (7 nap)“7.00:00:00” (7 days) Minden PS-feldolgozó kezdeményezi a modul frissítésének ellenőrzését a PS-galériában a munkavégző folyamat indításakor és minden MDMaxBackgroundUpgradePeriod után.Every PS Worker initiates checking for module upgrades on the PS Gallery on Worker process start and every MDMaxBackgroundUpgradePeriod after that. Ha a PS-katalógusban új modul-verziók érhetők el, akkor a rendszer a PS-feldolgozók számára elérhető fájlrendszerbe telepíti őket.If new module versions are available on the PS Gallery, they will be installed to the file system available to PS Workers. Ennek az értéknek a csökkentése lehetővé teszi, hogy a függvény alkalmazása hamarabb lekérje a modul újabb verzióit, de az alkalmazás erőforrás-használatát is megnöveli (hálózati I/O-, CPU-és tárolási).Decreasing this value will let your Function app get newer module versions sooner, but will also increase the app resource usage (network I/O, CPU, storage). Ennek az értéknek a növelésével csökken az alkalmazás erőforrásainak használata, de az új modul-verziók az alkalmazásba való kézbesítése is késleltethető.Increasing this value will decrease the app resource usage but may also delay delivering new module versions to your app.
MDNewSnapshotCheckPeriodMDNewSnapshotCheckPeriod "01:00:00" (1 óra)“01:00:00” (1 hour) Miután telepítette az új modul verzióit a fájlrendszerre, minden PS-feldolgozót újra kell indítani.After the new module versions are installed to the file system, every PS Worker needs to be restarted. A PS-feldolgozók újraindítása hatással lehet az alkalmazás rendelkezésre állására, mert az az aktuális függvény hívásait megszakítja.Restarting PS Workers may affect your app availability because it may interrupt current function invocations. Amíg az összes PS-feldolgozó újraindul, a függvény meghívása a régi vagy az új modul verzióját is használhatja.Until all PS Workers are restarted, function invocations may use either the old or the new module versions. Az összes PS-feldolgozó újraindítása a MDNewSnapshotCheckPeriod-en belül fejeződik be.Restarting all PS Workers will complete within MDNewSnapshotCheckPeriod. Ennek az értéknek a növelésével csökken a megszakítások gyakorisága, de az is előfordulhat, hogy a függvény meghívásakor a régi vagy az új modul nem determinisztikus módon-verzióit használja.Increasing this value will decrease the frequency of interruptions, but may also increase the period of time when function invocations use either the old or the new module versions non-deterministically.
MDMinBackgroundUpgradePeriodMDMinBackgroundUpgradePeriod "1.00:00:00" (1 nap)“1.00:00:00” (1 day) A gyakori munkavégző újraindítások esetén a modulok frissítésének ellenőrzése nem történik meg, ha bármelyik feldolgozó már kezdeményezte az utolsó MDMinBackgroundUpgradePeriod belül.In order to avoid excessive module upgrades on frequent Worker restarts, checking for module upgrades will not be performed if any worker already initiated that within the last MDMinBackgroundUpgradePeriod.

Megjegyzés

A felügyelt függőségek a www.powershellgallery.com elérésére támaszkodnak a modulok letöltéséhez.Managed dependencies relies on access to www.powershellgallery.com to download modules. A szükséges tűzfalszabályok hozzáadásával gondoskodnia kell arról, hogy a Function Runtime hozzáférjen ehhez az URL-címhez.You need to ensure the function runtime has access to this url by adding any required firewall rules.

A saját egyéni moduljainak kihasználása kicsit eltér a megszokott módon.Leveraging your own custom modules is a little different than how you would do it normally.

Ha a modult a helyi gépen telepíti, az a $env:PSModulePath globálisan elérhető mappáiba kerül.When you install the module on your local machine, it goes in one of the globally available folders in your $env:PSModulePath. Mivel a függvény az Azure-ban fut, nem fog hozzáférni a gépen telepített modulokhoz.Since your function runs in Azure, you won't have access to the modules installed on your machine. Ehhez az szükséges, hogy a PowerShell-függvényhez tartozó $env:PSModulePath a szokásos PowerShell-parancsfájlban $env:PSModulePath értéktől eltérő legyen.This requires that the $env:PSModulePath for a PowerShell function app differs from $env:PSModulePath in a regular PowerShell script.

A functions-ben a PSModulePath két elérési utat tartalmaz:In Functions, PSModulePath contains two paths:

  • @No__t-0 mappa, amely a függvényalkalmazás gyökerében található.A Modules folder that exists at the root of your Function App.
  • Egy Modules mappa elérési útja, amely a PowerShell nyelvi feldolgozón belül él.A path to a Modules folder that lives inside the PowerShell language worker.

Függvény alkalmazás-szintű Modules mappaFunction app-level Modules folder

Egyéni modulok használatához olyan modulokat helyezhet el, amelyeken a függvények egy Modules mappától függenek.To use custom modules, you can place modules on which your functions depend in a Modules folder. Ebből a mappából a modulok automatikusan elérhetők a functions Runtime számára.From this folder, modules are automatically available to the functions runtime. A Function alkalmazás bármely funkciója használhatja ezeket a modulokat.Any function in the function app can use these modules.

Megjegyzés

A követelmények. psd1 fájlban megadott modulokat a rendszer automatikusan letölti és belefoglalja az elérési útra, így nem kell felvennie őket a modulok mappába.Modules specified in the requirements.psd1 file are automatically downloaded and included in the path so you don't need to include them in the modules folder. Ezeket a rendszer helyileg tárolja a $env: LOCALAPPDATA/AzureFunctions mappában és a/data/ManagedDependencies mappában a felhőben való futtatáskor.These are stored locally in the $env:LOCALAPPDATA/AzureFunctions folder and in the /data/ManagedDependencies folder when run in the cloud.

Az egyéni modul funkció kihasználása érdekében hozzon létre egy Modules mappát a Function alkalmazás gyökerében.To take advantage of the custom module feature, create a Modules folder in the root of your function app. Másolja a függvényekben használni kívánt modulokat erre a helyre.Copy the modules you want to use in your functions to this location.

mkdir ./Modules
Copy-Item -Path /mymodules/mycustommodule -Destination ./Modules -Recurse

A modules mappában a Function alkalmazásnak a következő mappastruktúrát kell megjelennie:With a Modules folder, your function app should have the following folder structure:

PSFunctionApp
 | - MyFunction
 | | - run.ps1
 | | - function.json
 | - Modules
 | | - MyCustomModule
 | | - MyOtherCustomModule
 | | - MySpecialModule.psm1
 | - local.settings.json
 | - host.json
 | - requirements.psd1

A Function app indításakor a PowerShell nyelvi feldolgozó hozzáadja ezt a Modules mappát a $env:PSModulePath-hez, így a modul automatikus betöltését ugyanúgy használhatja, mint egy normál PowerShell-parancsfájlban.When you start your function app, the PowerShell language worker adds this Modules folder to the $env:PSModulePath so that you can rely on module autoloading just as you would in a regular PowerShell script.

Nyelvi feldolgozói szint @no__t – 0 mappaLanguage worker level Modules folder

A PowerShell nyelvi feldolgozója általában számos modult használ.Several modules are commonly used by the PowerShell language worker. Ezek a modulok a PSModulePath utolsó helyén vannak meghatározva.These modules are defined in the last position of PSModulePath.

A modulok aktuális listája a következő:The current list of modules is as follows:

  • Microsoft. PowerShell. Archive: az archívumok kezeléséhez használt modul, például .zip, .nupkg és egyebek.Microsoft.PowerShell.Archive: module used for working with archives, like .zip, .nupkg, and others.
  • ThreadJob: A PowerShell-feladatok API-k szálon alapuló implementálása.ThreadJob: A thread-based implementation of the PowerShell job APIs.

A modulok legújabb verzióját a függvények használják.The most recent version of these modules is used by Functions. Ezen modulok adott verziójának használatához az adott verziót a Function app Modules mappájába helyezheti el.To use a specific version of these modules, you can put the specific version in the Modules folder of your function app.

Környezeti változókEnvironment variables

A függvények, az Alkalmazásbeállítások, például a szolgáltatási kapcsolatok karakterláncai a végrehajtás során környezeti változókként jelennek meg.In Functions, app settings, such as service connection strings, are exposed as environment variables during execution. Ezeket a beállításokat $env:NAME_OF_ENV_VAR használatával érheti el, ahogy az az alábbi példában is látható:You can access these settings using $env:NAME_OF_ENV_VAR, as shown in the following example:

param($myTimer)

Write-Host "PowerShell timer trigger function ran! $(Get-Date)"
Write-Host $env:AzureWebJobsStorage
Write-Host $env:WEBSITE_SITE_NAME

A Function app-beállítások több módon is hozzáadhatók, frissíthetők és törölhetők:There are several ways that you can add, update, and delete function app settings:

Helyileg futtatva az Alkalmazásbeállítások a Local. Settings. JSON Project fájlból lesznek beolvasva.When running locally, app settings are read from the local.settings.json project file.

EgyidejűségConcurrency

Alapértelmezés szerint a függvények PowerShell-futtatókörnyezete egyszerre csak egy függvény hívását képes feldolgozni.By default, the Functions PowerShell runtime can only process one invocation of a function at a time. Előfordulhat azonban, hogy ez a párhuzamossági szint nem elegendő a következő helyzetekben:However, this concurrency level might not be sufficient in the following situations:

  • Ha nagy számú hívást próbál meg egyszerre kezelni.When you're trying to handle a large number of invocations at the same time.
  • Ha olyan függvényekkel rendelkezik, amelyek más függvényeket hívnak meg ugyanazon a Function alkalmazáson belül.When you have functions that invoke other functions inside the same function app.

Ezt a viselkedést úgy módosíthatja, ha a következő környezeti változót egész értékre állítja:You can change this behavior by setting the following environment variable to an integer value:

PSWorkerInProcConcurrencyUpperBound

Ezt a környezeti változót a függvényalkalmazás alkalmazás beállításaiban állíthatja be.You set this environment variable in the app settings of your Function App.

A párhuzamosság használatának szempontjaiConsiderations for using concurrency

Alapértelmezés szerint a PowerShell egyszálas parancsfájlkezelési nyelv.PowerShell is a single threaded scripting language by default. A párhuzamosság azonban több PowerShell-futási terek is hozzáadható ugyanabban a folyamatban.However, concurrency can be added by using multiple PowerShell runspaces in the same process. A létrehozott futási terek mérete megegyezik a PSWorkerInProcConcurrencyUpperBound alkalmazás beállításával.The amount of runspaces created will match the PSWorkerInProcConcurrencyUpperBound application setting. Az átviteli sebességet a kiválasztott csomagban elérhető CPU és memória mennyisége befolyásolja.The throughput will be impacted by the amount of CPU and memory available in the selected plan.

A Azure PowerShell egyes folyamat-szintű kontextusokat és állapotot használ, hogy segítsen a felesleges gépelésben.Azure PowerShell uses some process-level contexts and state to help save you from excess typing. Ha azonban a függvény alkalmazásban bekapcsolja a párhuzamosságot, és meghívja az állapotot megváltoztató műveleteket, akkor a verseny feltételei is megváltozhatnak.However, if you turn on concurrency in your function app and invoke actions that change state, you could end up with race conditions. Ezek a versenyhelyzet nehéz hibakeresést végezni, mert egy hívás egy bizonyos állapotra támaszkodik, és a másik meghívás megváltoztatta az állapotot.These race conditions are difficult to debug because one invocation relies on a certain state and the other invocation changed the state.

Az Azure PowerShell-ben óriási érték van, mivel néhány művelet jelentős időt vehet igénybe.There's immense value in concurrency with Azure PowerShell, since some operations can take a considerable amount of time. Azonban körültekintően kell eljárnia.However, you must proceed with caution. Ha azt gyanítja, hogy a verseny feltételét tapasztalja, állítsa a PSWorkerInProcConcurrencyUpperBound alkalmazás beállítását 1 értékre, és Ehelyett használja a nyelv munkavégző folyamat szintjének elkülönítését a párhuzamossághoz.If you suspect that you're experiencing a race condition, set the PSWorkerInProcConcurrencyUpperBound app setting to 1 and instead use language worker process level isolation for concurrency.

A függvény konfigurálása @no__t – 0Configure function scriptFile

Alapértelmezés szerint a rendszer a PowerShell-függvényt run.ps1 fájlból hajtja végre, amely ugyanazokat a szülő könyvtárat osztja meg, mint a megfelelő function.json.By default, a PowerShell function is executed from run.ps1, a file that shares the same parent directory as its corresponding function.json.

A function.json scriptFile tulajdonsága a következő példához hasonló mappa-struktúra beszerzésére használható:The scriptFile property in the function.json can be used to get a folder structure that looks like the following example:

FunctionApp
 | - host.json
 | - myFunction
 | | - function.json
 | - lib
 | | - PSFunction.ps1

Ebben az esetben a myFunction function.json tartalmaz egy scriptFile tulajdonságot, amely a fájlra hivatkozik, és az exportált függvénnyel fut.In this case, the function.json for myFunction includes a scriptFile property referencing the file with the exported function to run.

{
  "scriptFile": "../lib/PSFunction.ps1",
  "bindings": [
    // ...
  ]
}

PowerShell-modulok használata BelépésiPont konfigurálásávalUse PowerShell modules by configuring an entryPoint

Ez a cikk a sablonok által generált alapértelmezett run.ps1 parancsfájl PowerShell-függvényeit mutatja.This article has shown PowerShell functions in the default run.ps1 script file generated by the templates. A függvényeket azonban PowerShell-modulokban is felveheti.However, you can also include your functions in PowerShell modules. A modulban a function. JSON konfigurációs fájl scriptFile és entryPoint mezőinek használatával hivatkozhat az adott függvény kódjára.You can reference your specific function code in the module by using the scriptFile and entryPoint fields in the function.json` configuration file.

Ebben az esetben a entryPoint a scriptFile-ben hivatkozott PowerShell-modul függvényének vagy parancsmagjának a neve.In this case, entryPoint is the name of a function or cmdlet in the PowerShell module referenced in scriptFile.

Vegye figyelembe a következő mappastruktúrát:Consider the following folder structure:

FunctionApp
 | - host.json
 | - myFunction
 | | - function.json
 | - lib
 | | - PSFunction.psm1

Ahol a PSFunction.psm1 a következőket tartalmazza:Where PSFunction.psm1 contains:

function Invoke-PSTestFunc {
    param($InputBinding, $TriggerMetadata)

    Push-OutputBinding -Name OutputBinding -Value "output"
}

Export-ModuleMember -Function "Invoke-PSTestFunc"

Ebben a példában a myFunction konfigurációjában szerepel egy scriptFile tulajdonság, amely PSFunction.psm1 értékre hivatkozik, amely egy másik mappában található PowerShell-modul.In this example, the configuration for myFunction includes a scriptFile property that references PSFunction.psm1, which is a PowerShell module in another folder. A entryPoint tulajdonság a Invoke-PSTestFunc függvényre hivatkozik, amely a modul belépési pontja.The entryPoint property references the Invoke-PSTestFunc function, which is the entry point in the module.

{
  "scriptFile": "../lib/PSFunction.psm1",
  "entryPoint": "Invoke-PSTestFunc",
  "bindings": [
    // ...
  ]
}

Ezzel a konfigurációval a Invoke-PSTestFunc a run.ps1 értéknek megfelelően lesz végrehajtva.With this configuration, the Invoke-PSTestFunc gets executed exactly as a run.ps1 would.

A PowerShell-függvények szempontjaiConsiderations for PowerShell functions

A PowerShell-függvények használatakor vegye figyelembe az alábbi részekben ismertetett szempontokat.When you work with PowerShell functions, be aware of the considerations in the following sections.

HidegindítóCold Start

Azure Functions a kiszolgáló nélküli üzemeltetési modellbenvaló fejlesztésekor a hideg indítás a valóság.When developing Azure Functions in the serverless hosting model, cold starts are a reality. A hűtőházi kezdés azt az időtartamot jelenti, ameddig a Function alkalmazásnak futnia kell a kérelem feldolgozásához.Cold start refers to period of time it takes for your function app to start running to process a request. A hidegindító folyamat gyakrabban fordul elő a fogyasztási tervben, mert a Function alkalmazás leáll az inaktivitási időszakok során.Cold start happens more frequently in the Consumption plan because your function app gets shut down during periods of inactivity.

Köteg modulok a Install-Module használata helyettBundle modules instead of using Install-Module

A szkript minden meghívásnál fut.Your script is run on every invocation. Kerülje a Install-Module használatát a parancsfájlban.Avoid using Install-Module in your script. Ehelyett használja a Save-Module értéket a közzététel előtt, így a függvénynek nem kell időt pazarolnia a modul letöltésével.Instead use Save-Module before publishing so that your function doesn't have to waste time downloading the module. Ha a ritkán használt funkciók hatással vannak a függvényekre, érdemes lehet a Function alkalmazást egy olyan app Service-csomagra telepíteni , amely a prémium szintű csomagravan beállítva.If cold starts are impacting your functions, consider deploying your function app to an App Service plan set to always on or to a Premium plan.

További lépésekNext steps

További információkért lásd a következőket:For more information, see the following resources: