Ansluta från ditt program till resurser utan att hantera autentiseringsuppgifter

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:

• Azure-portalen
• Azure CLI
• Azure PowerShell
• Resource Manager
• REST

När du har skapat en användartilldelad hanterad identitet bör du anteckna värdena clientId principalId 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 Azure Identity-biblioteket för önskat programmeringsspråk. Biblioteket hämtar åtkomsttoken åt dig, vilket gör det enkelt att ansluta till målresurser.

Läs mer om Azure Identity-biblioteken nedan:

• Azure Identity-bibliotek för .NET
• Azure Identity-bibliotek för Java
• Azure Identity-bibliotek för JavaScript
• Azure Identity-bibliotek för Python
• Azure Identity-modul för Go
• Azure Identity-bibliotek för C++

Använda Azure Identity-biblioteket i utvecklingsmiljön

Azure Identity-biblioteken anger var och en en DefaultAzureCredential typ. DefaultAzureCredential försöker automatiskt autentisera via flera mekanismer, inklusive miljövariabler eller en interaktiv inloggning. Autentiseringstypen kan användas i utvecklingsmiljön 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.

Åtkomst till en blob i Azure Storage

.NET

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

Java

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

Node.js

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

Python

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

Kör

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

.NET

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;

Java

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

Node.js

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

Python

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

Kör

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

Åtkomst till Azure SQL Database

.NET

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

Java

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.

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;

Läs mer om hur du använder en hanterad identitet för att ansluta Azure SQL Database till en Azure Spring Apps-app.

Node.js

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

Python

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

Kör

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

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ö.

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.

Nästa steg

• Så här använder du hanterade identiteter för App Service och Azure Functions
• Använda hanterade identiteter med Azure Container Instances
• Implementera hanterade identiteter för Microsoft Azure-resurser
• Använda arbetsbelastningsidentitetsfederation för hanterade identiteter för att få åtkomst till Microsoft Entra-skyddade resurser utan att hantera hemligheter