Partilhar via

Tutorial: Chamar várias APIs no aplicativo iOS/macOS usando autenticação nativa

  • Artigo

Aplica-se a: Círculo verde com um símbolo de marca de verificação branco. iOS (Swift) Círculo verde com um símbolo de marca de verificação branco. macOS (Swift)

Neste tutorial, você aprenderá como adquirir um token de acesso e chamar uma API em seu aplicativo iOS/macOS. O SDK de autenticação nativo da Biblioteca de Autenticação da Microsoft (MSAL) para iOS/macOS permite que você adquira vários tokens de acesso com um único login. Esse recurso permite que você adquira um ou mais tokens de acesso sem exigir que um usuário se autentique novamente.

Neste tutorial, irá aprender a:

  • Adquira um ou vários tokens de acesso.
  • Chamar uma API

Pré-requisitos

Adquira um ou vários tokens de acesso

O SDK de autenticação nativa do MSAL pode armazenar vários tokens de acesso. Depois de entrar, você pode obter um token de acesso usando a getAccessToken(scope:) função e especificando os escopos para o novo token de acesso que deseja conceder.

  1. Declare e defina valores para um conjunto de escopos de API usando o seguinte trecho de código:

    let protectedAPIUrl1: String? = nil
let protectedAPIUrl2: String? = nil 
let protectedAPIScopes1: [String] = []
let protectedAPIScopes2: [String] = []

var accessTokenAPI1: String?
var accessTokenAPI2: String?
    • Inicialize protectedAPIUrl1 com a URL da sua primeira API da Web.
    • Inicialize protectedAPIUrl2 com a URL da sua segunda API da Web.
    • Defina protectedAPIScopes1 com escopos para sua primeira API, como ["api://<Resource_App_ID>/ToDoList.Read", "api://<Resource_App_ID>/ToDoList.ReadWrite"].
    • Defina protectedAPIScopes2 com escopos para sua segunda API, semelhante ao protectedAPIScopes1.
    • Declare as variáveis accessTokenAPI1 de cadeia de caracteres opcionais e accessTokenAPI2.

  2. Entra no usuário usando o seguinte trecho de código:

    @IBAction func signInPressed(_: Any) {
    guard let email = emailTextField.text, let password = passwordTextField.text else {
        resultTextView.text = "Email or password not set"
        return
    }

    print("Signing in with email \(email) and password")

    showResultText("Signing in...")

    nativeAuth.signIn(username: email, password: password, delegate: self)
}

    O signInPressed método manipula a pressão do botão de entrada. Ele verifica se os campos de e-mail e senha estão preenchidos. Se um deles estiver vazio, ele mostrará "Email ou senha não definidos". Se ambos os campos forem preenchidos, ele registra o e-mail, exibe "Entrar..." e inicia o login usando o signIn método de nativeAuth com o e-mail e senha fornecidos. O SDK recupera um token válido para os escopos OIDC padrão (openid, offline_access, profile) porque nenhum escopo é especificado.

  3. Adquira um ou vários tokens de acesso usando o seguinte trecho de código:

    @IBAction func protectedApi1Pressed(_: Any) {
    guard let url = protectedAPIUrl1, !protectedAPIScopes1.isEmpty else {
        showResultText("API 1 not configured.")
        return
    }

    if let accessToken = accessTokenAPI1 {
        accessProtectedAPI(apiUrl: url, accessToken: accessToken)
    } else {
        accountResult?.getAccessToken(scopes: protectedAPIScopes1, delegate: self)
        let message = "Retrieving access token to use with API 1..."
        showResultText(message)
        print(message)
    }
}

@IBAction func protectedApi2Pressed(_: Any) {
    guard let url = protectedAPIUrl2, !protectedAPIScopes2.isEmpty else {
        showResultText("API 2 not configured.")
        return
    }

    if let accessToken = accessTokenAPI2 {
        accessProtectedAPI(apiUrl: url, accessToken: accessToken)
    } else {
        accountResult?.getAccessToken(scopes: protectedAPIScopes2, delegate: self)
        let message = "Retrieving access token to use with API 2..."
        showResultText(message)
        print(message)
    }
}

    Os protectedApi1Pressed métodos e protectedApi2Pressed gerenciam o processo de aquisição de tokens de acesso para dois conjuntos distintos de escopos. Primeiro, eles garantem que a URL e os escopos de cada API estejam configurados corretamente. Se um token de acesso para a API já estiver disponível, ele acessará diretamente a API. Caso contrário, ele solicita um token de acesso e informa o usuário sobre o processo de recuperação de token em andamento.

    Para atribuir um token de acesso a protectedAPIScopes1 e protectedAPIScopes2, use o seguinte trecho:

    func onAccessTokenRetrieveCompleted(result: MSALNativeAuthTokenResult) {
    print("Access Token: \(result.accessToken)")

    if protectedAPIScopes1.allSatisfy(result.scopes.contains),
       let url = protectedAPIUrl1
    {
        accessTokenAPI1 = result.accessToken
        accessProtectedAPI(apiUrl: url, accessToken: result.accessToken)
    }

    if protectedAPIScopes2.allSatisfy(result.scopes.contains(_:)),
       let url = protectedAPIUrl2
    {
        accessTokenAPI2 = result.accessToken
        accessProtectedAPI(apiUrl: url, accessToken: result.accessToken)
    }

    showResultText("Signed in." + "\n\n" + "Scopes:\n\(result.scopes)" + "\n\n" + "Access Token:\n\(result.accessToken)")
    updateUI()
}

func onAccessTokenRetrieveError(error: MSAL.RetrieveAccessTokenError) {
    showResultText("Error retrieving access token: \(error.errorDescription ?? "No error description")")
}

    O onAccessTokenRetrieveCompleted método imprime o token de acesso ao console. Em seguida, verifica se protectedAPIScopes1 estão incluídos nos escopos do resultado e se protectedAPIUrl1 está disponível, em caso afirmativo, define accessTokenAPI1 e chama accessProtectedAPI com a URL e o token. Ele executa uma verificação semelhante para protectedAPIScopes2 e protectedAPIUrl2, atualizando accessTokenAPI2 e fazendo a chamada de API se as condições forem atendidas. Finalmente, o método exibe uma mensagem com o status conectado, escopos e token de acesso e atualiza a interface do usuário.

    O onAccessTokenRetrieveError método exibe uma mensagem de erro com a descrição do erro de recuperação do token de acesso ou uma mensagem padrão se nenhuma descrição for fornecida.

Chamar uma API

Use os seguintes trechos de código para chamar uma API:

func accessProtectedAPI(apiUrl: String, accessToken: String) {
    guard let url = URL(string: apiUrl) else {
        let errorMessage = "Invalid API url"
        print(errorMessage)
        DispatchQueue.main.async {
            self.showResultText(errorMessage)
        }
        return
    }
    
    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
    
    let task = URLSession.shared.dataTask(with: request) { data, response, error in
        if let error = error {
            print("Error found when accessing API: \(error.localizedDescription)")
            DispatchQueue.main.async {
                self.showResultText(error.localizedDescription)
            }
            return
        }
        
        guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode)
        else {
            DispatchQueue.main.async {
                self.showResultText("Unsuccessful response found when accessing the API")
            }
            return
        }
        
        guard let data = data, let result = try? JSONSerialization.jsonObject(with: data, options: []) else {
            DispatchQueue.main.async {
                self.showResultText("Couldn't deserialize result JSON")
            }
            return
        }
        
        DispatchQueue.main.async {
            self.showResultText("""
                            Accessed API successfully using access token.
                            HTTP response code: \(httpResponse.statusCode)
                            HTTP response body: \(result)
                            """)
        }
    }
    
    task.resume()
}

O accessProtectedAPI método envia uma solicitação GET para o ponto de extremidade da API especificado usando o token de acesso fornecido. Ele configura a solicitação com o token no cabeçalho Authorization. Quando recebe uma resposta bem-sucedida (código de status HTTP 200-299), ele desserializa os dados JSON e atualiza a interface do usuário com o código de status HTTP e o corpo da resposta. Se ocorrer um erro durante o processamento de solicitação ou resposta, ele exibirá a mensagem de erro na interface do usuário. Esse método permite o acesso à API 1 ou à API 2, dependendo da URL e do token de acesso fornecido.

Conteúdos relacionados