Logowanie użytkowników aplikacji systemu iOS (Swift) na potrzeby uwierzytelniania - Microsoft Entra External ID

Artykuł
05/22/2024

Jest to trzeci samouczek z serii samouczków, który przeprowadzi Cię przez proces logowania użytkowników przy użyciu Tożsamość zewnętrzna Microsoft Entra.

W tym samouczku wykonasz następujące elementy:

Zaloguj się użytkownik.
Wyloguj użytkownika.

Wymagania wstępne

Samouczek: przygotowywanie aplikacji systemu iOS (Swift) do uwierzytelniania

Istnieją dwie główne opcje logowania użytkowników przy użyciu biblioteki Microsoft Authentication Library (MSAL) dla systemu iOS: uzyskiwanie tokenów interaktywnie lub dyskretnie.

Aby interaktywnie zalogować się użytkownika, użyj następującego kodu:
```
acquireTokenInteractively() {
    guard let applicationContext = self.applicationContext else { return }
    guard let webViewParameters = self.webViewParamaters else { return }

    updateLogging(text: "Acquiring token interactively...")

    let parameters = MSALInteractiveTokenParameters(scopes: Configuration.kScopes, webviewParameters: webViewParameters)
    parameters.promptType = .selectAccount

    applicationContext.acquireToken(with: parameters) { (result, error) in

        if let error = error {

            self.updateLogging(text: "Could not acquire token: \(error)")
            return
        }

        guard let result = result else {

            self.updateLogging(text: "Could not acquire token: No result returned")
            return
        }

        self.accessToken = result.accessToken
        self.updateLogging(text: "Access token is \(self.accessToken)")
        self.updateCurrentAccount(account: result.account)
    }
}
```
Kod najpierw sprawdza, czy kontekst aplikacji i parametry widoku internetowego są dostępne. Następnie aktualizuje rejestrowanie, aby wskazać, że jest on pozyskiwany interaktywnie. Następnie konfiguruje parametry pozyskiwania tokenu interakcyjnego, określając zakresy i parametry widoku internetowego. Ustawia również typ monitu, aby wybrać konto.

Następnie wywołuje metodę acquireToken w kontekście aplikacji ze zdefiniowanymi parametrami. W procedurze obsługi uzupełniania sprawdza wszelkie błędy. Jeśli wystąpi błąd, zaktualizuje on rejestrowanie za pomocą komunikatu o błędzie. W przypadku powodzenia pobiera token dostępu z wyniku, aktualizuje rejestrowanie przy użyciu tokenu i aktualizuje bieżące konto.

Gdy aplikacja uzyska token dostępu, możesz pobrać oświadczenia skojarzone z bieżącym kontem. W tym celu użyj następującego fragmentu kodu:
```
let claims = result.account.accountClaims
let preferredUsername = claims?["preferred_username"] as? String
```
Kod odczytuje oświadczenia z konta, korzystając accountClaims z właściwości result.account obiektu. Następnie pobiera wartość oświadczenia "preferred_username" ze słownika oświadczeń i przypisuje go do zmiennej preferredUsername .

Aby zalogować użytkownika w trybie dyskretnym, użyj następującego kodu:

func acquireTokenSilently() {
    self.loadCurrentAccount { (account) in

        guard let currentAccount = account else {

            self.updateLogging(text: "No token found, try to acquire a token interactively first")
            return
        }

        self.acquireTokenSilently(currentAccount)
    }
}

Kod inicjuje proces uzyskiwania tokenów w trybie dyskretnym. Najpierw próbuje załadować bieżące konto. Jeśli zostanie znalezione bieżące konto, przejdzie do uzyskania tokenu w trybie dyskretnym przy użyciu tego konta. Jeśli nie znaleziono bieżącego konta, zaktualizuje on rejestrowanie, aby wskazać, że nie znaleziono tokenu i sugeruje próbę uzyskania tokenu interaktywnie.

W powyższym kodzie wywołujemy dwie funkcje loadCurrentAccount i acquireTokenSilently. Funkcja loadCurrentAccount powinna mieć następujący kod:

func loadCurrentAccount(completion: AccountCompletion? = nil) {

    guard let applicationContext = self.applicationContext else { return }

    let msalParameters = MSALParameters()
    msalParameters.completionBlockQueue = DispatchQueue.main

    // Note that this sample showcases an app that signs in a single account at a time
    applicationContext.getCurrentAccount(with: msalParameters, completionBlock: { (currentAccount, previousAccount, error) in

        if let error = error {
            self.updateLogging(text: "Couldn't query current account with error: \(error)")
            return
        }

        if let currentAccount = currentAccount {

            self.updateCurrentAccount(account: currentAccount)
            self.acquireTokenSilently(currentAccount)

            if let completion = completion {
                completion(self.currentAccount)
            }

            return
        }

        // If testing with Microsoft's shared device mode, see the account that has been signed out from another app. More details here:
        // https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-ios-shared-devices
        if let previousAccount = previousAccount {

            self.updateLogging(text: "The account with username \(String(describing: previousAccount.username)) has been signed out.")

        } else {

            self.updateLogging(text: "")
        }

        self.accessToken = ""
        self.updateCurrentAccount(account: nil)

        if let completion = completion {
            completion(nil)
        }
    })
}

Kod używa biblioteki MSAL dla systemu iOS do załadowania bieżącego konta. Sprawdza błędy i odpowiednio aktualizuje rejestrowanie. Jeśli zostanie znalezione bieżące konto, aktualizuje je i próbuje uzyskać tokeny w trybie dyskretnym. Jeśli istnieje poprzednie konto, rejestruje wylogowanie. Jeśli nie znaleziono żadnych kont, wyczyszczenie tokenu dostępu. Na koniec wykonuje blok ukończenia, jeśli zostanie podany.

Funkcja acquireTokenSilently powinna zawierać następujący kod:

func acquireTokenSilently(_ account : MSALAccount) {
    guard let applicationContext = self.applicationContext else { return }

    /**

     Acquire a token for an existing account silently

     - forScopes:           Permissions you want included in the access token received
     in the result in the completionBlock. Not all scopes are
     guaranteed to be included in the access token returned.
     - account:             An account object that we retrieved from the application object before that the
     authentication flow will be locked down to.
     - completionBlock:     The completion block that will be called when the authentication
     flow completes, or encounters an error.
     */

    updateLogging(text: "Acquiring token silently...")

    let parameters = MSALSilentTokenParameters(scopes: Configuration.kScopes, account: account)

    applicationContext.acquireTokenSilent(with: parameters) { (result, error) in

        if let error = error {

            let nsError = error as NSError

            // interactionRequired means we need to ask the user to sign-in. This usually happens
            // when the user's Refresh Token is expired or if the user has changed their password
            // among other possible reasons.

            if (nsError.domain == MSALErrorDomain) {

                if (nsError.code == MSALError.interactionRequired.rawValue) {

                    DispatchQueue.main.async {
                        self.acquireTokenInteractively()
                    }
                    return
                }
            }

            self.updateLogging(text: "Could not acquire token silently: \(error)")
            return
        }

        guard let result = result else {

            self.updateLogging(text: "Could not acquire token: No result returned")
            return
        }

        self.accessToken = result.accessToken
        self.updateLogging(text: "Refreshed Access token is \(self.accessToken)")
        self.updateSignOutButton(enabled: true)
    }
}

Ta funkcja używa biblioteki MSAL dla systemu iOS do dyskretnego uzyskiwania tokenu dla istniejącego konta. Po zweryfikowaniu elementu rejestruje proces pozyskiwania applicationContexttokenu. Za pomocą metody MSALSilentTokenParametersdefiniuje wymagane parametry. Następnie próbuje uzyskać token w trybie dyskretnym. Jeśli wystąpią błędy, sprawdza wymagania dotyczące interakcji z użytkownikiem, inicjując w razie potrzeby interaktywny proces. Po pomyślnym zakończeniu accessToken aktualizuje właściwość i rejestruje odświeżony token, kończąc przez włączenie przycisku wylogowywanie.

Wyloguj użytkownika

Aby wylogować użytkownika z aplikacji systemu iOS (Swift) przy użyciu biblioteki MSAL dla systemu iOS, użyj następującego kodu:

   @IBAction func signOut(_ sender: UIButton) {
        
        guard let applicationContext = self.applicationContext else { return }
        
        guard let account = self.currentAccount else { return }
        
        guard let webViewParamaters = self.webViewParamaters else { return }
        
        updateLogging(text: "Signing out...")
        
        do {
            
            /**
             Removes all tokens from the cache for this application for the provided account
             
             - account:    The account to remove from the cache
             */
            
            let signoutParameters = MSALSignoutParameters(webviewParameters: webViewParamaters)
            
            // If testing with Microsoft's shared device mode, trigger signout from browser. More details here:
            // https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-ios-shared-devices
            
            if (self.currentDeviceMode == .shared) {
                signoutParameters.signoutFromBrowser = true
            } else {
                signoutParameters.signoutFromBrowser = false
            }
            
            applicationContext.signout(with: account, signoutParameters: signoutParameters, completionBlock: {(success, error) in
                
                if let error = error {
                    self.updateLogging(text: "Couldn't sign out account with error: \(error)")
                    return
                }
                
                self.updateLogging(text: "Sign out completed successfully")
                self.accessToken = ""
                self.updateCurrentAccount(account: nil)
            })
            
        }
    }

Kod weryfikuje istnienie elementów applicationContext, currentAccounti webViewParamaters. Następnie rejestruje proces wylogowywanie. Kod usuwa wszystkie tokeny z pamięci podręcznej dla podanego konta. W zależności od bieżącego trybu urządzenia określa, czy wylogować się z przeglądarki. Po zakończeniu aktualizuje odpowiednio tekst rejestrowania. Jeśli podczas procesu wylogowania wystąpi błąd, rejestruje komunikat o błędzie. Po pomyślnym wylogowaniu aktualizuje token dostępu do pustego ciągu i czyści bieżące konto.

Następne kroki

Samouczek: wywoływanie chronionego internetowego interfejsu API w aplikacji systemu iOS (Swift).

Udostępnij za pośrednictwem

Wymagania wstępne

Wyloguj użytkownika

Następne kroki

Opinia

Dodatkowe zasoby

Udostępnij za pośrednictwem

Samouczek: logowanie użytkowników w aplikacji mobilnej systemu iOS (Swift)

Wymagania wstępne

Logowanie użytkownika

Wyloguj użytkownika

Następne kroki

Opinia

Dodatkowe zasoby