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

Článek
06/25/2019

Přehled

Toto téma ukazuje, jak do mobilní aplikace přidat cloudové ověřování. V tomto kurzu přidáte ověřování do projektu rychlého Univerzální platforma Windows (UPW) pro Mobile Apps pomocí zprostředkovatele identity podporovaného Azure App Service. Po úspěšném ověření a ověření back-endem mobilní aplikace se zobrazí hodnota ID uživatele.

Tento kurz je založený na Mobile Apps startu. Nejprve musíte kurz dokončit Začínáme pomocí Mobile Apps.

Registrace aplikace k ověřování a konfigurace App Service

Nejprve musíte svou aplikaci zaregistrovat na webu zprostředkovatele identity a pak nastavíte přihlašovací údaje generované zprostředkovatelem v Mobile Apps back-endu.

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

Přidání aplikace do adres URL povoleného externího přesměrování

Zabezpečené ověřování vyžaduje, aby bylo pro vaši aplikaci definováno nové schéma adresy URL. Díky tomu může ověřovací systém po dokončení procesu ověřování přesměrovat zpět do vaší aplikace. V tomto kurzu používáme v celém kurzu název aplikace schématu adresy URL. Můžete ale použít libovolné schéma URL, které si zvolíte. Měl by být jedinečný pro vaši mobilní aplikaci. Povolení přesměrování na straně serveru:

V Azure Portal vyberte svou App Service.
Klikněte na možnost nabídky Ověřování / autorizace.
Do pole Povolené externí adresy URL pro přesměrování zadejte url_scheme_of_your_app://easyauth.callback. Řetězec url_scheme_of_your_app tomto řetězci je schéma adresy URL pro vaši mobilní aplikaci. Měl by se řídit normální specifikací adresy URL pro protokol (používejte pouze písmena a číslice a začněte písmenem). Řetězec, který zvolíte, byste si měli poznamenat, protože na několika místech budete muset upravit kód mobilní aplikace pomocí schématu adresy URL.
Klikněte na Uložit.

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

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

Node.js back-end (prostřednictvím Azure Portal):

V nastavení Mobile Apps klikněte na Snadné tabulky a vyberte tabulku. Klikněte na Změnit oprávnění, u všech oprávnění vyberte Jenom ověřený přístup a pak klikněte na Uložit.
Back-end .NET (C#):

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

Pokud chcete vyžadovat ověřování pro přístup k tabulce, přidejte do skriptu Node.js serveru 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, najdete v tématu Postupy: Stažení projektu kódu Node.js back-endu pomocí Gitu.

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

Dále aplikaci aktualizujete tak, aby ověřovat uživatele před vyžádáním prostředků od App Service.

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

Do 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ěří 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 pro vašeho zprostředkovatele.

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

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

Do souboru 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 Save , 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 souboru 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 na Deklarace. V rozevíracím seznamu Available Declarations ( Dostupné deklarace) vyberte Protocol (Protokol) a klikněte na tlačítko Add ( Přidat). Teď nakonfigurujte vlastnostideklarace protokolu . Do pole Zobrazovaný název přidejte název, který chcete zobrazit uživatelům vaší 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 dotazovat back-endu 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 App Service při každém spuštění aplikace. Nejenže je tato metoda neefektivní, ale v případě, že by se mnoho zákazníků pokusilo spustit aplikaci ve stejnou dobu, můžete na tyto problémy naběhat. Lepším přístupem je ukládání autorizačního tokenu vráceného vaší App Service do mezipaměti a před použitím přihlášení založeného na poskytovateli zkuste tento token nejprve použít.

Poznámka

Token vystavený službou můžete ukládat do mezipaměti App Services bez ohledu na to, jestli používáte ověřování spravované klientem nebo spravované službou. Tento kurz 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 provádí také v případě, že nejsou uložené přihlašovací údaje.

Poznámka

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

Restartujte aplikaci dvakrát.

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

Další kroky

Teď, když jste dokončili tento kurz základního ověřování, zvažte pokračování k jednomu z následujících kurzů:

Přidání nabízených oznámení do aplikace
Naučte se přidávat do aplikace podporu nabízených oznámení a konfigurovat back-end mobilní aplikace tak, aby k zasílání nabízených oznámení používal Azure Notification Hubs.
Povolení offline synchronizace u aplikace
Naučte se, jak pomocí back-endu mobilní aplikace přidat do aplikace podporu offline režimu. 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 když není k dispozici žádné síťové připojení.

Sdílet prostřednictvím