Autenticarsi a risorse di Azure da app Java ospitate on-premises

Le applicazioni ospitate all'esterno di Azure, ad esempio in locale o in un data center di terze parti, devono usare un principal di servizio tramite Microsoft Entra ID per autenticarsi ai servizi di Azure. Nelle sezioni seguenti viene illustrato quanto segue:

• Come registrare un'applicazione con Microsoft Entra per creare un'entità servizio.
• Come assegnare ruoli alle autorizzazioni di ambito.
• Come eseguire l'autenticazione usando un'entità servizio dal codice dell'app.

Usando le entità servizio dell'applicazione dedicate, è possibile seguire il principio dei privilegi minimi quando si accede alle risorse Azure. Limitare le autorizzazioni ai requisiti specifici dell'app durante lo sviluppo per impedire l'accesso accidentale alle risorse Azure destinate ad altre app o servizi. Questo approccio consente anche di evitare problemi durante lo spostamento dell'app nell'ambiente di produzione assicurandosi che l'app non sia con privilegi elevati nell'ambiente di sviluppo.

Creare una registrazione dell'app diversa per ogni ambiente in cui si ospita l'app. È possibile configurare autorizzazioni di risorse specifiche dell'ambiente per ogni principale del servizio e assicurarsi che un'app distribuita in un ambiente non acceda alle risorse Azure in un altro ambiente.

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.

Azure

1. Nel portale di Azure usare la barra di ricerca per passare alla pagina App registrations.

2. Nella pagina App registrations 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.

   Schermata che mostra come creare una registrazione dell'applicazione nel portale 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 Descrizione, immettere un valore di Current.
   • Per il valore Expires, lasciare il valore consigliato predefinito di 180 days.
   • Selezionare Aggiungere per aggiungere il segreto.

9. Nella pagina certificati & segreti copiare la proprietà valore del segreto client da usare in un passaggio futuro.

   Annotazioni

   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.

Azure CLI

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

1. 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"
   }
   

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

   Annotazioni

   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.

Assegnare ruoli al principale di servizio dell'applicazione

Successivamente, determinare i ruoli (autorizzazioni) necessari per l'app in base alle risorse e assegnare tali ruoli all'entità servizio creata. I ruoli possono essere assegnati 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.

Azure

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

2. Selezionare Access control (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 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 .
   • Cerca il principale del servizio creato in precedenza e selezionalo dai risultati filtrati. Scegliere Selezionare per selezionare il gruppo e chiudere il pannello a comparsa.
   • Selezionare Rivedi e assegna nella parte inferiore della scheda Membri .

   

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

Azure CLI

1. Usare il comando az role definition list per ottenere i nomi dei ruoli a cui è possibile assegnare un'entità servizio:

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

2. Usare il comando az role assignment create per assegnare un ruolo a un service principal dell'applicazione.

   az role assignment create \
       --assignee "<app-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. Quando si usano Java, è possibile configurare le variabili di ambiente in diversi modi, 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.

Bash

Impostare le variabili di ambiente seguenti. Sostituire i valori segnaposto con i valori effettivi della registrazione dell'app:

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

Per un'applicazione Java in esecuzione come servizio systemd in un server di produzione, definire le variabili di ambiente in un file e farvi riferimento con la direttiva EnvironmentFile nel file di unità di servizio:

[Unit]
Description=Java application service
After=network.target

[Service]
User=app-user
WorkingDirectory=/path/to/java-app
EnvironmentFile=/path/to/java-app/app-environment-variables
ExecStart=/usr/bin/java -jar app.jar

[Install]
WantedBy=multi-user.target

Il file di ambiente deve contenere un elenco di variabili di ambiente con i relativi valori:

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

Visual Studio Code

In Visual Studio Code impostare le variabili di ambiente nel file .vscode/launch.json del progetto. L'app usa automaticamente questi valori all'avvio. 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": [
        {
            "type": "java",
            "name": "Launch App",
            "request": "launch",
            "mainClass": "com.example.App",
            "env": {
                "AZURE_CLIENT_ID": "<your-client-id>",
                "AZURE_TENANT_ID": "<your-tenant-id>",
                "AZURE_CLIENT_SECRET": "<your-client-secret>"
            }
        }
    ]
}

IntelliJ IDEA

Configurare le variabili di ambiente nella configurazione di esecuzione:

1. Selezionare Esegui > Modifica configurazioni....

2. Selezionare la configurazione dell'applicazione.

3. Nel campo Variabili di ambiente aggiungere le variabili:

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

4. Selezionare Applica e quindi OK.

Windows

È possibile impostare le variabili di ambiente per Windows dalla riga di comando. Tuttavia, tutte le app in esecuzione in tale sistema operativo possono accedere ai valori, che potrebbero causare conflitti. Prestare attenzione a questo approccio. È possibile impostare le variabili di ambiente a livello di utente o di sistema.

# Set user environment variables
setx AZURE_CLIENT_ID "<your-client-id>"
setx AZURE_TENANT_ID "<your-tenant-id>"
setx AZURE_CLIENT_SECRET "<your-client-secret>"

# Set system environment variables - requires running as admin
setx AZURE_CLIENT_ID "<your-client-id>" /m
setx AZURE_TENANT_ID "<your-tenant-id>" /m
setx AZURE_CLIENT_SECRET "<your-client-secret>" /m

È anche possibile usare PowerShell per impostare le variabili di ambiente a livello di utente o di sistema:

# Set user environment variables
[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")

# Set system environment variables - requires running as admin
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_ID", "<your-client-id>", "Machine")
[Environment]::SetEnvironmentVariable("AZURE_TENANT_ID", "<your-tenant-id>", "Machine")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_SECRET", "<your-client-secret>", "Machine")

Autenticarsi ai servizi di Azure dalla tua app

La libreria Azure Identity fornisce varie credentials: implementazioni di TokenCredential che supportano diversi scenari e flussi di autenticazione Microsoft Entra. I passaggi seguenti illustrano come usare ClientSecretCredential quando si usano i principali del servizio localmente e in produzione.

Implementare il codice

Aggiungere la azure-identity dipendenza al pom.xml file:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
</dependency>

È possibile accedere ai servizi Azure usando classi client specializzate dalle varie librerie client di Azure SDK. Per qualsiasi codice Java che crea un oggetto client Azure SDK nell'app, seguire questa procedura:

1. Importare la ClientSecretCredentialBuilder classe dal com.azure.identity pacchetto.
2. Creare un ClientSecretCredential oggetto usando ClientSecretCredentialBuilder con tenantId, clientIde clientSecret.
3. Passare l'istanza di ClientSecretCredential al metodo credential del generatore di oggetti client Azure SDK.

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

import com.azure.identity.ClientSecretCredential;
import com.azure.identity.ClientSecretCredentialBuilder;
import com.azure.storage.blob.BlobServiceClient;
import com.azure.storage.blob.BlobServiceClientBuilder;

String tenantId = System.getenv("AZURE_TENANT_ID");
String clientId = System.getenv("AZURE_CLIENT_ID");
String clientSecret = System.getenv("AZURE_CLIENT_SECRET");

ClientSecretCredential credential = new ClientSecretCredentialBuilder()
    .tenantId(tenantId)
    .clientId(clientId)
    .clientSecret(clientSecret)
    .build();

BlobServiceClient blobServiceClient = new BlobServiceClientBuilder()
    .endpoint("https://<account-name>.blob.core.windows.net")
    .credential(credential)
    .buildClient();