Připojení z aplikace k prostředkům bez zpracování přihlašovacích údajů
Článek
Prostředky Azure se spravovanými identitami podporují vždy možnost zadat spravovanou identitu pro připojení k prostředkům Azure, které podporují ověřování Microsoft Entra. Díky podpoře spravovaných identit vývojáři nespravuje přihlašovací údaje v kódu. Spravované identity jsou doporučenou možností ověřování při práci s prostředky Azure, které je podporují.
Přečtěte si přehled spravovaných identit.
Tato stránka ukazuje, jak nakonfigurovat službu App Service, aby se mohl připojit ke službě Azure Key Vault, Azure Storage a Microsoft SQL Serveru. Stejné principy je možné použít pro jakýkoli prostředek Azure, který podporuje spravované identity a který se připojí k prostředkům, které podporují ověřování Microsoft Entra.
Ukázky kódu používají klientskou knihovnu Azure Identity, což je doporučená metoda, protože automaticky zpracovává mnoho kroků za vás, včetně získání přístupového tokenu použitého v připojení.
K jakým prostředkům se můžou spravované identity připojit?
Spravovaná identita se může připojit k libovolnému prostředku, který podporuje ověřování Microsoft Entra. Obecně platí, že pro prostředek není nutná žádná zvláštní podpora, aby se k němu mohly připojit spravované identity.
Některé prostředky nepodporují ověřování Microsoft Entra nebo jejich klientská knihovna nepodporuje ověřování pomocí tokenu. Pokračujte ve čtení a podívejte se na naše pokyny, jak používat spravovanou identitu k bezpečnému přístupu k přihlašovacím údajům, aniž byste je museli ukládat do konfigurace kódu nebo aplikace.
Vytvoření spravované identity
Existují dva typy spravovaných identit: přiřazené systémem a přiřazené uživatelem. Identity přiřazené systémem jsou přímo propojené s jedním prostředkem Azure. Když se prostředek Azure odstraní, je to identita. Spravovanou identitu přiřazenou uživatelem je možné přidružit k více prostředkům Azure a její životní cyklus je nezávislý na těchto prostředcích.
Pro většinu scénářů doporučujeme používat spravovanou identitu přiřazenou uživatelem. Pokud zdrojový prostředek, který používáte, nepodporuje spravované identity přiřazené uživatelem, měli byste se podívat do dokumentace poskytovatele prostředků a zjistit, jak ho nakonfigurovat tak, aby měla spravovanou identitu přiřazenou systémem.
Důležité
Účet použitý k vytváření spravovaných identit potřebuje k vytvoření nové spravované identity roli, například Přispěvatel spravovaných identit.
Vytvořte spravovanou identitu přiřazenou uživatelem pomocí preferované možnosti:
Po vytvoření spravované identity přiřazené uživatelem si poznamenejte clientId hodnoty, principalId které se vrátí při vytvoření spravované identity. Používáte principalId při přidávání oprávnění a clientId v kódu aplikace.
Konfigurace služby App Service pomocí spravované identity přiřazené uživatelem
Než budete moct ve svém kódu použít spravovanou identitu, musíme ji přiřadit službě App Service, která ji bude používat. Proces konfigurace služby App Service tak, aby používal spravovanou identitu přiřazenou uživatelem, vyžaduje, abyste v konfiguraci aplikace zadali identifikátor prostředku spravované identity.
Přidání oprávnění k identitě
Jakmile nakonfigurujete službu App Service tak, aby používala spravovanou identitu přiřazenou uživatelem, udělte identitě potřebná oprávnění. V tomto scénáři používáme tuto identitu k interakci se službou Azure Storage, takže k udělení oprávnění spravované identity přiřazené uživatelem k prostředku potřebujete použít systém řízení přístupu na základě role (RBAC).
Důležité
K přidání přiřazení rolí budete potřebovat roli správce uživatelských přístupů nebo vlastníka cílového prostředku. Ujistěte se, že udělujete nejnižší požadovaná oprávnění ke spuštění aplikace.
Všechny prostředky, ke kterým chcete získat přístup, vyžadují udělení oprávnění identit. Pokud například požadujete token pro přístup ke službě Key Vault, musíte také přidat zásadu přístupu, která zahrnuje spravovanou identitu vaší aplikace nebo funkce. Jinak budou vaše volání do služby Key Vault odmítnuta, i když použijete platný token. Totéž platí pro Azure SQL Database. Další informace o tom, které prostředky podporují tokeny Microsoft Entra, najdete v tématu Služby Azure, které podporují ověřování Microsoft Entra.
Použití spravovaných identit v kódu
Po dokončení výše uvedených kroků má služba App Service spravovanou identitu s oprávněními k prostředku Azure. Spravovanou identitu můžete použít k získání přístupového tokenu, který váš kód může použít k interakci s prostředky Azure místo ukládání přihlašovacích údajů do kódu.
Doporučujeme používat klientské knihovny, které poskytujeme pro váš preferovaný programovací jazyk. Tyto knihovny získávají přístupové tokeny za vás, což usnadňuje ověřování pomocí Microsoft Entra ID. Další informace najdete v tématu Klientské knihovny pro ověřování spravovaných identit.
Použití knihovny identit Azure pro přístup k prostředkům Azure
Knihovny identit Azure poskytují typ DefaultAzureCredential .
DefaultAzureCredential se pokusí automaticky ověřit uživatele prostřednictvím různých toků, včetně proměnných prostředí nebo interaktivního přihlašování. Typ přihlašovacích údajů můžete použít ve vývojovém prostředí s vlastními přihlašovacími údaji. Dá se také použít v produkčním prostředí Azure pomocí spravované identity. Při nasazování aplikace se nevyžadují žádné změny kódu.
Pokud používáte spravované identity přiřazené uživatelem, měli byste také explicitně zadat spravovanou identitu přiřazenou uživatelem, kterou chcete ověřit předáním ID klienta identity jako parametru. ID klienta můžete načíst tak, že přejdete na identitu na webu 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())
}
Přístup k tajnému kódu uloženému ve službě 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();
Pokud používáte Azure Spring Apps, můžete se ke službě Azure SQL Database připojit pomocí spravované identity, aniž byste museli provádět změny kódu.
src/main/resources/application.properties Otevřete soubor a přidejte Authentication=ActiveDirectoryMSI; na konec následujícího řádku. Nezapomeňte pro proměnnou použít správnou hodnotu $AZ_DATABASE_NAME .
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)
}
}
Použití knihovny Microsoft Authentication Library (MSAL) pro přístup k prostředkům Azure
Kromě knihoven identit Azure můžete také použít MSAL pro přístup k prostředkům Azure pomocí spravovaných identit. Následující fragmenty kódu ukazují, jak používat MSAL pro přístup k prostředkům Azure v různých programovacích jazycích.
U spravovaných identit přiřazených systémem nemusí vývojář předávat žádné další informace. Služba MSAL automaticky odvodí relevantní metadata o přiřazené identitě. Pro spravované identity přiřazené uživatelem musí vývojář předat ID klienta, úplný identifikátor prostředku nebo ID objektu spravované identity.
Potom můžete získat token pro přístup k prostředku. Před použitím spravovaných identit musí vývojáři povolit prostředky, které chtějí použít.
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 zatím nepodporuje spravované identity. Knihovnu identit Azure můžete použít k získání tokenů pro spravované identity.
Připojení k prostředkům, které nepodporují ověřování na základě ID Nebo tokenu Microsoftu v knihovnách
Některé prostředky Azure zatím nepodporují ověřování Microsoft Entra nebo jejich klientské knihovny nepodporují ověřování pomocí tokenu. Tyto prostředky jsou obvykle opensourcové technologie, které v připojovací řetězec očekávají uživatelské jméno a heslo nebo přístupový klíč.
Abyste se vyhnuli ukládání přihlašovacích údajů v kódu nebo konfiguraci vaší aplikace, můžete přihlašovací údaje uložit jako tajný kód ve službě Azure Key Vault. Pomocí výše uvedeného příkladu můžete načíst tajný klíč z Azure KeyVault pomocí spravované identity a předat přihlašovací údaje do svého připojovací řetězec. Tento přístup znamená, že v kódu nebo prostředí není potřeba zpracovávat žádné přihlašovací údaje. Podrobný příklad najdete v tématu Použití spravovaných identit pro přístup k certifikátům služby Azure Key Vault. Další informace o ověřování ve službě Azure Key Vault najdete v tématu ověřování služby Azure Key Vault.
Pokyny, pokud zpracováváte tokeny přímo
V některých scénářích můžete chtít získat tokeny pro spravované identity ručně místo použití integrované metody pro připojení k cílovému prostředku. Mezi tyto scénáře patří žádná klientská knihovna pro programovací jazyk, který používáte, nebo cílový prostředek, ke kterému se připojujete, nebo připojení k prostředkům, které nejsou spuštěné v Azure. Při ručním získávání tokenů poskytujeme následující pokyny:
Uložení tokenů do mezipaměti, které jste získali
Pro zvýšení výkonu a spolehlivosti doporučujeme, aby vaše aplikace ukládaly tokeny do mezipaměti v místní paměti nebo zašifrovaly, pokud je chcete uložit na disk. Vzhledem k tomu, že tokeny spravované identity jsou platné 24 hodin, není možné pravidelně vyžadovat nové tokeny, protože jeden token uložený v mezipaměti se vrátí z vydávajícího koncového bodu tokenu. Pokud překročíte limity požadavků, budete omezeni rychlostí a zobrazí se chyba HTTP 429.
Když token získáte, můžete nastavit, aby platnost mezipaměti tokenů vypršela 5 minut před expires_on (nebo ekvivalentní vlastností), která se vrátí při vygenerování tokenu.
Kontrola tokenu
Vaše aplikace by neměla spoléhat na obsah tokenu. Obsah tokenu je určený jenom pro cílovou skupinu (cílový prostředek), ke které se přistupuje, nikoli pro klienta, který token požaduje. Obsah tokenu se může v budoucnu změnit nebo zašifrovat.
Nezpřístupňujte ani nepřesouvejte tokeny
Tokeny by se měly považovat za přihlašovací údaje. Nezpřístupňujte je uživatelům ani jiným službám; Například řešení protokolování/monitorování. Neměli by být přesunuti ze zdrojového prostředku, který je používá, jinak než k ověření u cílového prostředku.