Udostępnij za pośrednictwem

Dodawanie uwierzytelniania do aplikacji systemu Windows

  • Artykuł

Przegląd

W tym temacie przedstawiono sposób dodawania uwierzytelniania opartego na chmurze do aplikacji mobilnej. W tym samouczku dodasz uwierzytelnianie do projektu szybkiego startu platformy uniwersalnej systemu Windows dla usługi Mobile Apps przy użyciu dostawcy tożsamości obsługiwanego przez usługę Azure App Service. Po pomyślnym uwierzytelnieniu i autoryzacji przez serwer Twojej aplikacji mobilnej zostanie wyświetlona wartość identyfikatora użytkownika.

Ten samouczek jest oparty na przewodniku Szybki start dotyczącym usługi Mobile Apps. Najpierw należy ukończyć samouczek Wprowadzenie do usługi Mobile Apps.

Rejestrowanie aplikacji pod kątem uwierzytelniania i konfigurowanie usługi App Service

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

  1. Skonfiguruj preferowanego dostawcę tożsamości, postępując zgodnie z instrukcjami specyficznymi dla dostawcy:

  2. Powtórz poprzednie kroki dla każdego dostawcy, który chcesz obsługiwać w aplikacji.

Dodaj swoją aplikację do dozwolonych zewnętrznych adresów URL przekierowania

Bezpieczne uwierzytelnianie wymaga zdefiniowania nowego schematu adresów URL dla aplikacji. Dzięki temu system uwierzytelniania może przekierować z powrotem do aplikacji po zakończeniu procesu uwierzytelniania. W tym samouczku użyjemy schematu adresów URL nazwa_aplikacji. Można jednak użyć dowolnego wybranego schematu adresów URL. Powinna być unikatowa dla aplikacji mobilnej. Aby włączyć przekierowanie po stronie serwera:

  1. W witrynie Azure Portalwybierz usługę App Service.

  2. Kliknij opcję menu Uwierzytelnianie/autoryzacja.

  3. W dozwolone zewnętrzne adresy URL przekierowań, wprowadź url_scheme_of_your_app://easyauth.callback. url_scheme_of_your_app w tym ciągu znaków to schemat adresów URL dla aplikacji mobilnej. Powinna ona być zgodna ze standardową specyfikacją adresu URL protokołu (należy używać tylko liter i cyfr, a następnie zaczynać się literą). Należy zanotować wybrany ciąg, ponieważ musisz dostosować kod aplikacji mobilnej za pomocą schematu adresów URL w kilku miejscach.

  4. Kliknij przycisk Zapisz.

Ograniczanie uprawnień do uwierzytelnionych użytkowników

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

  • Node.js część serwerowa (za pośrednictwem Azure Portal) :

    W ustawieniach usługi Mobile Apps kliknij pozycję Łatwe tabele i wybierz tabelę. Kliknij pozycję Zmień uprawnienia, wybierz pozycję Dostęp uwierzytelniony tylko dla wszystkich uprawnień, a następnie kliknij Zapisz.

  • zaplecze platformy .NET (C#):

    W projekcie serwera przejdź do Controllers>TodoItemController.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 zamiast klasy. Ponownie opublikuj projekt serwera.

      [Authorize]
  public class TodoItemController : TableController<TodoItem>

  • Node.js zaplecze (za pomocą kodu Node.js) :

    Aby wymagać uwierzytelniania w celu uzyskania dostępu do tabeli, dodaj następujący wiersz do skryptu serwera Node.js:

      table.access = 'authenticated';

    Aby uzyskać więcej informacji, zobacz Instrukcje: wymaganie uwierzytelniania w celu uzyskania dostępu do tabel. Aby dowiedzieć się, jak pobrać projekt kodu Szybkiego startu z witryny, zobacz How to: Download the Node.js backend backend code project using Git.

Teraz możesz sprawdzić, czy dostęp anonimowy do zaplecza został wyłączony. Po ustawieniu projektu aplikacji platformy UWP jako projektu startowego, wdróż i uruchom aplikację. Sprawdź, czy po uruchomieniu zostanie zgłoszony nieobsługiwany wyjątek z kodem stanu 401 (Nieautoryzowany). Dzieje się tak, ponieważ aplikacja próbuje uzyskać dostęp do kodu aplikacji mobilnej jako użytkownik nieuwierzytelniony, ale tabela TodoItem wymaga teraz uwierzytelniania.

Następnie zaktualizujesz aplikację w celu uwierzytelnienia użytkowników przed zażądaniem zasobów z usługi App Service.

Dodawanie uwierzytelniania do aplikacji

  1. W pliku projektu aplikacji UWP 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 w serwisie Facebook. Jeśli używasz dostawcy tożsamości innego niż Facebook, zmień wartość MobileServiceAuthenticationProvider powyżej na wartość dostawcy.

  2. Zastąp metodę OnNavigatedTo() w MainPage.xaml.cs. Następnie dodasz przycisk Zaloguj się 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);
     }
 }

  3. Dodaj następujący fragment kodu do 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();
     }
 }

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

  5. Dodaj następujący fragment kodu do 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);
 }

  6. Otwórz plik Package.appxmanifest, przejdź do Deklaracje, na liście rozwijanej Dostępne deklaracje wybierz pozycję Protokół i kliknij przycisk Dodaj. Teraz skonfiguruj właściwości deklaracji protokołu. W polu Nazwa wyświetlanadodaj nazwę, którą chcesz pokazać użytkownikom swojej aplikacji. W Nazwa, dodaj schemat adresu URL swojej aplikacji: {url_scheme_of_your_app}.

  7. Naciśnij F5, aby uruchomić aplikację, kliknij przycisk Zaloguj się i zaloguj się do aplikacji przy użyciu wybranego dostawcy tożsamości. Po pomyślnym zalogowaniu aplikacja działa bez błędów i możesz wykonywać zapytania dotyczące zaplecza i aktualizować dane.

Przechowywanie tokenu uwierzytelniania na kliencie

W poprzednim przykładzie pokazano standardowe logowanie, które wymaga, aby klient kontaktował się zarówno z dostawcą tożsamości, jak i usługą App Service za każdym razem, gdy aplikacja zostanie uruchomiona. Nie tylko ta metoda jest nieefektywna, ale można napotkać problemy związane z użyciem, jeśli wielu klientów próbuje uruchomić aplikację w tym samym czasie. Lepszym rozwiązaniem jest buforowanie tokenu autoryzacji zwróconego przez usługę App Service i próba użycia go najpierw przed użyciem logowania opartego na dostawcy.

Uwaga

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

  1. W pliku projektu MainPage.xaml.cs dodaj następujące przy użyciu instrukcji:

     using System.Linq;        
 using Windows.Security.Credentials;

  2. 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 AuthenticateAsyncaplikacja próbuje użyć poświadczeń przechowywanych w PasswordVault w celu uzyskania dostępu do usługi. Regularne logowanie jest również wykonywane, gdy nie ma przechowywanych poświadczeń.

    Uwaga

    Token buforowany może wygasł, a wygaśnięcie tokenu może wystąpić również po uwierzytelnieniu, gdy aplikacja jest używana. Aby dowiedzieć się, jak określić, czy token wygasł, zobacz Sprawdzanie wygasłych tokenów uwierzytelniania. Aby znaleźć rozwiązanie dotyczące zarządzania błędami autoryzacji związanymi z wygasającymi tokenami, zapoznaj się z wpisem dotyczącym buforowania i zarządzania wygasłymi tokenami w zarządzanym SDK usługi Azure Mobile Services.

  3. Uruchom ponownie aplikację dwa razy.

    Zwróć uwagę, że w pierwszym uruchomieniu logowanie się przy użyciu dostawcy jest ponownie wymagane. Jednak podczas drugiego ponownego uruchamiania używane są buforowane poświadczenia, a logowanie jest pomijane.

Następne kroki

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

  • Dodaj powiadomienia push do swojej aplikacji
    Dowiedz się, jak dodać obsługę powiadomień wypychanych do aplikacji i skonfigurować zaplecze aplikacji mobilnej w celu 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ę offline aplikacji przy użyciu zaplecza aplikacji mobilnej. Synchronizacja w trybie offline umożliwia użytkownikom końcowym interakcję z aplikacją mobilną — wyświetlanie, dodawanie lub modyfikowanie danych — nawet wtedy, gdy nie ma połączenia sieciowego.