Kimlik bilgilerini işlemeden uygulamanızdan kaynaklara bağlanma

Yönetilen kimlik desteğine sahip Azure kaynakları, Microsoft Entra kimlik doğrulamasını destekleyen Azure kaynaklarına bağlanmak için her zaman bir yönetilen kimlik belirtme seçeneği sağlar. Yönetilen kimlikler desteği, geliştiricilerin koddaki kimlik bilgilerini yönetmesini gereksiz kılar. Yönetilen kimlikler, bunları destekleyen Azure kaynaklarıyla çalışırken önerilen kimlik doğrulama seçeneğidir. Yönetilen kimliklere genel bir bakış okuyun.

Bu sayfada Bir App Service'in Azure Key Vault, Azure Depolama ve Microsoft SQL Server'a bağlanabilmesi için nasıl yapılandırabileceğiniz gösterilmektedir. Yönetilen kimlikleri destekleyen ve Microsoft Entra kimlik doğrulamasını destekleyen kaynaklara bağlanacak tüm Azure kaynakları için aynı ilkeler kullanılabilir.

Kod örnekleri, bağlantıda kullanılan bir erişim belirteci alma da dahil olmak üzere sizin için birçok adımı otomatik olarak işlediğinden önerilen yöntem olan Azure Identity istemci kitaplığını kullanır.

Yönetilen kimlikler hangi kaynaklara bağlanabilir?

Yönetilen kimlik, Microsoft Entra kimlik doğrulamasını destekleyen herhangi bir kaynağa bağlanabilir. Genel olarak, yönetilen kimliklerin kaynağa bağlanmasına izin vermek için özel bir destek gerekmez.

Bazı kaynaklar Microsoft Entra kimlik doğrulamasını desteklemez veya istemci kitaplıkları belirteçle kimlik doğrulamayı desteklemez. Kodunuzda veya uygulama yapılandırmanızda depolamanıza gerek kalmadan kimlik bilgilerine güvenli bir şekilde erişmek için Yönetilen kimlik kullanma yönergelerimizi görmek için okumaya devam edin.

Yönetilen kimlik oluşturma

İki tür yönetilen kimlik vardır: sistem tarafından atanan ve kullanıcı tarafından atanan. Sistem tarafından atanan kimlikler doğrudan tek bir Azure kaynağına bağlanır. Azure kaynağı silindiğinde kimlik de silinir. Kullanıcı tarafından atanan yönetilen kimlik birden çok Azure kaynağıyla ilişkilendirilebilir ve yaşam döngüsü bu kaynaklardan bağımsızdır.

Çoğu senaryo için kullanıcı tarafından atanan yönetilen kimlik kullanmanızı öneririz. Kullandığınız kaynak kullanıcı tarafından atanan yönetilen kimlikleri desteklemiyorsa, sistem tarafından atanan yönetilen kimliğe sahip olacak şekilde yapılandırmayı öğrenmek için bu kaynak sağlayıcısının belgelerine başvurmalısınız.

Önemli

Yönetilen kimlikleri oluşturmak için kullanılan hesabın, kullanıcı tarafından atanan yeni bir yönetilen kimlik oluşturmak için "Yönetilen Kimlik Katkıda Bulunanı" gibi bir role ihtiyacı vardır.

Tercih ettiğiniz seçeneği kullanarak kullanıcı tarafından atanan bir yönetilen kimlik oluşturun:

• Azure portalı
• Azure CLI
• Azure PowerShell
• Resource Manager
• DİNLENME

Kullanıcı tarafından atanan bir yönetilen kimlik oluşturduktan sonra, yönetilen kimlik oluşturulduğunda döndürülen ve principalId değerlerini not clientId alın. İzinleri eklerken ve clientId uygulamanızın kodunda kullanırsınızprincipalId.

App Service'i kullanıcı tarafından atanan yönetilen kimlikle yapılandırma

Yönetilen kimliği kodunuzda kullanabilmeniz için önce bunu kullanacak App Service'e atamamız gerekir. App Service'i kullanıcı tarafından atanan yönetilen kimliği kullanacak şekilde yapılandırma işlemi, yönetilen kimliğin kaynak tanımlayıcısını uygulama yapılandırmanızda belirtmenizi gerektirir.

Kimliğe izin ekleme

App Service'inizi kullanıcı tarafından atanan yönetilen kimliği kullanacak şekilde yapılandırdıktan sonra, kimlik için gerekli izinleri verin. Bu senaryoda, Azure Depolama ile etkileşime geçmek için bu kimliği kullanıyoruz, bu nedenle kaynağa kullanıcı tarafından atanan yönetilen kimlik izinlerini vermek için Azure Rol Tabanlı Erişim Denetimi (RBAC) sistemini kullanmanız gerekir.

Önemli

Rol atamaları eklemek için hedef kaynak için "Kullanıcı Erişim Yöneticisi" veya "Sahip" gibi bir role ihtiyacınız olacaktır. Uygulamanın çalışması için gereken en düşük ayrıcalığı sağladığından emin olun.

Erişmek istediğiniz tüm kaynaklar için kimlik izinleri vermeniz gerekir. Örneğin, Key Vault'a erişmek için bir belirteç isterseniz, uygulamanızın veya işlevinizin yönetilen kimliğini içeren bir erişim ilkesi de eklemeniz gerekir. Aksi takdirde, geçerli bir belirteç kullansanız bile Key Vault'a yaptığınız çağrılar reddedilir. Aynı durum Azure SQL Veritabanı için de geçerlidir. Microsoft Entra belirteçlerini destekleyen kaynaklar hakkında daha fazla bilgi edinmek için bkz. Microsoft Entra kimlik doğrulamasını destekleyen Azure hizmetleri.

Kodunuzda yönetilen kimlikleri kullanma

Yukarıda açıklanan adımları tamamladıktan sonra, App Service'inizin Azure kaynağı izinleri olan bir yönetilen kimliği vardır. Kodunuzun kimlik bilgilerini kodunuzda depolamak yerine Azure kaynaklarıyla etkileşimde bulunurken kullanabileceği bir erişim belirteci almak için yönetilen kimliği kullanabilirsiniz.

Tercih ettiğiniz programlama dili için Azure Kimlik kitaplığını kullanmanızı öneririz. Kitaplık sizin için erişim belirteçleri alarak hedef kaynaklara bağlanmayı kolaylaştırır.

Azure Kimlik kitaplıkları hakkında daha fazla bilgiyi aşağıda bulabilirsiniz:

• .NET için Azure Kimlik kitaplığı
• Java için Azure Kimlik kitaplığı
• JavaScript için Azure Kimlik kitaplığı
• Python için Azure Kimlik kitaplığı
• Go için Azure Identity modülü
• C++ için Azure Kimlik kitaplığı

Geliştirme ortamınızda Azure Kimlik kitaplığını kullanma

Azure Kimlik kitaplıklarının her birinin bir DefaultAzureCredential türü vardır. DefaultAzureCredential ortam değişkenleri veya etkileşimli oturum açma dahil olmak üzere birden çok mekanizma aracılığıyla otomatik olarak kimlik doğrulaması yapmaya çalışır. Kimlik bilgisi türü, kendi kimlik bilgilerinizi kullanarak geliştirme ortamınızda kullanılabilir. Yönetilen kimlik kullanarak üretim Azure ortamınızda da kullanılabilir. Uygulamanızı dağıtırken kod değişikliği gerekmez.

Kullanıcı tarafından atanan yönetilen kimlikler kullanıyorsanız, kimliğin istemci kimliğini parametre olarak geçirerek kimlik doğrulaması yapmak istediğiniz kullanıcı tarafından atanan yönetilen kimliği de açıkça belirtmeniz gerekir. Azure portalında kimliğe göz atarak istemci kimliğini alabilirsiniz.

Azure Depolama'da Blob'a erişme

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

Piton

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

Gitmek

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

Azure Key Vault'ta depolanan gizli diziye erişme

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

Piton

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

Gitmek

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

Azure SQL Veritabanı erişme

.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

Azure Spring Apps kullanıyorsanız, kodunuzda değişiklik yapmadan yönetilen kimlik kullanarak Azure SQL Veritabanı'lere bağlanabilirsiniz.

src/main/resources/application.properties Dosyasını açın ve aşağıdaki satırın sonuna ekleyinAuthentication=ActiveDirectoryMSI;. Değişken için $AZ_DATABASE_NAME doğru değeri kullandığınızdan emin olun.

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;

Azure Spring Apps uygulamasına Azure SQL Veritabanı bağlamak için yönetilen kimlik kullanma hakkında daha fazla bilgi edinin.

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

Piton

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

Gitmek

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

Kitaplıklarda Microsoft Entra Id veya belirteç tabanlı kimlik doğrulamasını desteklemeyen kaynaklara bağlanma

Bazı Azure kaynakları henüz Microsoft Entra kimlik doğrulamasını desteklemez veya istemci kitaplıkları belirteçle kimlik doğrulamayı desteklemez. Bu kaynaklar genellikle bir bağlantı dizesi kullanıcı adı ve parola veya erişim anahtarı bekleyen açık kaynak teknolojilerdir.

Kimlik bilgilerinin kodunuzda veya uygulama yapılandırmanızda depolanmasını önlemek için kimlik bilgilerini Azure Key Vault'ta gizli dizi olarak depolayabilirsiniz. Yukarıda görüntülenen örneği kullanarak, yönetilen kimlik kullanarak Azure KeyVault'tan gizli diziyi alabilir ve kimlik bilgilerini bağlantı dizesi geçirebilirsiniz. Bu yaklaşım, kodunuzda veya ortamınızda doğrudan hiçbir kimlik bilgilerinin işlenmesi gerekmeyen bir yaklaşımdır.

Belirteçleri doğrudan işlip işlemediğinize ilişkin yönergeler

Bazı senaryolarda, hedef kaynağa bağlanmak için yerleşik bir yöntem kullanmak yerine yönetilen kimlikler için belirteçleri el ile almak isteyebilirsiniz. Bu senaryolar, kullandığınız programlama dili veya bağlandığınız hedef kaynak için istemci kitaplığı veya Azure'da çalışmayan kaynaklara bağlanmayı içermez. Belirteçleri el ile alırken aşağıdaki yönergeleri sağlarız:

Aldığınız belirteçleri önbelleğe alma

Performans ve güvenilirlik için uygulamanızın belirteçleri yerel bellekte önbelleğe almalarını veya diske kaydetmek istiyorsanız şifrelenmiş olmalarını öneririz. Yönetilen kimlik belirteçleri 24 saat boyunca geçerli olduğundan, yeni belirteçleri düzenli olarak istemenin bir avantajı yoktur çünkü önbelleğe alınmış bir belirteç veren uç noktadan döndürülür. İstek sınırlarını aşarsanız hız sınırına sahip olursunuz ve HTTP 429 hatası alırsınız.

Belirteç aldığınızda belirteç önbelleğinizin süresinin, belirteç oluşturulduğunda döndürülecek olan (veya eşdeğer özellik) 5 dakika önce expires_on dolacak şekilde ayarlayabilirsiniz.

Belirteç denetimi

Uygulamanız bir belirtecin içeriğine güvenmemelidir. Belirtecin içeriği yalnızca erişilen hedef kitleye (hedef kaynak) yöneliktir, belirteci isteyen istemciye yönelik değildir. Belirteç içeriği gelecekte değişebilir veya şifrelenebilir.

Belirteçleri kullanıma sunma veya taşıma

Belirteçler kimlik bilgileri gibi ele alınmalıdır. Bunları kullanıcılara veya diğer hizmetlere göstermeyin; örneğin, günlüğe kaydetme/izleme çözümleri. Hedef kaynakta kimlik doğrulaması yapmak dışında, bunları kullanan kaynak kaynaktan taşınmamalıdır.

Sonraki adımlar

• App Service ve Azure İşlevleri için yönetilen kimlikleri kullanma
• Azure Container Instances ile yönetilen kimlikleri kullanma
• Microsoft Azure Kaynakları için yönetilen kimlikleri uygulama
• Gizli dizileri yönetmeden Microsoft Entra korumalı kaynaklara erişmek için yönetilen kimlikler için iş yükü kimlik federasyonu kullanma