Autenticare le app Python ai servizi di Azure durante lo sviluppo locale usando i principal di servizio

Quando si creano applicazioni cloud, gli sviluppatori spesso devono eseguire e testare le proprie app in locale. Anche durante lo sviluppo locale, l'applicazione deve eseguire l'autenticazione a tutti i servizi di Azure con cui interagisce. Questo articolo illustra come configurare entità di servizio dedicate specificamente per l'uso durante lo sviluppo locale.

Le entità servizio dell'applicazione dedicate per lo sviluppo locale supportano il principio dei privilegi minimi limitando l'accesso solo alle risorse di Azure richieste dall'app durante lo sviluppo. L'uso di un'entità servizio dell'applicazione dedicata riduce il rischio di accesso imprevisto ad altre risorse e consente di evitare bug correlati alle autorizzazioni durante la transizione all'ambiente di produzione, in cui autorizzazioni più ampie potrebbero causare problemi.

Quando si registrano applicazioni per lo sviluppo locale in Azure, è consigliabile:

• Creare registrazioni app separate per ogni sviluppatore: in questo modo ogni sviluppatore ha la propria entità servizio, evitando la necessità di condividere le credenziali e abilitando un controllo di accesso più granulare.
• Creare registrazioni di app separate per ogni applicazione: ciò garantisce che ogni app disponga solo delle autorizzazioni necessarie, riducendo la potenziale superficie di attacco.

Per abilitare l'autenticazione durante lo sviluppo locale, impostare le variabili di ambiente con le credenziali dell'entità servizio dell'applicazione. Azure SDK per Python rileva queste variabili e le usa per autenticare le richieste ai servizi di Azure.

Gli oggetti principale del servizio dell'applicazione vengono creati quando viene registrata un'app in Azure. Questa registrazione può essere eseguita usando il portale di Azure o l'interfaccia della riga di comando di Azure. Il processo di registrazione crea una registrazione dell'app in Microsoft Entra ID (in precedenza Azure Active Directory) e genera un oggetto entità servizio per l'app. L'oggetto "service principal" viene usato per autenticare l'app nei servizi di Azure. Il processo di registrazione dell'app genera anche un segreto client (password) per l'app. Questo segreto viene usato per autenticare l'app nei servizi di Azure. Il segreto client non viene mai archiviato nel controllo del codice sorgente, ma in un .env file nella directory dell'applicazione. Il .env file viene letto dall'applicazione in fase di esecuzione per impostare le variabili di ambiente usate da Azure SDK per Python per autenticare l'app. I passaggi seguenti illustrano come registrare un'app in Azure e creare un'entità servizio per l'app. I passaggi vengono illustrati sia per l'interfaccia della riga di comando di Azure che per il portale di Azure.

• Interfaccia della riga di comando di Azure
• Portale di Azure

I comandi dell'interfaccia della riga di comando di Azure possono essere eseguiti in Azure Cloud Shell o in una workstation con l'interfaccia della riga di comando di Azure installata.

Per prima cosa, utilizzare il comando az ad sp create-for-rbac per creare una nuova entità servizio per l'applicazione. Il comando crea anche la registrazione dell'applicazione per l'app contemporaneamente.

SERVICE_PRINCIPAL_NAME=<service-principal-name>
az ad sp create-for-rbac --name $SERVICE_PRINCIPAL_NAME

L'output di questo comando è simile al seguente. Prendere nota di questi valori o mantenere aperta questa finestra perché questi valori saranno necessari nei passaggi successivi e non saranno più in grado di visualizzare di nuovo il valore della password (segreto client). È tuttavia possibile aggiungere una nuova password in un secondo momento senza invalidare l'entità servizio o le password esistenti, se necessario.

{
  "appId": "00001111-aaaa-2222-bbbb-3333cccc4444",
  "displayName": "<service-principal-name>",
  "password": "Ee5Ff~6Gg7.-Hh8Ii9Jj0Kk1Ll2Mm3_Nn4Oo5Pp6",
  "tenant": "aaaabbbb-0000-cccc-1111-dddd2222eeee"
}

Successivamente, è necessario ottenere il appID valore e archiviarlo in una variabile. Questo valore viene usato per impostare le variabili di ambiente nell'ambiente di sviluppo locale in modo che Azure SDK per Python possa eseguire l'autenticazione in Azure usando l'entità servizio.

APP_ID=$(az ad sp list \
  --all \
  --query "[?displayName=='$SERVICE_PRINCIPAL_NAME'].appId | [0]" \
  --output tsv)

Poiché in genere sono presenti più sviluppatori che lavorano su un'applicazione, è consigliabile creare un gruppo di sicurezza Microsoft Entra per incapsulare i ruoli (autorizzazioni) necessari per lo sviluppo locale, anziché assegnare i ruoli ai singoli oggetti entità servizio. Ciò offre i vantaggi seguenti:

• Ogni sviluppatore ha la certezza di avere gli stessi ruoli assegnati perché i ruoli vengono assegnati a livello di gruppo.
• Se è necessario un nuovo ruolo per l'app, basta aggiungerlo al gruppo Microsoft Entra specifico per l'app.
• Se un nuovo sviluppatore si aggiunge al team, viene creata una nuova entità servizio dell'applicazione per lo sviluppatore e aggiunta al gruppo, assicurando che lo sviluppatore disponga delle autorizzazioni appropriate per lavorare sull'app.

• Interfaccia della riga di comando di Azure
• Portale di Azure

Il comando az ad group create viene usato per creare gruppi di sicurezza in Microsoft Entra ID. I parametri --display-name e --main-nickname sono obbligatori. Il nome assegnato al gruppo deve essere basato sul nome dell'applicazione. È anche utile includere una stringa come local-dev nel nome del gruppo per indicare lo scopo del gruppo.

GROUP_DISPLAY_NAME="<group-name>"
GROUP_MAIL_NICKNAME="<group-mail-nickname>"
GROUP_DESCRIPTION="<group-description>"
az ad group create \
  --display-name $GROUP_DISPLAY_NAME \
  --mail-nickname $GROUP_MAIL_NICKNAME \
  --description $GROUP_DESCRIPTION

Per aggiungere membri al gruppo, è necessario l'ID oggetto del principale del servizio dell'applicazione, che è diverso dall'ID applicazione. Usare az ad sp list per elencare i principali di servizio disponibili. Il comando del parametro --filter accetta filtri di stile OData e può essere usato per filtrare l'elenco come illustrato. Il parametro --query limita le colonne solo a quelle di interesse.

SP_OBJECT_ID=$(az ad sp list \
  --filter "startswith(displayName,'$GROUP_DISPLAY_NAME')" \
  --query "[0].id" \
  --output tsv)

Il comando az ad group member add può quindi essere usato per aggiungere membri ai gruppi.

az ad group member add \
    --group $GROUP_DISPLAY_NAME \
    --member-id $SP_OBJECT_ID

Successivamente, è necessario determinare i ruoli (autorizzazioni) necessari per l'app in base alle risorse e assegnare tali ruoli all'app. In questo esempio i ruoli vengono assegnati al gruppo Microsoft Entra creato nel passaggio 2. I ruoli possono essere assegnati a una risorsa, a un gruppo di risorse o a un ambito di sottoscrizione. Questo esempio illustra come assegnare ruoli nell'ambito del gruppo di risorse perché la maggior parte delle applicazioni raggruppa tutte le risorse di Azure in un singolo gruppo di risorse.

• Interfaccia della riga di comando di Azure
• Portale di Azure

A un utente, un gruppo o un principale del servizio applicativo viene assegnato un ruolo in Azure utilizzando il comando az role assignment create. È possibile specificare un gruppo con il relativo ID oggetto. È possibile specificare un'entità servizio dell'applicazione utilizzando il suo appId.

RESOURCE_GROUP_NAME=<resource-group-name>
SUBSCRIPTION_ID=$(az account show --query id --output tsv)
ROLE_NAME=<role-name>
az role assignment create \
  --assignee "$APP_ID" \
  --scope "./subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP_NAME" \
  --role "$ROLE_NAME"

! [! NOTA] Per impedire a Git Bash di trattare /subscriptions/... come percorso del file, anteporre ./ alla stringa per il scope parametro e usare virgolette doppie intorno all'intera stringa.

Per ottenere i nomi dei ruoli che è possibile assegnare, usare il comando az role definition list .

az role definition list \
    --query "sort_by([].{roleName:roleName, description:description}, &roleName)" \
    --output table

Ad esempio, per consentire all'entità servizio dell'applicazione con appId di 00001111-aaaa-2222-bbbb-3333cccc4444 l'accesso in lettura, scrittura ed eliminazione ai contenitori e ai dati BLOB in tutti gli account di archiviazione nel gruppo di risorse msdocs-python-sdk-auth-example nella sottoscrizione con ID aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e, è necessario assegnare l'entità servizio dell'applicazione al ruolo di Collaboratore dati BLOB di Archiviazione usando il comando seguente.

az role assignment create --assignee 00001111-aaaa-2222-bbbb-3333cccc4444 \
    --scope "./subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-python-sdk-auth-example" \
    --role "Storage Blob Data Contributor"

Per informazioni sull'assegnazione delle autorizzazioni a livello di risorsa o sottoscrizione tramite l'interfaccia della riga di comando di Azure, vedere l'articolo Assegnare ruoli di Azure usando l'interfaccia della riga di comando di Azure.

L'oggetto DefaultAzureCredential cercherà le informazioni sull'entità servizio in un set di variabili di ambiente in fase di esecuzione. Poiché la maggior parte degli sviluppatori lavora su più applicazioni, è consigliabile usare un pacchetto come python-dotenv per accedere all'ambiente da un .env file archiviato nella directory dell'applicazione durante lo sviluppo. In questo modo le variabili di ambiente usate per autenticare l'applicazione in Azure possono essere usate solo da questa applicazione.

Il .env file non viene mai archiviato nel controllo del codice sorgente perché contiene la chiave privata dell'applicazione per Azure. Il file .gitignore standard per Python esclude automaticamente il file .env dall'archiviazione.

Per usare il pacchetto python-dotenv, installare prima di tutto il pacchetto nell'applicazione.

pip install python-dotenv

Creare quindi un .env file nella directory radice dell'applicazione. Impostare i valori delle variabili di ambiente con i valori ottenuti dal processo di registrazione dell'app come indicato di seguito:

• AZURE_CLIENT_ID → Il valore dell'ID dell'app.
• AZURE_TENANT_ID → Il valore dell'ID del tenant.
• AZURE_CLIENT_SECRET → Password/credenziali generate per l'app.

AZURE_CLIENT_ID=00001111-aaaa-2222-bbbb-3333cccc4444
AZURE_TENANT_ID=aaaabbbb-0000-cccc-1111-dddd2222eeee
AZURE_CLIENT_SECRET=Ee5Ff~6Gg7.-Hh8Ii9Jj0Kk1Ll2Mm3_Nn4Oo5Pp6

Infine, nel codice di avvio per l'applicazione, utilizzare la libreria python-dotenv per leggere all'avvio le variabili di ambiente dal file .env.

from dotenv import load_dotenv

if ( os.environ['ENVIRONMENT'] == 'development'):
    print("Loading environment variables from .env file")
    load_dotenv(".env")

Per autenticare gli oggetti client di Azure SDK in Azure, l'applicazione deve usare la DefaultAzureCredential classe del azure.identity pacchetto. In questo scenario, DefaultAzureCredential rileverà le variabili di ambiente AZURE_CLIENT_ID, AZURE_TENANT_ID e AZURE_CLIENT_SECRET se impostate, leggerà tali variabili per ottenere le informazioni sull'entità servizio dell'applicazione per connettersi ad Azure.

Per iniziare, aggiungere il pacchetto azure.identity all'applicazione.

pip install azure-identity

Successivamente, per qualsiasi codice Python che crea un oggetto client Azure SDK nell'app, è necessario:

1. Importare la DefaultAzureCredential classe dal azure.identity modulo.
2. Creare un oggetto DefaultAzureCredential.
3. Passare l'oggetto DefaultAzureCredential al costruttore dell'oggetto client di Azure SDK.

Un esempio è illustrato nel segmento di codice seguente.

from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient

# Acquire a credential object
token_credential = DefaultAzureCredential()

blob_service_client = BlobServiceClient(
        account_url="https://<my_account_name>.blob.core.windows.net",
        credential=token_credential)