Démarrage rapide : Déployer votre premier agent hébergé

• Azure Developer CLI (azd) 1.27.1 ou version ultérieure.

• Extension azd microsoft.foundry . Installez et vérifiez l’extension une fois azd installée :

  azd ext install microsoft.foundry
  

• Une session authentifiée azd . Connectez-vous après avoir installé l’extension :

  azd auth login
  

• Python 3.13 ou version ultérieure.

• Azure CLI installé et authentifié :

  az login
  

• Les packages Python SDK utilisés dans ce guide de démarrage rapide :

  pip install "azure-ai-projects>=2.3.0" azure-identity python-dotenv
  

• Un projet Foundry existant avec un modèle déployé. La procédure avec le SDK Python dans ce guide de démarrage rapide crée et achemine une version d’agent hébergée, mais elle ne génère pas la structure d’un nouveau projet Foundry et ne crée pas de déploiement de modèle pour vous. Si vous avez besoin du flux de travail d’approvisionnement complet, utilisez l’onglet cli Azure Développeur dans cet article.

• .NET 10 SDK.

• Azure CLI installé et authentifié :

  az login
  

• Packages .NET utilisés dans ce guide de démarrage rapide.

  dotnet add package Azure.AI.Projects --version 2.1.0-beta.4
  dotnet add package Azure.Identity
  

  Note

  Les API de déploiement de code source sont actuellement disponibles dans une version préliminaire de Azure.AI.Projects. Le package stable 2.0.x n’inclut pas ces API.

• Un projet Foundry existant avec un modèle déployé. Le chemin du SDK C# crée et route une version d’agent hébergé, mais il ne crée pas de projet foundry ou de déploiement de modèle. Pour le workflow complet d’approvisionnement, utilisez l’onglet Azure Developer CLI.

• Visual Studio Code.
• Microsoft Foundry Toolkit pour Visual Studio Code.

• application GitHub Copilot.

• L’extension Microsoft Foundry Canvas. Pour l’installer, dans l’application GitHub Copilot ouvrezles plug-ins>, recherchezmicrosoft-foundry, puis sélectionnez Installer. Pour plus d’informations, consultez Qu’est-ce que Microsoft Foundry Canvas ?

• Azure Developer CLI (azd) 1.27.1 ou version ultérieure. Le canevas utilise azd pour tester et déployer l’agent.

• Extension azd microsoft.foundry . Installez et vérifiez l’extension une fois azd installée :

  azd ext install microsoft.foundry
  

• Hôte pour agent de codage sur lequel la Microsoft Foundry Skill est installée.

• Azure CLI et Azure Developer CLI (azd) installés et authentifiés :

  az login
  azd auth login
  

Étape 1 : Initialiser l’agent d’exemple

Initialisez un nouvel agent hébergé à l’aide de l’exemple Agent Framework de base dans un répertoire vide :

azd ai agent init -m "https://github.com/microsoft-foundry/foundry-samples/blob/main/samples/python/hosted-agents/agent-framework/responses/01-basic/azure.yaml" --deploy-mode code

Le flux interactif invite à :

• Nom de l’agent : personnalisez le nom ou acceptez le nom par défaut, agent-framework-agent-basic-responses
• Project Foundry : sélectionnez Créer un project Foundry ou utiliser un project Foundry existant
• Tenant : sélectionnez votre locataire Azure
• Abonnement : sélectionnez votre abonnement Azure
• Location : sélectionnez une région Azure
• Modèle : sélectionnez le modèle par défaut, gpt-5.4-mini ou un autre modèle auquel vous pouvez accéder
• Version du modèle : sélectionner l’option par défaut
• Référence SKU de modèle : sélectionnez une option avec un quota disponible qui n’est pas Batch, généralement Standard ou GlobalStandard
• Capacité de déploiement : sélectionnez la valeur par défaut10
• Nom du déploiement : sélectionnez la valeur par défaut, gpt-5.4-mini

Une fois terminé, vous voyez que la définition de l’agent IA est ajoutée à votre projet azd avec succès ! Modifiez le répertoire dans le dossier de l’agent nouvellement créé.

cd agent-framework-agent-basic-responses

Étape 2 : Approvisionner des ressources Azure

Provisionnez les ressources définies dans azure.yaml:

azd provision

Étape 3 : Tester l’agent localement

azd ai agent run

Cette commande crée un environnement virtuel, installe des dépendances, lance l’agent à l’aide de l’agent startupCommand défini dans azure.yamlet ouvre l’inspecteur d’agent dans votre navigateur pour pouvoir discuter avec l’agent.

Étape 4 : Déployer sur Foundry Agent Service

Déployez le code source de l’agent. azd empaquette la source en tant que fichier ZIP et le charge dans Foundry. Foundry résout les dépendances, génère l’agent hébergé à distance et le déploie :

azd deploy

Une fois la commande terminée, la sortie affiche des liens vers le playground de l’assistant et le point de terminaison de l’assistant :

Deploying services (azd deploy)

  Done: Deploying service basic-agent
  - Agent playground (portal): https://ai.azure.com/.../build/agents/basic-agent/build?version=1
  - Agent endpoint: https://ai-account-<name>.services.ai.azure.com/api/projects/<project>/agents/basic-agent/versions/1

Étape 5 : Appeler votre agent

1. Envoyez la même invite à l’agent déployé :

   azd ai agent invoke "Write a haiku about deploying cloud applications."
   

   Vous devriez voir une réponse haiku dans quelques secondes.

2. (Facultatif) Diffusez les journaux du conteneur en continu pendant que vous interagissez avec l’assistant :

   azd ai agent monitor --follow
   

Étape 1 : Créer ou choisir un projet Foundry

1. Ouvrez le portail Foundry et créez un projet Foundry, ou sélectionnez-en un existant.

2. Dans le projet, déployez un modèle compatible conversation comme gpt-5.4-mini.

3. Copiez ces valeurs à partir du portail :

   • Point de terminaison du projet dans Vue d’ensemble.
   • Nom du déploiement dans Build>Déploiements.

Étape 2 : Télécharger l’exemple de code d’agent de base

Clonez le dépôt d’exemples de Foundry.

git clone https://github.com/microsoft-foundry/foundry-samples.git

Étape 3 : Créer un environnement Python et configurer des paramètres

Créez un environnement virtuel et installez les packages Python requis pour ce guide de démarrage rapide.

Pour macOS ou Linux :

python -m venv .venv
source .venv/bin/activate
pip install "azure-ai-projects>=2.3.0" azure-identity python-dotenv

Pour Windows (PowerShell) :

python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install "azure-ai-projects>=2.3.0" azure-identity python-dotenv

Créez un dossier de travail pour le script de déploiement, puis créez un .env fichier dans ce dossier :

FOUNDRY_PROJECT_ENDPOINT=<your-project-endpoint>
FOUNDRY_MODEL_NAME=<your-model-deployment-name>
FOUNDRY_HOSTED_AGENT_NAME=basic-agent
FOUNDRY_SAMPLE_PATH=<full-path-to-foundry-samples/samples/python/hosted-agents/agent-framework/responses/01-basic/src/agent-framework-agent-basic-responses>

Étape 4 : Déployer l’agent hébergé avec Python

Créez un fichier nommé deploy_hosted_agent.py dans le même dossier de travail qu’avec .env le contenu suivant :

import os
import tempfile
import time
import zipfile
from pathlib import Path

from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
  AgentEndpointConfig,
  CodeConfiguration,
  CodeDependencyResolution,
  FixedRatioVersionSelectionRule,
  HostedAgentDefinition,
  ProtocolConfiguration,
  ProtocolVersionRecord,
  ResponsesProtocolConfiguration,
  VersionSelector,
)
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv

load_dotenv()

endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]
model_name = os.environ["FOUNDRY_MODEL_NAME"]
agent_name = os.environ.get("FOUNDRY_HOSTED_AGENT_NAME", "basic-agent")
sample_path = Path(os.environ["FOUNDRY_SAMPLE_PATH"]).resolve()


def create_code_zip(source_dir: Path) -> Path:
  zip_path = Path(tempfile.gettempdir()) / f"{agent_name}.zip"
  excluded = {".git", ".venv", "__pycache__", ".env", "deploy_hosted_agent.py"}

  with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zip_file:
    for path in source_dir.rglob("*"):
      if not path.is_file():
        continue
      if any(part in excluded for part in path.parts):
        continue
      zip_file.write(path, path.relative_to(source_dir))

  return zip_path


def wait_for_active_version(project_client: AIProjectClient, version: str) -> None:
  for attempt in range(60):
    time.sleep(10)
    details = project_client.agents.get_version(
      agent_name=agent_name,
      agent_version=version,
    )
    status = details["status"]
    print(f"Provisioning status: {status} (attempt {attempt + 1}/60)")

    if status == "active":
      return

    if status == "failed":
      raise RuntimeError(f"Hosted agent provisioning failed: {dict(details)}")

  raise RuntimeError("Timed out waiting for the hosted agent version to become active.")


code_zip_path = create_code_zip(sample_path)

with (
  code_zip_path.open("rb") as code_stream,
  DefaultAzureCredential() as credential,
  AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
):
  original_agent_endpoint = None
  created = None

  try:
    created = project_client.agents.create_version_from_code(
      agent_name=agent_name,
      description="Basic hosted agent deployed from local Python source.",
      definition=HostedAgentDefinition(
        cpu="0.5",
        memory="1Gi",
        code_configuration=CodeConfiguration(
          runtime="python_3_14",
          entry_point=["python", "main.py"],
          dependency_resolution=CodeDependencyResolution.REMOTE_BUILD,
        ),
        environment_variables={
          "FOUNDRY_PROJECT_ENDPOINT": endpoint,
          "FOUNDRY_MODEL_NAME": model_name,
        },
        protocol_versions=[
          ProtocolVersionRecord(protocol="responses", version="2.0.0")
        ],
      ),
      code=code_stream,
    )

    print(f"Created hosted agent version {created.version}")

    wait_for_active_version(project_client, created.version)

    original_agent_endpoint = project_client.agents.get(
      agent_name=agent_name
    ).agent_endpoint
    project_client.agents.update_details(
      agent_name=agent_name,
      agent_endpoint=AgentEndpointConfig(
        version_selector=VersionSelector(
          version_selection_rules=[
            FixedRatioVersionSelectionRule(
              agent_version=created.version,
              traffic_percentage=100,
            ),
          ]
        ),
        protocol_configuration=ProtocolConfiguration(
          responses=ResponsesProtocolConfiguration()
        ),
      ),
    )

    print(f"Agent endpoint configured for version {created.version}")

    with project_client.get_openai_client(agent_name=agent_name) as openai_client:
      response = openai_client.responses.create(
        input="Write a haiku about deploying cloud applications.",
      )

    print(f"Agent response: {response.output_text}")
  finally:
    if original_agent_endpoint is not None:
      project_client.agents.update_details(
        agent_name=agent_name,
        agent_endpoint=original_agent_endpoint,
      )
      print("Agent endpoint restored")

    if created is not None:
      project_client.agents.delete_version(
        agent_name=agent_name,
        agent_version=created.version,
        force=True,
      )
      print(f"Deleted hosted agent version {created.version}")

Exécutez le script :

python deploy_hosted_agent.py

Le script compresse l’exemple de source, le charge en tant que nouvelle version d’agent hébergé, attend que l’approvisionnement se termine, route temporairement le point de terminaison de l’agent hébergé vers cette version, appelle l’agent déployé, puis restaure la configuration du point de terminaison précédente et supprime la version temporaire.

Étape 5 : Appeler votre agent

Une fois le script terminé, utilisez l’agent hébergé de l’une des façons suivantes :

1. Modifiez deploy_hosted_agent.py et changez la valeur input transmise à openai_client.responses.create(...), puis réexécutez le script.
2. Si vous souhaitez une version persistante avec routage au lieu d’un déploiement de validation temporaire, adaptez le script pour ignorer les étapes de restauration et delete_version(...) après avoir examiné les implications du routage du trafic.
3. Si vous avez utilisé l’exemple de script comme écrit, il restaure déjà la configuration du point de terminaison et supprime la version temporaire de l’agent hébergé après validation.
4. Si vous avez créé un groupe de ressources dédié pour ce guide de démarrage rapide, vous pouvez supprimer le groupe de ressources du portail Azure une fois que vous n’avez plus besoin du déploiement du projet ou du modèle.

Étape 1 : Créer ou choisir un projet Foundry

1. Ouvrez le portail Foundry et créez un projet Foundry, ou sélectionnez-en un existant.

2. Dans le projet, déployez un modèle compatible conversation comme gpt-5.4-mini.

3. Copiez ces valeurs à partir du portail :

   • Point de terminaison du projet dans Vue d’ensemble.
   • Nom du déploiement dans Build>Déploiements.

Étape 2 : Télécharger l’agent hello-world C#

Clonez le référentiel d’exemples Foundry :

git clone https://github.com/microsoft-foundry/foundry-samples.git

La source de l’agent est dans samples/csharp/hosted-agents/agent-framework/hello-world/src/hello-world-dotnet-agent-framework.

Étape 3 : Créer un projet de déploiement C#

Créez une application console et installez les packages requis :

dotnet new console --name HostedAgentDeployer
cd HostedAgentDeployer
dotnet add package Azure.AI.Projects --version 2.1.0-beta.4
dotnet add package Azure.Identity

Définissez les valeurs que l’application de déploiement utilise. Dans PowerShell, exécutez :

$env:FOUNDRY_PROJECT_ENDPOINT = "<your-project-endpoint>"
$env:FOUNDRY_MODEL_NAME = "<your-model-deployment-name>"
$env:FOUNDRY_HOSTED_AGENT_NAME = "basic-agent"
$env:FOUNDRY_SAMPLE_PATH = "<full-path-to-hello-world-dotnet-agent-framework>"

Pour macOS ou Linux, exécutez :

export FOUNDRY_PROJECT_ENDPOINT="<your-project-endpoint>"
export FOUNDRY_MODEL_NAME="<your-model-deployment-name>"
export FOUNDRY_HOSTED_AGENT_NAME="basic-agent"
export FOUNDRY_SAMPLE_PATH="<full-path-to-hello-world-dotnet-agent-framework>"

Étape 4 : Déployer l’agent hébergé avec C#

Remplacez le contenu de Program.cs par le code suivant. Le SDK .NET compresse et téléverse le répertoire source, vous n’avez donc pas besoin de créer vous-même l’archive ZIP.

using Azure.AI.Extensions.OpenAI;
using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;
using OpenAI.Responses;

#pragma warning disable AAIP001, OPENAI001

var projectEndpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT")
  ?? throw new InvalidOperationException("FOUNDRY_PROJECT_ENDPOINT isn't set.");
var modelName = Environment.GetEnvironmentVariable("FOUNDRY_MODEL_NAME")
  ?? throw new InvalidOperationException("FOUNDRY_MODEL_NAME isn't set.");
var agentName = Environment.GetEnvironmentVariable("FOUNDRY_HOSTED_AGENT_NAME")
  ?? "basic-agent";
var samplePath = Environment.GetEnvironmentVariable("FOUNDRY_SAMPLE_PATH")
  ?? throw new InvalidOperationException("FOUNDRY_SAMPLE_PATH isn't set.");

AIProjectClient projectClient = new(
  endpoint: new Uri(projectEndpoint),
  tokenProvider: new DefaultAzureCredential());

HostedAgentDefinition definition = new(cpu: "0.5", memory: "1Gi")
{
  Versions =
  {
    new ProtocolVersionRecord(ProjectsAgentProtocol.Responses, "2.0.0")
  },
  CodeConfiguration = new(
    runtime: "dotnet_10",
    entryPoint: ["dotnet", "hello-world.dll"],
    dependencyResolution: CodeDependencyResolution.RemoteBuild),
};
definition.EnvironmentVariables.Add(
  "FOUNDRY_PROJECT_ENDPOINT", projectEndpoint);
definition.EnvironmentVariables.Add(
  "AZURE_AI_MODEL_DEPLOYMENT_NAME", modelName);

ProjectsAgentVersion? created = null;
AgentEndpointConfiguration? originalEndpoint = null;

try
{
  created = await projectClient.AgentAdministrationClient
    .CreateAgentVersionFromCodeAsync(
      agentName: agentName,
      filePath: samplePath,
      metadata: new AgentVersionFromCodeMetadata(definition));
  Console.WriteLine($"Created hosted agent version {created.Version}");

  for (var attempt = 1; attempt <= 60; attempt++)
  {
    await Task.Delay(TimeSpan.FromSeconds(10));
    created = await projectClient.AgentAdministrationClient
      .GetAgentVersionAsync(agentName, created.Version);
    Console.WriteLine(
      $"Provisioning status: {created.Status} (attempt {attempt}/60)");

    if (created.Status == AgentVersionStatus.Active)
    {
      break;
    }
    if (created.Status == AgentVersionStatus.Failed)
    {
      throw new InvalidOperationException("Hosted agent provisioning failed.");
    }
  }

  if (created.Status != AgentVersionStatus.Active)
  {
    throw new TimeoutException(
      "Timed out waiting for the hosted agent version to become active.");
  }

  ProjectsAgentRecord agent = await projectClient.AgentAdministrationClient
    .GetAgentAsync(agentName);
  originalEndpoint = agent.AgentEndpoint;

  AgentEndpointConfiguration endpoint = new()
  {
    VersionSelector = new(
      [new FixedRatioVersionSelectionRule(created.Version, 100)]),
    ProtocolConfiguration = new()
    {
      Responses = new ResponsesProtocolConfiguration()
    }
  };
  await projectClient.AgentAdministrationClient.PatchAgentAsync(
    agentName,
    new PatchAgentOptions { AgentEndpoint = endpoint });
  Console.WriteLine($"Agent endpoint configured for version {created.Version}");

  ProjectResponsesClient responsesClient = projectClient.ProjectOpenAIClient
    .GetProjectResponsesClientForAgentEndpoint(agentName);
  ResponseResult response = await responsesClient.CreateResponseAsync(
    "Write a haiku about deploying cloud applications.");
  Console.WriteLine($"Agent response: {response.GetOutputText()}");
}
finally
{
  if (originalEndpoint is not null)
  {
    await projectClient.AgentAdministrationClient.PatchAgentAsync(
      agentName,
      new PatchAgentOptions { AgentEndpoint = originalEndpoint });
    Console.WriteLine("Agent endpoint restored");
  }

  if (created is not null)
  {
    await projectClient.AgentAdministrationClient.DeleteAgentVersionAsync(
      agentName,
      created.Version,
      force: true);
    Console.WriteLine($"Deleted hosted agent version {created.Version}");
  }
}

Le code suit les modèles de chargement source et de routage de point de terminaison de l’Kit de développement logiciel (SDK) Azure pour .NET exemple d’agent de code.

Exécutez l’application :

dotnet run

L’application charge la source de l’agent C#, attend l’approvisionnement, achemine le point de terminaison de l’agent vers la nouvelle version, envoie une invite, restaure l’itinéraire précédent et supprime la version temporaire.

Étape 5 : Appeler votre agent

Une fois l’application terminée, utilisez l’agent hébergé de l’une des manières suivantes :

1. Dans Program.cs, modifiez l’invite passée à CreateResponseAsync, puis réexécutez dotnet run .
2. Pour conserver la version routée, supprimez la restauration du point de terminaison et les appels DeleteAgentVersionAsync après avoir examiné l’impact du routage du trafic.
3. Si vous avez utilisé l’application C# comme écrite, elle restaure la configuration du point de terminaison et supprime la version temporaire de l’agent hébergé après validation.
4. Si vous avez créé un groupe de ressources dédié pour ce guide de démarrage rapide, supprimez le groupe de ressources du portail Azure lorsque vous n’avez plus besoin du déploiement du projet ou du modèle.

Étape 1 : Créer un projet Foundry

1. Ouvrez la palette de commandes (Ctrl+Maj+P), puis sélectionnez Foundry Toolkit : Créer Project.
2. Sélectionnez votre abonnement Azure.
3. Créez un groupe de ressources ou sélectionnez-en un existant.
4. Entrez un nom pour le projet Foundry.

Étape 2 : Déployer un modèle

1. Ouvrez la palette de commandes et sélectionnez Foundry Toolkit : Ouvrir le catalogue de modèles.
2. gpt-4.1 Recherchez et sélectionnez Déployer.
3. Dans la page de déploiement de modèle, sélectionnez Deploy to Microsoft Foundry.

Étape 3 : Créer un projet d’agent hébergé

1. Ouvrez la palette de commandes et sélectionnez Foundry Toolkit : Créer un agent hébergé.
2. Sélectionnez Python comme langage.
3. Pour Framework, sélectionnez Agent Framework.
4. Sélectionnez l’API Réponses comme type de protocole.
5. Sélectionnez Basic comme exemple de code.
6. Sélectionnez le bouton Suivant.
7. Choisissez un dossier pour les fichiers projet et entrez un nom pour l’agent.
8. Pour Configuration de l’environnement, choisissez Configuration avec Microsoft Foundry. Le contenu est renseigné automatiquement avec le projet et le modèle que vous avez créés aux étapes 1 et 2.
9. Cliquez sur le bouton Créer.

Une nouvelle fenêtre VS Code s’ouvre avec le projet en tant qu’espace de travail actif.

Étape 4 : Installer les dépendances

Créez un environnement virtuel et installez les exigences.

Pour macOS ou Linux :

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

Pour Windows (PowerShell) :

python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt

Étape 5 : Tester l’agent localement

Appuyez sur F5 pour démarrer le serveur HTTP local avec le débogage activé. Foundry Toolkit Agent Inspector s’ouvre pour effectuer des tests interactifs, et vous pouvez définir des points d’arrêt dans votre code.

Pour exécuter le serveur sans débogage :

python main.py

L’assistant écoute sur http://localhost:8088/. Envoyez une invite de test avec curl (ou un client HTTP) :

curl -sS -H "Content-Type: application/json" -X POST http://localhost:8088/responses \
    -d '{"input": "Write a haiku about deploying cloud applications.", "stream": false}'

Étape 6 : Déployer sur le service de l’agent Foundry

1. Ouvrez la palette de commandes et sélectionnez Foundry Toolkit : Déployer l’agent hébergé. Une vue web de déploiement s’ouvre.
2. Pour la méthode de déploiement, sélectionnez Code.
3. Sélectionnez Remote en tant que mode package.
4. Le nom de l’agent est renseigné automatiquement.
5. Sélectionnez le bouton Suivant.
6. La page Vérifier et déployer est renseignée automatiquement.
7. Sélectionnez le bouton Déployer .

Une fois le déploiement terminé, l’agent apparaît sous Agents hébergés dans l’Explorateur Foundry Toolkit.

Étape 7 : Appeler votre agent

1. Dans l’Explorateur Foundry Toolkit, développez Agents hébergés et sélectionnez votre agent. La page détails affiche l’état sous Détails du déploiement.
2. Sélectionnez l’onglet Playground et envoyez une invite de test telle que Write a haiku about deploying cloud applications..

Le canevas Microsoft Foundry vous guide tout au long de la création et du déploiement d’un agent hébergé à partir d’un panneau latéral dans l’application GitHub Copilot. Lorsque vous faites des choix sur le canevas, celui-ci transmet chaque étape à Copilot avec le contexte pertinent de votre projet Foundry.

Étape 1 : Ouvrir le canevas

1. Dans l’application GitHub Copilot, invitez Copilot pour créer un agent hébergé Foundry. Par exemple:

   Create a Foundry hosted agent using Microsoft Foundry Canvas
   

2. Le canevas s’ouvre dans le volet droit. S’il ne s’ouvre pas automatiquement, ouvrez-le à partir du panneau droit.

Le canevas vous guide à travers trois étapes, qui correspondent aux étapes suivantes :

• Créez un agent hébergé. Choisissez votre projet Foundry et indiquez à Copilot ce que vous souhaitez créer. Vous pouvez commencer à partir d’une invite préécrite pour accélérer les choses.
• Générez l’agent hébergé. Choisissez le modèle, les boîtes à outils, les compétences et les garde-fous de votre agent à partir des ressources de votre projet Foundry.
• Déployer et tester. Testez l’agent localement et, lorsque vous êtes satisfait, déployez-le sur Foundry Agent Service.

Étape 2 : Connecter un projet Foundry

1. Ouvrez le menu du projet de canevas et connectez-vous à Azure si vous y êtes invité.
2. Sélectionnez un abonnement.
3. Sélectionnez un projet Foundry. Le canevas conserve cette sélection lorsque vous la rouvrez.

Étape 3 : Créer la structure de base de l’agent

Choisissez comment démarrer :

• Sélectionnez Inspirez-moi pour créer la structure de base d’un agent hébergé à partir d’une idée générée.
• Sélectionnez l’exemple d’invite Hello world pour partir d’un agent de base.

Copilot structure le code de l’agent dans votre espace de travail en fonction de votre choix.

Étape 4 : Configurer l’assistant

Dans cette étape, vous connectez l’agent aux ressources de votre projet Foundry. Chaque sélection envoie une invite à Copilot, qui met à jour le code et la configuration de l’agent pour vous :

1. Sélectionnez un modèle déployé pour alimenter le raisonnement de l’agent.
2. Connectez les boîtes à outils de Foundry et leurs outils pour doter l’agent de capacités, comme l’appel d’API ou l’exécution de code.
3. Connectez des compétences qui encapsulent une logique réutilisable que l’agent peut utiliser.
4. Attribuez des garde-fous pour appliquer des contrôles de sécurité et de contenu.

Étape 5 : Tester l’agent localement

1. Sélectionnez Inspecter localement. Le canevas s’exécute azd ai agent run dans le terminal intégré Copilot, attend l’agent sur le port 8088et incorpore l’inspecteur d’agent.

2. Envoyez une invite de test, par exemple :

   Write a haiku about deploying cloud applications.
   

3. Si l’inspecteur signale une erreur, copiez le message d’erreur dans la zone d’invite du canevas et demandez à Copilot de résoudre le problème.

Étape 6 : Déployer sur le service de l’agent Foundry

1. Sélectionnez Déployer sur Foundry. Le canevas utilise azd et Copilot pour déployer votre agent hébergé.
2. Une fois le déploiement terminé, utilisez les liens dans la sortie pour ouvrir l’aire de jeu de l’agent dans le portail Foundry.

Étape 1 : Ouvrez un espace de travail avec la compétence Foundry

Ouvrez un dossier vide dans votre hôte d’agent de codage, tel que GitHub Copilot dans Visual Studio Code, Copilot CLI ou Claude Code. Vérifiez que la microsoft-foundry compétence est disponible avant de demander à l’agent de codage de créer des ressources Azure.

Si la compétence n'est pas disponible, suivez Utiliser la compétence Microsoft Foundry dans les agents de programmation.

Étape 2 : Demander à la compétence de créer l’agent hébergé

Demandez à votre agent de code d’utiliser la compétence pour le workflow complet de l’agent hébergé :

Use the Microsoft Foundry Skill hosted-agent quick-start workflow to create my
first hosted agent end to end. Verify my environment first, and stop if I need
to sign in myself. Use Python 3.13, Agent Framework, the Responses API, the
Basic sample, and code deployment. Create a new Foundry project unless I provide
an existing project. Use the model deployment from the Basic sample unless I
provide an existing deployment. Test the agent locally, deploy it to Foundry
Agent Service, and invoke it with: "Write a haiku about deploying cloud
applications."

L’agent de codage doit inspecter les outils Foundry disponibles lorsque les outils MCP sont disponibles, charger le flux de travail de démarrage rapide de l’agent hébergé et demander des valeurs manquantes par défaut, telles que l’abonnement, la région, le nom du projet et s’il faut utiliser un projet Foundry existant.

Étape 3 : Examiner et approuver le plan

1. Passez en revue le plan, les fichiers, les commandes, les ressources Azure et les attributions de rôles proposées par l’agent de codage.
2. Pour reproduire ce guide de démarrage rapide, choisissez Python 3.13, Agent Framework, API Responses, l’exemple de code Basic et le déploiement Code.
3. N’approuvez la création de ressources engendrant des coûts qu’après avoir vérifié l’abonnement, la région, le groupe de ressources, le déploiement du modèle et le quota.
4. Si l’agent de codage vous demande d’authentifier, d’exécuter az login et azd auth login de vous-même, puis de demander à l’agent de codage de continuer.

Étape 4 : utiliser la compétence comme structure de base et tester l’agent

Laissez l’agent de codage créer le projet d’agent hébergé, provisionner des ressources lorsque vous choisissez un nouveau projet Foundry, écrivez des valeurs d’environnement local, préparez l’environnement local et exécutez un test de fumée local. Pour les agents Python, le workflow de compétence utilise azd ai agent run pour installer les dépendances lors de la première exécution locale.

Le flux de travail doit également ajouter le fichier d’aide du projet requis par l’hôte de l’agent de codage et vérifier la configuration du projet généré avant le test local.

Si l’hôte de votre agent de codage ne peut pas maintenir un serveur local en cours d’exécution pour le smoke test, utilisez l’onglet Azure Developer CLI dans cet article pour obtenir les commandes de test en local. Vous ne pouvez poursuivre le déploiement qu’après avoir décidé de valider l’agent à distance plutôt.

Étape 5 : Déployer et appeler l’agent hébergé

Une fois le test de fumée local réussi, demandez à votre agent de codage de terminer le déploiement et la validation à distance :

Continue with the Microsoft Foundry Skill workflow. Deploy the hosted agent to
Foundry Agent Service, show the deployment status and playground link, and invoke
it remotely with: "Write a haiku about deploying cloud applications." If the
skill workflow requires evaluation suite generation before the final summary,
submit the generation job and show me the follow-up eval command.

Une fois le flux de travail terminé, l’agent de codage doit afficher le nom de l’agent hébergé, la version, l’état du déploiement, le point de terminaison, le lien de terrain de jeu, les ressources créées, la réponse à l’invite de test et toute commande de suivi d’évaluation.

azd down

Lorsque l’environnement a créé le projet, azd répertorie les ressources, les invite à confirmer et les supprime en environ 2 à 5 minutes.

1. Ouvrez le portail Azure et accédez au groupe de ressources qui contient votre agent.
2. Sélectionnez Supprimer le groupe de ressources, tapez le nom du groupe de ressources pour confirmer, puis sélectionnez Supprimer.

Le canevas crée un espace de travail basé sur azd, vous pouvez donc effectuer le nettoyage avec azd down depuis le dossier de l’espace de travail.

azd down

Lorsque l’environnement a créé le projet, azd répertorie les ressources, les invite à confirmer et les supprime en environ 2 à 5 minutes.

La compétence Microsoft Foundry ne supprime pas les ressources par elle-même. Il peut aider votre agent de codage à identifier les ressources créées par ce guide de démarrage rapide et à choisir la méthode de nettoyage appropriée. Vous ou votre agent de codage exécutez toujours la commande de nettoyage après avoir examiné et approuvé celui-ci.

1. Dans le dossier de projet de l’agent hébergé, demandez à votre agent de codage de passer en revue le nettoyage :

   Use the Microsoft Foundry Skill to identify the Azure resources created for
   this quickstart. Confirm whether azd down is the right cleanup method for
   this project, and show me the resources before any deletion command runs.
   

2. Si le projet d’agent hébergé a été créé avec azd et que le groupe de ressources contient uniquement des ressources de démarrage rapide, exécutez :

   azd down
   

3. Approuvez la suppression uniquement après avoir vérifié le groupe de ressources et les ressources que les commandes répertorient.

Si votre agent de codage ne peut pas exécuter de commandes de nettoyage, utilisez l'onglet cli Azure développeur dans cet article ou supprimez le groupe de ressources du portail Azure.