Cómo usar identidades administradas de recursos de Azure en una máquina virtual de Azure para adquirir un token de acceso

Identidades administradas para recursos de Azure es una característica de Microsoft Entra ID. Cada servicio de Azure compatible con Managed Identities for Azure Resources está sujeto a su propia escala de tiempo. Asegúrese de revisar el estado de disponibilidad de las identidades administradas para el recurso y los problemas conocidos antes de comenzar.

Las identidades administradas de los recursos de Azure proporcionan a los servicios de Azure una identidad administrada automáticamente en Microsoft Entra ID. Puede usar esta identidad para autenticar a cualquier servicio que admita la autenticación de Microsoft Entra, sin necesidad de tener credenciales en el código.

En este artículo se proporcionan varios ejemplos de código y script para la adquisición de tokens. También contiene instrucciones sobre cómo controlar la expiración del token y los errores HTTP.

Prerrequisitos

• Si no está familiarizado con la característica Managed Identities for Azure Resources, consulte esta introducción. Si no tiene una cuenta de Azure, regístrese para obtener una cuenta gratuita antes de continuar.

Si tiene previsto usar los ejemplos de Azure PowerShell de este artículo, no se olvide de instalar la última versión de Azure PowerShell.

Información general

Una aplicación cliente puede solicitar un token de acceso de solo aplicación de identidad administrada para acceder a un recurso determinado. El token se basa en la entidad de servicio de identidades administradas de recursos de Azure. Por lo tanto, no es necesario que el cliente obtenga un token de acceso en su propia entidad de servicio. El token es adecuado para utilizarse como un token de portador en llamadas de servicio a servicio que requieren credenciales de cliente.

Obtención de un token con HTTP

La interfaz básica para obtener un token de acceso se basa en REST, de modo que podrá acceder a cualquier aplicación cliente que se ejecute en la máquina virtual que es capaz de realizar llamadas REST de HTTP. Este enfoque es similar al modelo de programación de Microsoft Entra, salvo que el cliente usa un punto de conexión en la máquina virtual (frente a un punto de conexión de Microsoft Entra).

Solicitud de ejemplo con el punto de conexión de Azure Instance Metadata Service (IMDS) (opción recomendada) :

GET 'http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https://management.azure.com/' HTTP/1.1 Metadata: true

Respuesta de ejemplo:

HTTP/1.1 200 OK
Content-Type: application/json
{
  "access_token": "eyJ0eXAi...",
  "refresh_token": "",
  "expires_in": "3599",
  "expires_on": "1506484173",
  "not_before": "1506480273",
  "resource": "https://management.azure.com/",
  "token_type": "Bearer"
}

Obtención de un token mediante la biblioteca cliente de identidad de Azure

El uso de la biblioteca cliente de identidad de Azure es la manera recomendada de usar identidades administradas. Todos los SDK de Azure se integran con la biblioteca Azure.Identity que proporciona compatibilidad con DefaultAzureCredential. Esta clase facilita el uso de identidades administradas con los SDK de Azure. Más información

1. Instale el paquete Azure.Identity y otros paquetes necesarios de la biblioteca del SDK de Azure, como Azure.Security.KeyVault.Secrets.

2. Use el código de ejemplo siguiente. No es necesario preocuparse por la obtención de tokens. Puede usar directamente los clientes del SDK de Azure. El código es para mostrar cómo obtener el token, si es necesario.

   using Azure.Core;
   using Azure.Identity;
   
   string userAssignedClientId = "<your managed identity client Id>";
   var credential = new DefaultAzureCredential(new DefaultAzureCredentialOptions { ManagedIdentityClientId = userAssignedClientId });
   var accessToken = credential.GetToken(new TokenRequestContext(new[] { "https://vault.azure.net" }));
   // To print the token, you can convert it to string 
   String accessTokenString = accessToken.Token.ToString();
   
   //You can use the credential object directly with Key Vault client.     
   var client = new SecretClient(new Uri("https://myvault.vault.azure.net/"), credential);
   

Obtención de un token con la biblioteca Microsoft.Azure.Services.AppAuthentication para .NET

En el caso de las aplicaciones y las funciones de .NET, la manera más sencilla de trabajar con identidades administradas de recursos de Azure es a través del paquete Microsoft.Azure.Services.AppAuthentication. Esta biblioteca también le permitirá probar el código localmente en la máquina de desarrollo. Puede probar el código con su cuenta de usuario desde Visual Studio, la CLI de Azure o la autenticación integrada de Active Directory. Para obtener más información sobre las opciones de desarrollo local con esta biblioteca, consulte la referencia de Microsoft.Azure.Services.AppAuthentication. En esta sección se muestra cómo empezar a usar la biblioteca en su código.

1. Agregue referencias a los paquetes de NuGet Microsoft.Azure.Services.AppAuthentication y Microsoft.Azure.KeyVault para la aplicación.

2. Agregue el siguiente código a su aplicación:

   using Microsoft.Azure.Services.AppAuthentication;
   using Microsoft.Azure.KeyVault;
   // ...
   var azureServiceTokenProvider = new AzureServiceTokenProvider();
   string accessToken = await azureServiceTokenProvider.GetAccessTokenAsync("https://management.azure.com/");
   // OR
   var kv = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback));
   

Para obtener más información sobre Microsoft.Azure.Services.AppAuthentication y las operaciones que expone, consulte la referencia de Microsoft.Azure.Services.AppAuthentication y el ejemplo de .NET sobre App Service y KeyVault con identidades administradas de recursos de Azure.

Obtención de un token con C#

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Web.Script.Serialization; 

// Build request to acquire managed identities for Azure resources token
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https://management.azure.com/");
request.Headers["Metadata"] = "true";
request.Method = "GET";

try
{
    // Call /token endpoint
    HttpWebResponse response = (HttpWebResponse)request.GetResponse();

    // Pipe response Stream to a StreamReader, and extract access token
    StreamReader streamResponse = new StreamReader(response.GetResponseStream()); 
    string stringResponse = streamResponse.ReadToEnd();
    JavaScriptSerializer j = new JavaScriptSerializer();
    Dictionary<string, string> list = (Dictionary<string, string>) j.Deserialize(stringResponse, typeof(Dictionary<string, string>));
    string accessToken = list["access_token"];
}
catch (Exception e)
{
    string errorText = String.Format("{0} \n\n{1}", e.Message, e.InnerException != null ? e.InnerException.Message : "Acquire token failed");
}

Obtención de un token con Java

Use esta biblioteca JSON para recuperar un token con Java.

import java.io.*;
import java.net.*;
import com.fasterxml.jackson.core.*;
 
class GetMSIToken {
    public static void main(String[] args) throws Exception {
 
        URL msiEndpoint = new URL("http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https://management.azure.com/");
        HttpURLConnection con = (HttpURLConnection) msiEndpoint.openConnection();
        con.setRequestMethod("GET");
        con.setRequestProperty("Metadata", "true");
 
        if (con.getResponseCode()!=200) {
            throw new Exception("Error calling managed identity token endpoint.");
        }
 
        InputStream responseStream = con.getInputStream();
 
        JsonFactory factory = new JsonFactory();
        JsonParser parser = factory.createParser(responseStream);
 
        while(!parser.isClosed()){
            JsonToken jsonToken = parser.nextToken();
 
            if(JsonToken.FIELD_NAME.equals(jsonToken)){
                String fieldName = parser.getCurrentName();
                jsonToken = parser.nextToken();
 
                if("access_token".equals(fieldName)){
                    String accesstoken = parser.getValueAsString();
                    System.out.println("Access Token: " + accesstoken.substring(0,5)+ "..." + accesstoken.substring(accesstoken.length()-5));
                    return;
                }
            }
        }
    }
}

Obtención de un token con Go

package main

import (
  "fmt"
  "io/ioutil"
  "net/http"
  "net/url"
  "encoding/json"
)

type responseJson struct {
  AccessToken string `json:"access_token"`
  RefreshToken string `json:"refresh_token"`
  ExpiresIn string `json:"expires_in"`
  ExpiresOn string `json:"expires_on"`
  NotBefore string `json:"not_before"`
  Resource string `json:"resource"`
  TokenType string `json:"token_type"`
}

func main() {
    
    // Create HTTP request for a managed services for Azure resources token to access Azure Resource Manager
    var msi_endpoint *url.URL
    msi_endpoint, err := url.Parse("http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01")
    if err != nil {
      fmt.Println("Error creating URL: ", err)
      return 
    }
    msi_parameters := msi_endpoint.Query()
    msi_parameters.Add("resource", "https://management.azure.com/")
    msi_endpoint.RawQuery = msi_parameters.Encode()
    req, err := http.NewRequest("GET", msi_endpoint.String(), nil)
    if err != nil {
      fmt.Println("Error creating HTTP request: ", err)
      return 
    }
    req.Header.Add("Metadata", "true")

    // Call managed services for Azure resources token endpoint
    client := &http.Client{}
    resp, err := client.Do(req) 
    if err != nil{
      fmt.Println("Error calling token endpoint: ", err)
      return
    }

    // Pull out response body
    responseBytes,err := ioutil.ReadAll(resp.Body)
    defer resp.Body.Close()
    if err != nil {
      fmt.Println("Error reading response body : ", err)
      return
    }

    // Unmarshall response body into struct
    var r responseJson
    err = json.Unmarshal(responseBytes, &r)
    if err != nil {
      fmt.Println("Error unmarshalling the response:", err)
      return
    }

    // Print HTTP response and marshalled response body elements to console
    fmt.Println("Response status:", resp.Status)
    fmt.Println("access_token: ", r.AccessToken)
    fmt.Println("refresh_token: ", r.RefreshToken)
    fmt.Println("expires_in: ", r.ExpiresIn)
    fmt.Println("expires_on: ", r.ExpiresOn)
    fmt.Println("not_before: ", r.NotBefore)
    fmt.Println("resource: ", r.Resource)
    fmt.Println("token_type: ", r.TokenType)
}

Obtención de un token mediante PowerShell

En el ejemplo siguiente se muestra cómo utilizar el punto de conexión REST de identidades administradas de recursos de Azure desde un cliente de PowerShell para las siguientes tareas:

1. Obtener un token de acceso.
2. Usar el token de acceso para llamar a una API de REST de Azure Resource Manager y consultar información sobre la máquina virtual. No olvide sustituir el identificador de suscripción, el nombre del grupo de recursos y el nombre de máquina virtual en <SUBSCRIPTION-ID>, <RESOURCE-GROUP> y <VM-NAME> respectivamente.

Invoke-WebRequest -Uri 'http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https%3A%2F%2Fmanagement.azure.com%2F' -Headers @{Metadata="true"}

Ejemplo de cómo analizar el token de acceso de la respuesta:

# Get an access token for managed identities for Azure resources
$response = Invoke-WebRequest -Uri 'http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https%3A%2F%2Fmanagement.azure.com%2F' `
                              -Headers @{Metadata="true"}
$content =$response.Content | ConvertFrom-Json
$access_token = $content.access_token
echo "The managed identities for Azure resources access token is $access_token"

# Use the access token to get resource information for the VM
$vmInfoRest = (Invoke-WebRequest -Uri 'https://management.azure.com/subscriptions/<SUBSCRIPTION-ID>/resourceGroups/<RESOURCE-GROUP>/providers/Microsoft.Compute/virtualMachines/<VM-NAME>?api-version=2017-12-01' -Method GET -ContentType "application/json" -Headers @{ Authorization ="Bearer $access_token"}).content
echo "JSON returned from call to get VM info:"
echo $vmInfoRest

Obtención de un token con CURL

curl 'http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https%3A%2F%2Fmanagement.azure.com%2F' -H Metadata:true -s

Ejemplo de cómo analizar el token de acceso de la respuesta:

response=$(curl 'http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https%3A%2F%2Fmanagement.azure.com%2F' -H Metadata:true -s)
access_token=$(echo $response | python -c 'import sys, json; print (json.load(sys.stdin)["access_token"])')
echo The managed identities for Azure resources access token is $access_token

Almacenamiento en caché de tokens

El subsistema de identidades administradas almacena en caché los tokens, pero se recomienda implementar el almacenamiento en caché de tokens en el código. Debe prepararse para escenarios en los que el recurso indica que el token ha expirado.

Las llamadas por cable a Microsoft Entra ID solo se generan cuando:

• el error de caché se produce debido a que no hay ningún token en la caché del subsistema de identidades administradas de recursos de Azure.
• el token almacenado en caché ha expirado.

Control de errores

El punto de conexión de identidades administradas señala los errores a través del campo de código de estado del encabezado del mensaje de respuesta HTTP, como errores 4xx o 5xx:

Si se produce un error, el cuerpo de respuesta HTTP correspondiente contiene los detalles del error en formato JSON:

Referencia de la respuesta HTTP

En esta sección se documentan las posibles respuestas de error. Un estado de "200 OK" es una respuesta correcta y el token de acceso se encuentra en el cuerpo de respuesta JSON; en el elemento access_token.

Instrucciones de reintento

Se recomienda reintentar si recibe un código de error 404, 429 o 5xx (consulte Control de errores arriba). Si recibe un error 410, significa que IMDS se está actualizando y estará disponible en 70 segundos como máximo.

Se aplican límites al número de llamadas realizadas al punto de conexión de IMDS. Cuando se supera el umbral de limitación, el punto de conexión de IMDS limita las solicitudes sucesivas mientras la limitación está en vigor. Durante este período, el punto de conexión de IMDS devuelve el código de estado HTTP 429 ("Demasiadas solicitudes") y se producirá un error en las solicitudes.

Para volver a intentarlo, se recomienda la estrategia siguiente:

Identificadores de recurso para los servicios de Azure

Consulte Servicios de Azure con compatibilidad con identidades administradas para obtener una lista de recursos que admiten identidades administradas para recursos de Azure.

Pasos siguientes

• Para habilitar las identidades administradas de recursos de Azure en una máquina virtual de Azure, consulte Configure managed identities for Azure resources on a VM using the Azure portal (Configuración de identidades administradas de recursos de Azure en una VM mediante Azure Portal).