Autentisera användare och hämta token för interaktiva agenter

Interaktiva agenter vidtar åtgärder för användarnas räkning. För att kunna agera på ett säkert sätt för användarna autentiserar agenten användaren, får medgivande för nödvändiga behörigheter och hämtar åtkomsttoken för underordnade API:er. Den här artikeln vägleder dig genom autentisering från slutpunkt till slutpunkt och flöde för tokenförvärv för din interaktiva agent:

Bevilja behörigheter via ärvbara behörigheter eller medgivande.
Autentisera användaren och hämta en åtkomsttoken.
Verifiera token och extrahera användaranspråk.
Hämta token för underordnade API:er med hjälp av OBO-flödet (On-Behalf-Of).

Anmärkning

Den här artikeln beskriver interaktiva agenter som agerar för inloggade användare som använder OBO-flödet. Om din agent behöver en egen användarliknande identitet (ett scenario för digital arbetare) kan du läsa agentens användarkonton och agentens OAuth-flöde för användarkonto.

Förutsättningar

Kontrollera att du har följande innan du börjar:

En agentidentitetsritning. Registrera agentens identitetsskissapp-ID (klient-ID).
En agentidentitet.
Ett klientprogram som är registrerat i Microsoft Entra för att hantera användarautentisering.
Kunskaper om OAuth 2.0-auktoriseringskodflödet.
Möjligheten att köra ett ASP.NET Core webb-API om du planerar att använda tokenverifieringen och OBO-exemplen i den här artikeln.

För administratörsauktorisering behöver du också:

Administratörsåtkomst för att bevilja medgivande för programbehörigheter.

Innan agenten kan agera för en användares räkning måste användaren eller en administratör samtycka till de behörigheter som krävs. Det finns två sätt att bevilja behörigheter:

Ärvbara behörigheter: Förauktorisera behörigheter på skissen så att agentidentiteter ärver dem automatiskt.
Begärandemedgivande: Registrera en omdirigerings-URI och uppmana användare eller administratörer att bevilja medgivande via en OAuth-begäran eller använda slutpunkten för administratörsmedgivande.

Använda ärvbara behörigheter

Konfigurera ärvbara behörigheter för agentidentitetsritningen för att förauktorisera en basuppsättning med delegerade omfång och programroller. Agentidentiteter som skapats från skissen ärver automatiskt dessa behörigheter utan interaktiva medgivandemeddelanden. Mer information finns i Konfigurera ärvbara behörigheter för agentidentitetsritningar.

Om du vill begära medgivande via ett OAuth-flöde måste din agentidentitetsritning först konfigureras med en omdirigerings-URI. För skisser måste omdirigerings-URI:n vara en webbprogramtyp . Till skillnad från omdirigerings-URI:er för appregistreringar kan en omdirigerings-URI på en skiss inte användas för att hämta delegerade behörighetstoken. Endast response_type=none stöds i OAuth2-begäran, vilket innebär att begäran endast innehåller medgivande och att inga token returneras.

Om du vill uppdatera omdirigerings-URI:n i agentidentitetsritningen måste du först hämta en åtkomsttoken med den delegerade behörigheten AgentIdentityBlueprint.ReadWrite.All. Skicka sedan en PATCH-begäran till programobjektet för agentidentitetsritningen:

PATCH https://graph.microsoft.com/beta/applications/<agent-blueprint-id>
OData-Version: 4.0
Content-Type: application/json
Authorization: Bearer <token>

{
  "web": {
    "redirectUris": [
      "https://myagentapp.com/authorize"
    ]
  }
}

Använd Microsoft Graph PowerShell för att uppdatera agentidentitetsritningen med omdirigerings-URI:n.

Connect-MgGraph -Scopes "AgentIdentityBlueprint.ReadWrite.All" -TenantId <your-tenant-id>

$applicationId = "<agent-blueprint-id>"
$web = @{
    redirectUris= @(
        "https://myagentapp.com/authorize"
    )
}

$body = @{
    web   =  $web
}

Invoke-MgGraphRequest -Method PATCH `
        -Uri "https://graph.microsoft.com/beta/applications/$applicationId" `
        -Headers @{ "OData-Version" = "4.0" } `
        -Body ($body | ConvertTo-Json)

Innan agenten kan agera för en användares räkning måste användaren samtycka till de behörigheter som krävs. Begäran om användarmedgivande returnerar inte en token. I stället registreras att användaren har beviljat agenten behörighet att agera för deras räkning. Tokenförvärv sker i Autentisera användaren och begära en token.

Viktigt!

Använd agentidentitetens klient-ID i parametern client_id , inte agentens identitetsskiss-ID.

Om du vill uppmana en användare om medgivande skapar du en auktoriserings-URL och omdirigerar användaren till den. Agenten kan presentera den här URL:en på olika sätt, till exempel som en länk i ett chattmeddelande.

https://login.microsoftonline.com/contoso.onmicrosoft.com/oauth2/v2.0/authorize?
  client_id=<agent-identity-id>
  &response_type=none
  &redirect_uri=https%3A%2F%2Fmyagentapp.com%2Fauthorize
  &response_mode=query
  &scope=User.Read
  &state=xyz123

När användaren öppnar den här URL:en uppmanar Microsoft Entra ID dem att logga in och bevilja medgivande. Efter medgivande skickas användaren tillbaka till omdirigerings-URI:n.

Nyckelparametrarna i url:en för auktorisering av användarmedgivande är:

client_id: Agentidentitetens klient-ID (inte agentidentitetsritningens klient-ID).
response_type: Ange till none eftersom den här begäran endast registrerar medgivande. Tokenförvärv används response_type=code i Autentisera användaren och begära en token.
redirect_uri: Måste matcha exakt den omdirigerings-URI som konfigurerats i agentidentitetsritningen.
scope: Ange de delegerade behörigheter som du behöver (till exempel User.Read).
state: Valfri parameter för att underhålla tillstånd mellan begäran och återanrop.

Mer information om OAuth-auktoriseringsbegrepp finns i Behörigheter och medgivande i Microsofts identitetsplattform.

Agenter kan också begära auktorisering från en Microsoft Entra ID administratör, som kan bevilja medgivande till agenten för alla användare i klientorganisationen. Administratörsmedgivande kan krävas beroende på de medgivandeinställningar som konfigurerats i klientorganisationen.

Om du vill bevilja administratörsmedgivande för hela klientorganisationen dirigerar du en administratör till följande URL. Använd agentidentitets-ID:t i parametern client_id .

https://login.microsoftonline.com/contoso.onmicrosoft.com/v2.0/adminconsent
?client_id=<agent-identity-id>
&scope=User.Read
&redirect_uri=<redirect-uri>
&state=xyz123

När administratören har gett sitt medgivande gäller behörigheterna för hela klientorganisationen. Användarna behöver inte godkänna det igen.

Anmärkning

Konfigurera en omdirigerings-URI i skissen och inkludera en state parameter i medgivandebegäran. När medgivande beviljas skickas användaren till omdirigerings-URI:n där du kan visa bekräftelse. Slutpunkten kan använda parametern state för att spåra att behörigheten har beviljats. För agenter för en enda klientorganisation kan du alternativt försöka begära token igen tills samtycke har beviljats, eftersom klientorganisations-ID:t redan är känt.

Autentisera användaren och begär en token

När medgivandet har beviljats initierar klientappen (till exempel en klientdel eller mobilapp) en OAuth 2.0-auktoriseringskodbegäran för att hämta en token där målgruppen är agentidentitetsritningen. I det här steget client_id refererar till klientappens eget registrerade program-ID, inte agentidentitets- eller agentidentitetsritningen.

Anmärkning

redirect_uri i den här begäran hör till klientappens registrering, inte ritningens omdirigerings-URI som konfigurerades i föregående medgivandesteget.

Omdirigera användaren till Microsoft Entra ID-auktoriseringsslutpunkten med följande parametrar:

GET https://login.microsoftonline.com/<your-tenant-id>/oauth2/v2.0/authorize?client_id=<client-app-id>
&response_type=code
&redirect_uri=<redirect_uri>
&response_mode=query
&scope=api://<agent-blueprint-id>/access_agent
&state=abc123

När användaren har loggat in får appen en auktoriseringskod vid omdirigerings-URI:n. Byt ut auktoriseringskoden mot en åtkomsttoken:

POST https://login.microsoftonline.com/<your-tenant-id>/oauth2/v2.0/token
Content-Type: application/x-www-form-urlencoded

client_id=<client-app-id>
&grant_type=authorization_code
&code=<authorization_code>
&redirect_uri=<redirect_uri>
&scope=api://<agent-blueprint-id>/access_agent
&client_secret=<client-secret>

Inkludera parametern client_secret endast om du använder en konfidentiell klient.

JSON-svaret innehåller en åtkomsttoken som kan användas för att komma åt agentens API.

Verifiera åtkomsttoken

Webb-API:et måste verifiera den inkommande åtkomsttoken innan agenten kan agera. Använd alltid ett godkänt bibliotek för att verifiera token. Skriv inte din egen tokenverifieringskod.

Installera nuget-paketet Microsoft.Identity.Web:
```
dotnet add package Microsoft.Identity.Web
```

I ditt ASP.NET Core webb-API-projekt implementerar du Microsoft Entra ID autentisering:

// Program.cs
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.Identity.Web;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApi(builder.Configuration.GetSection("AzureAd"));

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

Konfigurera autentiseringsuppgifter i appsettings.json filen:

Varning

Klienthemligheter ska inte användas som klientautentiseringsuppgifter i produktionsmiljöer för agentidentitetsritningar på grund av säkerhetsrisker. Använd i stället säkrare autentiseringsmetoder som federerade autentiseringsuppgifter (FIC) med hanterade identiteter eller klientcertifikat. Dessa metoder ger förbättrad säkerhet genom att eliminera behovet av att lagra känsliga hemligheter direkt i programkonfigurationen.
```
"AzureAd": {
    "Instance": "https://login.microsoftonline.com/",
    "TenantId": "<your-tenant-id>",
    "ClientId": "<agent-blueprint-id>",
    "Audience": "<agent-blueprint-id>",
    "ClientCredentials": [
        {
            "SourceType": "ClientSecret",
            "ClientSecret": "your-client-secret"
        }
    ]
}
```

Mer information om Microsoft. Identity.Web, se Microsoft. Dokumentation om Identity.Web.

Verifiera användarpåståenden

Efter validering av åtkomsttoken kan agenten identifiera användaren och utföra auktoriseringskontroller. I följande exempel extraherar API-vägen användaranspråk från åtkomsttoken och returnerar dem i API-svaret:

app.MapGet("/hello-agent", (HttpContext httpContext) =>
{   
    var claims = httpContext.User.Claims.Select(c => new
    {
        Type = c.Type,
        Value = c.Value
    });

    return Results.Ok(claims);
})
.RequireAuthorization();

Hämta token för underordnade API:er

När en interaktiv agent har verifierat användarens token kan den begära åtkomsttoken för att anropa underordnade API:er för användarens räkning. OBO-flödet (On-Behalf-Of) gör det möjligt för agenten att:

Ta emot en åtkomsttoken från en klient.
Byt ut den mot en ny åtkomsttoken för ett nedströms-API som Microsoft Graph.
Använd den nya token för att komma åt skyddade resurser för den ursprungliga användarens räkning.

Använd Microsoft Identity Web
Använd Microsoft Graph SDK

Biblioteket Microsoft.Identity.Web förenklar OBO-implementeringen genom att hantera tokenutbyte automatiskt, så du behöver inte implementera flödet manuellt genom att följa protokollet.

Installera nödvändiga NuGet-paket:

dotnet add package Microsoft.Identity.Web
dotnet add package Microsoft.Identity.Web.AgentIdentities

I ditt ASP.NET Core webb-API-projekt uppdaterar du implementeringen av Microsoft Entra ID-autentisering:

// Program.cs
using Microsoft.AspNetCore.Authorization;
using Microsoft.Identity.Abstractions;
using Microsoft.Identity.Web;
using Microsoft.Identity.Web.Resource;
using Microsoft.Identity.Web.TokenCacheProviders.InMemory;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddMicrosoftIdentityWebApiAuthentication(builder.Configuration)
    .EnableTokenAcquisitionToCallDownstreamApi();
builder.Services.AddAgentIdentities();
builder.Services.AddInMemoryTokenCaches();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

app.Run();

I agent-API:et byter du ut den inkommande användaråtkomsttoken mot en ny åtkomsttoken för agentidentiteten. Microsoft.Identity.Web validerar den inkommande åtkomsttoken och hanterar utbytet av token på uppdrag av:

app.MapGet("/agent-obo-user", async (HttpContext httpContext) =>
{
    string agentIdentity = "<your-agent-identity>";
    IAuthorizationHeaderProvider authorizationHeaderProvider = httpContext.RequestServices.GetService<IAuthorizationHeaderProvider>()!;
    AuthorizationHeaderProviderOptions options = new AuthorizationHeaderProviderOptions().WithAgentIdentity(agentIdentity);

    string authorizationHeaderWithUserToken = await authorizationHeaderProvider.CreateAuthorizationHeaderForUserAsync(["https://graph.microsoft.com/.default"], options);

    var response = new { header = authorizationHeaderWithUserToken };
    return Results.Json(response);
})
.RequireAuthorization();

Om du använder Microsoft Graph SDK kan du autentisera mot Microsoft Graph med hjälp av GraphServiceClient.

Installera nödvändiga NuGet-paket:

dotnet add package Microsoft.Identity.Web
dotnet add package Microsoft.Identity.Web.AgentIdentities
dotnet add package Microsoft.Identity.Web.GraphServiceClient

I ditt ASP.NET Core webb-API-projekt konfigurerar du autentisering och lägger till stöd för Microsoft Graph:

// Program.cs
using Microsoft.AspNetCore.Authorization;
using Microsoft.Identity.Web;
using Microsoft.Identity.Web.TokenCacheProviders.InMemory;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddMicrosoftIdentityWebApiAuthentication(builder.Configuration)
    .EnableTokenAcquisitionToCallDownstreamApi();
builder.Services.AddAgentIdentities();
builder.Services.AddInMemoryTokenCaches();
builder.Services.AddMicrosoftGraph();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

app.Run();

Hämta en GraphServiceClient från tjänstleverantören och anropa Microsoft Graph API:er med agentidentiteten:

app.MapGet("/agent-obo-user", async (HttpContext httpContext) =>
{
    string agentIdentity = "<your-agent-identity>";

    GraphServiceClient graphServiceClient = httpContext.RequestServices.GetService<GraphServiceClient>()!;
    var me = await graphServiceClient.Me.GetAsync(r => r.Options.WithAuthenticationOptions(
        o =>
        {
            o.WithAgentIdentity(agentIdentity);
        }));
    return me.UserPrincipalName;
})
.RequireAuthorization();

Under huven omfattar OBO-flödet två tokenutbyten: först hämtar agentidentitetsritningen en exchange-token med dess klientautentiseringsuppgifter och sedan utbyter agentidentiteten den token tillsammans med användarens åtkomsttoken för en underordnade API-token. För en fullständig genomgång av protokollet, inklusive HTTP-begärandeformat och detaljer om tokenverifiering, se On-behalf-of-flödet i agenter.

Läs mer om agenttoken och relaterade API:er:

Feedback

Var den här sidan till hjälp?

Last updated on 2026-06-15

Autentisera användare och hämta token för interaktiva agenter

Förutsättningar

Behörigheter och medgivande

Använda ärvbara behörigheter

Begära medgivande

Registrera en omdirigerings-URI

Begära användarmedgivande

Begära administratörsmedgivande för alla användare

Autentisera användaren och begär en token

Verifiera åtkomsttoken

Verifiera användarpåståenden

Hämta token för underordnade API:er

Relaterat innehåll

Feedback

Ytterligare resurser