Övning – Implementera interaktiv autentisering med hjälp av MSAL.NET

10 minuter

I den här övningen får du lära dig hur du utför följande åtgärder:

Registrera en app på Microsoft Identity Platform
PublicClientApplicationBuilder Använd klassen i MSAL.NET
Hämta en token interaktivt i ett konsolprogram

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Om du inte redan har en sådan kan du registrera dig för en kostnadsfri utvärderingsversion på https://azure.com/free
Visual Studio Code: Du kan installera Visual Studio Code från https://code.visualstudio.com.
En version av .NET SDK https://dotnet.microsoft.com/download/dotnet (6.0, 7.0 eller 8.0)

Registrera ett nytt program

Logga in på portalen: https://portal.azure.com
Sök efter och markera Microsoft Entra ID.
Under Hantera väljer du Appregistreringar> Ny registrering.

När sidan registrera ett program visas anger du programmets registreringsinformation:

Fält	Värde
Namn	`az204appreg`
Kontotyper som stöds	Välj Endast konton i den här organisationskatalogen
Omdirigerings-URI (valfritt)	Välj Offentlig klient/intern (mobil och skrivbord) och ange `http://localhost` i rutan till höger.

Välj Registrera.

Microsoft Entra-ID tilldelar ett unikt program-ID (klient)-ID till din app och du tas till programmets översiktssida.

Konfigurera konsolprogrammet

Starta Visual Studio Code och öppna en terminal genom att välja Terminal och sedan Ny terminal.
Skapa en mapp för projektet och ändra till mappen.
```
md az204-auth
cd az204-auth
```
Skapa .NET-konsolappen.
```
dotnet new console
```
Öppna mappen az204-auth i Visual Studio Code.
```
code . -r
```

Skapa konsolappen

I det här avsnittet lägger du till nödvändiga paket och kod i projektet.

Lägga till paket och använda instruktioner

Microsoft.Identity.Client Lägg till paketet i projektet i en terminal i Visual Studio Code.
```
dotnet add package Microsoft.Identity.Client
```
Öppna filen Program.cs och lägg till using instruktioner som ska inkluderas Microsoft.Identity.Client och för att aktivera asynkrona åtgärder.
```
using System.Threading.Tasks;
using Microsoft.Identity.Client;
```
Ändra main-metoden för att aktivera asynkronisering.
```
public static async Task Main(string[] args)
```

Lägga till kod för interaktiv autentisering

Du behöver två variabler för att lagra program-ID:t (klient) och katalog -ID:t (klientorganisation). Du kan kopiera dessa värden från portalen. Lägg till följande kod och ersätt strängvärdena med lämpliga värden från portalen.
```
private const string _clientId = "APPLICATION_CLIENT_ID";
private const string _tenantId = "DIRECTORY_TENANT_ID";
```

PublicClientApplicationBuilder Använd klassen för att skapa auktoriseringskontexten.

var app = PublicClientApplicationBuilder
    .Create(_clientId)
    .WithAuthority(AzureCloudInstance.AzurePublic, _tenantId)
    .WithRedirectUri("http://localhost")
    .Build();

Kod	beskrivning
`.Create`	Skapar ett `PublicClientApplicationBuilder` från ett clientID.
`.WithAuthority`	Lägger till en känd utfärdare som motsvarar en ADFS-server. I koden anger vi det offentliga molnet och använder klientorganisationen för den app som vi registrerade.

Hämta en token

När du registrerade az204appreg-appen genererade den automatiskt en API-behörighet user.read för Microsoft Graph. Du använder den behörigheten för att hämta en token.

Ange behörighetsomfånget för tokenbegäran. Lägg till följande kod under PublicClientApplicationBuilder.
```
string[] scopes = { "user.read" };
```

Lägg till kod för att begära token och skriva ut resultatet till konsolen.

AuthenticationResult result = await app.AcquireTokenInteractive(scopes).ExecuteAsync();

Console.WriteLine($"Token:\t{result.AccessToken}");

Granska slutfört program

Innehållet i filen Program.cs bör likna följande exempel:

using System;
using System.Threading.Tasks;
using Microsoft.Identity.Client;

namespace az204_auth
{
    class Program
    {
        private const string _clientId = "APPLICATION_CLIENT_ID";
        private const string _tenantId = "DIRECTORY_TENANT_ID";

        public static async Task Main(string[] args)
        {
            var app = PublicClientApplicationBuilder
                .Create(_clientId)
                .WithAuthority(AzureCloudInstance.AzurePublic, _tenantId)
                .WithRedirectUri("http://localhost")
                .Build(); 
            string[] scopes = { "user.read" };
            AuthenticationResult result = await app.AcquireTokenInteractive(scopes).ExecuteAsync();

            Console.WriteLine($"Token:\t{result.AccessToken}");
        }
    }
}

Kör appen

I Visual Studio Code-terminalen kör du dotnet build för att söka efter fel och sedan dotnet run köra appen.
Appen öppnar standardwebbläsaren där du uppmanas att välja det konto som du vill autentisera med. Om det finns flera konton i listan väljer du den som är associerad med den klientorganisation som används i appen.
Om det är första gången du autentiserar till den registrerade appen får du ett meddelande om att behörigheter begärs och ber dig godkänna appen för att läsa data som är associerade med ditt konto. Välj Acceptera.
Du bör se resultatet som liknar exemplet nedan i -konsolen.
```
Token:  eyJ0eXAiOiJKV1QiLCJub25jZSI6IlVhU.....
```