Verifiëren bij Azure-resources vanuit .NET-apps die on-premises worden gehost

Artikel
03/22/2025

Apps die buiten Azure worden gehost, zoals on-premises of in een datacenter van derden, moeten een service-principal voor toepassingen gebruiken via Microsoft Entra ID voor verificatie bij Azure-services. In de volgende secties leert u het volgende:

Een toepassing registreren bij Microsoft Entra om een service-principal te maken
Rollen toewijzen aan bereikmachtigingen
Verifiëren met behulp van een service-principal vanuit uw app-code

Met behulp van service-principals voor toegewezen toepassingen kunt u voldoen aan het principe van minimale bevoegdheden bij het openen van Azure-resources. Machtigingen zijn beperkt tot de specifieke vereisten van de app tijdens de ontwikkeling, waardoor onbedoelde toegang tot Azure-resources wordt voorkomen die zijn bedoeld voor andere apps of services. Deze aanpak helpt ook problemen te voorkomen wanneer de app naar productie wordt verplaatst door ervoor te zorgen dat deze niet te veel bevoegdheden heeft in de ontwikkelomgeving.

Er moet een andere app-registratie worden gemaakt voor elke omgeving waarin de app wordt gehost. Hierdoor kunnen omgevingsspecifieke resourcemachtigingen worden geconfigureerd voor elke service-principal en ervoor zorgen dat een app die in één omgeving is geïmplementeerd, niet praat met Azure-resources die deel uitmaken van een andere omgeving.

De app registreren in Azure

Toepassingsservice-principalobjecten worden gemaakt via een app-registratie in Azure met behulp van Azure Portal of Azure CLI.

Azure portal
Azure CLI

Gebruik de zoekbalk in Azure Portal om naar de pagina App-registraties te gaan.
Op de pagina App-registraties, selecteer + Nieuwe registratie.
Op de pagina Een toepassing registreren:
- Voer voor het veld Naam een beschrijvende waarde in die de naam van de app en de doelomgeving bevat.
- Selecteer voor de Ondersteunde accounttypenalleen Accounts in deze organisatiedirectory (alleen Microsoft Customer Led - Enkele tenant)of welke optie het beste past bij uw vereisten.
Selecteer Registreren om uw app te registreren en de service-principal te maken.
Kopieer op de pagina App-registratie voor uw app de toepassing-id (client) en de directory-id (tenant), en plak deze op een tijdelijke locatie voor later gebruik in de configuratie van uw app-code.
Selecteer Een certificaat of geheim toevoegen om referenties voor uw app in te stellen.
Op de pagina Certificaten en geheimen, selecteer + nieuwe clientsleutel.
Voeg in het een clientgeheim toe flyoutvenster dat wordt geopend:
- Voer voor de Descriptioneen waarde in van Current.
- Voor de verloopt waarde, laat u de standaard aanbevolen waarde van 180 dagen staan.
- Selecteer Toevoegen om het geheim toe te voegen.
Kopieer op de pagina Certificaten & geheimen de eigenschap Waarde van het clientgeheim voor gebruik in een toekomstige stap.

Notitie

De waarde van het clientgeheim wordt slechts eenmaal weergegeven nadat de app-registratie is gemaakt. U kunt meer clientgeheimen toevoegen zonder dit clientgeheim ongeldig te maken, maar u kunt deze waarde niet opnieuw weergeven.

Azure CLI-opdrachten kunnen worden uitgevoerd in de Azure Cloud Shell- of op een werkstation waarop de Azure CLI is geïnstalleerd.

Gebruik de opdracht az ad sp create-for-rbac om een nieuwe appregistratie en service principal voor de app te maken.

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

De uitvoer van deze opdracht lijkt op de volgende JSON:

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

Kopieer deze uitvoer naar een tijdelijk bestand in een teksteditor, omdat u deze waarden in een toekomstige stap nodig hebt.

Notitie

De waarde van het clientgeheim wordt slechts eenmaal weergegeven nadat de app-registratie is gemaakt. U kunt meer clientgeheimen toevoegen zonder dit clientgeheim ongeldig te maken, maar u kunt deze waarde niet opnieuw weergeven.

Rollen toewijzen aan de service-principal van de toepassing

Bepaal vervolgens welke rollen (machtigingen) uw app nodig heeft voor welke resources en wijs deze rollen toe aan de service-principal die u hebt gemaakt. Rollen kunnen worden toegewezen op het niveau van een resource, resourcegroep of abonnement. In dit voorbeeld ziet u hoe u rollen toewijst binnen het bereik van de resourcegroep, omdat de meeste apps al hun Azure-resources groeperen in één resourcegroep.

Azure Portal
Azure CLI

Navigeer in Azure Portal naar de pagina Overzicht van de resourcegroep die uw app bevat.
Selecteer Toegangsbeheer (IAM) in de linker navigatie.
Selecteer op de pagina Toegangsbeheer (IAM) + toevoegen en kies vervolgens Roltoewijzing toevoegen in de vervolgkeuzelijst. De pagina Roltoewijzing toevoegen bevat verschillende tabbladen voor het configureren en toewijzen van rollen.
Gebruik op het tabblad Rol het zoekvak om de rol te vinden die u wilt toewijzen. Selecteer de rol en kies vervolgens Volgende.
Op het tabblad Leden:
- Voor de Toegang tot waarde toewijzen, selecteert u gebruiker, groep of service-principal.
- Kies voor de waarde Leden, selecteer + Leden selecteren om het flyout-deelvenster Leden selecteren te openen.
- Zoek naar de service principal die je eerder hebt gemaakt en selecteer deze in de gefilterde resultaten. Kies Selecteer om de groep te selecteren en het flyoutdeelvenster te sluiten.
- Selecteer Beoordelen + toewijzen onderaan het Leden tabblad.
Op het tabblad Controleren en toewijzen, selecteer onderaan de pagina Controleren en toewijzen.

Gebruik de opdracht az role definition list om de namen op te halen van de rollen waaraan een service-principal kan worden toegewezen:
```
az role definition list \
    --query "sort_by([].{roleName:roleName, description:description}, &roleName)" \
    --output table
```
Gebruik de opdracht az role assignment create om een rol aan een service-principal van een applicatie toe te wijzen.
```
az role assignment create \
 --assignee "<app-Id>" \
 --role "<role-name>" \
 --resource-group "<resource-group-name>"
```
Zie Azure-rollen toewijzen met behulp van de Azure CLI voor meer informatie over het toewijzen van machtigingen op resource- of abonnementsniveau met behulp van de Azure CLI.

De omgevingsvariabelen van de app instellen

Tijdens runtime zoeken bepaalde referenties uit de Azure Identity-bibliotheek, zoals DefaultAzureCredential, EnvironmentCredentialen ClientSecretCredential, naar informatie over de service-principal in de omgevingsvariabelen. Er zijn meerdere manieren om omgevingsvariabelen te configureren wanneer u met .NET werkt, afhankelijk van uw hulpprogramma's en omgeving.

Configureer, ongeacht de methode die u kiest, de volgende omgevingsvariabelen voor een service-principal:

AZURE_CLIENT_ID: wordt gebruikt om de geregistreerde app in Azure te identificeren.
AZURE_TENANT_ID: de id van de Microsoft Entra-tenant.
AZURE_CLIENT_SECRET: de geheime referentie die is gegenereerd voor de app.

In Visual Studio kunnen omgevingsvariabelen worden ingesteld in het launchsettings.json bestand in de map Properties van uw project. Deze waarden worden automatisch opgehaald wanneer de app wordt gestart. Deze configuraties reizen echter niet met uw app tijdens de implementatie, dus u moet omgevingsvariabelen instellen in uw doelhostingomgeving.

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

In Visual Studio Code kunnen omgevingsvariabelen worden ingesteld in het launch.json-bestand van uw project. Deze waarden worden automatisch opgehaald wanneer de app wordt gestart. Deze configuraties reizen echter niet met uw app tijdens de implementatie, dus u moet omgevingsvariabelen instellen in uw doelhostingomgeving.

"configurations": [
{
    "env": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "AZURE_CLIENT_ID": "<your-client-id>",
        "AZURE_TENANT_ID":"<your-tenant-id>",
        "AZURE_CLIENT_SECRET": "<your-client-secret>"
    }
}

U kunt omgevingsvariabelen voor Windows instellen vanaf de opdrachtregel. De waarden zijn echter toegankelijk voor alle apps die op dat besturingssysteem worden uitgevoerd en kunnen conflicten veroorzaken, dus wees voorzichtig met deze aanpak. Omgevingsvariabelen kunnen worden ingesteld op gebruikers- of systeemniveau.

# Set user environment variables
setx ASPNETCORE_ENVIRONMENT "Development"
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 ASPNETCORE_ENVIRONMENT "Development" /m
setx AZURE_CLIENT_ID "<your-client-id>" /m
setx AZURE_TENANT_ID "<your-tenant-id>" /m
setx AZURE_CLIENT_SECRET "<your-client-secret>" /m

PowerShell kan ook worden gebruikt om omgevingsvariabelen in te stellen op gebruikers- of systeemniveau:

# Set user environment variables
[Environment]::SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development", "User")
[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("ASPNETCORE_ENVIRONMENT", "Development", "Machine")
[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")

Verifiëren bij Azure-services vanuit uw app

De Azure Identity-bibliotheek biedt verschillende referenties: implementaties van TokenCredential aangepast aan de ondersteuning van verschillende scenario's en Microsoft Entra-verificatiestromen. In de volgende stappen wordt gedemonstreerd hoe u ClientSecretCredential kunt gebruiken bij het lokaal en in productie werken met service-principals.

De code implementeren

Voeg het pakket Azure.Identity toe. Installeer in een ASP.NET Core-project ook het pakket Microsoft.Extensions.Azure:

Opdrachtregel
NuGet Package Manager

Navigeer in een terminal van uw keuze naar de projectmap van de toepassing en voer de volgende opdrachten uit:

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

Azure-services worden geopend met behulp van gespecialiseerde clientklassen uit de verschillende Azure SDK-clientbibliotheken. Deze klassen en uw eigen aangepaste services moeten worden geregistreerd voor afhankelijkheidsinjectie, zodat ze in uw app kunnen worden gebruikt. Voer in Program.csde volgende stappen uit om een clientklasse te configureren voor afhankelijkheidsinjectie en verificatie op basis van tokens:

Neem de Azure.Identity en Microsoft.Extensions.Azure naamruimten op via using instructies.
Registreer de Azure-service-client met behulp van de bijbehorende Add-voorvoegselextensiemethode.
Stel ClientSecretCredential in met de tenantId, clientIden clientSecret.
Geef het ClientSecretCredential exemplaar door aan de methode 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));
});

Een alternatief voor de UseCredential-methode is om de referentie direct aan de serviceclient op te geven.

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)));

Delen via