Extension persistante

L’extension durable pour Microsoft Agent Framework apporte une exécution durable aux agents, aux orchestrations multi-agents et aux flux de travail Microsoft Agent Framework. Vous pouvez l’utiliser pour rendre persistantes les sessions de l’agent, l’orchestration des points de contrôle et la progression du flux de travail, récupérer des défaillances et mettre à l’échelle le travail sur les hôtes distribués sans modifier votre logique d’agent principale.

L’extension prend en charge deux modèles d’hébergement en C# et Python :

  • Azure Functions pour l’hébergement serverless managé avec le modèle de programmation Azure Functions.
  • Apportez votre propre calcul / auto-hébergé pour exécuter des agents et des workflows durables dans votre propre processus de travail, service, conteneur, environnement Kubernetes ou infrastructure d’application existante.

Note

Ce guide couvre l’hébergement C# et Python Extension durable. Pour l’hébergement Go, consultez l’hébergement A2A et le référentiel Agent Framework Go.

Overview

Les agents durables combinent le modèle de programmation Agent Framework avec l’infrastructure Durable Task, telle que le Planificateur de tâches durables, pour créer des agents qui :

  • Conserver l’état automatiquement entre les requêtes et les exécutions de travail
  • Reprendre après les échecs sans perdre le contexte de conversation ou répéter le travail terminé
  • Mettre à l’échelle les travailleurs distribués et sans état en fonction de la demande
  • Orchestrer des workflows multi-agents avec des garanties d’exécution fiables
  • Flux de travail Framework de l’agent de point de contrôle créés avec le modèle de flux de travail basé sur les graphiques
  • Suspendre l’entrée humaine ou les événements externes sans consommer de jetons de calcul ou de modèle en attente
  • Reprendre la livraison diffusée en continu lorsqu’elle est configurée avec un répartiteur de flux, telle que Redis ; confirmer l’achèvement durable séparément
  • Gérer le cycle de vie de session avec le nettoyage de durée de vie (TTL) de session et la surveillance basée sur le tableau de bord

Quand utiliser des agents durables

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

  • État de la conversation persistante : les sessions d’agent survivent aux incidents de processus, aux redémarrages et aux événements de montée en puissance scale-out
  • 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, des files d’attente, des webhooks, des minuteurs ou des événements d’application existants
  • É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
  • flux de travail Durable Agent Framework : rendre durables les flux de travail Microsoft Agent Framework basés sur des graphiques afin que chaque étape puisse être point de contrôle et reprise
  • Sessions de longue durée : conserver les conversations utiles disponibles lors de l’utilisation du nettoyage de durée de vie (TTL) de session pour supprimer automatiquement les sessions inactives
  • Réponses en temps réel : fournir une sortie de jeton incrémentielle avec une reconnexion basée sur le répartiteur, tout en vérifiant séparément le résultat durable

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

Choisir un modèle d’hébergement

Modèle d’hébergement Choisissez-le quand vous en avez besoin
Azure Functions Modèle d’hébergement serverless managé ; scale-out intégré et scale-to-zero ; Azure Functions déclencheurs et liaisons ; Points de terminaison HTTP générés par le modèle de programmation Functions ; déclencheur de serveur MCP ; et gestion minimale de l’infrastructure hôte.
Bring-your-own-compute / auto-hébergé Contrôlez davantage le processus hôte, l’environnement de déploiement, le cycle de vie du runtime, l’infrastructure, la mise en réseau, l’authentification ou l’intégration à une application ou un service existant. Utilisez ce modèle pour les conteneurs, Kubernetes, les workers de longue durée, les applications console, les services personnalisés ou les environnements d’hébergement non Functions.

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. Dans les scénarios auto-hébergés, vos propres contrôles hôtes contrôlent la durée de vie, la mise à l’échelle, la mise à l’échelle, la mise en réseau et le déploiement.

Premiers pas

Utilisez les commandes d’installation pour votre modèle d’hébergement ci-dessous. Conservez les options de préversion affichées pour les packages en préversion. Pour obtenir des applications complètes, consultez la source et les exemples.

La documentation sur la branche source peut décrire les fonctionnalités qui ne sont pas encore disponibles dans les packages publiés. Appliquez les étapes de configuration et de migration uniquement pour les fonctionnalités incluses dans votre version installée.

Important

Avant de mettre à niveau un déploiement existant, passez en revue le déploiement et la migration de schéma. Ne pointez pas un worker mis à niveau à l’ancienne historique des flux de travail sans vérifier la compatibilité de la relecture.

Dans un projet .NET, choisissez le package défini pour votre modèle d’hébergement.

Pour Azure Functions hébergement, ajoutez le package d’intégration Azure Functions et les packages de travail Functions.

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

Note

Utilisez l’extension Functions Worker, DurableTask Worker et les versions d’extension Worker AzureManaged déclarées par les dépendances de l’extension de l’agent. Supprimez les références de package directes qui rétrogradent ces dépendances. Consultez les références de dépendance .NET. Les mises à niveau côte à côte de schema-v2 nécessitent également un filtrage d’élément de travail ; consultez déploiement et migration de schéma.

Pour l’hébergement bring-your-own-compute, ajoutez le package d’intégration de tâche durable de base et les packages worker/client du planificateur de tâches durables utilisés par votre hôte :

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

Dans un projet Python, choisissez le package de votre modèle d’hébergement. Python hôtes nécessitent une stratégie de déploiement explicite.

Pour Azure Functions hébergement, utilisez Python 3.13 ou version ultérieure et installez le package d’intégration Azure Functions. Les commandes suivantes installent également le client Azure OpenAI utilisé dans ce guide.

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

Pour l’hébergement bring-your-own-compute, utilisez Python 3.10 ou version ultérieure et installez le package d’intégration Durable Task.

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

Pour un nouveau hub de tâches isolé avec des workers et des clients mis à niveau, définissez DURABLE_AGENTS_DEPLOYMENT_MODE=isolated_v2 avant de démarrer l’un ou l’autre hôte. Pour un hub existant, choisissez la stratégie de migration au lieu d’appliquer ce paramètre de manière aveugle. Le paramètre reconnaît l’isolation ; il ne détecte pas d’autres travailleurs ni rend les anciennes histoires compatibles.

hébergement Azure Functions

Avec l’extension durable, vous pouvez déployer et héberger Microsoft agents 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 dans Azure Functions, l’extension crée automatiquement des points de terminaison HTTP pour votre agent et gère l’infrastructure sous-jacente pour le stockage de l’état de conversation, la gestion des requêtes simultanées et la coordination des flux de travail multi-agent. L’intégration d’hébergement Azure Functions fournit également des commodités spécifiques aux fonctions, telles que les API REST générées pour l’envoi de messages, la vérification de l’état et la gestion des sessions, ainsi que des déclencheurs tels que le déclencheur de serveur MCP pour l’hébergement d’agents en tant que serveurs MCP sans écrire de collage de déclencheur.

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

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

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

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

Warning

DefaultAzureCredential est pratique pour le développement, mais nécessite une considération minutieuse en production. En production, envisagez d’utiliser des informations d’identification spécifiques (par exemple ManagedIdentityCredential) pour éviter les problèmes de latence, la détection involontaire des informations d’identification et les risques de sécurité potentiels liés aux mécanismes de secours.

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

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

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

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

Bring-your-own-compute / hébergement auto-hébergé

Utilisez l’hébergement apportez votre propre calcul lorsque vous souhaitez que les fonctionnalités d’extension durable n’utilisent pas le modèle de programmation Azure Functions. Dans ce modèle, votre processus démarre un worker de tâche durable, inscrit des agents durables ou des flux de travail et se connecte à un back-end du planificateur de tâches durables. Le code client peut s’exécuter dans le même processus ou dans un service distinct.

Les travailleurs auto-hébergés utilisent les mêmes fonctionnalités d’extension durable de base que Azure Functions l’hébergement : point de contrôle et reprise, orchestration déterministe de l’agent, flux de travail Durable Agent Framework, attentes humaines dans la boucle, streaming fiable, nettoyage de session inactive, visibilité du tableau de bord et exécution distribuée sur les instances worker sans état. Votre hôte est chargé d’exposer ses propres API, gestion du cycle de vie, mise en réseau, authentification et modèle de déploiement.

Configurez votre hôte avec le package d’intégration Durable Task de base. Utilisez ConfigureDurableAgents pour les agents durables et ConfigureDurableWorkflows pour les flux de travail Microsoft Agent Framework basés sur des graphiques.

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

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

await host.StartAsync();

Consultez les exemples de console .NET Durable Agents et .NET exemples de console Flux de travail durables pour obtenir des exemples auto-hébergés exécutables.

Utilisez le package d’intégration Durable Task pour exécuter un processus de travail qui inscrit des agents et écoute les demandes. Le code client peut se connecter au même hub de tâches Durable Task Scheduler à partir d’un autre processus.

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

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

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

worker.start()

Consultez les exemples Python Durable Task pour obtenir des exemples de client-worker, notamment l’hébergement à agent unique, le routage multi-agent, le streaming fiable, le chaînage d’orchestration, la concurrence, les conditions et les modèles de boucles humaines dans la boucle.

Flux de travail Durable Agent Framework

La durabilité n’est pas limitée aux orchestrations durables. Microsoft flux de travail Agent Framework créés avec le modèle de flux de travail basé sur des graphiques peut également être rendu durable. L’exécution du flux de travail des points de contrôle d’extension durable est donc terminée et les étapes de l’agent ne sont pas répétées après le redémarrage ou l’échec d’un processus.

Utilisez des orchestrations durables lorsque vous souhaitez une coordination impérative avec des branches basées sur le code, des minuteurs, des activités et des événements externes. Utilisez des flux de travail Durable Agent Framework lorsque vous souhaitez un graphique déclaratif d’exécuteurs et d’agents avec routage typé, fan-out/fan-in, edges conditionnels, événements de flux de travail, état partagé, sous-flux de travail ou ports de requête de boucles humaines.

Note

Les flux de travail Durable Agent Framework sont différents du stockage de point de contrôle dans les flux de travail standard. Le stockage de point de contrôle permet de reprendre l’exécution d’un flux de travail dans le runtime Agent Framework. L’extension durable exécute le flux de travail sur l’infrastructure tâche durable afin que la progression du flux de travail soit point de contrôle et récupérée sur les workers durables distribués. Pour connaître les points de contrôle de flux de travail standard, consultez Points de contrôle et reprise.

Inscrivez des flux de travail basés sur des graphiques avec ConfigureDurableWorkflows pour les applications auto-hébergées ou ConfigureDurableWorkflows sur le générateur d’applications Functions pour l’hébergement Azure Functions.

Consultez les exemples .NET flux de travail durables Azure Functions et .NET des exemples de console Flux de travail durables.

Les exemples de flux de travail durables sont disponibles pour l’hébergement Azure Functions, notamment l’état partagé, aucun état partagé, l’exécution de flux de travail parallèle et les flux de travail de boucles humaines. Python prend également en charge les flux de travail basés sur des graphiques sur un worker Durable Task autonome.

Consultez les exemples Python Azure Functions pour obtenir des exemples durables d’agent, d’orchestration, de serveur MCP et de flux de travail.

Pour l’exécution de graphe auto-hébergé, consultez l’exemple de flux de travail Python autonome.

Samples

Language Modèle d’hébergement Agents et orchestrations durables Flux de travail basés sur des graphiques
C# Azure Functions exemples d’agents .NET exemples de flux de travail .NET
C# Self-hosted exemples d’agents de console .NET exemples de flux de travail de console .NET
Python Azure Functions exemples Python Functions exemples de flux de travail Python Functions
Python Self-hosted exemples de Python worker et de client flux de travail autonome Python

Ces exemples illustrent la prise en charge, et non les contrats d’API identiques entre les langages. Functions génère des points de terminaison HTTP ; Les applications auto-hébergées implémentent et sécurisent leurs propres API.

Threads d’agent avec état avec historique des conversations

Les agents gèrent des sessions persistantes qui survivent entre plusieurs interactions. Chaque session a un ID de session unique et stocke l’état de conversation dans un stockage durable géré par l’infrastructure Durable Task, telle que durable Task Scheduler.

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 un processus hôte redémarre ou reprend sur une autre instance de travail, la conversation continue de façon transparente à partir de l’endroit où elle s’est arrêtée.

Configurez délibérément le nettoyage de session, la rétention de l’historique et la rétention des résultats. Ces politiques ont des effets différents ; voir le cycle de vie et la capacité d’état.

L’exemple de Azure Functions suivant illustre plusieurs requêtes HTTP à la même session. Les deux intégrations linguistiques retournent x-ms-session-id et acceptent le paramètre de requête canonique sessionId . Traitez l’ID retourné comme opaque : l’exemple montre une adresse d’entité schema-v2 .NET, tandis que Python mise en forme de session dépend de la stratégie de déploiement. Dans les applications auto-hébergées, utilisez les API clientes Durable Task à partir de votre propre processus ou service.

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

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

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

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

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.

Utilisez sessionId et waitForResponse dans les nouveaux clients HTTP de l’agent. thread_id est un alias de requête déconseillé, et non l’en-tête de réponse à capturer. Pour Python réponses JSON, lisez sessionId et correlationId. Consultez le guide de migration de l’API HTTP pour connaître les alias et la gestion des conflits.

Confirmer l’achèvement durable

Pour les points de terminaison de l’agent Functions générés .NET, interprétez l’achèvement comme suit :

État HTTP Meaning
202 Accepted Dispatch est accepté. L’exécution n’est pas confirmée correctement.
200 OK Un résultat réussi validé est disponible.
500 Internal Server Error Une défaillance de terminal validée prise en charge est retournée. Distinguez-le des erreurs d’hôte ou de transport ordinaires.
410 Gone L’achèvement est connu, mais son résultat n’est pas disponible. Le résultat conservé peut être succeeded ou failed; il ne s’agit pas nécessairement d’une exécution ayant échoué ou d’une expiration de résultat uniquement.

Lire x-ms-durable-outcome lorsqu’une saisie semi-automatique n’a aucun résultat disponible. Ne traitez 410 pas comme étant en attente, déduitz un résultat de l’historique des conversations ou soumettez automatiquement avec une nouvelle identité. Les appelants JSON utilisent une chaîne status et un nombre numérique statusCode; le champ précédent status_code est un alias de compatibilité temporaire.

Python Functions distingue également la réussite disponible, les résultats ayant échoué conservés et les résultats terminés indisponibles. Ses enveloppes d'erreur et ses options sdk ne sont pas identiques à .NET. Consultez le contrat d’achèvement .NET et Python contrat HTTP.

Ces états décrivent les points de terminaison de l’agent. L’API de gestion d’orchestration Durable Functions a sa propre réponse d’état et son contrat d’interrogation.

Diffusion en continu fiable

L’extension durable prend en charge la diffusion en continu fiable pour les applications qui ont besoin d’une remise de jetons en temps réel en même temps que l’exécution durable de l’agent. La diffusion en continu peut être utilisée avec l’extension principale dans les deux modèles d’hébergement, mais les hôtes distribués ont besoin d’un répartiteur de flux fiable, tel que Redis, afin que les clients puissent reprendre la lecture des flux de jetons conservés après des reconnexions ou des modifications de travail, sous réserve des paramètres de persistance et de rétention du répartiteur.

Utilisez la diffusion en continu fiable lorsque l’expérience utilisateur dépend des réponses incrémentielles, mais que la charge de travail a toujours besoin d’une sémantique d’exécution durable. L’achèvement du flux ne confirme pas par lui-même que le résultat et l’état de l’agent ont été durablement conservés ; vérifiez séparément le résultat durable faisant autorité. Pour obtenir des exemples exécutables, consultez les exemples Python Durable Task qui incluent des modèles de diffusion en continu fiables.

Orchestrations multi-agents déterministes

L’extension durable prend en charge la création de flux de travail déterministes qui coordonnent plusieurs agents à l’aide d’orchestrations durables de tâches. Dans Azure Functions, ils utilisent des orchestrations Durable Functions ; dans les hôtes bring-your-own-compute, ils s’exécutent via le worker durable task et le client que vous configurez.

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.

Le point de contrôle durable n’effectue pas d’outils ou d’écritures externes transactionnelles ou exactement une fois. Créez des effets secondaires d’activité et d’outil idempotent et définissez des limites de nouvelle tentative. Une défaillance après une écriture externe, mais avant qu’une validation durable puisse réexécuter l’opération.

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.

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

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

class EmailResponse(BaseModel):
    response: str

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return summary.text

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

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

app = AgentFunctionApp(agents=[content_agent])

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

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

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

    winner = yield when_any([approval_task, timeout_task])

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

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

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 SDK client Durable Task ou des points de terminaison d’extension durables Azure 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. Azure Functions applications peuvent utiliser d’autres back-ends de stockage (comme stockage Azure), mais DTS est optimisé spécifiquement pour les charges de travail durables et offre des fonctionnalités de supervision et de performances supérieures. Les travailleurs auto-hébergés utilisent également DTS pour la planification, l’état et la visibilité du tableau de bord durables.

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.

Déploiement et migration de schémas

L’état de l’agent Schema-v2 change à la fois l’état persistant et les identités de répartition. Planifier la coexistence des workers séparément de la conversion d’état.

Les nouvelles sessions utilisent l’espace de noms d’entité dafx-v2- . Pendant un déploiement en deux phases, laissez ProcessLegacyEntities désactivé pendant que les workers v1 restent actifs. Arrêtez tous les workers v1 avant de pouvoir ProcessLegacyEntities traiter et mettre à niveau des entités héritées éligibles en place.

Les workers autonomes inscrivent des filtres d’élément de travail. Les déploiements de fonctions côte à côte nécessitent également des packages d’extension De travail Fonctions compatibles, DurableTask et De travail AzureManaged qui prennent en charge le filtrage côté hôte sur chaque hôte participant, ainsi workItemFilteringEnabled que dans la configuration du fournisseur de stockage du planificateur. Sans filtrage compatible, utilisez un basculement hors connexion au lieu des hôtes v1 et v2 simultanés sur un hub. Suivez le guide de mise à niveau .NET pour obtenir la configuration complète.

Choisissez une stratégie explicite avant de construire un hôte :

  • two_phase: Utilisez durable Task Scheduler avec le filtrage d’élément de travail principal compatible. Les nouveaux noms avec version isolent la répartition tandis que les entités héritées éligibles restent sur les anciens workers. Arrêtez les anciens workers avant d’activer le traitement des noms historiques et les mises à niveau d’entité sur place. Gérer les workers filtrés compatibles pendant la coexistence ; les filtres de noms ne sont pas des réservations permanentes si cette flotte se déconnecte.
  • isolated_v2: Utilisez un hub de tâches isolé avec des workers et des clients mis à niveau correspondants. Le paramètre reconnaît l’isolation, mais ne sonde pas les autres travailleurs. Utilisez de nouvelles instances de flux de travail.

Un nouveau hub n’est pas une exigence inconditionnelle pour le chemin de migration d’entité en deux phases. Consultez Python migration d’entité pour la configuration et les prérequis spécifiques à l’hôte.

Warning

La migration d’entité ne répare pas la compatibilité de relecture de flux de travail. Les historiques de flux de travail plus anciens, y compris les historiques v2 plus anciens, ne sont pas pris en charge par le runtime mis à niveau. S’ils doivent se terminer, gardez-les sur leurs travailleurs et hub d’origine. Démarrez de nouvelles instances après la mise à niveau ; ne reposez pas uniquement sur le marqueur de version du flux de travail pour prouver la compatibilité. Consultez Python compatibilité du runtime.

Cycle de vie et capacité d’état

Choisissez des stratégies pour chaque couche indépendamment :

Couche Qu’est-ce qu’il contrôle ?
Durée de vie de session Supprime l’ensemble de l’entité, y compris l’état de la conversation et les reçus d’achèvement.
Conservation de l’historique durable Supprime le contenu de transcription stockée éligible ; L’état protégé peut toujours dépasser la capacité.
Compactage d’entrée de modèle Modifie le contexte envoyé au modèle ; il ne s’agit pas nécessairement de l’histoire durable.
Rétention des résultats Contrôle la disponibilité de la charge utile de réponse indépendamment du résultat d’achèvement conservé.
Cycle de vie de la charge utile d’objets blob Contrôle les objets blob de charge utile déchargés du SDK ; la suppression de session ou la purge d’orchestration ne les nettoie pas.

Dans .NET'état de réception de schéma-v2, la durée de vie héritée non configurée de 14 jours ne supprime pas automatiquement l'entité. Configurez explicitement une durée de vie globale ou par agent si vous souhaitez nettoyer les sessions inactives. Passer timeToLive: null pour AddAIAgent hériter de la valeur par défaut globale configurée ; il ne remplace pas une valeur par défaut globale de sept jours avec « jamais expire ». Définissez cette option DefaultTimeToLive = null pour désactiver la durée de vie globale des agents sans remplacements positifs par agent.

.NET valeurs par défaut ;DurableAgentHistoryRetentionMode.KeepAllAuto permet la rétention des transcriptions basées sur la pression. ResultRetentionPeriod la valeur par défaut est de 60 secondes et est séparée de la durée de vie de session. Python dispose d’options de rétention et de budget distinctes, notamment retention="keep_all" par défaut. Ne supposez pas les mêmes options ou valeurs par défaut entre les hôtes.

Python prend en charge le déchargement facultatif de charge utile d’objets blob gérés par le KIT de développement logiciel (SDK) dans les deux modèles d’hébergement. Configurez les magasins de producteurs et de consommateurs, les informations d’identification et le cycle de vie des objets blob. Le déchargement ne supprime pas les limites de capacité d’entité entière ni remplace la rétention ; conservez les objets blob pendant que l’état référencé ou l’historique de relecture en a besoin. Consultez .NET état et rétention, Python rétention et budgets, et Python déchargement d’objets blob Functions.

Pour obtenir des conseils sur l’infrastructure, la capacité et les opérations du planificateur, consultez l’intégration durable des tâches pour Agent Framework.

Tutoriel : Créer et exécuter un agent durable avec Azure Functions

Ce tutoriel vous montre comment créer et exécuter un agent IA durable à l’aide du modèle d’hébergement Azure Functions pour l’extension durable. 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. Pour les agents auto-hébergés, consultez les exemples.

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.

Définissez DURABLE_AGENTS_DEPLOYMENT_MODE=isolated_v2 uniquement après avoir confirmé que le hub de didacticiels est isolé et que tous les workers et clients utilisent le runtime mis à niveau.

Utilisez un hub de tâches nouveau pour ce didacticiel, distinct des applications durables existantes. Pour une application existante, suivez plutôt le déploiement et la migration de schéma .

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 :

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

Note

Vous pouvez également utiliser python -m venv .venv avec un interpréteur Python 3.13 installé. Si cette commande se bloque sur Windows, utilisez la commande ci-dessus à la uv venv place. Vérifiez l’interpréteur actif avec qui python --version vous devez installer des packages.

  1. Installez les packages nécessaires :

    Mettez à jour les packages Functions dans La prise en main, y compris le agent-framework-openai package client, avant d’installer requirements.txt le modèle. Résolvez les broches de dépendance en conflit dans le manifeste plutôt que de forcer l’installation sur eux.

    uv 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.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Hosting;

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

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

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

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_azurefunctions import AgentFunctionApp
from agent_framework.openai import OpenAIChatCompletionClient
from azure.identity import DefaultAzureCredential

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

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

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

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 ...
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "AZURE_OPENAI_ENDPOINT": "https://your-openai-resource.openai.azure.com",
    "AZURE_OPENAI_DEPLOYMENT": "gpt-4o-mini",
    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None",
    "TASKHUB_NAME": "default"
  }
}

Note

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.

Pour Python, ajoutez-y "DURABLE_AGENTS_DEPLOYMENT_MODE": "isolated_v2"Values uniquement après avoir confirmé que le hub de didacticiels est isolé. Configurez le paramètre d’application équivalent lors du déploiement ; les paramètres locaux ne sont pas chargés automatiquement.

Pour l’hébergement soutenu par planificateur, utilisez le même hub de tâches dans host.json (via %TASKHUB_NAME%), TASKHUB_NAME, , l’émulateur DURABLE_TASK_SCHEDULER_CONNECTION_STRINGet le tableau de bord. Ce didacticiel utilise default, que l’émulateur crée automatiquement. Si ce hub contient déjà d’anciennes historiques ou est utilisé par d’autres workers, choisissez un nom de hub unique, inutilisé, définissez l’émulateur sur ce nom et mettez à jour les paramètres de l’application DTS_TASK_HUB_NAMES et la sélection du tableau de bord de manière cohérente. Il suffit de définir un planificateur chaîne de connexion ne sélectionne pas le fournisseur de stockage du planificateur.

Dans host.json, configurez le fournisseur du planificateur sous extensions.durableTask, en conservant les autres paramètres d’hôte du modèle :

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

Utilisez les dépendances du fournisseur du planificateur pour votre langage d’hébergement. Cette configuration sélectionne le serveur principal pour un nouveau déploiement de didacticiel isolé ; elle n’active pas le filtrage requis pour une mise à niveau côte à côte.

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

Ces étapes supposent que l’hôte Functions utilise le fournisseur de stockage Durable Task Scheduler. Les exemples Python Functions de la version sont par défaut stockage Azure. Si vous démarrez à partir de ces exemples, sélectionnez et configurez le fournisseur du planificateur avant d’utiliser le tableau de bord DTS ; sinon Azurite conserve l’état durable et le tableau de bord du planificateur reste vide. Consultez la configuration du planificateur de tâches durables.

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.

Tip

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 crée le default hub de tâches et démarre l’émulateur, correspondant aux paramètres de ce didacticiel. La commande 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.

Tip

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-v2-MyDurableAgent: entityTrigger

Cela illustre l’inscription .NET schema-v2 ; Python noms de déclencheurs dépendent de la stratégie de déploiement. Ces points de terminaison gèrent automatiquement l’état de conversation. Vous n’avez donc pas besoin de créer vous-même des objets de session.

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 une session 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 (l’en-tête x-ms-session-id contient l’ID de session ; cet exemple montre un ID de schéma-v2 .NET) :

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

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

Enregistrez l’ID de session exact à partir de l’en-tête x-ms-session-id de la requête suivante. Ne construisez pas ou réécritez-le. Python retourne également cet en-tête, mais son format d’ID peut différer.

Continuer la conversation

Envoyez un message de suivi à la même session en incluant l’ID retourné dans le paramètre de requête canonique sessionId :

Remplacez l’id d’exemple par la valeur réelle de l’en-tête de x-ms-session-id la réponse précédente. Encodez l’URL si nécessaire.

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

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 par défaut, ou le même nom de hub unique que celui que vous avez configuré dans votre application et votre émulateur, 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

Tip

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 la fin du déploiement. 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

Pour l'autorisation par défaut des points de terminaison générés au niveau de la fonction, incluez une clé Functions dans les requêtes à Azure. Une clé Functions n’est pas une autorisation d’utilisateur d’application ; consultez la sécurité et la résolution des problèmes de 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 une session 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?"

Enregistrez l’ID de session retourné dans l’en-tête de x-ms-session-id réponse.

Poursuivre la conversation dans Azure

Envoyez un message de suivi dans la même session. Utilisez l’ID exact retourné par la réponse précédente :

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

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 configuré pour l’application déployée.

  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 avec Azure Functions

Ce tutoriel vous montre comment orchestrer plusieurs agents IA durables à l’aide du modèle d’hébergement Azure Functions et 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. Pour obtenir des exemples d’orchestration auto-hébergés, consultez les exemples.

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.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Hosting;

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

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

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

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

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

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

app.Run();

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_azurefunctions import AgentFunctionApp
from agent_framework.openai import OpenAIChatCompletionClient

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

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

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

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

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

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

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 :

from durabletask.task import OrchestrationContext, when_all

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

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

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

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

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

    return result

Note

Ce guide couvre l’hébergement C# et Python Extension durable. Pour l’hébergement Go, consultez l’hébergement A2A et le référentiel Agent Framework Go.

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 configuré pour votre application.

  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.

Sécurité et résolution des problèmes de production

Traitez ces limites d’accès séparément :

  • Utilisateurs d’applications : Authentifiez les appelants et autorisez l’accès à chaque session, flux de travail et réponse d’approbation humaine. Les ID de session, de corrélation et de requête sont des identificateurs, et non des informations d’identification.
  • Points de terminaison functions : Les clés au niveau de la fonction protègent les points de terminaison HTTP générés, mais n’établissent pas d’identité d’utilisateur d’application ou de propriété de session. Protéger et faire pivoter les clés ; ne les exposez pas dans le code d’application fourni par le navigateur.
  • Accès au modèle : Accordez à l’identité de travail les autorisations de modèle requises. Les informations d’identification du modèle n’accordent pas l’accès au planificateur ou à la session d’un autre utilisateur.
  • Accès du planificateur : Configurez les autorisations worker, client et tableau de bord pour leurs rôles prévus. Pour obtenir des conseils sur l’infrastructure, consultez l’intégration de Durable Task.
Symptôme Cocher
échec de l’installation du package Python ou du démarrage de Functions Utilisez Python 3.13 ou version ultérieure pour Functions, installez les packages Functions dans Prise en main et sélectionnez explicitement une stratégie de déploiement. Le minimum de Python autonome est différent.
Les requêtes réussissent, mais le tableau de bord DTS est vide Vérifiez que le fournisseur de stockage Functions n’est AzureManagedpas , et AzureStorageque le point de terminaison du planificateur et le hub de tâches correspondent au tableau de bord.
Une session semble perdre le contexte Réutilisez la valeur retournée x-ms-session-id exactement avec sessionId; recherchez un autre hub, un espace de noms de déploiement ou un nettoyage de session configuré.
Les anciens flux de travail échouent après la mise à niveau Vérifiez la compatibilité de la relecture avant de reprendre les exécutions historiques. La migration d’entité ne répare pas les historiques de flux de travail incompatibles.
Un flux se termine mais l’achèvement durable est manquant Traitez la sortie du flux comme provisoire et vérifiez le résultat faisant autorité ou le résultat conservé. Un marqueur d’achèvement de flux n’est pas un accusé de réception de validation durable.
Une opération terminée retourne 410 Inspectez les résultats conservés et la disponibilité des résultats. Ne supposez pas l’échec, conservez l’interrogation comme si elle était en attente ou envoyez automatiquement une nouvelle opération.
Les écritures d’état d’entité dépassent la capacité Inspectez l’état de l’entité entière, les enregistrements protégés, la stratégie de rétention et les références de charge utile. Le compactage d’entrée de modèle seul ne garantit pas que l’état stocké correspond.

Étapes suivantes

Points de terminaison compatibles avec OpenAI

Ressources supplémentaires :

  • Dernière mise à jour :