A Durable Functions problémáinak diagnosztizálása és elhárítása

A Durable Functions számos diagnosztikai eszközt biztosít a vezénylések hibaelhárításához. Ez a cikk bemutatja, hogyan konfigurálhatja a nyomkövetést és a naplózást, hogyan írhat visszajátszással biztonságos kódot, hogyan vizsgálhatja meg az elosztott nyomkövetéseket, és hogyan végezhet hibakeresést helyileg.

Ebből a cikkből megtudhatja, hogyan:

• Az Application Insights nyomon követésének konfigurálása életciklus-eseményekhez
• Lekérdezési vezénylési példányok a Kusto használatával
• Tartós feladat-keretrendszer (DTFx) naplózásának engedélyezése alacsony szintű diagnosztikához
• Elosztott nyomkövetés beállítása a végpontok közötti vezénylési folyamatok vizualizációja érdekében
• Visszajátszásbiztos naplók írása vezénylő függvényekben
• Egyéni orkesztrációs állapot jelentése külső ügyfeleknek
• Vezénylések helyi hibakeresése töréspontok használatával

Az Application Insights nyomon követésének konfigurálása

Az Application Insights a Durable Functions monitorozásának ajánlott módja. A Durable bővítmény nyomkövetési eseményeket bocsát ki, amelyek segítségével nyomon követheti egy vezénylés végpontok közötti végrehajtását. Ezeket a nyomon követési eseményeket a Application Insights Analytics eszközzel találja meg és kérdezheti le a Azure portálon.

Naplószintű konfiguráció

Konfigurálja az Application Insightsnak a host.json fájlban kibocsátott nyomkövetési adatok részletességét:

{
    "logging": {
        "logLevel": {
            "Host.Triggers.DurableTask": "Information",
        },
    }
}

Alapértelmezés szerint minden nem újrajátszási nyomkövetési esemény kibocsátásra kerül. Az adatok mennyiségének csökkentése érdekében állítsa be a Host.Triggers.DurableTask vagy "Warning" értékeket "Error"-re, ami azt jelenti, hogy csak kivételes helyzetekben kerül sor események kibocsátására. Ha engedélyezni szeretné a részletes vezénylési ismétlési események kibocsátását, állítsa a logReplayEvents értéket true-re a host.json konfigurációs fájlban.

Note

Alapértelmezés szerint az Azure Functions futtatókörnyezet mintavételezi az Application Insights telemetriai adatait, hogy elkerülje az adatok túl gyakori kibocsátását. A mintavételezés a nyomon követési információk elvesztését okozhatja, ha rövid időn belül számos életciklus-esemény történik. A Azure Functions monitorozási cikk ismerteti a viselkedés konfigurálását.

Bemeneti és kimeneti naplózás

Alapértelmezés szerint a vezénylő, a tevékenység és az entitásfüggvény bemenetei és kimenetei nincsenek naplózva. Ez a megközelítés azért ajánlott, mert a bemenetek és kimenetek naplózása növelheti az Application Insights költségeit. A bemeneti és kimeneti terhelések bizalmas információkat is tartalmazhatnak. Ehelyett a függvénybemenetek és -kimenetek bájtjainak száma lesz naplózva. Ha azt szeretné, hogy a Durable Functions bővítmény naplózza a teljes bemeneti és kimeneti hasznos adatokat, állítsa a traceInputsAndOutputs tulajdonságot true értékre a host.json konfigurációs fájlban.

Orchesztrációs lekérdezési példányok

Az Application Insights Analyticsben használja az alábbi Kusto-lekérdezéseket az orchestration példányok vizsgálatához.

Egyedüli példány lekérdezés

Az alábbi lekérdezés a Hello Sequence függvény vezénylésének egyetlen példányára vonatkozó előzménykövetési adatokat mutatja be. Kiszűri a visszajátszás végrehajtását, így csak a logikai végrehajtási útvonal jelenik meg. Az események rendezhetők az alábbi lekérdezés szerint timestamp és sequenceNumber módon:

let targetInstanceId = "ddd1aaa685034059b545eb004b15d4eb";
let start = datetime(2018-03-25T09:20:00);
traces
| where timestamp > start and timestamp < start + 30m
| where customDimensions.Category == "Host.Triggers.DurableTask"
| extend functionName = customDimensions["prop__functionName"]
| extend instanceId = customDimensions["prop__instanceId"]
| extend state = customDimensions["prop__state"]
| extend isReplay = tobool(tolower(customDimensions["prop__isReplay"]))
| extend sequenceNumber = tolong(customDimensions["prop__sequenceNumber"])
| where isReplay != true
| where instanceId == targetInstanceId
| sort by timestamp asc, sequenceNumber asc
| project timestamp, functionName, state, instanceId, sequenceNumber, appName = cloud_RoleName

Az eredmény azoknak a nyomon követési eseményeknek a listája, amelyek a vezénylés végrehajtási útvonalát jelenítik meg, beleértve a végrehajtási idő által növekvő sorrendben rendezett tevékenységfüggvényeket is.

Példányösszegző lekérdezés

Az alábbi lekérdezés megjeleníti a megadott időtartományban futtatott orkesztrációs folyamatelemek állapotát.

let start = datetime(2017-09-30T04:30:00);
traces
| where timestamp > start and timestamp < start + 1h
| where customDimensions.Category == "Host.Triggers.DurableTask"
| extend functionName = tostring(customDimensions["prop__functionName"])
| extend instanceId = tostring(customDimensions["prop__instanceId"])
| extend state = tostring(customDimensions["prop__state"])
| extend isReplay = tobool(tolower(customDimensions["prop__isReplay"]))
| extend output = tostring(customDimensions["prop__output"])
| where isReplay != true
| summarize arg_max(timestamp, *) by instanceId
| project timestamp, instanceId, functionName, state, output, appName = cloud_RoleName
| order by timestamp asc

Az eredmény a példányazonosítók listája és az aktuális futtatókörnyezeti állapotuk.

Nyomon követési adathivatkozás

Minden vezénylési példány nyomon követési eseményeket hoz létre az életciklusa során. Minden életciklus-esemény tartalmaz egy customDimensions hasznos terhet több mezővel. A mezőnevek mindegyike prop__-vel kezdődik.

Mezőnév	Description
hubName	Annak a feladat központ neve, amelyben az orchestrációk futnak.
appName	A függvényalkalmazás neve Ez a mező akkor hasznos, ha több függvényalkalmazás is ugyanazt az Application Insights-példányt használja.
slotName	Az telepítési hely, amelyen az aktuális függvényalkalmazás fut. Ez a mező akkor hasznos, ha telepítési helyek használatával verziózza az orchestrationöket.
functionName	Az orchestrátor vagy tevékenységfüggvény neve.
functionType	A függvény típusa, például az Orchestrator vagy a Tevékenység.
instanceId	Az orchestrációs példány egyedi azonosítója.
state	A példány életciklus-végrehajtási állapota.
state.Scheduled	A függvény végrehajtásra lett ütemezve, de még nem indult el.
state.Started	A függvény elindult, de még nem várt vagy fejeződött be.
state.Awaited	Az orchestrátor beütemezett néhány munkát, és most arra vár, hogy azok befejeződjenek.
state.Listening	A vezénylő egy külső eseményértesítést figyel.
state.Completed	A függvény sikeresen befejeződött.
state.Failed	A függvény hiba miatt meghiúsult.
reason	A nyomkövetési eseményhez társított további adatok. Ha például egy példány egy külső eseményértesítésre vár, ez a mező annak az eseménynek a nevét jelzi, amelyre vár. Ha egy függvény meghibásodik, ez a mező tartalmazza a hiba részleteit.
isReplay	Logikai érték, amely azt jelzi, hogy a nyomkövetési esemény az újrajátszott végrehajtáshoz tartozik-e.
extensionVersion	A Durable Task bővítmény verziója. A verzióinformációk különösen fontos adatok a bővítmény lehetséges hibáinak jelentésekor. A hosszan futó példányok több verziót is jelenthetnek, ha a példány futtatása közben frissítés történik.
sequenceNumber	Egy esemény végrehajtási sorszáma. Az időbélyeggel kombinálva ez segít az eseményeket végrehajtási idő szerint rendezni. Vegye figyelembe, hogy ez a szám nullára visszaáll, ha a gazdagép újraindul a példány futása közben, ezért fontos, hogy mindig először időbélyeg szerint, majd a sequenceNumber szerint rendezze.

Tartós feladat-keretrendszer naplózása (DTFx)

A Durable bővítménynaplók hasznosak a vezénylési logika viselkedésének megértéséhez. Ezek a naplók azonban nem mindig tartalmaznak elegendő információt a keretrendszerszintű teljesítmény- és megbízhatósági problémák hibakereséséhez. A Durable bővítmény 2.3.0-s verziójától kezdve a mögöttes Durable Task Framework (DTFx) által kibocsátott naplók is elérhetők a gyűjteményhez.

A DTFx által kibocsátott naplók megtekintésekor fontos tisztában lenni azzal, hogy a DTFx motornak két összetevője van: a központi diszpécsermotor (DurableTask.Core) és a számos támogatott tárolószolgáltató egyike.

Összetevő	Description
DurableTask.Core	Alapvető vezénylési végrehajtás és alacsony szintű ütemezési naplók és telemetriai adatok.
DurableTask.DurableTaskScheduler	A Durable Task Schedulerre jellemző háttérnaplók.
DurableTask.AzureStorage	A Azure Storage állapotszolgáltatóra vonatkozó háttérnaplók. Ezek a naplók részletes interakciókat tartalmaznak a belső üzenetsorokkal, blobokkal és tárolótáblákkal a belső vezénylési állapot tárolásához és lekéréséhez.
DurableTask.Netherite	A Netherite tárhely szolgáltatóra vonatkozó háttérnaplók, ha engedélyezve van.
DurableTask.SqlServer	Ha engedélyezve van, a Microsoft SQL (MSSQL) tárolószolgáltatóra vonatkozó háttérnaplók.

Ezeket a naplókat a függvényalkalmazás logging/logLevel fájlban lévő szakasz frissítésével engedélyezheti. Az alábbi példa bemutatja, hogyan engedélyezheti a figyelmeztetési és hibanaplókat mind a kettőbőlDurableTask.Core:DurableTask.AzureStorage

{
  "version": "2.0",
  "logging": {
    "logLevel": {
      "DurableTask.AzureStorage": "Warning",
      "DurableTask.Core": "Warning"
    }
  }
}

Ha engedélyezve van az Application Insights, a rendszer automatikusan hozzáadja ezeket a naplókat a trace gyűjteményhez. A Kusto-lekérdezések használatával ugyanúgy kereshet rajtuk, mint más trace naplókban.

Note

Termelési alkalmazások esetén javasoljuk a DurableTask.Core, valamint a megfelelő tárhelyszolgáltatói naplók (például DurableTask.AzureStorage) engedélyezését a "Warning" szűrő használatával. A nagyobb részletességű szűrők, például "Information" a teljesítményproblémák hibakereséséhez hasznosak. Ezek a naplóesemények azonban nagy mennyiségűek lehetnek, és jelentősen növelhetik az Application Insights adattárolási költségeit.

Az alábbi Kusto-lekérdezés bemutatja, hogyan kérdezhet le DTFx-naplókat. A lekérdezés legfontosabb része where customerDimensions.Category startswith "DurableTask", mivel ez szűri az eredményeket a naplókra, valamint a DurableTask.Core és DurableTask.AzureStorage kategóriákra.

traces
| where customDimensions.Category startswith "DurableTask"
| project
    timestamp,
    severityLevel,
    Category = customDimensions.Category,
    EventId = customDimensions.EventId,
    message,
    customDimensions
| order by timestamp asc 

Az eredmény a Durable Task Framework naplószolgáltatói által írt naplók halmaza.

A naplóeseményekről további információt a Durable Task Framework strukturált naplózási dokumentációjában talál a GitHubon.

Elosztott nyomkövetés

Az elosztott nyomkövetés nyomon követi a kéréseket, és bemutatja, hogy a különböző szolgáltatások hogyan kommunikálnak egymással. A Durable Functions-ben az vezényléseket, entitásokat és tevékenységeket kapcsolja össze. Az elosztott nyomkövetés az egyes vezénylési lépések végrehajtási idejét jeleníti meg a teljes vezényléshez képest, és azonosítja, hogy hol fordulnak elő problémák vagy kivételek. Ez a funkció az Application Insightsban minden nyelvhez és társzolgáltatóhoz támogatott.

Prerequisites

Az elosztott nyomkövetéshez meghatározott minimális bővítményverziók szükségesek:

• Izolált .NET-alkalmazások esetén : Microsoft.Azure.Functions.Worker.Extensions.DurableTask>= v1.4.0.
• A nem .NET alkalmazások esetében kövesse ezeket az utasításokat a Microsoft.Azure.WebJobs.Extensions.DurableTask>= v3.2.0 manuális telepítéséhez most. Az elosztott nyomkövetés >v4.24.x bővítménycsomagokban érhető el.

Elosztott nyomkövetés beállítása

Az elosztott nyomkövetés konfigurálásához frissítse és állítsa be az host.json Application Insights-erőforrást.

host.json

{
   "extensions": {
     "durableTask": {
       "tracing": {
         "distributedTracingEnabled": true,
         "version": "V2"
       }
     }
   }
 }

Application Insights

Konfigurálja a függvényalkalmazást egy Application Insights-erőforrással.

A nyomok vizsgálata

Az Application Insights-erőforrásban lépjen a Tranzakciókeresés elemre. Az eredményekben keresse meg az Request és Dependency eseményeket, amelyek Durable-specifikus előtagokkal kezdődnek (például orchestration:, activity:, stb.). Ezen események egyikének kiválasztásával megnyílik egy Gantt-diagram, amely a végpontok közötti elosztott nyomkövetést jeleníti meg. A diagram az egyes vezénylési lépéseket vízszintes sávként jeleníti meg, a szülő vezénylés alá ágyazott tevékenység- és részvezénylési hívásokkal. A sáv hossza az egyes lépések falióra-időtartamát jelöli, így könnyen észreveheti a szűk keresztmetszeteket vagy a váratlanul lassú tevékenységeket.

Note

Nem látja a nyomkövetéseket az Application Insightsban? Várjon körülbelül öt percet az alkalmazás futtatása után, hogy az összes adat eljusson az Application Insights erőforrásba.

Visszajátszásbiztos naplózás a vezénylő függvényekben

Az Orchestrator függvények minden alkalommal visszajátszásra kerülnek, amikor új bemenet érkezik, ami azt jelenti, hogy bármely naplóutasítás a vezénylőben többször fut egyetlen logikai végrehajtás során. Egy három tevékenységhívással rendelkező függvény például a következőhöz hasonló naplókimenetet hoz létre a visszajátszás során:

Calling F1.
Calling F1.
Calling F2.
Calling F1.
Calling F2.
Calling F3.
Calling F1.
Calling F2.
Calling F3.
Done!

Ha meg szeretné akadályozni az ismétlődő naplósorokat, ellenőrizze a "visszajátszás alatt van" jelzőt, hogy a naplók csak az első (nem visszajátszási) áthaladáskor futjanak. Az alábbi példák a visszajátszásbiztos naplózást mutatják be az egyes nyelveken.

C# (InProc)

A Durable Functions 2.0-tól kezdve a CreateReplaySafeLogger használatával automatikusan kiszűrheti a naplóbejegyzéseket a visszajátszás során.

[FunctionName("FunctionChain")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context,
    ILogger log)
{
    log = context.CreateReplaySafeLogger(log);
    log.LogInformation("Calling F1.");
    await context.CallActivityAsync("F1");
    log.LogInformation("Calling F2.");
    await context.CallActivityAsync("F2");
    log.LogInformation("Calling F3");
    await context.CallActivityAsync("F3");
    log.LogInformation("Done!");
}

C# (izolált)

A .NET-izolált feldolgozóban hozzon létre egy visszajátszásbiztos naplózót a következővel: TaskOrchestrationContext.CreateReplaySafeLogger

[Function("FunctionChain")]
public static async Task Run([OrchestrationTrigger] TaskOrchestrationContext context)
{
    ILogger log = context.CreateReplaySafeLogger("FunctionChain");
    log.LogInformation("Calling F1.");
    await context.CallActivityAsync("F1");
    log.LogInformation("Calling F2.");
    await context.CallActivityAsync("F2");
    log.LogInformation("Calling F3");
    await context.CallActivityAsync("F3");
    log.LogInformation("Done!");
}

JavaScript

const df = require("durable-functions");

module.exports = df.orchestrator(function*(context){
    if (!context.df.isReplaying) context.log("Calling F1.");
    yield context.df.callActivity("F1");
    if (!context.df.isReplaying) context.log("Calling F2.");
    yield context.df.callActivity("F2");
    if (!context.df.isReplaying) context.log("Calling F3.");
    yield context.df.callActivity("F3");
    context.log("Done!");
});

Node.js programozási modell v4-alkalmazásai (beleértve a TypeScriptet)

import * as df from "durable-functions";

df.app.orchestration("FunctionChain", function* (context) {
    if (!context.df.isReplaying) context.log("Calling F1.");
    yield context.df.callActivity("F1");
    if (!context.df.isReplaying) context.log("Calling F2.");
    yield context.df.callActivity("F2");
    if (!context.df.isReplaying) context.log("Calling F3.");
    yield context.df.callActivity("F3");
    context.log("Done!");
});

Note

Az isReplaying ellenőrzés letiltja a vezénylő újrajátszása által okozott ismétlődő naplókat. Nem tiltja le a teljes újrafuttatás által okozott ismétlődő naplókat (például a gazdagép újraindítását, a hosszú helyi hibakeresési munkameneteket vagy az üzenetsor üzeneteinek láthatósági időtúllépéseit). Ezekben az esetekben továbbra is megjelenhetnek ismétlődő naplósorok ugyanazzal a vezénylési példányazonosítóval.

Python

import logging
import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    if not context.is_replaying:
        logging.info("Calling F1.")
    yield context.call_activity("F1")
    if not context.is_replaying:
        logging.info("Calling F2.")
    yield context.call_activity("F2")
    if not context.is_replaying:
        logging.info("Calling F3.")
    yield context.call_activity("F3")
    logging.info("Done!")
    return None

main = df.Orchestrator.create(orchestrator_function)

Java

@FunctionName("FunctionChain")
public void functionChain(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx,
        ExecutionContext functionContext) {
    Logger log = functionContext.getLogger();
    if (!ctx.getIsReplaying()) log.info("Calling F1.");
    ctx.callActivity("F1").await();
    if (!ctx.getIsReplaying()) log.info("Calling F2.");
    ctx.callActivity("F2").await();
    if (!ctx.getIsReplaying()) log.info("Calling F3.");
    ctx.callActivity("F3").await();
    log.info("Done!");
}

A visszajátszásbiztos naplózással a napló kimenete a következő:

Calling F1.
Calling F2.
Calling F3.
Done!

Testreszabott orkesztáció állapot

Egyéni vezénylési állapot használatával jelentse a munkafolyamat előrehaladását külső ügyfeleknek. A gyakori minták közé tartoznak a befejezési százalékok, a lépésleírások és a hibaösszegzők. A külső ügyfelek a HTTP-állapot lekérdezési API-val vagy nyelvspecifikus API-hívásokkal tekinthetik meg az egyéni állapotot.

Az alábbi kód bemutatja, hogyan állíthat be egyéni állapotértéket egy orchestrator függvényben:

C# (InProc)

[FunctionName("SetStatusTest")]
public static async Task SetStatusTest([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    // ...do work...

    // update the status of the orchestration with some arbitrary data
    var customStatus = new { completionPercentage = 90.0, status = "Updating database records" };
    context.SetCustomStatus(customStatus);

    // ...do more work...
}

Note

Az előző C# példa a Durable Functions 2.x-hez tartozik. Az 1.x Durable Functions esetén a DurableOrchestrationContext-t kell használni IDurableOrchestrationContext helyett. A verziók közötti különbségekről további információt a Durable Functions verzióiról szóló cikkben talál.

C# (Isolated)

[Function("SetStatusTest")]
public static async Task SetStatusTest([OrchestrationTrigger] TaskOrchestrationContext context)
{
    // ...do work...

    // update the status of the orchestration with some arbitrary data
    var customStatus = new { completionPercentage = 90.0, status = "Updating database records" };
    context.SetCustomStatus(customStatus);

    // ...do more work...
}

JavaScript

const df = require("durable-functions");

module.exports = df.orchestrator(function*(context) {
    // ...do work...

    // update the status of the orchestration with some arbitrary data
    const customStatus = { completionPercentage: 90.0, status: "Updating database records", };
    context.df.setCustomStatus(customStatus);

    // ...do more work...
});

Node.js programozási modell v4-alkalmazásai (beleértve a TypeScriptet)

import * as df from "durable-functions";

df.app.orchestration("SetStatusTest", function* (context) {
    // ...do work...

    // update the status of the orchestration with some arbitrary data
    const customStatus = { completionPercentage: 90.0, status: "Updating database records" };
    context.df.setCustomStatus(customStatus);

    // ...do more work...
});

Python

import logging
import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    # ...do work...

    # update the status of the orchestration with some arbitrary data
    custom_status = {'completionPercentage': 90.0, 'status': 'Updating database records'}
    context.set_custom_status(custom_status)
    # ...do more work...

    return None

main = df.Orchestrator.create(orchestrator_function)

Java

@FunctionName("SetStatusTest")
public void setStatusTest(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    // ...do work...

    // update the status of the orchestration with some arbitrary data
    ctx.setCustomStatus(new Object() {
        public final double completionPercentage = 90.0;
        public final String status = "Updating database records";
    });

    // ...do more work...
}

Amíg a folyamatvezérlés fut, a külső ügyfelek lekérhetik ezt a testreszabott állapotot:

GET /runtime/webhooks/durabletask/instances/instance123?code=XYZ

Az ügyfelek a következő választ kapják:

{
  "runtimeStatus": "Running",
  "input": null,
  "customStatus": { "completionPercentage": 90.0, "status": "Updating database records" },
  "output": null,
  "createdTime": "2017-10-06T18:30:24Z",
  "lastUpdatedTime": "2017-10-06T19:40:30Z"
}

Warning

Az egyéni állapot hasznos adatai legfeljebb 16 KB UTF-16 JSON-szövegre korlátozódnak, mert el kell férnie egy Azure Table Storage oszlopban. Ha nagyobb hasznos adatra van szüksége, használhatja a külső tárolót.

Debugging

Azure Functions közvetlenül támogatja a függvénykódok hibakeresését, és ugyanez a támogatás a Durable Functions esetében is rendelkezésre áll, függetlenül attól, hogy az Azure-ban vagy helyben futtatjuk őket. A legjobb hibakeresési élmény érdekében használja az alábbi munkafolyamatot:

1. Új hibakeresési munkamenetet indíthat egy új tevékenységközponttal , vagy törölheti a tevékenységközpont tartalmát a munkamenetek között. Az előző futtatásokból származó hátrahagyott üzenetek váratlan újrafuttatást okozhatnak.

2. Állítson be töréspontokat az orchestrátorban vagy a tevékenységfüggvényekben. Vezénylőfüggvények esetén használjon olyan feltételes töréspontot, amely csak akkor aktiválódik, ha a "visszajátszáskor" érték false-re van állítva, hogy elkerülje ugyanannak a töréspontnak a több alkalommal való elérését a visszajátszás során.

3. A szokásos módon haladjon végig a kódon. Tartsa szem előtt a következő viselkedéseket:

   • Újrajátszás:
     Az Orchestrator funkciói rendszeresen ismétlődnek, amikor új bemenetek érkeznek. A vezénylőfüggvények egyetlen logikai végrehajtása többször is ugyanazt a töréspontot érheti el, különösen akkor, ha a függvénykód korai szakaszában van beállítva.

   • Várakozás:
     Amikor egy await kerül a vezérlőfüggvénybe, az visszaadja az irányítást a Durable Task Framework diszpécserének. Ha ez az első alkalom, hogy egy adott await feladat megjelenik, a társított tevékenység soha nem folytatódik. Mivel a feladat soha nem folytatódik, nem lehet átlépni (F10 a Visual Studio-ban) az awaiten. Az átlépés csak akkor működik, ha egy feladat visszajátszása történik.

   • Üzenetküldési időtúllépések:
     A Durable Functions belsőleg üzenetsor-üzenetekkel hajtja végre a vezénylői, tevékenységi és entitásfüggvényeket. Több virtuálisgép-környezetben a kiterjesztett hibakeresési munkamenetek miatt egy másik virtuális gép feldolgozhatja az üzenetet, ami ismétlődő végrehajtást eredményezhet. Bár ez a viselkedés a normál üzenetsor-triggerek függvényei esetén is létezik, fontos kiemelni ezt a kontextust, mivel az üzenetsorok implementációs részletet képeznek.

   • Leállítás és indítás:
     A Durable Functionsben lévő üzenetek továbbra is megmaradnak a hibakeresési munkamenetek között. Ha leállítja a hibakeresést, és leállítja a helyi gazdagépfolyamatot egy tartós függvény végrehajtása közben, a függvény automatikusan újrafuthat egy későbbi hibakeresési munkamenetben.

További eszközök

Tárterület állapotának vizsgálata

Alapértelmezés szerint a Durable Functions az Azure Storage-ban tárolja az állapotot. A vezénylés állapotát és az üzeneteket olyan eszközökkel vizsgálhatja meg, mint a Microsoft Azure Storage Explorer.

Warning

Bár kényelmesen megtekintheti a végrehajtási előzményeket a táblatárolóban, ne függjön a táblától. A Durable Functions bővítmény fejlődésével változhat.

Note

Az alapértelmezett Azure Storage szolgáltató helyett konfigurálhat más társzolgáltatókat. Az alkalmazáshoz konfigurált tárolószolgáltatótól függően előfordulhat, hogy a mögöttes állapot vizsgálatához különböző eszközöket kell használnia.

Tartós Folyamatok Felügyelet

Durable Functions Monitor a vezénylési és entitáspéldányok monitorozására, kezelésére és hibakeresésére szolgáló grafikus eszköz. Visual Studio Code bővítményként vagy önálló alkalmazásként érhető el. A beállítási utasításokat és a funkciók listáját a Durable Functions Wiki figyelése című témakörben találja.

Azure portál diagnosztikái

A Azure portál beépített diagnosztikai eszközöket biztosít a függvényalkalmazásokhoz.

Problémák diagnosztizálása és megoldása: Az Azure Function App Diagnostics hasznos erőforrás az alkalmazás lehetséges problémáinak monitorozásához és diagnosztizáléséhez. Emellett javaslatokat is nyújt a problémák diagnosztizáláson alapuló megoldásához. További információ: Azure Függvényalkalmazás-diagnosztika.

Vezénylési nyomkövetések: Az Azure Portal részletes vezénylési nyomkövetési adatokat biztosít, amelyek segítenek megérteni az egyes vezénylési példányok állapotát és a végrehajtás nyomon követését elejétől a végéig. Amikor megtekinti a függvények listáját a Azure Functions alkalmazásban, megjelenik egy Monitor oszlop, amely hivatkozásokat tartalmaz a nyomkövetésekre. Ehhez engedélyeznie kell az Application Insightst ahhoz, hogy az alkalmazás hozzáférjen ezekhez az információkhoz.

Roslyn elemző eszköz

A Durable Functions Roslyn Analyzer egy élő kódelemző, amely a C#-fejlesztőket Durable Functions meghatározott kód-korlátozások követésére irányítja. A Visual Studio és Visual Studio Code engedélyezésére vonatkozó útmutatásért lásd: Durable Functions Roslyn Analyzer.

Hibaelhárítás

Az olyan gyakori problémák elhárításához, mint a elakadt vezénylések, a sikertelen indítás vagy a lassú futás, tekintse meg a Durable Functions hibaelhárítási útmutatót.

Következő lépések

További információ az Azure Functions monitorozásáról