Dela via

Azure Functions (Durable)

Med tillägget för varaktiga uppgifter för Microsoft Agent Framework kan du skapa tillståndskänsliga AI-agenter och deterministiska orkestreringar med flera agenter i en serverlös miljö i Azure.

Azure Functions är en serverlös beräkningstjänst som gör att du kan köra kod på begäran utan att hantera infrastrukturen. Tillägget för varaktiga uppgifter bygger på den här grunden för att tillhandahålla hantering av varaktigt tillstånd, vilket innebär att agentens konversationshistorik och körningstillstånd på ett tillförlitligt sätt bevaras och överlever fel, omstarter och långvariga åtgärder.

Översikt

Varaktiga agenter kombinerar kraften i Agent Framework med Azure Durable Functions för att skapa agenter som:

  • Spara tillstånd automatiskt mellan funktionsanrop
  • Återuppta efter fel utan att förlora konversationskontexten
  • Skala automatiskt baserat på efterfrågan
  • Samordna arbetsflöden för flera agenter med tillförlitliga körningsgarantier

När du ska använda varaktiga agenter

Välj hållbara agenter när du behöver:

  • Fullständig kodkontroll: Distribuera och hantera din egen beräkningsmiljö samtidigt som du behåller serverlösa fördelar
  • Komplexa orkestreringar: Samordna flera agenter med deterministiska, tillförlitliga arbetsflöden som kan köras i dagar eller veckor
  • Händelsedriven orkestrering: Integrera med Azure Functions-utlösare (HTTP, timers, köer osv.) och bindningar för händelsedrivna agentarbetsflöden
  • Automatiskt konversationstillstånd: Agentkonversationshistoriken hanteras automatiskt och sparas utan att det krävs explicit tillståndshantering i koden

Den här serverlösa värdmetoden skiljer sig från hanterad tjänstbaserad agentvärd (till exempel Foundry Agent Service), som tillhandahåller fullständigt hanterad infrastruktur utan att du behöver distribuera eller hantera Azure Functions-appar. Varaktiga agenter är idealiska när du behöver flexibiliteten i distribution som utgår från kod kombinerat med tillförlitligheten för tillståndshantering med beständighet.

När agenterna finns i Azure Functions Flex Consumption-värdplanen kan de skala till tusentals instanser eller till noll instanser när de inte används, så att du bara betalar för den beräkning du behöver.

Komma igång

I ett .NET Azure Functions-projekt lägger du till nödvändiga NuGet-paket.

dotnet add package Azure.AI.OpenAI --prerelease
dotnet add package Azure.Identity
dotnet add package Microsoft.Agents.AI.OpenAI --prerelease
dotnet add package Microsoft.Agents.AI.Hosting.AzureFunctions --prerelease

Anmärkning

Förutom dessa paket kontrollerar du att ditt projekt använder version 2.2.0 eller senare av microsoft.Azure.Functions.Worker-paketet .

Installera nödvändiga Python-paket i ett Python Azure Functions-projekt.

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

Serverlös värd

Med det varaktiga uppgiftstillägget kan du distribuera och vara värd för Microsoft Agent Framework-agenter i Azure Functions med inbyggda HTTP-slutpunkter och orkestreringsbaserat anrop. Azure Functions tillhandahåller händelsedrivna priser med betala per anrop med automatisk skalning och minimal infrastrukturhantering.

När du konfigurerar en varaktig agent skapar det varaktiga aktivitetstillägget automatiskt HTTP-slutpunkter för din agent och hanterar all underliggande infrastruktur för lagring av konversationstillstånd, hantering av samtidiga begäranden och samordning av arbetsflöden för flera agenter.

using System;
using Azure.AI.OpenAI;
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 AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsAIAgent(
        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();

import os
from agent_framework.azure import AzureOpenAIChatClient, AgentFunctionApp
from azure.identity import DefaultAzureCredential

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

# Create an AI agent following the standard Microsoft Agent Framework pattern
agent = AzureOpenAIChatClient(
    endpoint=endpoint,
    deployment_name=deployment_name,
    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])

Tillståndskänsliga agenttrådar med konversationshistorik

Agenter upprätthåller beständiga trådar som överlever över flera interaktioner. Varje tråd identifieras av ett unikt tråd-ID och lagrar hela konversationshistoriken i beständig lagring som hanteras av Durable Task Scheduler.

Det här mönstret möjliggör konversationskontinuitet där agenttillstånd bevaras genom processkrascher och omstarter, vilket gör att fullständig konversationshistorik kan upprätthållas mellan användartrådar. Den hållbara lagringen säkerställer att även om din Azure Functions-instans startar om eller skalar till en annan instans fortsätter konversationen sömlöst från där den slutade.

I följande exempel visas flera HTTP-begäranden till samma tråd, som visar hur konversationskontexten bevaras:

# First interaction - start a new thread
curl -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 thread ID in x-ms-thread-id header and joke as plain text
# HTTP/1.1 200 OK
# Content-Type: text/plain
# x-ms-thread-id: @dafx-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 - continue the same thread with context
curl -X POST "https://your-function-app.azurewebsites.net/api/agents/Joker/run?thread_id=@dafx-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!

Agenttillståndet hålls kvar i varaktig lagring, vilket möjliggör körning i distribuerad form över flera instanser. Varje instans kan återuppta agentens körning efter avbrott eller fel, vilket säkerställer en kontinuerlig drift.

Deterministiska orkestreringar för flera agenter

Tillägget durable task stöder skapandet av deterministiska arbetsflöden som samordnar flera agenter med hjälp av Azure Durable Functions-orkestreringar .

Orkestreringar är kodbaserade arbetsflöden som samordnar flera åtgärder (till exempel agentanrop, externa API-anrop eller timers) på ett tillförlitligt sätt. Deterministisk innebär att orkestreringskoden körs på samma sätt när den spelas upp efter ett fel, vilket gör arbetsflöden tillförlitliga och debuggable – när du spelar upp en orkestreringshistorik kan du se exakt vad som hände i varje steg.

Orkestreringar körs tillförlitligt, överlever fel mellan agentanropen och tillhandahåller förutsägbara och upprepbara processer. Detta gör dem idealiska för komplexa scenarier med flera agenter där du behöver garanterad exekveringsordning och feltolerans.

Sekventiella orkestreringar

I det sekventiella multiagentmönstret körs specialiserade agenter i en specifik ordning, där varje agents utdata kan påverka nästa agentkörning. Det här mönstret stöder villkorsstyrd logik och förgrening baserat på agentsvar.

När du använder agenter i orkestreringar måste du använda API:et context.GetAgent() för att hämta en DurableAIAgent instans, vilket är en särskild underklass av standardtypen AIAgent som omsluter en av dina registrerade agenter. Omslutningen DurableAIAgent säkerställer att agentanrop spåras korrekt och kontrollpunktas av det hållbara orkestreringsramverket.

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);
}

När du använder agenter i orkestreringar måste du använda app.get_agent()-metoden för att hämta en hållbar agent-instans, som är ett speciellt omslag runt en av dina registrerade agenter. Den hållbara agentomslutningen säkerställer att agentanrop spåras korrekt och kontrollpunkteras av det tåliga orkestreringsramverket.

import azure.durable_functions as df
from typing import cast
from agent_framework.azure 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: df.DurableOrchestrationContext):
    email = context.get_input()

    # 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,
        response_format=SpamDetectionResult
    )
    spam_result = cast(SpamDetectionResult, spam_result_raw.get("structured_response"))

    if spam_result.is_spam:
        result = yield context.call_activity("handle_spam_email", 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,
        response_format=EmailResponse
    )
    email_response = cast(EmailResponse, email_response_raw.get("structured_response"))

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

Orkestreringar samordnar arbete mellan flera agenter och klarar av fel mellan agentanrop. Orkestreringskontexten innehåller metoder för att hämta och interagera med värdbaserade agenter inom orkestreringar.

Parallella orkestreringar

I det parallella multiagentmönstret kör du flera agenter samtidigt och aggregerar sedan deras resultat. Det här mönstret är användbart för att samla in olika perspektiv eller bearbeta oberoende underaktiviteter samtidigt.

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;
}

import azure.durable_functions as df
from agent_framework.azure import AgentFunctionApp

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

@app.orchestration_trigger(context_name="context")
def research_orchestration(context: df.DurableOrchestrationContext):
    topic = context.get_input()

    # 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 context.task_all([technical_task, market_task, competitor_task])

    # Aggregate results
    all_research = "\n\n".join([r.get('response', '') 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.get('response', '')

Den parallella körningen spåras med hjälp av en lista över arbetsuppgifter. Automatisk kontrollpunktshantering säkerställer att slutförda agentkörningar inte upprepas eller går förlorade om ett fel inträffar under aggregering.

Orkestreringar för människor i loopen

Deterministiska agentorkestreringar kan pausas för mänsklig indata, godkännande eller granskning utan att förbruka beräkningsresurser. Varaktig körning gör det möjligt för orkestreringar att vänta i dagar eller till och med veckor medan de väntar på mänskliga svar. I kombination med serverlös värd, spunnas alla beräkningsresurser ned under väntetiden, vilket eliminerar beräkningskostnader tills människan tillhandahåller sina indata.

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";
}

import azure.durable_functions as df
from datetime import timedelta
from agent_framework.azure import AgentFunctionApp

app = AgentFunctionApp(agents=[content_agent])

@app.orchestration_trigger(context_name="context")
def content_approval_workflow(context: df.DurableOrchestrationContext):
    topic = context.get_input()

    # 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", draft_content)

    # 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 context.task_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", draft_content)
            return result
        return "Content rejected"

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

Deterministiska agentorkestreringar kan vänta på externa händelser och varaktigt bevara deras tillstånd medan de väntar på mänsklig feedback, överleva fel, omstarter och förlängda väntetider. När det mänskliga svaret kommer återupptas orkestreringen automatiskt med fullständigt konversationssammanhang och exekveringstillstånd intakt.

Tillhandahålla mänskliga indata

Om du vill skicka godkännande eller indata till en väntande orkestrering skapar du en extern händelse till orkestreringsinstansen med hjälp av Durable Functions-klient-SDK:t. En granskare kan till exempel godkänna innehåll via ett webbformulär som anropar:

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)

Kostnadseffektivitet

Arbetsflöden med mänsklig interaktion med varaktiga agenter är extremt kostnadseffektiva när de värdshusas på Azure Functions Flex Consumption-plan. För ett arbetsflöde som väntar 24 timmar på godkännande betalar du bara för några sekunders körningstid (tiden för att generera innehåll, skicka meddelanden och bearbeta svaret)– inte de 24 timmarna som väntar. Under väntetiden förbrukas inga beräkningsresurser.

Observerbarhet i samband med Durable Task Scheduler

Durable Task Scheduler (DTS) är den rekommenderade hållbara backendlösningen för era hållbara agenter, som erbjuder bästa prestanda, hanterad infrastruktur och inbyggd observerbarhet via ett UI-dashboard. Även om Azure Functions kan använda andra lagringsserverdelar (till exempel Azure Storage), är DTS optimerat specifikt för varaktiga arbetsbelastningar och ger överlägsen prestanda och övervakningsfunktioner.

Insikter om agentsessioner

  • Konversationshistorik: Visa fullständig chatthistorik för varje agentsession, inklusive alla meddelanden, verktygsanrop och konversationskontext när som helst
  • Tidsinställning för aktiviteter: Övervaka hur lång tid det tar för specifika uppgifter och agentinteraktioner att slutföras

Skärmbild av instrumentpanelen Durable Task Scheduler som visar agentchatthistorik med konversationstrådar och meddelanden.

Orkestreringsinsikter

  • Visualisering med flera agenter: Se körningsflödet när du anropar flera specialiserade agenter med visuell representation av parallella körningar och villkorsstyrd förgrening
  • Körningshistorik: Få åtkomst till detaljerade körningsloggar
  • Realtidsövervakning: Spåra aktiva orkestreringar, köade arbetsobjekt och agenttillstånd i din distribution
  • Prestandamått: Övervaka agentens svarstider, tokenanvändning och orkestreringstid

Skärmbild av kontrollpanelen Durable Task Scheduler som visar visualisering av orkestrering med interaktioner mellan agenter och arbetsflödets körning.

Felsökningsfunktioner

  • Visa strukturerade agentutdata och verktygsanropsresultat
  • Spårningsverktygsanrop och deras resultat
  • Övervaka extern händelsehantering för scenarier med människa i loopen

På instrumentpanelen kan du förstå exakt vad dina agenter gör, diagnostisera problem snabbt och optimera prestanda baserat på verkliga körningsdata.

Självstudie: Skapa och köra en varaktig agent

Den här självstudien visar hur du skapar och kör en hållbar AI-agent med hjälp av det varaktiga uppgiftstillägget för Microsoft Agent Framework. Du skapar en Azure Functions-app som är värd för en tillståndskänslig agent med inbyggda HTTP-slutpunkter och lär dig hur du övervakar den med instrumentpanelen Durable Task Scheduler.

Förutsättningar

Kontrollera att du har följande förutsättningar innan du börjar:

Anmärkning

Microsoft Agent Framework stöds med alla versioner av .NET som stöds aktivt. I det här exemplet rekommenderar vi .NET 9 SDK eller en senare version.

Ladda ned snabbstartsprojektet

Använd Azure Developer CLI för att initiera ett nytt projekt från snabbstartsmallen durable agents.

  1. Skapa en ny katalog för projektet och navigera till den:

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Initiera projektet från mallen:

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

    När du uppmanas att ange ett miljönamn anger du ett namn som my-durable-agent.

Detta laddar ned snabbstartsprojektet med alla nödvändiga filer, inklusive Azure Functions-konfiguration, agentkod och infrastruktur som kodmallar.

  1. Skapa en ny katalog för projektet och navigera till den:

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Initiera projektet från mallen:

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

    När du uppmanas att ange ett miljönamn anger du ett namn som my-durable-agent.

  2. Skapa och aktivera en virtuell miljö:

    python3 -m venv .venv
source .venv/bin/activate

  1. Installera de paket som krävs:

    python -m pip install -r requirements.txt

Detta laddar ned snabbstartsprojektet med alla nödvändiga filer, inklusive Azure Functions-konfiguration, agentkod och infrastruktur som kodmallar. Den förbereder också en virtuell miljö med nödvändiga beroenden.

Etablera Azure-resurser

Använd Azure Developer CLI för att skapa nödvändiga Azure-resurser för din varaktiga agent.

  1. Upprätta infrastrukturen

    azd provision

    Det här kommandot skapar:

    • En Azure OpenAI-tjänst med en gpt-4o-mini-distribution
    • En Azure Functions-app med Flex Consumption-hostingplan
    • Ett Azure Storage-konto för Azure Functions-körningen och beständig lagring
    • En Durable Task Scheduler-instans (konsumtionsplan) för hantering av agenttillstånd
    • Nödvändiga nätverks- och identitetskonfigurationer

  2. När du uppmanas till det väljer du din Azure-prenumeration och väljer en plats för resurserna.

Etableringsprocessen tar några minuter. När det är klart lagrar azd den skapade resursinformationen i din miljö.

Granska agentkoden

Nu ska vi undersöka koden som definierar din varaktiga agent.

Öppna Program.cs för att se agentkonfigurationen:

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

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 AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsAIAgent(
        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();

Den här koden:

  1. Hämtar din Azure OpenAI-konfiguration från miljövariabler.
  2. Skapar en Azure OpenAI-klient med azure-autentiseringsuppgifter.
  3. Skapar en AI-agent med instruktioner och ett namn.
  4. Konfigurerar Azure Functions-appen som värd för agenten med beständig trådhantering.

Öppna function_app.py för att se agentkonfigurationen:

import os
from agent_framework.azure import AzureOpenAIChatClient, AgentFunctionApp
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_NAME", "gpt-4o-mini")

# Create an AI agent following the standard Microsoft Agent Framework pattern
agent = AzureOpenAIChatClient(
    endpoint=endpoint,
    deployment_name=deployment_name,
    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])

Den här koden:

  • Hämtar din Azure OpenAI-konfiguration från miljövariabler.
  • Skapar en Azure OpenAI-klient med azure-autentiseringsuppgifter.
  • Skapar en AI-agent med instruktioner och ett namn.
  • Konfigurerar Azure Functions-appen som värd för agenten med beständig trådhantering.

Agenten är nu redo att finnas i Azure Functions. Det varaktiga aktivitetstillägget skapar automatiskt HTTP-slutpunkter för att interagera med din agent och hanterar konversationstillstånd för flera begäranden.

Konfigurera lokala inställningar

Skapa en local.settings.json fil för lokal utveckling baserat på exempelfilen som ingår i projektet.

  1. Kopiera exempelinställningsfilen:

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

  1. Hämta din Azure OpenAI-slutpunkt från de etablerade resurserna:

    azd env get-value AZURE_OPENAI_ENDPOINT

  2. Öppna local.settings.json och ersätt <your-resource-name> i AZURE_OPENAI_ENDPOINT värdet med slutpunkten från föregående kommando.

Din local.settings.json ska se ut så här:

{
  "IsEncrypted": false,
  "Values": {
    // ... other settings ...
    "AZURE_OPENAI_ENDPOINT": "https://your-openai-resource.openai.azure.com",
    "AZURE_OPENAI_DEPLOYMENT": "gpt-4o-mini",
    "TASKHUB_NAME": "default"
  }
}

Anmärkning

Filen local.settings.json används endast för lokal utveckling och distribueras inte till Azure. För produktionsdistributioner konfigureras de här inställningarna automatiskt i Azure Functions-appen av infrastrukturmallarna.

Starta lokala beroenden för utveckling

Om du vill köra varaktiga agenter lokalt måste du starta två tjänster:

  • Azurite: Emulerar Azure Storage-tjänster (används av Azure Functions för att hantera utlösare och internt tillstånd).
  • DTS-emulator (Durable Task Scheduler): Hanterar varaktigt tillstånd (konversationshistorik, orkestreringstillstånd) och schemaläggning för dina agenter

Starta Azurite

Azurite emulerar Azure Storage-tjänster lokalt. Azure Functions använder det för att hantera internt tillstånd. Du måste köra detta i ett nytt terminalfönster och hålla det igång medan du utvecklar och testar din varaktiga agent.

  1. Öppna ett nytt terminalfönster och hämta Azurite Docker-avbildningen:

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

  2. Starta Azurite i ett terminalfönster:

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

    Azurite startar och lyssnar på standardportarna för blobtjänster (10000), Kö (10001) och Tabell (10002).

Håll det här terminalfönstret öppet medan du utvecklar och testar din varaktiga agent.

Tips/Råd

Mer information om Azurite, inklusive alternativa installationsmetoder, finns i Använda Azurite-emulatorn för lokal Azure Storage-utveckling.

Starta emulatorn Durable Task Scheduler

DTS-emulatorn tillhandahåller den hållbara serverdelen för hantering av agenttillstånd och orkestreringar. Den lagrar konversationshistorik och säkerställer att agentens tillstånd kvarstår vid omstart. Det utlöser också varaktiga orkestreringar och agenter. Du måste köra detta i ett separat nytt terminalfönster och hålla det igång medan du utvecklar och testar din varaktiga agent.

  1. Öppna ett nytt terminalfönster och hämta Docker-avbildningen för DTS-emulatorn:

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

  2. Kör DTS-emulatorn:

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

    Det här kommandot startar emulatorn och exponerar:

    • Port 8080: gRPC-slutpunkten för Durable Task Scheduler (används av din Functions-app)
    • Port 8082: Den administrativa kontrollpanelen

  3. Instrumentpanelen kommer att vara tillgänglig på http://localhost:8082.

Håll det här terminalfönstret öppet medan du utvecklar och testar din varaktiga agent.

Tips/Råd

Mer information om DTS-emulatorn, inklusive hur du konfigurerar flera aktivitetshubbar och får åtkomst till instrumentpanelen, finns i Utveckla med Durable Task Scheduler.

Kör funktionsappen

Nu är du redo att köra din Azure Functions-app med den hållbara agenten.

  1. I ett nytt terminalfönster (där både Azurite och DTS-emulatorn körs i separata fönster) navigerar du till projektkatalogen.

  2. Starta Azure Functions-körningen:

    func start

  3. Du bör se utdata som anger att funktionsappen körs, inklusive HTTP-slutpunkterna för din agent:

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

Dessa slutpunkter hanterar konversationstillstånd automatiskt – du behöver inte skapa eller hantera trådobjekt själv.

Testa agenten lokalt

Nu kan du interagera med din varaktiga agent med hjälp av HTTP-begäranden. Agenten upprätthåller konversationstillstånd för flera begäranden, vilket möjliggör konversationer med flera turer.

Starta en ny konversation

Skapa en ny tråd och skicka ditt första meddelande:

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

Exempelsvar (observera att x-ms-thread-id rubriken innehåller tråd-ID:t):

HTTP/1.1 200 OK
Content-Type: text/plain
x-ms-thread-id: @dafx-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.

Spara tråd-ID:t från x-ms-thread-id rubriken (t.ex. @dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d) för nästa begäran.

Fortsätt konversationen

Skicka ett uppföljningsmeddelande till samma tråd genom att inkludera tråd-ID:t som en frågeparameter:

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

Ersätt @dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d med det faktiska tråd-ID:t från föregående svarsrubrik x-ms-thread-id .

Exempelsvar:

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.

Observera att agenten kommer ihåg kontexten från föregående meddelande (de tre programmeringsspråken) utan att du behöver ange dem igen. Eftersom konversationstillståndet lagras korrekt av Durable Task Scheduler bevaras den här historiken även om du startar om funktionsappen eller om konversationen återupptas av en annan instans.

Övervaka med kontrollpanelen för Durable Task Scheduler

Durable Task Scheduler innehåller en inbyggd instrumentpanel för övervakning och felsökning av dina varaktiga agenter. Instrumentpanelen ger djup insyn i agentåtgärder, konversationshistorik och exekveringsflöde.

Få åtkomst till instrumentpanelen

  1. Öppna instrumentpanelen för din lokala DTS-emulator i http://localhost:8082 webbläsaren.

  2. Välj standardaktivitetshubben i listan för att visa dess detaljer.

  3. Välj kugghjulsikonen i det övre högra hörnet för att öppna inställningarna och se till att alternativet Aktivera agentsidor under Förhandsversionsfunktioner är markerat.

Utforska agentkonversationer

  1. Gå till fliken Agenter på instrumentpanelen.

  2. Välj din durable agent-tråd (t.ex. mydurableagent - 263fa373-fa01-4705-abf2-5a114c2bb87d) i listan.

    Du ser en detaljerad vy över agenttråden, inklusive den fullständiga konversationshistoriken med alla meddelanden och svar.

    Skärmbild av instrumentpanelen Durable Task Scheduler som visar en agenttråds konversationshistorik.

Instrumentpanelen innehåller en tidslinjevy som hjälper dig att förstå konversationsflödet. Viktig information är:

  • Tidsstämplar och varaktighet för varje interaktion
  • Meddelande- och svarsinnehåll
  • Antal token som används

Tips/Råd

DTS-instrumentpanelen innehåller realtidsuppdateringar så att du kan se agentens beteende när du interagerar med den via HTTP-slutpunkterna.

Distribuera till Azure

Nu när du har testat din varaktiga agent lokalt distribuerar du den till Azure.

  1. Distribuera programmet:

    azd deploy

    Det här kommandot paketerar ditt program och distribuerar det till Azure Functions-appen som skapades under etableringen.

  2. Vänta tills distributionen har slutförts. Utdata bekräftar när agenten körs i Azure.

Testa den distribuerade agenten

Testa din agent som körs i Azure efter distributionen.

Hämta funktionsnyckeln

Azure Functions kräver en API-nyckel för HTTP-utlösta funktioner i produktion:

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`

Starta en ny konversation i Azure

Skapa en ny tråd och skicka ditt första meddelande till den distribuerade agenten:

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?"

Observera tråd-ID:t som returneras i svarshuvudet x-ms-thread-id .

Fortsätt konversationen i Azure

Skicka ett uppföljningsmeddelande i samma tråd. Ersätt <thread-id> med tråd-ID:t från föregående svar:

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

Agenten upprätthåller konversationskontexten i Azure precis som den gjorde lokalt, vilket visar agenttillståndets hållbarhet.

Övervaka den distribuerade agenten

Du kan övervaka din driftsatta agent via instrumentpanelen Durable Task Scheduler i Azure.

  1. Hämta namnet på din Durable Task Scheduler-instans:

    azd env get-value DTS_NAME

  2. Öppna Azure-portalen och sök efter namnet på Durable Task Scheduler från föregående steg.

  3. På översiktspanelen för resursen Durable Task Scheduler väljer du default-aktivitetshuben från listan.

  4. Välj Öppna instrumentpanel överst på sidan för aktivitetshubben för att öppna instrumentpanelen för övervakning.

  5. Visa agentens konversationer precis som du gjorde med den lokala emulatorn.

Instrumentpanelen i Azure innehåller samma felsöknings- och övervakningsfunktioner som den lokala emulatorn, så att du kan granska konversationshistorik, spåra verktygsanrop och analysera prestanda i produktionsmiljön.

Självstudie: Orkestrera varaktiga agenter

Den här självstudien visar hur du orkestrera flera hållbara AI-agenter med hjälp av fan-out/fan-in-mönstret. Du utökar den varaktiga agenten från föregående självstudiekurs för att skapa ett system med flera agenter som bearbetar en användares fråga och sedan översätter svaret till flera språk samtidigt.

Förstå orkestreringsmönstret

Orkestreringen som du skapar följer det här flödet:

  1. Användarindata – en fråga eller ett meddelande från användaren
  2. Huvudagent – Den MyDurableAgent från den första självstudiekursen bearbetar frågan
  3. "Fan-out" – huvudagentens svar skickas samtidigt till båda översättningsagenterna
  4. Översättningsagenter – Två specialiserade agenter översätter svaret (franska och spanska)
  5. Fan-in – Resultaten aggregeras till ett enda JSON-svar med det ursprungliga svaret och översättningarna

Det här mönstret möjliggör samtidig bearbetning, vilket minskar den totala svarstiden jämfört med sekventiell översättning.

Registrera agenter vid start

Om du vill använda agenter korrekt i varaktiga orkestreringar registrerar du dem vid programstart. De kan användas mellan orkestreringskörningar.

Uppdatera din Program.cs för att registrera översättningsagenterna tillsammans med den befintliga MyDurableAgent:

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

// 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 Azure OpenAI client
AzureOpenAIClient client = new(new Uri(endpoint), new DefaultAzureCredential());
ChatClient chatClient = client.GetChatClient(deploymentName);

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

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

AIAgent spanishAgent = chatClient.AsAIAgent(
    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();

Uppdatera din function_app.py för att registrera översättningsagenterna tillsammans med den befintliga MyDurableAgent:

import os
from azure.identity import DefaultAzureCredential
from agent_framework.azure import AzureOpenAIChatClient, AgentFunctionApp

# 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")

# Create the Azure OpenAI client
chat_client = AzureOpenAIChatClient(
    endpoint=endpoint,
    deployment_name=deployment_name,
    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])

Skapa en orkestreringsfunktion

En orkestreringsfunktion samordnar arbetsflödet mellan flera agenter. Den hämtar registrerade agenter från den varaktiga kontexten och samordnar deras körning, anropar först huvudagenten och ger sedan ut till översättningsagenter samtidigt.

Skapa en ny fil med namnet AgentOrchestration.cs i projektkatalogen:

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;
    }
}

Lägg till orkestreringsfunktionen i function_app.py filen:

import azure.durable_functions as df

@app.orchestration_trigger(context_name="context")
def agent_orchestration_workflow(context: df.DurableOrchestrationContext):
    """
    Orchestration function that coordinates multiple agents.
    Returns a dictionary with the original response and translations.
    """
    input_text = context.get_input()

    # 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 context.task_all(parallel_tasks) # type: ignore

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

    return result

Testa orkestreringen

Se till att dina lokala utvecklingsberoenden från den första självstudien fortfarande körs:

  • Azurite i ett terminalfönster
  • Durable Task Scheduler-emulator i ett annat terminalfönster

Med dina lokala utvecklingsberoenden igång:

  1. Starta din Azure Functions-app i ett nytt terminalfönster:

    func start

  2. Durable Functions-tillägget skapar automatiskt inbyggda HTTP-slutpunkter för hantering av orkestreringar. Starta orkestreringen med hjälp av det inbyggda API:et:

    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. Svaret innehåller URL:er för att hantera orkestreringsinstansen:

    {
  "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. Använd statusQueryGetUri för att fråga om orkestreringens status (ersätt abc123def456 med ditt faktiska instans-ID):

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

  1. Avsök statusslutpunkten tills runtimeStatus den är Completed. När processen är klar kommer du att se ett samordningsresultat med huvudagentens svar och dess översättningar:

    {
  "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..."
  }
}

Övervaka orkestreringen på instrumentpanelen

Dashboarden Durable Task Scheduler ger en översikt över din orkestrering:

  1. Öppna http://localhost:8082 i webbläsaren.

  2. Välj aktivitetshubben "standard".

  3. Välj fliken Orkestrering.

  4. Hitta orkestreringsinstansen i listan.

  5. Välj den instans som ska visas:

    • Tidslinjen för orkestrering
    • Huvudagentutförande som följs av samtidiga översättningsagenter
    • Varje agentkörning (MyDurableAgent; sedan franska och spanska översättarna)
    • Fan-out och fan-in mönster visualiserade
    • Tidsinställning och varaktighet för varje steg

Distribuera orkestreringen till Azure

Distribuera det uppdaterade programmet med Hjälp av Azure Developer CLI:

azd deploy

Detta distribuerar din uppdaterade kod med den nya orkestreringsfunktionen och ytterligare agenter till appen Azure Functions som skapades i den första handledningen.

Testa den distribuerade orkestreringen

Efter distributionen testar du orkestreringen som körs i Azure.

  1. Hämta systemnyckeln för det hållbara tillägget:

    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. Starta orkestreringen med hjälp av det inbyggda API:et:

    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. Använd statusQueryGetUri från svaret för att avsöka efter slutförande och visa resultaten med översättningar.

Nästa steg

OpenAI-Compatible slutpunkter

Ytterligare resurser:

  • Last updated on