Delen via

Een toepassing configureren om een beheerde identiteit te vertrouwen (preview)

  • Artikel

In dit artikel wordt beschreven hoe u een Microsoft Entra-toepassing configureert om een beheerde identiteit te vertrouwen. Vervolgens kunt u het beheerde identiteitstoken uitwisselen voor een toegangstoken dat toegang heeft tot met Microsoft Entra beveiligde resources zonder dat u app-geheimen hoeft te gebruiken of te beheren.

Voorwaarden

Belangrijke overwegingen en beperkingen

Als u een federatieve identiteitsreferentie wilt maken, bijwerken of verwijderen, moet het account dat de actie uitvoert de rol van toepassingsbeheerder hebben, toepassingsontwikkelaar, cloudtoepassingsbeheerderof toepassingseigenaar. De microsoft.directory/applications/credentials/update permission is vereist om een federatieve identiteitsreferentie bij te werken.

Er kunnen maximaal 20 federatieve identiteitsreferenties worden toegevoegd aan een toepassing of door de gebruiker toegewezen beheerde identiteit.

Wanneer u een federatieve identiteitsreferentie configureert, zijn er verschillende belangrijke gegevens die u kunt opgeven:

  • uitgever en entiteit zijn de belangrijkste gegevens die nodig zijn om de vertrouwensrelatie in te stellen. De combinatie van issuer en subject moet uniek zijn in de app. Wanneer de Azure-workload Microsoft identity platform aanvraagt om het token voor beheerde identiteit uit te wisselen voor een toegangstoken, worden de uitgever en subject waarden van de federatieve identiteitsreferentie gecontroleerd op de issuer en subject claims die zijn opgegeven in het beheerde identiteit-token. Als deze validatiecontrole slaagt, geeft het Microsoft Identity Platform een toegangstoken uit aan de externe softwarewerkload.

  • issuer is de URL van de authoriteit-URL van de Microsoft Entra-tenant in het formaat https://login.microsoftonline.com/{tenant}/v2.0. De Microsoft Entra-app en de beheerde identiteit moeten deel uitmaken van dezelfde tenant. Als de issuer claim voorloop- of volgspaties in de waarde heeft, wordt de tokenuitwisseling geblokkeerd.

    Belangrijk

    Hoewel de app-registratie en de beheerde identiteit zich in dezelfde tenant moeten bevinden, kan de service-principal van de app-registratie het beheerde identiteitstoken nog steeds inwisselen.

  • onderwerp is de GUID van de object-ID (principal-ID) van de beheerde identiteit die aan de Azure-workload is toegewezen. Het Microsoft Identity Platform kijkt naar het binnenkomende externe token en weigert de uitwisseling voor een toegangstoken als het onderwerp veld dat is geconfigureerd in de federatieve identiteitsreferentie, niet overeenkomt met de principal-id van de beheerde identiteit. De GUID is hoofdlettergevoelig.

  • Belangrijk

    U kunt in deze functie alleen User-Assigned beheerde identiteiten gebruiken.

  • *Doelgroepen vermelden de doelgroepen die kunnen worden weergegeven in het externe token (vereist). U moet één doelgroepwaarde toevoegen, met een limiet van 600 tekens. De waarde moet een van de volgende zijn en moet overeenkomen met de waarde van de aud claim in het token voor beheerde identiteit.

    • openbare cloud: api://AzureADTokenExchange
    • Fairfax: api://AzureADTokenExchangeUSGov
    • Mooncake: api://AzureADTokenExchangeChina
    • USNat-: api://AzureADTokenExchangeUSNat
    • USSec: api://AzureADTokenExchangeUSSec

    Belangrijk

    Als u per ongeluk onjuiste informatie toevoegt aan de issuer, onderwerp of doelgroep, wordt de federatieve identiteitsreferentie zonder fouten aangemaakt. De fout wordt pas zichtbaar wanneer de tokenuitwisseling mislukt.

  • Naam is de unieke identificator voor de federatieve identiteitsreferentie. (Vereist) Dit veld heeft een tekenlimiet van 3-120 tekens en moet URL-vriendelijk zijn. Alfanumerieke tekens, streepjes of onderstrepingstekens worden ondersteund en het eerste teken mag alleen alfanumeriek zijn. Het is onveranderbaar nadat deze is gemaakt.

  • beschrijving is de door de gebruiker verstrekte beschrijving van de federatieve identiteitsreferentie (optioneel). De beschrijving wordt niet gevalideerd of gecontroleerd door Microsoft Entra-id. Dit veld heeft een limiet van 600 tekens.

Jokertekens worden niet ondersteund in een federatieve id-eigenschapswaarde.

De object-id van de beheerde identiteit ophalen

  1. Meld u aan bij de Azure Portal.
  2. Voer Beheerde Identiteitenin het zoekvak in. Selecteer Beheerde identiteitenonder Services.
  3. Zoek en selecteer de door de gebruiker toegewezen beheerde identiteit die u hebt gemaakt als onderdeel van de vereisten.
  4. Kopieer in het deelvenster Overzicht de waarde van de Object-id (principaal). Deze waarde wordt gebruikt als het onderwerpveld in de configuratie van federatieve referenties.

schermopname van een door de gebruiker toegewezen beheerde identiteit in Azure Portal. De object-id is gemarkeerd, die wordt gebruikt als het veld *subject* in de configuratie van federatieve referenties.

Een federatieve identiteitsreferentie configureren voor een bestaande toepassing

In deze sectie configureert u een federatieve identiteitsreferentie voor een bestaande toepassing om een beheerde identiteit te vertrouwen. Gebruik de volgende tabbladen om te kiezen hoe u een federatieve identiteitsreferentie voor een bestaande toepassing configureert.

  1. Meld u aan bij het Microsoft Entra-beheercentrum. Controleer of u zich in de tenant bevindt waar uw toepassing is geregistreerd.

  2. Blader naar Identity>Applications>App-registratiesen selecteer uw toepassing in het hoofdvenster.

  3. Selecteer onder Beheren, Certificaten & geheimen.

  4. Selecteer het tabblad Federatieve referenties en selecteer Referentie toevoegen.

    Schermopname van het deelvenster Certificaten en geheimen van het Microsoft Entra-beheercentrum met het tabblad Federatieve referenties gemarkeerd.

  5. Selecteer in het scenario met federatieve referenties vervolgkeuzelijst andere verleners en vul de waarden in volgens de volgende tabel:

    Veld Beschrijving Voorbeeld
    Uitgevende instelling De URL van de OAuth 2.0/OIDC-issuer van de Microsoft Entra ID-autoriteit. https://login.microsoftonline.com/{tenantID}/v2.0
    Onderwerp-id De Principal ID GUID van de beheerde identiteit. aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb
    Naam Een unieke beschrijvende naam voor het bewijs. msi-webapp1
    Beschrijving (optioneel) Een door de gebruiker verstrekte beschrijving van de federatieve identiteitsreferentie. vertrouw de werkbelastingen die UAMI moet imiteren voor de app-
    Audiëntie De doelgroepwaarde die moet worden weergegeven in het externe token. • openbare cloud: api://AzureADTokenExchange
    • Fairfax: api://AzureADTokenExchangeUSGov
    • Mooncake: api://AzureADTokenExchangeChina
    • USNat-: api://AzureADTokenExchangeUSNat
    • USSec: api://AzureADTokenExchangeUSSec

    Schermopname van het credentiaalvenster in het Microsoft Entra-beheercentrum.

Uw toepassingscode bijwerken om een toegangstoken aan te vragen

In onderstaande tabel ziet u codevoorbeelden die clientreferentie-'service naar service'-stromen tonen. Beheerde identiteiten als inloggegevens kunnen echter worden gebruikt in andere authenticatiestromen, zoals namens anderen (OBO)-stromen. De voorbeelden zijn geldig in beide gevallen waarin de resourcetenant zich in dezelfde tenant bevindt als de app-registratie en de beheerde identiteit, of in een andere tenant.

Azure.Identity

In het volgende voorbeeld ziet u hoe u verbinding maakt met een Azure-opslagcontainer met behulp van Azure.Identity, maar kan worden aangepast voor toegang tot elke resource die wordt beveiligd door Microsoft Entra. De voorbeelden zijn geldig zowel in gevallen waarin de resourcetenant zich in dezelfde tenant bevindt als de app-registratie en de beheerde identiteit, als in gevallen waarin het zich in een andere tenant bevindt.

using Azure.Identity;
using Azure.Storage.Blobs;

internal class Program
{
    // This example demonstrates how to access an Azure blob storage account by utilizing the manage identity credential.
  static void Main(string[] args)
  {
        string storageAccountName = "YOUR_STORAGE_ACCOUNT_NAME";
        string containerName = "CONTAINER_NAME";
        
        // The application must be granted access on the target resource
      string appClientId = "YOUR_APP_CLIENT_ID";

        // The tenant where the target resource is created, in this example, the storage account tenant
        // If the resource tenant different from the app tenant, your app needs to be 
      string resourceTenantId = "YOUR_RESOURCE_TENANT_ID";

        // The managed identity which you configured as a Federated Identity Credential (FIC)
      string miClientId = "YOUR_MANAGED_IDENTITY_CLIENT_ID"; 

        // Audience value must be one of the below values depending on the target cloud.
        // Public cloud: api://AzureADTokenExchange
        //  Fairfax: api://AzureADTokenExchangeUSGov
        //  Mooncake: api://AzureADTokenExchangeChina
        //  USNat: api://AzureADTokenExchangeUSNat
        //  USSec: api://AzureADTokenExchangeUSSec
      string audience = "api://AzureADTokenExchange";

        // 1. Create an assertion with the managed identity access token, so that it can be exchanged an app token
        var miCredential = new ManagedIdentityCredential(managedIdentityClientId);
        ClientAssertionCredential assertion = new(
            tenantId,
            appClientId,
            async (token) =>
            {
                // fetch Managed Identity token for the specified audience
                var tokenRequestContext = new Azure.Core.TokenRequestContext(new[] { $"{audience}/.default" });
                var accessToken = await miCredential.GetTokenAsync(tokenRequestContext).ConfigureAwait(false);
                return accessToken.Token;
            });

        // 2. The assertion can be used to obtain an App token (taken care of by the SDK)
        var containerClient  = new BlobContainerClient(new Uri($"https://{storageAccountName}.blob.core.windows.net/{containerName}"), assertion);

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

Microsoft.Identity.Web

In Microsoft.Identity.Webkan een webtoepassing of web-API het clientcertificaat vervangen door een ondertekende clientverklaring voor verificatie. In uw toepassing kunt u de sectie ClientCredentials in uw appsettings.json bijwerken naar de volgende configuratie:

{
  "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"
      }
   ]
  }
}

MSAL (.NET)

In MSAL-kunt u de klasse ManagedClientApplication gebruiken om een token voor beheerde identiteit te verkrijgen. Dit token kan vervolgens worden gebruikt als clientverklaring bij het maken van een vertrouwelijke clienttoepassing.

Waarschuwing

Voor .NET-apps raden we u sterk aan om bibliotheken op een hoger niveau te gebruiken die zijn gebaseerd op MSAL, zoals Microsoft.Identity.Web of Azure.Identity.

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

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

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

Zie ook