Trvalé rozšíření

Rozšíření Durable pro Microsoft Agent Framework přináší trvalé spouštění agentům, orchestracím s více agenty a pracovním postupům Microsoft Agent Framework. Můžete ho použít k zachování relací agentů, orchestrace kontrolních bodů a průběhu pracovního postupu, zotavení z chyb a škálování práce napříč distribuovanými hostiteli beze změny základní logiky agenta.

Rozšíření podporuje dva modely hostování v jazyce C# a Python:

  • Azure Functions pro spravované bezserverové hostování pomocí programovacího modelu Azure Functions.
  • Bring-your-own-compute / self-hosted for running durable agents and workflows in your own worker process, service, container, Kubernetes environment, or existing app infrastructure.

Note

Tato příručka popisuje hostování rozšíření C# a Python Durable Extension. Informace o hostování Go najdete v tématu Hostování A2A a úložiště Agent Framework Go.

Overview

Odolné agenty kombinují programovací model agenta Framework s infrastrukturou Durable Task, jako je například Plánovač úloh Durable, a vytvářejí agenty, které:

  • Automatické uchování stavu napříč požadavky a prováděními pracovních procesů
  • Obnovení po selhání bez ztráty kontextu konverzace nebo opakování dokončené práce
  • Škálování napříč distribuovanými bezstavovými pracovními procesy na základě poptávky
  • Orchestrace pracovníchpostupůch
  • Pracovní postupy rozhraní CheckPoint Agent Framework vytvořené pomocí modelu pracovního postupu založeného na grafech
  • Pozastavení pro vstup člověka nebo externí události bez využití výpočetních tokenů nebo tokenů modelu při čekání
  • Obnovení streamovaného doručování při konfiguraci u zprostředkovatele datových proudů, jako je Redis; potvrdit trvalé dokončování samostatně
  • Správa životního cyklu relace s vyčištěním TTL (session to Live) a monitorováním na základě řídicího panelu

Kdy použít odolné agenty

Pokud potřebujete, vyberte odolné agenty:

  • Trvalý stav konverzace: Relace agenta přežijí chyby procesu, restartování a události horizontálního navýšení kapacity
  • Složité orchestrace: Koordinace více agentů s deterministickými a spolehlivými pracovními postupy, které se můžou spouštět po dobu dnů nebo týdnů
  • Orchestrace řízená událostmi: Integrace s triggery, frontami, webhooky, časovači nebo existujícími událostmi aplikace
  • Automatický stav konverzace: Historie konverzací agenta se automaticky spravuje a zachovává bez nutnosti explicitního zpracování stavu v kódu.
  • >: Vytváření pracovních postupů architektury agentů Microsoft založených na grafech na trvalém stavu, aby každý krok mohl být kontrolní a obnovený
  • Dlouhodobé relace: Udržování užitečných konverzací dostupných při čištění hodnoty TTL (time-to live) relace k automatickému odebrání nečinných relací
  • Odpovědi v reálném čase: Doručování výstupu přírůstkového tokenu s opětovným připojením založeném na zprostředkovateli při kontrole trvalého výsledku samostatně

Tento přístup k hostování se liší od hostování agentů založených na spravovaných službách (například foundry Agent Service), který poskytuje plně spravovanou infrastrukturu bez nutnosti nasazení nebo správy hostitelů pracovních procesů. Odolné agenty jsou ideální, když potřebujete flexibilitu nasazení typu code-first v kombinaci se správou trvalých stavů.

Volba modelu hostování

Model hostingu Zvolte ho, když potřebujete
Azure Functions Spravovaný model bezserverového hostování; integrované škálování na více instancí a škálování na nulu; Azure Functions triggery a vazby; Koncové body HTTP generované programovacím modelem functions; aktivační událost serveru MCP; a minimální správu hostitelské infrastruktury.
Používání vlastních výpočetních prostředků / hostování v místním prostředí Větší kontrola nad hostitelským procesem, prostředím nasazení, životním cyklem modulu runtime, infrastrukturou, sítí, ověřováním nebo integrací s existující aplikací nebo službou. Tento model použijte pro kontejnery, Kubernetes, dlouhotrvající pracovní procesy, konzolové aplikace, vlastní služby nebo hostitelské prostředí, která nejsou službami Functions.

Při hostování v plánu hostování Flex Consumption služby Azure Functions mohou být agenti škálováni na tisíce instancí nebo na nula instancí, pokud se nepoužívají, takže můžete platit jenom za výpočetní prostředky, které potřebujete. Ve scénářích v místním prostředí řídí vaše vlastní hostitelská řízení životnosti procesů, škálování, sítě a nasazení.

Začínáme

Níže použijte instalační příkazy pro model hostování. Nechte předběžné možnosti zobrazené pro balíčky ve verzi Preview. Kompletní aplikace najdete ve zdroji a ukázkách.

Dokumentace ke zdrojové větvi může popisovat možnosti, které ještě nejsou dostupné v publikovaných balíčcích. Použijte kroky konfigurace a migrace jenom pro funkce zahrnuté v nainstalované verzi.

Important

Před upgradem existujícího nasazení zkontrolujte migraci nasazení a schématu. Neodkazujte upgradovaný pracovní proces na staré historie pracovních postupů bez kontroly kompatibility přehrávání.

V projektu .NET zvolte sadu balíčků pro váš model hostování.

Pro Azure Functions hostování přidejte integrační balíček Azure Functions a pracovní balíčky Functions.

dotnet add package Microsoft.Agents.AI.Foundry --prerelease
dotnet add package Microsoft.Agents.AI.Hosting.AzureFunctions --prerelease

Note

Použijte verze rozšíření Functions Worker, DurableTask worker a rozšíření pracovního procesu AzureManaged deklarované závislostmi rozšíření agenta. Odeberte přímé odkazy na balíčky, které tyto závislosti downgradují. Podívejte se na odkazy na .NET závislostí. Souběžné upgrady schématu v2 také vyžadují filtrování pracovních položek; viz nasazení a migrace schématu.

Pro hostování vlastních výpočetních prostředků přidejte základní integrační balíček Durable Task a pracovní nebo klientské balíčky Durable Task Scheduler používané vaším hostitelem:

dotnet add package Microsoft.Agents.AI.Foundry --prerelease
dotnet add package Microsoft.Agents.AI.DurableTask --prerelease
dotnet add package Microsoft.DurableTask.Client.AzureManaged
dotnet add package Microsoft.DurableTask.Worker.AzureManaged
dotnet add package Microsoft.Extensions.Hosting

V projektu Python zvolte balíček pro model hostování. Python hostitelé vyžadují explicitní strategii nasazení.

Pro hostování Azure Functions použijte Python 3.13 nebo novější a nainstalujte integrační balíček Azure Functions. Následující příkazy také nainstalují Azure klienta OpenAI použitého v této příručce.

pip install agent-framework-azurefunctions agent-framework-openai azure-identity --pre

Pro hostování vlastních výpočetních prostředků použijte Python 3.10 nebo novější a nainstalujte integrační balíček Durable Task.

pip install agent-framework-durabletask agent-framework-openai azure-identity --pre

Pro nové izolované centrum úloh s upgradovanými pracovními procesy a klienty nastavte DURABLE_AGENTS_DEPLOYMENT_MODE=isolated_v2 před spuštěním některého hostitele. U existujícího centra zvolte strategii migrace místo toho, abyste toto nastavení použili nevidomě. Nastavení uznává izolaci; nezjistí ostatní pracovní procesy ani nekompatibilní starou historii.

hostování Azure Functions

S rozšířením Durable můžete nasazovat a hostovat agenty Microsoft Agent Framework v Azure Functions s integrovanými koncovými body HTTP a voláním založeným na orchestraci. Služba Azure Functions poskytuje ceny založené na událostech a průběžných platbách s automatickým škálováním a minimální správou infrastruktury.

Při konfiguraci odolného agenta v Azure Functions rozšíření automaticky vytvoří koncové body HTTP pro vašeho agenta a spravuje základní infrastrukturu pro ukládání stavu konverzace, zpracování souběžných požadavků a koordinaci pracovních postupů s více agenty. Integrace hostování Azure Functions také poskytuje funkce specifické pro funkce, jako jsou vygenerovaná rozhraní REST API pro odesílání zpráv, kontrolu stavu a správu relací a triggery, jako je trigger serveru MCP pro hostování agentů jako serverů MCP, aniž byste museli psát připevnění triggeru.

using System;
using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Hosting;

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT") ?? "gpt-4o-mini";

// Create an AI agent following the standard Microsoft Agent Framework pattern
AIAgent agent = new AIProjectClient(new Uri(endpoint), new DefaultAzureCredential())
    .AsAIAgent(
        model: deploymentName,
        instructions: "You are good at telling jokes.",
        name: "Joker");

// Configure the function app to host the agent with durable thread management
// This automatically creates HTTP endpoints and manages state persistence
using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options =>
        options.AddAIAgent(agent)
    )
    .Build();
app.Run();

Warning

DefaultAzureCredential je vhodný pro vývoj, ale vyžaduje pečlivé zvážení v produkčním prostředí. V produkčním prostředí zvažte použití konkrétních přihlašovacích údajů (např ManagedIdentityCredential. ) k zabránění problémům s latencí, neúmyslnému testování přihlašovacích údajů a potenciálním bezpečnostním rizikům z náhradních mechanismů.

import os
from agent_framework_azurefunctions import AgentFunctionApp
from agent_framework.openai import OpenAIChatCompletionClient
from azure.identity import DefaultAzureCredential

endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT", "gpt-4o-mini")
api_version = os.getenv("AZURE_OPENAI_API_VERSION")

# Create an AI agent following the standard Microsoft Agent Framework pattern
agent = OpenAIChatCompletionClient(
    azure_endpoint=endpoint,
    model=deployment_name,
    api_version=api_version,
    credential=DefaultAzureCredential()
).as_agent(
    instructions="You are good at telling jokes.",
    name="Joker"
)

# Configure the function app to host the agent with durable thread management
# This automatically creates HTTP endpoints and manages state persistence
app = AgentFunctionApp(agents=[agent])

Používání vlastních výpočetních prostředků / hostování v místním prostředí

Pokud chcete, aby funkce Durable Extension bez použití programovacího modelu Azure Functions používaly hostování vlastních výpočetních prostředků. V tomto modelu spustí proces pracovní proces Durable Task, zaregistruje trvalé agenty nebo pracovní postupy a připojí se k back-endu Plánovače trvalých úloh. Klientský kód může běžet ve stejném procesu nebo v samostatné službě.

Pracovní procesy v místním prostředí používají stejné základní možnosti rozšíření Durable Extension jako hostování Azure Functions: vytváření kontrolních bodů a obnovení, deterministická orchestrace agentů, trvalé pracovní postupy rozhraní Agent Framework, čekání na smyčku mezi lidmi, spolehlivé streamování, vyčištění relace nečinnosti, viditelnost řídicího panelu a distribuované spouštění napříč bezstavovými instancemi pracovních procesů. Váš hostitel zodpovídá za zveřejnění vlastních rozhraní API, správy životního cyklu, sítí, ověřování a modelu nasazení.

Nakonfigurujte hostitele pomocí základního integračního balíčku Durable Task. Použijte ConfigureDurableAgents pro trvalé agenty a ConfigureDurableWorkflows pro pracovní postupy architektury agenta založené na grafech Microsoft Agent Framework.

string connectionString = Environment.GetEnvironmentVariable("DURABLE_TASK_SCHEDULER_CONNECTION_STRING")
    ?? "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None";

IHost host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.ConfigureDurableAgents(
            options => options.AddAIAgent(agent),
            workerBuilder: builder => builder.UseDurableTaskScheduler(connectionString),
            clientBuilder: builder => builder.UseDurableTaskScheduler(connectionString));
    })
    .Build();

await host.StartAsync();

Ukázky konzoly .NET Durable Agents a .NET ukázky konzoly Durable Workflows pro spustitelné příklady v místním prostředí.

Pomocí balíčku integrace Durable Task spusťte pracovní proces, který registruje agenty a naslouchá požadavkům. Klientský kód se může připojit ke stejnému centru úloh Plánovače úloh Durable z jiného procesu.

from agent_framework_durabletask import DurableAIAgentWorker
from durabletask.azuremanaged.worker import DurableTaskSchedulerWorker

worker = DurableTaskSchedulerWorker(
    host_address="http://localhost:8080",
    secure_channel=False,
    taskhub="default",
)

agent_worker = DurableAIAgentWorker(worker)
agent_worker.add_agent(agent)

worker.start()

Příklady pracovních klientů, včetně hostování s jedním agentem, směrování s více agenty, spolehlivého streamování, řetězení orchestrace, souběžnosti, podmíněných podmínek a vzorců lidské smyčky, najdete v Python ukázkách trvalých úloh.

Pracovní postupy durable Agent Framework

Stálost není omezena na trvalé orchestrace. Microsoft pracovní postupy rozhraní Agent Framework vytvořené pomocí modelu pracovního postupu založeného na grafech lze také zhoršovat. Provádění pracovních bodů kontrolních bodů rozšíření Durable Extension, takže dokončený exekutor a kroky agenta se po restartování nebo selhání procesu neopakují.

Trvalé orchestrace používejte v případě, že chcete imperativní koordinaci s větvení založenými na kódu, časovači, aktivitami a externími událostmi. Pracovní postupy durable Agent Framework používejte, pokud chcete deklarativní graf exekutorů a agentů se zadaným směrováním, ventilátorem nebo ventilátorem, podmíněnými hrany, událostmi pracovního postupu, sdíleným stavem, dílčími pracovními postupy nebo porty požadavků na požadavek human-in-the-loop.

Note

Pracovní postupy Durable Agent Framework se liší od úložiště kontrolních bodů ve standardních pracovních postupech. Úložiště kontrolních bodů pomáhá obnovit spuštění pracovního postupu v modulu runtime Agent Framework. Rozšíření Durable Spustí pracovní postup v infrastruktuře trvalých úloh, takže průběh pracovního postupu je kontrolní bod a obnovený napříč distribuovanými trvalými pracovními procesy. Standardní kontrolní body pracovního postupu najdete v tématu Kontrolní body a obnovení.

Zaregistrujte pracovní postupy založené na grafech pomocí ConfigureDurableWorkflows pro aplikace v místním prostředí nebo ConfigureDurableWorkflows v Tvůrci aplikací Functions pro hostování Azure Functions.

Podívejte se na ukázky Azure Functions .NET Durable Workflows a .NET ukázky konzoly Durable Workflows.

Ukázky trvalých pracovních postupů jsou k dispozici pro hostování Azure Functions, včetně sdíleného stavu, žádného sdíleného stavu, paralelního provádění pracovních postupů a pracovních postupů smyčky pro člověka. Python také podporuje pracovní postupy založené na grafech na samostatném pracovním procesu Durable Task.

Příklady trvalých agentů, orchestrace, serveru MCP a pracovních postupů najdete v ukázkách Python Azure Functions.

Informace o provádění grafu v místním prostředí najdete v ukázce samostatného pracovního postupu Python.

Samples

Jazyk Model hostingu Odolné agenty a orchestrace Pracovní postupy založené na grafech
jazyk C# Azure Functions Ukázky agentů .NET ukázky pracovních postupů .NET
jazyk C# Self-hosted Ukázky agenta konzoly .NET ukázky pracovních postupů konzoly .NET
Python Azure Functions Ukázky Python Functions Ukázky pracovních postupů Python Functions
Python Self-hosted ukázky pracovních procesů a klientů Python Python samostatný pracovní postup

Tyto ukázky demonstrují podporu, nikoli stejné kontrakty rozhraní API napříč jazyky. Funkce generují koncové body HTTP; aplikace v místním prostředí implementují a zabezpečují svá vlastní rozhraní API.

Vlákna stavových agentů s historií konverzací

Agenti udržují trvalé relace, které přetrvají napříč několika interakcemi. Každá relace má jedinečné ID relace a ukládá stav konverzace v odolném úložišti spravovaném infrastrukturou Durable Task, například Plánovač úloh Durable.

Tento model umožňuje konverzační kontinuitu, kdy se stav agenta zachová prostřednictvím chybových ukončení procesu a restartování, což umožňuje udržovat úplnou historii konverzací napříč uživatelskými vlákny. Odolné úložiště zajišťuje, že i když se hostitelský proces restartuje nebo obnoví v jiné instanci pracovního procesu, konverzace bez problémů pokračuje tam, kde skončila.

Nakonfigurujte čištění relace, uchovávání historie a uchovávání výsledků záměrně. Tyto zásady mají různé účinky; viz životní cyklus stavu a kapacita.

Následující Azure Functions příklad ukazuje více požadavků HTTP na stejnou relaci. Integrace jazyka vrací x-ms-session-id a přijímají parametr kanonického sessionId dotazu. Považovat vrácené ID za neprůhlené: Příklad ukazuje adresu entity .NET schema-v2, zatímco formátování relace Python závisí na strategii nasazení. V aplikacích v místním prostředí použijte rozhraní API klienta Durable Task z vlastního procesu nebo služby.

# First interaction - start a new session
curl -i -X POST https://your-function-app.azurewebsites.net/api/agents/Joker/run \
  -H "Content-Type: text/plain" \
  -d "Tell me a joke about pirates"

# Response includes session ID in x-ms-session-id header and joke as plain text
# HTTP/1.1 200 OK
# Content-Type: text/plain
# x-ms-session-id: @dafx-v2-joker@263fa373-fa01-4705-abf2-5a114c2bb87d
#
# Why don't pirates shower before they walk the plank? Because they'll just wash up on shore later!

# Second interaction - reuse the exact session ID returned by the first request
curl -X POST "https://your-function-app.azurewebsites.net/api/agents/Joker/run?sessionId=@dafx-v2-joker@263fa373-fa01-4705-abf2-5a114c2bb87d" \
  -H "Content-Type: text/plain" \
  -d "Tell me another one about the same topic"

# Agent remembers the pirate context from the first message and responds with plain text
# What's a pirate's favorite letter? You'd think it's R, but it's actually the C!

Stav agenta se udržuje v odolném úložišti a umožňuje distribuované spouštění napříč několika instancemi. Každá instance může obnovit spuštění agenta po přerušení nebo selháních a zajistit tak nepřetržitou operaci.

Používejte sessionId a waitForResponse v nových klientech HTTP agenta. thread_id je zastaralý alias požadavku, ne hlavička odpovědi, která se má zachytit. Pro Python odpovědi JSON, čtení sessionId a correlationId. Informace o aliasech a zpracování konfliktů najdete v průvodci migrací rozhraní HTTP API .

Potvrzení trvalého dokončování

Pro vygenerované koncové body agenta .NET Functions interpretujte dokončení následujícím způsobem:

Stav HTTP Meaning
202 Accepted Odeslání je přijato. Provedení se nepotvrdí úspěšně.
200 OK K dispozici je potvrzený úspěšný výsledek.
500 Internal Server Error Vrátí se podporovaná potvrzená chyba terminálu. Odlište je od běžných chyb hostitele nebo přenosu.
410 Gone Dokončení je známé, ale jeho výsledek není k dispozici. Uchováný výsledek může být succeeded nebo failed; nemusí se nutně jednat o neúspěšné provedení nebo pouze vypršení platnosti výsledku.

Čtení x-ms-durable-outcome , pokud dokončení nemá žádný dostupný výsledek. Nechovejte jako 410 čekající, odvozujte výsledek z historie konverzací nebo automaticky znovu odešlete novou identitu. Volající JSON používají řetězec status a číselnou hodnotu statusCode. Dřívější status_code pole je dočasný alias kompatibility.

Python Functions také rozlišuje dostupné výsledky, zachovává neúspěšné výsledky a nedostupné dokončené výsledky. Obálky chyb a možnosti sady SDK nejsou identické s .NET. Viz kontrakt dokončení .NET a Python kontrakt HTTP.

Tyto stavy popisují koncové body agenta. Rozhraní API pro správu orchestrace Durable Functions má vlastní odpověď na stav a kontrakt dotazování.

Spolehlivé streamování

Durable Extension podporuje spolehlivé streamování pro aplikace, které potřebují doručování tokenů v reálném čase spolu se spouštěním trvalých agentů. Streamování je možné použít s rozšířením jádra v obou hostitelských modelech, ale distribuovaný hostitel potřebuje spolehlivého zprostředkovatele streamů, jako je Redis, aby klienti mohli po opětovném připojení nebo změnách pracovního procesu obnovit čtení datových proudů zachovaných tokenů, a to v závislosti na trvalosti a uchovávání informací zprostředkovatele.

Spolehlivé streamování používejte, když uživatelské prostředí závisí na přírůstkových odpovědích, ale úloha stále potřebuje trvalou sémantiku spouštění. Dokončení datového proudu sám o sobě nepotvrzuje, že byl výsledek a stav agenta trvale zachován; samostatně zkontrolujte autoritativní trvalý výsledek. Příklady s možností spuštění najdete v ukázkách Python Durable Task, které zahrnují spolehlivé vzory streamování.

Deterministické orchestrace s více agenty

Rozšíření Durable Podporuje vytváření deterministických pracovních postupů, které koordinuje více agentů pomocí orchestrací trvalých úloh. V Azure Functions tyto nástroje používají orchestrace Durable Functions; v hostitelích s vlastními výpočetními prostředky, běží prostřednictvím pracovního procesu Durable Task a klienta, který nakonfigurujete.

Orchestrace jsou pracovní postupy založené na kódu, které spolehlivě koordinuje více operací (jako jsou volání agenta, externí volání rozhraní API nebo časovače). Deterministický znamená, že se kód orchestrace provádí stejným způsobem při přehrání po selhání, takže pracovní postupy jsou spolehlivé a laditelné – při přehrání historie orchestrace můžete přesně zjistit, co se stalo v jednotlivých krocích.

Orchestrace se provádějí spolehlivě, odolející selháním mezi voláními agenta a poskytují předvídatelnost a opakovatelnost procesů. Díky tomu jsou ideální pro složité scénáře s více agenty, ve kterých potřebujete garantované pořadí provádění a odolnost proti chybám.

Trvalé vytváření kontrolních bodů nevytváří nástroje ani externí zápisy transakční nebo přesně jednou. Nastavit aktivitu a nástroje vedlejší účinky idempotentní a definovat hranice opakování. Selhání po externím zápisu, ale před trvalým potvrzením může způsobit opětovné spuštění operace.

Sekvenční orchestrace

Ve víceagentním sekvenčním vzoru se specializovaní agenti spouštějí v přesném pořadí, kde výstup každého agenta může ovlivnit provedení dalšího agenta. Tento model podporuje podmíněnou logiku a větvení na základě odpovědí agenta.

Při použití agentů v orchestracích je nutné pomocí context.GetAgent() rozhraní API získat instanci DurableAIAgent, což je speciální podtřída standardního typu AIAgent, která obaluje jednoho z vašich registrovaných agentů. Obálka DurableAIAgent zajišťuje správné sledování a checkpointování hovorů agenta rámcem trvalé orchestrace.

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Agents.AI.DurableTask;

[Function(nameof(SpamDetectionOrchestration))]
public static async Task<string> SpamDetectionOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    Email email = context.GetInput<Email>();

    // Check if the email is spam
    DurableAIAgent spamDetectionAgent = context.GetAgent("SpamDetectionAgent");
    AgentSession spamSession = await spamDetectionAgent.CreateSessionAsync();

    AgentResponse<DetectionResult> spamDetectionResponse = await spamDetectionAgent.RunAsync<DetectionResult>(
        message: $"Analyze this email for spam: {email.EmailContent}",
        session: spamSession);
    DetectionResult result = spamDetectionResponse.Result;

    if (result.IsSpam)
    {
        return await context.CallActivityAsync<string>(nameof(HandleSpamEmail), result.Reason);
    }

    // Generate response for legitimate email
    DurableAIAgent emailAssistantAgent = context.GetAgent("EmailAssistantAgent");
    AgentSession emailSession = await emailAssistantAgent.CreateSessionAsync();

    AgentResponse<EmailResponse> emailAssistantResponse = await emailAssistantAgent.RunAsync<EmailResponse>(
        message: $"Draft a professional response to: {email.EmailContent}",
        session: emailSession);

    return await context.CallActivityAsync<string>(nameof(SendEmail), emailAssistantResponse.Result.Response);
}

Při použití agentů v orchestracích musíte použít metodu app.get_agent() k získání trvalé instance agenta, což je speciální obálka kolem jednoho z registrovaných agentů. Odolná obálka agenta zajišťuje, že volání agenta jsou správně sledována a zaznamenávána kontrolními body odolným rámcem pro orchestrace.

from durabletask.task import OrchestrationContext
from agent_framework_azurefunctions import AgentFunctionApp
from pydantic import BaseModel

class SpamDetectionResult(BaseModel):
    is_spam: bool
    reason: str

class EmailResponse(BaseModel):
    response: str

app = AgentFunctionApp(agents=[spam_detection_agent, email_assistant_agent])

@app.orchestration_trigger(context_name="context")
def spam_detection_orchestration(context: OrchestrationContext, email: dict):
    # Check if the email is spam
    spam_agent = app.get_agent(context, "SpamDetectionAgent")
    spam_thread = spam_agent.create_session()

    spam_result_raw = yield spam_agent.run(
        messages=f"Analyze this email for spam: {email['content']}",
        session=spam_thread,
        options={"response_format": SpamDetectionResult},
    )
    spam_result = SpamDetectionResult.model_validate(spam_result_raw.value)

    if spam_result.is_spam:
        result = yield context.call_activity("handle_spam_email", input=spam_result.reason)
        return result

    # Generate response for legitimate email
    email_agent = app.get_agent(context, "EmailAssistantAgent")
    email_thread = email_agent.create_session()

    email_response_raw = yield email_agent.run(
        messages=f"Draft a professional response to: {email['content']}",
        session=email_thread,
        options={"response_format": EmailResponse},
    )
    email_response = EmailResponse.model_validate(email_response_raw.value)

    result = yield context.call_activity("send_email", input=email_response.response)
    return result

Orchestrace koordinuje práci mezi více agenty a odolává selhání mezi voláními agentů. Kontext orchestrace poskytuje metody pro získání a interakci s hostovanými agenty v orchestracích.

Paralelní orchestrace

V paralelním vzoru s více agenty spustíte více agentů současně a pak agregujete jejich výsledky. Tento model je užitečný pro souběžné shromažďování různorodých perspektiv nebo zpracování nezávislých dílčích úkolů.

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Agents.AI.DurableTask;

[Function(nameof(ResearchOrchestration))]
public static async Task<string> ResearchOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    string topic = context.GetInput<string>();

    // Execute multiple research agents in parallel
    DurableAIAgent technicalAgent = context.GetAgent("TechnicalResearchAgent");
    DurableAIAgent marketAgent = context.GetAgent("MarketResearchAgent");
    DurableAIAgent competitorAgent = context.GetAgent("CompetitorResearchAgent");

    // Start all agent runs concurrently
    Task<AgentResponse<TextResponse>> technicalTask = 
        technicalAgent.RunAsync<TextResponse>($"Research technical aspects of {topic}");
    Task<AgentResponse<TextResponse>> marketTask = 
        marketAgent.RunAsync<TextResponse>($"Research market trends for {topic}");
    Task<AgentResponse<TextResponse>> competitorTask = 
        competitorAgent.RunAsync<TextResponse>($"Research competitors in {topic}");

    // Wait for all tasks to complete
    await Task.WhenAll(technicalTask, marketTask, competitorTask);

    // Aggregate results
    string allResearch = string.Join("\n\n", 
        technicalTask.Result.Result.Text,
        marketTask.Result.Result.Text,
        competitorTask.Result.Result.Text);

    DurableAIAgent summaryAgent = context.GetAgent("SummaryAgent");
    AgentResponse<TextResponse> summaryResponse = 
        await summaryAgent.RunAsync<TextResponse>($"Summarize this research:\n{allResearch}");

    return summaryResponse.Result.Text;
}

from durabletask.task import OrchestrationContext, when_all
from agent_framework_azurefunctions import AgentFunctionApp

app = AgentFunctionApp(agents=[technical_agent, market_agent, competitor_agent, summary_agent])

@app.orchestration_trigger(context_name="context")
def research_orchestration(context: OrchestrationContext, topic: str):
    # Execute multiple research agents in parallel
    technical_agent = app.get_agent(context, "TechnicalResearchAgent")
    market_agent = app.get_agent(context, "MarketResearchAgent")
    competitor_agent = app.get_agent(context, "CompetitorResearchAgent")

    technical_task = technical_agent.run(messages=f"Research technical aspects of {topic}")
    market_task = market_agent.run(messages=f"Research market trends for {topic}")
    competitor_task = competitor_agent.run(messages=f"Research competitors in {topic}")

    # Wait for all tasks to complete
    results = yield when_all([technical_task, market_task, competitor_task])

    # Aggregate results
    all_research = "\n\n".join(r.text for r in results)

    summary_agent = app.get_agent(context, "SummaryAgent")
    summary = yield summary_agent.run(messages=f"Summarize this research:\n{all_research}")

    return summary.text

Paralelní provádění se sleduje pomocí seznamu úkolů. Automatické vytváření kontrolních bodů zajišťuje, že dokončená spuštění agenta se neopakují ani neztratí, pokud během agregace dojde k chybě.

Orchestrace human-in-the-loop

Deterministické orchestrace agentů se mohou dočasně zastavit kvůli zadání od člověka, schválení nebo kontrole, aniž by spotřebovávaly výpočetní kapacity. Trvalé provádění umožňuje orchestracím čekat celé dny nebo dokonce týdny na lidské reakce. V kombinaci s bezserverovým hostováním se všechny výpočetní zdroje během čekací doby vypnou, což eliminuje náklady na výpočet, dokud člověk neposkytne svůj vstup.

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Agents.AI.DurableTask;

[Function(nameof(ContentApprovalWorkflow))]
public static async Task<string> ContentApprovalWorkflow(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    string topic = context.GetInput<string>();

    // Generate content using an agent
    DurableAIAgent contentAgent = context.GetAgent("ContentGenerationAgent");
    AgentResponse<GeneratedContent> contentResponse = 
        await contentAgent.RunAsync<GeneratedContent>($"Write an article about {topic}");
    GeneratedContent draftContent = contentResponse.Result;

    // Send for human review
    await context.CallActivityAsync(nameof(NotifyReviewer), draftContent);

    // Wait for approval with timeout
    HumanApprovalResponse approvalResponse;
    try
    {
        approvalResponse = await context.WaitForExternalEvent<HumanApprovalResponse>(
            eventName: "ApprovalDecision",
            timeout: TimeSpan.FromHours(24));
    }
    catch (OperationCanceledException)
    {
        // Timeout occurred - escalate for review
        return await context.CallActivityAsync<string>(nameof(EscalateForReview), draftContent);
    }

    if (approvalResponse.Approved)
    {
        return await context.CallActivityAsync<string>(nameof(PublishContent), draftContent);
    }

    return "Content rejected";
}

from durabletask.task import OrchestrationContext, when_any
from datetime import timedelta
from agent_framework_azurefunctions import AgentFunctionApp

app = AgentFunctionApp(agents=[content_agent])

@app.orchestration_trigger(context_name="context")
def content_approval_workflow(context: OrchestrationContext, topic: str):
    # Generate content using an agent
    content_agent = app.get_agent(context, "ContentGenerationAgent")
    draft_content = yield content_agent.run(
        messages=f"Write an article about {topic}"
    )

    # Send for human review
    yield context.call_activity("notify_reviewer", input=draft_content.text)

    # Wait for approval with timeout
    approval_task = context.wait_for_external_event("ApprovalDecision")
    timeout_task = context.create_timer(
        context.current_utc_datetime + timedelta(hours=24)
    )

    winner = yield when_any([approval_task, timeout_task])

    if winner == approval_task:
        timeout_task.cancel()
        approval_data = approval_task.result
        if approval_data.get("approved"):
            result = yield context.call_activity("publish_content", input=draft_content.text)
            return result
        return "Content rejected"

    # Timeout occurred - escalate for review
    result = yield context.call_activity("escalate_for_review", input=draft_content.text)
    return result

Deterministické orchestrace agentů mohou čekat na externí události a trvale uchovávat jejich stav při čekání na lidskou zpětnou vazbu, odolávat selháním, restartování a delším čekacím obdobím. Když dorazí lidská odpověď, orchestrace se automaticky obnoví, přičemž zůstává zachován úplný kontext konverzace i stav provádění beze změny.

Poskytování lidského vstupu

Pokud chcete odeslat schválení nebo vstup do čekající orchestrace, vytvořte externí událost do instance orchestrace pomocí klientské sady SDK durable task nebo koncových bodů rozšíření Azure Functions Durable. Recenzent může například schválit obsah prostřednictvím webového formuláře, který spustí:

await client.RaiseEventAsync(instanceId, "ApprovalDecision", new HumanApprovalResponse 
{ 
    Approved = true,
    Feedback = "Looks great!"
});

approval_data = {
    "approved": True,
    "feedback": "Looks great!"
}
await client.raise_event(instance_id, "ApprovalDecision", approval_data)

Nákladová efektivita

Pracovní postupy s člověkem ve smyčce s trvalými agenty jsou mimořádně nákladově efektivní, když jsou hostovány na plánu Flex Consumption služby Azure Functions. U pracovního postupu, který čeká na schválení 24 hodin, platíte jenom několik sekund spuštění (doba generování obsahu, odeslání oznámení a zpracování odpovědi) – ne 24 hodin čekání. Během čekací doby se nevyužívají žádné výpočetní prostředky.

Pozorovatelnost pomocí plánovače trvalých úloh

Plánovač úloh Durable Task Scheduler (DTS) je doporučený trvalý back-end pro vaše odolné agenty, který nabízí nejlepší výkon, plně spravovanou infrastrukturu a integrovanou pozorovatelnost prostřednictvím řídicího panelu uživatelského rozhraní. Azure Functions aplikace můžou používat jiné back-endy úložiště (například Azure Storage), ale DTS je optimalizovaný speciálně pro odolné úlohy a poskytuje vynikající možnosti výkonu a monitorování. Pracovní procesy v místním prostředí také používají DTS k trvalému plánování, stavu a viditelnosti řídicího panelu.

Přehledy relací agenta

  • Historie konverzací: Zobrazení úplné historie chatu pro každou relaci agenta, včetně všech zpráv, volání nástrojů a kontextu konverzace v jakémkoli okamžiku
  • Časování úloh: Monitorování doby trvání konkrétních úloh a interakcí agentů

Snímek obrazovky řídicího panelu Plánovače trvalých úloh zobrazující historii chatu agenta s vlákny konverzace a zprávami

Přehledy orchestrace

  • Vizualizace více agentů: Zobrazení průběhu provádění při volání více specializovaných agentů s vizuálním zobrazením paralelních spuštění a podmíněného větvení
  • Historie spuštění: Přístup k podrobným protokolům spuštění
  • Monitorování v reálném čase: Sledování aktivních orchestrací, pracovních položek zařazených do fronty a stavů agentů napříč nasazením
  • Metriky výkonu: Monitorování doby odezvy agenta, využití tokenů a doba orchestrace

Snímek obrazovky řídicího panelu Plánovače trvalých úloh zobrazující vizualizaci orchestrace s více interakcemi agentů a prováděním pracovního postupu

Možnosti ladění

  • Zobrazení výstupů strukturovaného agenta a výsledků volání nástrojů
  • Volání nástrojů trasování a jejich výsledky
  • Monitorování zpracování externích událostí pro scénáře s lidskou zpětnou vazbou

Řídicí panel umožňuje přesně pochopit, co dělají vaši agenti, rychle diagnostikovat problémy a optimalizovat výkon na základě skutečných dat spuštění.

Migrace nasazení a schématu

Stav agenta Schema-v2 mění trvalé stavové i odesílající identity. Plánování koexistence pracovních procesů odděleně od převodu stavu

Nové relace používají dafx-v2- obor názvů entity. Během dvoufázového zavedení nechejte ProcessLegacyEntities zakázané, zatímco pracovní procesy v1 zůstanou aktivní. Před povolením ProcessLegacyEntities zpracování a upgradu oprávněných starších entit zastavte všechny pracovní procesy verze 1.

Samostatné pracovní procesy registrují filtry pracovních položek. Souběžná nasazení funkcí také vyžadují kompatibilní pracovní proces Functions, rozšíření pracovního procesu DurableTask a balíčky rozšíření pracovních procesů AzureManaged, které podporují filtrování na straně hostitele u každého zúčastněného hostitele a navíc workItemFilteringEnabled v konfiguraci poskytovatele úložiště plánovače. Bez kompatibilního filtrování používejte offline přímé připojení místo souběžných hostitelů v1 a v2 v jednom centru. Dokončete konfiguraci podle průvodce upgradem .NET.

Před vytvořením hostitele zvolte explicitní strategii:

  • two_phase: Použijte Durable Task Scheduler s kompatibilním filtrováním pracovních položek back-endu. Nové názvy verzí izolují odesílání, zatímco oprávněné starší entity zůstanou u starých pracovních procesů. Před povolením historického zpracování názvů a upgradů místních entit zastavte staré pracovní procesy. Udržovat kompatibilní filtrované pracovníky během koexistence; filtry názvů nejsou trvalé rezervace, pokud se tato flotila odpojí.
  • isolated_v2: Použijte izolované centrum úloh s odpovídajícími upgradovanými pracovními procesy a klienty. Nastavení uznává izolaci, ale neprovádí sondu pro ostatní pracovníky. Používejte nové instance pracovního postupu.

Nové centrum není bezpodmínečným požadavkem na cestu migrace dvoufázové entity. Informace o nastavení a požadavcích specifických pro hostitele najdete v tématu Python migrace entit.

Warning

Migrace entit neopravuje kompatibilitu přehrání pracovního postupu. Upgradovaný modul runtime nepodporuje ovlivněné starší historie pracovních postupů, včetně starších historie v2. Pokud se musí dokončit, nechte je na svých původních pracovních a centrálních pracovníkech. Po upgradu spusťte nové instance; nespoléhejte pouze na značku verze pracovního postupu, aby se prokázala kompatibilita. Viz Python kompatibilita modulu runtime.

Životní cyklus stavu a kapacita

Vyberte zásady pro každou vrstvu nezávisle:

Vrstva Co to řídí
Hodnota TTL relace Odstraní celou entitu včetně potvrzení o stavu konverzace a dokončení.
Uchování trvalé historie Odebere oprávněný uložený obsah přepisu; chráněný stav může i nadále překročit kapacitu.
Komprimace vstupu modelu Změní kontext odeslaný do modelu; nemusí nutně vyřezávat trvalou historii.
Uchování výsledků Řídí dostupnost datové části odpovědi nezávisle na zachování výsledku dokončení.
Životní cyklus datové části objektu blob Řídí objekty blob datové části s přesměrováním zatížení sady SDK; Odstranění relace nebo vymazání orchestrace je nevyčistí.

V .NET stavu příjmu schématu v2 nekonfigurovaná starší 14denní hodnota TTL automaticky neodstraní entitu. Pokud chcete vyčištění nečinné relace explicitně nakonfigurovat globální hodnotu TTL nebo hodnotu TTL pro jednotlivé agenty. AddAIAgent Předáním timeToLive: null zdědí nakonfigurované globální výchozí nastavení. Nepřepíše sedmidenní globální výchozí hodnotu s hodnotou Nikdy nevyprší. Nastavte DefaultTimeToLive = null na zakázání globální hodnoty TTL pro agenty bez pozitivních přepsání jednotlivých agentů.

.NET výchozí hodnota DurableAgentHistoryRetentionMode.KeepAll; Auto umožňuje uchovávání přepisu na základě tlaku. ResultRetentionPeriod výchozí hodnota je 60 sekund a je oddělená od hodnoty TTL relace. Python má odlišné možnosti uchovávání a rozpočtu, včetně retention="keep_all" výchozího nastavení. Nepředpokládejte stejné možnosti ani výchozí hodnoty mezi hostiteli.

Python podporuje snižování zátěže datové části objektů blob spravované sadou SDK v obou modelech hostování. Nakonfigurujte úložiště producenta i příjemce, přihlašovací údaje a životní cyklus objektů blob. Snižování zátěže neodebere limity kapacity celé entity ani nenahrazuje uchovávání. zachovat objekty blob, zatímco se odkazuje na stav nebo přehrání historie je vyžaduje. Viz .NET stav a uchovávání, Python uchovávání a rozpočty a snižování zátěže objektů blob Python Functions.

Informace o infrastruktuře plánovače, kapacitě a provozních pokynech najdete v tématu Integrace trvalých úloh pro platformu Agent Framework.

Kurz: Vytvoření a spuštění odolného agenta pomocí Azure Functions

V tomto kurzu se dozvíte, jak vytvořit a spustit odolného agenta AI pomocí modelu hostování Azure Functions pro rozšíření Durable. Vytvoříte aplikaci Azure Functions, která je hostitelem stavového agenta s integrovanými koncovými body HTTP, a dozvíte se, jak ji monitorovat pomocí řídicího panelu Plánovače úloh Durable. Ukázky najdete v případě agentů v místním prostředí.

Prerequisites

Než začnete, ujistěte se, že máte následující požadavky:

Note

Rozhraní Microsoft Agent Framework je podporováno ve všech aktivně podporovaných verzích rozhraní .NET. Pro účely této ukázky doporučujeme sadu .NET 9 SDK nebo novější verzi.

Nastavte DURABLE_AGENTS_DEPLOYMENT_MODE=isolated_v2 pouze po potvrzení, že je centrum kurzů izolované a že všichni pracovníci a klienti používají upgradovaný modul runtime.

Pro účely tohoto kurzu použijte nové centrum úloh oddělené od existujících trvalých aplikací. U existující aplikace použijte místo toho migraci nasazení a schématu .

Stažení projektu rychlého startu

Pomocí Azure Developer CLI inicializujete nový projekt ze šablony rychlého startu durable agents.

  1. Vytvořte pro projekt nový adresář a přejděte na něj:

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Inicializace projektu ze šablony:

    azd init --template durable-agents-quickstart-dotnet

    Po zobrazení výzvy k zadání názvu prostředí zadejte název, například my-durable-agent.

Tím se stáhne projekt pro rychlý start se všemi potřebnými soubory, včetně konfigurace služby Azure Functions, kódu agenta a infrastruktury jako šablony kódu.

  1. Vytvořte pro projekt nový adresář a přejděte na něj:

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Inicializace projektu ze šablony:

    azd init --template durable-agents-quickstart-python

    Po zobrazení výzvy k zadání názvu prostředí zadejte název, například my-durable-agent.

  2. Vytvoření a aktivace virtuálního prostředí:

    uv venv --python 3.13 .venv
source .venv/bin/activate

Note

Můžete také použít python -m venv .venv s nainstalovaným interpretem Python 3.13. Pokud tento příkaz přestane reagovat na Windows, použijte uv venv místo toho výše uvedený příkaz. Před instalací balíčků ověřte aktivní interpret python --version .

  1. Nainstalujte požadované balíčky:

    Před instalací aktualizujte šablonu requirements.txt na balíčky Functions v části Začínáme, včetně agent-framework-openai balíčku klienta. Vyřešte konfliktní kolidující piny závislostí v manifestu, a ne vynucení instalace.

    uv pip install -r requirements.txt

Tím se stáhne projekt pro rychlý start se všemi potřebnými soubory, včetně konfigurace služby Azure Functions, kódu agenta a infrastruktury jako šablony kódu. Připraví také virtuální prostředí s požadovanými závislostmi.

Zřízení prostředků Azure

Pomocí Azure Developer CLI vytvořte požadované prostředky Azure pro vašeho odolného agenta.

  1. Zřízení infrastruktury:

    azd provision

    Tento příkaz vytvoří:

    • Služba Azure OpenAI s nasazením gpt-4o-mini
    • Aplikace Azure Functions s plánem hostování Flex Consumption
    • Účet služby Azure Storage pro modul runtime Azure Functions a trvalé úložiště
    • Instance Plánovače trvalých úkolů (spotřební plán) pro správu stavu agenta
    • Nezbytné síťové a identitní konfigurace

  2. Po zobrazení výzvy vyberte své předplatné Azure a zvolte umístění prostředků.

Proces zřizování trvá několik minut. Po dokončení azd uloží ve vašem prostředí informace o vytvořených prostředcích.

Kontrola kódu agenta

Teď se podíváme na kód, který definuje vašeho odolného agenta.

Otevřete, Program.cs abyste viděli konfiguraci agenta:

using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Hosting;

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") 
    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT environment variable is not set");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT") ?? "gpt-4o-mini";

// Create an AI agent following the standard Microsoft Agent Framework pattern
AIAgent agent = new AIProjectClient(new Uri(endpoint), new DefaultAzureCredential())
    .AsAIAgent(
        model: deploymentName,
        instructions: "You are a helpful assistant that can answer questions and provide information.",
        name: "MyDurableAgent");

using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options => options.AddAIAgent(agent))
    .Build();
app.Run();

Tento kód:

  1. Načte konfiguraci Azure OpenAI z proměnných prostředí.
  2. Vytvoří klienta Azure OpenAI pomocí přihlašovacích údajů Azure.
  3. Vytvoří agenta AI s pokyny a názvem.
  4. Nakonfiguruje aplikaci Azure Functions pro hostování agenta s trvalou správou vláken.

Otevřete, function_app.py abyste viděli konfiguraci agenta:

import os
from agent_framework_azurefunctions import AgentFunctionApp
from agent_framework.openai import OpenAIChatCompletionClient
from azure.identity import DefaultAzureCredential

endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
if not endpoint:
    raise ValueError("AZURE_OPENAI_ENDPOINT is not set.")
deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT", "gpt-4o-mini")
api_version = os.getenv("AZURE_OPENAI_API_VERSION")

# Create an AI agent following the standard Microsoft Agent Framework pattern
agent = OpenAIChatCompletionClient(
    azure_endpoint=endpoint,
    model=deployment_name,
    api_version=api_version,
    credential=DefaultAzureCredential()
).as_agent(
    instructions="You are a helpful assistant that can answer questions and provide information.",
    name="MyDurableAgent"
)

# Configure the function app to host the agent with durable thread management
app = AgentFunctionApp(agents=[agent])

Tento kód:

  • Načte konfiguraci Azure OpenAI z proměnných prostředí.
  • Vytvoří klienta Azure OpenAI pomocí přihlašovacích údajů Azure.
  • Vytvoří agenta AI s pokyny a názvem.
  • Nakonfiguruje aplikaci Azure Functions pro hostování agenta s trvalou správou vláken.

Agent je teď připravený k hostovaní ve službě Azure Functions. Rozšíření trvalých úloh automaticky vytvoří koncové body HTTP pro interakci s vaším agentem a spravuje stav konverzací napříč několika požadavky.

Konfigurace místního nastavení

Vytvořte local.settings.json soubor pro místní vývoj na základě ukázkového souboru, který je součástí projektu.

  1. Zkopírujte ukázkový soubor nastavení:

    cp local.settings.sample.json local.settings.json

  1. Získejte koncový bod Azure OpenAI ze zřízených prostředků:

    azd env get-value AZURE_OPENAI_ENDPOINT

  2. Otevřete local.settings.json a nahraďte <your-resource-name> hodnotu AZURE_OPENAI_ENDPOINT koncovým bodem z předchozího příkazu.

Vaše local.settings.json by mělo vypadat takto:

{
  "IsEncrypted": false,
  "Values": {
    // ... other settings ...
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "AZURE_OPENAI_ENDPOINT": "https://your-openai-resource.openai.azure.com",
    "AZURE_OPENAI_DEPLOYMENT": "gpt-4o-mini",
    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None",
    "TASKHUB_NAME": "default"
  }
}

Note

Soubor local.settings.json se používá jenom pro místní vývoj a není nasazený do Azure. Pro produkční nasazení jsou tato nastavení automaticky nakonfigurovaná v aplikaci Azure Functions pomocí šablon infrastruktury.

V případě Python přidejte "DURABLE_AGENTS_DEPLOYMENT_MODE": "isolated_v2"Values ho až po potvrzení izolace centra kurzů. Konfigurace ekvivalentního nastavení aplikace při nasazování; místní nastavení se nenahraje automaticky.

Pro hostování založené na plánovači použijte stejné centrum úloh v host.json (prostřednictvím %TASKHUB_NAME%), TASKHUB_NAME, DURABLE_TASK_SCHEDULER_CONNECTION_STRINGemulátoru a řídicího panelu. Tento kurz používá default, který emulátor vytvoří automaticky. Pokud už toto centrum obsahuje staré historie nebo ho používají jiní pracovníci, zvolte jedinečný, nepoužitý název centra, nastavte emulátor DTS_TASK_HUB_NAMES na tento název a konzistentně aktualizujte nastavení aplikace a výběr řídicího panelu. Pouhé definování plánovače připojovací řetězec nevybere poskytovatele úložiště plánovače.

V host.jsončásti Konfigurovat zprostředkovatele plánovače v části extensions.durableTaskZachování dalších nastavení hostitele šablony:

{
  "extensions": {
    "durableTask": {
      "hubName": "%TASKHUB_NAME%",
      "storageProvider": {
        "type": "AzureManaged",
        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
      }
    }
  }
}

Pro váš hostitelský jazyk použijte závislosti zprostředkovatele plánovače. Tato konfigurace vybere back-end pro nové nasazení izolovaného kurzu; nepovoluje filtrování potřebné pro souběžný upgrade.

Zahájit lokální vývojové závislosti

Pokud chcete spustit trvalé agenty místně, musíte spustit dvě služby:

  • Azurite: Emuluje služby Azure Storage (používané službou Azure Functions ke správě triggerů a interního stavu).
  • Emulátor plánovače trvalých úloh (DTS): Spravuje trvalý stav (historie konverzací, stav orchestrace) a plánování pro vaše agenty

Tento postup předpokládá, že hostitel služby Functions používá poskytovatele úložiště Plánovač úloh Durable. Ukázky Python Functions vydané verze se standardně Azure Storage. Pokud začnete s těmito ukázkami, vyberte a nakonfigurujte poskytovatele plánovače před použitím řídicího panelu DTS; jinak Azurite uchovává trvalý stav a řídicí panel plánovače zůstane prázdný. Viz Nastavení Plánovače trvalých úloh.

Spustit Azurite

Azurite emuluje služby Azure Storage místně. Azure Functions ji používá ke správě interního stavu. Budete ho muset spustit v novém okně terminálu a nechat ho běžet při vývoji a testování odolného agenta.

  1. Otevřete nové okno terminálu a stáhněte image Azurite Dockeru:

    docker pull mcr.microsoft.com/azure-storage/azurite

  2. Spusťte Azurite v okně terminálu:

    docker run -p 10000:10000 -p 10001:10001 -p 10002:10002 mcr.microsoft.com/azure-storage/azurite

    Azurite se spustí a naslouchá na výchozích portech pro služby Blob (10000), Queue (10001) a Table (10002).

Během vývoje a testování odolného agenta nechte toto okno terminálu otevřené.

Tip

Další informace o Azurite, včetně alternativních metod instalace, naleznete v tématu Použití emulátoru Azurite pro místní vývoj služby Azure Storage.

Spuštění emulátoru Plánovače úloh Durable

Emulátor DTS poskytuje trvalý back-end pro správu stavu a orchestrací agenta. Ukládá historii konverzací a zajišťuje, aby se stav vašeho agenta zachoval při každém restartování. Aktivuje také trvanlivé orchestrace a agenty. Budete ho muset spustit v samostatném novém okně terminálu a nechat ho běžet při vývoji a testování odolného agenta.

  1. Otevřete další nové okno terminálu a stáhněte image Dockeru emulátoru DTS:

    docker pull mcr.microsoft.com/dts/dts-emulator:latest

  2. Spusťte emulátor DTS:

    docker run -p 8080:8080 -p 8082:8082 mcr.microsoft.com/dts/dts-emulator:latest

    Tento příkaz vytvoří default centrum úloh a spustí emulátor, který odpovídá nastavení tohoto kurzu. Příkaz zveřejňuje:

    • Port 8080: Koncový bod gRPC pro plánovač úloh Durable (používaný aplikací Functions)
    • Port 8082: Řídicí panel pro správu

  3. Řídicí panel bude k dispozici na adrese http://localhost:8082.

Během vývoje a testování odolného agenta nechte toto okno terminálu otevřené.

Tip

Další informace o emulátoru DTS, včetně postupu konfigurace více center úloh a přístupu k řídicímu panelu, najdete v tématu Vývoj s využitím Plánovače trvalých úloh.

Spuštění aplikace funkcí

Teď jste připraveni spustit aplikaci Azure Functions s trvalým agentem.

  1. V novém okně terminálu, zatímco Azurite a emulátor DTS běží v samostatných oknech, navigujte do adresáře projektu.

  2. Spusťte modul runtime Azure Functions:

    func start

  3. By měl být zobrazen výstup naznačující, že vaše funkční aplikace je spuštěna, včetně koncových bodů HTTP pro vašeho agenta:

    Functions:
     http-MyDurableAgent: [POST] http://localhost:7071/api/agents/MyDurableAgent/run
     dafx-v2-MyDurableAgent: entityTrigger

To znázorňuje .NET registraci schématu v2; Python názvy triggerů závisí na strategii nasazení. Tyto koncové body spravují stav konverzace automaticky, takže nemusíte vytvářet objekty relace sami.

Otestujte agenta lokálně

Teď můžete s trvalým agentem pracovat pomocí požadavků HTTP. Agent udržuje stav konverzace napříč několika požadavky a umožňuje více konverzací.

Zahájení nové konverzace

Vytvořte novou relaci a odešlete první zprávu:

curl -i -X POST http://localhost:7071/api/agents/MyDurableAgent/run \
  -H "Content-Type: text/plain" \
  -d "What are three popular programming languages?"

Ukázková odpověď (hlavička x-ms-session-id obsahuje ID relace; tento příklad ukazuje ID .NET schema-v2):

HTTP/1.1 200 OK
Content-Type: text/plain
x-ms-session-id: @dafx-v2-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d
Content-Length: 189

Three popular programming languages are Python, JavaScript, and Java. Python is known for its simplicity and readability, JavaScript powers web interactivity, and Java is widely used in enterprise applications.

Uložte přesné ID relace z hlavičky x-ms-session-id pro další požadavek. Nevytváření ani přepisování nevytváření. Python také vrátí tuto hlavičku, ale formát ID se může lišit.

Pokračovat v konverzaci

Odeslání následné zprávy do stejné relace zahrnutím vráceného ID do parametru kanonického sessionId dotazu:

Nahraďte ukázkové ID skutečnou hodnotou z hlavičky x-ms-session-id předchozí odpovědi. V případě potřeby zakódujte hodnotu pomocí adresy URL.

curl -X POST "http://localhost:7071/api/agents/MyDurableAgent/run?sessionId=@dafx-v2-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d" \
  -H "Content-Type: text/plain" \
  -d "Which one is best for beginners?"

Ukázková odpověď:

Python is often considered the best choice for beginners among those three. Its clean syntax reads almost like English, making it easier to learn programming concepts without getting overwhelmed by complex syntax. It's also versatile and widely used in education.

Všimněte si, že agent si pamatuje kontext z předchozí zprávy (tři programovací jazyky), aniž byste je museli znovu zadávat. Vzhledem k tomu, že stav konverzace je trvale uložený plánovačem trvalých úloh, tato historie přetrvává i v případě, že restartujete aplikaci funkcí nebo konverzaci obnovíte jinou instancí.

Monitorování pomocí řídicího panelu Plánovače úloh Durable

Durable Task Scheduler poskytuje integrovaný řídicí panel pro monitorování a ladění trvalých agentů. Řídicí panel nabízí hluboký přehled o operacích agenta, historii konverzací a toku provádění.

Přístup k řídicímu panelu

  1. Otevřete řídicí panel pro místní emulátor http://localhost:8082 DTS ve webovém prohlížeči.

  2. Vyberte výchozí nebo stejný jedinečný název centra, který jste nakonfigurovali v aplikaci i emulátoru, abyste zobrazili jeho podrobnosti.

  3. Klikněte na ikonu ozubeného kola v pravém horním rohu pro otevření nastavení a ujistěte se, že je možnost Povolit stránky agenta vybrána v části Ukázkové funkce.

Prozkoumání konverzací agentů

  1. Na řídicím panelu přejděte na kartu Agenti .

  2. Ze seznamu vyberte vlákno odolného agenta (např. mydurableagent - 263fa373-fa01-4705-abf2-5a114c2bb87d).

    Zobrazí se podrobné zobrazení vlákna agenta, včetně celé historie konverzací se všemi zprávami a odpověďmi.

    Snímek obrazovky řídicího panelu Plánovače trvalých úloh zobrazující historii konverzací vlákna agenta

Řídicí panel poskytuje zobrazení časové osy, které vám pomůže pochopit tok konverzace. Mezi klíčové informace patří:

  • Časová razítka a doba trvání pro každou interakci
  • Obsah výzvy a odpovědi
  • Počet použitých tokenů

Tip

Řídicí panel DTS poskytuje aktualizace v reálném čase, takže můžete sledovat chování agenta při interakci s ním prostřednictvím koncových bodů HTTP.

Nasazení do Azure

Teď, když jste místně otestovali odolného agenta, nasaďte ho do Azure.

  1. Nasazení aplikace:

    azd deploy

    Tento příkaz zabalí vaši aplikaci a nasadí ji do aplikace Azure Functions vytvořené během zřizování.

  2. Počkejte, až se nasazení dokončí. Výstup potvrdí, že je agent spuštěný v Azure.

Otestování nasazeného agenta

Po nasazení otestujte agenta spuštěný v Azure.

Získání klíče funkce

Pro výchozí autorizaci na úrovni funkce vygenerovaných koncových bodů zahrňte do požadavků na Azure klíč functions. Klíč služby Functions není autorizace uživatelem aplikace; viz provozní zabezpečení a řešení potíží.

API_KEY=`az functionapp function keys list --name $(azd env get-value AZURE_FUNCTION_NAME) --resource-group $(azd env get-value AZURE_RESOURCE_GROUP) --function-name http-MyDurableAgent --query default -o tsv`

Zahájení nové konverzace v Azure

Vytvořte novou relaci a odešlete první zprávu nasazeným agentům:

curl -i -X POST "https://$(azd env get-value AZURE_FUNCTION_NAME).azurewebsites.net/api/agents/MyDurableAgent/run?code=$API_KEY" \
  -H "Content-Type: text/plain" \
  -d "What are three popular programming languages?"

Uložte ID relace vrácené v x-ms-session-id hlavičce odpovědi.

Pokračování v konverzaci v Azure

Odešlete zprávu s následnou zprávou ve stejné relaci. Použijte přesné ID vrácené předchozí odpovědí:

SESSION_ID="<session-id>"
curl -X POST "https://$(azd env get-value AZURE_FUNCTION_NAME).azurewebsites.net/api/agents/MyDurableAgent/run?code=$API_KEY" \
  --url-query "sessionId=$SESSION_ID" \
  -H "Content-Type: text/plain" \
  -d "Which is easiest to learn?"

Agent zachovává kontext konverzace v Azure stejně jako místně, což demonstruje trvanlivost stavu agenta.

Monitorování nasazeného agenta

Nasazeného agenta můžete monitorovat pomocí řídicího panelu Plánovače úloh Durable v Azure.

  1. Získejte název instance Plánovače úloh Durable:

    azd env get-value DTS_NAME

  2. Otevřete web Azure Portal a vyhledejte název plánovače trvalých úloh z předchozího kroku.

  3. V okně přehledu prostředku Plánovač úloh Durable Task Scheduler vyberte centrum úloh nakonfigurované pro nasazenou aplikaci.

  4. Výběrem možnosti Otevřít řídicí panel v horní části stránky centra úloh otevřete řídicí panel monitorování.

  5. Podívejte se na konverzace agenta stejně jako v místním emulátoru.

Řídicí panel hostovaný v Azure poskytuje stejné možnosti ladění a monitorování jako místní emulátor, což umožňuje kontrolovat historii konverzací, volání nástrojů trasování a analyzovat výkon v produkčním prostředí.

Kurz: Orchestrace trvalých agentů pomocí Azure Functions

V tomto kurzu se dozvíte, jak orchestrovat více trvalých agentů umělé inteligence pomocí modelu hostování Azure Functions a modelu fan-out/fan-in. Rozšířením odolného agenta z předchozího kurzu vytvoříte systém s více agenty, který zpracuje otázku uživatele, a pak současně přeloží odpověď do více jazyků. Příklady orchestrace v místním prostředí najdete v ukázkách.

Principy modelu orchestrace

Orchestrace, kterou vytvoříte, se řídí tímto tokem:

  1. Uživatelský vstup – otázka nebo zpráva od uživatele
  2. Hlavní agent – MyDurableAgent z prvního tutoriálu zpracovává otázku
  3. Fan-out – odpověď hlavního agenta se odesílá souběžně oběma agentům překladu.
  4. Agenti překladu – dva specializovaní agenti překládají odpověď (francouzština a španělština)
  5. Fan-in – Výsledky se agregují do jedné odpovědi JSON s původní odpovědí a překlady.

Tento model umožňuje souběžné zpracování, což snižuje celkovou dobu odezvy v porovnání s sekvenčním překladem.

Registrace agentů při spuštění

Pokud chcete správně používat agenty v trvalých orchestracích, zaregistrujte je při spuštění aplikace. Dají se použít napříč prováděními orchestrace.

Aktualizujte váš Program.cs, aby registroval agenty překladu spolu s existujícími MyDurableAgent agenty:

using System;
using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Hosting;

// Get the Azure OpenAI configuration
string endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
string deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT")
    ?? "gpt-4o-mini";

// Create the Microsoft Foundry client
AIProjectClient client = new(new Uri(endpoint), new DefaultAzureCredential());

// Create the main agent from the first tutorial
AIAgent mainAgent = client.AsAIAgent(
    model: deploymentName,
    instructions: "You are a helpful assistant that can answer questions and provide information.",
    name: "MyDurableAgent");

// Create translation agents
AIAgent frenchAgent = client.AsAIAgent(
    model: deploymentName,
    instructions: "You are a translator. Translate the following text to French. Return only the translation, no explanations.",
    name: "FrenchTranslator");

AIAgent spanishAgent = client.AsAIAgent(
    model: deploymentName,
    instructions: "You are a translator. Translate the following text to Spanish. Return only the translation, no explanations.",
    name: "SpanishTranslator");

// Build and configure the Functions host
using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options =>
    {
        // Register all agents for use in orchestrations and HTTP endpoints
        options.AddAIAgent(mainAgent);
        options.AddAIAgent(frenchAgent);
        options.AddAIAgent(spanishAgent);
    })
    .Build();

app.Run();

Aktualizujte váš function_app.py, aby registroval agenty překladu spolu s existujícími MyDurableAgent agenty:

import os
from azure.identity import DefaultAzureCredential
from agent_framework_azurefunctions import AgentFunctionApp
from agent_framework.openai import OpenAIChatCompletionClient

# Get the Azure OpenAI configuration
endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
if not endpoint:
    raise ValueError("AZURE_OPENAI_ENDPOINT is not set.")
deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT", "gpt-4o-mini")
api_version = os.getenv("AZURE_OPENAI_API_VERSION")

# Create the Azure OpenAI client
chat_client = OpenAIChatCompletionClient(
    azure_endpoint=endpoint,
    model=deployment_name,
    api_version=api_version,
    credential=DefaultAzureCredential()
)

# Create the main agent from the first tutorial
main_agent = chat_client.as_agent(
    instructions="You are a helpful assistant that can answer questions and provide information.",
    name="MyDurableAgent"
)

# Create translation agents
french_agent = chat_client.as_agent(
    instructions="You are a translator. Translate the following text to French. Return only the translation, no explanations.",
    name="FrenchTranslator"
)

spanish_agent = chat_client.as_agent(
    instructions="You are a translator. Translate the following text to Spanish. Return only the translation, no explanations.",
    name="SpanishTranslator"
)

# Create the function app and register all agents
app = AgentFunctionApp(agents=[main_agent, french_agent, spanish_agent])

Vytvořte funkci orchestrace

Funkce orchestrace koordinuje pracovní postup napříč více agenty. Načte zaregistrované agenty z trvalého kontextu a orchestruje jejich spuštění, nejprve zavolá hlavního agenta, a poté roztříští úkoly na překladatelské agenty souběžně.

Vytvořte nový soubor s názvem AgentOrchestration.cs v adresáři projektu:

using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.DurableTask;
using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;

namespace MyDurableAgent;

public static class AgentOrchestration
{
    // Define a strongly-typed response structure for agent outputs
    public sealed record TextResponse(string Text);

    [Function("agent_orchestration_workflow")]
    public static async Task<Dictionary<string, string>> AgentOrchestrationWorkflow(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        var input = context.GetInput<string>() ?? throw new ArgumentNullException(nameof(context), "Input cannot be null");

        // Step 1: Get the main agent's response
        DurableAIAgent mainAgent = context.GetAgent("MyDurableAgent");
        AgentResponse<TextResponse> mainResponse = await mainAgent.RunAsync<TextResponse>(input);
        string agentResponse = mainResponse.Result.Text;

        // Step 2: Fan out - get the translation agents and run them concurrently
        DurableAIAgent frenchAgent = context.GetAgent("FrenchTranslator");
        DurableAIAgent spanishAgent = context.GetAgent("SpanishTranslator");

        Task<AgentResponse<TextResponse>> frenchTask = frenchAgent.RunAsync<TextResponse>(agentResponse);
        Task<AgentResponse<TextResponse>> spanishTask = spanishAgent.RunAsync<TextResponse>(agentResponse);

        // Step 3: Wait for both translation tasks to complete (fan-in)
        await Task.WhenAll(frenchTask, spanishTask);

        // Get the translation results
        TextResponse frenchResponse = (await frenchTask).Result;
        TextResponse spanishResponse = (await spanishTask).Result;

        // Step 4: Combine results into a dictionary
        var result = new Dictionary<string, string>
        {
            ["original"] = agentResponse,
            ["french"] = frenchResponse.Text,
            ["spanish"] = spanishResponse.Text
        };

        return result;
    }
}

Přidejte do function_app.py souboru funkci orchestrace:

from durabletask.task import OrchestrationContext, when_all

@app.orchestration_trigger(context_name="context")
def agent_orchestration_workflow(context: OrchestrationContext, input_text: str):
    """
    Orchestration function that coordinates multiple agents.
    Returns a dictionary with the original response and translations.
    """
    # Step 1: Get the main agent's response
    main_agent = app.get_agent(context, "MyDurableAgent")
    main_response = yield main_agent.run(input_text)
    agent_response = main_response.text

    # Step 2: Fan out - get the translation agents and run them concurrently
    french_agent = app.get_agent(context, "FrenchTranslator")
    spanish_agent = app.get_agent(context, "SpanishTranslator")

    parallel_tasks = [
        french_agent.run(agent_response),
        spanish_agent.run(agent_response)
    ]

    # Step 3: Wait for both translation tasks to complete (fan-in)
    translations = yield when_all(parallel_tasks)

    # Step 4: Combine results into a dictionary
    result = {
        "original": agent_response,
        "french": translations[0].text,
        "spanish": translations[1].text
    }

    return result

Note

Tato příručka popisuje hostování rozšíření C# a Python Durable Extension. Informace o hostování Go najdete v tématu Hostování A2A a úložiště Agent Framework Go.

Otestování orchestrace

Ujistěte se, že vaše lokální závislosti na vývoji z prvního tutoriálu stále běží:

  • Azurite v jednom okně terminálu
  • Emulátor plánovače úloh Durable v jiném okně terminálu

Při běhu místních vývojových závislostí:

  1. Spusťte aplikaci Azure Functions v novém okně terminálu:

    func start

  2. Rozšíření Durable Functions automaticky vytvoří integrované koncové body HTTP pro správu orchestrací. Spusťte orchestraci pomocí integrovaného rozhraní API:

    curl -X POST http://localhost:7071/runtime/webhooks/durabletask/orchestrators/agent_orchestration_workflow \
  -H "Content-Type: application/json" \
  -d '"\"What are three popular programming languages?\""'

  1. Odpověď obsahuje adresy URL pro správu instance orchestrace:

    {
  "id": "abc123def456",
  "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456",
  "sendEventPostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456/raiseEvent/{eventName}",
  "terminatePostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456/terminate",
  "purgeHistoryDeleteUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456"
}

  2. Zjistěte stav orchestrace pomocí hodnoty statusQueryGetUri (nahraďte abc123def456 vaším skutečným ID instance):

    curl http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456

  1. Průběžně kontrolujte stav koncového bodu, dokud runtimeStatus není Completed. Po dokončení uvidíte výstup orchestrace s odpovědí hlavního agenta a jeho překlady:

    {
  "name": "agent_orchestration_workflow",
  "instanceId": "abc123def456",
  "runtimeStatus": "Completed",
  "output": {
    "original": "Three popular programming languages are Python, JavaScript, and Java. Python is known for its simplicity...",
    "french": "Trois langages de programmation populaires sont Python, JavaScript et Java. Python est connu pour sa simplicité...",
    "spanish": "Tres lenguajes de programación populares son Python, JavaScript y Java. Python es conocido por su simplicidad..."
  }
}

Monitorování orchestrace na řídicím panelu

Řídicí panel plánovače trvalých úloh poskytuje přehled o orchestraci:

  1. Otevřete http://localhost:8082 v prohlížeči.

  2. Vyberte centrum úloh nakonfigurované pro vaši aplikaci.

  3. Vyberte kartu Orchestrace.

  4. Vyhledejte instanci orchestrace v seznamu.

  5. Vyberte instanci, která se má zobrazit:

    • Časová osa orchestrace
    • Spuštění hlavního agenta následované souběžnými agenty pro překlad
    • Každé spuštění agenta (MyDurableAgent, francouzští a španělští překladatelé)
    • Fan-out a fan-in vzory vizualizovány
    • Časování a doba trvání jednotlivých kroků

Nasazení orchestrace do Azure

Nasazení aktualizované aplikace pomocí Azure Developer CLI:

azd deploy

Tím se nasadí aktualizovaný kód s novou funkcí orchestrace a dalšími agenty do aplikace Azure Functions vytvořené v prvním kurzu.

Otestování nasazené orchestrace

Po nasazení otestujte orchestraci spuštěnou v Azure.

  1. Získejte systémový klíč pro rozšíření Durable:

    SYSTEM_KEY=$(az functionapp keys list --name $(azd env get-value AZURE_FUNCTION_NAME) --resource-group $(azd env get-value AZURE_RESOURCE_GROUP) --query "systemKeys.durabletask_extension" -o tsv)

  1. Spusťte orchestraci pomocí integrovaného rozhraní API:

    curl -X POST "https://$(azd env get-value AZURE_FUNCTION_NAME).azurewebsites.net/runtime/webhooks/durabletask/orchestrators/agent_orchestration_workflow?code=$SYSTEM_KEY" \
  -H "Content-Type: application/json" \
  -d '"\"What are three popular programming languages?\""'
  1. Pomocí statusQueryGetUri z odpovědi můžete provádět dotazování na stav dokončení a zobrazit výsledky včetně překladů.

Provozní zabezpečení a řešení potíží

Zacházejte s těmito hranicemi přístupu samostatně:

  • Uživatelé aplikace: Ověřte volající a autorizujete přístup k jednotlivým relacím, pracovním postupům a odpovědím na lidské schválení. ID relací, korelace a požadavků jsou identifikátory, nikoli přihlašovací údaje.
  • Koncové body funkcí: Klíče na úrovni funkce chrání vygenerované koncové body HTTP, ale nenavazují identitu uživatele aplikace nebo vlastnictví relace. Chránit a otáčet klíče; nezpřístupněte je v kódu aplikace doručené v prohlížeči.
  • Přístup k modelu: Udělte identitě pracovního procesu požadovaná oprávnění modelu. Přihlašovací údaje modelu neudělí přístup k plánovači ani k relaci jiného uživatele.
  • Přístup k plánovači: Nakonfigurujte oprávnění pracovního procesu, klienta a řídicího panelu pro jejich zamýšlené role. Pokyny k infrastruktuře najdete v tématu Integrace Durable Task.
Symptom Zaškrtnutí
instalace balíčku Python nebo selhání spuštění služby Functions Pro službu Functions použijte Python 3.13 nebo novější, nainstalujte balíčky Functions v části Začínáme a explicitně vyberte strategii nasazení. Samostatné Python minimum se liší.
Požadavky jsou úspěšné, ale řídicí panel DTS je prázdný. Ověřte, AzureStorageže poskytovatel úložiště Functions není AzureManageda že koncový bod plánovače a centrum úloh odpovídají řídicímu panelu.
Zdá se, že relace ztratí kontext. Použijte přesnou vrácenou x-ms-session-id hodnotu sessionIdpomocí funkce ; zkontrolujte jiné centrum, obor názvů nasazení nebo nakonfigurované vyčištění relace.
Staré pracovní postupy selžou po upgradu Před obnovením historických spuštění zkontrolujte kompatibilitu přehrávání. Migrace entit neopravuje nekompatibilní historii pracovních postupů.
Datový proud se dokončí, ale trvalé dokončení chybí. Považovat výstup streamu za prozatímní a zkontrolovat autoritativní výsledek nebo zachovat výsledek. Značka dokončení datového proudu není potvrzení trvalým potvrzením.
Dokončená operace se vrátí. 410 Zkontrolujte zachování výsledků a dostupnost výsledků. Nepředpokládáte selhání, cyklické dotazování jako čekající nebo automaticky odešlete novou operaci.
Zápisy do stavu entity překračují kapacitu Zkontrolujte stav celé entity, chráněné záznamy, zásady uchovávání informací a odkazy na datovou část. Samotná komprimace vstupu modelu nezaručuje, že se uložený stav vejde.

Další kroky

Koncové body kompatibilní s OpenAI

Další prostředky:

  • Poslední aktualizace v