Dela via

Konfigurera ett program för att lita på en hanterad identitet

Den här artikeln beskriver hur man konfigurerar en Microsoft Entra-applikation för att lita på en hanterad identitet. Du kan sedan byta det hanterade identitetstoken mot ett åtkomsttoken som kan nå de Microsoft Entra-skyddade resurserna utan att behöva använda eller hantera apphemligheter.

Förutsättningar

Viktiga överväganden och begränsningar

Om du vill skapa, uppdatera eller ta bort en federerad identitetsautentiseringsuppgift måste kontot som utför åtgärden ha rollen Programadministratör, Programutvecklare, Molnprogramadministratöreller Programägare. Behörigheten microsoft.directory/applications/credentials/update krävs för att uppdatera en federerad identitetsautentiseringsuppgift.

Högst 20 federerade identitetsuppgifter kan läggas till i ett program eller en användartilldelad hanterad identitet.

När du konfigurerar en federerad identitetsautentiseringsuppgift finns det flera viktiga uppgifter att tillhandahålla:

  • utfärdare, ämne är de viktigaste delarna av information som behövs för att konfigurera förtroenderelationen. När Azure-arbetsbelastningen begär att Microsofts identitetsplattform byter ut den hanterade identitetstoken mot en Entra-appåtkomsttoken, kontrolleras utfärdaren och ämnesvärdena för de federerade identitetsautentiseringsuppgifterna mot anspråken issuer och subject som anges i token för hanterad identitet. Om verifieringskontrollen godkänns utfärdar Microsofts identitetsplattform en åtkomsttoken till den externa programvaruarbetsbelastningen.

  • issuer är URL:en för auktoritets-URL:en för Microsoft Entra-hyresgästens form https://login.microsoftonline.com/{tenant}/v2.0. Både Microsoft Entra-appen och den hanterade identiteten måste tillhöra samma klientorganisation. Om anspråket issuer har inledande eller avslutande blanksteg i värdet blockeras tokenväxlingen.

  • subject: Det här är skiftlägeskänsligt GUID för den hanterade identitetens objekt-ID (principal) som tilldelats Azure-arbetsbelastningen. Den hanterade identiteten måste finnas i samma klientorganisation som appregistreringen, även om målresursen finns i ett annat moln. Microsofts identitetsplattform avvisar tokenutbytet om konfigurationen subject i den federerade identitetens autentiseringsuppgifter inte exakt matchar den hanterade identitetens huvudnamns-ID.

  • målgrupper anger det värde som visas i anspråket aud i den hanterade identitetstoken (krävs). Värdet måste vara något av följande beroende på målmolnet.

    • Microsoft Entra ID global tjänst: api://AzureADTokenExchange
    • Microsoft Entra ID för amerikanska regeringen: api://AzureADTokenExchangeUSGov
    • Microsoft Entra Kina drivs av 21Vianet: api://AzureADTokenExchangeChina

    Viktigt!

    Åtkomst till resurser i en annan klientorganisation stöds. Åtkomst till resurser i ett annat moln stöds inte. Tokenbegäranden till andra moln misslyckas.

    Viktigt!

    Om du av misstag lägger till felaktig information i inställningarna för utfärdare, ämne eller målgrupp skapas den federerade identitetsreferensen framgångsrikt utan fel. Felet blir inte uppenbart förrän tokenutbytet misslyckas.

  • namn är den unika identifieraren för den federerade identitetsautentiseringsuppgiften. (Krävs) Det här fältet har en teckengräns på 3–120 tecken och måste vara URL-vänligt. Alfanumeriska tecken, bindestreck eller understreck stöds, och det första tecknet måste vara alfanumeriskt. Den är oföränderlig när den har skapats.

  • beskrivning är den användardefinierade beskrivningen av den federerade identitetsautentiseringsuppgiften (valfritt). Beskrivningen verifieras inte eller kontrolleras inte av Microsoft Entra-ID. Det här fältet har en gräns på 600 tecken.

Jokertecken stöds inte i något federerat egenskapsvärde för identitetsautentiseringsuppgifter.

Konfigurera en federerad identitetsautentiseringsuppgift i ett program

I den här sektionen kommer du att konfigurera en federerad identitetsuppgift på en befintlig applikation för att lita på en hanterad identitet. Använd följande flikar för att välja hur du vill konfigurera en federationens identitetsautentisering på en befintlig applikation.

  1. Logga in på administrationscentret för Microsoft Entra. Kontrollera att du befinner dig i den hyresgäst där din applikation är registrerad.

  2. Bläddra tillAppregistreringar för > och välj ditt program i huvudfönstret.

  3. Under Hantera väljer du Certifikat och hemligheter.

  4. Välj fliken Federerade autentiseringsuppgifter och välj Lägg till autentiseringsuppgifter.

    Skärmbild av certifikat- och sekretspanelen i Microsoft Entra admin center med fliken för federerade autentiseringsuppgifter markerad.

  5. I listrutan Federerade autentiseringsuppgifter väljer du Hanterad identitet och fyller i värdena enligt följande tabell:

    Fält Beskrivning Exempel
    Utfärdare OAuth 2.0/OIDC-utfärdarens URL för Microsoft Entra ID-auktoriteten som utfärdar token för hanterad identitet. Det här värdet fylls automatiskt i med den aktuella Entra-klientemissionären. https://login.microsoftonline.com/{tenantID}/v2.0
    Välj hanterad identitet Klicka på den här länken för att välja den hanterade identitet som ska fungera som den federerade identitetsautentiseringsuppgiften. Du kan bara använda User-Assigned hanterade identiteter som autentiseringsuppgifter. msi-webapp1
    Beskrivning (valfritt) En användarlevererad beskrivning av den federerade identitetsuppgiften. Lita på arbetsbelastningarna UAMI som en autentiseringsuppgift för min app
    Målgrupp Värdet för publiken som måste finnas i den externa token. Måste anges till något av följande värden:
    • Entra ID Global Service: api://AzureADTokenExchange
    • Entra ID för USA regering: api://AzureADTokenExchangeUSGov
    • Entra ID Kina drivs av 21Vianet: api://AzureADTokenExchangeChina

    Skärmbild av autentiseringsfönstret i Microsoft Entra administrationscenter.

Uppdatera din applikationskod för att begära en åtkomsttoken

Följande kodfragment visar hur du hämtar en hanterad identitetstoken och använder den som autentiseringsuppgifter för ditt Entra-program. Exemplen är giltiga i båda fallen där målresursen i samma klientorganisation som Entra-programmet eller i en annan klientorganisation.

Azure Identity-klientbibliotek

Följande kodexempel visar åtkomst till en Azure Key Vault-hemlighet, men kan anpassas för åtkomst till alla resurser som skyddas av Microsoft Entra.

using Azure.Core;
using Azure.Identity;
using Azure.Security.KeyVault.Secrets;

// Audience value must be one of the below values depending on the target cloud:
// - Entra ID Global cloud: api://AzureADTokenExchange
// - Entra ID US Government: api://AzureADTokenExchangeUSGov
// - Entra ID China operated by 21Vianet: api://AzureADTokenExchangeChina
string miAudience = "api://AzureADTokenExchange";

// Create an assertion with the managed identity access token, so that it can be
// exchanged for an app token. Client ID is passed here. Alternatively, either
// object ID or resource ID can be passed.
ManagedIdentityCredential miCredential = new(
    ManagedIdentityId.FromUserAssignedClientId("<YOUR_MI_CLIENT_ID>"));
TokenRequestContext tokenRequestContext = new([$"{miAudience}/.default"]);
ClientAssertionCredential clientAssertionCredential = new(
    "<YOUR_RESOURCE_TENANT_ID>",
    "<YOUR_APP_CLIENT_ID>",
    async _ =>
        (await miCredential
            .GetTokenAsync(tokenRequestContext)
            .ConfigureAwait(false)).Token
);

// Create a new SecretClient using the assertion
SecretClient client = new(
    new Uri("https://testfickv.vault.azure.net/"), 
    clientAssertionCredential);

// Retrieve the secret
KeyVaultSecret secret = client.GetSecret("<SECRET_NAME>");

Microsoft.Identity.Web

I Microsoft.Identity.Web kan du ange avsnittet ClientCredentials i dinappsettings.json som ska använda SignedAssertionFromManagedIdentity för att aktivera koden med den konfigurerade hanterade identiteten som autentiseringsuppgifter:

{
  "AzureAd": {
    "Instance": "https://login.microsoftonline.com/",
    "ClientId": "YOUR_APPLICATION_ID",
    "TenantId": "YOUR_TENANT_ID",
    
    "ClientCredentials": [
      {
        "SourceType": "SignedAssertionFromManagedIdentity",
        "ManagedIdentityClientId": "YOUR_USER_ASSIGNED_MANAGED_IDENTITY_CLIENT_ID",
        "TokenExchangeUrl": "api://AzureADTokenExchange/.default"
      }
    ]
  }
}

MSAL (.NET)

I MSAL kan du använda klassen ManagedClientApplication för att skaffa en Managed Identity-token. Denna token kan sedan användas som en klientbekräftelse när man konstruerar en konfidentiell klientapplikation.

using Microsoft.Identity.Client;
using Microsoft.Identity.Client.AppConfig;
using Azure.Storage.Blobs;
using Azure.Core;
using Azure.Storage.Blobs.Models;

internal class Program
{
  static async Task Main(string[] args)
  {
      string storageAccountName = "YOUR_STORAGE_ACCOUNT_NAME";
      string containerName = "CONTAINER_NAME";

      string appClientId = "YOUR_APP_CLIENT_ID";
      string resourceTenantId = "YOUR_RESOURCE_TENANT_ID";
      Uri authorityUri = new($"https://login.microsoftonline.com/{resourceTenantId}");
      string miClientId = "YOUR_MI_CLIENT_ID";
      string audience = "api://AzureADTokenExchange/.default";

      // Get mi token to use as assertion
      var miAssertionProvider = async (AssertionRequestOptions _) =>
      {
            var miApplication = ManagedIdentityApplicationBuilder
                .Create(ManagedIdentityId.WithUserAssignedClientId(miClientId))
                .Build();

            var miResult = await miApplication.AcquireTokenForManagedIdentity(audience)
                .ExecuteAsync()
                .ConfigureAwait(false);
            return miResult.AccessToken;
      };

      // Create a confidential client application with the assertion.
      IConfidentialClientApplication app = ConfidentialClientApplicationBuilder.Create(appClientId)
        .WithAuthority(authorityUri, false)
        .WithClientAssertion(miAssertionProvider)
        .WithCacheOptions(CacheOptions.EnableSharedCacheOptions)
        .Build();

        // Get the federated app token for the storage account
        string[] scopes = [$"https://{storageAccountName}.blob.core.windows.net/.default"];
        AuthenticationResult result = await app.AcquireTokenForClient(scopes).ExecuteAsync().ConfigureAwait(false);

        TokenCredential tokenCredential = new AccessTokenCredential(result.AccessToken);
        var containerClient = new BlobContainerClient(
            new Uri($"https://{storageAccountName}.blob.core.windows.net/{containerName}"),
            tokenCredential);

        await foreach (BlobItem blob in containerClient.GetBlobsAsync())
        {
            // TODO: perform operations with the blobs
            BlobClient blobClient = containerClient.GetBlobClient(blob.Name);
            Console.WriteLine($"Blob name: {blobClient.Name}, URI: {blobClient.Uri}");
        }
    }
}

Se även