Bagikan melalui

Azure Functions (Tahan Lama)

Ekstensi tugas tahan lama untuk Microsoft Agent Framework memungkinkan Anda membangun agen AI stateful dan orkestrasi deterministik multi-agen di lingkungan tanpa server di Azure.

Azure Functions adalah layanan komputasi tanpa server yang memungkinkan Anda menjalankan kode sesuai permintaan tanpa mengelola infrastruktur. Ekstensi tugas tahan lama dibangun di atas fondasi ini untuk menyediakan manajemen status yang tahan lama, yang berarti riwayat percakapan dan status eksekusi agen Anda bertahan dan bertahan dari kegagalan, menghidupkan ulang, dan operasi yang berjalan lama.

Gambaran Umum

Agen tahan lama menggabungkan kekuatan Agent Framework dengan Azure Durable Functions untuk membuat agen yang:

  • Mempertahankan status secara otomatis di seluruh pemanggilan fungsi
  • Lanjutkan setelah kegagalan tanpa kehilangan konteks percakapan
  • Menskalakan secara otomatis berdasarkan permintaan
  • Mengatur alur kerja multi-agen dengan jaminan eksekusi yang andal

Kapan menggunakan agen tahan lama

Pilih agen tahan lama saat Anda membutuhkan:

  • Kontrol kode penuh: Menyebarkan dan mengelola lingkungan komputasi Anda sendiri sambil mempertahankan manfaat tanpa server
  • Orkestrasi kompleks: Mengoordinasikan beberapa agen dengan alur kerja deterministik dan andal yang dapat berjalan selama ber hari atau minggu
  • Orkestrasi berbasis peristiwa: Integrasikan dengan pemicu Azure Functions (HTTP, timer, antrean, dll.) dan pengikatan untuk alur kerja agen berbasis peristiwa
  • Status percakapan otomatis: Riwayat percakapan agen dikelola dan dipertahankan secara otomatis tanpa memerlukan penanganan status eksplisit dalam kode Anda

Pendekatan hosting tanpa server ini berbeda dari hosting agen berbasis layanan terkelola (seperti Azure AI Foundry Agent Service), yang menyediakan infrastruktur yang dikelola sepenuhnya tanpa mengharuskan Anda untuk menyebarkan atau mengelola aplikasi Azure Functions. Agen tahan lama sangat ideal ketika Anda membutuhkan fleksibilitas penyebaran code-first yang dikombinasikan dengan keandalan manajemen status yang tahan lama.

Saat dihosting dalam paket hosting Konsumsi Azure Functions Flex , agen dapat menskalakan ke ribuan instans atau ke nol instans saat tidak digunakan, memungkinkan Anda membayar hanya untuk komputasi yang Anda butuhkan.

Memulai Langkah Pertama

Dalam proyek .NET Azure Functions, tambahkan paket NuGet yang diperlukan.

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

Nota

Selain paket ini, pastikan proyek Anda menggunakan paket Microsoft.Azure.Functions.Worker versi 2.2.0 atau yang lebih baru.

Dalam proyek Python Azure Functions, instal paket Python yang diperlukan.

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

Hosting tanpa server

Dengan ekstensi tugas yang tahan lama, Anda dapat menyebarkan dan menghosting agen Microsoft Agent Framework di Azure Functions dengan titik akhir HTTP bawaan dan pemanggilan berbasis orkestrasi. Azure Functions menyediakan harga bayar per pemanggilan berbasis peristiwa dengan penskalaan otomatis dan manajemen infrastruktur minimal.

Saat Anda mengonfigurasi agen yang tahan lama, ekstensi tugas tahan lama secara otomatis membuat titik akhir HTTP untuk agen Anda dan mengelola semua infrastruktur yang mendasar untuk menyimpan status percakapan, menangani permintaan bersamaan, dan mengoordinasikan alur kerja multi-agen.

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])

Utas agen stateful dengan riwayat percakapan

Agen mempertahankan benang persisten yang bertahan selama beberapa interaksi. Setiap utas diidentifikasi oleh ID utas unik dan menyimpan riwayat percakapan lengkap dalam penyimpanan tahan lama yang dikelola oleh Durable Task Scheduler.

Pola ini memungkinkan kelangsungan percakapan di mana keadaan agen dipertahankan melalui terjadinya crash dan restart proses, sehingga mampu mempertahankan riwayat percakapan secara penuh di seluruh utas pengguna. Penyimpanan persisten memastikan bahwa meskipun instans Azure Functions Anda dimulai ulang atau diskalakan ke instans yang berbeda, percakapan dapat berlanjut dengan mulus dari titik terakhir.

Contoh berikut menunjukkan beberapa permintaan HTTP ke utas yang sama, memperlihatkan bagaimana konteks percakapan berlanjut:

# 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!

Status agen dipertahankan dalam penyimpanan tahan lama, memungkinkan eksekusi terdistribusi di beberapa instans. Instans apa pun dapat melanjutkan eksekusi agen setelah gangguan atau kegagalan, memastikan operasi berkelanjutan.

Orkestrasi multi-agen deterministik

Ekstensi tugas yang tahan lama mendukung pembuatan alur kerja deterministik yang mengoordinasikan beberapa agen dengan menggunakan orkestrasi Azure Durable Functions.

Orkestrasi adalah alur kerja berbasis kode yang mengoordinasikan beberapa operasi (seperti panggilan agen, panggilan API eksternal, atau timer) dengan cara yang dapat diandalkan. Deterministik berarti kode orkestrasi menjalankan cara yang sama ketika diputar ulang setelah kegagalan, membuat alur kerja dapat diandalkan dan dapat di-debug—saat Anda memutar ulang riwayat orkestrasi, Anda dapat melihat dengan tepat apa yang terjadi di setiap langkah.

Orkestrasi dijalankan dengan andal, bertahan terhadap kegagalan yang terjadi di antara panggilan agen, serta memberikan proses yang dapat diprediksi dan dapat diulang. Ini membuatnya ideal untuk skenario multi-agen yang kompleks di mana Anda memerlukan urutan eksekusi terjamin dan toleransi kesalahan.

Orkestrasi berurutan

Dalam pola multi-agen berurutan, agen khusus dijalankan dalam urutan tertentu, di mana setiap output agen dapat memengaruhi eksekusi agen berikutnya. Pola ini mendukung logika kondisional dan percabangan berdasarkan respons agen.

Saat menggunakan agen dalam orkestrasi, Anda harus menggunakan context.GetAgent() API untuk mendapatkan instance DurableAIAgent, yang merupakan subkelas khusus dari tipe standar AIAgent yang membungkus salah satu agen terdaftar Anda. Pembungkus DurableAIAgent memastikan agar panggilan agen dilacak dengan benar dan mendapatkan titik pemeriksaan oleh kerangka orkestrasi berdaya tahan.

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

Saat menggunakan agen dalam orkestrasi, Anda harus menggunakan metode app.get_agent() untuk mendapatkan instans agen yang tahan lama, yang merupakan pembungkus khusus yang membungkus salah satu agen terdaftar Anda. Pembungkus agen tahan lama memastikan bahwa panggilan agen dilacak dan diperiksa dengan benar oleh kerangka orkestrasi yang tangguh.

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

Orkestrasi mengoordinasikan pekerjaan di berbagai agen dan mampu bertahan dari kegagalan yang terjadi di antara panggilan agen. Konteks orkestrasi menyediakan metode untuk mengambil dan berinteraksi dengan agen terhosting dalam orkestrasi.

Orkestrasi paralel

Dalam pola multi-agen paralel, Anda menjalankan beberapa agen secara bersamaan dan kemudian menggabungkan hasilnya. Pola ini berguna untuk mengumpulkan beragam perspektif atau memproses subtugas independen secara bersamaan.

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', '')

Eksekusi paralel dilacak menggunakan daftar tugas. Titik pemeriksaan otomatis memastikan bahwa eksekusi agen yang selesai tidak diulang atau hilang jika kegagalan terjadi selama agregasi.

Orkestrasi human-in-the-loop

Orkestrasi agen deterministik dapat menjeda input, persetujuan, atau peninjauan manusia tanpa menggunakan sumber daya komputasi. Eksekusi tahan lama memungkinkan orkestrasi untuk menunggu bertahun-hari atau bahkan berminggu-minggu sambil menunggu respons manusia. Ketika dikombinasikan dengan hosting tanpa server, semua sumber daya komputasi dimatikan selama periode tunggu, menghilangkan biaya komputasi hingga ada masukan dari manusia.

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

Orkestrasi agen deterministik dapat menunggu peristiwa eksternal, secara stabil mempertahankan keadaan mereka sambil menunggu umpan balik manusia, menghadapi kegagalan, restart, dan periode menunggu yang diperpanjang. Ketika respons manusia tiba, orkestrasi secara otomatis berkelanjutan dengan konteks percakapan yang lengkap dan status eksekusi yang tetap utuh.

Memberikan input manusia

Untuk mengirim persetujuan atau input ke orkestrasi tunggu, ajukan peristiwa eksternal ke instans orkestrasi menggunakan SDK klien Durable Functions. Misalnya, peninjau mungkin menyetujui konten melalui formulir web yang memanggil:

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)

Efisiensi biaya

Alur kerja human-in-the-loop (manusia dalam lingkaran) dengan agen persisten sangat hemat biaya saat dihosting pada paket Flex Consumption Azure Functions. Untuk alur kerja yang menunggu 24 jam untuk persetujuan, Anda hanya membayar untuk beberapa detik waktu eksekusi (waktu untuk menghasilkan konten, mengirim pemberitahuan, dan memproses respons)—bukan 24 jam menunggu. Selama periode tunggu, tidak ada sumber daya komputasi yang digunakan.

Kemampuan Dapat Diamati dengan Durable Task Scheduler

Durable Task Scheduler (DTS) adalah backend tahan lama yang direkomendasikan untuk agen tahan lama Anda, menawarkan performa terbaik, infrastruktur yang dikelola sepenuhnya, dan pengamatan bawaan melalui dasbor UI. Meskipun Azure Functions dapat menggunakan backend penyimpanan lain (seperti Azure Storage), DTS dioptimalkan khusus untuk beban kerja yang tahan lama dan memberikan kemampuan performa dan pemantauan yang unggul.

Wawasan sesi agen

  • Riwayat percakapan: Menampilkan riwayat obrolan lengkap untuk setiap sesi agen, termasuk semua pesan, panggilan alat, dan konteks percakapan kapan saja
  • Waktu tugas: Memantau berapa lama waktu yang diperlukan tugas tertentu dan interaksi agen untuk diselesaikan

Cuplikan layar dasbor Durable Task Scheduler memperlihatkan riwayat obrolan agen dengan utas percakapan dan pesan.

Wawasan orkestrasi

  • Visualisasi multi-agen: Lihat alur eksekusi saat memanggil beberapa agen khusus dengan representasi visual eksekusi paralel dan pencabangan bersyarat
  • Riwayat eksekusi: Anda dapat mengakses log eksekusi yang terperinci
  • Pemantauan real-time: Melacak orkestrasi aktif, item kerja dalam antrean, dan status agen di seluruh penyebaran Anda
  • Metrik performa: Memantau waktu respons agen, penggunaan token, dan durasi orkestrasi

Cuplikan layar dasbor Durable Task Scheduler memperlihatkan visualisasi orkestrasi dengan beberapa interaksi agen dan eksekusi alur kerja.

Kemampuan penelusuran kesalahan

  • Melihat output agen terstruktur dan hasil panggilan alat
  • Melacak pemanggilan fungsi alat dan hasilnya
  • Memantau penanganan peristiwa eksternal untuk skenario Human-In-The-Loop (partisipasi manusia dalam proses)

Dasbor memungkinkan Anda memahami dengan tepat apa yang dilakukan agen Anda, mendiagnosis masalah dengan cepat, dan mengoptimalkan performa berdasarkan data eksekusi nyata.

Tutorial: Membuat dan menjalankan agen yang tahan lama

Tutorial ini menunjukkan kepada Anda cara membuat dan menjalankan agen AI yang tahan lama menggunakan ekstensi tugas tahan lama untuk Microsoft Agent Framework. Anda akan membuat aplikasi Azure Functions yang menghosting agen stateful dengan titik akhir HTTP bawaan, dan mempelajari cara memantaunya menggunakan dasbor Durable Task Scheduler.

Prasyarat

Sebelum memulai, pastikan Anda memiliki prasyarat berikut:

Nota

Microsoft Agent Framework didukung dengan semua versi .NET yang didukung secara aktif. Untuk tujuan sampel ini, kami merekomendasikan .NET 9 SDK atau versi yang lebih baru.

Unduh proyek siap-guna

Gunakan Azure Developer CLI untuk menginisialisasi proyek baru dari templat panduan memulai cepat agen durable.

  1. Buat direktori baru untuk proyek Anda dan navigasikan ke direktori tersebut:

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Inisialisasi proyek dari templat:

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

    Saat dimintai nama lingkungan, masukkan nama seperti my-durable-agent.

Ini mengunduh proyek quickstart dengan semua file yang diperlukan, termasuk konfigurasi Azure Functions, kode agen, dan template infrastruktur sebagai kode.

  1. Buat direktori baru untuk proyek Anda dan navigasikan ke direktori tersebut:

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Inisialisasi proyek dari templat:

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

    Saat dimintai nama lingkungan, masukkan nama seperti my-durable-agent.

  2. Membuat dan mengaktifkan lingkungan virtual:

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

  1. Instal paket yang diperlukan:

    python -m pip install -r requirements.txt

Ini mengunduh proyek quickstart dengan semua file yang diperlukan, termasuk konfigurasi Azure Functions, kode agen, dan template infrastruktur sebagai kode. Ini juga menyiapkan lingkungan virtual dengan dependensi yang diperlukan.

Penyediaan sumber daya Azure

Gunakan Azure Developer CLI untuk membuat sumber daya Azure yang diperlukan untuk agen tahan lama Anda.

  1. Provisikan infrastruktur:

    azd provision

    Perintah ini membuat:

    • Layanan Azure OpenAI dengan implementasi gpt-4o-mini
    • Aplikasi Azure Functions dengan skema hosting Flex Consumption
    • Akun Azure Storage untuk menjalankan Azure Functions dan penyimpanan yang berkelanjutan
    • Instans Durable Task Scheduler (Skema konsumsi) untuk mengelola status agen
    • Konfigurasi jaringan dan identitas yang diperlukan

  2. Saat diminta, pilih langganan Azure Anda dan pilih lokasi untuk sumber daya.

Proses provisi membutuhkan waktu beberapa menit. Setelah selesai, azd menyimpan informasi sumber daya yang dibuat di lingkungan Anda.

Meninjau kode agen

Sekarang mari kita periksa kode yang mendefinisikan agen tahan lama Anda.

Buka Program.cs untuk melihat konfigurasi agen:

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

kode ini:

  1. Mengambil konfigurasi Azure OpenAI Anda dari variabel lingkungan.
  2. Membuat klien Azure OpenAI menggunakan kredensial Azure.
  3. Membuat agen AI dengan instruksi dan nama.
  4. Mengonfigurasi aplikasi Azure Functions untuk menghosting agen dengan pengelolaan thread yang andal.

Buka function_app.py untuk melihat konfigurasi agen:

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])

kode ini:

  • Mengambil konfigurasi Azure OpenAI Anda dari variabel lingkungan.
  • Membuat klien Azure OpenAI menggunakan kredensial Azure.
  • Membuat agen AI dengan instruksi dan nama.
  • Mengonfigurasi aplikasi Azure Functions untuk menghosting agen dengan pengelolaan thread yang andal.

Agen sekarang siap untuk dihosting di Azure Functions. Ekstensi tugas yang tahan lama secara otomatis membuat titik akhir HTTP untuk berinteraksi dengan agen Anda dan mengelola status percakapan sepanjang beberapa permintaan.

Mengonfigurasi pengaturan lokal

Buat local.settings.json file untuk pengembangan lokal berdasarkan file sampel yang disertakan dalam proyek.

  1. Salin file pengaturan sampel:

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

  1. Dapatkan titik akhir Azure OpenAI Anda dari sumber daya yang disediakan:

    azd env get-value AZURE_OPENAI_ENDPOINT

  2. Buka local.settings.json dan ganti <your-resource-name> dalam nilai AZURE_OPENAI_ENDPOINT dengan titik akhir dari perintah sebelumnya.

Anda local.settings.json akan terlihat seperti ini:

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

Nota

File local.settings.json hanya digunakan untuk pengembangan lokal dan tidak disebarkan ke Azure. Untuk penyebaran produksi, pengaturan ini secara otomatis dikonfigurasi di aplikasi Azure Functions Anda oleh templat infrastruktur.

Memulai dependensi pengembangan lokal

Untuk menjalankan agen tahan lama secara lokal, Anda perlu memulai dua layanan:

  • Azurite: Meniru layanan Azure Storage (digunakan oleh Azure Functions untuk mengelola pemicu dan status internal).
  • Durable Task Scheduler (DTS) Emulator: Mengelola status stabil (riwayat percakapan, status orkestrasi) dan penjadwalan untuk agen-agen Anda

Mulai Azurite

Azurite mengemulasi layanan Azure Storage secara lokal. Azure Functions menggunakannya untuk mengelola status internal. Anda harus menjalankan ini di jendela terminal baru dan membuatnya tetap berjalan saat Anda mengembangkan dan menguji agen tahan lama Anda.

  1. Buka jendela terminal baru dan tarik gambar Azurite Docker:

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

  2. Mulai Azurite di jendela terminal:

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

    Azurite akan memulai dan mendengarkan port default untuk layanan Blob (10000), Antrean (10001), dan Tabel (10002).

Biarkan jendela terminal ini tetap terbuka saat Anda mengembangkan dan menguji agen tahan lama Anda.

Petunjuk / Saran

Untuk informasi selengkapnya tentang Azurite, termasuk metode penginstalan alternatif, lihat Menggunakan emulator Azurite untuk pengembangan Azure Storage lokal.

Mulai emulator Durable Task Scheduler

Emulator DTS menyediakan backend tahan lama untuk mengelola status agen dan orkestrasi. Ini menyimpan riwayat percakapan dan memastikan status agen Anda tetap ada di seluruh restart. Ini juga memicu orkestrasi dan agen yang tahan lama. Anda harus menjalankan ini di jendela terminal baru yang terpisah dan membuatnya tetap berjalan saat Anda mengembangkan dan menguji agen tahan lama Anda.

  1. Buka jendela terminal baru lainnya dan tarik gambar Docker emulator DTS:

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

  2. Jalankan emulator DTS:

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

    Perintah ini memulai emulator dan mengekspos:

    • Port 8080: Titik akhir gRPC untuk Durable Task Scheduler (digunakan oleh aplikasi Functions Anda)
    • Port 8082: Dasbor administratif

  3. Dasbor akan tersedia di http://localhost:8082.

Biarkan jendela terminal ini tetap terbuka saat Anda mengembangkan dan menguji agen tahan lama Anda.

Petunjuk / Saran

Untuk mempelajari selengkapnya tentang emulator DTS, termasuk cara mengonfigurasi beberapa hub tugas dan mengakses dasbor, lihat Mengembangkan dengan Durable Task Scheduler.

Menjalankan aplikasi fungsi

Sekarang Anda siap untuk menjalankan aplikasi Azure Functions anda dengan agen yang tahan lama.

  1. Di jendela terminal baru (menjaga emulator Azurite dan DTS berjalan di jendela terpisah), navigasikan ke direktori proyek Anda.

  2. Jalankan runtime Azure Functions:

    func start

  3. Anda akan melihat output yang menunjukkan bahwa aplikasi fungsi Anda berjalan, termasuk titik akhir HTTP untuk agen Anda:

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

Titik akhir ini mengelola status percakapan secara otomatis - Anda tidak perlu membuat atau mengelola objek utas sendiri.

Menguji agen di lingkungan lokal

Sekarang Anda dapat berinteraksi dengan agen tahan lama Anda menggunakan permintaan HTTP. Agen mempertahankan status percakapan di beberapa permintaan, memungkinkan percakapan berkelanjutan.

Memulai percakapan baru

Buat utas baru dan kirim pesan pertama Anda:

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

Contoh respons (perhatikan x-ms-thread-id header berisi ID utas):

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.

Simpan ID utas dari x-ms-thread-id header (misalnya, @dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d) untuk permintaan berikutnya.

Melanjutkan percakapan

Kirim pesan tindak lanjut ke utas yang sama dengan menyertakan ID utas sebagai parameter kueri:

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

Ganti @dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d dengan ID thread yang sebenarnya dari header respons sebelumnya x-ms-thread-id.

Contoh respons:

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.

Perhatikan bahwa agen mengingat konteks dari pesan sebelumnya (tiga bahasa pemrograman) tanpa Anda harus menentukannya lagi. Karena status percakapan disimpan dengan durably oleh Durable Task Scheduler, riwayat ini tetap ada bahkan jika Anda memulai ulang aplikasi fungsi atau percakapan dilanjutkan oleh instans yang berbeda.

Memantau dengan dasbor Durable Task Scheduler

Durable Task Scheduler menyediakan dasbor bawaan untuk memantau dan memecahkan masalah agen durabel Anda. Dasbor menawarkan visibilitas mendalam ke dalam operasi agen, riwayat percakapan, dan alur eksekusi.

Akses dasbor

  1. Buka dasbor untuk emulator DTS lokal Anda di http://localhost:8082 browser web Anda.

  2. Pilih hub tugas default dari daftar untuk menampilkan detailnya.

  3. Pilih ikon roda gigi di sudut kanan atas untuk membuka pengaturan, dan pastikan bahwa opsi Aktifkan halaman Agen di bawah Fitur Pratinjau dipilih.

Menjelajahi percakapan agen

  1. Di dasbor, navigasikan ke tab Agen .

  2. Pilih utas agen tahan lama Anda (misalnya, mydurableagent - 263fa373-fa01-4705-abf2-5a114c2bb87d) dari daftar.

    Anda akan melihat tampilan terperinci utas agen, termasuk riwayat percakapan lengkap dengan semua pesan dan respons.

    Cuplikan layar dasbor Durable Task Scheduler memperlihatkan riwayat percakapan utas agen.

Dasbor menyediakan tampilan garis waktu untuk membantu Anda memahami alur percakapan. Informasi utama meliputi:

  • Tanda waktu dan durasi untuk setiap interaksi
  • Konten perintah dan respons
  • Jumlah token yang digunakan

Petunjuk / Saran

Dasbor DTS menyediakan pembaruan real time, sehingga Anda dapat melihat perilaku agen saat berinteraksi dengannya melalui titik akhir HTTP.

Sebarkan ke Azure

Sekarang setelah Anda menguji agen tahan lama Anda secara lokal, sebarkan ke Azure.

  1. Sebarkan aplikasi:

    azd deploy

    Perintah ini mengemas aplikasi Anda dan meng-deploy-nya ke aplikasi Azure Functions yang dibuat selama proses provisi.

  2. Tunggu hingga penerapan selesai. Output akan mengonfirmasi kapan agen Anda berjalan di Azure.

Menguji agen yang terpasang

Setelah penyebaran, uji agen Anda yang berjalan di Azure.

Mendapatkan kunci fungsi

Azure Functions memerlukan kunci API untuk fungsi yang dipicu HTTP dalam produksi:

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`

Memulai percakapan baru di Azure

Buat utas baru dan kirim pesan pertama Anda ke agen yang telah di-deploy.

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

Perhatikan ID utas yang dikembalikan di x-ms-thread-id tajuk respons.

Melanjutkan percakapan di Azure

Kirim pesan tindak lanjut di utas yang sama. Ganti <thread-id> dengan ID utas dari respons sebelumnya:

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

Agen mempertahankan konteks percakapan di Azure seperti yang dilakukan secara lokal, menunjukkan durabilitas status agen.

Memantau agen yang disebarkan

Anda dapat memantau agen yang disebarkan melalui dasbor Durable Task Scheduler di Azure.

  1. Dapatkan nama instans Durable Task Scheduler Anda:

    azd env get-value DTS_NAME

  2. Buka portal Microsoft Azure dan cari nama Durable Task Scheduler dari langkah sebelumnya.

  3. Di bilah gambaran umum sumber daya Durable Task Scheduler, pilih hub tugas default dari daftar.

  4. Pilih Buka Dasbor di bagian atas halaman hub tugas untuk membuka dasbor pemantauan.

  5. Lihat percakapan agen Anda seperti yang Anda lakukan dengan emulator lokal.

Dasbor yang dihosting Azure menyediakan kemampuan penelusuran kesalahan dan pemantauan yang sama dengan emulator lokal, memungkinkan Anda memeriksa riwayat percakapan, melacak panggilan alat, dan menganalisis performa di lingkungan produksi Anda.

Tutorial: Mengatur agen tahan lama

Tutorial ini menunjukkan kepada Anda cara mengatur beberapa agen AI tahan lama menggunakan pola fan-out/fan-in. Anda akan memperluas agen tahan lama dari tutorial sebelumnya untuk membuat sistem multi-agen yang memproses pertanyaan pengguna, lalu menerjemahkan respons ke dalam beberapa bahasa secara bersamaan.

Memahami pola orkestrasi

Orkestrasi yang akan Anda buat mengikuti alur ini:

  1. Input pengguna - Pertanyaan atau pesan dari pengguna
  2. Agen utama - MyDurableAgent dari tutorial pertama yang memproses pertanyaan
  3. Fan-out - Pesan respon agen utama dikirim secara bersamaan ke kedua agen terjemahan
  4. Agen terjemahan - Dua agen khusus menerjemahkan respons (Prancis dan Spanyol)
  5. Fan-in - Hasil dikumpulkan ke dalam satu respons JSON dengan respons dan terjemahan asli

Pola ini memungkinkan pemrosesan bersamaan, mengurangi total waktu respons dibandingkan dengan terjemahan berurutan.

Mendaftarkan agen pada saat memulai

Untuk menggunakan agen dengan benar dalam orkestrasi tahan lama, daftarkan di awal aplikasi. Mereka dapat digunakan di seluruh pelaksanaan orkestrasi.

Perbarui Program.cs Anda untuk mendaftarkan agen terjemahan bersamaan dengan MyDurableAgent yang sudah ada.

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

Perbarui function_app.py Anda untuk mendaftarkan agen terjemahan bersamaan dengan MyDurableAgent yang sudah ada.

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])

Membuat fungsi orkestrasi

Fungsi orkestrasi mengoordinasikan alur kerja di beberapa agen. Ia mengambil kembali agen terdaftar dari konteks yang berkelanjutan dan mengorkestrasi eksekusi mereka, pertama-tama memanggil agen utama, kemudian menyebar ke agen terjemahan secara bersamaan.

Buat file baru bernama AgentOrchestration.cs di direktori proyek Anda:

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

Tambahkan fungsi orkestrasi ke file Anda function_app.py :

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

Menguji orkestrasi

Pastikan dependensi pengembangan lokal Anda dari tutorial pertama masih berjalan:

  • Azurite dalam satu jendela terminal
  • Emulator Durable Task Scheduler di jendela terminal lain

Dengan menjalankan dependensi pengembangan lokal Anda

  1. Mulai aplikasi Azure Functions Anda di jendela terminal baru:

    func start

  2. Ekstensi Durable Functions secara otomatis membuat titik akhir HTTP bawaan untuk mengelola orkestrasi. Mulai orkestrasi menggunakan API bawaan:

    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. Respons mencakup URL untuk mengelola instans orkestrasi:

    {
  "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. Kueri status orkestrasi menggunakan statusQueryGetUri (ganti abc123def456 dengan ID instans Anda yang sebenarnya):

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

  1. Memeriksa titik akhir status sampai runtimeStatus adalah Completed. Setelah selesai, Anda akan melihat output orkestrasi dengan respons agen utama dan terjemahannya:

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

Pantau orkestrasi di dasbor

Dasbor Durable Task Scheduler memberikan visibilitas ke dalam orkestrasi Anda:

  1. Buka http://localhost:8082 di browser Anda.

  2. Pilih hub tugas "default".

  3. Pilih tab "Orkestrasi".

  4. Temukan instans orkestrasi Anda dalam daftar.

  5. Pilih instans untuk melihat:

    • Garis waktu orkestrasi
    • Eksekusi agen utama diikuti oleh agen penerjemahan bersamaan
    • Setiap pelaksanaan agen (MyDurableAgent, serta penerjemah Prancis dan Spanyol)
    • Pola fan-out dan fan-in divisualisasikan
    • Waktu dan durasi untuk setiap langkah

Menyebarkan orkestrasi ke Azure

Sebarkan aplikasi yang diperbarui menggunakan Azure Developer CLI:

azd deploy

Ini menyebarkan kode yang diperbarui dengan fungsi orkestrasi baru dan agen tambahan ke aplikasi Azure Functions yang dibuat di tutorial pertama.

Menguji orkestrasi yang telah diterapkan

Setelah penyebaran, lakukan pengujian terhadap orkestrasi Anda yang berjalan di Azure.

  1. Dapatkan kunci sistem untuk ekstensi tahan lama:

    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. Mulai orkestrasi menggunakan API bawaan:

    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. statusQueryGetUri Gunakan dari respons ke polling untuk penyelesaian dan lihat hasilnya dengan terjemahan.

Langkah selanjutnya

Titik AkhirOpenAI-Compatible

Sumber daya tambahan:

  • Last updated on