Habilite a autenticação em seu próprio aplicativo iOS Swift usando o Azure AD B2C

Importante

A partir de 1º de maio de 2025, o Azure AD B2C não estará mais disponível para compra para novos clientes. Saiba mais nas nossas Perguntas Frequentes.

Este artigo mostra como adicionar a autenticação do Azure Ative Directory B2C (Azure AD B2C) ao seu próprio aplicativo móvel iOS Swift. Saiba como integrar um aplicativo iOS Swift com a Microsoft Authentication Library (MSAL) para iOS.

Use este artigo com Configurar autenticação em um aplicativo iOS Swift de exemplo, substituindo o aplicativo iOS Swift de exemplo pelo seu próprio aplicativo iOS Swift. Depois de concluir as instruções neste artigo, seu aplicativo aceitará entradas por meio do Azure AD B2C.

Pré-requisitos

Analise os pré-requisitos e as instruções de integração em Configurar a autenticação em um aplicativo iOS Swift de exemplo usando o Azure AD B2C.

Criar um projeto de aplicativo iOS Swift

Se você ainda não tem um aplicativo iOS Swift, configure um novo projeto seguindo as seguintes etapas:

Abra o Xcode e selecione Arquivo>Novo>Projeto.
Para aplicações iOS, selecione Aplicação iOS> e, em seguida, selecioneSeguinte.
Para Escolher opções para seu novo projeto, forneça o seguinte:
1. Nome do produto, como MSALiOS.
2. Identificador da organização, como contoso.com.
3. Para Interface, selecione Storyboard.
4. Para o Ciclo de vida, selecione UIKit App Delegate.
5. Para o Idioma, selecione Swift.
Selecione Seguinte.
Selecione uma pasta na qual criar seu aplicativo e, em seguida, selecione Criar.

Etapa 1: Instalar a biblioteca MSAL

Use CocoaPods para instalar a biblioteca MSAL. Na mesma pasta do arquivo .xcodeproj do seu projeto, se o arquivo podfile não existir, crie um arquivo vazio e nomeie-o podfile. Adicione o seguinte código ao arquivo podfile :
```
use_frameworks!

target '<your-target-here>' do
   pod 'MSAL'
end
```
Substitua <your-target-here> pelo nome do seu projeto (por exemplo, MSALiOS). Para obter mais informações, consulte Referência de sintaxe do Podfile.
Em uma janela do terminal, vá para a pasta que contém o arquivo podfile e, em seguida, execute pod install para instalar a biblioteca MSAL.
Depois de executar o pod install comando, um <arquivo name.xcworkspace> do projeto é criado. Para recarregar o projeto no Xcode, feche o Xcode e abra o <arquivo name.xcworkspace> do projeto.

Etapa 2: definir o esquema de URL do aplicativo

Quando os usuários se autenticam, o Azure AD B2C envia um código de autorização para o aplicativo usando o URI de redirecionamento configurado no registro do aplicativo Azure AD B2C.

O formato URI de redirecionamento padrão do MSAL é msauth.[Your_Bundle_Id]://auth. Um exemplo seria msauth.com.microsoft.identitysample.MSALiOS://auth, onde msauth.com.microsoft.identitysample.MSALiOS está o esquema de URL.

Nesta etapa, registre seu esquema de URL usando a CFBundleURLSchemes matriz. O seu aplicativo escuta o esquema de URL para o callback do Azure AD B2C.

No Xcode, abra o arquivo Info.plist como um arquivo de código-fonte. <dict> Na seção , adicione o seguinte trecho 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>

Etapa 3: Adicionar o código de autenticação

O código de exemplo é composto de uma UIViewController classe. A classe:

Define a estrutura para uma interface do usuário.
Contém informações sobre seu provedor de identidade do Azure AD B2C. O aplicativo usa essas informações para estabelecer uma relação de confiança com o Azure AD B2C.
Contém o código de autenticação para autenticar usuários, adquirir tokens e validá-los.

Escolha um UIViewController local onde os usuários se autentiquem. No seu UIViewController, mescle o código com o código fornecido no GitHub.

Etapa 4: configurar seu aplicativo iOS Swift

Depois de adicionar o código de autenticação, configure seu aplicativo iOS Swift com as configurações do Azure AD B2C. As configurações do UIViewController provedor de identidade do Azure AD B2C são definidas na classe escolhida na seção anterior.

Para saber como configurar seu aplicativo iOS Swift, consulte Configurar a autenticação em um aplicativo iOS Swift de exemplo usando o Azure AD B2C.

Etapa 5: executar e testar o aplicativo móvel

Crie e execute o projeto com um simulador de um dispositivo iOS conectado.
Selecione Entrar e inscreva-se ou entre com sua conta local ou social do Azure AD B2C.
Depois de autenticar com êxito, você verá seu nome para exibição na barra de navegação.

Etapa 6: Personalizar seus blocos de construção de código

Esta seção descreve os blocos de construção de código que habilitam a autenticação para seu aplicativo iOS Swift. Ele lista os métodos do UIViewController e discute como personalizar seu código.

Etapa 6.1: Instanciar um aplicativo cliente público

Os aplicativos cliente públicos não são confiáveis para manter segredos de aplicativos com segurança e não têm segredos de cliente. Em viewDidLoad, instancie um MSAL usando um objeto de aplicativo cliente público.

O trecho de código Swift a seguir demonstra como inicializar o MSAL com um MSALPublicClientApplicationConfig objeto de configuração.

O objeto de configuração fornece informações sobre seu ambiente do Azure AD B2C. Por exemplo, ele fornece a ID do cliente, o URI de redirecionamento e a autoridade para criar solicitações de autenticação para o Azure AD B2C. Para obter informações sobre o objeto de configuração, consulte Configurar o aplicativo móvel de exemplo.

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

O initWebViewParams método configura a experiência de autenticação interativa .

O trecho de código Swift a seguir inicializa o membro da webViewParameters classe com a visualização da Web do sistema. Para obter mais informações, consulte Personalizar navegadores e WebViews para iOS/macOS.

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

Etapa 6.2: Iniciar uma solicitação de autorização interativa

Uma solicitação de autorização interativa é um fluxo em que os usuários são solicitados a se inscrever ou entrar usando a exibição da Web do sistema. Quando os usuários selecionam o botão Entrar , o authorizationButton método é chamado.

O authorizationButton método prepara o MSALInteractiveTokenParameters objeto com dados relevantes sobre a solicitação de autorização. O acquireToken método usa o MSALInteractiveTokenParameters para autenticar usuários através da visualização web do sistema.

O trecho de código a seguir demonstra como iniciar a solicitação de autorização interativa:

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

Depois que os usuários concluem o fluxo de autorização, com ou sem êxito, o resultado é retornado para o fechamento do acquireToken método.

O acquireToken método retorna os result objetos e error . Use este fechamento para:

Atualize a interface do usuário do aplicativo móvel com informações após a conclusão da autenticação.
Chame um serviço de API da Web com um token de acesso.
Manipular erros de autenticação (por exemplo, quando um usuário cancela o fluxo de entrada).

Etapa 6.3: Chamar uma API da Web

Para chamar uma API da Web de autorização baseada em token, o aplicativo precisa de um token de acesso válido. O aplicativo faz o seguinte:

Adquire um token de acesso com as permissões (escopos) necessárias para o ponto de extremidade da API Web.
Passa o token de acesso como um token de portador no cabeçalho de autorização da solicitação HTTP usando este formato:

Authorization: Bearer <access-token>

Quando os usuários se autenticam interativamente, o aplicativo recebe um token de acquireToken acesso no fechamento. Para chamadas subsequentes à Web API, utilize o método acquire token silent (acquireTokenSilent), conforme descrito nesta seção.

O acquireTokenSilent método executa as seguintes ações:

Ele tenta obter um token de acesso com as permissões solicitadas do cache de tokens. Se o token estiver presente e não tiver expirado, o token será retornado.
Se o token não estiver presente no cache de token ou tiver expirado, a biblioteca MSAL tentará usar o token de atualização para adquirir um novo token de acesso.
Se o token de atualização não existir ou tiver expirado, uma exceção será retornada. Nesse caso, você deve solicitar que o usuário entre interativamente.

O trecho de código a seguir demonstra como adquirir um token de acesso:

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

O callGraphAPI método recupera o token de acesso e chama a API da Web, conforme mostrado aqui:

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

Etapa 6.4: Terminar sessão dos utilizadores

Sair com o MSAL remove todas as informações conhecidas sobre os usuários do aplicativo. Use o método de saída para sair dos usuários e atualizar a interface do usuário. Por exemplo, você pode ocultar elementos protegidos da interface do usuário, ocultar o botão de saída ou mostrar o botão de entrada.

O trecho de código a seguir demonstra como desconectar utilizadores.

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

Próximos passos

Saiba como:

Feedback

Esta página foi útil?

Last updated on 2025-05-03