Lägga till autentisering i Xamarin.Forms-appen

Artikel
01/12/2024

Not

Den här produkten har dragits tillbaka. En ersättning för projekt som använder .NET 8 eller senare finns i Community Toolkit Datasync-biblioteket.

I den här självstudien lägger du till Microsoft-autentisering i din app med hjälp av Microsoft Entra-ID. Innan du slutför den här självstudien kontrollerar du att du har skapat projektet och distribuerat serverdelen.

Not

Eftersom iOS-appen kräver nyckelringsåtkomst måste du konfigurera en iOS-etableringsprofil. En etableringsprofil kräver antingen en riktig iOS-enhet eller ett betalt Apple Developer-konto (om du använder simulatorn). Du kan hoppa över den här självstudien och gå vidare till att lägga till offlineåtkomst till din app om du inte kan använda autentisering på grund av den här begränsningen.

Dricks

Även om vi använder Microsoft Entra-ID för autentisering kan du använda valfritt autentiseringsbibliotek som du vill med Azure Mobile Apps.

Lägga till autentisering i serverdelstjänsten

Din serverdelstjänst är en standardtjänst ASP.NET 6. Alla självstudier som visar hur du aktiverar autentisering för en ASP.NET 6-tjänst fungerar med Azure Mobile Apps.

Om du vill aktivera Microsoft Entra-autentisering för din serverdelstjänst måste du:

Registrera ett program med Microsoft Entra-ID.
Lägg till autentiseringskontroll i ASP.NET 6-serverdelsprojektet.

Registrera programmet

Registrera först webb-API:et i din Microsoft Entra-klientorganisation och lägg till ett omfång genom att följa dessa steg:

Logga in på Azure-portalen.
Om du har åtkomst till flera klienter använder du Kataloger + prenumerationer filtrera på den översta menyn för att växla till den klientorganisation där du vill registrera programmet.
Sök efter och välj Microsoft Entra ID.
Under Hanteraväljer du Appregistreringar>Ny registrering.
- Namn: ange ett namn för ditt program; till exempel Snabbstart för TodoApp. Användare av din app ser det här namnet. Du kan ändra det senare.
- Kontotyper som stöds: Konton i valfri organisationskatalog (Alla Microsoft Entra-kataloger – Multitenant) och personliga Microsoft-konton (t.ex. Skype, Xbox)
Välj Registrera.
Under Hanteraväljer du Exponera ett API>Lägg till ett omfång.
För program-ID-URIaccepterar du standardinställningen genom att välja Spara och fortsätta.
Ange följande information:
- Omfångsnamn: access_as_user
- Vem kan samtycka?: administratörer och användare
- Visningsnamn för administratörsmedgivande: Access TodoApp
- Beskrivning av administratörsmedgivande: Allows the app to access TodoApp as the signed-in user.
- Visningsnamn för användarmedgivande: Access TodoApp
- Beskrivning av användarmedgivande: Allow the app to access TodoApp on your behalf.
- state: Enabled
Välj Lägg till omfång för att slutföra omfångstillägget.
Observera värdet för omfånget, ungefär som api://<client-id>/access_as_user (kallas Web API-omfång). Du behöver omfånget när du konfigurerar klienten.
Välj Översikt.
Observera application(client) ID i avsnittet Essentials (kallas Web API Application ID). Du behöver det här värdet för att konfigurera serverdelstjänsten.

Öppna Visual Studio och välj det TodoAppService.NET6 projektet.

Högerklicka på projektet TodoAppService.NET6 och välj sedan Hantera NuGet-paket....
På den nya fliken väljer du Bläddraoch anger sedan Microsoft.Identity.Web i sökrutan.
Välj Microsoft.Identity.Web-paketet och tryck sedan på Installera.
Följ anvisningarna för att slutföra installationen av paketet.
Öppna Program.cs. Lägg till följande i listan över using-instruktioner:

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.Identity.Web;

Lägg till följande kod direkt ovanför anropet till builder.Services.AddDbContext():

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
  .AddMicrosoftIdentityWebApi(builder.Configuration);
builder.Services.AddAuthorization();

Lägg till följande kod direkt ovanför anropet till app.MapControllers():

app.UseAuthentication();
app.UseAuthorization();

Din Program.cs bör nu se ut så här:

using Microsoft.AspNetCore.Datasync;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.Identity.Web;
using TodoAppService.NET6.Db;
  
var builder = WebApplication.CreateBuilder(args);
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
  
if (connectionString == null)
{
  throw new ApplicationException("DefaultConnection is not set");
}
  
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
  .AddMicrosoftIdentityWebApi(builder.Configuration);
builder.Services.AddAuthorization();
builder.Services.AddDbContext<AppDbContext>(options => options.UseSqlServer(connectionString));
builder.Services.AddDatasyncControllers();
  
var app = builder.Build();
  
// Initialize the database
using (var scope = app.Services.CreateScope())
{
  var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
  await context.InitializeDatabaseAsync().ConfigureAwait(false);
}
  
// Configure and run the web service.
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();
app.Run();

Redigera Controllers\TodoItemController.cs. Lägg till ett [Authorize] attribut i klassen. Klassen bör se ut så här:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Datasync;
using Microsoft.AspNetCore.Datasync.EFCore;
using Microsoft.AspNetCore.Mvc;
using TodoAppService.NET6.Db;

namespace TodoAppService.NET6.Controllers
{
  [Authorize]
  [Route("tables/todoitem")]
  public class TodoItemController : TableController<TodoItem>
  {
    public TodoItemController(AppDbContext context)
      : base(new EntityTableRepository<TodoItem>(context))
    {
    }
  }
}

Redigera appsettings.json. Lägg till följande block:

  "AzureAd": {
    "Instance": "https://login.microsoftonline.com",
    "ClientId": "<client-id>",
    "TenantId": "common"
  },

Ersätt <client-id> med web-API-program-ID:t som du registrerade tidigare. När det är klart bör det se ut så här:

{
  "AzureAd": {
    "Instance": "https://login.microsoftonline.com",
    "ClientId": "<client-id>",
    "TenantId": "common"
  },
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=TodoApp;Trusted_Connection=True"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

Publicera tjänsten till Azure igen:

Högerklicka på projektet TodoAppService.NET6 och välj sedan Publicera....
Välj knappen Publicera i det övre högra hörnet på fliken.

Öppna en webbläsare för att https://yoursite.azurewebsites.net/tables/todoitem?ZUMO-API-VERSION=3.0.0. Observera att tjänsten nu returnerar ett 401 svar, vilket indikerar att autentisering krävs.

Skärmbild av webbläsaren som visar ett fel.

Registrera din app med identitetstjänsten

Microsoft Data Sync Framework har inbyggt stöd för alla autentiseringsprovider som använder en Json-webbtoken (JWT) i en rubrik i HTTP-transaktionen. Det här programmet använder Microsoft Authentication Library (MSAL) för att begära en sådan token och auktorisera den inloggade användaren till serverdelstjänsten.

Konfigurera ett internt klientprogram

Du kan registrera interna klienter för att tillåta autentisering till webb-API:er som finns i din app med hjälp av ett klientbibliotek, till exempel Microsoft Identity Library (MSAL).

I Azure-portalenväljer du Microsoft Entra-ID>Appregistreringar>Ny registrering.
På sidan Registrera ett program:
- ange en Namn för din appregistrering. Du kanske vill använda namnet native-quickstart för att skilja den här från den som används av serverdelstjänsten.
- Välj Konton i valfri organisationskatalog (Alla Microsoft Entra-kataloger – Multitenant) och personliga Microsoft-konton (t.ex. Skype, Xbox).
- I omdirigerings-URI:
  - Välj offentlig klient (mobile & desktop)
  - Ange URL-quickstart://auth
Välj Registrera.
Välj API-behörigheter>Lägg till en behörighet>Mina API:er.
Välj den appregistrering som du skapade tidigare för serverdelstjänsten. Om du inte ser appregistreringen kontrollerar du att du har lagt till access_as_user omfång.
Under Välj behörigheterväljer du access_as_useroch sedan Lägg till behörigheter.
Välj autentisering>mobila program och skrivbordsprogram.
Markera kryssrutan bredvid https://login.microsoftonline.com/common/oauth2/nativeclient.
Markera kryssrutan bredvid msal{client-id}://auth (ersätt {client-id} med ditt program-ID).
Välj Lägg till URI-och lägg sedan till http://localhost i fältet för extra URI:er.
Välj Spara längst ned på sidan.
Välj Översikt. Anteckna program-ID(klient)-ID:t (kallas internt klientprogram-ID) eftersom du behöver det för att konfigurera mobilappen.

Vi har definierat tre omdirigerings-URL:er:

http://localhost används av WPF-program.
https://login.microsoftonline.com/common/oauth2/nativeclient används av UWP-program.
msal{client-id}://auth används av mobila program (Android och iOS).

Lägga till Microsoft Identity Client i din app

Öppna den TodoApp.sln lösningen i Visual Studio och ange TodoApp.Forms projektet som startprojekt.

Lägg till Microsoft Identity Library (MSAL) till plattformsprojektet:

Högerklicka på projektet och välj sedan Hantera NuGet-paket....
Välj fliken Bläddra.
Ange Microsoft.Identity.Client i sökrutan och tryck sedan på Retur.
Välj resultatet Microsoft.Identity.Client och klicka sedan på Installera.
Godkänn licensavtalet för att fortsätta installationen.

Lägg till det interna klient-ID:t och serverdelsomfånget i konfigurationen.

Öppna TodoApp.Data-projektet och redigera filen Constants.cs. Lägg till konstanter för ApplicationId och Scopes:

  public static class Constants
  {
      /// <summary>
      /// The base URI for the Datasync service.
      /// </summary>
      public static string ServiceUri = "https://demo-datasync-quickstart.azurewebsites.net";

      /// <summary>
      /// The application (client) ID for the native app within Microsoft Entra ID
      /// </summary>
      public static string ApplicationId = "<client-id>";

      /// <summary>
      /// The list of scopes to request
      /// </summary>
      public static string[] Scopes = new[]
      {
          "<scope>"
      };
  }

Ersätt <client-id> med det interna klientprogram-ID:t du fick när du registrerade klientprogrammet i Microsoft Entra-ID och <scope> med web-API-omfånget du kopierade när du använde Exponera ett API- när du registrerade tjänstprogrammet.

Öppna projektet TodoApp.Forms. Lägg till en ny fil med namnet IPlatform.cs med följande innehåll:

using Microsoft.Identity.Client;

namespace TodoApp.Forms
{
    public interface IPlatform
    {
        IPublicClientApplication GetIdentityClient(string applicationId);
    }
}

Det här gränssnittet används senare för att tillåta det delade projektet att be plattformsprojektet om en identitetsklient som är lämplig för plattformen.

Öppna App.xaml.cs. Lägg till följande using-instruktioner:

using Microsoft.Datasync.Client;
using Microsoft.Identity.Client;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;

I klassen App lägger du till två nya egenskaper:

public IPublicClientApplication IdentityClient { get; set; }
public IPlatform PlatformService { get; }

Justera konstruktorn så att den läser:

public App(IPlatform platformService)
{
    InitializeComponent();

    PlatformService = platformService;
    TodoService = new RemoteTodoService(GetAuthenticationToken);
    MainPage = new NavigationPage(new MainPage(this, TodoService));
}

Lägg till metoden GetAuthenticationToken i klassen:

public async Task<AuthenticationToken> GetAuthenticationToken()
{
    if (IdentityClient == null)
    {
        IdentityClient = PlatformService.GetIdentityClient(Constants.ApplicationId);
    }

    var accounts = await IdentityClient.GetAccountsAsync();
    AuthenticationResult result = null;
    bool tryInteractiveLogin = false;

    try
    {
        result = await IdentityClient
            .AcquireTokenSilent(Constants.Scopes, accounts.FirstOrDefault())
            .ExecuteAsync();
    }
    catch (MsalUiRequiredException)
    {
        tryInteractiveLogin = true;
    }
    catch (Exception ex)
    {
        Debug.WriteLine($"MSAL Silent Error: {ex.Message}");
    }

    if (tryInteractiveLogin)
    {
        try
        {
            result = await IdentityClient
                .AcquireTokenInteractive(Constants.Scopes)
                .ExecuteAsync()
                .ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"MSAL Interactive Error: {ex.Message}");
        }
    }

    return new AuthenticationToken
    {
        DisplayName = result?.Account?.Username ?? "",
        ExpiresOn = result?.ExpiresOn ?? DateTimeOffset.MinValue,
        Token = result?.AccessToken ?? "",
        UserId = result?.Account?.Username ?? ""
    };
}

Metoden GetAuthenticationToken() fungerar med Microsoft Identity Library (MSAL) för att få en åtkomsttoken som lämpar sig för att auktorisera den inloggade användaren till serverdelstjänsten. Den här funktionen skickas sedan till RemoteTodoService för att skapa klienten. Om autentiseringen lyckas skapas AuthenticationToken med data som krävs för att auktorisera varje begäran. Annars skapas en felaktig token som har upphört att gälla i stället.

Konfigurera Android-appen för autentisering

Öppna projektet TodoApp.Forms.Android. Skapa en ny klass MsalActivity med följande kod:

using Android.App;
using Android.Content;
using Microsoft.Identity.Client;

namespace TodoApp.Forms.Droid
{
    [Activity(Exported = true)]
    [IntentFilter(new[] { Intent.ActionView },
        Categories = new[] { Intent.CategoryBrowsable, Intent.CategoryDefault },
        DataHost = "auth",
        DataScheme = "msal{client-id}")]
    public class MsalActivity : BrowserTabActivity
    {
    }
}

Ersätt {client-id} med program-ID för den interna klienten (som är samma som Constants.ApplicationId).

Om ditt projekt är avsett för Android version 11 (API version 30) eller senare måste du uppdatera din AndroidManifest.xml för att uppfylla kraven på Android-paketsynlighet. Öppna TodoApp.Forms.Android/Properties/AndroidManifest.xml och lägg till följande queries/intent noder i noden manifest:

<manifest>
  ...
  <queries>
    <intent>
      <action android:name="android.support.customtabs.action.CustomTabsService" />
    </intent>
  </queries>
</manifest>

Öppna MainActivity.cs. Lägg till IPlatform i definitionen av klassen MainActivity:

public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity, IPlatform

Ändra LoadApplication()-anropet i metoden OnCreate():

protected override void OnCreate(Bundle savedInstanceState)
{
    base.OnCreate(savedInstanceState);

    Xamarin.Essentials.Platform.Init(this, savedInstanceState);
    global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
    LoadApplication(new App(this));
}

Lägg till följande kod längst ned i klassen:

protected override void OnActivityResult(int requestCode, [GeneratedEnum] Result resultCode, Intent data)
{
    base.OnActivityResult(requestCode, resultCode, data);
    // Return control to MSAL
    AuthenticationContinuationHelper.SetAuthenticationContinuationEventArgs(requestCode, resultCode, data);
}

public IPublicClientApplication GetIdentityClient(string applicationId)
{
    var identityClient = PublicClientApplicationBuilder.Create(applicationId)
        .WithAuthority(AzureCloudInstance.AzurePublic, "common")
        .WithRedirectUri($"msal{applicationId}://auth")
        .WithParentActivityOrWindow(() => this)
        .Build();
    return identityClient;
}

När det delade projektet kräver autentisering hämtar det en identitetsklient från GetIdentityClient()och växlar sedan till en intern aktivitet som öppnar systemwebbläsaren. När autentiseringen är klar omdirigeras systemwebbläsaren till den definierade omdirigerings-URL:en (msal{client-id}://auth). MsalActivity hämtar omdirigerings-URL:en, som sedan växlar tillbaka till huvudaktiviteten genom att anropa OnActivityResult(). Då anropas MSAL-autentiseringshjälpen, som slutför transaktionen.

Konfigurera iOS-appen för autentisering

Öppna filen AppDelegate.cs i TodoApp.Forms.iOS-projektet. Lägg till IPlatform i definitionen av klassen AppDelegate:

public partial class AppDelegate : global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate, IPlatform

Ändra metoden FinishedLaunching() så att den läser:

public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
    global::Xamarin.Forms.Forms.Init();
    LoadApplication(new App(this));
    return base.FinishedLaunching(app, options);
}

Lägg till följande kod i slutet av klassen:

public override bool OpenUrl(UIApplication app, NSUrl url, NSDictionary options)
{
    bool result = AuthenticationContinuationHelper.SetAuthenticationContinuationEventArgs(url);
    return result || base.OpenUrl(app, url, options);
}

public IPublicClientApplication GetIdentityClient(string applicationId)
{
    var identityClient = PublicClientApplicationBuilder.Create(applicationId)
        .WithIosKeychainSecurityGroup("com.microsoft.adalcache")
        .WithRedirectUri($"msal{applicationId}://auth")
        .Build();
    return identityClient;
}

Lägg till nyckelringsåtkomst till Entitlements.plist:

Öppna filen Entitlements.plist.
Välj nyckelring.
Välj Lägg till ny i nyckelringsgrupperna.
Ange com.microsoft.adalcache som värde:

Lägg till de anpassade berättigandena i projektet:

Högerklicka på projektet TodoApp.Forms.iOS och välj sedan Egenskaper.
Välj iOS-paketsignering.
Välj knappen ... bredvid fältet anpassade berättiganden.
Välj Entitlementsoch välj sedan Öppna.
Spara projektet genom att trycka på Ctrl+S-.

Testa Android-appen

Ange TodoApp.Forms.Android som startprojekt och tryck sedan på F5 för att skapa och köra appen. När appen startar uppmanas du att logga in på appen. Vid den första körningen uppmanas du att godkänna appen. När autentiseringen är klar körs appen som vanligt.

Testa iOS-appen

Not

Eftersom iOS-appen kräver nyckelringsåtkomst måste du konfigurera en etableringsprofil. En etableringsprofil kräver antingen en riktig enhet eller ett betalt Apple Developer-konto (om du använder simulatorn). Mer information finns i Enhetsetablering för iOS-.

Ange TodoApp.Forms.iOS som startprojekt och tryck sedan på F5 för att skapa och köra appen. När appen startar uppmanas du att logga in på appen. Vid den första körningen uppmanas du att godkänna appen. När autentiseringen är klar körs appen som vanligt.

Nästa steg

Konfigurera sedan programmet så att det fungerar offline genom att implementera ett offlinearkiv.

Dela via