Så här använder du hanterade identiteter för Azure-resurser på en virtuell Azure-dator för att hämta en åtkomsttoken

Hanterade identiteter för Azure-resurser ger Azure-tjänster en automatiskt hanterad identitet i Microsoft Entra ID. Du kan använda den här identiteten för att autentisera mot alla tjänster som har stöd för Microsoft Entra-autentisering, utan att behöva ha några autentiseringsuppgifter i koden.

Den här artikeln innehåller olika kod- och skriptexempel för tokenförvärv. Den innehåller också vägledning om hur du hanterar förfallodatum för token och HTTP-fel.

Förutsättningar

• Om du inte känner till funktionen för hanterade identiteter för Azure-resurser kan du läsa igenom den här översikten. Om du inte har något Azure-konto registrerar du dig för ett kostnadsfritt konto innan du fortsätter.

Om du planerar att använda Azure PowerShell-exemplen i den här artikeln måste du installera den senaste versionen av Azure PowerShell.

Översikt

Ett klientprogram kan begära en appåtkomsttoken för hanterad identitet för att få åtkomst till en viss resurs. Token baseras på de hanterade identiteterna för Azure-resurstjänstens huvudnamn. Därför behöver klienten inte hämta en åtkomsttoken under sitt eget huvudnamn för tjänsten. Token är lämplig för användning som en bearer-token i tjänst-till-tjänst-anrop som kräver klientautentiseringsuppgifter.

Hämta en token med HTTP

Det grundläggande gränssnittet för att hämta en åtkomsttoken baseras på REST, vilket gör det tillgängligt för alla klientprogram som körs på den virtuella datorn och som kan göra HTTP REST-anrop. Den här metoden liknar programmeringsmodellen Microsoft Entra, förutom att klienten använder en slutpunkt på den virtuella datorn (jämfört med en Microsoft Entra-slutpunkt).

Exempelbegäran med IMDS-slutpunkten (Azure Instance Metadata Service) (rekommenderas):

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

Exempelsvar:

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

Hämta en token med hjälp av Azure Identity-klientbiblioteket

Att använda Azure Identity-klientbiblioteket är det rekommenderade sättet att använda hanterade identiteter. Alla Azure-SDK:er är integrerade med biblioteket Azure.Identity som ger stöd för DefaultAzureCredential. Den här klassen gör det enkelt att använda hanterade identiteter med Azure SDK:er.Läs mer

1. Installera Azure.Identity-paketet och andra nödvändiga Azure SDK-bibliotekspaket, till exempel Azure.Security.KeyVault.Secrets.

2. Använd exempelkoden nedan. Du behöver inte oroa dig för att få tokens. Du kan använda Azure SDK-klienterna direkt. Koden är till för att visa hur du får token, om du behöver.

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

Hämta en token med hjälp av C#

using System;
using System.Net.Http;
using Newtonsoft.Json.Linq;

// Construct HttpClient
var httpClient = new HttpClient
{
    DefaultRequestHeaders =
    {
        { "Metadata", Boolean.TrueString }
    }
};

// Construct URI to call
var resource = "https://management.azure.com/";
var uri = $"http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource={resource}";

// Make call
var response = await httpClient.GetAsync(uri);
try
{
    response.EnsureSuccessStatusCode();
}
catch (HttpRequestException)
{
    var error = await response.Content.ReadAsStringAsync();
    Console.WriteLine(error);
    throw;
}

// Parse response using Newtonsoft.Json
var content = await response.Content.ReadAsStringAsync();
var obj = JObject.Parse(content);
var accessToken = obj["access_token"];

Console.WriteLine(accessToken);

Hämta en token med Java

Använd det här JSON-biblioteket för att hämta en token med hjälp av 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;
                }
            }
        }
    }
}

Hämta en token med 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)
}

Hämta en token med PowerShell

I följande exempel visas hur du använder hanterade identiteter för REST-slutpunkten för Azure-resurser från en PowerShell-klient för att:

1. Hämta en åtkomsttoken.
2. Använd åtkomsttoken för att anropa ett Azure Resource Manager REST API och få information om den virtuella datorn. Se till att ersätta ditt prenumerations-ID, resursgruppsnamn och namn på den virtuella datorn med <SUBSCRIPTION-ID>, <RESOURCE-GROUP><VM-NAME>och , respektive.

Invoke-RestMethod -Method GET -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"}

Exempel på hur du parsar åtkomsttoken från svaret:

# Get an access token for managed identities for Azure resources
$resource = 'https://management.azure.com'
$response = Invoke-RestMethod -Method GET `
                            -Uri "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=$resource" `
                            -Headers @{ Metadata="true" }
$accessToken = $response.access_token
Write-Host "Access token using a User-Assigned Managed Identity is $accessToken"

# Use the access token to get resource information for the VM
$secureToken = $accessToken | ConvertTo-SecureString -AsPlainText
$vmInfoRest = Invoke-RestMethod -Method GET `
                              -Uri 'https://management.azure.com/subscriptions/<SUBSCRIPTION-ID>/resourceGroups/<RESOURCE-GROUP>/providers/Microsoft.Compute/virtualMachines/<VM-NAME>?api-version=2017-12-01' `
                              -ContentType 'application/json' `
                              -Authentication Bearer `
                              -Token $secureToken
Write-Host "JSON returned from call to get VM info: $($vmInfoRest.content)"

Hämta en token med 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

Exempel på hur du parsar åtkomsttoken från svaret:

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 Access token using a User-Assigned Managed Identity is $access_token

Cachelagring av token

Undersystemet för hanterade identiteter cachelagrar token, men vi rekommenderar fortfarande att du implementerar cachelagring av token i koden. Du bör förbereda dig för scenarier där resursen anger att token har upphört att gälla.

Kabelanslutna anrop till Microsoft Entra ID resulterar endast när:

• Cachemiss inträffar på grund av att det inte finns någon token i de hanterade identiteterna för cacheminnet för Azure-resursernas undersystem.
• Den cachelagrade token har upphört att gälla.

Felhantering

Slutpunkten för hanterade identiteter signalerar fel via statuskodfältet i HTTP-svarsmeddelandehuvudet, som antingen 4xx- eller 5xx-fel:

Om ett fel inträffar innehåller motsvarande HTTP-svarstext JSON med felinformationen:

Referens för HTTP-svar

I det här avsnittet dokumenteras möjliga felsvar. Statusen "200 OK" är ett lyckat svar och åtkomsttoken finns i JSON-svarstexten i elementet access_token.

Vägledning för återförsök

Försök igen om du får felkoden 404, 429 eller 5xx (se Felhantering). Om du får ett 410-fel indikerar det att IMDS går igenom uppdateringar och kommer att vara tillgängligt inom högst 70 sekunder.

Begränsningsgränser gäller för antalet anrop som görs till IMDS-slutpunkten. När tröskelvärdet för begränsning överskrids begränsar IMDS-slutpunkten eventuella ytterligare begäranden medan begränsningen gäller. Under den här perioden returnerar IMDS-slutpunkten HTTP-statuskoden 429 ("För många begäranden") och begärandena misslyckas.

För återförsök rekommenderar vi följande strategi:

Resurs-ID:t för Azure-tjänster

Se Azure-tjänster med stöd för hanterade identiteter för en lista över resurser som stöder hanterade identiteter för Azure-resurser.

Nästa steg

• Information om hur du aktiverar hanterade identiteter för Azure-resurser på en virtuell Azure-dator finns i Konfigurera hanterade identiteter för Azure-resurser på en virtuell dator med hjälp av Azure-portalen.