Publicera din agent som en agentapplikation

Observera

Den här artikeln beskriver den tidigare publiceringsupplevelsen. Den nya agentpubliceringsmodellen finns i Migrera från agentprogram till den nya agentslutpunkten och publiceringsmiljön.

Publicering flyttar en agent från en utvecklingstillgång i ditt Foundry-projekt till en hanterad Azure resurs som externa konsumenter kan anropa via en stabil slutpunkt. Tänk på det som det steg som flyttar din agent från "fungerar i mitt projekt" till "redo för andra att använda".

Den här artikeln visar hur du publicerar en agent, konfigurerar dess autentisering och behörigheter, anropar ditt agentprogram med hjälp av protokollet Svars-API och uppdaterar agentprogrammet när du distribuerar nya agentversioner. Efter publiceringen kan du anropa agentprogrammet med hjälp av protokollet Svar eller Aktivitet.

Vad är publicering?

Under utvecklingen skapar och testar du din agent i ett Foundry-projekt. Projektet ger dig och dina teammedlemmar en delad arbetsyta, men den är inte utformad för bred distribution eftersom alla med projektåtkomst kan interagera med alla agenter och delar samma konversationskontext och behörigheter. Publicering är det steg som flyttar en agent från det delade utvecklingsutrymmet och till en produktionsklar Azure resurs.

När du publicerar en agentversion skapar Foundry en agentprogramresurs som omsluter agentversionen med en egen anrops-URL, autentiseringsprincip, unik Entra-agentidentitet och en unik Entra-agentskiss. En distribution skapas också som en underordnad resurs i programmet, som refererar till den specifika agentversion som publiceras och stöder livscykelhantering för start/stopp.

Observera

Foundry Agent-program är inte registrerade i Microsoft Entra agentregistret.

Varför publicera?

Publicering ger dig funktioner som utveckling på projektnivå inte tillhandahåller:

  • Extern delning – Bevilja åtkomst till teammedlemmar eller kunder utan att ge dem åtkomst till ditt Foundry-projekt.

  • Stabil slutpunkt – Program-URL:en förblir densamma även när du distribuerar nya agentversioner.

  • Distinkt agentidentitet – Den publicerade agenten får en egen Entra-agentidentitet och Entra-agentskiss, separat från projektets delade identitet och skiss.

  • Independent RBAC och auktorisering – Agentapplikationen är en separat Azure-resurs med sitt eget RBAC-scope. Du kan tilldela roller som Foundry User direkt på agentprogramresursen för att styra vem som kan anropa den.

    Viktigt

    Foundrys RBAC-roller har nyligen namnändrats. Foundry User, Foundry Owner, Foundry Account Owner och Foundry Project Manager hette tidigare Azure AI-användare, Azure AI-ägare, Azure AI-kontoägare och Azure AI Project Manager. Du kanske fortfarande ser de tidigare namnen på vissa platser medan namnbytet distribueras. Roll-ID:na och kärnbehörigheterna ändras inte av namnbytet.

  • Azure Policy integration – Som en Azure Resource Manager resurs (ARM) kan programmet styras av Azure Policy.

  • Integration med Microsoft 365 Copilot och Teams – Distribuera ditt agentprogram till kanaler som Microsoft 365 Copilot och Teams.

Vad ändras när du publicerar?

Den viktigaste ändringen är identitet. En opublicerad agent använder projektets delade agentidentitet. När agenten har publicerats får den sin egen dedikerade agentidentitet. Alla verktyg som använder agentidentitetsautentisering växlar från projektets delade identitet till agentprogrammets unika agentidentitet.

Vad du ska titta efter

Eftersom identiteten ändras överförs inte behörigheterna automatiskt. När du publicerar en agent måste du omtilldela RBAC-behörigheter till den nya agentidentiteten för alla resurser som agenten behöver åtkomst till. Om du hoppar över det här steget kommer anrop från verktyget som fungerar under utvecklingen att misslyckas med auktoriseringsfel när agenten har publicerats.

Förutsättningar

  • Ett Foundry-projekt med minst en agentversion skapad
  • Foundry Project Manager-rollen på Foundry-resursomfånget för att publicera agenter
  • Användarrollen Foundry i omfånget för agentprogrammet för att chatta med en publicerad agent med hjälp av Responses API-protokollet (eller en anpassad roll med behörigheten Microsoft.CognitiveServices/accounts/AIServices/applications/invoke/action)

Observera

Foundry Agent Consumer-rollen är utformad för att interagera med agentslutpunkter och ger inte åtkomst till att anropa agentprogram. Agentprogram använder en annan behörighetssökväg (Microsoft.CognitiveServices/accounts/AIServices/applications/invoke/action). Använd foundry-användarrollen eller en anpassad roll som innehåller den här behörigheten.

Viktigt

Koden i den här artikeln använder paket som för närvarande är i förhandsversion. Den här förhandsversionen tillhandahålls utan ett serviceavtal och vi rekommenderar det inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller har begränsade funktioner. Mer information finns i Supplemental Terms of Use for Microsoft Azure Previews.

Förstå applikationer för agenter och utplaceringar

Innan du publicerar är det viktigt att förstå relationen mellan projekt, agentversioner, program och distributioner.

Diagram som illustrerar hur Foundry-projekt organiserar agentversioner, program och distributioner, med fokus på styrnings- och RBAC-roller.

Ett Foundry-projekt är ett arbetsorganisationskoncept som grupperar relaterade resurser, till exempel agenter, filer och index. En agent representerar en sammansättningsbar enhet som definieras av dess instruktioner, modell och verktyg. En agentversion fångar en specifik oföränderlig ögonblicksbild av en agent. Varje gång du gör ändringar i din agent, till exempel när du uppdaterar prompten eller lägger till verktyg, skapas en ny agentversion. Varje agentversion exponeras under Foundry-projektet, där utvecklare med projektåtkomst kan skapa, köra och testa den.

Ett agentprogram projicerar en eller flera agenter som en tjänst – oberoende adresserbara, styrbara och utrustade med funktioner för livscykel- och innehållshantering. Det ger ett hållbart gränssnitt som etablerar autentisering, identitet och en stabil startpunkt för konsumenter. En distribution är en instans av en agentversion som körs i ett program som kan startas, stoppas och uppdateras för att referera till nya agentversioner.

Hantering av routning och version

Varje agentprogram fungerar som en routningstabell till specifika agentdistributioner. För närvarande stöder ett agentprogram en aktiv distribution som dirigerar 100% av trafiken som tas emot av programmets slutpunkt till distributionen. När du publicerar en ny agentversion till ett befintligt program dirigeras 100% av trafiken som tas emot av programmets slutpunkt till distributionen som refererar till den nya agentversionen.

Diagram över ett agentprogram som dirigerar trafik till en distribution som kör en specifik agentversion, som visar en stabil startpunkt och trafikflöde.

Protokoll

En agentprogramresurs exponerar en stabil slutpunkt med flera alternativ för protokoll och autentisering.

Observera

För närvarande kan endast ett protokoll – antingen Svar eller Aktivitetsprotokoll – aktiveras för ett agentprogram i taget.

Svarsprotokoll

Foundry-agenter exponerar som standard ett OpenAI-kompatibelt protokoll baserat på svar för interaktion med agenter.

För applikationer exponeras denna slutpunkt på:

https://{accountName}.services.ai.azure.com/api/projects/{projectName}/applications/{applicationName}/protocols/openai

Det OpenAI-kompatibla API:et som exponeras via program har ändrats för att säkerställa att användarnas konversationer förblir privata. Den här begränsningen är tillfällig och tas bort när vi har stöd för slutanvändarisolering. Därför är API:et mer begränsat än openAI-API:et som hanteras av projektslutpunkten. Specifikt:

  • Endast det tillståndslösa svars-API:et (POST /responses) stöds.
  • Andra API:er som /conversations, /files, /vector_storesoch /containers är otillgängliga.

Den här begränsningen innebär att klienten måste lagra konversationshistorik för konversationer med flera turer.

Aktivitetsprotokoll

Foundry-agenter kan också exponera Activity Protocol som används av Azure Bot Service.

För program exponeras den här slutpunkten på:

https://{accountName}.services.ai.azure.com/api/projects/{projectName}/applications/{applicationName}/protocols/activityprotocol

Autentisering

Du kan konfigurera inkommande slutanvändarautentisering i programmet. Följande alternativ är tillgängliga:

  • Standard (RBAC): Anroparen måste ha rollen Foundry User (eller en anpassad roll med behörigheten /applications/invoke/action ) på agentprogramresursen. Välj det här alternativet om du vill anropa agentprogrammet med hjälp av protokollet Svars-API. Mer information om Foundry RBAC-roller finns i Role-baserad åtkomstkontroll för Microsoft Foundry.
  • Channels (Azure Bot Service): När du publicerar till M365/Teams eller till A365 som autopilot är kanaler den autentisering som används. Detta väljs automatiskt i användargränssnittet via publiceringsflödet M365/Teams.

API-nyckelautentisering stöds inte för att anropa agentprogram. Använd Microsoft Entra ID (Azure RBAC) för att auktorisera anropare.

Publicera en agent

Foundry-portalen

Det här avsnittet visar hur du publicerar en agent med hjälp av foundry-portalgränssnittet.

  1. I Agent Builder skapar eller väljer du en agentversion som du vill publicera.

  2. Välj Publicera agent för att skapa ett agentprogram och en distribution.

Förväntat resultat: Publiceringen har slutförts och agentversionen visar en publicerad status.

  1. Konfigurera autentisering för ditt agentprogram:

    • Som standard är autentiseringstypen inställd på RBAC (Role-Based Access Control).
    • Användare som anropar agentprogrammet med hjälp av svarsprotokollet måste beviljas Foundry User inbyggd Azure RBAC-roll (eller en motsvarande anpassad roll) på agentprogramresursen.

  2. Tilldela behörigheter för verktygsautentisering:

    • Om din agent innehåller verktyg som använder agentidentitet för autentisering måste den nyligen skapade agentidentiteten ha lämpliga behörigheter
    • Navigera till varje Azure resurs som agenten har åtkomst till och tilldela den nödvändiga RBAC-rollen till den nya agentidentiteten

  3. När du har publicerat kan du:

    • Dela den publicerade slutpunkten med externa konsumenter eller integrera den i ditt befintliga program.
    • Dela och chatta med ditt program i kanaler som Teams/M365 Copilot.

REST API

Om du vill publicera en agentversion måste du skapa ett program och en distribution som refererar till din agentversion.

Viktigt

Agentprogram är Azure resurser. Använd den senaste API-versionen som är tillgänglig för din prenumeration och ditt konto när du anropar hanteringsslutpunkten.

Innan du börjar

  1. Logga in och hämta en Azure Resource Manager åtkomsttoken:
az login
az account get-access-token --resource https://management.azure.com

Använd värdet accessToken som Authorization: Bearer <token> rubrik i följande begäranden.

Om du bara vill avbilda tokenvärdet (till exempel för användning i ett skript) använder du:

az account get-access-token --resource https://management.azure.com --query accessToken -o tsv

  1. Samla in de värden som du behöver för begärande-URL:en.

    • subscription_id: Använd den prenumeration som innehåller din Foundry-resurs. Du hittar den i Azure portalen (Prenumerationer) eller genom att köra az account show --query id -o tsv.
    • resource_group: Resursgruppen som innehåller din Foundry-resurs. Du hittar den på sidan Foundry-resursen Overview i Azure-portalen.
    • account_name: Namnet på din Foundry-resurs (Azure resursnamn).
    • project_name: Gjuteriprojektets namn.
    • application_name och deployment_name: Välj namn för agentprogrammet och distributionen som du vill skapa.

  2. Välj en api-version.

1. Skapa agentprogram.

För en fullständig egenskapsreferens och ett exempel på infrastruktur som kod (Bicep) för agentprogram, se Azure Resource Manager mallreferens för Microsoft.CognitiveServices/accounts/projects/applications.

Obligatoriskt fält: Ange agentName fältet till namnet på den agent som du vill publicera.

I följande exempel visas endast de minsta obligatoriska fälten. Som standard är authorizationPolicy inställt på Default (Azure RBAC) och trafficRoutingPolicy dirigerar all trafik till den första distributionen.

PUT https://management.azure.com/subscriptions/{{subscription_id}}/resourceGroups/{{resource_group}}/providers/Microsoft.CognitiveServices/accounts/{{account_name}}/projects/{{project_name}}/applications/{{application_name}}?api-version={{api_version}}
Authorization: Bearer {{token}}
Content-Type: application/json

{
  "properties":{
    "agents": [{"agentName": "Publishing Agent"}]
  }
}

2. Skapa en agentdistribution.

En fullständig referens över egenskaper och ett exempel på infrastruktur-som-kod med Bicep för agentdistributioner finns i referensen till Azure Resource Manager-mallen för Microsoft.CognitiveServices/accounts/projects/applications/agentDeployments.

Obligatoriska fält:

  • deploymentType: Distribueringsläge. Används Managed för promptagenter. Använd Hosted för hostade agenter.
  • agents: Agentnamnet och versionen som ska distribueras.
  • protocols: Protokollet som distributionen exponerar. För svar anger du protocol som Responses och version som 1.0.

Fler obligatoriska fält för endast värdbaserad:

  • minReplicas: Anger det minsta antalet repliker
  • maxReplicas: Anger det maximala antalet repliker
Aktivera agenter
PUT https://management.azure.com/subscriptions/{{subscription_id}}/resourceGroups/{{resource_group}}/providers/Microsoft.CognitiveServices/accounts/{{account_name}}/projects/{{project_name}}/applications/{{application_name}}/agentdeployments/{{deployment_name}}?api-version={{api_version}}
Authorization: Bearer {{token}}
Content-Type: application/json

{
  "properties":{
    "displayName": "Test Managed Deployment",
    "deploymentType": "Managed",
    "protocols": [
        {
          "protocol": "Responses",
          "version": "1.0"
        }
    ],
    "agents": [
        {
            "agentName": "Publishing Agent",
            "agentVersion": "1"
        }
    ]
  }
}
Värdbaserade agenter
PUT https://management.azure.com/subscriptions/{{subscription_id}}/resourceGroups/{{resource_group}}/providers/Microsoft.CognitiveServices/accounts/{{account_name}}/projects/{{project_name}}/applications/{{application_name}}/agentdeployments/{{deployment_name}}?api-version={{api_version}}
Authorization: Bearer {{token}}
Content-Type: application/json
{
  "properties": {
    "displayName": "Test Hosted Deployment",
    "deploymentType": "Hosted",
    "minReplicas": 1,
    "maxReplicas": 1,
    "protocols": [
        {
            "protocol": "Responses",
            "version": "1.0"
        }
    ],
    "agents": [
        {
            "agentName": "ContainerAgent",
            "agentVersion": "1"
        }
    ]
  }
}

3. Kontrollera att distributionen körs

Distributioner av Prompt-agenten startar vanligtvis automatiskt. Hostade agentdriftsättningar ärver statusen för den publicerade agentversionen – om versionen stoppas stoppas även driftsättningen.

Om du vill kontrollera det aktuella tillståndet hämtar du distributionsresursen och inspekterar egenskapen state:

GET https://management.azure.com/subscriptions/{{subscription_id}}/resourceGroups/{{resource_group}}/providers/Microsoft.CognitiveServices/accounts/{{account_name}}/projects/{{project_name}}/applications/{{application_name}}/agentdeployments/{{deployment_name}}?api-version={{api_version}}
Authorization: Bearer {{token}}

Använd följande anrop för att starta en stoppad distribution:

POST https://management.azure.com/subscriptions/{{subscription_id}}/resourceGroups/{{resource_group}}/providers/Microsoft.CognitiveServices/accounts/{{account_name}}/projects/{{project_name}}/applications/{{application_name}}/agentdeployments/{{deployment_name}}/start?api-version={{api_version}}
Authorization: Bearer {{token}}
Content-Type: application/json

Kontrollera att publiceringen har slutförts

Bekräfta att din agent har publicerats framgångsrikt innan slutpunkten delas med användare. När du har publicerat kontrollerar du att:

  • Agentprogramresursen finns.
  • Driftsättningen är igång.
  • Du kan anropa programslutpunkten.

Snabbverifiering genom att anropa slutpunkten

Om du vill köra följande kommandon behöver du Azure CLI.

  1. Hämta en åtkomsttoken för den anropande användaren.
az account get-access-token --resource https://ai.azure.com
  1. Anropa agentprogrammets slutpunkt (svarsprotokollet).
curl -X POST \
  "https://<foundry-resource-name>.services.ai.azure.com/api/projects/<project-name>/applications/<app-name>/protocols/openai/responses?api-version=2025-11-15-preview" \
  -H "Authorization: Bearer <access-token>" \
  -H "Content-Type: application/json" \
  -d '{"input":"Say hello"}'

Om du får 403 Forbiddenbekräftar du att anroparen har rollen Foundry-användare på agentprogramresursen.

Uppdatera ett publicerat agentprogram

När du behöver distribuera en ny version av din agent uppdaterar du det befintliga programmet och distributionen för att referera till den nya agentversionen.

Foundry-portalen

  1. I Agent Builder navigerar du till den specifika agentversion som du vill publicera.

  2. Välj Publicera uppdateringar.

  3. Bekräfta uppdateringen. Agentprogrammet dirigerar automatiskt 100% trafik till den nya agentversionen.

Den stabila slutpunkts-URL:en förblir oförändrad, vilket säkerställer att nedströmskonsumenter inte störs av uppdateringen.

REST API

Om agentnamnet förblir detsamma och du bara vill distribuera en ny agentversion uppdaterar du distributionen så att den refererar till en ny agentversion.

PUT https://management.azure.com/subscriptions/{{subscription_id}}/resourceGroups/{{resource_group}}/providers/Microsoft.CognitiveServices/accounts/{{account_name}}/projects/{{project_name}}/applications/{{application_name}}/agentdeployments/{{deployment_name}}?api-version={{api_version}}
Authorization: Bearer {{token}}
Content-Type: application/json

{
  "properties":{
    "description": "This is a managed deployment",
     "displayName": "Test Managed Deployment",
    "deploymentType": "Managed",
    "protocols": [
        {
          "protocol": "Responses",
          "version": "1.0"
        }
    ],
    "agents": [
        {
            "agentName": "Publishing Agent",
            "agentVersion": "<updated-agent-version>"
        }
    ]
  }
}

Om du vill distribuera en agent med ett annat namn måste du:

  1. Uppdatera agentprogrammet så att det nya agentnamnet tillåts.
  2. Skapa eller uppdatera en distribution för att referera till den nya agentversionen.
  3. Om du har skapat en ny distribution uppdaterar du agentprogrammets trafikroutningsprincip så att 100% trafik går till den nya distributionen.

Ge användare åtkomst för att anropa en publicerad agent

När du har publicerat en agent måste uppringare ha rollen Foundry User (eller en anpassad roll som innehåller behörigheten Microsoft.CognitiveServices/accounts/AIServices/applications/invoke/action) på resursen Agent Application. Den här rolltilldelningen är begränsad till det enskilda agentprogrammet, så du kan ge åtkomst till en enda publicerad agent utan att ge användarna åtkomst till hela Foundry-projektet eller andra agenter.

Observera

Rollen Foundry Agent Consumer är utformad för direkta interaktioner med agentslutpunkter och ger inte åtkomst till agentapplikationer. Använd Foundry-användare eller en anpassad roll med den behörighet som krävs för åtkomst till agentprogram.

Viktigt

Agentprogrammets RBAC hanteras via Azure Resource Manager, inte via Entra-agentidentiteten. Entra-agentidentiteten som den publicerade agenten tar emot är för agentens egna utgående anrop till verktyg och resurser. Om du vill styra vem som kan invoke den publicerade agenten tilldelar du Azure RBAC-roller på ARM-resursen för agentprogram med hjälp av Azure-portalen, Azure CLI eller REST API.

Mer information om Azure RBAC finns i Role-baserad åtkomstkontroll för Microsoft Foundry

Anropa ditt agentprogram

Observera

Agentprogram stöder för närvarande ett protokoll i taget, men detta kan ändras. När du skapar ett agentprogram i Foundry-användargränssnittet är det standard för protokollet Svars-API. Om du senare publicerar till Microsoft 365 eller Teams konfigurerar publiceringsflödet aktivitetsprotokollet.

När du har publicerat anropar du din agent via dess slutpunkt med hjälp av antingen protokollet Svars-API eller aktivitetsprotokollet. Aktivitetsprotokollet används när din agent publiceras till Microsoft 365 och Teams.

Information om hur du använder ditt agentprogram i Microsoft 365 Copilot och Teams finns i Publicera agenter för Microsoft 365 Copilot och Microsoft Teams.

Information om hur du publicerar din agent som autopilot finns i Publicera en agent som en autopilot i Agent 365

Använd via Responses API-protokollet

Om du vill anropa agentapplikationen med hjälp av Responses-API-protokollet behöver du:

Använd OpenAI-klienten med slutpunkten agentapplikationer

from openai import OpenAI 
from azure.identity import DefaultAzureCredential, get_bearer_token_provider 

# Replace placeholders with your resource, project, and app names
BASE_URL = "https://<foundry-resource-name>.services.ai.azure.com/api/projects/<project-name>/applications/<app-name>/protocols/openai"

# Create OpenAI client authenticated with Azure credentials
openai = OpenAI(
    api_key=get_bearer_token_provider(DefaultAzureCredential(), "https://ai.azure.com/.default"),
    base_url=BASE_URL,
    default_query={"api-version": "2025-11-15-preview"}
)

# Send a request to the published agent
response = openai.responses.create( 
  input="Write a haiku", 
) 
print(f"Response output: {response.output_text}")

Den här metoden autentiserar med Azure autentiseringsuppgifter och kräver att anroparen har rollen Foundry User på agentprogramresursen.

Säkerhets- och sekretessöverväganden

  • Använd minsta möjliga behörighet. Ge användarna den minsta roll de behöver (till exempel separera publiceringsbehörigheter från anropa behörigheter).
  • Undvik att dela projektåtkomst när du bara behöver dela en agent. Använd agentprogramslutpunkten och RBAC på programresursen.
  • Bädda inte in åtkomsttoken i källkod, skript eller klientprogram. Använd Microsoft Entra autentiseringsflöden som är lämpliga för din app.
  • Planera för identitetsändringar när du publicerar. Verktygsanrop som autentiseras av agentidentitet använder programidentiteten efter publicering, inte projektidentiteten.
  • Lagra konversationshistorik i klienten om du behöver funktioner för flera turer. Agentprogram begränsar för närvarande API:er och lagrar inte svar.

Begränsningar

Agenter som publiceras som agentprogram har följande begränsningar:

Begränsning Beskrivning
Api för tillståndslösa svar Endast det tillståndslösa svars-API:et stöds. Andra API:er som /conversations, /files, /vector_storesoch /containers är otillgängliga.
Ingen UI- eller CLI-hantering Det finns inget dedikerat användargränssnitt/CLI för avancerade hanteringsåtgärder. Använd REST-API:et för hanteringsåtgärder som inte är tillgängliga i foundry-portalens publiceringsflöde.

Felsökning

Frågan Sannolik orsak Upplösning
Publiceringsagenten är inaktiverad Rollen för Foundry Project Manager saknas i Foundry-resursomfånget Tilldela rollen Foundry Project Manager på Foundry-resursens (kontots) omfång, inte bara på projektomfånget.
403 Forbidden när slutpunkten anropas Anroparen saknar behörighet att anropa agentprogramresursen Tilldela foundry-användarrollen på agentprogramresursen till anroparen. Se Bevilja användare åtkomst för att anropa en publicerad agent.
401 Unauthorized när slutpunkten anropas Åtkomsttoken saknas, har upphört att gälla eller för fel resurs Autentisera om och begär en token för https://ai.azure.com.
Verktygsanrop misslyckas efter publicering Agentprogrammets identitet har inte samma åtkomst som projektidentiteten Tilldela om de nödvändiga RBAC-rollerna till den publicerade agentidentiteten för alla nedströms Azure-resurser som den behöver komma åt.
Konversationer med flera vändningar fungerar inte som förväntat Agentprogram lagrar inte konversationstillstånd åt dig Lagra konversationshistorik i klienten och skicka kontexten som en del av din begäran.

Rensa resurser

Om du inte längre behöver en publicerad slutpunkt tar du bort agentprogrammet Azure resursen (och dess distributioner). Om du tar bort programmet tas inte dina agentversioner bort i Foundry-projektet.

Referens: Egenskaper för agentapplikation och distribution

Använd följande tabeller när du skapar REST API-begäranden eller behöver förstå fälten som returneras som svar.


Egenskaper för agentprogram
Namn Beskrivning Värde Kan anges i begärandetexten?
displayName Visningsnamnet för agentprogrammet Sträng ✅
baseUrl Agentprogrammets dedikerade slutpunkt Sträng ❌ (skrivskyddad)
agents De agenter som exponeras av programmet. matris med objekt ✅
agentIdentityBlueprint Agentens identitetsmall som är kopplad till agentapplikationen. Objekt ❌ (skrivskyddad)
defaultInstanceIdentity Agentidentiteten som är associerad med agentprogrammet Objekt ❌ (skrivskyddad)
authorizationPolicy Definierar hur användare tillåts att autentisera till appen. Om det inte anges anges det här fältet som standard Objekt ✅
trafficRoutingPolicy Definierar vilken distribution agenten skickar trafik till. För närvarande kan all trafik endast dirigeras till en distribution. Objekt ✅
provisioningState Hämtar status för agentprogrammet när åtgärden initierades. Sträng ❌ (skrivskyddad)
isEnabled Anger om ett agentprogram är aktiverat eller inaktiverat. Boolean ✅
Distributionsegenskaper
Namn Beskrivning Värde Kan anges i begärandetexten?
displayName Utplaceringens visningsnamn. Sträng ✅
deploymentId En systemgenererad unik identifierare för varje distinkt livslängd för en distribution med en viss resursidentifierare. Sträng ❌ (skrivskyddad)
state Utplaceringens tillstånd. enum (Starting, Running, Stopping, Failed, Deleting, Deleted, Updating) ❌ (skrivskyddat) det finns explicita API:er som start/stopp för att kontrollera tillstånd
protocols De protokoll som stöds av distributionen matris med objekt ✅
agents Agentversionen som är kopplad till en specifik distribution. matris med objekt ✅
provisioningState Hämtar status för distributionen vid tidpunkten då operationen anropades. enum (Succeeded, Failed, Canceled, Creating, Updating, Deleting) ❌ (skrivskyddad)
deploymentType Den typ av agent som är kopplad till distributionen Räkna upp (Hosted eller Managed) ✅
minReplicas Det minsta antalet repliker som alltid körs. Heltal ✅ (endast när deploymentType: Hosted)
maxReplicas Det maximala antalet repliker som kan köras. Heltal ✅ (endast när deploymentType: Hosted)

Faqs

Varför sparas inte konversationer för publicerade agenter (även kallat varför stöds endast tillståndslösa svar)?

Idag finns det en tillfällig begränsning där publicerade agenter endast stöder tillståndslösa Responses API-interaktioner (det vill säga inga återkommande konversationer). Arbetet med att åtgärda detta pågår redan.

Anledningen till den här begränsningen är att även om Foundry Agent Service stöder hanterad konversationshistorik, framtvingar den ännu inte slutanvändarisolering mellan konversationer i samma projekt. Med andra ord, om någon känner till en annan användares konversations-ID kan de komma åt den konversationshistoriken även om det inte är deras. Det är acceptabelt i en utvecklingskontext i ett enda projekt, men det är inte acceptabelt för produktion, där kunderna behöver strikt konversationsisolering per användare.

Agentprogram är avsedda att exponera funktioner för en annan målgrupp (till exempel andra i din organisation eller dina kunder), åtskilda från projektutvecklare, med stabila versioner, konfiguration och kontrollerad åtkomst. Med tanke på det målet förväntar sig användare av agentprogram naturligtvis att deras interaktioner med programmet ska vara privata och inte synliga för andra. Det här är för närvarande inte möjligt eftersom de OpenAI-API:er för en användare som vi har byggt ovanpå inte tillhandahåller intern dataisolering, och vi måste skapa isoleringslagret själva. Tills vi har stöd för fullständig dataisolering av slutanvändarnas applikationer, är endast tillståndslösa svar tillgängliga. Den här begränsningen är tillfällig.

Vad är prismodellen för en publicerad agent? Baseras kostnaden på en förbrukningsmodell eller debiteras klienten bara för att programresursen (slutpunkten) har den underliggande infrastrukturen distribuerad när agenten har publicerats?

Publicerade agenter använder en publisher-pays-modell: utgivaren (Foundry-projektägaren) mobiliserar kostnader baserat på den underliggande infrastruktur som distribueras när agenten publiceras som en applikation, ej baserat på per-samtalsförbrukning. Slutanvändare av det publicerade programmet ådrar sig inga kostnader som standard, även om kunderna kan välja att placera ett eget mätnings- eller faktureringslager framför programmet om de vill implementera en förbrukningsbaserad modell för sin organisation eller för externa användare.

Relaterat innehåll

Nästa steg

Hantera agenter i stor skala

  • Last updated on