Dodawanie uwierzytelniania do Windows aplikacji

Artykuł
06/25/2019

Omówienie

W tym temacie przedstawiono sposób dodawania uwierzytelniania opartego na chmurze do aplikacji mobilnej. W tym samouczku dodasz uwierzytelnianie do projektu szybki start platforma uniwersalna systemu Windows (UWP) dla platformy Mobile Apps przy użyciu dostawcy tożsamości obsługiwanego przez Azure App Service. Po pomyślnym uwierzytelnieniu i autoryzacji przez zaplecza aplikacji mobilnej zostanie wyświetlona wartość identyfikatora użytkownika.

Ten samouczek jest oparty na Mobile Apps Szybki start. Najpierw musisz ukończyć samouczek z Wprowadzenie pomocą Mobile Apps.

Zarejestruj aplikację do uwierzytelniania i skonfiguruj App Service

Najpierw należy zarejestrować aplikację w witrynie dostawcy tożsamości, a następnie ustawić poświadczenia wygenerowane przez dostawcę w Mobile Apps back end.

Skonfiguruj preferowanego dostawcę tożsamości, zgodnie z instrukcjami specyficznymi dla dostawcy:
Powtórz poprzednie kroki dla każdego dostawcy, którego chcesz obsługiwać w aplikacji.

Dodawanie aplikacji do adresów URL dozwolonego zewnętrznego przekierowania

Bezpieczne uwierzytelnianie wymaga zdefiniowania nowego schematu adresu URL dla aplikacji. Dzięki temu system uwierzytelniania może przekierować z powrotem do aplikacji po zakończeniu procesu uwierzytelniania. W tym samouczku używamy nazwy aplikacji schematu adresu URL w całym. Możesz jednak użyć dowolnego schematu adresów URL, który wybierzesz. Powinna być unikatowa dla Twojej aplikacji mobilnej. Aby włączyć przekierowanie po stronie serwera:

W Azure Portal wybierz swój App Service.
Kliknij opcję menu Uwierzytelnianie/ autoryzacja.
W adresie URL dozwolonego zewnętrznego przekierowania wprowadź .url_scheme_of_your_app://easyauth.callback Wartością url_scheme_of_your_app w tym ciągu jest schemat adresu URL aplikacji mobilnej. Powinna być zgodne ze specyfikacją standardowego adresu URL dla protokołu (należy używać tylko liter i cyfr i rozpoczynać się literą). Należy zanotować ciąg, który wybierzesz, ponieważ konieczne będzie dostosowanie kodu aplikacji mobilnej za pomocą schematu adresu URL w kilku miejscach.
Kliknij pozycję Zapisz.

Ograniczanie uprawnień do uwierzytelnionych użytkowników

Domyślnie interfejsy API w Mobile Apps mogą być wywoływane anonimowo. Następnie należy ograniczyć dostęp tylko do uwierzytelnionych klientów.

Node.js (za pośrednictwem Azure Portal):

W ustawieniach Mobile Apps kliknij pozycję Łatwe tabele i wybierz tabelę. Kliknij pozycję Zmień uprawnienia, wybierz opcję Dostęp uwierzytelniony tylko dla wszystkich uprawnień, a następnie kliknij przycisk Zapisz.
.NET back end (C#):

W projekcie serwera przejdź do plikówControllersTodoItemController.cs>. Dodaj atrybut [Authorize] do klasy TodoItemController w następujący sposób. Aby ograniczyć dostęp tylko do określonych metod, można również zastosować ten atrybut tylko do tych metod, a nie do klasy . Ponownie opublikować projekt serwera.
```
  [Authorize]
  public class TodoItemController : TableController<TodoItem>
```
Node.js zaplecza (za pośrednictwem Node.js kodu):

Aby wymagać uwierzytelniania w celu uzyskania dostępu do tabeli, dodaj następujący wiersz do Node.js skryptu serwera:
```
  table.access = 'authenticated';
```
Aby uzyskać więcej informacji, zobacz Uwierzytelnianie wymagane w celu uzyskania dostępu do tabel. Aby dowiedzieć się, jak pobrać projekt kodu szybkiego startu ze swojej witryny, zobacz How to: Download the Node.js backend quickstart code project using Git (Jak pobrać projekt kodu zaplecza przy użyciu usługi Git).

Teraz możesz sprawdzić, czy anonimowy dostęp do zaplecza został wyłączony. Po skonfigurowaniu projektu aplikacji platformy uniwersalnej systemu Windows jako projektu startowego wd wdrażaj i uruchamiaj aplikację. Sprawdź, czy nieobsługiwany wyjątek z kodem stanu 401 (Brak autoryzacji) jest wywoływany po uruchamianiu aplikacji. Dzieje się tak, ponieważ aplikacja próbuje uzyskać dostęp do kodu aplikacji mobilnej jako nieuwierzytowany użytkownik, ale tabela TodoItem wymaga teraz uwierzytelniania.

Następnie zaktualizujemy aplikację w celu uwierzytelnienia użytkowników przed zażądaniem zasobów od App Service.

Dodawanie uwierzytelniania do aplikacji

W pliku projektu aplikacji platformy uniwersalnej systemu Windows MainPage.xaml.cs dodaj następujący fragment kodu:

 // 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;
 }

Ten kod uwierzytelnia użytkownika przy użyciu identyfikatora logowania do serwisu Facebook. Jeśli używasz dostawcy tożsamości innego niż Facebook, zmień wartość właściwości MobileServiceAuthenticationProvider powyżej na wartość dostawcy.

Zastąp metodę OnNavigatedTo() w pliku MainPage.xaml.cs. Następnie dodasz przycisk Zaloguj do aplikacji, która wyzwala uwierzytelnianie.

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

Dodaj następujący fragment kodu do pliku MainPage.xaml.cs:

 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();
     }
 }

Otwórz plik projektu MainPage.xaml, znajdź element definiujący przycisk Zapisz i zastąp go następującym kodem:

 <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>

Dodaj następujący fragment kodu do pliku App.xaml.cs:

 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);
 }

Otwórz plik Package.appxmanifest, przejdź do opcji Deklaracje, na liście rozwijanej Dostępne deklaracje wybierz pozycję Protokół i kliknij przycisk Dodaj. Teraz skonfiguruj właściwoścideklaracji protokołu . W nazwa wyświetlana, dodaj nazwę, która ma być wyświetlana dla użytkowników aplikacji. W nazwa, dodaj {url_scheme_of_your_app}.
Naciśnij klawisz F5, aby uruchomić aplikację, kliknij przycisk Zaloguj i zaloguj się do aplikacji przy użyciu wybranego dostawcy tożsamości. Po pomyślnym zalogowaniu aplikacja zostanie uruchomiona bez błędów i będzie można wykonać zapytanie dotyczące zaplecza i wprowadzić aktualizacje danych.

Przechowywanie tokenu uwierzytelniania na kliencie

W poprzednim przykładzie po raz pierwszy zalogowano się, co wymaga od klienta skontaktowania się zarówno z dostawcą tożsamości, jak i App Service aplikacji. Ta metoda nie tylko jest nieefektywna, ale może też prowadzić do problemów związanych z użyciem, jeśli wielu klientów spróbuje uruchomić aplikację w tym samym czasie. Lepszym rozwiązaniem jest buforowanie tokenu autoryzacji zwróconego przez App Service i próba użycia tego tokenu przed użyciem logowania opartego na dostawcy.

Uwaga

Możesz buforować token wystawiony przez usługę App Services niezależnie od tego, czy używasz uwierzytelniania zarządzanego przez klienta, czy zarządzanego przez usługę. W tym samouczku jest używane uwierzytelnianie zarządzane przez usługę.

W pliku projektu MainPage.xaml.cs dodaj następujące instrukcje using :
```
 using System.Linq;        
 using Windows.Security.Credentials;
```

Zastąp metodę AuthenticateAsync następującym kodem:

 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;
 }

W tej wersji funkcji AuthenticateAsync aplikacja próbuje użyć poświadczeń przechowywanych w usłudze PasswordVault w celu uzyskania dostępu do usługi. Regularne logowanie jest również wykonywane, gdy nie ma przechowywanych poświadczeń.

Uwaga

Token z pamięci podręcznej może wygasł, a wygaśnięcie tokenu może również nastąpić po uwierzytelnieniu, gdy aplikacja jest w użyciu. Aby dowiedzieć się, jak ustalić, czy token wygasł, zobacz Sprawdzanie wygasłych tokenów uwierzytelniania. Rozwiązanie do obsługi błędów autoryzacji związanych z wygasających tokenami można znaleźć w te Buforowanie post i handling expired tokens in Azure Mobile Services managed SDK (Obsługa wygasłych tokenów w zestawie SDK zarządzanym przez usługę Azure Mobile Services).

Uruchom ponownie aplikację dwa razy.

Zwróć uwagę, że przy pierwszym uruchomieniu ponownie wymagane jest zalogowanie się przy użyciu dostawcy. Jednak przy drugim ponownym uruchomieniu są używane buforowane poświadczenia i logowanie jest pomijane.

Następne kroki

Po ukończeniu tego samouczka uwierzytelniania podstawowego rozważ kontynuowanie pracy z jednym z następujących samouczków:

Dodawanie powiadomień wypychanych do aplikacji
Dowiedz się, jak dodać obsługę powiadomień wypychanych do aplikacji i skonfigurować zaplecze Aplikacji mobilnej na potrzeby wysyłania powiadomień wypychanych przy użyciu usługi Azure Notification Hubs.
Włączanie synchronizacji w trybie offline dla aplikacji
Dowiedz się, jak dodać obsługę aplikacji w trybie offline przy użyciu zaplecza Aplikacji mobilnej. Synchronizacja w trybie offline umożliwia użytkownikom mobilnym interakcję z aplikacją mobilną — wyświetlanie, dodawanie lub modyfikowanie danych — nawet wtedy, gdy nie ma połączenia sieciowego.

Udostępnij za pośrednictwem