Configurare un'applicazione per considerare attendibile un'identità gestita (anteprima)

Questo articolo descrive come configurare un'applicazione Microsoft Entra per considerare attendibile un'identità gestita. È quindi possibile scambiare il token di identità gestita per un token di accesso che può accedere alle risorse protette di Microsoft Entra senza dover usare o gestire i segreti dell'app.

Prerequisiti

• Un account Azure con una sottoscrizione attiva. Crea un account gratuitamente.
• Questo account Azure deve disporre delle autorizzazioni per gestire le applicazioni, in particolare per autorizzazioni di aggiornamento. Uno dei seguenti ruoli di Microsoft Entra include le autorizzazioni necessarie:
  • Amministratore applicazioni
  • Sviluppatore di applicazioni
  • amministratore di applicazioni cloud
• Una comprensione dei concetti di identità gestite per le risorse di Azure.
• Un'identità gestita assegnata dall'utente assegnata alla risorsa di calcolo di Azure (ad esempio, una macchina virtuale o un servizio app di Azure) che ospita il carico di lavoro.
• Un di registrazione dell'app in Microsoft Entra ID. La registrazione dell'app deve appartenere allo stesso tenant dell'identità gestita
  • Se è necessario accedere alle risorse in un altro tenant, la registrazione dell'app deve essere un'applicazione multi-tenant e l'app deve essere distribuita nell'altro tenant. Inoltre, è necessario concedere all'app le autorizzazioni di accesso alle risorse in tale tenant. Informazioni su come aggiungere un'app multitenant in altri tenant
• La registrazione dell'app deve avere accesso alle risorse protette di Microsoft Entra (ad esempio, Azure, Microsoft Graph, Microsoft 365 e così via). Questo accesso può essere concesso tramite autorizzazioni API o autorizzazioni delegate .

Considerazioni e restrizioni importanti

Per creare, aggiornare o eliminare una credenziale di identità federata, l'account che esegue l'azione deve avere il ruolo amministratore applicazione , Sviluppatore di applicazioni, Amministratore applicazioni cloudo Proprietario applicazione. È necessaria l'autorizzazione microsoft.directory/applications/credentials/update per aggiornare una credenziale di identità federata.

È possibile aggiungere al massimo 20 credenziali di identità federate a un'applicazione o a un'identità gestita assegnata dall'utente.

Quando si configura una credenziale di identità federata, sono disponibili diverse informazioni importanti da fornire:

• L'emittente e il soggetto sono le informazioni chiave necessarie per configurare la relazione di fiducia. La combinazione di issuer e subject deve essere univoca nell'app. Quando il carico di lavoro di Azure richiede a Microsoft Identity Platform di scambiare il token di identità gestita per un token di accesso, l'autorità di certificazione e soggetto valori delle credenziali dell'identità federata vengono controllati rispetto alle attestazioni e fornite nel token di identità gestita. Se il controllo di convalida viene superato, Microsoft Identity Platform rilascia un token di accesso al carico di lavoro esterno del software.

• emittente è l'URL dell'autorità del tenant di Microsoft Entra nel formato https://login.microsoftonline.com/{tenant}/v2.0. L'app Microsoft Entra e l'identità gestita devono appartenere allo stesso tenant. Se l'attestazione issuer contiene spazi vuoti iniziali o finali nel valore, lo scambio di token viene bloccato.

  Importante

  Anche se la registrazione dell'app e l'identità gestita devono trovarsi nello stesso tenant, l'entità servizio della registrazione dell'app può comunque riscattare il token di identità gestita.

• oggetto è il GUID dell'ID dell'oggetto dell'identità gestita (ID del principale) assegnata al carico di lavoro di Azure. La piattaforma di identità Microsoft esamina il token esterno e rifiuta lo scambio di un token di accesso se il campo soggetto configurato nella credenziale dell'identità federata non corrisponde all'ID principale dell'identità gestita. Il GUID fa distinzione tra maiuscole e minuscole.

• Importante

  In questa funzionalità è possibile usare solo identità gestite User-Assigned.

• *I gruppi di destinatari elencano i gruppi di destinatari che possono essere visualizzati nel token esterno (obbligatorio). È necessario aggiungere un singolo valore del gruppo di destinatari, con un limite di 600 caratteri. Il valore deve essere uno dei seguenti e deve corrispondere al valore dell'attestazione aud nel token di Identità Gestita.

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

  Importante

  Se si aggiungono accidentalmente informazioni errate nell'emittente , nel soggetto o nel destinatario , la credenziale di identità federata viene creata correttamente senza errori. L'errore non diventa evidente fino a quando lo scambio di token non riesce.

• nome è l'identificatore univoco per la credenziale di identità federata. (Obbligatorio) Questo campo ha un limite di caratteri di 3-120 caratteri e deve essere descrittivo per l'URL. Sono supportati caratteri alfanumerici, trattini o caratteri di sottolineatura e il primo carattere deve essere solo alfanumerico. Una volta creato, non è modificabile.

• descrizione è la descrizione fornita dall'utente della credenziale dell'identità federata (facoltativa). La descrizione non viene convalidata o controllata da Microsoft Entra ID. Questo campo ha un limite di 600 caratteri.

I caratteri jolly non sono supportati in nessun valore delle proprietà delle credenziali di identità federata.

Ottenere l'ID dell'oggetto dell'identità gestita

1. Accedi al portale Azure .
2. Nella casella di ricerca immettere identità gestite. In Servicesselezionare Identità Gestite.
3. Cercare e selezionare l'identità gestita assegnata dall'utente creata come parte dei prerequisiti .
4. Nel riquadro Panoramica copiare il valore ID object (principal). Questo valore viene usato come campo oggetto nella configurazione delle credenziali federate.

Configurare una credenziale di identità federata in un'applicazione esistente

In questa sezione si configurerà una credenziale di identità federata in un'applicazione esistente per considerare attendibile un'identità gestita. Usare le schede seguenti per scegliere come configurare una credenziale di identità federata in un'applicazione esistente.

az ad app federated-credential create --id 00001111-aaaa-2222-bbbb-3333cccc4444 --parameters credential.json

{
    "name": "msi-webapp1",
    "issuer": "https://login.microsoftonline.com/{tenantID}/v2.0",
    "subject": "00001111-aaaa-2222-bbbb-3333cccc4444",
    "description": "Trust the workload's UAMI to impersonate the App",
    "audiences": [
        "api://AzureADTokenExchange"
    ]
}

New-AzADAppFederatedCredential -ApplicationObjectId $appObjectId -Audience api://AzureADTokenExchange -Issuer 'https://login.microsoftonline.com/{tenantID}/v2.0' -Name 'MyMsiFic' -Subject '00001111-aaaa-2222-bbbb-3333cccc4444'

az rest --method POST --uri 'https://graph.microsoft.com/applications/{app_registration_id}/federatedIdentityCredentials' --body '{"name":"MyMsiFicTest","issuer":"https://login.microsoftonline.com/{tenantID}/v2.0","subject":"{Managed_Identity_Principal_ID}","description":"Trust the workloads UAMI to impersonate the App","audiences":["api://AzureADTokenExchange"]}'

extension 'br:mcr.microsoft.com/bicep/extensions/microsoftgraph/v1.0:0.1.8-preview'

param myWorkloadManagedIdentity string = '[MANAGED-IDENTITY-NAME]'
param applicationDisplayName string = '[APPLICATION-DISPLAYNAME]'
param applicationName string = '[APPLICATION-UNIQUE-NAME]'

resource myManagedIdentity 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' existing = {
  name: myWorkloadManagedIdentity
}

resource myApp 'Microsoft.Graph/applications@v1.0' = {
  displayName: applicationDisplayName
  uniqueName: applicationName

  resource myMsiFic 'federatedIdentityCredentials@v1.0' = {
    name: '${myApp.uniqueName}/msiAsFic'
    description: 'Trust the workloads UAMI to impersonate the App'
    audiences: [
       'api://AzureADTokenExchange'
    ]
    issuer: '${environment().authentication.loginEndpoint}${tenant().tenantId}/v2.0'
    subject: myManagedIdentity.properties.principalId
  }
}

Aggiornare il codice dell'applicazione per richiedere un token di accesso

Gli esempi di codice seguenti nella tabella seguente illustrano i flussi di credenziali client "da servizio a servizio". Tuttavia, le identità gestite come credenziali possono essere usate in altri flussi di autenticazione, ad esempio flussi OBO (On-Behalf-of). Gli esempi sono validi in entrambi i casi: quando il tenant della risorsa si trova nello stesso tenant della registrazione dell'app e dell'identità gestita, oppure in un tenant diverso.

Azure.Identity

L'esempio seguente illustra come connettersi a un contenitore di archiviazione di Azure usando Azure.Identity, ma può essere adattato per accedere a qualsiasi risorsa protetta da Microsoft Entra. Gli esempi sono validi in entrambi i casi: quando il tenant della risorsa si trova nello stesso tenant della registrazione dell'app e dell'identità gestita, oppure in un tenant diverso.

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.Web, un'applicazione Web o un'API Web può sostituire il certificato client con un'asserzione client firmata per l'autenticazione. Nell'applicazione, puoi aggiornare la sezione ClientCredentials del tuo appsettings.json alla configurazione seguente:

{
  "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è possibile usare la classe ManagedClientApplication per acquisire un token di identità gestita. Questo token può quindi essere usato come asserzione client quando si crea un'applicazione client riservata.

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

Vedere anche

• Considerazioni importanti e restrizioni per le credenziali di identità federate.