Configurer des autorisations Azure AD Graph pour une inscription d’application

Article
08/16/2024

Azure Active Directory (Azure AD) Graph est déconseillé et est dans son chemin de mise hors service. Nous vous recommandons de suivre la liste de contrôle de planification de la migration des applications pour vous aider à migrer vos applications vers Microsoft Graph.

Votre application peut toujours nécessiter temporairement des autorisations Azure AD Graph pour accéder aux ressources. Vous pouvez suivre l’une des trois méthodes décrites dans cet article pour configurer les autorisations Azure AD Graph pour l’inscription de votre application :

Attention

Toute application utilisant Azure AD Graph cesse de fonctionner une fois l’API mise hors service. Pour plus d’informations, consultez Migrer des applications Azure AD Graph vers Microsoft Graph.

Configuration requise

Les étapes décrites dans cet article nécessitent deux ensembles de privilèges :

Privilèges permettant d’ajouter des autorisations à une inscription d’application
Privilèges permettant d’accorder ces autorisations à l’inscription de l’application

Un utilisateur disposant au moins du rôle Administrateur de rôle privilégié peut effectuer les deux opérations, tandis qu’un utilisateur disposant du rôle Administrateur d’application ou Administrateur d’application cloud peut uniquement ajouter les autorisations. Pour vous aider à appliquer la séparation des tâches et l’accès au moindre privilège, séparez les tâches d’ajout d’autorisations et d’octroi d’autorisations à différents utilisateurs. Pour plus d’informations sur les actions prises en charge par ces rôles, consultez Rôles intégrés Microsoft Entra.

En outre, vous avez besoin des ressources et privilèges suivants :

Connectez-vous à un client API tel que l’Explorateur Graph pour exécuter les requêtes HTTP.
L’autorisation doit être accordée à l’application Application.ReadWrite.All utilisée pour effectuer ces modifications.

Utiliser l’API des applications Microsoft Graph

L’objet d’application Microsoft Graph inclut une propriété requiredResourceAccess qui est une collection d’objets avec des informations sur l’API de ressource et les autorisations. Utilisez cette propriété pour configurer les autorisations Azure AD Graph comme décrit dans les étapes suivantes.

Étape 1 : Identifier les ID d’autorisation pour les autorisations Azure AD Graph requises par votre application

Identifiez les autorisations Azure AD Graph dont votre application a besoin, leurs ID d’autorisation et s’il s’agit de rôles d’application (autorisations d’application) ou oauth2PermissionScopes (autorisations déléguées). Pour plus d’informations, consultez Informations de référence sur les autorisations Azure AD Graph.

Azure AD Graph est identifié en tant qu’objet servicePrincipal avec 00000002-0000-0000-c000-000000000000 comme appId global unique et Windows Azure Active Directory comme displayName et appDisplayName. Exécutez la requête suivante pour récupérer l’objet principal de service pour Azure AD Graph dans votre locataire.

Demande

GET https://graph.microsoft.com/v1.0/servicePrincipals?$filter=appId eq '00000002-0000-0000-c000-000000000000'


// Code snippets are only available for the latest version. Current version is 5.x

// To initialize your graphClient, see https://learn.microsoft.com/en-us/graph/sdks/create-client?from=snippets&tabs=csharp
var result = await graphClient.ServicePrincipals.GetAsync((requestConfiguration) =>
{
	requestConfiguration.QueryParameters.Filter = "appId eq '00000002-0000-0000-c000-000000000000'";
});



mgc service-principals list --filter "appId eq '00000002-0000-0000-c000-000000000000'"



// Code snippets are only available for the latest major version. Current major version is $v1.*

// Dependencies
import (
	  "context"
	  msgraphsdk "github.com/microsoftgraph/msgraph-sdk-go"
	  graphserviceprincipals "github.com/microsoftgraph/msgraph-sdk-go/serviceprincipals"
	  //other-imports
)


requestFilter := "appId eq '00000002-0000-0000-c000-000000000000'"

requestParameters := &graphserviceprincipals.ServicePrincipalsRequestBuilderGetQueryParameters{
	Filter: &requestFilter,
}
configuration := &graphserviceprincipals.ServicePrincipalsRequestBuilderGetRequestConfiguration{
	QueryParameters: requestParameters,
}

// To initialize your graphClient, see https://learn.microsoft.com/en-us/graph/sdks/create-client?from=snippets&tabs=go
servicePrincipals, err := graphClient.ServicePrincipals().Get(context.Background(), configuration)


// Code snippets are only available for the latest version. Current version is 6.x

GraphServiceClient graphClient = new GraphServiceClient(requestAdapter);

ServicePrincipalCollectionResponse result = graphClient.servicePrincipals().get(requestConfiguration -> {
	requestConfiguration.queryParameters.filter = "appId eq '00000002-0000-0000-c000-000000000000'";
});


const options = {
	authProvider,
};

const client = Client.init(options);

let servicePrincipals = await client.api('/servicePrincipals')
	.filter('appId eq \'00000002-0000-0000-c000-000000000000\'')
	.get();


<?php
use Microsoft\Graph\GraphServiceClient;
use Microsoft\Graph\Generated\ServicePrincipals\ServicePrincipalsRequestBuilderGetRequestConfiguration;


$graphServiceClient = new GraphServiceClient($tokenRequestContext, $scopes);

$requestConfiguration = new ServicePrincipalsRequestBuilderGetRequestConfiguration();
$queryParameters = ServicePrincipalsRequestBuilderGetRequestConfiguration::createQueryParameters();
$queryParameters->filter = "appId eq '00000002-0000-0000-c000-000000000000'";
$requestConfiguration->queryParameters = $queryParameters;


$result = $graphServiceClient->servicePrincipals()->get($requestConfiguration)->wait();


Import-Module Microsoft.Graph.Applications

Get-MgServicePrincipal -Filter "appId eq '00000002-0000-0000-c000-000000000000'"


# Code snippets are only available for the latest version. Current version is 1.x
from msgraph import GraphServiceClient
from msgraph.generated.service_principals.service_principals_request_builder import ServicePrincipalsRequestBuilder
from kiota_abstractions.base_request_configuration import RequestConfiguration
# To initialize your graph_client, see https://learn.microsoft.com/en-us/graph/sdks/create-client?from=snippets&tabs=python
query_params = ServicePrincipalsRequestBuilder.ServicePrincipalsRequestBuilderGetQueryParameters(
		filter = "appId eq '00000002-0000-0000-c000-000000000000'",
)

request_configuration = RequestConfiguration(
query_parameters = query_params,
)

result = await graph_client.service_principals.get(request_configuration = request_configuration)

Réponse

Dans l’objet response, les détails des autorisations d’application Azure AD Graph sont répertoriés dans l’objet appRoles , tandis que les détails des autorisations déléguées sont répertoriés dans l’objet oauth2PermissionScopes .

HTTP/1.1 200 OK
Content-type: application/json

{
    "@odata.context": "https://graph.microsoft.com/v1.0/$metadata#servicePrincipals",
    "value": [
        {
            "id": "1804a6f8-e623-4520-8f40-ba1b0c11c42d",
            "accountEnabled": true,
            "appDisplayName": "Windows Azure Active Directory",
            "appDescription": null,
            "appId": "00000002-0000-0000-c000-000000000000",
            "appOwnerOrganizationId": "f8cdef31-a31e-4b4a-93e4-5f571e91255a",
            "appRoleAssignmentRequired": false,
            "displayName": "Windows Azure Active Directory",
            "servicePrincipalNames": [
                "https://graph.windows.net",
                "00000002-0000-0000-c000-000000000000/graph.microsoftazure.us",
                "00000002-0000-0000-c000-000000000000/graph.windows.net",
                "00000002-0000-0000-c000-000000000000/directory.windows.net",
                "00000002-0000-0000-c000-000000000000",
                "https://graph.windows.net/",
                "https://graph.microsoftazure.us"
            ],
            "servicePrincipalType": "Application",
            "signInAudience": "AzureADMultipleOrgs",
            "appRoles": [
                {
                    "allowedMemberTypes": [
                        "Application"
                    ],
                    "description": "Allows the app to read applications and service principals without a signed-in user",
                    "displayName": "Read all applications",
                    "id": "3afa6a7d-9b1a-42eb-948e-1650a849e176",
                    "isEnabled": true,
                    "origin": "Application",
                    "value": "Application.Read.All"
                }
            ],
            "oauth2PermissionScopes": [
                {
                    "adminConsentDescription": "Allows users to sign in to the app, and allows the app to read the profile of signed-in users. It also allow the app to read basic company information of signed-in users.",
                    "adminConsentDisplayName": "Sign in and read user profile",
                    "id": "311a71cc-e848-46a1-bdf8-97ff7156d8e6",
                    "isEnabled": true,
                    "type": "User",
                    "userConsentDescription": "Allows you to sign in to the app with your work account and let the app read your profile. It also allows the app to read basic company information.",
                    "userConsentDisplayName": "Sign you in and read your profile",
                    "value": "User.Read"
                }
            ]
        }
    ]
}

À partir de la sortie tronquée précédente, 311a71cc-e848-46a1-bdf8-97ff7156d8e6 est l’ID d’autorisation pour l’autorisation déléguée User.Read , tandis que 3afa6a7d-9b1a-42eb-948e-1650a849e176 est l’ID d’autorisation pour l’autorisation d’application Application.Read.All dans Azure AD Graph.

Étape 2 : Ajouter des autorisations Azure AD Graph à votre application

L’exemple suivant appelle l’API Mettre à jour l’application pour ajouter les autorisations déléguées et d’application User.Read et Application.Read.All d’Azure AD Graph à une inscription d’application identifiée par l’ID d’objet 581088ba-83c5-4975-b8af-11d2d7a76e98.

Importante

Pour mettre à jour la propriété requiredResourceAccess , vous devez transmettre les autorisations existantes et nouvelles. Le passage de nouvelles autorisations uniquement remplace et supprime les autorisations existantes.

Demande

PATCH https://graph.microsoft.com/v1.0/applications/581088ba-83c5-4975-b8af-11d2d7a76e98
Content-Type: application/json

{
    "requiredResourceAccess": [
        {
            "resourceAppId": "00000002-0000-0000-c000-000000000000",
            "resourceAccess": [
                {
                    "id": "311a71cc-e848-46a1-bdf8-97ff7156d8e6",
                    "type": "Scope"
                },
                {
                    "id": "3afa6a7d-9b1a-42eb-948e-1650a849e176",
                    "type": "Role"
                }
            ]
        }
    ]
}


// Code snippets are only available for the latest version. Current version is 5.x

// Dependencies
using Microsoft.Graph.Models;

var requestBody = new Application
{
	RequiredResourceAccess = new List<RequiredResourceAccess>
	{
		new RequiredResourceAccess
		{
			ResourceAppId = "00000002-0000-0000-c000-000000000000",
			ResourceAccess = new List<ResourceAccess>
			{
				new ResourceAccess
				{
					Id = Guid.Parse("311a71cc-e848-46a1-bdf8-97ff7156d8e6"),
					Type = "Scope",
				},
				new ResourceAccess
				{
					Id = Guid.Parse("3afa6a7d-9b1a-42eb-948e-1650a849e176"),
					Type = "Role",
				},
			},
		},
	},
};

// To initialize your graphClient, see https://learn.microsoft.com/en-us/graph/sdks/create-client?from=snippets&tabs=csharp
var result = await graphClient.Applications["{application-id}"].PatchAsync(requestBody);



mgc applications patch --application-id {application-id} --body '{\
    "requiredResourceAccess": [\
        {\
            "resourceAppId": "00000002-0000-0000-c000-000000000000",\
            "resourceAccess": [\
                {\
                    "id": "311a71cc-e848-46a1-bdf8-97ff7156d8e6",\
                    "type": "Scope"\
                },\
                {\
                    "id": "3afa6a7d-9b1a-42eb-948e-1650a849e176",\
                    "type": "Role"\
                }\
            ]\
        }\
    ]\
}\
'



// Code snippets are only available for the latest major version. Current major version is $v1.*

// Dependencies
import (
	  "context"
	  msgraphsdk "github.com/microsoftgraph/msgraph-sdk-go"
	  graphmodels "github.com/microsoftgraph/msgraph-sdk-go/models"
	  //other-imports
)

requestBody := graphmodels.NewApplication()


requiredResourceAccess := graphmodels.NewRequiredResourceAccess()
resourceAppId := "00000002-0000-0000-c000-000000000000"
requiredResourceAccess.SetResourceAppId(&resourceAppId) 


resourceAccess := graphmodels.NewResourceAccess()
id := uuid.MustParse("311a71cc-e848-46a1-bdf8-97ff7156d8e6")
resourceAccess.SetId(&id) 
type := "Scope"
resourceAccess.SetType(&type) 
resourceAccess1 := graphmodels.NewResourceAccess()
id := uuid.MustParse("3afa6a7d-9b1a-42eb-948e-1650a849e176")
resourceAccess1.SetId(&id) 
type := "Role"
resourceAccess1.SetType(&type) 

resourceAccess := []graphmodels.ResourceAccessable {
	resourceAccess,
	resourceAccess1,
}
requiredResourceAccess.SetResourceAccess(resourceAccess)

requiredResourceAccess := []graphmodels.RequiredResourceAccessable {
	requiredResourceAccess,
}
requestBody.SetRequiredResourceAccess(requiredResourceAccess)

// To initialize your graphClient, see https://learn.microsoft.com/en-us/graph/sdks/create-client?from=snippets&tabs=go
applications, err := graphClient.Applications().ByApplicationId("application-id").Patch(context.Background(), requestBody, nil)


// Code snippets are only available for the latest version. Current version is 6.x

GraphServiceClient graphClient = new GraphServiceClient(requestAdapter);

Application application = new Application();
LinkedList<RequiredResourceAccess> requiredResourceAccess = new LinkedList<RequiredResourceAccess>();
RequiredResourceAccess requiredResourceAccess1 = new RequiredResourceAccess();
requiredResourceAccess1.setResourceAppId("00000002-0000-0000-c000-000000000000");
LinkedList<ResourceAccess> resourceAccess = new LinkedList<ResourceAccess>();
ResourceAccess resourceAccess1 = new ResourceAccess();
resourceAccess1.setId(UUID.fromString("311a71cc-e848-46a1-bdf8-97ff7156d8e6"));
resourceAccess1.setType("Scope");
resourceAccess.add(resourceAccess1);
ResourceAccess resourceAccess2 = new ResourceAccess();
resourceAccess2.setId(UUID.fromString("3afa6a7d-9b1a-42eb-948e-1650a849e176"));
resourceAccess2.setType("Role");
resourceAccess.add(resourceAccess2);
requiredResourceAccess1.setResourceAccess(resourceAccess);
requiredResourceAccess.add(requiredResourceAccess1);
application.setRequiredResourceAccess(requiredResourceAccess);
Application result = graphClient.applications().byApplicationId("{application-id}").patch(application);


const options = {
	authProvider,
};

const client = Client.init(options);

const application = {
    requiredResourceAccess: [
        {
            resourceAppId: '00000002-0000-0000-c000-000000000000',
            resourceAccess: [
                {
                    id: '311a71cc-e848-46a1-bdf8-97ff7156d8e6',
                    type: 'Scope'
                },
                {
                    id: '3afa6a7d-9b1a-42eb-948e-1650a849e176',
                    type: 'Role'
                }
            ]
        }
    ]
};

await client.api('/applications/581088ba-83c5-4975-b8af-11d2d7a76e98')
	.update(application);


<?php
use Microsoft\Graph\GraphServiceClient;
use Microsoft\Graph\Generated\Models\Application;
use Microsoft\Graph\Generated\Models\RequiredResourceAccess;
use Microsoft\Graph\Generated\Models\ResourceAccess;


$graphServiceClient = new GraphServiceClient($tokenRequestContext, $scopes);

$requestBody = new Application();
$requiredResourceAccessRequiredResourceAccess1 = new RequiredResourceAccess();
$requiredResourceAccessRequiredResourceAccess1->setResourceAppId('00000002-0000-0000-c000-000000000000');
$resourceAccessResourceAccess1 = new ResourceAccess();
$resourceAccessResourceAccess1->setId('311a71cc-e848-46a1-bdf8-97ff7156d8e6');
$resourceAccessResourceAccess1->setType('Scope');
$resourceAccessArray []= $resourceAccessResourceAccess1;
$resourceAccessResourceAccess2 = new ResourceAccess();
$resourceAccessResourceAccess2->setId('3afa6a7d-9b1a-42eb-948e-1650a849e176');
$resourceAccessResourceAccess2->setType('Role');
$resourceAccessArray []= $resourceAccessResourceAccess2;
$requiredResourceAccessRequiredResourceAccess1->setResourceAccess($resourceAccessArray);

$requiredResourceAccessArray []= $requiredResourceAccessRequiredResourceAccess1;
$requestBody->setRequiredResourceAccess($requiredResourceAccessArray);


$result = $graphServiceClient->applications()->byApplicationId('application-id')->patch($requestBody)->wait();


Import-Module Microsoft.Graph.Applications

$params = @{
	requiredResourceAccess = @(
		@{
			resourceAppId = "00000002-0000-0000-c000-000000000000"
			resourceAccess = @(
				@{
					id = "311a71cc-e848-46a1-bdf8-97ff7156d8e6"
					type = "Scope"
				}
				@{
					id = "3afa6a7d-9b1a-42eb-948e-1650a849e176"
					type = "Role"
				}
			)
		}
	)
}

Update-MgApplication -ApplicationId $applicationId -BodyParameter $params


# Code snippets are only available for the latest version. Current version is 1.x
from msgraph import GraphServiceClient
from msgraph.generated.models.application import Application
from msgraph.generated.models.required_resource_access import RequiredResourceAccess
from msgraph.generated.models.resource_access import ResourceAccess
# To initialize your graph_client, see https://learn.microsoft.com/en-us/graph/sdks/create-client?from=snippets&tabs=python
request_body = Application(
	required_resource_access = [
		RequiredResourceAccess(
			resource_app_id = "00000002-0000-0000-c000-000000000000",
			resource_access = [
				ResourceAccess(
					id = UUID("311a71cc-e848-46a1-bdf8-97ff7156d8e6"),
					type = "Scope",
				),
				ResourceAccess(
					id = UUID("3afa6a7d-9b1a-42eb-948e-1650a849e176"),
					type = "Role",
				),
			],
		),
	],
)

result = await graph_client.applications.by_application_id('application-id').patch(request_body)

Réponse

HTTP/1.1 204 No Content

Étape 3 : Vérifier que les autorisations Azure AD Graph ont été ajoutées à votre application

Vérifiez que votre inscription d’application dispose des autorisations de l’API Graph Azure AD que vous avez ajoutées à l’étape 2 en :

Appel du point de terminaison Microsoft Graph GET /application/{id} et lecture de la propriété requiredResourceAccess comme suit :
```
GET https://graph.microsoft.com/v1.0/applications/581088ba-83c5-4975-b8af-11d2d7a76e98?$select=id,requiredResourceAccess
```
Vérification de la page Inscriptions d’applications dans le Centre d’administration Microsoft Entra.

Bien que vous ayez ajouté des autorisations Azure AD Graph, vous n’avez pas accordé ces autorisations à l’application. De nombreuses autorisations nécessitent le consentement de l’administrateur avant de pouvoir être utilisées pour accéder aux données de l’organisation. Connectez-vous au Centre d’administration Microsoft Entra en tant qu’administrateur de rôle privilégié et accordez le consentement administrateur pour les autorisations d’inscription de l’application.

Lorsque vous utilisez Microsoft Graph et tous les kits SDK associés, vous pouvez accorder des autorisations à une inscription d’application sans avoir à utiliser le Centre d’administration Microsoft Entra et en sélectionnant le bouton Accorder le consentement administrateur pour [Société] dans la page Autorisations de l’API. Pour plus d’informations, consultez Accorder ou révoquer des autorisations d’API par programmation.

Utiliser le Centre d’administration Microsoft Entra pour rechercher les API utilisées par votre organisation

Connectez-vous au Centre d'administration Microsoft 365.
DéveloppezApplications>d’identité>, sélectionnez Inscriptions d’applications.
Dans la fenêtre Inscriptions d’applications , sous l’onglet Toutes les applications , sélectionnez l’application à laquelle vous souhaitez ajouter des autorisations Azure AD Graph.
Dans le volet gauche de la fenêtre, sous le groupe de menus Gérer , sélectionnez Autorisations d’API. Dans la fenêtre Autorisations configurées , sélectionnez Ajouter une autorisation.
Dans la fenêtre Demander des autorisations d’API , basculez vers l’onglet API que mon organisation utilise et recherchez Windows Azure Active Directory ou 00000002-0000-0000-c000-000000000000. Sélectionnez dans le jeu de résultats filtré pour afficher la fenêtre Autorisations d’Azure Active Directory Graph .
Sélectionnez l’onglet Autorisations déléguées ou Autorisations d’application pour choisir dans la liste des autorisations déléguées et des autorisations d’application respectivement. Sélectionnez Ajouter des autorisations pour ajouter l’autorisation à l’inscription de votre application.
Après avoir ajouté les autorisations dont vous avez besoin, revenez dans la fenêtre Autorisations configurées , sélectionnez Accorder le consentement administrateur pour accorder les autorisations Azure AD Graph à l’inscription de votre application.

Mettre à jour le manifeste de l’application dans le Centre d’administration Microsoft Entra

Connectez-vous au Centre d'administration Microsoft 365.
Développez le menu >IdentitéApplications> sélectionnez Inscriptions d’applications.
Dans la fenêtre Inscriptions d’applications , sous l’onglet Toutes les applications , sélectionnez l’application à laquelle vous souhaitez ajouter des autorisations Azure AD Graph.
Dans le volet gauche de la fenêtre, sous le groupe de menus Gérer , sélectionnez Manifeste pour ouvrir un éditeur qui vous permet de modifier directement les attributs de l’objet d’inscription d’application.
Modifiez soigneusement la propriété requiredResourceAccess dans le manifeste de l’application pour ajouter les détails suivants :

Conseil

A. Vous pouvez modifier le manifeste de l’application dans le Centre d’administration Microsoft Entra ou sélectionner Télécharger pour modifier le manifeste localement, puis utiliser Charger pour le réappliquer à votre application.

B. Pour en savoir plus sur la configuration de la propriété requiredResourceAccess , consultez type de ressource requiredResourceAccess.

C. Reportez-vous aux informations de référence sur les autorisations Azure AD Graph pour plus d’informations sur les noms d’autorisation, les ID et les types d’autorisations Azure AD Graph.

5.1. Si aucune autorisation Azure AD Graph n’est attribuée à l’application, ajoutez la propriété resourceAppId et affectez la valeur 00000002-0000-0000-c000-000000000000 représentant Azure AD Graph.

5.2. Ajoutez la propriété resourceAccess et configurez les autorisations.

L’extrait de code JSON suivant montre une propriété requiredResourceAccess avec Azure AD Graph comme ressource, et les objets User.Read et Application.Read.All oauth2PermissionScope (autorisation déléguée) et appRole (autorisation d’application), respectivement.
```
"requiredResourceAccess": [
    {
        "resourceAppId": "00000002-0000-0000-c000-000000000000",
        "resourceAccess": [
            {
                "id": "311a71cc-e848-46a1-bdf8-97ff7156d8e6",
                "type": "Scope"
            },
            {
                "id": "3afa6a7d-9b1a-42eb-948e-1650a849e176",
                "type": "Role"
            }
        ]
    }
],
```
Enregistrez vos modifications.
Dans le groupe de menus Gérer , sélectionnez Autorisations d’API et, dans Autorisations configurées pour l’inscription de votre application, sélectionnez Accorder le consentement administrateur pour accorder les autorisations Azure AD Graph à votre inscription d’application.

Partager via

Configurer des autorisations Azure AD Graph pour une inscription d’application

Configuration requise

Utiliser l’API des applications Microsoft Graph

Étape 1 : Identifier les ID d’autorisation pour les autorisations Azure AD Graph requises par votre application

Demande

Réponse

Étape 2 : Ajouter des autorisations Azure AD Graph à votre application

Demande

Réponse

Étape 3 : Vérifier que les autorisations Azure AD Graph ont été ajoutées à votre application

Utiliser le Centre d’administration Microsoft Entra pour rechercher les API utilisées par votre organisation

Mettre à jour le manifeste de l’application dans le Centre d’administration Microsoft Entra

Commentaires

Ressources supplémentaires

Partager via

Configurer des autorisations Azure AD Graph pour une inscription d’application

Configuration requise

Utiliser l’API des applications Microsoft Graph

Étape 1 : Identifier les ID d’autorisation pour les autorisations Azure AD Graph requises par votre application

Demande

Réponse

Étape 2 : Ajouter des autorisations Azure AD Graph à votre application

Demande

Réponse

Étape 3 : Vérifier que les autorisations Azure AD Graph ont été ajoutées à votre application

Étape 4 : Accorder le consentement de l’administrateur

Accorder des autorisations d’API sans utiliser l’invite de consentement

Utiliser le Centre d’administration Microsoft Entra pour rechercher les API utilisées par votre organisation

Mettre à jour le manifeste de l’application dans le Centre d’administration Microsoft Entra

Contenu connexe

Commentaires

Ressources supplémentaires