Připojení z aplikace k prostředkům bez zpracování přihlašovacích údajů

Článek
10/01/2024

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žít knihovnu Identit Azure pro preferovaný programovací jazyk. Knihovna za vás získává přístupové tokeny, což usnadňuje připojení k cílovým prostředkům.

Přečtěte si další informace o následujících knihovnách identit Azure:

Použití knihovny Azure Identity ve vývojovém prostředí

Knihovny identit Azure poskytují typ DefaultAzureCredential . DefaultAzureCredential automaticky se pokusí ověřit prostřednictvím více mechanismů, 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í pomocí vlastních přihlašovacích údajů. 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.

Přístup k objektu blob ve službě Azure Storage

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;

import com.azure.core.util.polling.SyncPoller;
import com.azure.identity.DefaultAzureCredentialBuilder;

import com.azure.security.keyvault.secrets.SecretClient;
import com.azure.security.keyvault.secrets.SecretClientBuilder;
import com.azure.security.keyvault.secrets.models.DeletedSecret;
import com.azure.security.keyvault.secrets.models.KeyVaultSecret;

String keyVaultName = "mykeyvault";
String keyVaultUri = "https://" + keyVaultName + ".vault.azure.net";
String secretName = "mysecret";

// read the user-assigned managed identity Client ID from your environment variables
String clientID = System.getProperty("Managed_Identity_Client_ID");
DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
        .managedIdentityClientId(clientID)
        .build();

SecretClient secretClient = new SecretClientBuilder()
    .vaultUrl(keyVaultUri)
    .credential(credential)
    .buildClient();
    
KeyVaultSecret retrievedSecret = secretClient.getSecret(secretName);

import { DefaultAzureCredential } from "@azure/identity";
import { SecretClient } from "@azure/keyvault-secrets";

// 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 client = new SecretClient("https://<your-key-vault-name>.vault.azure.net/", credential);

async function getSecret() {
    const secret = await client.getSecret("<your-secret-name>");
    const secretValue = secret.value;
    console.log(secretValue);
}

getSecret().catch(err => console.error("Error retrieving secret:", err));

from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
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)

client = SecretClient(vault_url="https://<your-key-vault-name>.vault.azure.net/", credential=credential)

def get_secret():
    secret = client.get_secret("<your-secret-name>")
    secret_value = secret.value
    print(secret_value)

if __name__ == "__main__":
    try:
        get_secret()
    except Exception as e:
        print(f"Error retrieving secret: {e}")

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/Azure/azure-sdk-for-go/sdk/keyvault/azsecrets"
)

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
    }

    client, err := azsecrets.NewClient("https://<your-key-vault-name>.vault.azure.net/", credential, nil)
    if err != nil {
        fmt.Printf("Failed to create secret client: %v\n", err)
        return
    }

    secretResp, err := client.GetSecret(context.TODO(), "<your-secret-name>", nil)
    if err != nil {
        fmt.Printf("Failed to get secret: %v\n", err)
        return
    }

    secretValue := *secretResp.Value
    fmt.Println(secretValue)
}

Přístup ke službě Azure SQL Database

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 .

spring.datasource.url=jdbc:sqlserver://$AZ_DATABASE_NAME.database.windows.net:1433;database=demo;encrypt=true;trustServerCertificate=false;hostNameInCertificate=*.database.windows.net;loginTimeout=30;Authentication=ActiveDirectoryMSI;

Přečtěte si další informace o tom, jak použít spravovanou identitu pro připojení Azure SQL Database k aplikaci Azure Spring Apps.


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

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.

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.

Sdílet prostřednictvím