Azure AD B2C: usare l'API Graph di Azure ADAzure AD B2C: Use the Azure AD Graph API

Nota

Per gestire gli utenti in una directory di Azure AD B2C è richiesto l'uso dell'API Graph di Azure AD.You must use the Azure AD Graph API to manage users in an Azure AD B2C directory. Si tratta di un'API diversa dall'API Microsoft Graph.This is different from the Microsoft Graph API. Fare clic qui per altre informazioni.Learn more here.

I tenant di Azure Active Directory (Azure AD) B2C tendono ad avere dimensioni molto grandi,Azure Active Directory (Azure AD) B2C tenants tend to be very large. il che significa che molte attività comuni di gestione dei tenant devono essere eseguite a livello di programmazione,This means that many common tenant management tasks need to be performed programmatically. ad esempio la gestione degli utenti.A primary example is user management. Potrebbe essere necessario eseguire la migrazione di un archivio utenti esistente in un tenant di B2C.You might need to migrate an existing user store to a B2C tenant. Potrebbe essere necessario ospitare la registrazione degli utenti nella propria pagina e creare gli account utente nella directory Azure AD B2C in background.You may want to host user registration on your own page and create user accounts in your Azure AD B2C directory behind the scenes. Questi tipi di attività richiedono la possibilità di creare, leggere, aggiornare ed eliminare gli account utente.These types of tasks require the ability to create, read, update, and delete user accounts. È possibile eseguire queste attività usando l'API Graph di Azure AD.You can do these tasks by using the Azure AD Graph API.

Per i tenant di B2C esistono essenzialmente due modalità di comunicazione con l'API Graph.For B2C tenants, there are two primary modes of communicating with the Graph API.

  • Per le attività interattive da eseguire una sola volta, è consigliabile eseguire le attività con un account amministratore nel tenant di B2C.For interactive, run-once tasks, you should act as an administrator account in the B2C tenant when you perform the tasks. Questa modalità richiede che un amministratore acceda con le credenziali prima di effettuare chiamate all'API Graph.This mode requires an administrator to sign in with credentials before that admin can perform any calls to the Graph API.
  • Per le attività automatizzate e continue è consigliabile usare un account del servizio a cui assegnare i privilegi necessari per eseguire le attività di gestione.For automated, continuous tasks, you should use some type of service account that you provide with the necessary privileges to perform management tasks. In Azure AD è possibile ottenere questo risultato registrando un'applicazione ed effettuando l'autenticazione in Azure AD.In Azure AD, you can do this by registering an application and authenticating to Azure AD. A questo scopo usare un ID applicazione che usa la concessione delle credenziali client OAuth 2.0.This is done by using an Application ID that uses the OAuth 2.0 client credentials grant. In questo caso l'applicazione agisce autonomamente, non come utente, per chiamare l'API Graph.In this case, the application acts as itself, not as a user, to call the Graph API.

In questo articolo verrà illustrato come eseguire il caso di uso automatizzato.In this article, we'll discuss how to perform the automated-use case. A scopo dimostrativo, verrà compilato un B2CGraphClient .NET 4.5 che esegue operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD, Create, Read, Update, Delete) di utenti.To demonstrate, we'll build a .NET 4.5 B2CGraphClient that performs user create, read, update, and delete (CRUD) operations. Il client avrà un'interfaccia della riga di comando di Windows che consente di richiamare diversi metodi.The client will have a Windows command-line interface (CLI) that allows you to invoke various methods. Tuttavia, il codice viene scritto affinché si comporti in modo automatico e non interattivo.However, the code is written to behave in a noninteractive, automated fashion.

Ottenere un tenant di Azure AD B2CGet an Azure AD B2C tenant

Prima di creare applicazioni o utenti oppure di interagire con Azure AD, saranno necessari un tenant di Azure AD B2C e un account amministratore globale in tale tenant.Before you can create applications or users, or interact with Azure AD at all, you will need an Azure AD B2C tenant and a global administrator account in the tenant. Se non è già disponibile un tenant vedere l' introduzione ad Azure AD B2C.If you don't have a tenant already, get started with Azure AD B2C.

Registrare l'applicazione nel tenantRegister your application in your tenant

Dopo aver creato un tenant B2C, è necessario registrare l'applicazione tramite il Portale di Azure.After you have a B2C tenant, you need to register your application via the Azure Portal.

Importante

Per usare l'API Graph con il tenant B2C, sarà necessario registrare un'applicazione dedicata usando il menu generico Registrazioni per l'app nel portale di Azure, NON il menu Applicazioni di Azure AD B2C.To use the Graph API with your B2C tenant, you will need to register a dedicated application by using the generic App Registrations menu in the Azure Portal, NOT Azure AD B2C's Applications menu. Non è possibile usare nuovamente le applicazioni B2C esistenti che sono state registrate nel menu Applicazioni di Azure AD B2C.You can't reuse the already-existing B2C applications that you registered in the Azure AD B2C's Applications menu.

  1. Accedere al portale di Azure.Sign in to the Azure portal.
  2. Scegliere il tenant di Azure AD B2C selezionando l'account nell'angolo superiore destro della pagina.Choose your Azure AD B2C tenant by selecting your account in the top right corner of the page.
  3. Nel riquadro di spostamento a sinistra scegliere More Services (Altri servizi), fare clic su Registrazioni per l'app e quindi su Aggiungi.In the left-hand navigation pane, choose More Services, click App Registrations, and click Add.
  4. Seguire le istruzioni e creare una nuova applicazione.Follow the prompts and create a new application.
    1. Selezionare App Web/API come Tipo di applicazione.Select Web App / API as the Application Type.
    2. Fornire qualsiasi URI di reindirizzamento (ad esempio https://B2CGraphAPI) in quanto non è rilevante per questo esempio.Provide any redirect URI (e.g. https://B2CGraphAPI) as it's not relevant for this example.
  5. L'applicazione verrà mostrata nell'elenco delle applicazioni, fare clic su di essa per ottenere l'ID applicazione (noto anche come ID Client).The application will now show up in the list of applications, click on it to obtain the Application ID (also known as Client ID). Copiarlo in quanto sarà necessario in una sezione successiva.Copy it as you'll need it in a later section.
  6. Nel menu Impostazioni fare clic su Chiavi e aggiungere una nuova chiave (nota anche come segreto client).In the Settings menu, click on Keys and add a new key (also known as client secret). Copiare anche questa per usarla in una sezione successiva.Also copy it for use in a later section.

Configurare le autorizzazioni creare, leggere e aggiornare per l'applicazioneConfigure create, read and update permissions for your application

A questo punto è necessario configurare l'applicazione per ottenere tutte le autorizzazioni necessarie per creare, leggere, aggiornare ed eliminare gli utenti.Now you need to configure your application to get all the required permissions to create, read, update and delete users.

  1. Continuando nel menu Registrazioni dell'app del portale di Azure, selezionare l'applicazione.Continuing in the Azure portal's App Registrations menu, select your application.
  2. Nel menu Impostazioni fare clic su Autorizzazioni necessarie.In the Settings menu, click on Required permissions.
  3. Nel menu Autorizzazioni necessarie fare clic su Windows Azure Active Directory.In the Required permissions menu, click on Windows Azure Active Directory.
  4. Nel menu Abilita accesso selezionare l'autorizzazione Leggi e scrivi i dati della directory da Autorizzazioni dell'applicazione e fare clic su Salva.In the Enable Access menu, select the Read and write directory data permission from Application Permissions and click Save.
  5. Infine, nel menu Autorizzazioni necessarie fare clic sul pulsante Concedi autorizzazioni.Finally, back in the Required permissions menu, click on the Grant Permissions button.

A questo punto è disponibile un'applicazione con le autorizzazioni per creare, leggere e aggiornare gli utenti dal tenant B2C.You now have an application that has permission to create, read and update users from your B2C tenant.

Nota

Il completamento dell'operazione di concessione di autorizzazioni può richiedere alcuni minuti.Granting permissions make take a few minutes to fully process.

Configurare le autorizzazioni di eliminazione per l'applicazioneConfigure delete permissions for your application

L'autorizzazione Legge e scrive i dati della directory attualmente NON include la possibilità di eseguire le eliminazioni, ad esempio l'eliminazione degli utenti.Currently, the Read and write directory data permission does NOT include the ability to do any deletions such as deleting users. Se si desidera assegnare all'applicazione la possibilità di eliminare gli utenti, è necessario eseguire questi passaggi aggiuntivi che coinvolgono PowerShell. In caso contrario, è possibile passare alla sezione successiva.If you want to give your application the ability to delete users, you'll need to do these extra steps that involve PowerShell, otherwise, you can skip to the next section.

Prima di tutto. se non è già installato, installare il modulo Azure AD PowerShell v1 (MSOnline):First, if you don't already have it installed, install the Azure AD PowerShell v1 module (MSOnline):

Install-Module MSOnline

Dopo aver installato il modulo di PowerShell, connettersi al tenant di Azure AD B2C.After you install the PowerShell module connect to your Azure AD B2C tenant.

Importante

È necessario usare un account di amministratore tenant B2C che sia locale in relazione al tenant B2C.You need to use a B2C tenant administrator account that is local to the B2C tenant. Questi account hanno un aspetto simile a questo: myusername@myb2ctenant.onmicrosoft.com.These accounts look like this: myusername@myb2ctenant.onmicrosoft.com.

Connect-MsolService

A questo punto si userà l'ID applicazione nello script seguente per assegnare all'applicazione il ruolo di amministratore account utente che consentirà di eliminare gli utenti.Now we'll use the Application ID in the script below to assign the application the user account administrator role which will allow it to delete users. Questi ruoli hanno identificatori noti, pertanto è sufficiente eseguire l'input dell'ID applicazione nello script seguente.These roles have well-known identifiers, so all you need to do is input your Application ID in the script below.

$applicationId = "<YOUR_APPLICATION_ID>"
$sp = Get-MsolServicePrincipal -AppPrincipalId $applicationId
Add-MsolRoleMember -RoleObjectId fe930be7-5e62-47db-91af-98c3a49a38b1 -RoleMemberObjectId $sp.ObjectId -RoleMemberType servicePrincipal

Ora l'applicazione dispone anche delle autorizzazioni per eliminare gli utenti dal tenant B2C.Your application now also has permissions to delete users from your B2C tenant.

Scaricare, configurare e compilare il codice di esempioDownload, configure, and build the sample code

Scaricare prima di tutto il codice di esempio ed eseguirlo.First, download the sample code and get it running. Esaminare quindi il codice.Then we will take a closer look at it. È possibile scaricare il codice di esempio come file ZIP.You can download the sample code as a .zip file. È anche possibile clonarlo nella directory desiderata:You can also clone it into a directory of your choice:

git clone https://github.com/AzureADQuickStarts/B2C-GraphAPI-DotNet.git

Aprire la soluzione Visual Studio B2CGraphClient\B2CGraphClient.sln in Visual Studio.Open the B2CGraphClient\B2CGraphClient.sln Visual Studio solution in Visual Studio. Nel progetto B2CGraphClient, aprire il file App.config.In the B2CGraphClient project, open the file App.config. Sostituire le tre impostazioni dell'app con valori personalizzati:Replace the three app settings with your own values:

<appSettings>
    <add key="b2c:Tenant" value="{Your Tenant Name}" />
    <add key="b2c:ClientId" value="{The ApplicationID from above}" />
    <add key="b2c:ClientSecret" value="{The Key from above}" />
</appSettings>

Nota

Il nome del tenant B2C è il dominio immesso durante la creazione del tenant e viene visualizzato nel pannello della directory nel portale di Azure.Your B2C tenant's name is the domain that you entered during tenant creation, and is displayed on the directory blade in the Azure portal. In genere termina con il suffisso .onmicrosoft.com, ad esempio, contosob2c.onmicrosoft.com.It usually ends with the suffix .onmicrosoft.com, for instance, contosob2c.onmicrosoft.com.

Fare quindi clic con il pulsante destro del mouse sulla soluzione B2CGraphClient e ricompilare l'esempio.Next, right-click on the B2CGraphClient solution and rebuild the sample. Se l'operazione riesce, sarà disponibile un file eseguibile B2C.exe in B2CGraphClient\bin\Debug.If you are successful, you should now have a B2C.exe executable file located in B2CGraphClient\bin\Debug.

Creare operazioni CRUD utente usando l'API GraphBuild user CRUD operations by using the Graph API

Per usare B2CGraphClient aprire un prompt dei comandi cmd di Windows e passare alla directory Debug.To use the B2CGraphClient, open a cmd Windows command prompt and change your directory to the Debug directory. Eseguire quindi il comando B2C Help .Then run the B2C Help command.

> cd B2CGraphClient\bin\Debug
> B2C Help

Verrà visualizzata una breve descrizione di ogni comando.This will display a brief description of each command. Ogni volta che si richiama uno di questi comandi, B2CGraphClient invia una richiesta all'API Graph di Azure AD.Each time you invoke one of these commands, B2CGraphClient makes a request to the Azure AD Graph API.

Ottenere un token di accessoGet an access token

Qualsiasi richiesta per l'API Graph necessita di un token di accesso per l'autenticazione.Any request to the Graph API requires an access token for authentication. B2CGraphClient usa Active Directory Authentication Library (ADAL) open source per semplificare l'acquisizione di token di accesso.B2CGraphClient uses the open-source Active Directory Authentication Library (ADAL) to help acquire access tokens. ADAL semplifica l'acquisizione del token fornendo un'API semplice e avendo cura di alcuni dettagli importanti, come la memorizzazione nella cache dei token di accesso.ADAL makes token acquisition easier by providing a simple API and taking care of some important details, such as caching access tokens. Non è tuttavia necessario usare ADAL per ottenere i token.You don't have to use ADAL to get tokens, though. È anche possibile ottenere i token creando richieste HTTP.You can also get tokens by crafting HTTP requests.

Nota

Questo esempio di codice usa ADAL v2 per comunicare con l'API Graph.This code sample uses ADAL v2 in order to communicate with the Graph API. Per ottenere token di accesso utilizzabili con l'API Graph di Azure AD, è necessario usare ADAL versione 2 o 3.You must use ADAL v2 or v3 in order to get access tokens which can be used with the Azure AD Graph API.

Quando si esegue B2CGraphClient, si crea un'istanza della classe B2CGraphClient.When B2CGraphClient runs, it creates an instance of the B2CGraphClient class. Il costruttore per questa classe imposta uno scaffolding di autenticazione di ADAL:The constructor for this class sets up an ADAL authentication scaffolding:

public B2CGraphClient(string clientId, string clientSecret, string tenant)
{
    // The client_id, client_secret, and tenant are provided in Program.cs, which pulls the values from App.config
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.tenant = tenant;

    // The AuthenticationContext is ADAL's primary class, in which you indicate the tenant to use.
    this.authContext = new AuthenticationContext("https://login.microsoftonline.com/" + tenant);

    // The ClientCredential is where you pass in your client_id and client_secret, which are
    // provided to Azure AD in order to receive an access_token by using the app's identity.
    this.credential = new ClientCredential(clientId, clientSecret);
}

Verrà usato come esempio il comando B2C Get-User .We'll use the B2C Get-User command as an example. Quando si richiama B2C Get-User senza input aggiuntivi, l’interfaccia della riga di comando chiama il metodo B2CGraphClient.GetAllUsers(...).When B2C Get-User is invoked without any additional inputs, the CLI calls the B2CGraphClient.GetAllUsers(...) method. Questo metodo chiama B2CGraphClient.SendGraphGetRequest(...), che invia una richiesta HTTP GET all'API Graph.This method calls B2CGraphClient.SendGraphGetRequest(...), which submits an HTTP GET request to the Graph API. Prima di inviare la richiesta GET, B2CGraphClient.SendGraphGetRequest(...) ottiene un token di accesso usando ADAL:Before B2CGraphClient.SendGraphGetRequest(...) sends the GET request, it first gets an access token by using ADAL:

public async Task<string> SendGraphGetRequest(string api, string query)
{
    // First, use ADAL to acquire a token by using the app's identity (the credential)
    // The first parameter is the resource we want an access_token for; in this case, the Graph API.
    AuthenticationResult result = authContext.AcquireToken("https://graph.windows.net", credential);

    ...

È possibile ottenere un token di accesso per l'API Graph chiamando il metodo AuthenticationContext.AcquireToken(...) di ADAL.You can get an access token for the Graph API by calling the ADAL AuthenticationContext.AcquireToken(...) method. ADAL restituisce quindi un valore access_token che rappresenta l'identità dell'applicazione.ADAL then returns an access_token that represents the application's identity.

Leggere gli utentiRead users

Quando si vuole ottenere un elenco di utenti oppure un utente specifico dall'API Graph, è possibile inviare una richiesta HTTP GET all'endpoint /users.When you want to get a list of users or get a particular user from the Graph API, you can send an HTTP GET request to the /users endpoint. Una richiesta per tutti gli utenti in un tenant ha un aspetto analogo al seguente:A request for all of the users in a tenant looks like this:

GET https://graph.windows.net/contosob2c.onmicrosoft.com/users?api-version=1.6
Authorization: Bearer eyJhbGciOiJSUzI1NiIsIng1dCI6IjdkRC1nZWNOZ1gxWmY3R0xrT3ZwT0IyZGNWQSIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJod...

Per visualizzare questa richiesta, eseguire:To see this request, run:

> B2C Get-User

Esistono due aspetti importanti da notare:There are two important things to note:

  • Il token di accesso acquisito tramite ADAL viene aggiunto all'intestazione Authorization usando lo schema Bearer.The access token acquired via ADAL is added to the Authorization header by using the Bearer scheme.
  • Per i tenant B2C, è necessario usare il parametro della query api-version=1.6.For B2C tenants, you must use the query parameter api-version=1.6.

Entrambi questi dettagli vengono gestiti con il metodo B2CGraphClient.SendGraphGetRequest(...) :Both of these details are handled in the B2CGraphClient.SendGraphGetRequest(...) method:

public async Task<string> SendGraphGetRequest(string api, string query)
{
    ...

    // For B2C user management, be sure to use the 1.6 Graph API version.
    HttpClient http = new HttpClient();
    string url = "https://graph.windows.net/" + tenant + api + "?" + "api-version=1.6";
    if (!string.IsNullOrEmpty(query))
    {
        url += "&" + query;
    }

    // Append the access token for the Graph API to the Authorization header of the request by using the Bearer scheme.
    HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url);
    request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", result.AccessToken);
    HttpResponseMessage response = await http.SendAsync(request);

    ...

Creare account utente consumerCreate consumer user accounts

Quando si creano account utente nel tenant di B2C, è possibile inviare una richiesta HTTP POST all'endpoint /users:When you create user accounts in your B2C tenant, you can send an HTTP POST request to the /users endpoint:

POST https://graph.windows.net/contosob2c.onmicrosoft.com/users?api-version=1.6
Authorization: Bearer eyJhbGciOiJSUzI1NiIsIng1dCI6IjdkRC1nZWNOZ1gxWmY3R0xrT3ZwT0IyZGNWQSIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJod...
Content-Type: application/json
Content-Length: 338

{
    // All of these properties are required to create consumer users.

    "accountEnabled": true,
    "signInNames": [                            // controls which identifier the user uses to sign in to the account
        {
            "type": "emailAddress",             // can be 'emailAddress' or 'userName'
            "value": "joeconsumer@gmail.com"
        }
    ],
    "creationType": "LocalAccount",            // always set to 'LocalAccount'
    "displayName": "Joe Consumer",                // a value that can be used for displaying to the end user
    "mailNickname": "joec",                        // an email alias for the user
    "passwordProfile": {
        "password": "P@ssword!",
        "forceChangePasswordNextLogin": false   // always set to false
    },
    "passwordPolicies": "DisablePasswordExpiration"
}

La maggior parte delle proprietà di questa richiesta è necessaria per creare utenti consumer.Most of these properties in this request are required to create consumer users. Per altre informazioni, fare clic qui.To learn more, click here. I commenti // sono stati inclusi a scopo illustrativo.Note that the // comments have been included for illustration. Non includerli in una richiesta effettiva.Do not include them in an actual request.

Per visualizzare la richiesta, eseguire uno dei comandi seguenti:To see the request, run one of the following commands:

> B2C Create-User ..\..\..\usertemplate-email.json
> B2C Create-User ..\..\..\usertemplate-username.json

Il comando Create-User accetta un file con estensione json come parametro di input.The Create-User command takes a .json file as an input parameter. Il file include una rappresentazione JSON di un oggetto utente.This contains a JSON representation of a user object. Nel codice di esempio sono presenti due file con estensione json: usertemplate-email.json e usertemplate-username.json.There are two sample .json files in the sample code: usertemplate-email.json and usertemplate-username.json. È possibile modificare questi file per adeguarli alle proprie esigenze.You can modify these files to suit your needs. Oltre ai campi obbligatori precedenti, questi file includono alcuni campi facoltativi che possono essere usati.In addition to the required fields above, several optional fields that you can use are included in these files. Per informazioni dettagliate sui campi facoltativi, vedere le informazioni di riferimento sull'API Graph di Azure AD.Details on the optional fields can be found in the Azure AD Graph API entity reference.

Per informazioni sul modo in cui viene costruita la richiesta POST, vedere B2CGraphClient.SendGraphPostRequest(...).You can see how the POST request is constructed in B2CGraphClient.SendGraphPostRequest(...).

  • Collega un token di accesso all'intestazione Authorization della richiesta.It attaches an access token to the Authorization header of the request.
  • Imposta api-version=1.6.It sets api-version=1.6.
  • Include l'oggetto utente JSON nel corpo della richiesta.It includes the JSON user object in the body of the request.

Nota

Se gli account di cui si vuole eseguire la migrazione da un archivio utenti esistente hanno un livello di complessità della password inferiore al livello avanzato di complessità della password applicato da Azure AD B2C, è possibile disabilitare il requisito per la password complessa usando il valore DisableStrongPassword nella proprietà passwordPolicies.If the accounts that you want to migrate from an existing user store has lower password strength than the strong password strength enforced by Azure AD B2C, you can disable the strong password requirement using the DisableStrongPassword value in the passwordPolicies property. È ad esempio possibile modificare la richiesta di creazione utente indicata in precedenza come segue: "passwordPolicies": "DisablePasswordExpiration, DisableStrongPassword".For instance, you can modify the create user request provided above as follows: "passwordPolicies": "DisablePasswordExpiration, DisableStrongPassword".

Aggiornare gli account utente consumerUpdate consumer user accounts

Quando si aggiornano gli oggetti utente, il processo è simile a quello per la creazione di oggetti utente,When you update user objects, the process is similar to the one you use to create user objects. ma questo processo usa il metodo HTTP PATCH:But this process uses the HTTP PATCH method:

PATCH https://graph.windows.net/contosob2c.onmicrosoft.com/users/<user-object-id>?api-version=1.6
Authorization: Bearer eyJhbGciOiJSUzI1NiIsIng1dCI6IjdkRC1nZWNOZ1gxWmY3R0xrT3ZwT0IyZGNWQSIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJod...
Content-Type: application/json
Content-Length: 37

{
    "displayName": "Joe Consumer",                // this request updates only the user's displayName
}

Provare ad aggiornare un utente aggiornando i file JSON con nuovi dati.Try to update a user by updating your JSON files with new data. È quindi possibile usare B2CGraphClient per eseguire uno di questi comandi:You can then use B2CGraphClient to run one of these commands:

> B2C Update-User <user-object-id> ..\..\..\usertemplate-email.json
> B2C Update-User <user-object-id> ..\..\..\usertemplate-username.json

Esaminare il metodo B2CGraphClient.SendGraphPatchRequest(...) per informazioni dettagliate su come inviare la richiesta.Inspect the B2CGraphClient.SendGraphPatchRequest(...) method for details on how to send this request.

Cercare gli utentiSearch users

È possibile cercare gli utenti nel tenant di B2C in due modi:You can search for users in your B2C tenant in a couple of ways. con l'ID oggetto dell'utente oppure con l'identificatore di accesso dell'utente, ovvero la proprietà signInNames.One, using the user's object ID or two, using the user's sign-in identifer (i.e., the signInNames property).

Eseguire uno dei comandi seguenti per cercare un utente specifico:Run one of the following commands to search for a specific user:

> B2C Get-User <user-object-id>
> B2C Get-User <filter-query-expression>

Ecco alcuni esempi:Here are a couple of examples:

> B2C Get-User 2bcf1067-90b6-4253-9991-7f16449c2d91
> B2C Get-User $filter=signInNames/any(x:x/value%20eq%20%27joeconsumer@gmail.com%27)

Eliminare gli utentiDelete users

Il processo per l'eliminazione di un utente è molto semplice.The process for deleting a user is straightforward. Usare il metodo HTTP DELETE e costruire l'URL con l'ID oggetto corretto:Use the HTTP DELETE method and construct the URL with the correct object ID:

DELETE https://graph.windows.net/contosob2c.onmicrosoft.com/users/<user-object-id>?api-version=1.6
Authorization: Bearer eyJhbGciOiJSUzI1NiIsIng1dCI6IjdkRC1nZWNOZ1gxWmY3R0xrT3ZwT0IyZGNWQSIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJod...

Per visualizzare un esempio, immettere questo comando e visualizzare la richiesta di eliminazione stampata nella console:To see an example, enter this command and view the delete request that is printed to the console:

> B2C Delete-User <object-id-of-user>

Esaminare il metodo B2CGraphClient.SendGraphDeleteRequest(...) per informazioni dettagliate su come inviare la richiesta.Inspect the B2CGraphClient.SendGraphDeleteRequest(...) method for details on how to send this request.

È possibile eseguire molte altre azioni con l'API Graph di Azure AD, oltre alla gestione degli utenti.You can perform many other actions with the Azure AD Graph API in addition to user management. Le informazioni di riferimento sull'API Graph di Azure AD illustrano i dettagli di ogni azione, insieme a richieste di esempio.The Azure AD Graph API reference provides details on each action, along with sample requests.

Usare gli attributi personalizzatiUse custom attributes

La maggior parte delle applicazioni consumer deve archiviare alcune informazioni del profilo utente personalizzate.Most consumer applications need to store some type of custom user profile information. Per eseguire questa operazione è ad esempio possibile definire un attributo personalizzato nel tenant di B2C.One way you can do this is to define a custom attribute in your B2C tenant. È quindi possibile gestire l'attributo nello stesso modo in cui si gestisce qualsiasi altra proprietà in un oggetto utente.You can then treat that attribute the same way you treat any other property on a user object. È possibile aggiornare l'attributo, eliminarlo, eseguire una query in base all'attributo, inviarlo come attestazione in un token di accesso e così via.You can update the attribute, delete the attribute, query by the attribute, send the attribute as a claim in sign-in tokens, and more.

Per definire un attributo personalizzato nel tenant di B2C, vedere le informazioni di riferimento sugli attributi personalizzati di B2C.To define a custom attribute in your B2C tenant, see the B2C custom attribute reference.

È possibile visualizzare gli attributi personalizzati definiti nel tenant di B2C usando B2CGraphClient:You can view the custom attributes defined in your B2C tenant by using B2CGraphClient:

> B2C Get-B2C-Application
> B2C Get-Extension-Attribute <object-id-in-the-output-of-the-above-command>

L'output di queste funzioni rivela i dettagli di ogni attributo personalizzato, ad esempio:The output of these functions reveals the details of each custom attribute, such as:

{
      "odata.type": "Microsoft.DirectoryServices.ExtensionProperty",
      "objectType": "ExtensionProperty",
      "objectId": "cec6391b-204d-42fe-8f7c-89c2b1964fca",
      "deletionTimestamp": null,
      "appDisplayName": "",
      "name": "extension_55dc0861f9a44eb999e0a8a872204adb_Jersey_Number",
      "dataType": "Integer",
      "isSyncedFromOnPremises": false,
      "targetObjects": [
        "User"
      ]
}

È possibile usare il nome completo, ad esempio extension_55dc0861f9a44eb999e0a8a872204adb_Jersey_Number, come proprietà per gli oggetti utente.You can use the full name, such as extension_55dc0861f9a44eb999e0a8a872204adb_Jersey_Number, as a property on your user objects. Aggiornare il file con estensione json con la nuova proprietà e un valore per la proprietà, quindi eseguire:Update your .json file with the new property and a value for the property, and then run:

> B2C Update-User <object-id-of-user> <path-to-json-file>

Se si usa B2CGraphClient, si ha a disposizione un'applicazione di servizio che può gestire gli utenti del tenant di B2C a livello di codice.By using B2CGraphClient, you have a service application that can manage your B2C tenant users programmatically. B2CGraphClient usa la propria identità di applicazione per l'autenticazione all'API Graph di Azure AD.B2CGraphClient uses its own application identity to authenticate to the Azure AD Graph API. Acquisisce anche i token usando un segreto client.It also acquires tokens by using a client secret. Quando si incorpora questa funzionalità nell'applicazione, tenere presenti alcuni punti chiave per le applicazioni B2C:As you incorporate this functionality into your application, remember a few key points for B2C apps:

  • È necessario concedere all'applicazione le autorizzazioni appropriate nel tenant.You need to grant the application the proper permissions in the tenant.
  • Attualmente è necessario usare ADAL (non MSAL) per ottenere i token di accesso.For now, you need to use ADAL (not MSAL) to get access tokens. È anche possibile inviare direttamente messaggi di protocollo, senza usare una raccolta.(You can also send protocol messages directly, without using a library.)
  • Quando si chiama l'API Graph, usare api-version=1.6.When you call the Graph API, use api-version=1.6.
  • Quando si creano e aggiornano utenti consumer, sono necessarie alcune proprietà, come illustrato in precedenza.When you create and update consumer users, a few properties are required, as described above.

In caso di domande o richieste relative ad azioni che si vorrebbe eseguire mediante l'API Graph nel tenant di B2C, inserire un commento a questo articolo o inviare una richiesta nel repository di esempi di codice di GitHub.If you have any questions or requests for actions you would like to perform by using the Graph API on your B2C tenant, leave a comment on this article or file an issue in the GitHub code sample repository.