Partilhar via

Configurar um aplicativo para confiar em uma identidade gerenciada (visualização)

  • Artigo

Este artigo descreve como configurar um aplicativo Microsoft Entra para confiar em uma identidade gerenciada. Em seguida, você pode trocar o token de identidade gerenciado por um token de acesso que pode acessar recursos protegidos do Microsoft Entra sem precisar usar ou gerenciar segredos do aplicativo.

Pré-requisitos

Considerações e restrições importantes

Para criar, atualizar ou excluir uma credencial de identidade federada, a conta que executa a ação deve ter o de Administrador de Aplicativos, de Desenvolvedor de Aplicativos, de Administrador de Aplicativos na Nuvem ou a função de Proprietário do Aplicativo. O de permissão microsoft.directory/applications/credentials/update é necessário para atualizar uma credencial de identidade federada.

Um máximo de 20 credenciais de identidade federada pode ser adicionado a um aplicativo ou identidade gerenciada atribuída pelo usuário.

Quando você configura uma credencial de identidade federada, há várias informações importantes a serem fornecidas:

  • do emitente e assunto são as principais informações necessárias para estabelecer a relação de confiança. A combinação de issuer e subject deve ser exclusiva no aplicativo. Quando a carga de trabalho do Azure solicita que a plataforma de identidade da Microsoft troque o token de Identidade Gerenciada por um token de acesso, o do emissor de e valores de de assunto da credencial de identidade federada são verificados em relação às declarações de e fornecidas no token de Identidade Gerenciada. Se essa verificação de validação for aprovada, a plataforma de identidade da Microsoft emitirá um token de acesso à carga de trabalho de software externo.

  • do emissor é a URL da Autoridade do locatário do Microsoft Entra no formato https://login.microsoftonline.com/{tenant}/v2.0. O Aplicativo Microsoft Entra e a Identidade Gerenciada devem pertencer ao mesmo locatário. Se a declaração de issuer tiver espaço em branco à esquerda ou à direita no valor, a troca de token será bloqueada.

    Importante

    Embora o registo da aplicação e a identidade gerida devam estar no mesmo locatário, o principal de serviço do registo da aplicação ainda pode resgatar o token de identidade gerida.

  • assunto é o GUID da ID de Objeto (ID Principal) da Identidade Gerenciada atribuída à carga de trabalho do Azure. A plataforma de identidade da Microsoft examina o token externo de entrada e rejeita a troca por um token de acesso se o campo de assunto configurado na Credencial de Identidade Federada não corresponder à ID Principal da Identidade Gerenciada. O GUID é sensível a maiúsculas e minúsculas.

  • Importante

    Você só pode usar User-Assigned Identidades Gerenciadas neste recurso.

  • *audiences listam os públicos que podem aparecer no token externo (Obrigatório). Você deve adicionar um único valor de audiência, que tem um limite de 600 caracteres. O valor deve ser um dos seguintes e deve corresponder ao valor da declaração de aud no token de Identidade Gerenciada.

    • : nuvem pública: api://AzureADTokenExchange
    • Fairfax: api://AzureADTokenExchangeUSGov
    • Mooncake: api://AzureADTokenExchangeChina
    • USNat: api://AzureADTokenExchangeUSNat
    • USSec: api://AzureADTokenExchangeUSSec

    Importante

    Se adicionar acidentalmente informações incorretas nodo emissor , assunto ou público, a credencial de identidade federada será criada com sucesso e sem erro. O erro não se torna aparente até que a troca de token falhe.

  • nome é o identificador exclusivo da credencial de identidade federada. (Obrigatório) Este campo tem um limite de caracteres de 3 a 120 caracteres e deve ser amigável para URL. Há suporte para caracteres alfanuméricos, traços ou sublinhados, e o primeiro caractere deve ser apenas alfanumérico. É imutável uma vez criado.

  • descrição é a descrição fornecida pelo usuário da credencial de identidade federada (opcional). A descrição não é validada ou verificada pela ID do Microsoft Entra. Este campo tem um limite de 600 caracteres.

Não há suporte para caracteres universais em nenhum valor nas propriedades das credenciais de identidade federada.

Obter a ID do objeto da identidade gerenciada

  1. Inicie sessão no portal do Azure.
  2. Na caixa de pesquisa, introduza Identidades Geridas. Em Serviços, selecione Identidades Gerenciadas.
  3. Procure e selecione a identidade gerenciada atribuída pelo usuário que você criou como parte dos pré-requisitos .
  4. No painel Visão Geral, copie o valor do ID do objeto (principal) . Esse valor é usado como o campo assunto na configuração de credenciais federadas.

Captura de ecrã de uma identidade gerida atribuída pelo utilizador no portal do Azure. O ID do objeto é realçado, que será usado como o campo *assunto* na configuração de credenciais federadas.

Configurar uma credencial de identidade federada em um aplicativo existente

Nesta seção, você configurará uma credencial de identidade federada em um aplicativo existente para confiar em uma identidade gerenciada. Use as guias a seguir para escolher como configurar uma credencial de identidade federada em um aplicativo existente.

  1. Entre no centro de administração do Microsoft Entra. Verifique se está no locatário onde a sua aplicação está registada.

  2. Navegue até Identity>Applications>Registros de aplicativose selecione seu aplicativo na janela principal.

  3. Em Gerenciar, selecione Certificados & segredos.

  4. Selecione a guia Credenciais federadas e selecione Adicionar credencial.

    Captura de ecrã do painel de certificados e segredos do centro de administração do Microsoft Entra com o separador de credenciais federadas realçado.

  5. No menu suspenso do cenário de credenciais federadas , selecione Outros Emissores e preencha os valores, de acordo com a tabela a seguir:

    Campo Descrição Exemplo
    Emissor A URL do emissor OAuth 2.0 / OIDC da autoridade Microsoft Entra ID. https://login.microsoftonline.com/{tenantID}/v2.0
    Identificador do assunto O GUID Principal ID da identidade gerenciada. aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb
    Nome Um nome descritivo exclusivo para a credencial. msi-webapp1
    Descrição (Opcional) Uma descrição fornecida pelo usuário da credencial de identidade federada. Confie nas cargas de trabalho UAMI para representar o aplicativo
    Público-alvo O valor de audiência que deve aparecer no token externo. • Nuvem pública: api://AzureADTokenExchange
    • Fairfax: api://AzureADTokenExchangeUSGov
    • Mooncake: api://AzureADTokenExchangeChina
    • USNat: api://AzureADTokenExchangeUSNat
    • USSec: api://AzureADTokenExchangeUSSec

    Captura de ecrã da janela de credenciais no centro de administração do Microsoft Entra.

Atualize o código do aplicativo para solicitar um token de acesso

Os exemplos de código a seguir na tabela a seguir mostram fluxos de credenciais de cliente "serviço a serviço". No entanto, as identidades gerenciadas como uma credencial podem ser usadas em outros fluxos de autenticação, como fluxos em nome de (OBO). Os exemplos são válidos em ambos os casos, quer o locatário do recurso esteja no mesmo locatário que o registo da aplicação e a identidade gerida, ou em um locatário diferente.

Azure.Identity

O exemplo a seguir demonstra como se conectar a um contêiner de armazenamento do Azure usando Azure.Identity, mas pode ser adaptado para acessar qualquer recurso protegido pelo Microsoft Entra. Os exemplos são válidos em ambos os casos: quando o locatário do recurso está no mesmo locatário que o registo do aplicativo e a identidade gerida, ou num locatário diferente.

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

Em Microsoft.Identity.Web, um aplicativo Web ou API Web pode substituir o certificado do cliente por uma declaração de cliente assinada para autenticação. Em seu aplicativo, você pode atualizar a seção ClientCredentials em seu appsettings.json para a seguinte configuração:

{
  "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)

No MSAL, pode usar a classe ManagedClientApplication para adquirir um token de Identidade Gerida. Esse token pode ser usado como uma asserção de cliente ao construir um aplicativo cliente confidencial.

Advertência

Para aplicativos .NET, é altamente recomendável usar bibliotecas de nível superior baseadas no MSAL, como Microsoft.Identity.Web ou 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}");
        }
  }
}

Ver também