Nawiązywanie połączenia z aplikacji z zasobami bez obsługi poświadczeń

Artykuł
10/01/2024

Zasoby platformy Azure z tożsamościami zarządzanymi obsługują zawsze opcję określenia tożsamości zarządzanej w celu nawiązania połączenia z zasobami platformy Azure obsługującymi uwierzytelnianie firmy Microsoft Entra. Obsługa tożsamości zarządzanych sprawia, że deweloperzy nie muszą zarządzać poświadczeniami w kodzie. Tożsamości zarządzane to zalecana opcja uwierzytelniania podczas pracy z zasobami platformy Azure, które je obsługują. Zapoznaj się z omówieniem tożsamości zarządzanych.

Na tej stronie pokazano, jak skonfigurować usługę App Service, aby mogła łączyć się z usługą Azure Key Vault, usługą Azure Storage i programem Microsoft SQL Server. Te same zasady mogą być używane dla dowolnego zasobu platformy Azure, który obsługuje tożsamości zarządzane i które będą łączyć się z zasobami obsługującymi uwierzytelnianie firmy Microsoft Entra.

Przykłady kodu używają biblioteki klienta tożsamości platformy Azure, która jest zalecaną metodą, ponieważ automatycznie obsługuje wiele kroków, w tym uzyskiwanie tokenu dostępu używanego w połączeniu.

Z jakimi zasobami mogą łączyć się tożsamości zarządzane?

Tożsamość zarządzana może łączyć się z dowolnym zasobem, który obsługuje uwierzytelnianie firmy Microsoft Entra. Ogólnie rzecz biorąc, nie jest wymagana specjalna obsługa zasobu, aby umożliwić tożsamościom zarządzanym łączenie się z nim.

Niektóre zasoby nie obsługują uwierzytelniania entra firmy Microsoft lub ich biblioteka kliencka nie obsługuje uwierzytelniania przy użyciu tokenu. Przeczytaj, aby zapoznać się z naszymi wskazówkami dotyczącymi bezpiecznego uzyskiwania dostępu do poświadczeń przy użyciu tożsamości zarządzanej bez konieczności przechowywania ich w kodzie lub konfiguracji aplikacji.

Tworzenie tożsamości zarządzanej

Istnieją dwa typy tożsamości zarządzanych: przypisane przez system i przypisane przez użytkownika. Tożsamości przypisane przez system są bezpośrednio połączone z pojedynczym zasobem platformy Azure. Gdy zasób platformy Azure zostanie usunięty, jest to tożsamość. Tożsamość zarządzana przypisana przez użytkownika może być skojarzona z wieloma zasobami platformy Azure, a jej cykl życia jest niezależny od tych zasobów.

W większości scenariuszy zalecamy użycie tożsamości zarządzanej przypisanej przez użytkownika. Jeśli używany zasób źródłowy nie obsługuje tożsamości zarządzanych przypisanych przez użytkownika, zapoznaj się z dokumentacją tego dostawcy zasobów, aby dowiedzieć się, jak skonfigurować go tak, aby miała tożsamość zarządzaną przypisaną przez system.

Ważne

Konto używane do tworzenia tożsamości zarządzanych wymaga roli, takiej jak "Współautor tożsamości zarządzanej", aby utworzyć nową tożsamość zarządzaną przypisaną przez użytkownika.

Utwórz tożsamość zarządzaną przypisaną przez użytkownika przy użyciu preferowanej opcji:

Po utworzeniu tożsamości zarządzanej przypisanej przez użytkownika zanotuj clientId wartości i principalId zwracane podczas tworzenia tożsamości zarządzanej. principalId Używasz funkcji podczas dodawania uprawnień i clientId w kodzie aplikacji.

Konfigurowanie usługi App Service przy użyciu tożsamości zarządzanej przypisanej przez użytkownika

Aby można było użyć tożsamości zarządzanej w kodzie, musimy przypisać ją do usługi App Service, która będzie jej używać. Proces konfigurowania usługi App Service do korzystania z tożsamości zarządzanej przypisanej przez użytkownika wymaga określenia identyfikatora zasobu tożsamości zarządzanej w konfiguracji aplikacji.

Dodawanie uprawnień do tożsamości

Po skonfigurowaniu usługi App Service do używania tożsamości zarządzanej przypisanej przez użytkownika należy przyznać niezbędne uprawnienia tożsamości. W tym scenariuszu używamy tej tożsamości do interakcji z usługą Azure Storage, dlatego należy użyć systemu kontroli dostępu opartej na rolach (RBAC) platformy Azure w celu udzielenia uprawnień tożsamości zarządzanej przypisanej przez użytkownika do zasobu.

Ważne

Do dodania przypisań ról potrzebna będzie rola, taka jak "Administrator dostępu użytkowników" lub "Właściciel" zasobu docelowego. Upewnij się, że udzielasz najmniejszego uprawnienia wymaganego do uruchomienia aplikacji.

Wszelkie zasoby, do których chcesz uzyskać dostęp, wymagają udzielenia uprawnień tożsamości. Jeśli na przykład zażądasz tokenu dostępu do usługi Key Vault, musisz również dodać zasady dostępu, które obejmują tożsamość zarządzaną aplikacji lub funkcji. W przeciwnym razie wywołania usługi Key Vault zostaną odrzucone, nawet jeśli używasz prawidłowego tokenu. To samo dotyczy usługi Azure SQL Database. Aby dowiedzieć się więcej o zasobach obsługujących tokeny firmy Microsoft Entra, zobacz Usługi platformy Azure, które obsługują uwierzytelnianie Firmy Microsoft Entra.

Używanie tożsamości zarządzanych w kodzie

Po wykonaniu opisanych powyżej kroków usługa App Service ma tożsamość zarządzaną z uprawnieniami do zasobu platformy Azure. Za pomocą tożsamości zarządzanej można uzyskać token dostępu, którego kod może używać do interakcji z zasobami platformy Azure, zamiast przechowywać poświadczenia w kodzie.

Zalecamy użycie biblioteki tożsamości platformy Azure dla preferowanego języka programowania. Biblioteka uzyskuje tokeny dostępu, co ułatwia nawiązywanie połączenia z zasobami docelowymi.

Przeczytaj więcej na temat bibliotek tożsamości platformy Azure poniżej:

Korzystanie z biblioteki tożsamości platformy Azure w środowisku projektowym

Biblioteki tożsamości platformy Azure zapewniają DefaultAzureCredential typ. DefaultAzureCredential automatycznie próbuje uwierzytelnić się za pośrednictwem wielu mechanizmów, w tym zmiennych środowiskowych lub logowania interakcyjnego. Typ poświadczeń może być używany w środowisku deweloperów przy użyciu własnych poświadczeń. Można go również używać w środowisku produkcyjnym platformy Azure przy użyciu tożsamości zarządzanej. Podczas wdrażania aplikacji nie są wymagane żadne zmiany kodu.

Jeśli używasz tożsamości zarządzanych przypisanych przez użytkownika, należy również jawnie określić tożsamość zarządzaną przypisaną przez użytkownika, za pomocą której chcesz uwierzytelnić się, przekazując identyfikator klienta tożsamości jako parametr. Identyfikator klienta można pobrać, przechodząc do tożsamości w witrynie Azure Portal.

Uzyskiwanie dostępu do obiektu blob w usłudze 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())
}

Uzyskiwanie dostępu do wpisu tajnego przechowywanego w usłudze 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)
}

Uzyskiwanie dostępu do usługi 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();

Jeśli używasz usługi Azure Spring Apps, możesz nawiązać połączenie z bazami danych Azure SQL Database przy użyciu tożsamości zarządzanej bez wprowadzania jakichkolwiek zmian w kodzie.

src/main/resources/application.properties Otwórz plik i dodaj Authentication=ActiveDirectoryMSI; go na końcu następującego wiersza. Pamiętaj, aby użyć poprawnej wartości dla $AZ_DATABASE_NAME zmiennej.

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;

Dowiedz się więcej na temat używania tożsamości zarządzanej do łączenia usługi Azure SQL Database z aplikacją 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)
    }
}

Nawiązywanie połączenia z zasobami, które nie obsługują identyfikatora Entra firmy Microsoft ani uwierzytelniania opartego na tokenach w bibliotekach

Niektóre zasoby platformy Azure nie obsługują jeszcze uwierzytelniania firmy Microsoft Entra lub ich biblioteki klienckie nie obsługują uwierzytelniania przy użyciu tokenu. Zazwyczaj te zasoby to technologie typu open source, które oczekują nazwy użytkownika i hasła lub klucza dostępu w parametry połączenia.

Aby uniknąć przechowywania poświadczeń w kodzie lub konfiguracji aplikacji, możesz przechowywać poświadczenia jako wpis tajny w usłudze Azure Key Vault. Korzystając z powyższego przykładu, możesz pobrać wpis tajny z usługi Azure KeyVault przy użyciu tożsamości zarządzanej i przekazać poświadczenia do parametry połączenia. Takie podejście oznacza, że żadne poświadczenia nie muszą być obsługiwane bezpośrednio w kodzie lub środowisku.

Wskazówki dotyczące bezpośredniej obsługi tokenów

W niektórych scenariuszach możesz ręcznie uzyskać tokeny dla tożsamości zarządzanych zamiast używać wbudowanej metody w celu nawiązania połączenia z zasobem docelowym. Te scenariusze nie obejmują biblioteki klienta dla używanego języka programowania lub zasobu docelowego, z którym nawiązujesz połączenie, lub łączenia się z zasobami, które nie są uruchomione na platformie Azure. Podczas ręcznego uzyskiwania tokenów udostępniamy następujące wskazówki:

Buforowanie uzyskanych tokenów

W celu zapewnienia wydajności i niezawodności zalecamy buforowanie tokenów aplikacji w pamięci lokalnej lub zaszyfrowanie, jeśli chcesz zapisać je na dysku. Ponieważ tokeny tożsamości zarządzanej są ważne przez 24 godziny, nie ma korzyści wynikających z regularnego żądania nowych tokenów, ponieważ buforowany token zostanie zwrócony z punktu końcowego wystawiającego tokeny. Jeśli przekroczysz limity żądań, wystąpi ograniczenie szybkości i zostanie wyświetlony błąd HTTP 429.

Po uzyskaniu tokenu możesz ustawić, że pamięć podręczna tokenu wygaśnie 5 minut przed expires_on (lub równoważną właściwością), która zostanie zwrócona po wygenerowaniu tokenu.

Inspekcja tokenów

Aplikacja nie powinna polegać na zawartości tokenu. Zawartość tokenu jest przeznaczona tylko dla odbiorców (zasobu docelowego), do którego uzyskuje się dostęp, a nie klienta żądającego tokenu. Zawartość tokenu może ulec zmianie lub zostać zaszyfrowana w przyszłości.

Nie ujawniaj ani nie przenosij tokenów

Tokeny powinny być traktowane jak poświadczenia. Nie ujawniaj ich użytkownikom ani innym usługom; na przykład rozwiązania do rejestrowania/monitorowania. Nie należy ich przenosić z zasobu źródłowego, który z nich korzysta, poza uwierzytelnianiem względem zasobu docelowego.

Następne kroki

Jak używać tożsamości zarządzanych dla usług App Service i Azure Functions
Jak używać tożsamości zarządzanych z usługą Azure Container Instances
Implementowanie tożsamości zarządzanych dla zasobów platformy Microsoft Azure
Używanie federacji tożsamości obciążenia dla tożsamości zarządzanych w celu uzyskania dostępu do chronionych zasobów firmy Microsoft bez zarządzania wpisami tajnymi

Udostępnij za pośrednictwem