Guide pratique de l’utilisation d’identités managées pour ressources Azure sur une machine virtuelle Azure afin d’acquérir un jeton d’accès

Les identités managées pour les ressources Azure sont une fonctionnalité de Microsoft Entra ID. Les services Azure prenant en charge les identités managées pour ressources Azure sont soumis à leur propre chronologie. Assurez-vous de passer en revue l’état Disponibilité des identités gérées pour votre ressource et les problèmes connus avant de commencer.

Les identités managées pour les ressources Azure fournissent aux services Azure une identité automatiquement gérée dans Microsoft Entra ID. Vous pouvez utiliser cette identité pour vous authentifier auprès de n’importe quel service prenant en charge l’authentification Microsoft Entra, sans avoir d’informations d’identification dans votre code.

Cet article fournit divers exemples de code et de script pour l’acquisition de jetons. Il contient également des conseils sur la gestion de l’expiration des jetons et des erreurs HTTP.

Prérequis

• Si vous n’êtes pas familiarisé de la fonctionnalité identités managées pour ressources Azure, consultez cette Vue d’ensemble. Si vous n’avez pas encore de compte Azure, Inscrivez-vous sur un compte gratuit avant de continuer.

Si vous envisagez d’utiliser les exemples de Azure PowerShell dans cet article, veillez à installer la dernière version de Azure PowerShell.

Vue d’ensemble

Une application cliente peut demander un jeton d’accès d’application uniquement d’identité managée pour accéder à une ressource donnée. Le jeton est basé sur le principal du service des identités managées pour ressources Azure. Par conséquent, il n’est pas nécessaire que le client obtienne un jeton d’accès sous son propre principal du service. Le jeton peut être utilisé comme un jeton du porteur dans les appels de service à service nécessitant des informations d’identification du client.

Obtenir un jeton par HTTP

L’interface fondamentale pour l’acquisition d’un jeton d’accès est basée sur REST, le rendant accessible à toute application cliente en cours d’exécution sur la machine virtuelle et pouvant effectuer des appels REST par HTTP. Cette approche est similaire au modèle de programmation Microsoft Entra, sauf que le client utilise un point de terminaison sur la machine virtuelle (par rapport à un point de terminaison Microsoft Entra).

Exemple de requête utilisant le point de terminaison IMDS (Instance Metadata Service) Azure (recommandé) :

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

Exemple de réponse :

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

Obtenir un jeton à l’aide de la bibliothèque de client d’identité Azure

L’utilisation de la bibliothèque de client d’identité Azure est la méthode recommandée pour utiliser des identités managées. Tous les kits de développement logiciel (SDK) Azure sont intégrés à la bibliothèque Azure.Identity, qui prend en charge DefaultAzureCredential. Cette classe facilite l’utilisation des identités managées avec les kits de développement logiciel (SDK) Azure.En savoir plus

1. Installez le package Azure.Identity et les autres packages de bibliothèque de kit de développement logiciel (SDK) Azure nécessaires, comme Azure.Security.KeyVault.Secrets.

2. Utilisez l’exemple de code ci-dessous. Vous n’avez pas à vous inquiéter de recevoir des jetons expirés. Vous pouvez utiliser directement les clients du kit de développement logiciel (SDK) Azure. Le code est destiné à illustrer comment obtenir le jeton, si nécessaire.

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

Obtenir un jeton à l’aide de la bibliothèque Microsoft.Azure.Services.AppAuthentication pour .NET

Pour les applications et fonctions .NET, la façon la plus simple d’utiliser des identités managées pour ressources Azure consiste à se servir du package Microsoft.Azure.Services.AppAuthentication. Cette bibliothèque vous permet également de tester votre code localement sur votre ordinateur de développement. Vous pouvez tester votre code à l’aide de votre compte d’utilisateur à partir de Visual Studio, d’Azure CLI ou de l’authentification intégrée Active Directory. Pour plus d’informations sur les options de développement local avec cette bibliothèque, consultez le Guide de référence technique sur Microsoft.Azure.Services.AppAuthentication. Cette section vous montre comment prendre en main la bibliothèque dans votre code.

1. Ajoutez des références aux packages NuGet Microsoft.Azure.Services.AppAuthentication et Microsoft.Azure.KeyVault à votre application.

2. Ajoutez le code suivant à votre application :

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

Pour en savoir plus sur Microsoft.Azure.Services.AppAuthentication et les opérations qu’il expose, voir le Guide de référence technique sur Microsoft.Azure.Services.AppAuthentication et l’exemple .NET d’utilisation d’App Service et de Key Vault avec des identités managées pour ressources Azure.

Obtenir un jeton par 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");
}

Obtenir un jeton par le biais de Java

Utilisez cette bibliothèque JSON pour récupérer un jeton à l’aide de 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;
                }
            }
        }
    }
}

Obtenir un jeton par 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)
}

Obtenir un jeton à l’aide de PowerShell

L’exemple suivant montre comment utiliser le point de terminaison REST d’identités managées pour ressources Azure à partir d’un client PowerShell :

1. Obtenez un jeton d’accès.
2. Utilisez le jeton d’accès pour appeler une API REST de Azure Resource Manager et obtenez des informations sur la machine virtuelle. Indiquez votre ID d’abonnement, le nom de groupe de ressources et le nom de la machine virtuelle respectivement à la place de <SUBSCRIPTION-ID>, <RESOURCE-GROUP>, et <VM-NAME>.

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

Exemple d’extraction du jeton d’accès de la réponse :

# 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

Obtenir un jeton par 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

Exemple d’extraction du jeton d’accès de la réponse :

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

Mise en cache de jeton

Le sous-système d’identités managées met en cache les jetons, mais nous vous recommandons quand même d’implémenter la mise en cache des jetons dans votre code. Vous devez vous préparer pour les scénarios dans lesquels la ressource indique que le jeton a expiré.

Les appels téléphoniques vers Microsoft Entra ID résultent uniquement lorsque :

• Une absence de mise en cache se produit en raison de l’absence de jeton dans le cache du sous-système des identités managées pour les ressources Azure.
• Le jeton mis en cache a expiré.

Gestion des erreurs

Le point de terminaison d’identités managées signale des erreurs par le biais du champ de code d’état de l’en-tête du message de la réponse HTTP en tant qu’erreurs 4xx ou 5xx :

Si une erreur se produit, le corps de réponse HTTP correspondant contient des données JSON avec les détails de l’erreur :

Référence de réponse HTTP

Cette section documente les réponses possibles aux erreurs. Un état « 200 OK » est une réponse correcte, et le jeton d’accès est contenu au sein du corps de réponse JSON, dans l’élément access_token.

Conseils sur les nouvelles tentatives

Il est recommandé d’effectuer une nouvelle tentative si vous recevez un code d’erreur 404, 429 ou 5xx (consultez la section Gestion des erreurs ci-dessus). Si vous recevez une erreur 410, elle indique que des mises à jour sont en cours sur IMDS et que la solution sera disponible dans un maximum de 70 secondes.

La limitation s’applique au nombre d’appels effectués au point de terminaison IMDS. Quand le seuil de limitation est dépassé, le point de terminaison IMDS limite toutes les autres requêtes pendant que la limitation est appliquée. Pendant cette période, le point de terminaison IMDS retourne le code d’état HTTP 429 (« Trop de requêtes ») et les requêtes échouent.

Pour une nouvelle tentative, nous vous recommandons la stratégie suivante :

ID de ressource pour les services Azure

Pour obtenir la liste des ressources qui prennent en charge les identités managées pour les ressources Azure, consultez Services Azure qui prennent en charge les identités managées.

Étapes suivantes

• Pour activer les identités managées pour ressources Azure sur une machine virtuelle Azure, voir Configurer des identités managées pour ressources Azure sur une machine virtuelle en utilisant le portail Azure.