Acquisire un token di accesso (Python)Acquire an access token (Python)

Questo esempio dimostra come chiamare uno script Python esterno per ottenere un token OAuth2.This example demonstrates how to call an external Python script to obtain an OAuth2 token. Per l'implementazione del delegato di autenticazione è richiesto un token di accesso OAuth2 valido.A valid OAuth2 access token is required by the implementation of the authentication delegate.

PrerequisitiPrerequisites

Per eseguire l'esempio seguente:To run the sample below:

  • Installare Python 2,7 o versione successiva.Install Python 2.7 or newer.
  • Implementare utils.h/cpp nel progetto.Implement utils.h/cpp in your project.
  • Auth.py deve essere aggiunto al progetto e presente nella stessa directory dei file binari in fase di compilazione.Auth.py should be added to your project and exist in same directory as the binaries at build.
  • Installazione e configurazione dell'SDK complete (MIP).Complete (MIP) SDK setup and configuration. Tra le altre attività, l'applicazione client verrà registrata nel tenant di Azure Active Directory (Azure AD).Among other tasks, you'll register your client application in your Azure Active Directory (Azure AD) tenant. Azure AD fornirà un ID applicazione, noto anche come ID client, che viene usato nella logica di acquisizione dei token.Azure AD will provide an application ID, also known as client ID, which is used in your token acquisition logic.

Questo codice non è destinato all'uso in produzione.This code isn't intended for production use. Può essere utilizzato solo per lo sviluppo e la comprensione dei concetti di autenticazione.It may only be used for development and understanding auth concepts. Questo esempio è multipiattaforma.The sample is cross-platform.

sample::auth::AcquireToken()sample::auth::AcquireToken()

Nell'esempio di autenticazione semplice è stata illustrata una AcquireToken() semplice funzione che non ha accettato parametri e ha restituito un valore di token hardcoded.In the simple authentication example, we demonstrated a simple AcquireToken() function that took no parameters and returned a hard-coded token value. In questo esempio, si eseguirà l'overload di AcquireToken() per accettare i parametri di autenticazione e chiamare uno script Python esterno per restituire il token.In this example, we'll overload AcquireToken() to accept authentication parameters and call an external Python script to return the token.

auth.hauth.h

In auth.h, la funzione AcquireToken() viene sottoposta a overload e la funzione in overload e i parametri aggiornati sono i seguenti:In auth.h, AcquireToken() is overloaded and the overloaded function and updated parameters are as follows:

//auth.h
#include <string>

namespace sample {
  namespace auth {
    std::string AcquireToken(
        const std::string& userName, //A string value containing the user's UPN.
        const std::string& password, //The user's password in plaintext
        const std::string& clientId, //The Azure AD client ID (also known as Application ID) of your application.
        const std::string& resource, //The resource URL for which an OAuth2 token is required. Provided by challenge object.
        const std::string& authority); //The authentication authority endpoint. Provided by challenge object.
    }
}

I primi tre parametri verranno forniti dall'input dell'utente o saranno hardcoded nell'applicazione.The first three parameters will be provided by user input or hard coded in to your application. Gli ultimi due parametri vengono forniti dall'SDK al delegato di autenticazione.The last two parameters are provided by the SDK to the auth delegate.

auth.cppauth.cpp

In auth.cpp viene aggiunta la definizione della funzione in overload e quindi si definisce il codice necessario per chiamare lo script Python.In auth.cpp, we add the overloaded function definition, then define the code necessary to call the Python script. La funzione accetta tutti i parametri specificati e li passa allo script Python.The function accepts all of the provided parameters and passes them to the Python script. Lo script viene eseguito e restituisce il token in formato stringa.The script executes and returns the token in string format.

#include "auth.h"
#include "utils.h"

#include <fstream>
#include <functional>
#include <memory>
#include <string>

using std::string;
using std::runtime_error;

namespace sample {
    namespace auth {

    //This function implements token acquisition in the application by calling an external Python script.
    //The Python script requires username, password, clientId, resource, and authority.
    //Username, Password, and ClientId are provided by the user/developer
    //Resource and Authority are provided as part of the OAuth2Challenge object that is passed in by the SDK to the AuthDelegate.
    string AcquireToken(
        const string& userName,
        const string& password,
        const string& clientId,
        const string& resource,
        const string& authority) {

    string cmd = "python";
    if (sample::FileExists("auth.py"))
        cmd += " auth.py -u ";

    else
        throw runtime_error("Unable to find auth script.");

    cmd += userName;
    cmd += " -p ";
    cmd += password;
    cmd += " -a ";
    cmd += authority;
    cmd += " -r ";
    cmd += resource;
    cmd += " -c ";
    // Replace <application-id> with the Application ID provided during your Azure AD application registration.
    cmd += (!clientId.empty() ? clientId : "<application-id>");

    string result = sample::Execute(cmd.c_str());
    if (result.empty())
        throw runtime_error("Failed to acquire token. Ensure Python is installed correctly.");

    return result;
    }
    }
}

Script PythonPython Script

Questo script acquisisce i token di autenticazione direttamente tramite adal per Python.This script acquires authentication tokens directly via ADAL for Python. Questo codice è incluso solo come mezzo per acquisire i token di autenticazione per l'uso da parte delle app di esempio e non è destinato all'uso nell'ambiente di produzione.This code is included only as a means to acquire auth tokens for use by the sample apps and is not intended for use in production. Lo script funziona solo su tenant che supportano l'autenticazione HTTP semplice tradizionale con nome utente/password.The script works only against tenants that support plain old username/password http authentication. L'autenticazione MFA o basata sui certificati avrà esito negativo.MFA or certificate-based authentication will fail.

Nota

Prima di eseguire questo esempio, è necessario installare ADAL per Python eseguendo uno dei comandi seguenti:Prior to running this sample, you must install ADAL for Python by running one of the following commands:

pip install adal
pip3 install adal
import getopt
import sys
import json
import re
from adal import AuthenticationContext

def printUsage():
  print('auth.py -u <username> -p <password> -a <authority> -r <resource> -c <clientId>')

def main(argv):
  try:
    options, args = getopt.getopt(argv, 'hu:p:a:r:c:')
  except getopt.GetoptError:
    printUsage()
    sys.exit(-1)

  username = ''
  password = ''
  authority = ''
  resource = ''

  clientId = ''

  for option, arg in options:
    if option == '-h':
      printUsage()
      sys.exit()
    elif option == '-u':
      username = arg
    elif option == '-p':
      password = arg
    elif option == '-a':
      authority = arg
    elif option == '-r':
      resource = arg
    elif option == '-c':
      clientId = arg

  if username == '' or password == '' or authority == '' or resource == '' or clientId == '':
    printUsage()
    sys.exit(-1)

  # Find everything after the last '/' and replace it with 'token'
  if not authority.endswith('token'):
    regex = re.compile('^(.*[\/])')
    match = regex.match(authority)
    authority = match.group()
    authority = authority + username.split('@')[1]

  auth_context = AuthenticationContext(authority)
  token = auth_context.acquire_token_with_username_password(resource, username, password, clientId)
  print(token["accessToken"])

if __name__ == '__main__':
  main(sys.argv[1:])

Aggiornare AcquireOAuth2TokenUpdate AcquireOAuth2Token

Infine, aggiornare la funzione AcquireOAuth2Token in AuthDelegateImpl per chiamare la funzione AcquireToken in overload.Finally, update the AcquireOAuth2Token function in AuthDelegateImpl to call the overloaded AcquireToken function. Gli URL delle risorse e dell'autorità vengono ottenuti leggendo challenge.GetResource() e challenge.GetAuthority().The resource and authority URLs are obtained by reading challenge.GetResource() and challenge.GetAuthority(). OAuth2Challenge viene passato al delegato di autenticazione quando viene aggiunto il motore.The OAuth2Challenge is passed in to the auth delegate when the engine is added. Queste operazioni vengono eseguite dall'SDK e non sono richiesti ulteriori interventi da parte dello sviluppatore.This work is done by the SDK and requires no additional work on the part of the developer.

bool AuthDelegateImpl::AcquireOAuth2Token(
    const mip::Identity& /*identity*/,
    const OAuth2Challenge& challenge,
    OAuth2Token& token) {

    //call our AcquireToken function, passing in username, password, clientId, and getting the resource/authority from the OAuth2Challenge object
    string accessToken = sample::auth::AcquireToken(mUserName, mPassword, mClientId, challenge.GetResource(), challenge.GetAuthority());
    token.SetAccessToken(accessToken);
    return true;
}

Quando viene aggiunto l'engine, l'SDK chiamerà la funzione AcquireOAuth2Token, che passa la richiesta, esegue lo script Python, riceve un token e quindi presenta il token al servizio.When the engine is added, the SDK will call the `AcquireOAuth2Token function, passing in the challenge, executing the Python script, receiving a token, then presenting the token to the service.