Verbinding maken vanuit uw toepassing met resources zonder referenties te verwerken
Artikel
Azure-resources met beheerde identiteiten ondersteunen altijd een optie om een beheerde identiteit op te geven om verbinding te maken met Azure-resources die ondersteuning bieden voor Microsoft Entra-verificatie. Door de ondersteuning voor beheerde identiteiten hoeven ontwikkelaars geen referenties in code te beheren. Beheerde identiteiten zijn de aanbevolen verificatieoptie bij het werken met Azure-resources die deze ondersteunen.
Bekijk een overzicht van beheerde identiteiten.
Op deze pagina ziet u hoe u een App Service zo configureert dat deze verbinding kan maken met Azure Key Vault, Azure Storage en Microsoft SQL Server. Dezelfde principes kunnen worden gebruikt voor elke Azure-resource die beheerde identiteiten ondersteunt en die verbinding maken met resources die ondersteuning bieden voor Microsoft Entra-verificatie.
De codevoorbeelden maken gebruik van de Azure Identity-clientbibliotheek. Dit is de aanbevolen methode, omdat deze automatisch veel van de stappen voor u verwerkt, waaronder het verkrijgen van een toegangstoken dat in de verbinding wordt gebruikt.
Met welke resources kunnen beheerde identiteiten verbinding maken?
Een beheerde identiteit kan verbinding maken met elke resource die ondersteuning biedt voor Microsoft Entra-verificatie. Over het algemeen is er geen speciale ondersteuning vereist voor de resource om beheerde identiteiten verbinding te laten maken.
Sommige resources bieden geen ondersteuning voor Microsoft Entra-verificatie of de clientbibliotheek biedt geen ondersteuning voor verificatie met een token. Lees verder om onze richtlijnen te bekijken over het gebruik van een beheerde identiteit om veilig toegang te krijgen tot de referenties zonder ze op te slaan in uw code of toepassingsconfiguratie.
Een beheerde identiteit maken
Er zijn twee typen beheerde identiteiten: door het systeem toegewezen en door de gebruiker toegewezen. Door het systeem toegewezen identiteiten worden rechtstreeks gekoppeld aan één Azure-resource. Als de Azure-resource wordt verwijderd, wordt ook de identiteit verwijderd. Een door de gebruiker toegewezen beheerde identiteit kan worden gekoppeld aan meerdere Azure-resources en de levenscyclus ervan is onafhankelijk van deze resources.
Voor de meeste scenario's wordt u aangeraden een door de gebruiker toegewezen beheerde identiteit te gebruiken. Als de bronresource die u gebruikt geen ondersteuning biedt voor door de gebruiker toegewezen beheerde identiteiten, raadpleegt u de documentatie van die resourceprovider om te leren hoe u deze configureert voor een door het systeem toegewezen beheerde identiteit.
Belangrijk
Het account dat wordt gebruikt voor het maken van beheerde identiteiten, heeft een rol nodig, zoals 'Inzender voor beheerde identiteiten' om een nieuwe door de gebruiker toegewezen beheerde identiteit te maken.
Maak een door de gebruiker toegewezen beheerde identiteit met behulp van uw voorkeursoptie:
Nadat u een door de gebruiker toegewezen beheerde identiteit hebt gemaakt, noteert u de clientId waarden die principalId worden geretourneerd wanneer de beheerde identiteit wordt gemaakt. U gebruikt principalId tijdens het toevoegen van machtigingen en clientId in de code van uw toepassing.
App Service configureren met een door de gebruiker toegewezen beheerde identiteit
Voordat u de beheerde identiteit in uw code kunt gebruiken, moeten we deze toewijzen aan de App Service die deze gebruikt. Voor het configureren van een App Service voor het gebruik van een door de gebruiker toegewezen beheerde identiteit moet u de resource-id van de beheerde identiteit opgeven in de configuratie van uw app.
Machtigingen toevoegen aan de identiteit
Zodra u uw App Service hebt geconfigureerd voor het gebruik van een door de gebruiker toegewezen beheerde identiteit, verleent u de benodigde machtigingen aan de identiteit. In dit scenario gebruiken we deze identiteit om te communiceren met Azure Storage. Daarom moet u het RBAC-systeem (Op rollen gebaseerd toegangsbeheer) van Azure gebruiken om de door de gebruiker toegewezen beheerde identiteit machtigingen te verlenen aan de resource.
Belangrijk
U hebt een rol nodig, zoals Beheerder van gebruikerstoegang of Eigenaar voor de doelresource om roltoewijzingen toe te voegen. Zorg ervoor dat u de minimale bevoegdheid verleent die nodig is om de toepassing uit te voeren.
Voor alle resources die u wilt openen, moet u de identiteitsmachtigingen verlenen. Als u bijvoorbeeld een token aanvraagt voor toegang tot Key Vault, moet u ook een toegangsbeleid toevoegen dat de beheerde identiteit van uw app of functie bevat. Anders worden uw aanroepen naar Key Vault geweigerd, zelfs als u een geldig token gebruikt. Hetzelfde geldt voor Azure SQL Database. Zie Azure-services die ondersteuning bieden voor Microsoft Entra-verificatie voor meer informatie over welke resources Ondersteuning bieden voor Microsoft Entra-tokens.
Beheerde identiteiten gebruiken in uw code
Nadat u de bovenstaande stappen hebt voltooid, heeft uw App Service een beheerde identiteit met machtigingen voor een Azure-resource. U kunt de beheerde identiteit gebruiken om een toegangstoken te verkrijgen dat uw code kan gebruiken om te communiceren met Azure-resources, in plaats van referenties op te slaan in uw code.
We raden u aan de clientbibliotheken te gebruiken die we bieden voor de programmeertaal van uw voorkeur. Deze bibliotheken verkrijgen toegangstokens voor u, zodat u eenvoudig kunt verifiëren met Microsoft Entra-id. Zie Clientbibliotheken voor verificatie van beheerde identiteitenvoor meer informatie.
Een Azure Identity-bibliotheek gebruiken voor toegang tot Azure-resources
De Azure Identity-bibliotheken bieden elk een DefaultAzureCredential type.
DefaultAzureCredential probeert de gebruiker automatisch te verifiëren via verschillende stromen, waaronder omgevingsvariabelen of een interactieve aanmelding. Het referentietype kan worden gebruikt in een ontwikkelomgeving met uw eigen referenties. Het kan ook worden gebruikt in uw Azure-productieomgeving met gebruikmaking van een beheerde identiteit. Er zijn geen codewijzigingen vereist wanneer u uw toepassing implementeert.
Als u door de gebruiker toegewezen beheerde identiteiten gebruikt, moet u ook expliciet de door de gebruiker toegewezen beheerde identiteit opgeven waarmee u zich wilt verifiëren door de client-id van de identiteit door te geven als parameter. U kunt de client-id ophalen door te bladeren naar de identiteit in Azure Portal.
using Azure.Identity;
using Azure.Storage.Blobs;
// code omitted for brevity
// Specify the Client ID if using user-assigned managed identities
var clientID = Environment.GetEnvironmentVariable("Managed_Identity_Client_ID");
var credentialOptions = new DefaultAzureCredentialOptions
{
ManagedIdentityClientId = clientID
};
var credential = new DefaultAzureCredential(credentialOptions);
var blobServiceClient1 = new BlobServiceClient(new Uri("<URI of Storage account>"), credential);
BlobContainerClient containerClient1 = blobServiceClient1.GetBlobContainerClient("<name of blob>");
BlobClient blobClient1 = containerClient1.GetBlobClient("<name of file>");
if (blobClient1.Exists())
{
var downloadedBlob = blobClient1.Download();
string blobContents = downloadedBlob.Value.Content.ToString();
}
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.storage.blob.BlobClient;
import com.azure.storage.blob.BlobContainerClient;
import com.azure.storage.blob.BlobServiceClient;
import com.azure.storage.blob.BlobServiceClientBuilder;
// read the Client ID from your environment variables
String clientID = System.getProperty("Client_ID");
DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
.managedIdentityClientId(clientID)
.build();
BlobServiceClient blobStorageClient = new BlobServiceClientBuilder()
.endpoint("<URI of Storage account>")
.credential(credential)
.buildClient();
BlobContainerClient blobContainerClient = blobStorageClient.getBlobContainerClient("<name of blob container>");
BlobClient blobClient = blobContainerClient.getBlobClient("<name of blob/file>");
if (blobClient.exists()) {
String blobContent = blobClient.downloadContent().toString();
}
import { DefaultAzureCredential } from "@azure/identity";
import { BlobServiceClient } from "@azure/storage-blob";
// Specify the Client ID if using user-assigned managed identities
const clientID = process.env.Managed_Identity_Client_ID;
const credential = new DefaultAzureCredential({
managedIdentityClientId: clientID
});
const blobServiceClient = new BlobServiceClient("<URI of Storage account>", credential);
const containerClient = blobServiceClient.getContainerClient("<name of blob>");
const blobClient = containerClient.getBlobClient("<name of file>");
async function downloadBlob() {
if (await blobClient.exists()) {
const downloadBlockBlobResponse = await blobClient.download();
const downloadedBlob = await streamToString(downloadBlockBlobResponse.readableStreamBody);
console.log("Downloaded blob content:", downloadedBlob);
}
}
async function streamToString(readableStream) {
return new Promise((resolve, reject) => {
const chunks = [];
readableStream.on("data", (data) => {
chunks.push(data.toString());
});
readableStream.on("end", () => {
resolve(chunks.join(""));
});
readableStream.on("error", reject);
});
}
downloadBlob().catch(console.error);
from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient
import os
# Specify the Client ID if using user-assigned managed identities
client_id = os.getenv("Managed_Identity_Client_ID")
credential = DefaultAzureCredential(managed_identity_client_id=client_id)
blob_service_client = BlobServiceClient(account_url="<URI of Storage account>", credential=credential)
container_client = blob_service_client.get_container_client("<name of blob>")
blob_client = container_client.get_blob_client("<name of file>")
def download_blob():
if blob_client.exists():
download_stream = blob_client.download_blob()
blob_contents = download_stream.readall().decode('utf-8')
print("Downloaded blob content:", blob_contents)
download_blob()
package main
import (
"context"
"fmt"
"io"
"os"
"strings"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func main() {
// The client ID for the user-assigned managed identity is read from the AZURE_CLIENT_ID env var
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
fmt.Printf("failed to obtain a credential: %v\n", err)
return
}
accountURL := "<URI of Storage account>"
containerName := "<name of blob>"
blobName := "<name of file>"
serviceClient, err := azblob.NewServiceClient(accountURL, cred, nil)
if err != nil {
fmt.Printf("failed to create service client: %v\n", err)
return
}
containerClient := serviceClient.NewContainerClient(containerName)
blobClient := containerClient.NewBlobClient(blobName)
// Check if the blob exists
_, err = blobClient.GetProperties(context.Background(), nil)
if err != nil {
fmt.Printf("failed to get blob properties: %v\n", err)
return
}
// Download the blob
downloadResponse, err := blobClient.Download(context.Background(), nil)
if err != nil {
fmt.Printf("failed to download blob: %v\n", err)
return
}
// Read the blob content
blobData := downloadResponse.Body(nil)
defer blobData.Close()
blobContents := new(strings.Builder)
_, err = io.Copy(blobContents, blobData)
if err != nil {
fmt.Printf("failed to read blob data: %v\n", err)
return
}
fmt.Println("Downloaded blob content:", blobContents.String())
}
Toegang tot een geheim dat is opgeslagen in Azure Key Vault
using Azure.Identity;
using Azure.Security.KeyVault.Secrets;
using Azure.Core;
// code omitted for brevity
// Specify the Client ID if using user-assigned managed identities
var clientID = Environment.GetEnvironmentVariable("Managed_Identity_Client_ID");
var credentialOptions = new DefaultAzureCredentialOptions
{
ManagedIdentityClientId = clientID
};
var credential = new DefaultAzureCredential(credentialOptions);
var client = new SecretClient(
new Uri("https://<your-unique-key-vault-name>.vault.azure.net/"),
credential);
KeyVaultSecret secret = client.GetSecret("<my secret>");
string secretValue = secret.Value;
using Azure.Identity;
using Microsoft.Data.SqlClient;
// code omitted for brevity
// Specify the Client ID if using user-assigned managed identities
var clientID = Environment.GetEnvironmentVariable("Managed_Identity_Client_ID");
var credentialOptions = new DefaultAzureCredentialOptions
{
ManagedIdentityClientId = clientID
};
AccessToken accessToken = await new DefaultAzureCredential(credentialOptions).GetTokenAsync(
new TokenRequestContext(new string[] { "https://database.windows.net//.default" }));
using var connection = new SqlConnection("Server=<DB Server>; Database=<DB Name>;")
{
AccessToken = accessToken.Token
};
var cmd = new SqlCommand("select top 1 ColumnName from TableName", connection);
await connection.OpenAsync();
SqlDataReader dr = cmd.ExecuteReader();
while(dr.Read())
{
Console.WriteLine(dr.GetValue(0).ToString());
}
dr.Close();
Als u Azure Spring Apps gebruikt, kunt u verbinding maken met Azure SQL Databases met behulp van een beheerde identiteit zonder wijzigingen aan te brengen in uw code.
Open het bestand src/main/resources/application.properties en voeg Authentication=ActiveDirectoryMSI; toe aan het einde van de volgende regel. Zorg ervoor dat u de juiste waarde voor de variabele $AZ_DATABASE_NAME gebruikt.
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)
}
}
Toegang krijgen tot Azure-resources met behulp van de Microsoft Authentication Library (MSAL)
Naast de Azure Identity-bibliotheken kunt u ook MSAL gebruiken om toegang te krijgen tot Azure-resources met behulp van beheerde identiteiten. De volgende codefragmenten laten zien hoe u MSAL gebruikt voor toegang tot Azure-resources in verschillende programmeertalen.
Voor door het systeem toegewezen beheerde identiteiten hoeft de ontwikkelaar geen aanvullende informatie door te geven. MSAL leidt automatisch de relevante metagegevens af over de toegewezen identiteit. Voor door de gebruiker toegewezen beheerde identiteiten moet de ontwikkelaar de client-id, de volledige resource-id of de object-id van de beheerde identiteit doorgeven.
Vervolgens kunt u een token verkrijgen om toegang te krijgen tot een resource. Voordat ze beheerde identiteiten gebruiken, moeten ontwikkelaars ze inschakelen voor de resources die ze willen gebruiken.
using Microsoft.Identity.Client;
using System;
string resource = "https://vault.azure.net";
// Applies to system-assigned managed identities only
IManagedIdentityApplication mi = ManagedIdentityApplicationBuilder.Create(ManagedIdentityId.SystemAssigned)
.Build();
// Applies to user-assigned managed identities only
string userAssignedManagedIdentityClientId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
IManagedIdentityApplication mi = ManagedIdentityApplicationBuilder.Create(ManagedIdentityId.WithUserAssignedClientId(userAssignedManagedIdentityClientId))
.Build();
// Acquire token
AuthenticationResult result = await mi.AcquireTokenForManagedIdentity(resource)
.ExecuteAsync()
.ConfigureAwait(false);
if (!string.IsNullOrEmpty(result.AccessToken))
{
Console.WriteLine(result.AccessToken);
}
import com.microsoft.aad.msal4j.IAuthenticationResult;
import com.microsoft.aad.msal4j.ManagedIdentityApplication;
import com.microsoft.aad.msal4j.ManagedIdentityId;
import com.microsoft.aad.msal4j.ManagedIdentityParameters;
String resource = "https://vault.azure.net";
// Use this for user-assigned managed identities
private static final String USER_ASSIGNED_MI_CLIENT_ID = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
// Use this for system-assigned managed identities
ManagedIdentityApplication miApp = ManagedIdentityApplication
.builder(ManagedIdentityId.systemAssigned())
.build();
// Use this for user-assigned managed identities
ManagedIdentityApplication miApp = ManagedIdentityApplication
.builder(ManagedIdentityId.userAssignedClientId(USER_ASSIGNED_MI_CLIENT_ID))
.build();
// Acquire token
IAuthenticationResult result = miApp.acquireTokenForManagedIdentity(
ManagedIdentityParameters.builder(resource)
.build()).get();
System.out.println(result.accessToken());
import {
LogLevel,
LoggerOptions,
AuthenticationResult,
} from "@azure/msal-common";
import {
ManagedIdentityRequestParams,
ManagedIdentityConfiguration,
ManagedIdentityApplication,
ManagedIdentityIdParams,
NodeSystemOptions,
} from "@azure/msal-node";
// Define resource
const managedIdentityRequestParams: ManagedIdentityRequestParams = {
resource: "https://vault.azure.net",
};
// This section applies to user-assigned managed identities only
const userAssignedManagedIdentityIdParams: ManagedIdentityIdParams = {
userAssignedClientId: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
};
const userAssignedManagedIdentityConfig: ManagedIdentityConfiguration = {
userAssignedManagedIdentityIdParams, // applicable to user-assigned managed identities only
// optional for logging
system: {
loggerOptions: {
logLevel: LogLevel.Verbose,
} as LoggerOptions,
} as NodeSystemOptions,
};
const userSystemAssignedManagedIdentityApplication: ManagedIdentityApplication =
new ManagedIdentityApplication(userAssignedManagedIdentityConfig);
// Acquire token: user-assigned managed identity
const response: AuthenticationResult =
await userAssignedManagedIdentityApplication.acquireToken(
managedIdentityRequestParams
);
// This section applies to system-assigned managed identities only
const systemAssignedManagedIdentityConfig: ManagedIdentityConfiguration = {
// optional for logging
system: {
loggerOptions: {
logLevel: LogLevel.Verbose,
} as LoggerOptions,
} as NodeSystemOptions,
};
const systemAssignedManagedIdentityApplication: ManagedIdentityApplication =
new ManagedIdentityApplication(systemAssignedManagedIdentityConfig);
// Acquire token: system-assigned managed identity
const response: AuthenticationResult =
await systemAssignedManagedIdentityApplication.acquireToken(
managedIdentityRequestParams
);
console.log(response);
import msal
import requests
# Use this for system-assigned managed identities
managed_identity = msal.SystemAssignedManagedIdentity()
# Use this for user-assigned managed identities
userAssignedClientId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
managed_identity = msal.UserAssignedManagedIdentity(client_id=userAssignedClientId)
global_app = msal.ManagedIdentityClient(managed_identity, http_client=requests.Session())
result = global_app.acquire_token_for_client(resource='https://vault.azure.net')
if "access_token" in result:
print("Token obtained!")
MSAL Go biedt nog geen ondersteuning voor beheerde identiteiten. U kunt de Azure Identity-bibliotheek gebruiken om tokens voor beheerde identiteiten te verkrijgen.
Verbinding maken met resources die geen ondersteuning bieden voor Microsoft Entra ID of verificatie op basis van tokens in bibliotheken
Sommige Azure-resources bieden nog geen ondersteuning voor Microsoft Entra-verificatie of hun clientbibliotheken bieden geen ondersteuning voor verificatie met een token. Deze resources zijn doorgaans opensource-technologieën waarvoor een gebruikersnaam en wachtwoord of een toegangssleutel in een verbindingsreeks wordt verwacht.
Als u wilt voorkomen dat referenties moeten worden opgeslagen in uw code of de configuratie van uw toepassing, kunt u de referenties opslaan als een geheim in Azure Key Vault. Met behulp van het bovenstaande voorbeeld kunt u het geheim ophalen uit Azure Key Vault door gebruik te maken van een beheerde identiteit en de referenties doorgeven aan uw verbindingsreeks. Deze methode betekent dat er geen referenties rechtstreeks in uw code of omgeving hoeven worden verwerkt. Zie Beheerde identiteiten gebruiken voor toegang tot Azure Key Vault-certificatenvoor een gedetailleerd voorbeeld. Zie Azure Key Vault-verificatievoor meer informatie over Azure Key Vault-verificatie.
Richtlijnen wanneer u rechtstreeks tokens verwerkt
In sommige scenario's kunt u tokens voor beheerde identiteiten handmatig verkrijgen in plaats van een ingebouwde methode te gebruiken om verbinding te maken met de doelresource. Deze scenario's omvatten geen clientbibliotheek voor de programmeertaal die u gebruikt of de doelresource waarmee u verbinding maakt, of verbinding maken met resources die niet worden uitgevoerd in Azure. Bij het handmatig verkrijgen van tokens bieden we de volgende richtlijnen:
De verkregen tokens in cache plaatsen
Voor prestaties en betrouwbaarheid wordt aanbevolen tokens in het lokale geheugen op te slaan, of versleuteld als u ze op schijf wilt opslaan. Aangezien tokens voor beheerde identiteiten 24 uur geldig zijn, is het niet handig om regelmatig nieuwe tokens aan te vragen, omdat er een uit de cache wordt geretourneerd door het eindpunt dat tokens uitgeeft. Als u de aanvraaglimieten overschrijdt, wordt de snelheid beperkt en wordt er een HTTP 429-fout weergegeven.
Wanneer u een token verkrijgt, kunt u instellen dat de tokencache verloopt 5 minuten voor de expires_on (of equivalente eigenschap) die wordt geretourneerd wanneer het token wordt gegenereerd.
Tokeninspectie
Uw toepassing mag niet afhankelijk zijn van de inhoud van een token. De inhoud van het token is alleen bedoeld voor de doelgroep (doelresource) waartoe toegang wordt verkregen, niet de client die het token aanvraagt. De tokeninhoud kan in de toekomst worden gewijzigd of versleuteld.
Geen tokens beschikbaar maken of verplaatsen
Tokens moeten worden behandeld als referenties. Maak ze niet beschikbaar voor gebruikers of andere services, zoals oplossingen voor logboekregistratie/bewaking. Ze mogen niet worden verplaatst van de bronresource die ze gebruikt, behalve voor verificatie met de doelresource.