Condividi tramite

Autenticare le app .NET nei servizi di Azure durante lo sviluppo locale usando i principal di servizio

  • Articolo

Durante lo sviluppo locale, le applicazioni devono eseguire l'autenticazione in Azure per accedere a vari servizi di Azure. Due approcci comuni per l'autenticazione locale sono usare un account sviluppatore o un'entità di servizio. Questo articolo spiega come usare un principale del servizio applicativo. Nelle sezioni seguenti si apprenderà:

  • Come registrare un'applicazione con Microsoft Entra per creare un principal del servizio
  • Come usare i gruppi di Entra di Microsoft 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 principali di servizio dedicati dell'applicazione consente di rispettare il principio del privilegio minimo per l'accesso alle risorse di Azure. Le autorizzazioni sono limitate ai requisiti specifici dell'app durante lo sviluppo, impedendo l'accesso accidentale alle risorse di 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.

Diagramma che mostra come un'app .NET locale usa le credenziali dello sviluppatore per connettersi ad Azure usando gli strumenti di sviluppo installati localmente.

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à di Azure legge queste variabili di ambiente per autenticare l'app nelle risorse di Azure necessarie.

Registrare l'app in Azure

Gli oggetti principal del servizio vengono creati tramite una registrazione dell'app in Azure usando il portale di Azure o Azure CLI.

  1. Nel portale di Azure, utilizzare la barra di ricerca per accedere alla pagina Registrazioni app.

  2. Nella pagina registrazioni dell'app , selezionare + Nuova registrazione.

  3. 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à.

  4. Selezionare Registra per registrare l'app e creare l'entità servizio.

    Screenshot che mostra come creare una registrazione dell'app nel portale di Azure.

  5. 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.

  6. Selezionare Aggiungi un certificato o un segreto per configurare le credenziali per l'app.

  7. Nella pagina Certificati & segreti, seleziona + Nuovo segreto del client.

  8. 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 Aggiungi per aggiungere il segreto.

  9. 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.

Creare un gruppo Microsoft Entra per lo sviluppo locale

Per lo sviluppo locale, creare un gruppo Microsoft Entra per racchiudere i ruoli (autorizzazioni) necessari all'applicazione, invece di assegnare i ruoli ai singoli oggetti principale di 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, deve essere aggiunto solo al gruppo dell'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.

  1. Vai alla pagina di panoramica ID Entra di Microsoft nel portale di Azure.

  2. Selezionare Tutti i gruppi dal menu a sinistra.

  3. Nella pagina Gruppi , selezionare Nuovo gruppo .

  4. Nella pagina Nuovo gruppo, compila i seguenti campi del modulo:

    • Tipo di gruppo: selezionare Security.
    • 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.

    Screenshot che mostra come creare un gruppo nel portale di Azure.

  5. Seleziona il link Nessun membro selezionato nella sezione Membri per aggiungere membri al gruppo.

  6. Nel pannello a comparsa che si apre, cercare l'entità servizio creata in precedenza e selezionarla dai risultati filtrati. Scegliere il pulsante Seleziona nella parte inferiore del pannello per confermare la selezione.

  7. 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.

Assegnare ruoli al gruppo

Successivamente, determinare i ruoli (autorizzazioni) necessari per l'app in base alle risorse e assegnare tali ruoli al gruppo 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 di Azure in un singolo gruppo di risorse.

  1. Nel portale di Azure passare alla pagina Panoramica del gruppo di risorse che contiene l'app.

  2. Selezionare controllo di accesso (IAM) dal menu di navigazione a sinistra.

  3. 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.

  4. Nella scheda Ruolo, usare la casella di ricerca per individuare il ruolo da assegnare. Selezionare il ruolo e quindi scegliere Avanti.

  5. Nella scheda membri:

    • Per assegnare l'accesso al valore di , selezionare utente, gruppo o principale di servizio.
    • Per il valore membri , scegliere + Seleziona membri per aprire il riquadro a comparsa Seleziona membri.
    • Cercare il gruppo 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.

    Screenshot che mostra come assegnare un ruolo al gruppo Microsoft Entra.

  6. Nella scheda Rivedi e assegna, seleziona Rivedi e assegna, nella parte inferiore della pagina.

Impostare le variabili di ambiente dell'app

In fase di esecuzione, alcune credenziali della libreria di identità di Azure , ad esempio DefaultAzureCredential, EnvironmentCredentiale ClientSecretCredential, cercano le informazioni sull'entità servizio per convenzione nelle variabili di ambiente. Esistono diversi modi per configurare le variabili di ambiente quando si usa .NET, a seconda degli strumenti e dell'ambiente.

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

  • AZURE_CLIENT_ID: usato per identificare l'app registrata in Azure.
  • AZURE_TENANT_ID: ID del tenant di Microsoft Entra.
  • AZURE_CLIENT_SECRET: credenziali segrete generate per l'app.

In Visual Studio le variabili di ambiente possono essere impostate nel file launchsettings.json nella cartella Properties 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.

"profiles": {
    "SampleProject": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "https://localhost:7177;http://localhost:5177",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "AZURE_CLIENT_ID": "<your-client-id>",
        "AZURE_TENANT_ID":"<your-tenant-id>",
        "AZURE_CLIENT_SECRET": "<your-client-secret>"
      }
    },
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "AZURE_CLIENT_ID": "<your-client-id>",
        "AZURE_TENANT_ID":"<your-tenant-id>",
        "AZURE_CLIENT_SECRET": "<your-client-secret>"
      }
    }
  }

Eseguire l'autenticazione ai servizi di Azure dall'app

La della libreria di identità di Azure fornisce varie credenziali, ovvero implementazioni di TokenCredential adattate al supporto di diversi scenari e flussi di autenticazione di Microsoft Entra. I passaggi successivi illustrano come usare ClientSecretCredential quando si utilizzano i principali del servizio a livello locale e nell'ambiente di produzione.

Implementare il codice

Aggiungere il pacchetto Azure.Identity. In un progetto ASP.NET Core installare anche il pacchetto Microsoft.Extensions.Azure:

In un terminale di propria scelta passare alla directory del progetto dell'applicazione ed eseguire i comandi seguenti:

dotnet add package Azure.Identity
dotnet add package Microsoft.Extensions.Azure

È possibile accedere ai servizi di Azure usando classi client specializzate dalle varie librerie client di Azure SDK. Queste classi e i tuoi servizi personalizzati devono essere registrati per l'iniezione delle dipendenze in modo che possano essere utilizzati in tutta l'app. In Program.cs, segui i passaggi seguenti per configurare una classe client per l'iniezione delle dipendenze e l'autenticazione basata su token.

  1. Includere gli spazi dei nomi Azure.Identity e Microsoft.Extensions.Azure tramite direttive using.
  2. Registrare il client del servizio Azure utilizzando il metodo di estensione corrispondente con prefisso Add.
  3. Configurare ClientSecretCredential con tenantId, clientIde clientSecret.
  4. Passare l'istanza di ClientSecretCredential al metodo UseCredential.
builder.Services.AddAzureClients(clientBuilder =>
{
    var tenantId = Environment.GetEnvironmentVariable("AZURE_TENANT_ID");
    var clientId = Environment.GetEnvironmentVariable("AZURE_CLIENT_ID");
    var clientSecret = Environment.GetEnvironmentVariable("AZURE_CLIENT_SECRET");

    clientBuilder.AddBlobServiceClient(
        new Uri("https://<account-name>.blob.core.windows.net"));

    clientBuilder.UseCredential(new ClientSecretCredential(tenantId, clientId, clientSecret));
});

Un'alternativa al metodo UseCredential consiste nel fornire direttamente le credenziali al client del servizio:

var tenantId = Environment.GetEnvironmentVariable("AZURE_TENANT_ID");
var clientId = Environment.GetEnvironmentVariable("AZURE_CLIENT_ID");
var clientSecret = Environment.GetEnvironmentVariable("AZURE_CLIENT_SECRET");

builder.Services.AddSingleton<BlobServiceClient>(_ =>
    new BlobServiceClient(
        new Uri("https://<account-name>.blob.core.windows.net"),
        new ClientSecretCredential(tenantId, clientId, clientSecret)));