Condividi tramite

Autenticare le app C++ nei servizi di Azure durante lo sviluppo locale usando le entità servizio

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 C++ locale usa un'entità servizio 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à 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 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 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.

Creare un gruppo Microsoft Entra per lo sviluppo locale

Creare un gruppo Microsoft Entra per incapsulare i ruoli (autorizzazioni) necessari per lo sviluppo locale dell'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.

  1. Passare alla pagina di panoramica di Microsoft Entra ID 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. Selezionare il collegamento Nessun membro selezionato in Membri per aggiungere membri al gruppo.

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

  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 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 .
    • 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 selezionare 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 informazioni sull'entità servizio per convenzione nelle variabili di ambiente. Esistono diversi modi per configurare le variabili di ambiente a seconda degli strumenti e dell'ambiente. È possibile creare un .env file o usare le variabili di ambiente di sistema per archiviare queste credenziali in locale durante lo sviluppo.

Indipendentemente dall'approccio scelto, impostare le variabili di ambiente seguenti per un'entità servizio:

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

Per le applicazioni C++, è possibile impostare queste variabili di ambiente in diversi modi. È possibile caricarli da un .env file nel codice oppure impostarli nell'ambiente di sistema. Gli esempi seguenti illustrano come impostare le variabili di ambiente in shell diverse:

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

Eseguire l'autenticazione ai servizi di Azure dall'app

La 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. Usare la classe ClientSecretCredential quando si usano i principali di servizio in locale e nell'ambiente di produzione. In questo scenario, ClientSecretCredential legge le variabili AZURE_CLIENT_IDdi ambiente , AZURE_TENANT_IDe AZURE_CLIENT_SECRET per ottenere le informazioni sull'entità servizio dell'applicazione per connettersi ad Azure.

  1. Aggiungere il pacchetto azure-identity-cpp all'applicazione usando vcpkg.

    vcpkg add port azure-identity-cpp

  2. Aggiungere le righe seguenti nel file CMake:

    find_package(azure-identity-cpp CONFIG REQUIRED)
target_link_libraries(<your project name> PRIVATE Azure::azure-identity)

  3. Per qualsiasi codice C++ che crea un oggetto client azure SDK nell'app:

    1. Includere l'intestazione azure/identity.hpp .
    2. Crea un'istanza di ClientSecretCredential.
    3. Passare l'istanza di ClientSecretCredential al costruttore client di Azure SDK.

    Un esempio è illustrato nel segmento di codice seguente:

    #include <azure/identity.hpp>
#include <azure/storage/blobs.hpp>
#include <iostream>
#include <memory>

// The following environment variables must be set before running the sample.
// * AZURE_TENANT_ID: Tenant ID for the Azure account.
// * AZURE_CLIENT_ID: The Client ID to authenticate the request.
// * AZURE_CLIENT_SECRET: The client secret.
std::string GetTenantId() { return std::getenv("AZURE_TENANT_ID"); }
std::string GetClientId() { return std::getenv("AZURE_CLIENT_ID"); }
std::string GetClientSecret() { return std::getenv("AZURE_CLIENT_SECRET"); }

int main() {
    try {
        // Create a credential - this will automatically read the environment variables
        // AZURE_CLIENT_ID, AZURE_TENANT_ID, and AZURE_CLIENT_SECRET
        auto credential = std::make_shared<Azure::Identity::ClientSecretCredential>(GetTenantId(), GetClientId(), GetClientSecret());

        // Create a client for the specified storage account
        std::string accountUrl = "https://<replace_with_your_storage_account_name>.blob.core.windows.net/";
        Azure::Storage::Blobs::BlobServiceClient blobServiceClient(accountUrl, credential);

        // Get a reference to a container
        std::string containerName = "sample-container";
        auto containerClient = blobServiceClient.GetBlobContainerClient(containerName);

        // Get a reference to a blob
        std::string blobName = "sample-blob";
        auto blobClient = containerClient.GetBlobClient(blobName);

        // TODO: perform some action with the blob client
        // auto downloadResult = blobClient.DownloadTo("path/to/local/file");

        std::cout << "Successfully authenticated and created Azure clients." << std::endl;

    } catch (const std::exception& ex) {
        std::cout << "Exception: " << ex.what() << std::endl;
        return 1;
    }

    return 0;
}
  • Last updated on