Partager via

Azure Functions (durable)

L'extension de tâche durable pour le Microsoft Agent Framework vous permet de créer des agents d'intelligence artificielle avec état, ainsi que des orchestrations déterministes multi-agents dans un environnement sans serveur sur Azure.

Azure Functions est un service de calcul serverless qui vous permet d’exécuter du code à la demande sans gérer l’infrastructure. L’extension de tâche durable repose sur cette base pour fournir une gestion durable de l’état, ce qui signifie que l’historique des conversations et l’état d’exécution de votre agent sont conservés de manière fiable et survivent aux échecs, aux redémarrages et aux opérations de longue durée.

Vue d’ensemble

Les agents durables combinent la puissance d’Agent Framework avec Azure Durable Functions pour créer des agents qui :

  • Conserver l’état automatiquement entre les appels de fonction
  • Reprendre après les échecs sans perdre le contexte de conversation
  • Mettre à l’échelle automatiquement en fonction de la demande
  • Orchestrer des workflows multi-agents avec des garanties d’exécution fiables

Quand utiliser des agents durables

Choisissez des agents durables lorsque vous avez besoin des éléments suivants :

  • Contrôle de code complet : déployer et gérer votre propre environnement de calcul tout en conservant les avantages serverless
  • Orchestrations complexes : coordonner plusieurs agents avec des flux de travail déterministes et fiables qui peuvent s’exécuter pendant des jours ou des semaines
  • Orchestration pilotée par les événements : intégrer des déclencheurs Azure Functions (HTTP, minuteurs, files d’attente, etc.) et des liaisons pour les flux de travail d’agent pilotés par les événements
  • État de conversation automatique : l’historique des conversations de l’agent est automatiquement géré et conservé sans nécessiter de gestion d’état explicite dans votre code

Cette approche d’hébergement serverless diffère de l’hébergement d’agent basé sur un service managé (tel qu’Azure AI Foundry Agent Service), qui fournit une infrastructure entièrement managée sans que vous deviez déployer ou gérer des applications Azure Functions. Les agents durables sont idéaux lorsque vous avez besoin de la flexibilité d'un déploiement orienté code combinée à la fiabilité de la gestion durable de l'état.

Lorsqu’ils sont hébergés dans le plan d’hébergement Flex Consumption d’Azure Functions , les agents peuvent effectuer une mise à l’échelle vers des milliers d’instances ou à zéro quand ils ne sont pas utilisés, ce qui vous permet de payer uniquement pour le calcul dont vous avez besoin.

Mise en route

Dans un projet Azure Functions .NET, ajoutez les packages NuGet requis.

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

Note

En plus de ces packages, vérifiez que votre projet utilise la version 2.2.0 ou ultérieure du package Microsoft.Azure.Functions.Worker .

Dans un projet Python Azure Functions, installez les packages Python requis.

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

Hébergement sans serveur

Avec l’extension de tâche durable, vous pouvez déployer et héberger des agents Microsoft Agent Framework dans Azure Functions avec des points de terminaison HTTP intégrés et un appel basé sur l’orchestration. Azure Functions fournit une tarification basée sur les événements et un paiement par appel avec une mise à l’échelle automatique et une gestion minimale de l’infrastructure.

Lorsque vous configurez un agent durable, l’extension de tâche durable crée automatiquement des points de terminaison HTTP pour votre agent et gère toutes les infrastructures sous-jacentes pour stocker l’état de conversation, gérer les requêtes simultanées et coordonner les workflows multi-agents.

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

Threads d’agent avec état avec historique des conversations

Les agents gèrent des threads persistants qui survivent entre plusieurs interactions. Chaque thread est identifié par un ID de thread unique et stocke l’historique complet des conversations dans le stockage durable géré par le planificateur de tâches durables.

Ce modèle permet la continuité conversationnelle dans laquelle l’état de l’agent est conservé par le biais de blocages et de redémarrages de processus, ce qui permet de conserver l’historique complet des conversations entre les threads utilisateur. Le stockage durable garantit que même si votre instance Azure Functions redémarre ou se met à l’échelle vers une autre instance, la conversation continue en toute transparence à partir de l’endroit où elle s’est arrêtée.

L’exemple suivant illustre plusieurs requêtes HTTP vers le même thread, montrant comment le contexte de conversation persiste :

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

L’état de l’agent est conservé dans un stockage durable, ce qui permet l’exécution distribuée sur plusieurs instances. Toute instance peut reprendre l’exécution d’un agent après des interruptions ou des échecs, ce qui garantit une opération continue.

Orchestrations multi-agents déterministes

L’extension de tâche durable prend en charge la création de flux de travail déterministes qui coordonnent plusieurs agents à l’aide d’orchestrations Azure Durable Functions .

Les orchestrations sont des workflows basés sur du code qui coordonnent plusieurs opérations (comme les appels d’agent, les appels d’API externes ou les minuteurs) de manière fiable. Déterministe signifie que le code d’orchestration s’exécute de la même façon lors de la relecture après un échec, ce qui rend les flux de travail fiables et déboguables, lorsque vous relisez l’historique d’une orchestration, vous pouvez voir exactement ce qui s’est passé à chaque étape.

Les orchestrations s’exécutent de manière fiable, en résistant aux pannes entre les appels d’agent, et fournissent des processus prévisibles et reproductibles. Cela les rend idéales pour les scénarios multi-agents complexes où vous avez besoin d’un ordre d’exécution garanti et d’une tolérance de panne.

Orchestrations séquentielles

Dans le modèle multi-agent séquentiel, les agents spécialisés s’exécutent dans un ordre spécifique, où la sortie de chaque agent peut influencer l’exécution de l’agent suivant. Ce modèle prend en charge la logique conditionnelle et le branchement en fonction des réponses de l’agent.

Lorsque vous utilisez des agents dans des orchestrations, vous devez utiliser l’API context.GetAgent() pour obtenir une DurableAIAgent instance, qui est une sous-classe spéciale du type standard AIAgent qui encapsule l’un de vos agents inscrits. Le DurableAIAgent wrapper garantit que les appels d'agent sont correctement suivis et enregistrés par le cadre d'orchestration durable.

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

Lorsque vous utilisez des agents dans des orchestrations, vous devez utiliser la app.get_agent() méthode pour obtenir une instance d’agent durable, qui est un wrapper spécial autour de l’un de vos agents inscrits. Le wrapper d’agent durable garantit que les appels d’agent sont correctement suivis et mis en point de contrôle par le cadre d’orchestration durable.

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

Les orchestrations coordonnent le travail entre plusieurs agents, tout en résistant aux défaillances survenant entre les appels d'agent. Le contexte d’orchestration fournit des méthodes permettant de récupérer et d’interagir avec des agents hébergés dans des orchestrations.

Orchestrations parallèles

Dans le modèle multi-agent parallèle, vous exécutez plusieurs agents simultanément, puis agrègez leurs résultats. Ce modèle est utile pour collecter simultanément diverses perspectives ou traiter des tâches subordonnées indépendantes.

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

L’exécution parallèle est suivie à l’aide d’une liste de tâches. La sauvegarde automatique garantit que les tâches d'agent complétées ne sont ni répétées ni perdues en cas de défaillance pendant l'agrégation.

Orchestrations human-in-the-loop

Les orchestrations d’agents déterministes peuvent suspendre l’entrée humaine, l’approbation ou la révision sans consommer de ressources de calcul. L’exécution durable permet aux orchestrations d’attendre des jours ou même des semaines en attendant des réponses humaines. Lorsqu'elles sont combinées avec l'hébergement sans serveur, toutes les ressources de calcul sont désactivées pendant la période d'attente, éliminant ainsi les coûts de calcul jusqu'à ce qu'une intervention humaine soit fournie.

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

Les orchestrations d’agents déterministes peuvent attendre des événements externes tout en persistant dans leur état, en attendant un retour humain, et en survivant à des échecs, des redémarrages et des périodes d’attente prolongées. Lorsque la réponse humaine arrive, l’orchestration reprend automatiquement avec un contexte de conversation complet et un état d’exécution intacts.

Fournir une entrée humaine

Pour envoyer une approbation ou une entrée à une orchestration en attente, déclenchez un événement externe à l’instance d’orchestration à l’aide du Kit de développement logiciel (SDK) client Durable Functions. Par exemple, un réviseur peut approuver du contenu via un formulaire web qui appelle :

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)

Rentabilité

Les workflows intégrant l'humain dans la boucle avec des agents durables sont extrêmement rentables lorsqu’ils sont hébergés sur le plan de consommation Flex d’Azure Functions. Pour un flux de travail en attente de 24 heures d’approbation, vous payez seulement quelques secondes de temps d’exécution (le temps de génération de contenu, d’envoi de notification et de traitement de la réponse) et non les 24 heures d’attente. Pendant la période d’attente, aucune ressource de calcul n’est consommée.

Observabilité avec planificateur de tâches durables

Le planificateur de tâches durables (DTS) est le back-end durable recommandé pour vos agents durables, offrant les meilleures performances, l’infrastructure entièrement managée et l’observabilité intégrée via un tableau de bord d’interface utilisateur. Bien qu’Azure Functions puisse utiliser d’autres back-ends de stockage (comme stockage Azure), DTS est optimisé spécifiquement pour les charges de travail durables et offre des fonctionnalités de supervision et de performances supérieures.

Insights de session de l’agent

  • Historique des conversations : afficher l’historique complet des conversations pour chaque session d’agent, y compris tous les messages, les appels d’outils et le contexte de conversation à tout moment
  • Minutage des tâches : surveiller combien de temps les tâches et les interactions spécifiques des agents prennent pour s'accomplir

Capture d’écran du tableau de bord Durable Task Scheduler montrant l’historique des conversations de l’agent avec des threads de conversation et des messages.

Insights sur l’orchestration

  • Visualisation multi-agent : voir le flux d’exécution lors de l’appel de plusieurs agents spécialisés avec une représentation visuelle des exécutions parallèles et des branchements conditionnels
  • Historique d’exécution : Accéder aux journaux d’exécution détaillés
  • Surveillance en temps réel : suivre les orchestrations actives, les éléments de travail mis en file d’attente et les états de l’agent dans votre déploiement
  • Métriques de performances : Surveiller les temps de réponse de l’agent, l’utilisation des jetons et la durée d’orchestration

Capture d’écran du tableau de bord Durable Task Scheduler montrant la visualisation de l’orchestration avec plusieurs interactions entre agents et l'exécution du flux de travail.

Fonctionnalités de débogage

  • Afficher les sorties structurées de l’agent et les résultats des appels d’outil
  • Appels des outils de suivi et leurs résultats
  • Surveiller la gestion des événements externes pour les scénarios human-in-the-loop

Le tableau de bord vous permet de comprendre exactement ce que font vos agents, de diagnostiquer rapidement les problèmes et d’optimiser les performances en fonction des données d’exécution réelles.

Tutoriel : Créer et exécuter un agent durable

Ce tutoriel vous montre comment créer et exécuter un agent IA durable à l’aide de l’extension de tâche durable pour Microsoft Agent Framework. Vous allez créer une application Azure Functions qui héberge un agent avec état avec des points de terminaison HTTP intégrés et découvrir comment la surveiller à l’aide du tableau de bord Planificateur de tâches durables.

Prerequisites

Avant de commencer, vérifiez que vous disposez des conditions préalables suivantes :

Note

Microsoft Agent Framework est pris en charge avec toutes les versions activement prises en charge de .NET. Pour les besoins de cet exemple, nous vous recommandons le Kit de développement logiciel (SDK) .NET 9 ou une version ultérieure.

Télécharger le projet de démarrage rapide

Utilisez Azure Developer CLI pour initialiser un nouveau projet à partir du modèle de démarrage rapide des agents durables.

  1. Créez un répertoire pour votre projet et accédez-y :

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Initialisez le projet à partir du modèle :

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

    Lorsque vous y êtes invité à entrer un nom d’environnement, entrez un nom tel que my-durable-agent.

Cela télécharge le projet de démarrage rapide avec tous les fichiers nécessaires, notamment la configuration d’Azure Functions, le code de l’agent et l’infrastructure en tant que modèles de code.

  1. Créez un répertoire pour votre projet et accédez-y :

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Initialisez le projet à partir du modèle :

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

    Lorsque vous y êtes invité à entrer un nom d’environnement, entrez un nom tel que my-durable-agent.

  2. Créez et activez un environnement virtuel :

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

  1. Installez les packages nécessaires :

    python -m pip install -r requirements.txt

Cela télécharge le projet de démarrage rapide avec tous les fichiers nécessaires, notamment la configuration d’Azure Functions, le code de l’agent et l’infrastructure en tant que modèles de code. Il prépare également un environnement virtuel avec les dépendances requises.

Approvisionner des ressources Azure

Utilisez Azure Developer CLI pour créer les ressources Azure requises pour votre agent durable.

  1. Provisionnez l’infrastructure :

    azd provision

    Cette commande crée :

    • Un service Azure OpenAI avec un déploiement gpt-4o-mini
    • Une application Azure Functions avec plan d’hébergement Flex Consumption
    • Un compte de stockage Azure pour le runtime Azure Functions et un stockage durable
    • Instance du planificateur de tâches durable (plan consommation) pour la gestion de l’état de l’agent
    • Configurations de mise en réseau et d’identité nécessaires

  2. Lorsque vous y êtes invité, sélectionnez votre abonnement Azure et choisissez un emplacement pour les ressources.

Le processus d’approvisionnement prend quelques minutes. Une fois terminé, azd stocke les informations de ressource créées dans votre environnement.

Passer en revue le code de l’agent

Examinons maintenant le code qui définit votre agent durable.

Ouvrez Program.cs pour afficher la configuration de l’agent :

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

Ce code :

  1. Récupère votre configuration Azure OpenAI à partir de variables d’environnement.
  2. Crée un client Azure OpenAI à l’aide des informations d’identification Azure.
  3. Crée un agent IA avec des instructions et un nom.
  4. Configure l’application Azure Functions pour héberger l’agent avec une gestion durable des threads.

Ouvrez function_app.py pour afficher la configuration de l’agent :

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

Ce code :

  • Récupère votre configuration Azure OpenAI à partir de variables d’environnement.
  • Crée un client Azure OpenAI à l’aide des informations d’identification Azure.
  • Crée un agent IA avec des instructions et un nom.
  • Configure l’application Azure Functions pour héberger l’agent avec une gestion durable des threads.

L’agent est maintenant prêt à être hébergé dans Azure Functions. L’extension de tâche durable crée automatiquement des points de terminaison HTTP pour interagir avec votre agent et gérer l’état de conversation entre plusieurs requêtes.

Configurer les paramètres locaux

Créez un local.settings.json fichier pour le développement local en fonction de l’exemple de fichier inclus dans le projet.

  1. Copiez l’exemple de fichier de paramètres :

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

  1. Obtenez votre point de terminaison Azure OpenAI à partir des ressources approvisionnées :

    azd env get-value AZURE_OPENAI_ENDPOINT

  2. Ouvrez local.settings.json et remplacez la valeur <your-resource-name> par le point de terminaison de la commande précédente.

Votre local.settings.json doit ressembler à cela :

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

Note

Le local.settings.json fichier est utilisé uniquement pour le développement local et n’est pas déployé sur Azure. Pour les déploiements de production, ces paramètres sont automatiquement configurés dans votre application Azure Functions par les modèles d’infrastructure.

Démarrer les dépendances de développement local

Pour exécuter localement des agents durables, vous devez démarrer deux services :

  • Azurite : émule les services de stockage Azure (utilisés par Azure Functions pour la gestion des déclencheurs et de l’état interne).
  • Émulateur DTS (Durable Task Scheduler) : gère l’état durable (historique des conversations, état d’orchestration) et la planification de vos agents

Démarrer Azurite

Azurite émule localement les services stockage Azure. Azure Functions l’utilise pour gérer l’état interne. Vous devez l’exécuter dans une nouvelle fenêtre de terminal et la maintenir en cours d’exécution pendant que vous développez et testez votre agent durable.

  1. Ouvrez une nouvelle fenêtre de terminal et extrayez l’image Docker Azurite :

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

  2. Démarrez Azurite dans une fenêtre de terminal :

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

    Azurite démarre et écoute sur les ports par défaut pour les services Blob (10000), File d’attente (10001) et Table (10002).

Laissez cette fenêtre de terminal ouverte pendant le développement et le test de votre agent durable.

Conseil / Astuce

Pour plus d’informations sur Azurite, notamment les autres méthodes d’installation, consultez Utiliser l’émulateur Azurite pour le développement de stockage Azure local.

Démarrer l’émulateur du planificateur de tâches durables

L'émulateur DTS fournit une infrastructure pérenne pour la gestion de l'état des agents et des orchestrations. Il stocke l’historique des conversations et garantit que l’état de votre agent persiste entre les redémarrages. Il déclenche également des orchestrations et des agents durables. Vous devez l’exécuter dans une nouvelle fenêtre de terminal distincte et la maintenir en cours d’exécution pendant que vous développez et testez votre agent durable.

  1. Ouvrez une autre nouvelle fenêtre de terminal et extrayez l’image Docker de l’émulateur DTS :

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

  2. Exécutez l’émulateur DTS :

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

    Cette commande démarre l’émulateur et expose :

    • Port 8080 : point de terminaison gRPC pour le planificateur de tâches durables (utilisé par votre application Functions)
    • Port 8082 : Tableau de bord administratif

  3. Le tableau de bord sera disponible à l’adresse http://localhost:8082.

Laissez cette fenêtre de terminal ouverte pendant le développement et le test de votre agent durable.

Conseil / Astuce

Pour en savoir plus sur l’émulateur DTS, notamment sur la configuration de plusieurs hubs de tâches et l’accès au tableau de bord, consultez Développer avec Durable Task Scheduler.

Exécuter l'application de fonctions

Vous êtes maintenant prêt à exécuter votre application Azure Functions avec l’agent durable.

  1. Dans une nouvelle fenêtre de terminal (en conservant Azurite et l’émulateur DTS s’exécutant dans des fenêtres distinctes), accédez à votre répertoire de projet.

  2. Démarrez le runtime Azure Functions :

    func start

  3. Vous devez voir la sortie indiquant que votre application de fonction est en cours d’exécution, y compris les points de terminaison HTTP de votre agent :

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

Ces points de terminaison gèrent automatiquement l’état de conversation : vous n’avez pas besoin de créer ou de gérer vous-même des objets de thread.

Tester l’agent localement

Vous pouvez maintenant interagir avec votre agent durable à l’aide de requêtes HTTP. L'agent maintient l'état de la conversation entre plusieurs requêtes, permettant des conversations multitours.

Commence une nouvelle conversation.

Créez un thread et envoyez votre premier message :

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

Exemple de réponse (notez que l’en-tête x-ms-thread-id contient l’ID de thread) :

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.

Enregistrez l’ID de thread à partir de l’en-tête x-ms-thread-id (par exemple, @dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d) pour la requête suivante.

Continuer la conversation

Envoyez un message de suivi au même thread en incluant l’ID de thread comme paramètre de requête :

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

Remplacez @dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d par l’ID de thread réel de l’en-tête de x-ms-thread-id la réponse précédente.

Exemple de réponse :

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.

Notez que l’agent mémorise le contexte du message précédent (les trois langages de programmation) sans avoir à les spécifier à nouveau. Étant donné que l’état de la conversation est stocké durablement par le planificateur de tâches durables, cet historique persiste même si vous redémarrez l’application de fonction ou si la conversation est reprise par une autre instance.

Superviser via le tableau de bord Durable Task Scheduler

Le planificateur de tâches durables fournit un tableau de bord intégré pour la surveillance et le débogage de vos agents durables. Le tableau de bord offre une visibilité approfondie des opérations de l’agent, de l’historique des conversations et du flux d’exécution.

Accéder au tableau de bord

  1. Ouvrez le tableau de bord de votre émulateur http://localhost:8082 DTS local dans votre navigateur web.

  2. Sélectionnez le hub de tâches par défaut dans la liste pour afficher ses détails.

  3. Sélectionnez l’icône d’engrenage dans le coin supérieur droit pour ouvrir les paramètres, puis vérifiez que l’option Activer les pages Agent sous Fonctionnalités d’aperçu est sélectionnée.

Explorer les conversations de l’agent

  1. Dans le tableau de bord, accédez à l’onglet Agents .

  2. Sélectionnez votre thread d’agent durable (par exemple, mydurableagent - 263fa373-fa01-4705-abf2-5a114c2bb87d) dans la liste.

    Vous verrez une vue détaillée du thread de l’agent, y compris l’historique complet des conversations avec tous les messages et réponses.

    Capture d’écran du tableau de bord Durable Task Scheduler montrant l’historique des conversations d’un thread d’agent.

Le tableau de bord fournit une vue de chronologie pour vous aider à comprendre le flux de la conversation. Les informations clés sont les suivantes :

  • Horodatages et durée de chaque interaction
  • Contenu de message et de réponse
  • Nombre de jetons utilisés

Conseil / Astuce

Le tableau de bord DTS fournit des mises à jour en temps réel. Vous pouvez donc observer le comportement de votre agent lorsque vous interagissez avec lui via les points de terminaison HTTP.

Déployer sur Azure

Maintenant que vous avez testé votre agent durable localement, déployez-le sur Azure.

  1. Déployez l’application :

    azd deploy

    Cette commande empaquette votre application et la déploie sur l’application Azure Functions créée lors de l’approvisionnement.

  2. Attendez que le déploiement se termine. Le résultat confirmera le fonctionnement de votre agent dans Azure.

Tester l’agent déployé

Après le déploiement, testez votre agent s’exécutant dans Azure.

Obtenir la clé de fonction

Azure Functions nécessite une clé API pour les fonctions déclenchées par HTTP en production :

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`

Démarrer une nouvelle conversation dans Azure

Créez un thread et envoyez votre premier message à l’agent déployé :

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

Notez l'ID de thread retourné dans l'en-tête de réponse x-ms-thread-id.

Poursuivre la conversation dans Azure

Envoyez un message de suivi dans le même thread. Remplacez <thread-id> par l’ID de thread de la réponse précédente :

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

L'agent gère le contexte de la conversation dans Azure tout comme localement, démontrant ainsi la persistance de l'état de l'agent.

Surveiller l’agent déployé

Vous pouvez surveiller votre agent déployé à l’aide du tableau de bord Planificateur de tâches durable dans Azure.

  1. Obtenez le nom de votre instance Durable Task Scheduler :

    azd env get-value DTS_NAME

  2. Ouvrez le portail Azure et recherchez le nom du planificateur de tâches durables à l’étape précédente.

  3. Dans le panneau vue d’ensemble de la ressource Planificateur de tâches durables, sélectionnez le hub de tâches par défaut dans la liste.

  4. Sélectionnez Ouvrir le tableau de bord en haut de la page du hub de tâches pour ouvrir le tableau de bord de surveillance.

  5. Affichez les conversations de votre agent comme vous l’avez fait avec l’émulateur local.

Le tableau de bord hébergé par Azure fournit les mêmes fonctionnalités de débogage et de surveillance que l’émulateur local, ce qui vous permet d’inspecter l’historique des conversations, d’appeler des outils de suivi et d’analyser les performances dans votre environnement de production.

Tutoriel : Orchestrer des agents durables

Ce tutoriel vous montre comment orchestrer plusieurs agents IA durables à l’aide du modèle fan-out/fan-in. Vous allez étendre l’agent durable à partir du tutoriel précédent pour créer un système multi-agent qui traite la question d’un utilisateur, puis traduit la réponse en plusieurs langues simultanément.

Présentation du modèle d’orchestration

L’orchestration que vous allez construire suit ce flux :

  1. Entrée de l’utilisateur : question ou message de l’utilisateur
  2. Agent principal - Le MyDurableAgent du premier tutoriel traite la question
  3. Fan-out - La réponse de l’agent principal est envoyée simultanément aux deux agents de traduction
  4. Agents de traduction - Deux agents spécialisés traduisent la réponse (français et espagnol)
  5. Fan-in - Les résultats sont rassemblés en une seule réponse JSON avec la réponse d’origine et les traductions

Ce modèle permet le traitement simultané, ce qui réduit le temps de réponse total par rapport à la traduction séquentielle.

Inscrire des agents au démarrage

Pour utiliser correctement les agents dans des orchestrations durables, inscrivez-les au démarrage de l’application. Elles peuvent être utilisées dans les exécutions d’orchestration.

Mettez à jour votre Program.cs pour enregistrer les agents de traduction en même temps que les MyDurableAgent existants.

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

Mettez à jour votre function_app.py pour enregistrer les agents de traduction en même temps que les MyDurableAgent existants.

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

Créer une fonction d’orchestration

Une fonction d’orchestration coordonne le flux de travail sur plusieurs agents. Il récupère les agents enregistrés à partir du contexte durable et orchestre leur exécution, en appelant d'abord l'agent principal, puis en déployant les agents de traduction simultanément.

Créez un fichier nommé AgentOrchestration.cs dans le répertoire de votre projet :

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

Ajoutez la fonction d’orchestration à votre function_app.py fichier :

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

Tester l’orchestration

Assurez-vous que vos dépendances de développement locales du premier tutoriel fonctionnent toujours :

  • Azurite dans une fenêtre de terminal
  • Émulateur Durable Task Scheduler dans une autre fenêtre de terminal

Avec vos dépendances de développement locales actives :

  1. Démarrez votre application Azure Functions dans une nouvelle fenêtre de terminal :

    func start

  2. L’extension Durable Functions crée automatiquement des points de terminaison HTTP intégrés pour la gestion des orchestrations. Démarrez l’orchestration à l’aide de l’API intégrée :

    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. La réponse inclut des URL pour la gestion de l’instance d’orchestration :

    {
  "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. Interrogez l'état de l’orchestration à l'aide de statusQueryGetUri (remplacez abc123def456 par votre ID d'instance réel) :

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

  1. Interrogez le point de terminaison de statut jusqu’à ce que runtimeStatus soit Completed. Une fois terminé, vous verrez le résultat de l'orchestration avec la réponse de l'agent principal et ses traductions.

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

Surveiller l’orchestration dans le tableau de bord

Le tableau de bord Du planificateur de tâches durables offre une visibilité sur votre orchestration :

  1. Ouvrez http://localhost:8082 dans votre navigateur.

  2. Sélectionnez le hub de tâches « par défaut ».

  3. Sélectionnez l’onglet « Orchestrations ».

  4. Recherchez votre instance d’orchestration dans la liste.

  5. Sélectionnez l’instance à afficher :

    • Chronologie de l’orchestration
    • Exécution principale de l’agent suivie d’agents de traduction simultanés
    • Chaque exécution de l’agent (MyDurableAgent, puis traducteurs français et espagnols)
    • Modèles fan-out et fan-in visualisés
    • Chronométrage et durée de chaque étape

Déployer l’orchestration sur Azure

Déployez l’application mise à jour à l’aide d’Azure Developer CLI :

azd deploy

Cela déploie votre code mis à jour avec la nouvelle fonction d’orchestration et des agents supplémentaires dans l’application Azure Functions créée dans le premier tutoriel.

Tester l’orchestration déployée

Après le déploiement, testez votre orchestration s’exécutant dans Azure.

  1. Obtenez la clé système pour l’extension durable :

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

  1. Démarrez l’orchestration à l’aide de l’API intégrée :

    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. Utilisez le statusQueryGetUri de la réponse pour sonder l'achèvement et afficher les résultats avec des traductions.

Prochaines étapes

points de terminaisonOpenAI-Compatible

Ressources supplémentaires :

  • Last updated on