Wdrażanie hostowanego agenta na podstawie kodu źródłowego

• pip w Pythonie 3.13 lub nowszym, aby spakować kod źródłowy lokalnie.

• Pakiety azure-ai-projects w wersji 2.2.0 lub nowszej oraz azure-identity.

  pip install "azure-ai-projects>=2.2.0" azure-identity
  

• Pakiet SDK platformy .NET 10, aby lokalnie spakować kod źródłowy.

• Pakiety Azure.AI.Projects.Agents i Azure.Identity.

  dotnet add package Azure.AI.Projects.Agents --prerelease
  dotnet add package Azure.Identity
  

  Note

  Interfejsy API wdrażania kodu źródłowego dla .NET są obecnie dostępne tylko w wersji wstępnej programu Azure.AI.Projects.Agents. Użyj flagi --prerelease , aby ją zainstalować. Te interfejsy API nie są jeszcze uwzględnione w stabilnej wersji (GA).

• Node.js 22 lub nowszy, aby spakować kod źródłowy lokalnie.

• Pakiety @azure/ai-projects i @azure/identity. Uruchamiasz element wywołujący w Node.js, ale wdrażane hostowane środowisko uruchomieniowe nadal opiera się na kodzie źródłowym w Pythonie lub .NET.

  npm install @azure/ai-projects @azure/identity
  

• Klient HTTP uruchamiany z wiersza polecenia, taki jak curl (przykłady REST w tym artykule korzystają z curl).
• Aby spakować źródło lokalnie, zainstaluj łańcuch narzędzi dla języka agenta: pip z wersji Python 3.13 lub nowszej albo zestawu SDK .NET 10.

Użyj zestawu SDK Python, aby wdrożyć agentów kodu źródłowego z własnych aplikacji lub automatyzacji. Skompilujesz plik zip samodzielnie i przekażesz jego bajty oraz algorytm SHA-256 do zestawu SDK, który przekazuje go i uwidacznia te same operacje tworzenia, sondowania, wywoływania i pobierania co interfejs API REST. Wdrożenie kodu wymaga azure-ai-projects wersji 2.2.0 lub nowszej.

Kompilowanie pliku zip

SDK języka Python przesyła plik ZIP, który tworzysz. Użyj tego samego układu i zasad rozwiązywania zależności, które opisano w sekcji Ręczne pakowanie pliku zip. Minimalny pakiet remote_build to płaskie archiwum ZIP z main.py i requirements.txt w katalogu głównym.

Tworzenie agenta

import hashlib
from pathlib import Path

from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
    CodeConfiguration,
    HostedAgentDefinition,
    ProtocolVersionRecord,
)
from azure.identity import DefaultAzureCredential

# Format: "https://<account>.services.ai.azure.com/api/projects/<project>"
PROJECT_ENDPOINT = "your_project_endpoint"
AGENT_NAME = "my-code-agent"
ZIP_PATH = Path("agent-code.zip")

code_zip_bytes = ZIP_PATH.read_bytes()
code_zip_sha256 = hashlib.sha256(code_zip_bytes).hexdigest()

credential = DefaultAzureCredential()
project = AIProjectClient(
    endpoint=PROJECT_ENDPOINT,
    credential=credential,
)

created = project.agents.create_version_from_code(
    agent_name=AGENT_NAME,
    definition=HostedAgentDefinition(
        cpu="1",
        memory="2Gi",
        code_configuration=CodeConfiguration(
            runtime="python_3_13",
            entry_point=["python", "main.py"],
            dependency_resolution="remote_build",
        ),
        protocol_versions=[
            ProtocolVersionRecord(protocol="responses", version="2.0.0")
        ],
        environment_variables={"AZURE_AI_MODEL_DEPLOYMENT_NAME": "gpt-5.4-mini"},
    ),
    code=(ZIP_PATH.name, code_zip_bytes, "application/zip"),
    code_zip_sha256=code_zip_sha256,
    description="Hello-world code agent",
)
print(f"Created version: {created.version}")

Dla protokołu Invocations ustaw wpis protocol_versions na ProtocolVersionRecord(protocol="invocations", version="2.0.0"). W przypadku protokołu Invocations (WebSocket) użyj ProtocolVersionRecord(protocol="invocations_ws", version="2.0.0"). W przypadku bundled trybu ustaw dependency_resolution="bundled" i uwzględnij wstępnie utworzone zależności w pliku zip. Aby uzyskać więcej informacji, zobacz Build Linux dependencies locally (Tworzenie zależności systemu Linux lokalnie).

Sonduj jako aktywne

import time

while True:
    version = project.agents.get_version(
        agent_name=AGENT_NAME, agent_version=created.version
    )
    status = version["status"]
    print(f"Status: {status}")
    if status == "active":
        break
    if status == "failed":
        raise RuntimeError(f"Provisioning failed: {version.get('error')}")
    time.sleep(5)

Zobacz Poll for active, aby uzyskać pełną listę wartości stanu i informacje o tym, jak odczytywać obiekt error w razie błędu.

Wywoływanie agenta

Gdy wersja osiągnie active, przypisz klienta OpenAI do punktu końcowego agenta i wywołaj go. W tym przykładzie użyto protokołu Responses:

openai_client = project.get_openai_client(agent_name=AGENT_NAME)

response = openai_client.responses.create(input="Hello! What can you do?")
print(response.output_text)

W przypadku protokołu Invocations wywołaj bezpośrednio punkt końcowy invoke za pomocą tokenu bearer, jak pokazano w sekcji Wywoływanie agenta.

Pobieranie wdrożonego pliku zip

Sprawdź dokładnie, co zostało wdrożone, pobierając plik zip i porównując jego algorytm SHA-256 z przekazaną wartością:

import hashlib
from pathlib import Path

out_path = Path(f"{AGENT_NAME}-{created.version}.zip")
sha = hashlib.sha256()
with open(out_path, "wb") as f:
    for chunk in project.agents.download_code(
        agent_name=AGENT_NAME, agent_version=created.version
    ):
        f.write(chunk)
        sha.update(chunk)

print(f"Downloaded {out_path} (matches upload: {sha.hexdigest() == code_zip_sha256})")

Aby zobaczyć kompletny, w pełni działający przykład, przejrzyj przykłady hostowanego agenta w języku Python.

Użyj zestawu SDK .NET, aby wdrożyć agentów kodu źródłowego z własnych aplikacji lub automatyzacji. W przeciwieństwie do podejść opartych na Pythonie i REST, zestaw SDK .NET automatycznie pakuje folder źródłowy do pliku ZIP — wystarczy podać ścieżkę do folderu zamiast samodzielnie tworzyć plik ZIP.

Tworzenie agenta

using System;
using Azure.AI.Projects.Agents;
using Azure.Identity;

// Format: "https://<account>.services.ai.azure.com/api/projects/<project>"
string projectEndpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT");

var agentsClient = new AgentAdministrationClient(
    endpoint: new Uri(projectEndpoint),
    tokenProvider: new DefaultAzureCredential());

var agentDefinition = new HostedAgentDefinition(cpu: "1", memory: "2Gi")
{
    Versions = { new ProtocolVersionRecord(ProjectsAgentProtocol.Responses, "2.0.0") },
    CodeConfiguration = new(
        runtime: "dotnet_10",
        entryPoint: ["dotnet", "MyAgent.dll"],
        dependencyResolution: CodeDependencyResolution.RemoteBuild),
};

var metadata = new AgentVersionFromCodeMetadata(agentDefinition);

ProjectsAgentVersion agentVersion = agentsClient.CreateAgentVersionFromCode(
    agentName: "my-code-agent",
    filePath: "./AgentCode",
    metadata: metadata);

Console.WriteLine($"Created version: {agentVersion.Version}");

W przypadku remote_build wskaż filePath w folderze źródeł projektu .NET. Usługa agenta uruchamia dotnet restore i dotnet publish za Ciebie podczas aprowizacji. Element entryPoint odnosi się do opublikowanej nazwy zestawu — na przykład ["dotnet", "MyAgent.dll"] dla projektu o nazwie MyAgent.csproj.

W przypadku protokołu Invocations zmień Versions wpis na new ProtocolVersionRecord(ProjectsAgentProtocol.Invocations, "2.0.0"). W przypadku protokołu Invocations (WebSocket) użyj new ProtocolVersionRecord(ProjectsAgentProtocol.InvocationsWs, "2.0.0"). W przypadku bundled trybu ustaw dependencyResolution: CodeDependencyResolution.Bundled i wskaż filePath folder zawierający dotnet publish dane wyjściowe. Zobacz Kompilowanie danych wyjściowych platformy .NET (w pakiecie).

Sonduj jako aktywne

while (agentVersion.Status != AgentVersionStatus.Active &&
       agentVersion.Status != AgentVersionStatus.Failed)
{
    Thread.Sleep(500);
    agentVersion = agentsClient.GetAgentVersion(
        agentName: agentVersion.Name,
        agentVersion: agentVersion.Version);
}

if (agentVersion.Status != AgentVersionStatus.Active)
{
    throw new InvalidOperationException($"Deployment failed, status: {agentVersion.Status}");
}

Pobieranie wdrożonego kodu

Pobierz i wyodrębnij wdrożony kod do katalogu lokalnego, aby sprawdzić, co działa. Pakiet SDK zapisuje rozpakowaną zawartość w lokalizacji path:

agentsClient.DownloadAgentCode(agentName: agentVersion.Name, path: "./downloaded");
Console.WriteLine("Downloaded agent code to ./downloaded");

Aby zobaczyć kompletny działający przykład, zobacz przykłady hostowanego agenta .NET.

Użyj zestawu SDK języka JavaScript/TypeScript, aby wdrożyć agentów kodu źródłowego z własnych aplikacji lub automatyzacji. Moduł wywołujący SDK działa w Node.js, ale wdrażane hostowane środowisko uruchomieniowe może być oparte na kodzie źródłowym w języku Python lub .NET — nie ma hostowanego środowiska uruchomieniowego agenta dla Node.js. Skompilujesz plik zip samodzielnie i przekażesz jego bajty oraz algorytm SHA-256 do zestawu SDK, który przekazuje go i uwidacznia te same operacje tworzenia, sondowania, wywoływania i pobierania co interfejs API REST.

Kompilowanie pliku zip

Pakiet SDK dla języków JavaScript/TypeScript przesyła utworzone przez Ciebie archiwum ZIP. Użyj tego samego układu i zasad rozwiązywania zależności, które opisano w sekcji Ręczne pakowanie pliku zip. Minimalny remote_build pakiet dla środowiska uruchomieniowego języka Python to płaskie archiwum ZIP z plikami main.py i requirements.txt w katalogu głównym.

Tworzenie agenta

npm install @azure/ai-projects @azure/identity

import { createHash } from "node:crypto";
import { readFileSync } from "node:fs";
import { AIProjectClient } from "@azure/ai-projects";
import { DefaultAzureCredential } from "@azure/identity";

// Format: "https://<account>.services.ai.azure.com/api/projects/<project>"
const projectEndpoint =
  process.env["FOUNDRY_PROJECT_ENDPOINT"] || "your_project_endpoint";
const agentName = "my-code-agent";

const codeZip = readFileSync("agent-code.zip");
const codeZipSha256 = createHash("sha256").update(codeZip).digest("hex");

const project = new AIProjectClient(
  projectEndpoint,
  new DefaultAzureCredential(),
);

// The hosted runtime is Python here; the caller SDK is
// JavaScript/TypeScript. To deploy .NET source instead, set
// runtime to "dotnet_10" and entry_point to ["dotnet", "MyAgent.dll"].
const created = await project.agents.createVersionFromCode(
  agentName,
  codeZipSha256,
  {
    metadata: {
      description: "Hello-world code agent",
      definition: {
        kind: "hosted",
        cpu: "1",
        memory: "2Gi",
        code_configuration: {
          runtime: "python_3_13",
          entry_point: ["python", "main.py"],
          dependency_resolution: "remote_build",
        },
        protocol_versions: [{ protocol: "responses", version: "2.0.0" }],
        environment_variables: {
          AZURE_AI_MODEL_DEPLOYMENT_NAME: "gpt-5.4-mini",
        },
      },
    },
    code: {
      contents: codeZip,
      contentType: "application/zip",
      filename: "agent-code.zip",
    },
  },
);
console.log(`Created version: ${created.version}`);

Dla protokołu Invocations ustaw wpis protocol_versions na { protocol: "invocations", version: "2.0.0" }. W przypadku protokołu Invocations (WebSocket) użyj { protocol: "invocations_ws", version: "2.0.0" }. W przypadku bundled trybu ustaw dependency_resolution: "bundled" i uwzględnij wstępnie utworzone zależności w pliku zip.

Sonduj jako aktywne

function sleep(ms: number) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

for (;;) {
  await sleep(5_000);
  const version = await project.agents.getVersion(
    agentName,
    created.version,
  );
  console.log(`Status: ${version.status}`);
  if (version.status === "active") {
    break;
  }
  if (version.status === "failed") {
    throw new Error(`Provisioning failed: ${JSON.stringify(version)}`);
  }
}

Zobacz Poll for active, aby uzyskać pełną listę wartości stanu i informacje o tym, jak odczytywać obiekt error w razie błędu.

Wywoływanie agenta

Gdy wersja osiągnie active, przypisz klienta OpenAI do punktu końcowego agenta i wywołaj go. W tym przykładzie użyto protokołu Responses:

const openAIClient = project.getOpenAIClient({
  azureConfig: { allowPreview: true, agentName },
});

const response = await openAIClient.responses.create({
  input: "Hello! What can you do?",
});
console.log(response.output_text);

W przypadku protokołu Invocations wywołaj bezpośrednio punkt końcowy invoke za pomocą tokenu bearer, jak pokazano w sekcji Wywoływanie agenta.

Pobieranie wdrożonego pliku zip

Sprawdź, co zostało wdrożone, pobierając plik zip i porównując jego wartość SHA-256 z przekazaną wartością:

import { createHash } from "node:crypto";
import { writeFileSync } from "node:fs";
import { buffer } from "node:stream/consumers";

const downloadResult = await project.agents.downloadAgentCode(agentName, {
  agentVersion: created.version,
});

// The result carries either a Node.js stream (readableStreamBody) or a
// browser Blob (blobBody), depending on the runtime. Handle both so the
// code compiles under strict TypeScript and works in either environment.
const downloadedBytes = downloadResult.readableStreamBody
  ? new Uint8Array(await buffer(downloadResult.readableStreamBody))
  : downloadResult.blobBody
    ? new Uint8Array(await (await downloadResult.blobBody).arrayBuffer())
    : undefined;

if (!downloadedBytes) {
  throw new Error("No content found in the downloaded agent code.");
}

const downloadedSha256 = createHash("sha256")
  .update(downloadedBytes)
  .digest("hex");

writeFileSync(`${agentName}-${created.version}.zip`, downloadedBytes);
console.log(
  `Downloaded (matches upload: ${downloadedSha256 === codeZipSha256})`,
);

Dokumentacja: AIProjectClient

Interfejs API REST można używać do bezpośrednich wdrożeń opartych na protokole HTTP lub niestandardowych narzędzi. W kolejnych sekcjach omówiono pierwsze wdrożenie krok po kroku: skonfigurowanie zmiennych, utworzenie archiwum ZIP, utworzenie agenta, sprawdzanie stanu aż do active oraz jego wywołanie. Punkty końcowe aktualizacji, wersji, pobierania i strumieniowego przesyłania dzienników są zgrupowane w sekcji Operacje w toku.

Wdrażanie przy użyciu interfejsu API REST

Użyj interfejsu API REST do bezpośrednich wdrożeń opartych na protokole HTTP lub niestandardowych narzędzi. W poniższych sekcjach omówiono pierwsze wdrożenie po kolei: skonfigurowanie zmiennych, utworzenie archiwum ZIP, utworzenie agenta, odpytywanie aż do active i wywołanie go. Punkty końcowe aktualizacji, wersji, pobierania i strumieniowego przesyłania dzienników są zgrupowane w sekcji Operacje w toku.

Konfigurowanie zmiennych

Bash

ENDPOINT="https://{account}.services.ai.azure.com/api/projects/{project}"
API_VERSION="v1"
TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
AGENT=my-code-agent
AGENT_VERSION=1
ZIP=./agent-code.zip
SHA=$(sha256sum "$ZIP" | cut -d' ' -f1)

PowerShell

$Endpoint    = "https://{account}.services.ai.azure.com/api/projects/{project}"
$ApiVersion  = "v1"
$Token       = az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv
$Agent       = "my-code-agent"
$Zip         = "./agent-code.zip"
$Sha         = (Get-FileHash $Zip -Algorithm SHA256).Hash.ToLower()

Tworzenie minimalnego pliku zip hello-world

Przed wywołaniem metody Create utwórz płaskie archiwum ZIP zawierające dwa pliki. Jest to minimalny ładunek danych akceptowany przez usługę Agent Service dla wdrożenia w języku Python remote_build.

agent-code.zip
+-- main.py            # your agent loop (starts a Foundry hosting server)
+-- requirements.txt   # dependencies (for example, agent-framework, agent-framework-foundry-hosting)

metadata.json (definicja agenta pokazana w przykładzie metadanych) znajduje się obok pliku zip na dysku i jest wysyłana jako oddzielna część wieloczęściowa — nie znajduje się w pliku zip. Aby uzyskać pełne układy plików (w tym tryb bundled i platformę .NET), zobacz Ręczne pakowanie pliku zip. Aby uzyskać informacje o plikach źródłowych roboczych, zobacz przykłady Python i .NET.

Kształt żądania wieloczęściowego

Wszystkie endpointy modyfikujące dane (Create, Update) używają multipart/form-data, złożonego z dwóch części:

Wymagane nagłówki dla każdego żądania wieloczęściowego:

Authorization: Bearer <token>
Accept: application/json
x-ms-code-zip-sha256: <sha256-hex-of-zip>

Nagłówek x-ms-code-zip-sha256 zawiera wartość SHA-256 przesłanego archiwum ZIP. Usługa przechowuje tę wartość i odsyła ją z powrotem w elemencie code:download, dzięki czemu można wykryć rozbieżność między tym, co miało zostać wdrożone, a tym, co zostało wdrożone. Zawsze dołączaj go.

Wywołanie Create wymaga również elementu x-ms-agent-name: <agent-name>. Wywołania aktualizacji pomijają ją, ponieważ nazwa jest już częścią adresu URL.

Przykład metadanych (kompilacja zdalna, odpowiedzi)

Te metadane są zgodne z plikiem zip hello-world.

{
  "description": "Hello-world code agent",
  "definition": {
    "kind": "hosted",
    "protocol_versions": [
      { "protocol": "responses", "version": "2.0.0" }
    ],
    "cpu": "1",
    "memory": "2Gi",
    "code_configuration": {
      "runtime": "python_3_13",
      "entry_point": ["python", "main.py"],
      "dependency_resolution": "remote_build"
    },
    "environment_variables": {
      "AZURE_AI_MODEL_DEPLOYMENT_NAME": "gpt-5.4-mini"
    }
  }
}

W przypadku protokołu Invocations zastąp wpis protocol_versions wpisem { "protocol": "invocations", "version": "2.0.0" }. W przypadku protokołu Invocations (WebSocket) użyj { "protocol": "invocations_ws", "version": "2.0.0" }. W trybie bundled ustaw "dependency_resolution": "bundled" i postępuj zgodnie z instrukcjami w Kompilowanie zależności systemu Linux lokalnie.

code_configuration i container_configuration wzajemnie wykluczają się w definicji agenta: uwzględnij code_configuration wdrożenie kodu źródłowego (ten artykuł) lub container_configuration wdrożenie oparte na obrazie. Zobacz Wdrażanie hostowanego agenta (kontenera) dla wariantu obrazu.

Tworzenie agenta

curl -X POST "$ENDPOINT/agents?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/json" \
  -H "x-ms-agent-name: $AGENT" \
  -H "x-ms-code-zip-sha256: $SHA" \
  -F "metadata=@metadata.json;type=application/json" \
  -F "code=@$ZIP;type=application/zip;filename=$AGENT.zip"

x-ms-agent-name jest wymagany tylko w wywołaniu Create. Nazwa musi zaczynać się i kończyć znakami alfanumerycznymi, może zawierać łączniki w środku i nie może przekraczać 63 znaków. Odpowiedź zawiera początkową wartość status elementu creating.

Sonduj jako aktywne

while true; do
  STATUS=$(curl -s -H "Authorization: Bearer $TOKEN" \
    "$ENDPOINT/agents/$AGENT/versions/$AGENT_VERSION?api-version=$API_VERSION" | jq -r '.status')
  echo "Status: $STATUS"
  [ "$STATUS" = "active" ] && break
  [ "$STATUS" = "failed" ] && echo "Provisioning failed." && exit 1
  sleep 5
done

Wywoływanie agenta

Wybierz protokół zadeklarowany przez agenta w pliku protocol_versions.

Protokół odpowiedzi:

curl -X POST "$ENDPOINT/agents/$AGENT/endpoint/protocols/openai/responses?api-version=v1" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-5.4-mini","input":"Hello, agent!","stream":false}'

Protokół wywołań:

curl -X POST "$ENDPOINT/agents/$AGENT/endpoint/protocols/invocations?api-version=v1" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"input":"Hello, this is a test invocation!"}'

Protokół wywołań (WebSocket):

Połącz się za pośrednictwem uaktualnienia protokołu WebSocket zamiast interfejsu REST POST. Aby zapoznać się z formatem punktu końcowego i przykładami klienta, zobacz Tworzenie agenta głosowego przy użyciu hostowanych agentów.

Przydatne nagłówki odpowiedzi:

W przypadku protokołu Responses identyfikator odpowiedzi na wywołanie jest polem id w treści JSON odpowiedzi (na przykład caresp_<random>). Użyj go, aby skorelować wywołanie z dziennikami kontenera lub odwołać się do wywołania w żądaniu pomocy technicznej.

Bieżące operacje

Po pierwszym wdrożeniu użyj tych punktów końcowych, aby rozwijać i obsługiwać agenta.

Zaktualizuj agenta lub utwórz jego wersję

Aby wdrożyć zmianę kodu lub aktualizację definicji, ponownie prześlij treść żądania wieloczęściowego do zasobu agenta. Usługa stosuje wersjonowanie adresowane zawartością: nowa wersja jest tworzona tylko wtedy, gdy rzeczywiście zmienia się suma SHA-256 pliku ZIP lub definicja agenta. Identyczne reposty zwracają istniejącą najnowszą wersję.

curl -X POST "$ENDPOINT/agents/$AGENT?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN" \
  -H "x-ms-code-zip-sha256: $SHA" \
  -F "metadata=@metadata.json;type=application/json" \
  -F "code=@$ZIP;type=application/zip;filename=$AGENT.zip"

Odpowiedź to pełny obiekt agenta z wypełnionym polem versions.latest. Sprawdź wynikową wersję, jak pokazano w Sprawdź, czy jest aktywna.

Jeśli Twoje narzędzie preferuje odpowiedź w formacie wersji (samo AgentVersionObject zamiast otoczki agenta), wyślij to samo ciało żądania multipart na adres $ENDPOINT/agents/$AGENT/versions?api-version=$API_VERSION. Reguła deduplikacji jest identyczna — oba punkty końcowe współdzielą tę samą logikę z możliwością adresacji zawartości.

Pobieranie wdrożonego pliku zip

Sprawdź dokładnie, co zostało wdrożone, pobierając plik zip. Pomiń agent_version, aby pobrać najnowszą wersję; podaj agent_version=<n>, aby wskazać konkretną wersję.

VERSION=1

# Latest version
curl -O -J "$ENDPOINT/agents/$AGENT/code:download?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/zip"

# Specific version
curl -O -J "$ENDPOINT/agents/$AGENT/code:download?api-version=$API_VERSION&agent_version=$VERSION" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/zip"

Dwa nagłówki odpowiedzi ułatwiają potwierdzenie pobranej zawartości:

Agenci bazujący na obrazach zwracają wartość 409 AgentNotCodeBased.

Przesyłaj strumieniowo dzienniki kontenerów

curl -N "$ENDPOINT/agents/$AGENT/sessions/<sessionId>:logstream?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: text/event-stream"

Dzienniki są dostarczane jako zdarzenia wysyłane przez serwer. {sessionId} jest wartością x-agent-session-id z odpowiedzi wywołania. Ten punkt końcowy służy do debugowania błędów i 424 session_not_ready odpowiedzi środowiska uruchomieniowego.

układ Python (tryb kompilacji zdalnej)

Usługa instaluje zależności w chmurze z requirements.txt.

agent-code.zip
+-- main.py
+-- requirements.txt

Układ instalacji Python (wariant pakietowy)

Dostarczasz wstępnie skompilowane zależności Linuksa w packages/.

agent-code.zip
+-- main.py                    # entry point
+-- requirements.txt
+-- packages/                  # extracted modules (not raw .whl files)
    +-- azure/identity/__init__.py
    +-- requests/__init__.py

Lokalne kompilowanie zależności dla systemu Linux (dołączone, Python)

Użyj tagu platformy manylinux2014_x86_64, aby pip pobierać koła systemu Linux nawet z Windows lub macOS.

Bash

pip install -r requirements.txt \
    --target packages/ \
    --platform manylinux2014_x86_64 \
    --python-version 3.13 \
    --implementation cp \
    --only-binary=:all:

zip -r agent-code.zip main.py requirements.txt packages/

PowerShell/ Windows cmd

pip install -r requirements.txt --target packages --platform manylinux2014_x86_64 --python-version 3.13 --implementation cp --only-binary=:all:

tar -a -c -f agent-code.zip main.py requirements.txt packages

--only-binary=:all: wymusza koła (bez kompilacji źródłowych). Element --python-version musi odpowiadać wartości runtime w definicji agenta.

układ .NET (zdalny tryb kompilacji)

Spakuj tylko źródła projektu — bez wyników wyjściowych bin/, obj/ ani publish/. Usługa agenta uruchamia dotnet restore i dotnet publish za Ciebie podczas aprowizacji.

agent-code.zip
+-- MyAgent.csproj
+-- Program.cs
+-- ... (additional .cs files)

Element entry_point, który ustawisz w definicji agenta, nadal odnosi się do opublikowanej nazwy zestawu (na przykład ["dotnet", "MyAgent.dll"]), wygenerowanej podczas publikowania po stronie serwera.

Układ platformy .NET (tryb pakietowy)

Spakuj dane wyjściowe z dotnet publish -c Release -r linux-x64 --self-contained false bezpośrednio w katalogu głównym archiwum ZIP:

agent-code.zip
+-- MyAgent.dll
+-- MyAgent.runtimeconfig.json
+-- ... (publish output)

Kompilowanie danych wyjściowych .NET (w pakiecie)

dotnet publish -c Release -r linux-x64 --self-contained false -o publish/
cd publish && zip -r ../agent-code.zip .

Użyj --self-contained true, jeśli chcesz wysłać środowisko uruchomieniowe .NET w pliku zip. Ustawienie runtime w definicji agenta musi odpowiadać TargetFramework.

Zestaw SDK języka JavaScript/TypeScript przekazuje pakiety źródłowe Python lub .NET. Nie ma Node.js hostowanego środowiska uruchomieniowego. Skompiluj plik zip, postępując zgodnie z kartą Python lub C# dla wdrożonego środowiska uruchomieniowego, a następnie przekaż go za pomocą polecenia project.agents.createVersionFromCode().

Zobacz na zakładki Python lub C#.

# Delete one version
project.agents.delete_version(agent_name=AGENT_NAME, agent_version=created.version)

# Delete the agent and all its versions
project.agents.delete(agent_name=AGENT_NAME)

// Delete the agent and all its versions (force cascades to active sessions)
agentsClient.DeleteAgent(agentName: "my-code-agent", force: true);

// Delete one version
await project.agents.deleteVersion(agentName, created.version);

// Delete the agent and all its versions (force cascades to active sessions)
await project.agents.delete(agentName, { force: true });

Dokumentacja: AIProjectClient

# Delete one version
curl -X DELETE "$ENDPOINT/agents/$AGENT/versions/$AGENT_VERSION?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN"

# Delete the agent and all its versions
curl -X DELETE "$ENDPOINT/agents/$AGENT?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN"

# Force-delete the agent (cascades to any active sessions)
curl -X DELETE "$ENDPOINT/agents/$AGENT?api-version=$API_VERSION&force=true" \
  -H "Authorization: Bearer $TOKEN"