Conectar usuários e chamar o Microsoft Graph de um aplicativo iOSSign in users and call the Microsoft Graph from an iOS app

Neste tutorial, você aprenderá a integrar um aplicativo iOS à plataforma de identidade da Microsoft.In this tutorial, you'll learn how to integrate an iOS app with the Microsoft identity platform. O aplicativo conectará um usuário, obterá um token de acesso para chamar a API do Microsoft Graph e fará uma solicitação para a API do Microsoft Graph.The app will sign in a user, get an access token to call the Microsoft Graph API, and make a request to the Microsoft Graph API.

Após concluir este guia, seu aplicativo aceitará conexões de contas Microsoft pessoais (incluindo outlook.com, live.com e outras) e contas corporativas ou de estudante de qualquer empresa ou organização que utilize o Azure Active Directory.When you've completed the guide, your application will accept sign-ins of personal Microsoft accounts (including outlook.com, live.com, and others) and work or school accounts from any company or organization that uses Azure Active Directory.

Como este tutorial funcionaHow this tutorial works

Mostra como funciona o aplicativo de exemplo gerado por este tutorial

O aplicativo deste tutorial conectará usuários e obterá dados no nome deles.The app in this tutorial will sign in users and get data on their behalf. Esses dados serão acessados por meio de uma API protegida (API do Microsoft Graph, nesse caso) que exige autorização e é protegida pela plataforma de identidade da Microsoft.This data will be accessed via a protected API (Microsoft Graph API in this case) that requires authorization and is protected by the Microsoft identity platform.

Mais especificamente:More specifically:

  • Seu aplicativo conectará o usuário por meio de um navegador ou do Microsoft Authenticator.Your app will sign in the user either through a browser or the Microsoft Authenticator.
  • O usuário final aceitará as permissões solicitadas por seu aplicativo.The end user will accept the permissions your application has requested.
  • Será emitido um token de acesso para seu aplicativo para a API do Microsoft Graph.Your app will be issued an access token for the Microsoft Graph API.
  • O token de acesso será incluído na solicitação HTTP para API Web.The access token will be included in the HTTP request to the web API.
  • Processe a resposta do Microsoft Graph.Process the Microsoft Graph response.

Esta amostra usa a MSAL (Biblioteca de Autenticação da Microsoft) para implementar a Autenticação.This sample uses the Microsoft Authentication library (MSAL) to implement Authentication. A MSAL automaticamente renovará tokens, fornecerá o SSO (logon único) entre outros aplicativos no dispositivo e ajudará a gerenciar as contas.MSAL will automatically renew tokens, deliver single sign-on (SSO) between other apps on the device, and manage the Account(s).

Pré-requisitosPrerequisites

  • O Xcode versão 10.x é necessário para criar o aplicativo neste guia.XCode version 10.x is required to build the app in this guide. Você pode fazer o download do XCode na URL de download do XCode.You can download XCode from the iTunes website.
  • Biblioteca de Autenticação da Microsoft (MSAL.framework).Microsoft Authentication Library (MSAL.framework). Você pode usar um gerenciador de dependência ou adicionar a biblioteca manualmente.You can use a dependency manager or add the library manually. As instruções abaixo mostram como fazer isso.The instructions below show you how.

Este tutorial irá criar um novo projeto.This tutorial will create a new project. Se, ao invés disso, você quiser baixar o tutorial concluído, baixe o código.If you want to download the completed tutorial instead, download the code.

Criar um novo projetoCreate a new project

  1. Abra o Xcode e selecione Crie um novo projeto Xcode.Open Xcode and select Create a new Xcode project.
  2. Selecione iOS > Aplicativo de Exibição Única e selecione Avançar.Select iOS > Single view App and select Next.
  3. Forneça um nome de produto.Provide a product name.
  4. Defina a Linguagem como Swift e selecione Avançar.Set the Language to Swift and select Next.
  5. Selecione uma pasta para criar seu aplicativo e clique em Criar.Select a folder to create your app and click Create.

Registre seu aplicativoRegister your application

  1. Vá para o Portal do AzureGo to the Azure portal
  2. Abra a folha Registros de aplicativo e clique em +Novo registro.Open the App registrations blade and click +New registration.
  3. Insira um Nome para seu aplicativo e, em seguida, sem definir um URI de Redirecionamento, clique em Registrar.Enter a Name for your app and then, without setting a Redirect URI, click Register.
  4. Na seção Gerenciar do painel exibido, selecione Autenticação.In the Manage section of the pane that appears, select Authentication.
  5. Clique em Experimentar a nova experiência ao lado da parte superior da tela para abrir a nova experiência de registro de aplicativo e, em seguida, clique em + Novo registro > + Adicionar uma plataforma > iOS.Click Try out the new experience near the top of the screen to open the new app registration experience, and then click +New registration > + Add a platform > iOS.
    • Insira a ID do Pacote do seu projeto.Enter your project's Bundle ID. Se você baixou o código, ele é com.microsoft.identitysample.MSALiOS.If you downloaded the code, this is com.microsoft.identitysample.MSALiOS. Se estiver criando seu próprio projeto, selecione seu projeto no Xcode e abra a guia Geral. O identificador do pacote será exibido na seção Identidade.If you're creating your own project, select your project in Xcode and open the General tab. The bundle identifier appears in the Identity section.
  6. Clique em Configure e salve a Configuração da MSAL exibida na página Configuração do iOS para que você possa inseri-la quando configurar o aplicativo mais tarde.Click Configure and save the MSAL Configuration that appears in the iOS configuration page so you can enter it when you configure your app later. Clique em Concluído.Click Done.

Adicionar MSALAdd MSAL

Escolha uma das seguintes maneiras de instalar a biblioteca MSAL em seu aplicativo:Choose one of the following ways to install the MSAL library in your app:

CocoaPodsCocoaPods

  1. Se estiver usando o CocoaPods, instale MSAL primeiro criando um arquivo vazio chamado podfile na mesma pasta do arquivo .xcodeproj do projeto.If you're using CocoaPods, install MSAL by first creating an empty file called podfile in the same folder as your project's .xcodeproj file. Adicione o seguinte a podfile:Add the following to podfile:

    use_frameworks!
    
    target '<your-target-here>' do
       pod 'MSAL', '~> 0.4.0'
    end
    
  2. Substitua <your-target-here> pelo nome do projeto.Replace <your-target-here> with the name of your project.

  3. Em uma janela do terminal, navegue até a pasta que contém podfile que você criou e execute pod install para instalar a biblioteca MSAL.In a terminal window, navigate to the folder that contains the podfile you created and run pod install to install the MSAL library.

  4. Feche o Xcode e abra <your project name>.xcworkspace para recarregar o projeto no Xcode.Close Xcode and open <your project name>.xcworkspace to reload the project in Xcode.

CarthageCarthage

Se estiver usando o Carthage, instale MSAL adicionando-o ao Cartfile:If you're using Carthage, install MSAL by adding it to your Cartfile:

github "AzureAD/microsoft-authentication-library-for-objc" "master"

ManualmenteManually

Você também pode usar o Submódulo Git ou conferir a última versão e usá-la como uma estrutura em seu aplicativo.You can also use Git Submodule, or check out the latest release to use as a framework in your application.

Adicionar o registro do seu aplicativoAdd your app registration

Em seguida, adicionaremos o registro de aplicativo ao código.Next, we'll add your app registration to your code.

Primeiro, adicione a seguinte instrução de importação à parte superior dos arquivos ViewController.swift e AppDelegate.swift:First, add the following import statement to the top of the ViewController.swift and AppDelegate.swift files:

import MSAL

Em seguida, adicione o seguinte código a ViewController.swift antes de viewDidLoad():Then Add the following code to ViewController.swift prior to viewDidLoad():

let kClientID = "Your_Application_Id_Here"

// Additional variables for Auth and Graph API
let kGraphURI = "https://graph.microsoft.com/v1.0/me/"
let kScopes: [String] = ["https://graph.microsoft.com/user.read"]
let kAuthority = "https://login.microsoftonline.com/common"
var accessToken = String()
var applicationContext : MSALPublicClientApplication?

Modifique o valor atribuído a kClientID para torná-lo a ID do aplicativo.Modify the value assigned to kClientIDto be your Application ID. Esse valor faz parte dos dados de Configuração da MSAL que você salvou durante a etapa no início deste tutorial para registrar o aplicativo no portal do Azure.This value is part of the MSAL Configuration data that you saved during the step at the beginning of this tutorial to register the application in the Azure portal.

Configurar esquemas de URLConfigure URL schemes

Nesta etapa, você registrará CFBundleURLSchemes para que o usuário possa ser redirecionado novamente para o aplicativo após a entrada.In this step, you will register CFBundleURLSchemes so that the user can be redirected back to the app after sign in. A propósito, LSApplicationQueriesSchemes também permite que seu aplicativo faça uso do Microsoft Authenticator.By the way, LSApplicationQueriesSchemes also allows your app to make use of Microsoft Authenticator.

No Xcode, abra Info.plist como um arquivo de código-fonte e adicione o código a seguir dentro da seção <dict>.In Xcode, open Info.plist as a source code file, and add the following inside of the <dict> section. Substitua [BUNDLE_ID] pelo valor usado no portal do Azure que, se você baixou o código, é com.microsoft.identitysample.MSALiOS.Replace [BUNDLE_ID] with the value you used in the Azure portal which, if you downloaded the code, is com.microsoft.identitysample.MSALiOS. Se estiver criando seu próprio projeto, selecione seu projeto no Xcode e abra a guia Geral. O identificador do pacote será exibido na seção Identidade.If you're creating your own project, select your project in Xcode and open the General tab. The bundle identifier appears in the Identity section.

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>msauth.[BUNDLE_ID]</string>
        </array>
    </dict>
</array>
<key>LSApplicationQueriesSchemes</key>
<array>
    <string>msauth</string>
    <string>msauthv2</string>
</array>

Criar a interface do usuário do seu aplicativoCreate your app’s UI

Agora crie uma interface do usuário que inclui um botão para chamar a API do Microsoft Graph, outra para sair e uma exibição de texto para ver uma saída adicionando o seguinte código à classe ViewController:Now create a UI that includes a button to call the Microsoft Graph API, another to sign out, and a text view to see some output by adding the following code to the ViewControllerclass:

var loggingText: UITextView!
var signOutButton: UIButton!
var callGraphButton: UIButton!

func initUI() {
        // Add call Graph button
        callGraphButton  = UIButton()
        callGraphButton.translatesAutoresizingMaskIntoConstraints = false
        callGraphButton.setTitle("Call Microsoft Graph API", for: .normal)
        callGraphButton.setTitleColor(.blue, for: .normal)
        callGraphButton.addTarget(self, action: #selector(callGraphAPI(_:)), for: .touchUpInside)
        self.view.addSubview(callGraphButton)
        
        callGraphButton.centerXAnchor.constraint(equalTo: view.centerXAnchor).isActive = true
        callGraphButton.topAnchor.constraint(equalTo: view.topAnchor, constant: 50.0).isActive = true
        callGraphButton.widthAnchor.constraint(equalToConstant: 300.0).isActive = true
        callGraphButton.heightAnchor.constraint(equalToConstant: 50.0).isActive = true
        
        // Add sign out button
        signOutButton = UIButton()
        signOutButton.translatesAutoresizingMaskIntoConstraints = false
        signOutButton.setTitle("Sign Out", for: .normal)
        signOutButton.setTitleColor(.blue, for: .normal)
        signOutButton.setTitleColor(.gray, for: .disabled)
        signOutButton.addTarget(self, action: #selector(signOut(_:)), for: .touchUpInside)
        self.view.addSubview(signOutButton)
        
        signOutButton.centerXAnchor.constraint(equalTo: view.centerXAnchor).isActive = true
        signOutButton.topAnchor.constraint(equalTo: callGraphButton.bottomAnchor, constant: 10.0).isActive = true
        signOutButton.widthAnchor.constraint(equalToConstant: 150.0).isActive = true
        signOutButton.heightAnchor.constraint(equalToConstant: 50.0).isActive = true
        signOutButton.isEnabled = false
        
        // Add logging textfield
        loggingText = UITextView()
        loggingText.isUserInteractionEnabled = false
        loggingText.translatesAutoresizingMaskIntoConstraints = false
        
        self.view.addSubview(loggingText)
        
        loggingText.topAnchor.constraint(equalTo: signOutButton.bottomAnchor, constant: 10.0).isActive = true
        loggingText.leftAnchor.constraint(equalTo: self.view.leftAnchor, constant: 10.0).isActive = true
        loggingText.rightAnchor.constraint(equalTo: self.view.rightAnchor, constant: 10.0).isActive = true
        loggingText.bottomAnchor.constraint(equalTo: self.view.bottomAnchor, constant: 10.0).isActive = true
    }

Em seguida, também dentro da classe ViewController, substitua o método viewDidLoad() por:Next, also inside the ViewController class, replace the viewDidLoad() method with:

    override func viewDidLoad() {
        super.viewDidLoad()
        initUI()
        do {
            try self.initMSAL()
        } catch let error {
            self.loggingText.text = "Unable to create Application Context \(error)"
        }
    }

Usar a MSALUse MSAL

Inicializar a MSALInitialize MSAL

Adicione o seguinte método InitMSAL à classe ViewController:Add the following InitMSAL method to the ViewController class:

    func initMSAL() throws {
        
        guard let authorityURL = URL(string: kAuthority) else {
            self.loggingText.text = "Unable to create authority URL"
            return
        }
        
        let authority = try MSALAADAuthority(url: authorityURL)
        
        let msalConfiguration = MSALPublicClientApplicationConfig(clientId: kClientID, redirectUri: nil, authority: authority)
        self.applicationContext = try MSALPublicClientApplication(configuration: msalConfiguration)
    }

Manipular o retorno de chamada de entradaHandle the sign-in callback

Abra o arquivo AppDelegate.swift .Open the AppDelegate.swift file. Para manipular o retorno de chamada após a entrada, adicione MSALPublicClientApplication.handleMSALResponse à classe appDelegate desta forma:To handle the callback after sign-in, add MSALPublicClientApplication.handleMSALResponse to the appDelegate class like this:

    func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
        
        guard let sourceApplication = options[UIApplication.OpenURLOptionsKey.sourceApplication] as? String else {
            return false
        }
        
        return MSALPublicClientApplication.handleMSALResponse(url, sourceApplication: sourceApplication)
    }

Adquirir tokensAcquire Tokens

Agora, podemos implementar a lógica de processamento da interface do usuário do aplicativo e obter tokens de maneira interativa por meio da MSAL.Now, we can implement the application's UI processing logic and get tokens interactively through MSAL.

A MSAL expõe dois métodos principais para obter tokens: acquireTokenSilently() e acquireTokenInteractively():MSAL exposes two primary methods for getting tokens: acquireTokenSilently() and acquireTokenInteractively():

  • acquireTokenSilently() tenta conectar um usuário e obter tokens sem nenhuma interação do usuário, desde que uma conta esteja presente.acquireTokenSilently() attempts to sign in a user and get tokens without any user interaction as long as an account is present.

  • acquireTokenInteractively() sempre mostra a interface do usuário ao tentar conectar o usuário.acquireTokenInteractively() always shows UI when attempting to sign in the user. Ele pode usar os cookies de sessão no navegador ou uma conta no Microsoft Authenticator para fornecer uma experiência de SSO interativo.It may use session cookies in the browser or an account in the Microsoft authenticator to provide an interactive-SSO experience.

Adicione o código a seguir à classe ViewController:Add the following code to the ViewController class:

    @objc func callGraphAPI(_ sender: UIButton) {
        
        guard let currentAccount = self.currentAccount() else {
            // We check to see if we have a current logged in account.
            // If we don't, then we need to sign someone in.
            acquireTokenInteractively()
            return
        }
        
        acquireTokenSilently(currentAccount)
    }

    func currentAccount() -> MSALAccount? {
        
        guard let applicationContext = self.applicationContext else { return nil }
        
        // We retrieve our current account by getting the first account from cache
        // In multi-account applications, account should be retrieved by home account identifier or username instead
        
        do {
            let cachedAccounts = try applicationContext.allAccounts()
            if !cachedAccounts.isEmpty {
                return cachedAccounts.first
            }
        } catch let error as NSError {
            self.updateLogging(text: "Didn't find any accounts in cache: \(error)")
        }
        
        return nil
    }

Obter um token interativamenteGet a token interactively

O código abaixo obtém um token pela primeira vez criando um objeto MSALInteractiveTokenParameters e chamando acquireToken.The code below gets a token for the first time by creating an MSALInteractiveTokenParameters object and calling acquireToken. Em seguida, você adicionará o código que:Next you will add code that:

  1. Cria MSALInteractiveTokenParameters com escopos.Creates MSALInteractiveTokenParameters with scopes.
  2. Chama acquireToken() com os parâmetros criados.Calls acquireToken() with the created parameters.
  3. Trata os erros.Handles errors. Para obter mais detalhes, confira o guia de tratamento de erros do iOS.For more detail, refer to the iOS error handling guide.
  4. Trata o caso de sucesso.Handles the successful case.

Adicione o código a seguir à classe ViewController .Add the following code to the ViewController class.

    func acquireTokenInteractively() {
   
        guard let applicationContext = self.applicationContext else { return }
     // #1    
        let parameters = MSALInteractiveTokenParameters(scopes: kScopes)
     // #2        
        applicationContext.acquireToken(with: parameters) { (result, error) in
     // #3            
            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
            }
     // #4            
            self.accessToken = result.accessToken
            self.updateLogging(text: "Access token is \(self.accessToken)")
            self.updateSignOutButton(enabled: true)
            self.getContentWithToken()
        }
    }

Obter um token no modo silenciosoGet a token silently

Para adquirir um token atualizado silenciosamente, adicione o código a seguir à classe ViewController.To acquire an updated token silently, add the following code to the ViewController class. Ele cria um objeto MSALSilentTokenParameters e chama acquireTokenSilent():It creates an MSALSilentTokenParameters object and calls acquireTokenSilent():

    
    func acquireTokenSilently(_ account : MSALAccount!) {
        guard let applicationContext = self.applicationContext else { return }
        let parameters = MSALSilentTokenParameters(scopes: kScopes, account: account)
        
        applicationContext.acquireTokenSilent(with: parameters) { (result, error) in    
            if let error = error {
                let nsError = error as NSError
                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)
            self.getContentWithToken()
        }
    }

Chamar a API do Microsoft GraphCall the Microsoft Graph API

Depois que você obtiver um token, seu aplicativo poderá usá-lo no cabeçalho HTTP para fazer uma solicitação autorizada ao Microsoft Graph:Once you have a token, your app can use it in the HTTP header to make an authorized request to the Microsoft Graph:

chave de cabeçalhoheader key valuevalue
AutorizaçãoAuthorization Bearer <access-token>Bearer <access-token>

Adicione o código a seguir à classe ViewController:Add the following code to the ViewController class:

    func getContentWithToken() {        
        // Specify the Graph API endpoint
        let url = URL(string: kGraphURI)
        var request = URLRequest(url: url!)
        
        // Set the Authorization header for the request. We use Bearer tokens, so we specify Bearer + the token we got from the result
        request.setValue("Bearer \(self.accessToken)", forHTTPHeaderField: "Authorization")
               
        URLSession.shared.dataTask(with: request) { data, response, error in
               
        if let error = error {
            self.updateLogging(text: "Couldn't get graph result: \(error)")
            return
        }
               
        guard let result = try? JSONSerialization.jsonObject(with: data!, options: []) else {
               
        self.updateLogging(text: "Couldn't deserialize result JSON")
            return
        }
               
        self.updateLogging(text: "Result from Graph: \(result))")
        
        }.resume()
    }

Confira API do Microsoft Graph para saber mais sobre a API do Microsoft Graph.See Microsoft Graph API to learn more about the Microsoft Graph API.

Usar a MSAL para saídaUse MSAL for Sign-out

Em seguida, adicione o suporte para saída.Next, add support for sign-out.

Importante

A saída com a MSAL remove todas as informações conhecidas sobre um usuário deste aplicativo, mas o usuário ainda terá uma sessão ativa em seu dispositivo.Signing out with MSAL removes all known information about a user from the application, but the user will still have an active session on their device. Se o usuário tentar entrar novamente, ele poderá ver a interface do usuário de entrada, mas talvez não precise inserir novamente suas credenciais, pois a sessão do dispositivo ainda estará ativa.If the user attempts to sign in again they may see sign-in UI, but may not need to reenter their credentials because the device session is still active.

Para adicionar a funcionalidade de saída, adicione o código a seguir dentro da classe ViewController.To add sign-out capability, add the following code inside the ViewController class. Esse método percorre todas as contas e as remove:This method cycles through all accounts and removes them:

    @objc func signOut(_ sender: UIButton) {
        
        guard let applicationContext = self.applicationContext else { return }
        
        guard let account = self.currentAccount() else { return }
        
        do {
            
            /**
             Removes all tokens from the cache for this application for the provided account
             
             - account:    The account to remove from the cache */
            
            try applicationContext.remove(account)
            self.loggingText.text = ""
            self.signOutButton.isEnabled = false
            
        } catch let error as NSError {
            
            self.updateLogging(text: "Received error signing account out: \(error)")
        }
    }

Ativar cache de tokenEnable token caching

Por padrão, a MSAL armazena em cache os tokens do seu aplicativo nas chaves do iOS.By default, MSAL caches your app's tokens in the iOS keychain.

Para habilitar o cache de token:To enable token caching:

  1. Acesse as Configurações do Projeto do Xcode > guia Funcionalidades > Habilitar o Compartilhamento do Conjunto de ChavesGo to your Xcode Project Settings > Capabilities tab > Enable Keychain Sharing
  2. Clique em + e insira com.microsoft.adalcache como uma entrada Grupos de Conjunto de Chaves.Click + and enter com.microsoft.adalcache as a Keychain Groups entry.

Adicionar métodos auxiliaresAdd helper methods

Adicione os seguintes métodos auxiliares à classe ViewController para concluir a amostra:Add the following helper methods to the ViewController class to complete the sample:

    
    func updateLogging(text : String) {
        
        if Thread.isMainThread {
            self.loggingText.text = text
        } else {
            DispatchQueue.main.async {
                self.loggingText.text = text
            }
        }
    }
    
    func updateSignOutButton(enabled : Bool) {
        if Thread.isMainThread {
            self.signOutButton.isEnabled = enabled
        } else {
            DispatchQueue.main.async {
                self.signOutButton.isEnabled = enabled
            }
        }
    }

Aplicativos de várias contasMulti-account applications

Este aplicativo foi criado para um cenário de conta única.This app is built for a single account scenario. A MSAL também dá suporte a cenários de várias contas, mas requer algum trabalho adicional dos aplicativos.MSAL also supports multi-account scenarios, but it requires some additional work from apps. Você precisará criar a interface do usuário para ajudar a selecionar qual conta deseja usar para cada ação que requer tokens do usuário.You will need to create UI to help user's select which account they want to use for each action that requires tokens. Como alternativa, seu aplicativo pode implementar uma heurística para selecionar qual conta usar por meio do método getAccounts().Alternatively, your app can implement a heuristic to select which account to use via the getAccounts() method.

Testar seu aplicativoTest your app

Executar localmenteRun locally

Compilar e implantar o aplicativo em um emulador ou dispositivo de teste.Build and deploy the app to a test device or emulator. Você deve conseguir conectar e obter tokens para o Azure AD ou contas Microsoft pessoais.You should be able to sign in and get tokens for Azure AD or personal Microsoft accounts.

Na primeira vez que um usuário entrar no aplicativo, ele será solicitado pela identidade da Microsoft a fornecer seu consentimento às permissões solicitadas.The first time a user signs into your app, they will be prompted by Microsoft identity to consent to the permissions requested. Embora a maioria dos usuários consiga fornecer seu consentimento, alguns locatários do Azure AD desabilitaram o consentimento do usuário, o que exige que os administradores forneçam consentimento em nome de todos os usuários.While most users are capable of consenting, some Azure AD tenants have disabled user consent, which requires admins to consent on behalf of all users. Para dar suporte a esse cenário, registre os escopos do seu aplicativo no portal do Azure.To support this scenario, register your app's scopes in the Azure portal.

Após entrar, este aplicativo exibirá os dados retornados do ponto de extremidade /me do Microsoft Graph.After you sign in, the app will display the data returned from the Microsoft Graph /me endpoint.

Obter ajudaGet help

Visite Ajuda e suporte se você tiver algum problema com este tutorial ou com a plataforma de identidade da Microsoft.Visit Help and support if you have trouble with this tutorial or with the Microsoft identity platform.

Ajude-nos a melhorar a plataforma de identidade da Microsoft.Help us improve the Microsoft identity platform. Deixe sua opinião respondendo a uma breve pesquisa de duas perguntas.Tell us what you think by completing a short two-question survey.