Povolení ověřování ve vlastní aplikaci iOS Swift pomocí Azure AD B2C

Důležité

Od 1. května 2025 už nebude Azure AD B2C k dispozici k nákupu pro nové zákazníky. Další informace najdete v našich nejčastějších dotazech.

Tento článek ukazuje, jak přidat ověřování Azure Active Directory B2C (Azure AD B2C) do vlastní mobilní aplikace iOS Swift. Zjistěte, jak integrovat aplikaci iOS Swift s knihovnou MICROSOFT Authentication Library (MSAL) pro iOS.

Tento článek použijte s konfigurací ověřování v ukázkové aplikaci iOS Swift a nahraďte ukázkovou aplikaci iOS Swift vlastní aplikací pro iOS Swift. Po dokončení pokynů v tomto článku vaše aplikace přijme přihlášení prostřednictvím Azure AD B2C.

Požadavky

Projděte si požadavky a pokyny k integraci v tématu Konfigurace ověřování v ukázkové aplikaci iOS Swift pomocí Azure AD B2C.

Vytvoření projektu aplikace Swift pro iOS

Pokud ještě nemáte aplikaci iOS Swift, nastavte nový projekt pomocí následujících kroků:

Otevřete Xcode a pak vyberte Soubor>nový>projekt.
V případě aplikací pro iOS vyberteaplikaci> a pak vyberte Další.
Pro výběr možností pro nový projekt zadejte následující:
1. Název produktu, například MSALiOS.
2. Identifikátor organizace, například contoso.com.
3. Pro rozhraní vyberte Storyboard.
4. Pro životní cyklus vyberte delegáta aplikace UIKit.
5. V případě jazyka vyberte Swift.
Vyberte Další.
Vyberte složku, ve které chcete aplikaci vytvořit, a pak vyberte Vytvořit.

Krok 1: Instalace knihovny MSAL

Pomocí CocoaPods nainstalujte knihovnu MSAL. Ve stejné složce jako soubor .xcodeproj projektu, pokud soubor podfile neexistuje, vytvořte prázdný soubor a pojmenujte ho podfile. Do souboru podfile přidejte následující kód:
```
use_frameworks!

target '<your-target-here>' do
   pod 'MSAL'
end
```
Nahraďte <your-target-here> názvem projektu (například MSALiOS). Další informace naleznete v tématu Podfile Syntax Reference.
V okně terminálu přejděte do složky, která obsahuje soubor podfile , a spusťte instalaci podu a nainstalujte knihovnu MSAL.
Po spuštění pod install příkazu <se vytvoří soubor name.xcworkspace> projektu . Pokud chcete projekt znovu načíst v Xcode, zavřete Xcode a otevřete <soubor název> projektu.xcworkspace .

Krok 2: Nastavení schématu adres URL aplikace

Když se uživatelé ověří, Azure AD B2C odešle autorizační kód do aplikace pomocí identifikátoru URI přesměrování nakonfigurovaného při registraci aplikace Azure AD B2C.

Výchozí formát identifikátoru URI přesměrování MSAL je msauth.[Your_Bundle_Id]://auth. Příkladem by bylo msauth.com.microsoft.identitysample.MSALiOS://auth, kde msauth.com.microsoft.identitysample.MSALiOS je schéma adresy URL.

V tomto kroku zaregistrujte schéma adres URL pomocí CFBundleURLSchemes pole. Vaše aplikace naslouchá na schématu URL pro callback z Azure AD B2C.

V Xcode otevřete soubor Info.plist jako soubor zdrojového kódu. <dict> V části přidejte následující fragment kódu 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: Přidání ověřovacího kódu

Vzorový kód je tvořen UIViewController třídou. Třída:

Definuje strukturu uživatelského rozhraní.
Obsahuje informace o zprostředkovateli identity Azure AD B2C. Aplikace tyto informace používá k navázání vztahu důvěryhodnosti s Azure AD B2C.
Obsahuje ověřovací kód pro ověřování uživatelů, získání tokenů a jejich ověření.

Zvolte, kde UIViewController se uživatelé ověřují. Ve svém kódu sloučíte UIViewControllerkód s kódem, který je k dispozici na GitHubu.

Krok 4: Konfigurace aplikace Pro iOS Swift

Po přidání ověřovacího kódu nakonfigurujte aplikaci iOS Swift pomocí nastavení Azure AD B2C. Nastavení zprostředkovatele identity Azure AD B2C se konfiguruje ve UIViewController třídě zvolené v předchozí části.

Informace o tom, jak nakonfigurovat aplikaci iOS Swift, najdete v tématu Konfigurace ověřování v ukázkové aplikaci iOS Swift pomocí Azure AD B2C.

Krok 5: Spuštění a otestování mobilní aplikace

Sestavte a spusťte projekt pomocí simulátoru připojeného zařízení s iOSem.
Vyberte Přihlásit se a pak se zaregistrujte nebo přihlaste pomocí místního nebo sociálního účtu Azure AD B2C.
Po úspěšném ověření se na navigačním panelu zobrazí zobrazované jméno.

Krok 6: Přizpůsobení stavebních bloků kódu

Tato část popisuje stavební bloky kódu, které umožňují ověřování pro vaši aplikaci iOS Swift. Uvádí metody UIViewController a popisuje, jak přizpůsobit kód.

Krok 6.1: Vytvoření instance veřejné klientské aplikace

Veřejné klientské aplikace nejsou důvěryhodné, aby bezpečně uchovávali tajné kódy aplikací a nemají tajné kódy klienta. V viewDidLoad vytvořte instanci knihovny MSAL pomocí objektu veřejné klientské aplikace.

Následující fragment kódu Swift ukazuje, jak inicializovat MSAL s objektem MSALPublicClientApplicationConfig konfigurace.

Objekt konfigurace poskytuje informace o prostředí Azure AD B2C. Poskytuje například ID klienta, identifikátor URI přesměrování a autoritu pro sestavování žádostí o ověřování v Azure AD B2C. Informace o objektu konfigurace najdete v tématu Konfigurace ukázkové mobilní aplikace.

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

Tato initWebViewParams metoda konfiguruje interaktivní prostředí ověřování .

Následující fragment kódu Swift inicializuje webViewParameters člena třídy pomocí systémového webového zobrazení. Další informace naleznete v tématu Přizpůsobení prohlížečů a WebViews pro iOS/macOS.

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

Krok 6.2: Spuštění interaktivní žádosti o autorizaci

Interaktivní žádost o autorizaci je tok, ve kterém se uživatelům zobrazí výzva k registraci nebo přihlášení pomocí systémového webového zobrazení. Když uživatelé vyberou tlačítko Přihlásit se , volá se authorizationButton metoda.

Metoda authorizationButton připraví objekt s relevantními daty MSALInteractiveTokenParameters o autorizační žádosti. Metoda acquireToken používá MSALInteractiveTokenParameters k ověřování uživatelů prostřednictvím systémového webového zobrazení.

Následující fragment kódu ukazuje, jak spustit interaktivní žádost o autorizaci:

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 úspěšném nebo neúspěšném dokončení autorizačního toku se výsledek vrátí k uzavřeníacquireToken metody.

Metoda acquireToken vrátí result a error objekty. Toto uzavření použijte k:

Po dokončení ověřování aktualizujte uživatelské rozhraní mobilní aplikace informacemi.
Volání služby webového rozhraní API pomocí přístupového tokenu
Řešte chyby ověřování (například když uživatel zruší proces přihlášení).

Krok 6.3: Volání webového rozhraní API

K volání webového rozhraní API pro autorizaci založeného na tokenech potřebuje aplikace platný přístupový token. Aplikace provede následující:

Získá přístupový token s požadovanými oprávněními (obory) pro koncový bod webového rozhraní API.
Předá přístupový token jako nosný token v autorizační hlavičce požadavku HTTP pomocí tohoto formátu:

Authorization: Bearer <access-token>

Když se uživatelé ověřují interaktivně, aplikace v acquireToken uzavření získá přístupový token. Pro následná volání webového rozhraní API použijte metodu získání tichého tokenu (acquireTokenSilent), jak je popsáno v této části.

Metoda acquireTokenSilent provede následující akce:

Pokusí se načíst přístupový token s požadovanými obory z mezipaměti tokenů. Pokud token existuje a nevypršela jeho platnost, vrátí se token.
Pokud token není v mezipaměti tokenů nebo vypršela jeho platnost, knihovna MSAL se pokusí použít obnovovací token k získání nového přístupového tokenu.
Pokud obnovovací token neexistuje nebo vypršela jeho platnost, vrátí se výjimka. V takovém případě byste měli uživatele vyzvat k interaktivnímu přihlášení.

Následující fragment kódu ukazuje, jak získat přístupový token:

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 načte přístupový token a volá webové rozhraní API, jak je znázorněno tady:

@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: Odhlášení uživatelů

Odhlášení pomocí MSAL odebere všechny známé informace o uživatelích z aplikace. Pomocí metody odhlášení odhlaste uživatele a aktualizujte uživatelské rozhraní. Můžete například skrýt chráněné prvky uživatelského rozhraní, skrýt tlačítko pro odhlášení nebo zobrazit tlačítko pro přihlášení.

Následující fragment kódu ukazuje, jak odhlásit uživatele:

@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)")
}
}

Další kroky

Naučte se jak:

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-05-01