Włączanie uwierzytelniania we własnej aplikacji Swift dla systemu iOS przy użyciu usługi Azure AD B2C

2025-05-04

Ważne

Od 1 maja 2025 r. usługa Azure AD B2C nie będzie już dostępna do zakupu dla nowych klientów. Dowiedz się więcej w naszych często zadawanych pytaniach.

W tym artykule przedstawiono sposób dodawania uwierzytelniania usługi Azure Active Directory B2C (Azure AD B2C) do własnej aplikacji mobilnej Swift dla systemu iOS. Dowiedz się, jak zintegrować aplikację Swift systemu iOS z biblioteką Microsoft Authentication Library (MSAL) dla systemu iOS.

Użyj tego artykułu z tematem Konfigurowanie uwierzytelniania w przykładowej aplikacji Swift dla systemu iOS, zastępując przykładową aplikację Swift dla systemu iOS własną aplikacją Swift dla systemu iOS. Po wykonaniu instrukcji w tym artykule aplikacja zaakceptuje logowania za pośrednictwem usługi Azure AD B2C.

Wymagania wstępne

Zapoznaj się z instrukcjami dotyczącymi wymagań wstępnych i integracji w temacie Konfigurowanie uwierzytelniania w przykładowej aplikacji Swift dla systemu iOS przy użyciu usługi Azure AD B2C.

Tworzenie projektu aplikacji Swift dla systemu iOS

Jeśli nie masz jeszcze aplikacji Swift dla systemu iOS, skonfiguruj nowy projekt, wykonując następujące czynności:

Otwórz program Xcode, a następnie wybierz pozycję Plik>nowy>projekt.
W przypadku aplikacji systemu iOS wybierz pozycjęAplikacja systemu >, a następnie wybierz pozycję Dalej.
W obszarze Wybierz opcje nowego projektu podaj następujące informacje:
1. Nazwa produktu, taka jak MSALiOS.
2. Identyfikator organizacji, taki jak contoso.com.
3. W obszarze Interfejs wybierz Storyboard.
4. Dla cyklu życia wybierz delegat aplikacji UIKit.
5. W polu Język wybierz pozycję Swift.
Wybierz Dalej.
Wybierz folder, w którym chcesz utworzyć aplikację, a następnie wybierz pozycję Utwórz.

Krok 1. Instalowanie biblioteki MSAL

Użyj narzędzia CocoaPods , aby zainstalować bibliotekę MSAL. W tym samym folderze co plik xcodeproj projektu, jeśli plik podfile nie istnieje, utwórz pusty plik i nadaj mu nazwę podfile. Dodaj następujący kod do pliku podfile :
```
use_frameworks!

target '<your-target-here>' do
   pod 'MSAL'
end
```
Zastąp <your-target-here> nazwą swojego projektu (na przykład MSALiOS). Aby uzyskać więcej informacji, zobacz Referencja składni Podfile.
W oknie terminalu przejdź do folderu zawierającego plik podfile, a następnie uruchom pod install, aby zainstalować bibliotekę MSAL.
Po uruchomieniu polecenia pod install, zostanie utworzony plik <twoja nazwa projektu>.xcworkspace. Aby ponownie załadować projekt w środowisku Xcode, zamknij program Xcode, a następnie otwórz <plik nazwa> projektu.xcworkspace .

Krok 2. Ustawianie schematu adresu URL aplikacji

Kiedy użytkownicy się uwierzytelniają, Azure AD B2C wysyła kod autoryzacji do aplikacji, korzystając z identyfikatora URI przekierowania skonfigurowanego podczas rejestracji aplikacji w Azure AD B2C.

Domyślny format URI przekierowania dla biblioteki MSAL to msauth.[Your_Bundle_Id]://auth. Przykładem może być msauth.com.microsoft.identitysample.MSALiOS://auth, gdzie msauth.com.microsoft.identitysample.MSALiOS jest schemat adresu URL.

W tym kroku zarejestruj schemat adresów URL przy użyciu tablicy CFBundleURLSchemes . Aplikacja nasłuchuje schematu adresów URL dla wywołania zwrotnego z usługi Azure AD B2C.

W programie Xcode otwórz plik Info.plist jako plik kodu źródłowego. <dict> W sekcji dodaj następujący fragment kodu XML:

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>msauth.com.microsoft.identitysample.MSALiOS</string>
        </array>
    </dict>
</array>
<key>LSApplicationQueriesSchemes</key>
<array>
    <string>msauthv2</string>
    <string>msauthv3</string>
</array>

Krok 3. Dodawanie kodu uwierzytelniania

Przykładowy kod składa się z UIViewController klasy. Klasa:

Definiuje strukturę interfejsu użytkownika.
Zawiera informacje o Twoim dostawcy tożsamości usługi Azure AD B2C. Aplikacja używa tych informacji do ustanowienia relacji zaufania z usługą Azure AD B2C.
Zawiera kod uwierzytelniania umożliwiający uwierzytelnianie użytkowników, uzyskiwanie tokenów i ich weryfikowanie.

Wybierz UIViewController, w którym użytkownicy się uwierzytelniają. W swoim UIViewController połącz kod z kodem podanym na GitHubie.

Krok 4. Konfigurowanie aplikacji Swift dla systemu iOS

Po dodaniu kodu uwierzytelniania skonfiguruj aplikację Swift dla systemu iOS przy użyciu ustawień usługi Azure AD B2C. Ustawienia dostawcy tożsamości usługi Azure AD B2C są konfigurowane w UIViewController klasie wybranej w poprzedniej sekcji.

Aby dowiedzieć się, jak skonfigurować aplikację Swift dla systemu iOS, zobacz Konfigurowanie uwierzytelniania w przykładowej aplikacji Swift dla systemu iOS przy użyciu usługi Azure AD B2C.

Krok 5. Uruchamianie i testowanie aplikacji mobilnej

Skompiluj i uruchom projekt za pomocą symulatora połączonego urządzenia z systemem iOS.
Wybierz pozycję Zaloguj się, a następnie zarejestruj się lub zaloguj się przy użyciu konta lokalnego lub społecznościowego usługi Azure AD B2C.
Po pomyślnym uwierzytelnieniu na pasku nawigacyjnym zobaczysz swoją nazwę wyświetlaną.

Krok 6. Dostosowywanie bloków konstrukcyjnych kodu

W tej sekcji opisano bloki konstrukcyjne kodu, które umożliwiają uwierzytelnianie aplikacji Swift dla systemu iOS. Zawiera on listę metod UIViewController i omawia sposób dostosowywania kodu.

Krok 6.1: Utwórz wystąpienie publicznej aplikacji klienckiej

Publiczne aplikacje klienckie nie są przeznaczone do bezpiecznego przechowywania tajemnic aplikacji i nie posiadają tajemnic klienckich. W viewDidLoad zainicjalizuj instancję MSAL-a używając obiektu aplikacji klienta publicznego.

Poniższy fragment kodu Swift pokazuje, jak zainicjować bibliotekę MSALPublicClientApplicationConfig MSAL za pomocą obiektu konfiguracji.

Obiekt konfiguracji zawiera informacje o środowisku usługi Azure AD B2C. Na przykład udostępnia identyfikator klienta, identyfikator URI przekierowania oraz autorytet potrzebne do budowania żądań uwierzytelniania w usłudze Azure AD B2C. Aby uzyskać informacje o obiekcie konfiguracji, zobacz Konfigurowanie przykładowej aplikacji mobilnej.

do {

    let signinPolicyAuthority = try self.getAuthority(forPolicy: self.kSignupOrSigninPolicy)
    let editProfileAuthority = try self.getAuthority(forPolicy: self.kEditProfilePolicy)
    
    let pcaConfig = MSALPublicClientApplicationConfig(clientId: kClientID, redirectUri: kRedirectUri, authority: signinPolicyAuthority)
    pcaConfig.knownAuthorities = [signinPolicyAuthority, editProfileAuthority]
    
    self.applicationContext = try MSALPublicClientApplication(configuration: pcaConfig)
    self.initWebViewParams()
    
    } catch {
        self.updateLoggingText(text: "Unable to create application \(error)")
    }

Metoda initWebViewParams konfiguruje środowisko uwierzytelniania interakcyjnego .

Poniższy fragment kodu Swift inicjuje webViewParameters składową klasy przy użyciu systemowego widoku internetowego. Aby uzyskać więcej informacji, zobacz Dostosowywanie przeglądarek i elementów WebView dla systemu iOS/macOS.

func initWebViewParams() {
    self.webViewParameters = MSALWebviewParameters(authPresentationViewController: self)
    self.webViewParameters?.webviewType = .default
}

Krok 6.2. Uruchamianie interakcyjnego żądania autoryzacji

Interakcyjne żądanie autoryzacji to przepływ, w którym użytkownicy są monitowani o zarejestrowanie się lub zalogowanie przy użyciu systemowego widoku internetowego. Gdy użytkownicy wybirą przycisk Zaloguj się, zostanie wywołana authorizationButton metoda .

Metoda authorizationButton przygotowuje MSALInteractiveTokenParameters obiekt z odpowiednimi danymi dotyczącymi żądania autoryzacji. Metoda acquireToken używa MSALInteractiveTokenParameters do uwierzytelniania użytkowników w systemowym widoku webowym.

Poniższy fragment kodu przedstawia sposób uruchamiania interakcyjnego żądania autoryzacji:

let parameters = MSALInteractiveTokenParameters(scopes: kScopes, webviewParameters: self.webViewParameters!)
parameters.promptType = .selectAccount
parameters.authority = authority

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

// On error code    
guard let result = result else {
    self.updateLoggingText(text: "Could not acquire token: \(error ?? "No error information" as! Error)")
    return
}

// On success code
self.accessToken = result.accessToken
self.updateLoggingText(text: "Access token is \(self.accessToken ?? "Empty")")
}

Po pomyślnym lub nieudanym zakończeniu przepływu autoryzacji przez użytkowników wynik zostanie zwrócony do zamknięciaacquireToken metody.

Metoda acquireToken zwraca result obiekty i error . Użyj tego zamknięcia, aby:

Zaktualizuj interfejs użytkownika aplikacji mobilnej przy użyciu informacji po zakończeniu uwierzytelniania.
Wywołaj usługę API za pomocą tokenu dostępu.
Obsługa błędów uwierzytelniania (na przykład gdy użytkownik anuluje przepływ logowania).

Krok 6.3. Wywoływanie internetowego interfejsu API

Aby wywołać internetowy interfejs API autoryzacji opartej na tokenach, aplikacja potrzebuje prawidłowego tokenu dostępu. Aplikacja wykonuje następujące czynności:

Uzyskuje token dostępu z wymaganymi uprawnieniami (zakresami) dla punktu końcowego API w sieci.
Przekazuje token dostępu jako token elementu nośnego w nagłówku autoryzacji żądania HTTP przy użyciu następującego formatu:

Authorization: Bearer <access-token>

Gdy użytkownicy uwierzytelniają się interaktywnie, aplikacja otrzymuje token dostępu w acquireToken zamknięciu. W przypadku kolejnych wywołań internetowego interfejsu API użyj metody bezgłośnego uzyskiwania tokenu (acquireTokenSilent), zgodnie z opisem w tej sekcji.

Metoda acquireTokenSilent wykonuje następujące akcje:

Próbuje pobrać token dostępu z żądanymi zakresami z pamięci podręcznej tokenu. Jeśli token jest obecny i nie wygasł, zostanie zwrócony token.
Jeśli token nie jest obecny w pamięci podręcznej lub wygasł, biblioteka MSAL próbuje użyć tokenu odświeżenia, aby uzyskać nowy token dostępu.
Jeśli token odświeżania nie istnieje lub wygasł, zwracany jest wyjątek. W takim przypadku należy monitować użytkownika o interakcyjne logowanie.

Poniższy fragment kodu przedstawia sposób uzyskiwania tokenu dostępu:

do {

// Get the authority using the sign-in or sign-up user flow
let authority = try self.getAuthority(forPolicy: self.kSignupOrSigninPolicy)

// Get the current account from the application context
guard let thisAccount = try self.getAccountByPolicy(withAccounts: applicationContext.allAccounts(), policy: kSignupOrSigninPolicy) else {
    self.updateLoggingText(text: "There is no account available!")
    return
}

// Configure the acquire token silent parameters
let parameters = MSALSilentTokenParameters(scopes: kScopes, account:thisAccount)
parameters.authority = authority
parameters.loginHint = "username"

// Acquire token silent
self.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) {
                
                // Start an interactive authorization code
                // Notice we supply the account here. This ensures we acquire token for the same account
                // as we originally authenticated.
                
                ...
            }
        }
        
        self.updateLoggingText(text: "Could not acquire token: \(error)")
        return
    }
    
    guard let result = result else {
        
        self.updateLoggingText(text: "Could not acquire token: No result returned")
        return
    }
    
    // On success, set the access token to the accessToken class member. 
    // The callGraphAPI method uses the access token to call a web API  
    self.accessToken = result.accessToken
    ...
}
} catch {
self.updateLoggingText(text: "Unable to construct parameters before calling acquire token \(error)")
}

Metoda callGraphAPI pobiera token dostępu i wywołuje internetowy interfejs API, jak pokazano poniżej:

@objc func callGraphAPI(_ sender: UIButton) {
    guard let accessToken = self.accessToken else {
        self.updateLoggingText(text: "Operation failed because could not find an access token!")
        return
    }
    
    let sessionConfig = URLSessionConfiguration.default
    sessionConfig.timeoutIntervalForRequest = 30
    let url = URL(string: self.kGraphURI)
    var request = URLRequest(url: url!)
    request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
    let urlSession = URLSession(configuration: sessionConfig, delegate: self, delegateQueue: OperationQueue.main)
    
    self.updateLoggingText(text: "Calling the API....")
    
    urlSession.dataTask(with: request) { data, response, error in
        guard let validData = data else {
            self.updateLoggingText(text: "Could not call API: \(error ?? "No error information" as! Error)")
            return
        }
        
        let result = try? JSONSerialization.jsonObject(with: validData, options: [])
        
        guard let validResult = result as? [String: Any] else {
            self.updateLoggingText(text: "Nothing returned from API")
            return
        }
        
        self.updateLoggingText(text: "API response: \(validResult.debugDescription)")
        }.resume()
}

Krok 6.4. Wylogowywanie użytkowników

Wylogowywanie przy użyciu biblioteki MSAL usuwa wszystkie znane informacje o użytkownikach z aplikacji. Użyj metody wylogowania, aby wylogować użytkowników i zaktualizować interfejs użytkownika. Możesz na przykład ukryć chronione elementy interfejsu użytkownika, ukryć przycisk wylogowywanie lub wyświetlić przycisk logowania.

Poniższy fragment kodu pokazuje, jak wylogować użytkowników:

@objc func signoutButton(_ sender: UIButton) {
do {
    
    
    let thisAccount = try self.getAccountByPolicy(withAccounts: applicationContext.allAccounts(), policy: kSignupOrSigninPolicy)
    
    if let accountToRemove = thisAccount {
        try applicationContext.remove(accountToRemove)
    } else {
        self.updateLoggingText(text: "There is no account to signing out!")
    }
    
    ...
    
} catch  {
    self.updateLoggingText(text: "Received error signing out: \(error)")
}
}

Dalsze kroki

Dowiedz się, jak:

Udostępnij za pośrednictwem