Útmutató a C# Azure Functions izolált feldolgozói folyamatban való futtatásához
Ez a cikk a .NET Functions izolált feldolgozói folyamatának használatát ismerteti, amely a függvényeket egy elkülönített feldolgozófolyamatban futtatja az Azure-ban. Ez lehetővé teszi a .NET-osztálytár függvényeinek futtatását a .NET olyan verzióján, amely eltér a Functions-gazdagép folyamat által használt verziótól. További információ a támogatott .NET-verziókról: Támogatott verzió.
Az alábbi hivatkozások segítségével azonnal megkezdheti a .NET izolált feldolgozói folyamatfüggvényeinek összeállítását.
| Első lépések | Alapelvek | Példák |
|---|---|---|
Ha továbbra is ugyanabban a folyamatban kell futtatnia a függvényeket, mint a gazdagép, tekintse meg a C#-osztály kódtárának folyamaton belüli függvényeit ismertető cikket.
Az izolált feldolgozói folyamat és a folyamaton belüli .NET-függvények átfogó összehasonlításáért lásd: A folyamaton belüli és a feldolgozói folyamat elkülönítése közötti különbségek .NET-Azure Functions.
Miért a .NET Functions izolált feldolgozófolyamata?
Bevezetésekor Azure Functions csak a .NET-függvények szorosan integrált módját támogatták. Ebben a folyamatban lévő módban a .NET-osztálytár függvényei ugyanabban a folyamatban futnak, mint a gazdagép. Ez a mód mély integrációt biztosít a gazdafolyamat és a függvények között. Ha például ugyanabban a folyamatban fut, a .NET-osztálytár függvényei megoszthatják a kötési API-kat és -típusokat. Ehhez az integrációhoz azonban szoros összekapcsolásra is szükség van a gazdafolyamat és a .NET-függvény között. A folyamatban futó .NET-függvényeket például a .NET ugyanazon verzióján kell futtatni, mint a Functions-futtatókörnyezetet. Ez azt jelenti, hogy a folyamaton belüli függvények csak hosszú távú támogatással (LTS) rendelkező .NET-verzión futtathatók. Ha engedélyezni szeretné, hogy a .NET nem LTS-verzióján fusson, dönthet úgy, hogy egy elkülönített feldolgozófolyamatban futtatja a parancsot. Ezzel a folyamatelkülönítéssel olyan függvényeket fejleszthet, amelyek a Functions-futtatókörnyezet által natív módon nem támogatott aktuális .NET-kiadásokat használják, beleértve a .NET-keretrendszer. Az izolált feldolgozói folyamat és a folyamatban lévő C#-osztály kódtárfüggvényei LTS-verziókon is futnak. További információ: Támogatott verziók.
Mivel ezek a függvények külön folyamatban futnak, a .NET izolált függvényalkalmazások és a .NET-osztálytár függvényalkalmazásai között van néhány funkció- és funkcióbeli különbség .
Az izolált feldolgozói folyamat előnyei
Ha a .NET-függvények izolált feldolgozófolyamatban futnak, az alábbi előnyöket használhatja ki:
- Kevesebb ütközés: mivel a függvények külön folyamatban futnak, az alkalmazásban használt szerelvények nem ütköznek a gazdafolyamat által használt szerelvények különböző verziójával.
- A folyamat teljes vezérlése: ön szabályozza az alkalmazás indítását, és szabályozhatja a használt konfigurációkat és a köztes szoftver elindítását.
- Függőséginjektálás: mivel teljes mértékben szabályozhatja a folyamatot, a függőséginjektáláshoz és a köztes szoftver függvényalkalmazásba való beépítéséhez használhatja az aktuális .NET-viselkedéseket.
Támogatott verziók
A Functions-futtatókörnyezet verziói a .NET adott verzióival működnek. További információ a Functions-verziókról: Azure Functions futtatókörnyezet verzióinak áttekintése. A verziótámogatás attól függ, hogy a függvények folyamatban vagy elkülönített feldolgozófolyamatban futnak-e.
Megjegyzés
A függvényalkalmazás által használt Functions-futtatókörnyezet verziójának módosításáról az aktuális futtatókörnyezeti verzió megtekintésével és frissítésével kapcsolatos cikkben olvashat.
Az alábbi táblázat a Függvények adott verziójával használható .NET Core vagy .NET-keretrendszer legmagasabb szintjét mutatja be.
| A Functions futtatókörnyezetének verziója | Folyamatban (.NET-osztálytár) |
Izolált feldolgozói folyamat (.NET izolált) |
|---|---|---|
| Functions 4.x | .NET 6.0 | .NET 6.0 .NET 7.0 (GA)1 .NET-keretrendszer 4.8 (GA)1 |
| Functions 1.x | .NET-keretrendszer 4.8 | n.a. |
1 A buildelési folyamathoz a .NET 6 SDK is szükséges.
Az Azure Functions kiadásokkal kapcsolatos legfrissebb hírekért, beleértve a régebbi alverziók eltávolítását, figyelje Azure App Service bejelentéseket.
.NET izolált feldolgozói folyamat projektje
A .NET izolált függvényprojektek alapvetően egy .NET-konzolalkalmazás-projekt, amely egy támogatott .NET-futtatókörnyezetet céloz meg. Az alábbi alapvető fájlok szükségesek minden .NET-izolált projekthez:
- host.json fájl.
- local.settings.json fájl.
- C# projektfájl (.csproj), amely meghatározza a projektet és a függőségeket.
- Program.cs fájl, amely az alkalmazás belépési pontja.
- A függvényeket meghatározó kódfájlok.
A teljes példákért tekintse meg a .NET 6 izolált mintaprojektet és a .NET-keretrendszer 4.8 izolált mintaprojektet.
Megjegyzés
Ahhoz, hogy az izolált függvényprojekt közzétehető legyen egy Windows- vagy Linux-függvényalkalmazásban az Azure-ban, be kell állítania dotnet-isolated egy értéket a távoli FUNCTIONS_WORKER_RUNTIME alkalmazásbeállításban. A zip-alapú telepítés támogatásához és a linuxos telepítési csomagból való futtatásához a hely konfigurációs beállítását linuxFxVersion is frissítenie kell a következőre: DOTNET-ISOLATED|7.0. További információ: Manuális verziófrissítések Linuxon.
Csomaghivatkozások
A .NET Functions izolált feldolgozófolyamat-projektek egyedi csomagkészletet használnak az alapvető funkciókhoz és a kötési bővítményekhez.
Alapcsomagok
A .NET-függvények izolált feldolgozófolyamatban való futtatásához a következő csomagok szükségesek:
Bővítménycsomagok
Mivel a .NET izolált feldolgozói folyamatfüggvényei különböző kötéstípusokat használnak, egyedi kötésbővítmény-csomagokra van szükségük.
Ezeket a bővítménycsomagokat a Microsoft.Azure.Functions.Worker.Extensions területen találja.
Indítás és konfigurálás
Izolált .NET-függvények használatakor hozzáférhet a függvényalkalmazás elindításához, amely általában a Program.cs fájlban található. Ön a felelős a saját gazdagéppéldányok létrehozásáért és elindításáért. Így közvetlenül is hozzáférhet az alkalmazás konfigurációs folyamatához. A .NET Functions izolált feldolgozói folyamatával sokkal egyszerűbben adhat hozzá konfigurációkat, injektálhat függőségeket, és futtathatja saját köztes szoftverét.
Az alábbi kód egy HostBuilder-folyamat példáját mutatja be:
var host = new HostBuilder()
.ConfigureFunctionsWorkerDefaults(builder =>
{
builder
.AddApplicationInsights()
.AddApplicationInsightsLogger();
})
.ConfigureServices(s =>
{
s.AddSingleton<IHttpResponderService, DefaultHttpResponderService>();
})
.Build();
Ehhez a kódhoz a szükséges using Microsoft.Extensions.DependencyInjection;.
A HostBuilder egy teljesen inicializált IHost-példány létrehozására és visszaadására szolgál, amelyet aszinkron módon futtat a függvényalkalmazás elindításához.
await host.RunAsync();
Fontos
Ha a projekt a 4.8-.NET-keretrendszer célozza meg, a HostBuilder létrehozása előtt is hozzá kell adniaFunctionsDebugger.Enable();. Ez lesz a metódus első sora Main() . További információ: Hibakeresés .NET-keretrendszer célzáskor.
Konfiguráció
A ConfigureFunctionsWorkerDefaults metódussal adhatja hozzá a függvényalkalmazáshoz szükséges beállításokat egy elkülönített feldolgozófolyamatban, amely a következő funkciókat tartalmazza:
- Konverterek alapértelmezett készlete.
- Állítsa be az alapértelmezett JsonSerializerOptions beállítást, hogy figyelmen kívül hagyja a tulajdonságneveken a burkolatot.
- Integrálás Azure Functions naplózással.
- Kimeneti kötés közbenső szoftvere és funkciói.
- Függvényvégrehajtás közbenső szoftvere.
- Alapértelmezett gRPC-támogatás.
.ConfigureFunctionsWorkerDefaults(builder =>
{
builder
.AddApplicationInsights()
.AddApplicationInsightsLogger();
})
A gazdagépszerkesztő folyamatához való hozzáférés azt jelenti, hogy az inicializálás során bármilyen alkalmazásspecifikus konfigurációt is beállíthat. A ConfigureAppConfiguration metódust meghívhatja a HostBuilderen egy vagy több alkalommal, hogy hozzáadja a függvényalkalmazáshoz szükséges konfigurációkat. Az alkalmazáskonfigurációval kapcsolatos további információkért lásd: Konfiguráció ASP.NET Core.
Ezek a konfigurációk a külön folyamatban futó függvényalkalmazásra vonatkoznak. A függvénygazda vagy az eseményindító és a kötés konfigurációjának módosításához továbbra is a host.json fájlt kell használnia.
Függőséginjektálás
A függőséginjektálás egyszerűbb, mint a .NET-osztálykódtárak. Ahelyett, hogy létre kell hoznia egy indítási osztályt a szolgáltatások regisztrálásához, csak meg kell hívnia a ConfigureServices szolgáltatást a gazdagépszerkesztőben, és az IServiceCollection bővítménymetóit kell használnia bizonyos szolgáltatások injektálásához.
Az alábbi példa egy singleton-szolgáltatásfüggőséget szúr be:
.ConfigureServices(s =>
{
s.AddSingleton<IHttpResponderService, DefaultHttpResponderService>();
})
Ehhez a kódhoz a szükséges using Microsoft.Extensions.DependencyInjection;. További információ: Függőséginjektálás ASP.NET Core.
Közbenső szoftver
Az elkülönített .NET támogatja a köztes szoftverregisztrációt is a ASP.NET-ben találhatóhoz hasonló modellel. Ez a modell lehetővé teszi, hogy logikát injektáljon a meghívási folyamatba, valamint a függvények végrehajtása előtt és után.
A ConfigureFunctionsWorkerDefaults bővítménymetódus túlterheléssel rendelkezik, amely lehetővé teszi a saját köztes szoftver regisztrálását, amint az az alábbi példában látható.
var host = new HostBuilder()
.ConfigureFunctionsWorkerDefaults(workerApplication =>
{
// Register our custom middlewares with the worker
workerApplication.UseMiddleware<ExceptionHandlingMiddleware>();
workerApplication.UseMiddleware<MyCustomMiddleware>();
workerApplication.UseWhen<StampHttpHeaderMiddleware>((context) =>
{
// We want to use this middleware only for http trigger invocations.
return context.FunctionDefinition.InputBindings.Values
.First(a => a.Type.EndsWith("Trigger")).Type == "httpTrigger";
});
})
.Build();
A UseWhen bővítménymetódussal regisztrálható egy feltételesen végrehajtott köztes szoftver. Ennek a metódusnak olyan predikátumot kell átadnia, amely logikai értéket ad vissza, és a köztes szoftver részt vesz az invocation feldolgozási folyamatban, ha a predikátum visszatérési értéke .true
A FunctionContext következő bővítménymetódusai megkönnyítik a köztes szoftver használatát az izolált modellben.
| Metódus | Leírás |
|---|---|
GetHttpRequestDataAsync |
Lekéri a HttpRequestData példányt, amikor egy HTTP-eseményindító meghívja. Ez a metódus egy példányt ValueTask<HttpRequestData?>ad vissza, amely akkor hasznos, ha üzenetadatokat szeretne olvasni, például kérésfejléceket és cookie-kat. |
GetHttpResponseData |
Lekéri a HttpResponseData példányt, amikor egy HTTP-eseményindító meghívja. |
GetInvocationResult |
Lekéri a példányt InvocationResult, amely az aktuális függvény végrehajtásának eredményét jelöli. Value A tulajdonság használatával igény szerint lekérheti vagy beállíthatja az értéket. |
GetOutputBindings |
Lekéri az aktuális függvény végrehajtásához tartozó kimeneti kötési bejegyzéseket. A metódus eredményében szereplő összes bejegyzés típusa OutputBindingData. A tulajdonság használatával Value igény szerint lekérheti vagy beállíthatja az értéket. |
BindInputAsync |
Kötést hoz létre egy bemeneti kötési elemhez a kért BindingMetadata példányhoz. Ezt a módszert például akkor használhatja, ha rendelkezik egy bemeneti kötéssel rendelkező függvénnyel BlobInput , amelyet a köztes szoftvernek el kell érnie vagy frissítenie kell. |
Az alábbi példa egy köztes szoftveres implementációra mutat be, amely beolvassa a HttpRequestData példányt, és frissíti a példányt a HttpResponseData függvény végrehajtása során. Ez a köztes szoftver ellenőrzi egy adott kérelemfejléc (x-correlationId) jelenlétét, és ha a jelen van, a fejlécérték használatával lepecsételi a válaszfejlécet. Ellenkező esetben létrehoz egy új GUID-értéket, és ezt használja a válaszfejléc lepecsételéshez.
internal sealed class StampHttpHeaderMiddleware : IFunctionsWorkerMiddleware
{
public async Task Invoke(FunctionContext context, FunctionExecutionDelegate next)
{
var requestData = await context.GetHttpRequestDataAsync();
string correlationId;
if (requestData!.Headers.TryGetValues("x-correlationId", out var values))
{
correlationId = values.First();
}
else
{
correlationId = Guid.NewGuid().ToString();
}
await next(context);
context.GetHttpResponseData()?.Headers.Add("x-correlationId", correlationId);
}
}
Az egyéni köztes szoftver függvényalkalmazásban való használatára vonatkozó teljesebb példáért tekintse meg az egyéni köztes szoftver referenciamintáját.
Lemondási jogkivonatok
A függvények elfogadhatnak egy CancellationToken paramétert, amely lehetővé teszi, hogy az operációs rendszer értesítse a kódot, amikor a függvény leáll. Ezzel az értesítéssel meggyőződhet arról, hogy a függvény nem fejeződik be váratlanul oly módon, hogy az adatok inkonzisztens állapotban maradnak.
A lemondási jogkivonatok támogatottak a .NET-függvényekben, ha elkülönített feldolgozófolyamatban futnak. Az alábbi példa kivételt jelez, ha egy lemondási kérelem érkezett:
[Function(nameof(ThrowOnCancellation))]
public async Task ThrowOnCancellation(
[EventHubTrigger("sample-workitem-1", Connection = "EventHubConnection")] string[] messages,
FunctionContext context,
CancellationToken cancellationToken)
{
_logger.LogInformation("C# EventHub {functionName} trigger function processing a request.", nameof(ThrowOnCancellation));
foreach (var message in messages)
{
cancellationToken.ThrowIfCancellationRequested();
await Task.Delay(6000); // task delay to simulate message processing
_logger.LogInformation("Message '{msg}' was processed.", message);
}
}
Az alábbi példa törlési műveleteket hajt végre, ha lemondási kérés érkezett:
[Function(nameof(HandleCancellationCleanup))]
public async Task HandleCancellationCleanup(
[EventHubTrigger("sample-workitem-2", Connection = "EventHubConnection")] string[] messages,
FunctionContext context,
CancellationToken cancellationToken)
{
_logger.LogInformation("C# EventHub {functionName} trigger function processing a request.", nameof(HandleCancellationCleanup));
foreach (var message in messages)
{
if (cancellationToken.IsCancellationRequested)
{
_logger.LogInformation("A cancellation token was received, taking precautionary actions.");
// Take precautions like noting how far along you are with processing the batch
_logger.LogInformation("Precautionary activities complete.");
break;
}
await Task.Delay(6000); // task delay to simulate message processing
_logger.LogInformation("Message '{msg}' was processed.", message);
}
}
ReadyToRun
A függvényalkalmazást ReadyToRun bináris fájlokként fordíthatja le. A ReadyToRun az idő előtti fordítás egy formája, amely javíthatja az indítási teljesítményt, hogy csökkentse a hidegindítás hatását a használatalapú csomagban való futtatáskor.
A ReadyToRun a .NET 6-os és újabb verzióiban érhető el, és a Azure Functions futtatókörnyezet 4.0-s vagy újabb verzióját igényli.
Ha ReadyToRunként szeretné lefordítani a projektet, frissítse a projektfájlt a és <RuntimeIdentifier> az <PublishReadyToRun> elemek hozzáadásával. Az alábbiakban a Windows 32 bites függvényalkalmazásokban való közzététel konfigurációját követve tesszük közzé.
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<AzureFunctionsVersion>v4</AzureFunctionsVersion>
<RuntimeIdentifier>win-x86</RuntimeIdentifier>
<PublishReadyToRun>true</PublishReadyToRun>
</PropertyGroup>
Végrehajtási környezet
A .NET izolált függvénykontext objektumot ad át a függvénymetódusainak. Ez az objektum lehetővé teszi egy ILogger-példány lekérését a naplókba való íráshoz a GetLogger metódus meghívásával és egy sztring categoryName megadásával. További információ: Naplózás.
Kötések
A kötések metódusokon, paramétereken és visszatérési típusokon alapuló attribútumok használatával vannak definiálva. A függvénymetódus egy olyan metódus, amelynek attribútuma Function és triggerattribútuma egy bemeneti paraméterre van alkalmazva, ahogyan az alábbi példában látható:
[Function("QueueFunction")]
[QueueOutput("output-queue")]
public static string[] Run([QueueTrigger("input-queue")] Book myQueueItem, FunctionContext context)
Az eseményindító attribútum meghatározza az eseményindító típusát, és a bemeneti adatokat egy metódusparaméterhez köti. Az előző példafüggvényt egy üzenetsor-üzenet aktiválja, az üzenetsor-üzenet pedig a paraméter metódusának myQueueItem lesz átadva.
Az Function attribútum függvénybejegyzési pontként jelöli meg a metódust. A névnek egyedinek kell lennie egy projekten belül, betűvel kell kezdődnie, és csak betűket, számokat és _, és -, legfeljebb 127 karakter hosszúságú karaktereket kell tartalmaznia. A projektsablonok gyakran létrehoznak egy nevű Runmetódust, de a metódus neve bármilyen érvényes C#-metódusnév lehet.
A kötések sztringekként, tömbökként és szerializálható típusokként, például egyszerű régi osztályobjektumokként (POCO-k) biztosíthatnak adatokat. Egyes szolgáltatási SDK-kból is köthet típusokat.
HTTP-eseményindítók esetén a httpRequestData és a HttpResponseData használatával kell hozzáférnie a kérelem- és válaszadatokhoz. Ennek az az oka, hogy a .NET Functions izolált munkavégző folyamatának használatakor nincs hozzáférése az eredeti HTTP-kérés- és válaszobjektumokhoz.
Az eseményindítók és kötések izolált feldolgozófolyamat-függvényekkel való használatára vonatkozó referenciaminták teljes készletét lásd a kötésbővítmények referenciamintájában.
Bemeneti kötések
A függvények nulla vagy több bemeneti kötéssel rendelkezhetnek, amelyek adatokat adhatnak át egy függvénynek. Az eseményindítókhoz hasonlóan a bemeneti kötések is úgy vannak definiálva, hogy egy kötési attribútumot alkalmaznak egy bemeneti paraméterre. A függvény végrehajtásakor a futtatókörnyezet megpróbálja lekérni a kötésben megadott adatokat. A kért adatok gyakran függnek az eseményindító által a kötési paramétereket használó információktól.
Kimeneti kötések
Kimeneti kötésbe való íráshoz egy kimeneti kötési attribútumot kell alkalmaznia a függvénymetódusra, amely meghatározta, hogyan írhat a kötött szolgáltatásba. A metódus által visszaadott érték a kimeneti kötésbe lesz írva. Az alábbi példa például egy kimeneti kötéssel ír egy sztringértéket egy elnevezett output-queue üzenetsorba:
[Function("QueueFunction")]
[QueueOutput("output-queue")]
public static string[] Run([QueueTrigger("input-queue")] Book myQueueItem, FunctionContext context)
{
// Use a string array to return more than one message.
string[] messages = {
$"Book name = {myQueueItem.Name}",
$"Book ID = {myQueueItem.Id}"};
var logger = context.GetLogger("QueueFunction");
logger.LogInformation($"{messages[0]},{messages[1]}");
// Queue Output messages
return messages;
}
Több kimeneti kötés
A kimeneti kötésbe írt adatok mindig a függvény visszatérési értéke. Ha több kimeneti kötésbe kell írnia, létre kell hoznia egy egyéni visszatérési típust. Ennek a visszatérési típusnak a osztály egy vagy több tulajdonságára alkalmazott kimeneti kötési attribútummal kell rendelkeznie. A HTTP-eseményindító következő példája a HTTP-válaszra és az üzenetsor kimeneti kötésére is ír:
public static class MultiOutput
{
[Function("MultiOutput")]
public static MyOutputType Run([HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequestData req,
FunctionContext context)
{
var response = req.CreateResponse(HttpStatusCode.OK);
response.WriteString("Success!");
string myQueueOutput = "some output";
return new MyOutputType()
{
Name = myQueueOutput,
HttpResponse = response
};
}
}
public class MyOutputType
{
[QueueOutput("myQueue")]
public string Name { get; set; }
public HttpResponseData HttpResponse { get; set; }
}
A HTTP-eseményindítók válasza mindig kimenetnek számít, így nincs szükség visszatérési érték attribútumra.
SDK-típusok (előzetes verzió)
Egyes szolgáltatásspecifikus kötéstípusok esetében a kötési adatok szolgáltatás SDK-k és -keretrendszerek típusaival adhatók meg. Ezek további képességeket biztosítanak azon túl, amit egy szerializált sztring vagy egyszerű régi CLR-objektum (POCO) kínálhat. Az SDK-típusok támogatása jelenleg előzetes verzióban érhető el, korlátozott forgatókönyv-lefedettséggel.
Az SDK-típusú kötések használatához a projektnek a Microsoft.Azure.Functions.Worker 1.12.1-preview1 vagy újabb és a Microsoft.Azure.Functions.Worker.Sdk 1.9.0-preview1 vagy újabb verzióra kell hivatkoznia. Az egyes szolgáltatásbővítményekhez külön csomagverziókra is szükség lesz. Ha helyileg teszteli az SDK-típusokat a gépen, Azure Functions Core Tools 4.0.5000-es vagy újabb verzióját is használnia kell. Az aktuális verziót a paranccsal func versionellenőrizheti.
Az előzetes verzió jelenleg a következő szolgáltatásspecifikus kötéseket tartalmazza:
| Szolgáltatás | Eseményindító | Bemeneti kötés | Kimeneti kötés |
|---|---|---|---|
| Azure Blobs | Előzetes verzió támogatása | Előzetes verzió támogatása | Még nem támogatott |
Az SDK-típuskötési minták példákat mutatnak be a különböző támogatott típusok használatára.
Megjegyzés
Az eseményindítók adataira támaszkodó kötési kifejezések használata esetén maga az eseményindító SDK-típusai nem támogatottak.
HTTP-eseményindító
A HTTP-eseményindítók a bejövő HTTP-kérelemüzenetet egy httpRequestData objektumra fordítják, amelyet a függvénynek ad át. Ez az objektum adatokat biztosít a kérésből, beleértve Headersa , Cookies, Identities, URLés opcionális üzenetet Body. Ez az objektum a HTTP-kérelemobjektumot ábrázolja, nem magát a kérést.
Hasonlóképpen, a függvény egy HttpResponseData objektumot ad vissza, amely a HTTP-válasz létrehozásához használt adatokat tartalmazza, beleértve az üzenetet StatusCode, Headersa és az opcionálisan egy üzenetet Body.
Az alábbi kód egy HTTP-eseményindító
[Function("HttpFunction")]
public static HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestData req,
FunctionContext executionContext)
{
var logger = executionContext.GetLogger("HttpFunction");
logger.LogInformation("message logged");
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
response.WriteString("Welcome to .NET isolated worker !!");
return response;
}
Naplózás
Az izolált .NET-ben a függvénynek átadott FunctionContext objektumból beszerzett ILogger-példány használatával írhat naplókba. Hívja meg a GetLogger metódust, és adjon meg egy sztringértéket, amely annak a kategóriának a neve, amelyben a naplók meg vannak írva. A kategória általában annak a függvénynek a neve, amelyből a naplók meg vannak írva. A kategóriákról a figyelési cikkből tudhat meg többet.
Az alábbi példa bemutatja, hogyan kérhet le egy ILoggert , és hogyan írhat naplókat egy függvényen belül:
var logger = executionContext.GetLogger("HttpFunction");
logger.LogInformation("message logged");
Az ILogger különböző módszereit használva különböző naplószinteket írhat, például LogWarning vagy LogError. A naplószintekről a monitorozási cikkből tudhat meg többet.
A függőséginjektálás használatakor ILogger is elérhető.
Hibakeresés .NET-keretrendszer
Ha az elkülönített projekt a 4.8-.NET-keretrendszer célozza meg, az aktuális előzetes verzió hatóköréhez manuális lépések szükségesek a hibakeresés engedélyezéséhez. Ezek a lépések nem szükségesek egy másik cél-keretrendszer használata esetén.
Az alkalmazásnak első műveleteként hívással FunctionsDebugger.Enable(); kell kezdődnie. Ez a metódusban fordul elő a Main() HostBuilder inicializálása előtt. A Program.cs fájlnak az alábbihoz hasonlóan kell kinéznie:
using System;
using System.Diagnostics;
using Microsoft.Extensions.Hosting;
using Microsoft.Azure.Functions.Worker;
using NetFxWorker;
namespace MyDotnetFrameworkProject
{
internal class Program
{
static void Main(string[] args)
{
FunctionsDebugger.Enable();
var host = new HostBuilder()
.ConfigureFunctionsWorkerDefaults()
.Build();
host.Run();
}
}
}
Ezután manuálisan kell csatolnia a folyamatot egy .NET-keretrendszer hibakereső használatával. A Visual Studio ezt még nem teszi meg automatikusan az elkülönített feldolgozói folyamat .NET-keretrendszer alkalmazások esetében, és a "Hibakeresés indítása" műveletet el kell kerülni.
A projektkönyvtárban (vagy annak kimeneti buildkönyvtárában) futtassa a következőt:
func host start --dotnet-isolated-debug
Ez elindítja a feldolgozót, és a folyamat a következő üzenettel leáll:
Azure Functions .NET Worker (PID: <process id>) initialized in debug mode. Waiting for debugger to attach...
Hol <process id> található a munkavégző folyamat azonosítója. Mostantól manuálisan is csatolhatja a folyamatot a Visual Studióval. A művelettel kapcsolatos utasításokért lásd: Hogyan csatolható egy futó folyamathoz.
A hibakereső csatolása után a folyamat végrehajtása folytatódik, és ön képes lesz a hibakeresésre.
Távoli hibakeresés a Visual Studióval
Mivel az izolált feldolgozófolyamat-alkalmazás a Functions-futtatókörnyezeten kívül fut, a távoli hibakeresőt külön folyamathoz kell csatolnia. A Visual Studio használatával végzett hibakeresésről további információt a Távoli hibakeresés című témakörben talál.