Ansluta från ditt program till resurser utan att hantera autentiseringsuppgifter
Artikel
Azure-resurser med stöd för hanterade identiteter ger alltid ett alternativ för att ange en hanterad identitet för att ansluta till Azure-resurser som stöder Microsoft Entra-autentisering. Stöd för hanterade identiteter gör det onödigt för utvecklare att hantera autentiseringsuppgifter i kod. Hanterade identiteter är det rekommenderade autentiseringsalternativet när du arbetar med Azure-resurser som stöder dem.
Läs en översikt över hanterade identiteter.
Den här sidan visar hur du konfigurerar en App Service så att den kan ansluta till Azure Key Vault, Azure Storage och Microsoft SQL Server. Samma principer kan användas för alla Azure-resurser som stöder hanterade identiteter och som ansluter till resurser som stöder Microsoft Entra-autentisering.
Kodexemplen använder Azure Identity-klientbiblioteket, vilket är den rekommenderade metoden eftersom det automatiskt hanterar många av stegen åt dig, inklusive att hämta en åtkomsttoken som används i anslutningen.
Vilka resurser kan hanterade identiteter ansluta till?
En hanterad identitet kan ansluta till alla resurser som stöder Microsoft Entra-autentisering. I allmänhet krävs inget särskilt stöd för resursen för att tillåta att hanterade identiteter ansluter till den.
Vissa resurser stöder inte Microsoft Entra-autentisering, eller så har deras klientbibliotek inte stöd för autentisering med en token. Fortsätt läsa för att se vår vägledning om hur du använder en hanterad identitet för att på ett säkert sätt komma åt autentiseringsuppgifterna utan att behöva lagra dem i din kod- eller programkonfiguration.
Skapa en hanterad identitet
Det finns två typer av hanterade identiteter: systemtilldelade och användartilldelade. Systemtilldelade identiteter är direkt länkade till en enda Azure-resurs. När Azure-resursen tas bort, så är även identiteten. En användartilldelad hanterad identitet kan associeras med flera Azure-resurser och dess livscykel är oberoende av dessa resurser.
Vi rekommenderar att du använder en användartilldelad hanterad identitet i de flesta scenarier. Om källresursen som du använder inte stöder användartilldelade hanterade identiteter bör du läsa den resursproviderns dokumentation för att lära dig hur du konfigurerar den så att den har en systemtilldelad hanterad identitet.
Viktigt!
Kontot som används för att skapa hanterade identiteter behöver en roll som "Hanterad identitetsdeltagare" för att skapa en ny användartilldelad hanterad identitet.
Skapa en användartilldelad hanterad identitet med det alternativ du föredrar:
När du har skapat en användartilldelad hanterad identitet bör du anteckna värdena clientIdprincipalId och som returneras när den hanterade identiteten skapas. Du använder principalId när du lägger till behörigheter och clientId i programmets kod.
Konfigurera App Service med en användartilldelad hanterad identitet
Innan du kan använda den hanterade identiteten i koden måste vi tilldela den till den App Service som ska använda den. Processen för att konfigurera en App Service för att använda en användartilldelad hanterad identitet kräver att du anger den hanterade identitetens resursidentifierare i appkonfigurationen.
Lägga till behörigheter till identiteten
När du har konfigurerat Din App Service att använda en användartilldelad hanterad identitet beviljar du identiteten nödvändiga behörigheter. I det här scenariot använder vi den här identiteten för att interagera med Azure Storage, så du måste använda RBAC-systemet (Azure Role Based Access Control) för att bevilja resursen användartilldelade hanterade identitetsbehörigheter.
Viktigt!
Du behöver en roll som "Administratör för användaråtkomst" eller "Ägare" för målresursen för att lägga till rolltilldelningar. Se till att du beviljar den lägsta behörighet som krävs för att programmet ska kunna köras.
Alla resurser som du vill komma åt kräver att du beviljar identitetsbehörigheter. Om du till exempel begär en token för att få åtkomst till Key Vault måste du också lägga till en åtkomstprincip som innehåller appens eller funktionens hanterade identitet. Annars avvisas dina anrop till Key Vault, även om du använder en giltig token. Detsamma gäller för Azure SQL Database. Mer information om vilka resurser som stöder Microsoft Entra-token finns i Azure-tjänster som stöder Microsoft Entra-autentisering.
Använda hanterade identiteter i koden
När du har slutfört stegen ovan har Din App Service en hanterad identitet med behörighet till en Azure-resurs. Du kan använda den hanterade identiteten för att hämta en åtkomsttoken som din kod kan använda för att interagera med Azure-resurser, i stället för att lagra autentiseringsuppgifter i koden.
Vi rekommenderar att du använder de klientbibliotek som vi tillhandahåller för önskat programmeringsspråk. Dessa bibliotek hämtar åtkomsttoken åt dig, vilket gör det enkelt att autentisera med Microsoft Entra-ID. Mer information finns i Klientbibliotek för autentisering av hanterade identiteter.
Använda ett Azure Identity-bibliotek för att få åtkomst till Azure-resurser
Azure Identity-biblioteken anger var och en en DefaultAzureCredential typ.
DefaultAzureCredential försöker automatiskt autentisera användaren via olika flöden, inklusive miljövariabler eller ett interaktivt inloggningsflöde. Autentiseringstypen kan användas i en utvecklingsmiljö med dina egna autentiseringsuppgifter. Den kan också användas i din Azure-produktionsmiljö med hjälp av en hanterad identitet. Inga kodändringar krävs när du distribuerar ditt program.
Om du använder användartilldelade hanterade identiteter bör du också uttryckligen ange den användartilldelade hanterade identitet som du vill autentisera med genom att skicka in identitetens klient-ID som en parameter. Du kan hämta klient-ID:t genom att bläddra till identiteten i Azure Portal.
using Azure.Identity;
using Azure.Storage.Blobs;
// code omitted for brevity
// Specify the Client ID if using user-assigned managed identities
var clientID = Environment.GetEnvironmentVariable("Managed_Identity_Client_ID");
var credentialOptions = new DefaultAzureCredentialOptions
{
ManagedIdentityClientId = clientID
};
var credential = new DefaultAzureCredential(credentialOptions);
var blobServiceClient1 = new BlobServiceClient(new Uri("<URI of Storage account>"), credential);
BlobContainerClient containerClient1 = blobServiceClient1.GetBlobContainerClient("<name of blob>");
BlobClient blobClient1 = containerClient1.GetBlobClient("<name of file>");
if (blobClient1.Exists())
{
var downloadedBlob = blobClient1.Download();
string blobContents = downloadedBlob.Value.Content.ToString();
}
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.storage.blob.BlobClient;
import com.azure.storage.blob.BlobContainerClient;
import com.azure.storage.blob.BlobServiceClient;
import com.azure.storage.blob.BlobServiceClientBuilder;
// read the Client ID from your environment variables
String clientID = System.getProperty("Client_ID");
DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
.managedIdentityClientId(clientID)
.build();
BlobServiceClient blobStorageClient = new BlobServiceClientBuilder()
.endpoint("<URI of Storage account>")
.credential(credential)
.buildClient();
BlobContainerClient blobContainerClient = blobStorageClient.getBlobContainerClient("<name of blob container>");
BlobClient blobClient = blobContainerClient.getBlobClient("<name of blob/file>");
if (blobClient.exists()) {
String blobContent = blobClient.downloadContent().toString();
}
import { DefaultAzureCredential } from "@azure/identity";
import { BlobServiceClient } from "@azure/storage-blob";
// Specify the Client ID if using user-assigned managed identities
const clientID = process.env.Managed_Identity_Client_ID;
const credential = new DefaultAzureCredential({
managedIdentityClientId: clientID
});
const blobServiceClient = new BlobServiceClient("<URI of Storage account>", credential);
const containerClient = blobServiceClient.getContainerClient("<name of blob>");
const blobClient = containerClient.getBlobClient("<name of file>");
async function downloadBlob() {
if (await blobClient.exists()) {
const downloadBlockBlobResponse = await blobClient.download();
const downloadedBlob = await streamToString(downloadBlockBlobResponse.readableStreamBody);
console.log("Downloaded blob content:", downloadedBlob);
}
}
async function streamToString(readableStream) {
return new Promise((resolve, reject) => {
const chunks = [];
readableStream.on("data", (data) => {
chunks.push(data.toString());
});
readableStream.on("end", () => {
resolve(chunks.join(""));
});
readableStream.on("error", reject);
});
}
downloadBlob().catch(console.error);
from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient
import os
# Specify the Client ID if using user-assigned managed identities
client_id = os.getenv("Managed_Identity_Client_ID")
credential = DefaultAzureCredential(managed_identity_client_id=client_id)
blob_service_client = BlobServiceClient(account_url="<URI of Storage account>", credential=credential)
container_client = blob_service_client.get_container_client("<name of blob>")
blob_client = container_client.get_blob_client("<name of file>")
def download_blob():
if blob_client.exists():
download_stream = blob_client.download_blob()
blob_contents = download_stream.readall().decode('utf-8')
print("Downloaded blob content:", blob_contents)
download_blob()
package main
import (
"context"
"fmt"
"io"
"os"
"strings"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func main() {
// The client ID for the user-assigned managed identity is read from the AZURE_CLIENT_ID env var
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
fmt.Printf("failed to obtain a credential: %v\n", err)
return
}
accountURL := "<URI of Storage account>"
containerName := "<name of blob>"
blobName := "<name of file>"
serviceClient, err := azblob.NewServiceClient(accountURL, cred, nil)
if err != nil {
fmt.Printf("failed to create service client: %v\n", err)
return
}
containerClient := serviceClient.NewContainerClient(containerName)
blobClient := containerClient.NewBlobClient(blobName)
// Check if the blob exists
_, err = blobClient.GetProperties(context.Background(), nil)
if err != nil {
fmt.Printf("failed to get blob properties: %v\n", err)
return
}
// Download the blob
downloadResponse, err := blobClient.Download(context.Background(), nil)
if err != nil {
fmt.Printf("failed to download blob: %v\n", err)
return
}
// Read the blob content
blobData := downloadResponse.Body(nil)
defer blobData.Close()
blobContents := new(strings.Builder)
_, err = io.Copy(blobContents, blobData)
if err != nil {
fmt.Printf("failed to read blob data: %v\n", err)
return
}
fmt.Println("Downloaded blob content:", blobContents.String())
}
Komma åt en hemlighet som lagras i Azure Key Vault
using Azure.Identity;
using Azure.Security.KeyVault.Secrets;
using Azure.Core;
// code omitted for brevity
// Specify the Client ID if using user-assigned managed identities
var clientID = Environment.GetEnvironmentVariable("Managed_Identity_Client_ID");
var credentialOptions = new DefaultAzureCredentialOptions
{
ManagedIdentityClientId = clientID
};
var credential = new DefaultAzureCredential(credentialOptions);
var client = new SecretClient(
new Uri("https://<your-unique-key-vault-name>.vault.azure.net/"),
credential);
KeyVaultSecret secret = client.GetSecret("<my secret>");
string secretValue = secret.Value;
using Azure.Identity;
using Microsoft.Data.SqlClient;
// code omitted for brevity
// Specify the Client ID if using user-assigned managed identities
var clientID = Environment.GetEnvironmentVariable("Managed_Identity_Client_ID");
var credentialOptions = new DefaultAzureCredentialOptions
{
ManagedIdentityClientId = clientID
};
AccessToken accessToken = await new DefaultAzureCredential(credentialOptions).GetTokenAsync(
new TokenRequestContext(new string[] { "https://database.windows.net//.default" }));
using var connection = new SqlConnection("Server=<DB Server>; Database=<DB Name>;")
{
AccessToken = accessToken.Token
};
var cmd = new SqlCommand("select top 1 ColumnName from TableName", connection);
await connection.OpenAsync();
SqlDataReader dr = cmd.ExecuteReader();
while(dr.Read())
{
Console.WriteLine(dr.GetValue(0).ToString());
}
dr.Close();
Om du använder Azure Spring Apps kan du ansluta till Azure SQL Databases med hjälp av en hanterad identitet utan att göra några ändringar i koden.
src/main/resources/application.properties Öppna filen och lägg till Authentication=ActiveDirectoryMSI; i slutet av följande rad. Se till att använda rätt värde för $AZ_DATABASE_NAME variabeln.
import { DefaultAzureCredential } from "@azure/identity";
import { Connection, Request } from "tedious";
// Specify the Client ID if using a user-assigned managed identity
const clientID = process.env.Managed_Identity_Client_ID;
const credential = new DefaultAzureCredential({
managedIdentityClientId: clientID
});
async function getAccessToken() {
const tokenResponse = await credential.getToken("https://database.windows.net//.default");
return tokenResponse.token;
}
async function queryDatabase() {
const accessToken = await getAccessToken();
const config = {
server: "<your-server-name>",
authentication: {
type: "azure-active-directory-access-token",
options: {
token: accessToken
}
},
options: {
database: "<your-database-name>",
encrypt: true
}
};
const connection = new Connection(config);
connection.on("connect", err => {
if (err) {
console.error("Connection failed:", err);
return;
}
const request = new Request("SELECT TOP 1 ColumnName FROM TableName", (err, rowCount, rows) => {
if (err) {
console.error("Query failed:", err);
return;
}
rows.forEach(row => {
console.log(row.value);
});
connection.close();
});
connection.execSql(request);
});
connection.connect();
}
queryDatabase().catch(err => console.error("Error:", err));
import os
from azure.identity import DefaultAzureCredential
from azure.core.credentials import AccessToken
import pyodbc
# Specify the Client ID if using a user-assigned managed identity
client_id = os.getenv("Managed_Identity_Client_ID")
credential = DefaultAzureCredential(managed_identity_client_id=client_id)
# Get the access token
token = credential.get_token("https://database.windows.net//.default")
access_token = token.token
# Set up the connection string
connection_string = "Driver={ODBC Driver 18 for SQL Server};Server=<your-server-name>;Database=<your-database-name>;"
# Connect to the database
connection = pyodbc.connect(connection_string, attrs_before={"AccessToken": access_token})
# Execute the query
cursor = connection.cursor()
cursor.execute("SELECT TOP 1 ColumnName FROM TableName")
# Fetch and print the result
row = cursor.fetchone()
while row:
print(row)
row = cursor.fetchone()
# Close the connection
cursor.close()
connection.close()
package main
import (
"context"
"database/sql"
"fmt"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/denisenkom/go-mssqldb"
)
func main() {
// The client ID for the user-assigned managed identity is read from the AZURE_CLIENT_ID env var
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
fmt.Printf("failed to obtain a credential: %v\n", err)
return
}
// Get the access token
token, err := credential.GetToken(context.TODO(), azidentity.TokenRequestOptions{
Scopes: []string{"https://database.windows.net//.default"},
})
if err != nil {
fmt.Printf("Failed to get token: %v\n", err)
return
}
// Set up the connection string
connString := fmt.Sprintf("sqlserver://<your-server-name>?database=<your-database-name>&access_token=%s", token.Token)
// Connect to the database
db, err := sql.Open("sqlserver", connString)
if err != nil {
fmt.Printf("Failed to connect to the database: %v\n", err)
return
}
defer db.Close()
// Execute the query
rows, err := db.QueryContext(context.TODO(), "SELECT TOP 1 ColumnName FROM TableName")
if err != nil {
fmt.Printf("Failed to execute query: %v\n", err)
return
}
defer rows.Close()
// Fetch and print the result
for rows.Next() {
var columnValue string
if err := rows.Scan(&columnValue); err != nil {
fmt.Printf("Failed to scan row: %v\n", err)
return
}
fmt.Println(columnValue)
}
}
Använda Microsoft Authentication Library (MSAL) för att få åtkomst till Azure-resurser
Förutom Azure Identity-biblioteken kan du även använda MSAL för att komma åt Azure-resurser med hjälp av hanterade identiteter. Följande kodfragment visar hur du använder MSAL för att komma åt Azure-resurser på olika programmeringsspråk.
För systemtilldelade hanterade identiteter behöver utvecklaren inte skicka någon ytterligare information. MSAL härleder automatiskt relevanta metadata om den tilldelade identiteten. För användartilldelade hanterade identiteter måste utvecklaren skicka antingen klient-ID, fullständig resursidentifierare eller objekt-ID för den hanterade identiteten.
Du kan sedan hämta en token för att komma åt en resurs. Innan du använder hanterade identiteter måste utvecklare aktivera dem för de resurser som de vill använda.
using Microsoft.Identity.Client;
using System;
string resource = "https://vault.azure.net";
// Applies to system-assigned managed identities only
IManagedIdentityApplication mi = ManagedIdentityApplicationBuilder.Create(ManagedIdentityId.SystemAssigned)
.Build();
// Applies to user-assigned managed identities only
string userAssignedManagedIdentityClientId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
IManagedIdentityApplication mi = ManagedIdentityApplicationBuilder.Create(ManagedIdentityId.WithUserAssignedClientId(userAssignedManagedIdentityClientId))
.Build();
// Acquire token
AuthenticationResult result = await mi.AcquireTokenForManagedIdentity(resource)
.ExecuteAsync()
.ConfigureAwait(false);
if (!string.IsNullOrEmpty(result.AccessToken))
{
Console.WriteLine(result.AccessToken);
}
import com.microsoft.aad.msal4j.IAuthenticationResult;
import com.microsoft.aad.msal4j.ManagedIdentityApplication;
import com.microsoft.aad.msal4j.ManagedIdentityId;
import com.microsoft.aad.msal4j.ManagedIdentityParameters;
String resource = "https://vault.azure.net";
// Use this for user-assigned managed identities
private static final String USER_ASSIGNED_MI_CLIENT_ID = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
// Use this for system-assigned managed identities
ManagedIdentityApplication miApp = ManagedIdentityApplication
.builder(ManagedIdentityId.systemAssigned())
.build();
// Use this for user-assigned managed identities
ManagedIdentityApplication miApp = ManagedIdentityApplication
.builder(ManagedIdentityId.userAssignedClientId(USER_ASSIGNED_MI_CLIENT_ID))
.build();
// Acquire token
IAuthenticationResult result = miApp.acquireTokenForManagedIdentity(
ManagedIdentityParameters.builder(resource)
.build()).get();
System.out.println(result.accessToken());
import {
LogLevel,
LoggerOptions,
AuthenticationResult,
} from "@azure/msal-common";
import {
ManagedIdentityRequestParams,
ManagedIdentityConfiguration,
ManagedIdentityApplication,
ManagedIdentityIdParams,
NodeSystemOptions,
} from "@azure/msal-node";
// Define resource
const managedIdentityRequestParams: ManagedIdentityRequestParams = {
resource: "https://vault.azure.net",
};
// This section applies to user-assigned managed identities only
const userAssignedManagedIdentityIdParams: ManagedIdentityIdParams = {
userAssignedClientId: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
};
const userAssignedManagedIdentityConfig: ManagedIdentityConfiguration = {
userAssignedManagedIdentityIdParams, // applicable to user-assigned managed identities only
// optional for logging
system: {
loggerOptions: {
logLevel: LogLevel.Verbose,
} as LoggerOptions,
} as NodeSystemOptions,
};
const userSystemAssignedManagedIdentityApplication: ManagedIdentityApplication =
new ManagedIdentityApplication(userAssignedManagedIdentityConfig);
// Acquire token: user-assigned managed identity
const response: AuthenticationResult =
await userAssignedManagedIdentityApplication.acquireToken(
managedIdentityRequestParams
);
// This section applies to system-assigned managed identities only
const systemAssignedManagedIdentityConfig: ManagedIdentityConfiguration = {
// optional for logging
system: {
loggerOptions: {
logLevel: LogLevel.Verbose,
} as LoggerOptions,
} as NodeSystemOptions,
};
const systemAssignedManagedIdentityApplication: ManagedIdentityApplication =
new ManagedIdentityApplication(systemAssignedManagedIdentityConfig);
// Acquire token: system-assigned managed identity
const response: AuthenticationResult =
await systemAssignedManagedIdentityApplication.acquireToken(
managedIdentityRequestParams
);
console.log(response);
import msal
import requests
# Use this for system-assigned managed identities
managed_identity = msal.SystemAssignedManagedIdentity()
# Use this for user-assigned managed identities
userAssignedClientId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
managed_identity = msal.UserAssignedManagedIdentity(client_id=userAssignedClientId)
global_app = msal.ManagedIdentityClient(managed_identity, http_client=requests.Session())
result = global_app.acquire_token_for_client(resource='https://vault.azure.net')
if "access_token" in result:
print("Token obtained!")
MSAL Go stöder inte hanterade identiteter än. Du kan använda Azure Identity-biblioteket för att hämta token för hanterade identiteter.
Ansluta till resurser som inte stöder Microsoft Entra-ID eller tokenbaserad autentisering i bibliotek
Vissa Azure-resurser har antingen inte stöd för Microsoft Entra-autentisering ännu, eller så har deras klientbibliotek inte stöd för autentisering med en token. Dessa resurser är vanligtvis tekniker med öppen källkod som förväntar sig ett användarnamn och lösenord eller en åtkomstnyckel i en anslutningssträng.
Om du vill undvika att lagra autentiseringsuppgifter i koden eller programkonfigurationen kan du lagra autentiseringsuppgifterna som en hemlighet i Azure Key Vault. Med exemplet ovan kan du hämta hemligheten från Azure KeyVault med hjälp av en hanterad identitet och skicka autentiseringsuppgifterna till din anslutningssträng. Den här metoden innebär att inga autentiseringsuppgifter behöver hanteras direkt i din kod eller miljö. Ett detaljerat exempel finns i Använda hanterade identiteter för att få åtkomst till Azure Key Vault-certifikat. Mer information om Azure Key Vault-autentisering finns i Azure Key Vault-autentisering.
Riktlinjer om du hanterar token direkt
I vissa scenarier kanske du vill hämta token för hanterade identiteter manuellt i stället för att använda en inbyggd metod för att ansluta till målresursen. Dessa scenarier omfattar inget klientbibliotek för det programmeringsspråk som du använder eller målresursen som du ansluter till eller ansluter till resurser som inte körs i Azure. När du hämtar token manuellt tillhandahåller vi följande riktlinjer:
Cachelagrar de token som du hämtar
För prestanda och tillförlitlighet rekommenderar vi att ditt program cachelagrar token i lokalt minne eller krypteras om du vill spara dem på disk. Eftersom hanterade identitetstoken är giltiga i 24 timmar finns det ingen fördel med att begära nya token regelbundet, eftersom en cachelagrad token returneras från den token som utfärdar slutpunkten. Om du överskrider begärandegränserna kommer du att vara begränsad och få ett HTTP 429-fel.
När du skaffar en token kan du ange att din tokencache upphör att gälla 5 minuter före den expires_on (eller motsvarande egenskap) som returneras när token genereras.
Tokenkontroll
Programmet bör inte förlita sig på innehållet i en token. Tokens innehåll är endast avsett för målgruppen (målresursen) som används, inte den klient som begär token. Tokeninnehållet kan ändras eller krypteras i framtiden.
Exponera eller flytta inte token
Token ska behandlas som autentiseringsuppgifter. Exponera dem inte för användare eller andra tjänster. till exempel loggnings-/övervakningslösningar. De bör inte flyttas från källresursen som använder dem, förutom för att autentisera mot målresursen.