Autenticare applicazioni Python ai servizi di Azure durante lo sviluppo locale usando i principali del servizio

Durante lo sviluppo locale, le applicazioni devono eseguire l'autenticazione per Azure per accedere a vari servizi Azure. Questo articolo illustra come usare un principale del servizio dell'applicazione come uno dei due approcci più comuni per l'autenticazione locale.

Come registrare un'applicazione con Microsoft Entra per creare un principal del servizio
Come usare i gruppi di Microsoft Entra per gestire in modo efficiente le autorizzazioni
Come assegnare ruoli alle autorizzazioni di ambito
Come eseguire l'autenticazione usando un'entità servizio dal codice dell'app

L'uso di service principal dedicati consente di rispettare il principio del minimo privilegio quando si accede alle risorse di Azure. Le autorizzazioni sono limitate ai requisiti specifici dell'app durante lo sviluppo, impedendo l'accesso accidentale alle risorse Azure destinate ad altre app o servizi. Questo approccio consente anche di evitare problemi quando l'app viene spostata nell'ambiente di produzione assicurandosi che non sia con privilegi elevati nell'ambiente di sviluppo.

Un diagramma che illustra come un'app in esecuzione in un ambiente di sviluppo locale ottiene l'entità servizio dell'applicazione da un file .env e quindi utilizza tale identità per connettersi alle risorse di Azure.

Quando l'app viene registrata in Azure, viene creata un'entità servizio dell'applicazione. Per lo sviluppo locale:

Creare una registrazione separata dell'app per ogni sviluppatore che lavora sull'applicazione per garantire che ciascun sviluppatore abbia il proprio principale del servizio applicazione, evitando così la necessità di condividere le credenziali.
Creare una registrazione dell'app separata per ogni app per limitare le autorizzazioni dell'app solo a ciò che è necessario.

Durante lo sviluppo locale, le variabili di ambiente vengono impostate con l'identità dell'entità servizio dell'applicazione. La libreria di identità Azure legge queste variabili di ambiente per autenticare l'app nelle risorse Azure necessarie.

Registrare l'app in Azure

Gli oggetti entità servizio principale dell'applicazione vengono creati tramite la registrazione di un'app in Azure usando il portale di Azure o l'Azure CLI.

Portale Azure
Azure CLI

Nel portale di Azure usare la barra di ricerca per passare alla pagina App registrations.
Nella pagina App registrations selezionare + Nuova registrazione.
Nella pagina Registrare un'applicazione:
- Per il campo Nome immettere un valore descrittivo che include il nome dell'app e l'ambiente di destinazione.
- Per i tipi di account supportati , selezionare Account solo in questa directory organizzativa (solo Microsoft Customer Led - tenant singolo), o l'opzione che più risponde alle proprie necessità.
Selezionare Registra per registrare l'app e creare l'entità servizio.

Schermata che mostra come creare una registrazione dell'applicazione nel portale Azure.
Nella pagina registrazione app per l'app copiare l'ID applicazione (client) e ID directory (tenant) e incollarli in un percorso temporaneo per usarli in un secondo momento nelle configurazioni del codice dell'app.
Selezionare Aggiungi un certificato o un segreto per configurare le credenziali per l'app.
Nella pagina Certificati & segreti, seleziona + Nuovo segreto del client.
Nel pannello a comparsa Aggiungi un client segreto che si apre:
- Per la Descrizione, immettere un valore current.
- Per il valore Scadenza di , lasciare il valore predefinito consigliato di 180 giorni.
- Selezionare Aggiungere per aggiungere il segreto.
Nella pagina certificati & segreti copiare la proprietà valore del segreto client da usare in un passaggio futuro.

Nota

Il valore del segreto client viene visualizzato una sola volta dopo la creazione della registrazione dell'app. È possibile aggiungere altri segreti client senza invalidare questo segreto client, ma non è possibile visualizzare di nuovo questo valore.

I comandi di Azure CLI possono essere eseguiti nel Azure Cloud Shell o su una workstation con Azure CLI installata.

Usa il comando az ad sp create-for-rbac per creare una nuova registrazione dell'applicazione e un principale del servizio per l'applicazione.

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

L'output di questo comando è simile al codice JSON seguente:

{
  "appId": "00000000-0000-0000-0000-000000000000",
  "displayName": "<service-principal-name>",
  "password": "abcdefghijklmnopqrstuvwxyz",
  "tenant": "11111111-1111-1111-1111-111111111111"
}

Copiare questo output in un file temporaneo in un editor di testo, perché questi valori saranno necessari in un passaggio futuro.

Nota

Il valore del segreto client viene visualizzato una sola volta dopo la creazione della registrazione dell'app. È possibile aggiungere altri segreti client senza invalidare questo segreto client, ma non è possibile visualizzare di nuovo questo valore.

Creare un gruppo di Microsoft Entra per lo sviluppo locale

Nell'ambito dello sviluppo locale, si consiglia di creare un gruppo Microsoft Entra per incapsulare i ruoli (autorizzazioni) necessari per l'app, anziché assegnare i ruoli a singoli oggetti principali del servizio. Questo approccio offre i vantaggi seguenti:

Ogni sviluppatore ha gli stessi ruoli assegnati a livello di gruppo.
Se è necessario un nuovo ruolo per l'app, è sufficiente aggiungerlo al gruppo 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.

Portale Azure
Azure CLI

Passare alla pagina di panoramica Microsoft Entra ID nel portale di Azure.
Selezionare Tutti i gruppi dal menu a sinistra.
Nella pagina Gruppi selezionare Nuovo gruppo.
Nella pagina Nuovo gruppo, compila i seguenti campi del modulo:
- Tipo di gruppo: selezionare Sicurezza.
- Nome gruppo: immettere un nome per il gruppo che include un riferimento al nome dell'app o dell'ambiente.
- Descrizione gruppo: immettere una descrizione che spiega lo scopo del gruppo.
Selezionare il collegamento Nessun membro selezionato in Membri per aggiungere membri al gruppo.
Nel pannello fluttuante che si apre, cercare il service principal creato in precedenza e selezionarlo nei risultati filtrati. Scegliere il pulsante Seleziona nella parte inferiore del pannello per confermare la selezione.
Selezionare Crea nella parte inferiore della pagina Nuovo gruppo per creare il gruppo e tornare alla pagina Tutti i gruppi . Se il nuovo gruppo non è elencato, attendere un attimo e aggiornare la pagina.

Usare il comando az ad group create per creare gruppi in Microsoft Entra ID.
```
az ad group create \
    --display-name <group-name> \
    --mail-nickname <group-mail-nickname> \
    --description <group-description>
```
I parametri --display-name e --mail-nickname sono obbligatori. Il nome assegnato al gruppo deve essere basato sul nome e sull'ambiente dell'app per indicare lo scopo del gruppo.
Per aggiungere membri al gruppo, è necessario l'ID oggetto del principale del servizio dell'applicazione, che è diverso dall'ID applicazione. Usare il comando az ad sp list per elencare i principali del servizio disponibili.
```
az ad sp list \
    --filter "startswith(displayName, '<group-name>')" \
    --query "[].{objectId:id, displayName:displayName}"
```
Il --filter parametro accetta filtri in stile OData e può essere usato per filtrare l'elenco come illustrato. Il parametro --query limita l'output solo alle colonne di interesse.

Usare il comando az ad group member add per aggiungere membri al gruppo:

az ad group member add \
    --group <group-name> \
    --member-id <object-id>

Assegnare ruoli al gruppo

Determinare quindi i ruoli (autorizzazioni) necessari per le risorse necessarie per l'app e assegnare tali ruoli al gruppo di Microsoft Entra creato. Ai gruppi può essere assegnato un ruolo nell'ambito della risorsa, del gruppo di risorse o della sottoscrizione. Questo esempio illustra come assegnare ruoli nell'ambito del gruppo di risorse, poiché la maggior parte delle app raggruppa tutte le risorse Azure in un singolo gruppo di risorse.

Portale Azure
Azure CLI

Nel portale di Azure passare alla pagina Panoramica del gruppo di risorse che contiene l'app.
Selezionare Access control (IAM) dal menu di navigazione a sinistra.
Nella pagina Controllo di accesso (IAM) selezionare + Aggiungi e quindi scegliere Aggiungi assegnazione di ruolo dal menu a discesa. Nella pagina Aggiungi assegnazione di ruolo sono disponibili diverse schede per configurare e assegnare ruoli.
Nella scheda Ruolo usare la casella di ricerca per individuare il ruolo da assegnare. Selezionare il ruolo e quindi scegliere Avanti.
Nella scheda Membri :
- Per il valore Assegna l'accesso a, selezionare Utente, gruppo o entità servizio.
- Per il valore Membri scegliere + Seleziona membri per aprire il pannello a comparsa Seleziona membri .
- Cercare il gruppo di Microsoft Entra creato in precedenza e selezionarlo nei risultati filtrati. Scegliere Selezionare per selezionare il gruppo e chiudere il pannello a comparsa.
- Selezionare Rivedi e assegna nella parte inferiore della scheda Membri .
Uno screenshot che mostra come assegnare un ruolo al gruppo Microsoft Entra.
Nella scheda Rivedi e assegna selezionare Rivedi e assegna nella parte inferiore della pagina.

Usare il comando az role definition list per ottenere i nomi dei ruoli a cui può essere assegnato un gruppo Microsoft Entra o un principale del servizio.
```
az role definition list \
    --query "sort_by([].{roleName:roleName, description:description}, &roleName)" \
    --output table
```
Usare il comando az role assignment create per assegnare un ruolo al gruppo di Microsoft Entra creato:
```
az role assignment create \
    --assignee "<group-object-Id>" \
    --role "<role-name>" \
    --resource-group "<resource-group-name>"
```
Per informazioni sull'assegnazione di autorizzazioni a livello di risorsa o sottoscrizione tramite il Azure CLI, vedere Assegnare ruoli Azure usando il Azure CLI.

Impostare le variabili di ambiente dell'app

In fase di esecuzione, alcune credenziali della libreria Identity Azure, ad esempio DefaultAzureCredential, EnvironmentCredential e ClientSecretCredential, cercano le informazioni sull'entità servizio secondo convenzioni nelle variabili di ambiente. Esistono diversi modi per configurare le variabili di ambiente quando si usano Python, a seconda degli strumenti e dell'ambiente.

Indipendentemente dall'approccio scelto, configurare le seguenti variabili di ambiente per un service principal:

AZURE_CLIENT_ID: ID applicazione dell'app registrata in Azure.
AZURE_TENANT_ID: ID del tenant di Microsoft Entra.
AZURE_CLIENT_SECRET: la credenziale del segreto client per l'app.

Poiché la maggior parte degli sviluppatori lavora su più applicazioni, è consigliabile usare un pacchetto come python-dotenv per accedere alle variabili di ambiente da un .env file archiviato nella directory dell'applicazione durante lo sviluppo. Questo approccio definisce l'ambito delle variabili di ambiente in modo che solo questa applicazione possa usarle.

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

Per usare il python-dotenv pacchetto, 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:

AZURE_CLIENT_ID=<your-client-id>
AZURE_TENANT_ID=<your-tenant-id>
AZURE_CLIENT_SECRET=<your-client-secret>

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

from dotenv import load_dotenv

load_dotenv()

In Visual Studio Code le variabili di ambiente possono essere impostate nel file launch.json del progetto. Questi valori vengono estratti automaticamente all'avvio dell'app. Tuttavia, queste configurazioni non viaggiano con l'app durante la distribuzione, quindi è necessario configurare le variabili di ambiente nell'ambiente di hosting di destinazione.

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Current File",
            "type": "debugpy",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal",
            "env": {
                "AZURE_CLIENT_ID": "<your-client-id>",
                "AZURE_TENANT_ID": "<your-tenant-id>",
                "AZURE_CLIENT_SECRET": "<your-client-secret>"
            }
        }
    ]
}

È possibile impostare le variabili di ambiente per Windows dalla riga di comando. Tuttavia, i valori sono accessibili a tutte le app in esecuzione nel sistema operativo e potrebbero causare conflitti, quindi prestare attenzione a questo approccio. Le variabili di ambiente possono essere impostate a livello di utente o di sistema.

setx AZURE_CLIENT_ID "<your-client-id>"
setx AZURE_TENANT_ID "<your-tenant-id>"
setx AZURE_CLIENT_SECRET "<your-client-secret>"

PowerShell può essere usato anche per impostare le variabili di ambiente a livello di utente o di sistema:

[Environment]::SetEnvironmentVariable("AZURE_CLIENT_ID", "<your-client-id>", "User")
[Environment]::SetEnvironmentVariable("AZURE_TENANT_ID", "<your-tenant-id>", "User")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_SECRET", "<your-client-secret>", "User")

Dopo aver eseguito questi comandi, riavviare tutti i terminali aperti o le applicazioni per raccogliere le nuove variabili di ambiente.

export AZURE_CLIENT_ID="<your-client-id>"
export AZURE_TENANT_ID="<your-tenant-id>"
export AZURE_CLIENT_SECRET="<your-client-secret>"

Per rendere persistenti queste variabili di ambiente tra le sessioni del terminale, aggiungere queste righe al file del profilo della shell , ad esempio ~/.bashrc, ~/.zshrco ~/.bash_profile.

Autenticarsi ai servizi di Azure dalla tua app

La libreria azure-identity fornisce varie credentials: implementazioni di TokenCredential adattate al supporto di diversi scenari e flussi di autenticazione Microsoft Entra. I passaggi successivi illustrano come usare ClientSecretCredential quando si usano principali del servizio localmente e in ambiente di produzione.

Implementare il codice

Per iniziare, aggiungere il pacchetto all'applicazione.

pip install azure-identity

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

Importare la ClientSecretCredential classe dal azure.identity modulo.
Importare il os modulo per leggere le variabili di ambiente.
Leggere le variabili di ambiente per ottenere l'ID client, l'ID tenant e il segreto client.
Creare un ClientSecretCredential oggetto passando l'ID tenant, l'ID client e il segreto client.
Passare l'oggetto ClientSecretCredential al costruttore dell'oggetto client Azure SDK.

Un esempio di questo approccio è illustrato nel segmento di codice seguente.

import os
from azure.identity import ClientSecretCredential
from azure.storage.blob import BlobServiceClient

tenant_id = os.environ.get("AZURE_TENANT_ID")
client_id = os.environ.get("AZURE_CLIENT_ID")
client_secret = os.environ.get("AZURE_CLIENT_SECRET")

credential = ClientSecretCredential(tenant_id, client_id, client_secret)

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

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-03-11