Přidání ověřování do aplikace pro Windows

2019-06-25

Přehled

V tomto tématu se dozvíte, jak do mobilní aplikace přidat cloudové ověřování. V tomto kurzu přidáte ověřování do projektu Rychlý start pro Univerzální platformu Windows (UPW) pro Mobile Apps pomocí zprostředkovatele identity, který podporuje Azure App Service. Po úspěšném ověření a autorizaci back-endem mobilní aplikace se zobrazí hodnota ID uživatele.

Tento kurz je založený na průvodci pro rychlé spuštění aplikací Mobile Apps. Nejprve musíte dokončit kurz Začínáme s Mobile Apps.

Registrace aplikace pro ověřování a konfigurace služby App Service

Nejprve je potřeba zaregistrovat aplikaci na webu zprostředkovatele identity a pak v back-endu Mobile Apps nastavit přihlašovací údaje vygenerované zprostředkovatelem.

Nakonfigurujte svého upřednostňovaného poskytovatele identity podle pokynů specifických pro poskytovatele:
Opakujte předchozí kroky pro každého poskytovatele, kterého chcete ve své aplikaci podporovat.

Přidání aplikace do povolených adres URL pro externí přesměrování

Zabezpečené ověřování vyžaduje, abyste definovali nové schéma adres URL pro vaši aplikaci. Systém ověření tak může po dokončení ověřovacího procesu přesměrovat zpět k vaší aplikaci. V tomto kurzu používáme schéma adresy URL appname v celém textu. Můžete ale použít libovolné schéma adres URL, které zvolíte. Měla by být jedinečná pro vaši mobilní aplikaci. Povolení přesměrování na straně serveru:

Na webu Azure Portal vyberte svou službu App Service.
Klikněte na možnost Ověřování / Autorizace.
Do povolených adres URL externího přesměrování zadejte url_scheme_of_your_app://easyauth.callback. Url_scheme_of_your_app v tomto řetězci je schéma adres URL pro vaši mobilní aplikaci. Měl by dodržovat normální specifikaci adresy URL pro protokol (používejte jenom písmena a číslice a začněte písmenem). Měli byste si poznamenat řetězec, který zvolíte, protože budete muset upravit kód mobilní aplikace pomocí schématu adresy URL na několika místech.
Klikněte na Uložit.

Omezení oprávnění pro ověřené uživatele

Ve výchozím nastavení je možné rozhraní API v back-endu Mobile Apps vyvolat anonymně. Dále je potřeba omezit přístup jenom na ověřené klienty.

Backend Node.js (prostřednictvím portálu Azure):

V nastavení Mobile Apps klikněte na Snadné tabulky a vyberte tabulku. Klepněte na tlačítko Změnit oprávnění, vyberte Ověřený přístup pouze pro všechna oprávnění a potom klepněte na tlačítko Uložit.
.NET backend (C#):

V projektu serveru přejděte na Kontrolery>TodoItemController.cs. Přidejte atribut [Authorize] do třídy TodoItemController následujícím způsobem. Chcete-li omezit přístup pouze na konkrétní metody, můžete tento atribut použít pouze u těchto metod místo třídy. Znovu publikujte projekt serveru.
```
  [Authorize]
  public class TodoItemController : TableController<TodoItem>
```
Node.js zázemí (prostřednictvím Node.js kódu):

Pokud chcete vyžadovat ověřování pro přístup k tabulce, přidejte do skriptu serveru Node.js následující řádek:
```
  table.access = 'authenticated';
```
Další podrobnosti najdete v tématu Postupy: Vyžadování ověřování pro přístup k tabulkám. Informace o tom, jak stáhnout projekt kódu pro rychlý start z webu, můžete najít v tématu Postupy: Stažení projektu kódu rychlého startu Node.js backendu pomocí Gitu.

Teď můžete ověřit, že je zakázaný anonymní přístup k vašemu back-endu. S projektem aplikace UPW nastaveným jako spouštěný projekt nasaďte a spusťte aplikaci; Ověřte, že se po spuštění aplikace vyvolá neošetřená výjimka se stavovým kódem 401 (Neautorizováno). K tomu dochází, protože se aplikace pokusí o přístup k kódu mobilní aplikace jako neověřený uživatel, ale tabulka TodoItem teď vyžaduje ověření.

V dalším kroku aplikaci aktualizujete tak, aby ověřovali uživatele před vyžádáním prostředků z vaší služby App Service.

Přidání ověřování do aplikace

V souboru projektu aplikace UPW MainPage.xaml.cs a přidejte následující fragment kódu:

 // Define a member variable for storing the signed-in user. 
 private MobileServiceUser user;

 // Define a method that performs the authentication process
 // using a Facebook sign-in. 
 private async System.Threading.Tasks.Task<bool> AuthenticateAsync()
 {
     string message;
     bool success = false;
     try
     {
         // Change 'MobileService' to the name of your MobileServiceClient instance.
         // Sign-in using Facebook authentication.
         user = await App.MobileService
             .LoginAsync(MobileServiceAuthenticationProvider.Facebook, "{url_scheme_of_your_app}");
         message =
             string.Format("You are now signed in - {0}", user.UserId);

         success = true;
     }
     catch (InvalidOperationException)
     {
         message = "You must log in. Login Required";
     }

     var dialog = new MessageDialog(message);
     dialog.Commands.Add(new UICommand("OK"));
     await dialog.ShowAsync();
     return success;
 }

Tento kód ověřuje uživatele pomocí přihlášení k Facebooku. Pokud používáte jiného zprostředkovatele identity než Facebook, změňte hodnotu MobileServiceAuthenticationProvider výše na hodnotu vašeho zprostředkovatele.

Nahraďte metodu OnNavigatedTo() v MainPage.xaml.cs. Dále do aplikace, která aktivuje ověřování, přidáte tlačítko Přihlásit se.

 protected override async void OnNavigatedTo(NavigationEventArgs e)
 {
     if (e.Parameter is Uri)
     {
         App.MobileService.ResumeWithURL(e.Parameter as Uri);
     }
 }

Do MainPage.xaml.cs přidejte následující fragment kódu:

 private async void ButtonLogin_Click(object sender, RoutedEventArgs e)
 {
     // Login the user and then load data from the mobile app.
     if (await AuthenticateAsync())
     {
         // Switch the buttons and load items from the mobile app.
         ButtonLogin.Visibility = Visibility.Collapsed;
         ButtonSave.Visibility = Visibility.Visible;
         //await InitLocalStoreAsync(); //offline sync support.
         await RefreshTodoItems();
     }
 }

Otevřete soubor projektu MainPage.xaml, vyhledejte element, který definuje tlačítko Uložit , a nahraďte ho následujícím kódem:

 <Button Name="ButtonSave" Visibility="Collapsed" Margin="0,8,8,0" 
         Click="ButtonSave_Click">
     <StackPanel Orientation="Horizontal">
         <SymbolIcon Symbol="Add"/>
         <TextBlock Margin="5">Save</TextBlock>
     </StackPanel>
 </Button>
 <Button Name="ButtonLogin" Visibility="Visible" Margin="0,8,8,0" 
         Click="ButtonLogin_Click" TabIndex="0">
     <StackPanel Orientation="Horizontal">
         <SymbolIcon Symbol="Permissions"/>
         <TextBlock Margin="5">Sign in</TextBlock> 
     </StackPanel>
 </Button>

Do App.xaml.cs přidejte následující fragment kódu:

 protected override void OnActivated(IActivatedEventArgs args)
 {
     if (args.Kind == ActivationKind.Protocol)
     {
         ProtocolActivatedEventArgs protocolArgs = args as ProtocolActivatedEventArgs;
         Frame content = Window.Current.Content as Frame;
         if (content.Content.GetType() == typeof(MainPage))
         {
             content.Navigate(typeof(MainPage), protocolArgs.Uri);
         }
     }
     Window.Current.Activate();
     base.OnActivated(args);
 }

Otevřete soubor Package.appxmanifest, přejděte do části Deklarace v rozevíracím seznamu Dostupné deklarace , vyberte Protokol a klikněte na tlačítko Přidat . Nyní nakonfigurujte vlastnosti deklarace protokolu . Do pole Zobrazovaný název přidejte název, který chcete zobrazit uživatelům aplikace. Do pole Název přidejte {url_scheme_of_your_app}.
Stisknutím klávesy F5 spusťte aplikaci, klikněte na tlačítko Přihlásit se a přihlaste se k aplikaci pomocí zvoleného zprostředkovatele identity. Po úspěšném přihlášení se aplikace spustí bez chyb a můžete se do back-endu dotazovat a aktualizovat data.

Uložení ověřovacího tokenu v klientovi

Předchozí příklad ukázal standardní přihlášení, které vyžaduje, aby klient kontaktoval zprostředkovatele identity i službu App Service při každém spuštění aplikace. Tato metoda není jenom neefektivní, pokud se mnoho zákazníků pokusí spustit aplikaci najednou, můžete narazit na problémy související s využitím. Lepším přístupem je ukládat autorizační token vrácený službou App Service do mezipaměti a před použitím přihlášení založeného na poskytovateli se pokuste tento token použít jako první.

Poznámka:

Token vydaný službou App Services můžete ukládat do mezipaměti bez ohledu na to, jestli používáte ověřování spravované klientem nebo spravované službou. V tomto kurzu se používá ověřování spravované službou.

Do souboru projektu MainPage.xaml.cs přidejte následující příkazy using :
```
 using System.Linq;        
 using Windows.Security.Credentials;
```

Nahraďte metodu AuthenticateAsync následujícím kódem:

 private async System.Threading.Tasks.Task<bool> AuthenticateAsync()
 {
     string message;
     bool success = false;

     // This sample uses the Facebook provider.
     var provider = MobileServiceAuthenticationProvider.Facebook;

     // Use the PasswordVault to securely store and access credentials.
     PasswordVault vault = new PasswordVault();
     PasswordCredential credential = null;

     try
     {
         // Try to get an existing credential from the vault.
         credential = vault.FindAllByResource(provider.ToString()).FirstOrDefault();
     }
     catch (Exception)
     {
         // When there is no matching resource an error occurs, which we ignore.
     }

     if (credential != null)
     {
         // Create a user from the stored credentials.
         user = new MobileServiceUser(credential.UserName);
         credential.RetrievePassword();
         user.MobileServiceAuthenticationToken = credential.Password;

         // Set the user from the stored credentials.
         App.MobileService.CurrentUser = user;

         // Consider adding a check to determine if the token is 
         // expired, as shown in this post: https://aka.ms/jww5vp.

         success = true;
         message = string.Format("Cached credentials for user - {0}", user.UserId);
     }
     else
     {
         try
         {
             // Sign in with the identity provider.
             user = await App.MobileService
                 .LoginAsync(provider, "{url_scheme_of_your_app}");

             // Create and store the user credentials.
             credential = new PasswordCredential(provider.ToString(),
                 user.UserId, user.MobileServiceAuthenticationToken);
             vault.Add(credential);

             success = true;
             message = string.Format("You are now signed in - {0}", user.UserId);
         }
         catch (MobileServiceInvalidOperationException)
         {
             message = "You must sign in. Sign-In Required";
         }
     }

     var dialog = new MessageDialog(message);
     dialog.Commands.Add(new UICommand("OK"));
     await dialog.ShowAsync();

     return success;
 }

V této verzi AuthenticateAsync se aplikace pokusí pro přístup ke službě použít přihlašovací údaje uložené ve službě PasswordVault . Pravidelné přihlašování se také provádí, pokud nejsou uložené přihlašovací údaje.

Poznámka:

Platnost tokenu uloženého v mezipaměti může vypršena a vypršení platnosti tokenu může dojít také po ověření, když se aplikace používá. Informace o tom, jak zjistit, jestli vypršela platnost tokenu, najdete v tématu Kontrola vypršení platnosti ověřovacích tokenů. Řešení pro zpracování chyb autorizace souvisejících s vypršením platnosti tokenů najdete v části Ukládání do mezipaměti a zpracování tokenů s vypršenou platností ve spravované sadě SDK služby Azure Mobile Services.

Restartujte aplikaci dvakrát.

Všimněte si, že při prvním spuštění se znovu vyžaduje přihlášení u poskytovatele. Při druhém restartování se však použijí přihlašovací údaje uložené v mezipaměti a přihlášení se vynechá.

Další kroky

Teď, když jste dokončili tento základní kurz ověřování, zvažte pokračování v některém z následujících kurzů:

Přidejte push notifikace do své aplikace
Zjistěte, jak do aplikace přidat podporu nabízených oznámení a nakonfigurovat back-end mobilní aplikace tak, aby používal Službu Azure Notification Hubs k odesílání nabízených oznámení.
Povolení offline synchronizace pro vaši aplikaci
Zjistěte, jak přidat offline podporu aplikace pomocí back-endu mobilní aplikace. Offline synchronizace umožňuje koncovým uživatelům pracovat s mobilní aplikací – prohlížením, přidáváním nebo úpravou dat – i v případě, že připojení k síti není k dispozici.

Sdílet prostřednictvím