Snabbstart: Distribuera din första värdbaserade agent

• Azure Developer CLI (azd) 1.27.1 eller senare.

• Tillägget azd microsoft.foundry . Installera och verifiera tillägget när azd det har installerats:

  azd ext install microsoft.foundry
  

• En autentiserad azd-session. Logga in när du har installerat tillägget:

  azd auth login
  

• Python 3.13 eller senare.

• Azure CLI installerat och autentiserat:

  az login
  

• De Python SDK-paket som används i den här snabbstarten:

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

• Ett befintligt Foundry-projekt med en distribuerad modell. Metoden med Python SDK i den här snabbstarten skapar och konfigurerar routning för en hostad agentversion, men skapar varken ett nytt Foundry-projekt eller en modellimplementering åt dig. Om du behöver det fullständiga etableringsarbetsflödet använder du fliken Azure Developer CLI i den här artikeln.

• .NET 10 SDK.

• Azure CLI installerat och autentiserat:

  az login
  

• De .NET paket som används i den här snabbstarten.

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

  Note

  API:er för källkodsdistribution är för närvarande tillgängliga i en förhandsversion av Azure.AI.Projects. Det stabila 2.0.x-paketet innehåller inte dessa API:er.

• Ett befintligt Foundry-projekt med en distribuerad modell. C# SDK-sökvägen skapar och dirigerar en värdbaserad agentversion, men den skapar inte ett Foundry-projekt eller modelldistribution. För det fullständiga etableringsarbetsflödet använder du fliken Azure Developer CLI.

• Visual Studio Code.
• Microsoft Foundry Toolkit för Visual Studio Code.

• GitHub Copilot App.

• Tillägget Microsoft Foundry Canvas. Om du vill installera det öppnar du GitHub Copilot-appen och går till Inställningar>Plugin-program, söker efter microsoft-foundry och väljer Installera. Mer information finns i Vad är Microsoft Foundry Canvas?

• Azure Developer CLI (azd) 1.27.1 eller senare. Ytan använder azd för att testa och distribuera agenten.

• Tillägget azd microsoft.foundry . Installera och verifiera tillägget när azd det har installerats:

  azd ext install microsoft.foundry
  

• En värd för en kodningsagent med den Microsoft Foundry Skill installerad.

• Azure CLI och Azure Developer CLI (azd) installerat och autentiserat:

  az login
  azd auth login
  

Steg 1: Initialisera exempelagent

Initiera en ny värdbaserad agent med hjälp av det grundläggande Agent Framework-exemplet i en tom katalog:

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

De interaktiva flödesprompterna för:

• Agentnamn: Anpassa namnet eller acceptera standardsvarenagent-framework-agent-basic-responses
• Foundry Project: Välj Skapa en ny Foundry-project eller Använd en befintlig Foundry-project
• Tenant: Välj din Azure-klientorganisation
• Prenumeration: Välj din Azure-prenumeration
• Location: Välj en Azure region
• Modell: Välj standard,gpt-5.4-mini eller en annan modell som du kan komma åt
• Modellversion: Välj standardalternativet
• Modell-SKU: Välj ett alternativ med tillgänglig kvot som inte är Batch, vanligtvis Standard eller GlobalStandard
• Distributionskapacitet: Välj standardvärdet10
• Distributionsnamn: Välj standardvärdetgpt-5.4-mini

När du är klar ser du ai-agentdefinitionen som har lagts till i azd-projektet! Ändra katalogen till den nyligen skapade agentmappen.

cd agent-framework-agent-basic-responses

Steg 2: Etablera Azure resurser

Etablera de resurser som definierats i azure.yaml:

azd provision

Steg 3: Testa agenten lokalt

azd ai agent run

Det här kommandot skapar en virtuell miljö, installerar beroenden, startar agenten med hjälp av den startupCommand definierade i azure.yamloch öppnar agentkontrollen i webbläsaren så att du kan chatta med agenten.

Steg 4: Distribuera till Foundry Agent Service

Distribuera agentens källkod. azd paketera källan som en ZIP-fil och laddar upp den till Foundry. Foundry löser beroenden, bygger den värdbaserade agenten via fjärranslutning och distribuerar den:

azd deploy

När kommandot är klart visar utdata länkar till agentens lekplats och agentslutpunkten:

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

Steg 5: Anropa din agent

1. Skicka samma fråga till den distribuerade agenten:

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

   Du bör se ett haiku-svar inom några sekunder.

2. (Valfritt) Strömma containerloggar medan du interagerar med agenten:

   azd ai agent monitor --follow
   

Steg 1: Skapa eller välj ett Foundry-projekt

1. Öppna Foundry-portalen och skapa ett Foundry-projekt eller välj ett befintligt.

2. I projektet distribuerar du en chattkompatibel modell som gpt-5.4-mini.

3. Kopiera dessa värden från portalen:

   • Projektslutpunkt i Översikt.
   • Distributionsnamn från Build>Distributioner.

Steg 2: Ladda ned standardexempelagentkoden

Klona lagringsplatsen med Foundry-exempel.

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

Steg 3: Skapa en Python miljö och konfigurera inställningar

Skapa en virtuell miljö och installera de Python paket som krävs för den här snabbstarten.

För macOS eller Linux:

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

För Windows (PowerShell):

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

Skapa en arbetsmapp för distributionsskriptet och skapa sedan en .env fil i mappen:

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>

Steg 4: Distribuera den värdbaserade agenten med Python

Skapa en fil med namnet deploy_hosted_agent.py i samma arbetsmapp som .env med följande innehåll:

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

Kör skriptet:

python deploy_hosted_agent.py

Skriptet zippar exempelkällan, laddar upp den som en ny värdbaserad agentversion, väntar på att etableringen ska slutföras, dirigerar tillfälligt den värdbaserade agentslutpunkten till den versionen, anropar den distribuerade agenten och återställer sedan den tidigare slutpunktskonfigurationen och tar bort den tillfälliga versionen.

Steg 5: Anropa din agent

När skriptet har slutförts använder du den värdbaserade agenten på något av följande sätt:

1. Redigera deploy_hosted_agent.py och ändra värdet som input skickades till openai_client.responses.create(...)och kör sedan skriptet igen.
2. Om du vill ha en beständig routningsversion i stället för en tillfällig valideringsdistribution kan du anpassa skriptet så att det hoppar över återställningen och delete_version(...) stegen när du har granskat trafikdirigeringskonsekvenserna.
3. Om du använde exempelskriptet som skrivet återställer det redan slutpunktskonfigurationen och tar bort den tillfälliga värdbaserade agentversionen efter valideringen.
4. Om du har skapat en dedikerad resursgrupp för den här snabbstarten kan du ta bort resursgruppen från Azure-portalen när du inte längre behöver projekt- eller modelldistributionen.

Steg 1: Skapa eller välj ett Foundry-projekt

1. Öppna Foundry-portalen och skapa ett Foundry-projekt eller välj ett befintligt.

2. I projektet distribuerar du en chattkompatibel modell som gpt-5.4-mini.

3. Kopiera dessa värden från portalen:

   • Projektslutpunkt i Översikt.
   • Distributionsnamn från Build>Distributioner.

Steg 2: Ladda ned C#-hello-world-agenten

Klona Foundrys exempellagringsplats:

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

Agentkällan finns i samples/csharp/hosted-agents/agent-framework/hello-world/src/hello-world-dotnet-agent-framework.

Steg 3: Skapa ett C#-distributionsprojekt

Skapa ett konsolprogram och installera de paket som krävs:

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

Ange de värden som distributionsprogrammet använder. Kör i PowerShell:

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

Kör för macOS eller Linux:

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

Steg 4: Distribuera den värdbaserade agenten med C#

Ersätt innehållet i Program.cs med följande kod. .NET SDK-paket och laddar upp källkatalogen, så du behöver inte skapa ZIP-arkivet själv.

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

Koden följer mönster för källuppladdning och slutpunktsroutning från Azure SDKs för .NET kodagentexempel.

Kör programmet:

dotnet run

Programmet laddar upp C#-agentkällan, väntar på etablering, dirigerar agentslutpunkten till den nya versionen, skickar en uppmaning, återställer föregående väg och tar bort den tillfälliga versionen.

Steg 5: Anropa din agent

När programmet har slutförts använder du den värdbaserade agenten på något av följande sätt:

1. I Program.cs ändrar du prompten som skickas till CreateResponseAsync, och kör sedan dotnet run igen.
2. Om du vill behålla den dirigerade versionen tar du bort slutpunktsåterställning och DeleteAgentVersionAsync anrop när du har granskat trafikdirigeringspåverkan.
3. Om du använde C#-programmet som skrivet återställs slutpunktskonfigurationen och den tillfälliga värdbaserade agentversionen tas bort efter valideringen.
4. Om du har skapat en dedikerad resursgrupp för den här snabbstarten tar du bort resursgruppen från Azure-portalen när du inte längre behöver projektet eller modelldistributionen.

Steg 1: Skapa ett Foundry-projekt

1. Öppna kommandopaletten (Ctrl+Skift+P) och välj Foundry Toolkit: Create Project.
2. Välj din Azure prenumeration.
3. Skapa en ny resursgrupp eller välj en befintlig.
4. Ange ett namn för Foundry-projektet.

Steg 2: Distribuera en modell

1. Öppna kommandopaletten och välj Foundry Toolkit: Öppna modellkatalogen.
2. Sök gpt-4.1 efter och välj Distribuera.
3. På sidan för modelldistribution väljer du Distribuera till Microsoft Foundry.

Steg 3: Skapa ett värdbaserat agentprojekt

1. Öppna kommandopaletten och välj Foundry Toolkit: Skapa ny värdbaserad agent.
2. Välj Python som språk.
3. För Framework väljer du Agent Framework.
4. Välj Svars-API som protokolltyp.
5. Välj Grundläggande som exempelkod.
6. Välj knappen Nästa.
7. Välj en mapp för projektfilerna och ange ett namn för agenten.
8. För Miljöinstallation väljer du Konfigurera med Microsoft Foundry. Innehållet fylls i automatiskt med projektet och modellen som du skapade i steg 1 och 2.
9. Välj knappen Skapa.

Ett nytt VS Code-fönster öppnas med projektet som aktiv arbetsyta.

Steg 4: Installera beroenden

Skapa en virtuell miljö och installera kraven.

För macOS eller Linux:

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

För Windows (PowerShell):

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

Steg 5: Testa agenten lokalt

Tryck på F5 för att starta den lokala HTTP-servern med felsökning aktiverat. Foundry Toolkit Agent Inspector öppnas för interaktiv testning och du kan ange brytpunkter i koden.

Så här kör du servern utan felsökning:

python main.py

Agenten lyssnar på http://localhost:8088/. Skicka en testprompt med curl (eller någon HTTP-klient):

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

Steg 6: Distribuera till Foundry Agent Service

1. Öppna Kommandopaletten och välj Foundry Toolkit: Deploy Hosted Agent. En webbvy för distribution öppnas.
2. Som Distributionsmetod väljer du Kod.
3. Välj Fjärr som paketläge.
4. Agentnamnet fylls i automatiskt.
5. Välj knappen Nästa.
6. Sidan Granska och distribuera fylls i automatiskt.
7. Välj knappen Distribuera .

När distributionen är slutförd visas agenten under Hosted Agents i Foundry Toolkits utforskare.

Steg 7: Anropa din agent

1. I Foundry Toolkits utforskare expanderar du Värdbaserade agenter och väljer din agent. Informationssidan visar statusen under Distributionsinformation.
2. Välj fliken Lekplats och skicka en testfråga, till exempel Write a haiku about deploying cloud applications..

Microsoft Foundry Canvas vägleder dig genom att skapa och distribuera en värdbaserad agent från en sidopanel i GitHub Copilot-appen. När du gör val på arbetsytan skickas varje steg till Copilot med relevant kontext från ditt Foundry-projekt.

Steg 1: Öppna arbetsytan

1. I GitHub Copilot-appen ber du Copilot att skapa en Foundry-värdagent. Ett exempel:

   Create a Foundry hosted agent using Microsoft Foundry Canvas
   

2. Ritytan öppnas i den högra panelen. Om den inte öppnas automatiskt öppnar du den från den högra panelen.

Arbetsytan vägleder dig genom tre steg som motsvarar följande:

• Skapa en värdbaserad agent. Välj ditt Foundry-projekt och berätta för Copilot vad du vill skapa. Du kan utgå från en färdigskriven prompt för att snabba upp arbetet.
• Skapa den värdbaserade agenten. Välj modell, verktygslådor, färdigheter och skyddsräcken för din agent från resurserna i ditt Foundry-projekt.
• Distribuera och testa. Testa agenten lokalt och distribuera den till Foundry Agent Service när du är nöjd.

Steg 2: Ansluta ett Foundry-projekt

1. Öppna projektmenyn i Canvas och logga in på Azure om du uppmanas att göra det.
2. Välj en prenumeration.
3. Välj ett Foundry-projekt. Arbetsytan behåller den här markeringen när du öppnar den igen.

Steg 3: Skapa grundstrukturen för agenten

Välj hur du ska börja:

• Välj Inspirera mig för att skapa en värdbaserad agent från en genererad idé.
• Välj hello world-exempelprompten för att starta från en grundläggande agent.

Copilot skapar agentkodens struktur i arbetsytan utifrån ditt val.

Steg 4: Konfigurera agenten

I det här steget ansluter du agenten till resurserna i ditt Foundry-projekt. Varje val skickar en uppmaning till Copilot, som uppdaterar agentkoden och konfigurationen åt dig:

1. Välj en distribuerad modell för att driva agentens resonemang.
2. Anslut Foundry Toolboxes och deras verktyg för att ge agentfunktionerna, till exempel att anropa API:er eller köra kod.
3. Anslut skills som paketerar återanvändbar logik som agenten kan använda.
4. Tilldela skyddsräcken för att tillämpa säkerhets- och innehållskontroller.

Steg 5: Testa agenten lokalt

1. Välj Inspektera lokalt. Arbetsytan kör azd ai agent run i den Copilot-integrerade terminalen, väntar på agenten på port 8088 och inbäddar Agent Inspector.

2. Skicka en testprompt, till exempel:

   Write a haiku about deploying cloud applications.
   

3. Om inspektören rapporterar ett fel kopierar du felmeddelandet till promptområdet på arbetsytan och du ber Copilot att åtgärda problemet.

Steg 6: Distribuera till Foundry Agent Service

1. Välj Distribuera till Foundry. Arbetsytan använder azd och Copilot för att distribuera din värdbaserade agent.
2. När distributionen är klar använder du länkarna i utdata för att öppna agentlekplatsen i Foundry-portalen.

Steg 1: Öppna en arbetsyta med Foundry Skill

Öppna en tom mapp i kodningsagentens värd, till exempel GitHub Copilot i Visual Studio Code, Copilot CLI eller Claude Code. Bekräfta att kunskapen microsoft-foundry är tillgänglig innan du ber kodningsagenten att skapa Azure resurser.

Om kunskapen inte är tillgänglig följer du Använd Microsoft Foundry Skill i kodningsagenter.

Steg 2: Be funktionen skapa den värdbaserade agenten

Be kodningsagenten att använda färdigheten för det fullständiga arbetsflödet för värdbaserad agent:

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

Kodagenten bör granska de tillgängliga Foundry-verktygen när MCP-verktyg är tillgängliga, läsa in snabbstartsarbetsflödet för den värdbaserade agenten och be om saknade värden eller använda standardvärden för dem, till exempel prenumeration, region, projektnamn och om ett befintligt Foundry-projekt ska användas.

Steg 3: Granska och godkänna planen

1. Granska planen, filer, kommandon, Azure resurser och rolltilldelningar som kodningsagenten föreslår.
2. Om du vill matcha den här snabbstarten väljer du Python 3.13, Agent Framework, Svars-API, Grundläggande exempelkod och Koddistribution.
3. Godkänn skapande av kostnadsbärande resurser först när du har verifierat prenumerationen, regionen, resursgruppen, modelldistributionen och kvoten.
4. Om kodningsagenten ber dig att autentisera dig, kör az login och azd auth login själv och be sedan kodningsagenten att fortsätta.

Steg 4: Låt färdigheten bygga upp och testa agenten

Låt kodningsagenten skapa det värdbaserade agentprojektet, etablera resurser när du väljer ett nytt Foundry-projekt, skriva lokala miljövärden, förbereda den lokala miljön och köra ett lokalt röktest. För Python-agenter använder skill-arbetsflödet azd ai agent run för att installera beroenden vid den första lokala körningen.

Arbetsflödet bör också lägga till den projektvägledningsfil som krävs av kodningsagentens värd och sanity-checka den genererade projektkonfigurationen före det lokala testet.

Om kodagentvärden inte kan hålla en lokal server igång för röktestet använder du fliken Azure Developer CLI i den här artikeln för de lokala testkommandona. Du kan fortsätta att distribuera först när du har bestämt dig för att verifiera agenten via fjärranslutning i stället.

Steg 5: Distribuera och anropa den värdbaserade agenten

När det lokala röktestet har slutförts ber du kodningsagenten att slutföra distributionen och fjärrverifieringen:

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.

När arbetsflödet har slutförts bör kodningsagenten visa värdbaserad agentnamn, version, distributionsstatus, slutpunkt, playground-länk, resurser som skapats, svaret på testprompten och eventuella utvärderingsuppföljningskommandon.

azd down

När miljön har skapat projektet listar azd resurserna, ber om bekräftelse och tar bort dem på cirka 2–5 minuter.

1. Öppna Azure-portalen och gå till resursgruppen som innehåller din agent.
2. Välj Ta bort resursgrupp, skriv namnet på resursgruppen för att bekräfta och välj Ta bort.

Arbetsytan skapar en azd-backad arbetsyta, så du rensar med azd down från arbetsytans mapp.

azd down

När miljön har skapat projektet listar azd resurserna, ber om bekräftelse och tar bort dem inom cirka 2–5 minuter.

Microsoft Foundry Skill tar inte bort resurser på egen hand. Det kan hjälpa kodningsagenten att identifiera de resurser som den här snabbstarten skapade och välja rätt rensningsmetod. Du eller din kodningsagent kör fortfarande rensningskommandot när du har granskat och godkänt det.

1. I projektmappen värdbaserad agent ber du kodningsagenten att granska rensningen:

   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. Om det värdbaserade agentprojektet skapades med azd och resursgruppen endast innehåller snabbstartsresurser kör du:

   azd down
   

3. Godkänn endast borttagning när du har verifierat resursgruppen och resurserna som kommandot visar.

Om kodningsagenten inte kan köra rensningskommandon använder du fliken Azure Developer CLI i den här artikeln eller tar bort resursgruppen från Azure-portalen.