Authentifizieren von Python Apps für Azure Dienste während der lokalen Entwicklung mithilfe von Dienstprinzipalen

Während der lokalen Entwicklung müssen sich Anwendungen bei Azure authentifizieren, um auf verschiedene Azure Dienste zuzugreifen. In diesem Artikel wird erläutert, wie Sie einen Anwendungsdienst-Prinzipal als einer von zwei gängigen Ansätzen für die lokale Authentifizierung verwenden.

Registrieren einer Anwendung bei Microsoft Entra zur Erstellung eines Dienstprinzipals
Verwenden von Microsoft Entra Gruppen zum effizienten Verwalten von Berechtigungen
Zuweisung von Rollen zu Bereichsberechtigungen
So authentifizieren Sie sich über einen Dienstprinzipal von Ihrem Anwendungscode aus

Wenn Sie dedizierte Anwendungsdienstprinzipale verwenden, können Sie das Prinzip der geringsten Rechte beim Zugriff auf Azure Ressourcen einhalten. Berechtigungen sind auf die spezifischen Anforderungen der App während der Entwicklung beschränkt und verhindern den versehentlichen Zugriff auf Azure Ressourcen, die für andere Apps oder Dienste vorgesehen sind. Dieser Ansatz hilft auch, Probleme zu vermeiden, wenn die App in die Produktion verschoben wird, indem sichergestellt wird, dass sie in der Entwicklungsumgebung nicht überprivilegiert ist.

Ein Diagramm, das zeigt, wie eine lokal laufende App den Anwendungshauptdienst aus einer .env-Datei erhält und diese Identität dann verwendet, um eine Verbindung zu Azure-Ressourcen herzustellen.

Wenn die App in Azure registriert ist, wird ein Anwendungsdienstprinzipal erstellt. Für die lokale Entwicklung:

Erstellen Sie für jeden Entwickler, der an der App arbeitet, eine eigene App-Registrierung, um sicherzustellen, dass jeder Entwickler seinen eigenen Anwendungsdienst-Prinzipal hat und keine Anmeldedaten austauschen muss.
Erstellen Sie eine separate App-Registrierung für jede App, um die Berechtigungen der App nur auf die erforderlichen Elemente zu beschränken.

Während der lokalen Entwicklung werden Umgebungsvariablen mit der Identität des Anwendungsdienstprinzipals festgelegt. Die Azure Identitätsbibliothek liest diese Umgebungsvariablen vor, um die App bei den erforderlichen Azure Ressourcen zu authentifizieren.

Registrieren der App in Azure

Anwendungsdienstprinzipalobjekte werden über eine App-Registrierung in Azure entweder über das Azure Portal oder Azure CLI erstellt.

Azure Portal
Azure CLI

Verwenden Sie im Azure-Portal die Suchleiste, um zur Seite App registrations zu navigieren.
Wählen Sie auf der Seite App registrations+ Neue Registrierung aus.
Gehen Sie auf der Seite Registrieren einer Anwendung folgendermaßen vor:
- Geben Sie für das Feld Name einen beschreibenden Wert ein, der den App-Namen und die Zielumgebung enthält.
- Wählen Sie unter Unterstützte Kontotypendie Option Nur Konten in diesem Organisationsverzeichnis (nur Microsoft Customer Led - Single Tenant)oder die Option, die Ihren Anforderungen am besten entspricht.
Wählen Sie Registrieren , um Ihre App zu registrieren und den Dienstprinzipal zu erstellen.

Ein Screenshot, der zeigt, wie man eine App-Registrierung im Azure-Portal erstellt.
Kopieren Sie auf der Seite App-Registrierung Ihrer App die Anwendungs-ID (Client-ID) und Verzeichnis-ID (Mandanten-ID) und fügen Sie sie an einem temporären Speicherort ein, um sie später in Ihren App-Codekonfigurationen zu verwenden.
Wählen Sie Zertifikat oder Geheimnis hinzufügen , um Anmeldedaten für Ihre App einzurichten.
Auf der Seite Zertifikate & Geheimnisse wählen Sie + Neues Client-Geheimnis.
In dem Hinzufügen eines Client-Geheimnisses Flyout-Panel, das sich öffnet:
- Für die Beschreibunggeben Sie den Wert Current ein.
- Für den Wert Expires belassen Sie den empfohlenen Standardwert von 180 Tagen.
- Wählen Sie Hinzufügen aus, um das Geheimnis hinzuzufügen.
Kopieren Sie auf der Seite Zertifikate & Geheimnisse die Eigenschaft Wert des Client-Geheimnisses zur Verwendung in einem späteren Schritt.

Hinweis

Der Wert des geheimen Clientschlüssels wird nur einmal angezeigt, nachdem die App-Registrierung erstellt wurde. Sie können weitere geheime Clientschlüssel hinzufügen, ohne diesen geheimen Clientschlüssel ungültig zu machen, aber es gibt keine Möglichkeit, diesen Wert erneut anzuzeigen.

Azure CLI Befehle können im Azure Cloud Shell oder auf einer Arbeitsstation ausgeführt werden, auf der Azure CLI installiert ist.

Verwenden Sie den Befehl az ad sp create-for-rbac , um eine neue App-Registrierung und einen neuen Dienstprinzipal für die App zu erstellen.

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

Die Ausgabe dieses Befehls ähnelt dem folgenden JSON:

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

Kopieren Sie diese Ausgabe in eine temporäre Datei in einem Text-Editor, da Sie diese Werte in einem zukünftigen Schritt benötigen.

Hinweis

Der Wert des geheimen Clientschlüssels wird nur einmal angezeigt, nachdem die App-Registrierung erstellt wurde. Sie können weitere geheime Clientschlüssel hinzufügen, ohne diesen geheimen Clientschlüssel ungültig zu machen, aber es gibt keine Möglichkeit, diesen Wert erneut anzuzeigen.

Erstellen einer Microsoft Entra Gruppe für die lokale Entwicklung

Erstellen Sie eine Microsoft Entra Gruppe, um die Rollen (Berechtigungen) zu kapseln, die die App in der lokalen Entwicklung benötigt, anstatt die Rollen einzelnen Dienstprinzipalobjekten zuzuweisen. Dieser Ansatz bietet die folgenden Vorteile:

Jeder Entwickler hat die gleichen Rollen auf Gruppenebene zugewiesen.
Wenn eine neue Rolle für die App erforderlich ist, muss sie nur der Gruppe für die App hinzugefügt werden.
Wenn ein neuer Entwickler dem Team beitritt, wird ein neuer Anwendungsdienstprinzipal für den Entwickler erstellt und der Gruppe hinzugefügt, um sicherzustellen, dass der Entwickler über die richtigen Berechtigungen für die Arbeit an der App verfügt.

Azure Portal
Azure CLI

Navigieren Sie zur Übersichtsseite Microsoft Entra ID im Azure-Portal.
Wählen Sie im linken Menü "Alle Gruppen " aus.
Wählen Sie auf der Seite "Gruppen " die Option "Neue Gruppe" aus.
Füllen Sie auf der Seite "Neue Gruppe " die folgenden Formularfelder aus:
- Gruppentyp: Wählen Sie Sicherheit aus.
- Gruppenname: Geben Sie einen Namen für die Gruppe ein, die einen Verweis auf den App- oder Umgebungsnamen enthält.
- Gruppenbeschreibung: Geben Sie eine Beschreibung ein, die den Zweck der Gruppe erläutert.
Wählen Sie unter Mitglieder den Link Keine Mitglieder ausgewählt aus, um der Gruppe Mitglieder hinzuzufügen.
Suchen Sie im daraufhin geöffneten Flyoutbereich nach dem zuvor erstellten Dienstprinzipal, und wählen Sie ihn aus den gefilterten Ergebnissen aus. Wählen Sie unten im Bereich die Schaltfläche "Auswählen " aus, um Ihre Auswahl zu bestätigen.
Wählen Sie unten auf der Seite "Neue Gruppe erstellen" aus, um die Gruppe zu erstellen und zur Seite "Alle Gruppen" zurückzukehren. Wenn die neue Gruppe nicht aufgeführt ist, warten Sie einen Moment, und aktualisieren Sie die Seite.

Verwenden Sie den Befehl az ad group create, um Gruppen in Microsoft Entra ID zu erstellen.
```
az ad group create \
    --display-name <group-name> \
    --mail-nickname <group-mail-nickname> \
    --description <group-description>
```
Die --display-name- und --mail-nickname-Parameter sind erforderlich. Der Name der Gruppe sollte auf dem Namen und der Umgebung der App basieren, um den Zweck der Gruppe anzugeben.
Zum Hinzufügen von Mitgliedern zur Gruppe benötigen Sie die Objekt-ID des Anwendungsdienstprinzipals, die sich von der Anwendungs-ID unterscheidet. Verwenden Sie den Befehl "az ad sp list" , um die verfügbaren Dienstprinzipale auflisten:
```
az ad sp list \
    --filter "startswith(displayName, '<group-name>')" \
    --query "[].{objectId:id, displayName:displayName}"
```
Der --filter Parameter akzeptiert OData-Formatfilter und kann verwendet werden, um die Liste wie dargestellt zu filtern. Der --query Parameter beschränkt die Ausgabe auf nur die Spalten von Interesse.
Verwenden Sie den Befehl " az ad group member add" zum Hinzufügen von Mitgliedern zur Gruppe:
```
az ad group member add \
    --group <group-name> \
    --member-id <object-id>
```

Weisen Sie der Gruppe Rollen zu

Ermitteln Sie als Nächstes, welche Rollen (Berechtigungen) Ihre App für welche Ressourcen benötigt, und weisen Sie diese Rollen der erstellten Microsoft Entra Gruppe zu. Gruppen können einer Rolle im Ressourcen-, Ressourcengruppen- oder Abonnementbereich zugewiesen werden. In diesem Beispiel wird gezeigt, wie Rollen im Ressourcengruppenbereich zugewiesen werden, da die meisten Apps alle ihre Azure Ressourcen in einer einzelnen Ressourcengruppe gruppieren.

Azure Portal
Azure CLI

Navigieren Sie im Azure-Portal zur Seite Overview der Ressourcengruppe, die Ihre App enthält.
Wählen Sie im linken Navigationsbereich die Option Zugriffssteuerung (IAM).
Wählen Sie auf der Seite access control (IAM)+ Hinzufügen und dann im Dropdownmenü " Rollenzuweisung hinzufügen " aus. Die Seite " Rollenzuweisung hinzufügen " bietet mehrere Registerkarten zum Konfigurieren und Zuweisen von Rollen.
Verwenden Sie auf der Registerkarte " Rolle " das Suchfeld, um die Rolle zu suchen, die Sie zuweisen möchten. Wählen Sie die Rolle und dann "Weiter" aus.
Auf der Registerkarte „Mitglieder“
- Wählen Sie für den Wert "Zugriff zuweisen""Benutzer", "Gruppe" oder "Dienstprinzipal" aus.
- Wählen Sie für den Wert " Mitglieder " die Option "Mitglieder auswählen " aus, um den Flyoutbereich " Mitglieder auswählen " zu öffnen.
- Suchen Sie nach der zuvor erstellten Microsoft Entra Gruppe, und wählen Sie sie aus den gefilterten Ergebnissen aus. Wählen Sie Auswählen aus, um die Gruppe auszuwählen und das Flyout-Panel zu schließen.
- Wählen Sie "Überprüfen" und "Zuweisen " am unteren Rand der Registerkarte " Mitglieder " aus.
Ein Screenshot, der zeigt, wie man einer Microsoft Entra-Gruppe eine Rolle zuweist.
Wählen Sie auf der Registerkarte " Überprüfen+ Zuweisen " die Option "Überprüfen" und "Zuweisen " am unteren Rand der Seite aus.

Verwenden Sie die Rollendefinitionsliste az, um die Namen der Rollen abzurufen, denen eine Microsoft Entra Gruppe oder ein Dienstprinzipal zugewiesen werden kann:
```
az role definition list \
    --query "sort_by([].{roleName:roleName, description:description}, &roleName)" \
    --output table
```
Verwenden Sie den Befehl az role assignment create, um der erstellten Microsoft Entra Gruppe eine Rolle zuzuweisen:
```
az role assignment create \
    --assignee "<group-object-Id>" \
    --role "<role-name>" \
    --resource-group "<resource-group-name>"
```
Informationen zum Zuweisen von Berechtigungen auf Ressourcen- oder Abonnementebene mithilfe des Azure CLI finden Sie unter Assign-Azure Rollen mithilfe der Azure CLI.

Festlegen der App-Umgebungsvariablen

Zur Laufzeit suchen bestimmte Anmeldeinformationen aus der Azure Identitätsbibliothek, wie DefaultAzureCredential, EnvironmentCredential und ClientSecretCredential, konventionell in den Umgebungsvariablen nach Dienstprinzipalinformationen. Es gibt mehrere Möglichkeiten zum Konfigurieren von Umgebungsvariablen beim Arbeiten mit Python, je nach Tool und Umgebung.

Konfigurieren Sie unabhängig vom gewählten Ansatz die folgenden Umgebungsvariablen für einen Dienstprinzipal:

AZURE_CLIENT_ID: Die Anwendungs-ID der registrierten App in Azure.
AZURE_TENANT_ID: Die ID des Microsoft Entra Mandanten.
AZURE_CLIENT_SECRET: Die Clientgeheimnis-Anmeldeinformationen für die App.

Da die meisten Entwickler an mehreren Anwendungen arbeiten, wird die Verwendung eines Pakets wie python-dotenv empfohlen, auf Umgebungsvariablen aus einer .env Datei zuzugreifen, die während der Entwicklung im Verzeichnis der Anwendung gespeichert ist. Bei diesem Ansatz werden die Umgebungsvariablen so erweitert, dass sie nur von dieser Anwendung verwendet werden können.

Die datei .env wird nie in die Quellcodeverwaltung eingecheckt, da sie den geheimen Anwendungsschlüssel für Azure enthält. Die Standarddatei .gitignore für Python schließt die datei .env automatisch vom Einchecken aus.

Um das python-dotenv Paket zu verwenden, installieren Sie zuerst das Paket in Ihrer Anwendung:

pip install python-dotenv

Erstellen Sie dann eine .env Datei in Ihrem Anwendungsstammverzeichnis. Legen Sie die Umgebungsvariablenwerte mit Werten fest, die aus dem App-Registrierungsprozess abgerufen wurden:

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

Verwenden Sie schließlich im Startcode für Ihre Anwendung die python-dotenv Bibliothek, um die Umgebungsvariablen aus der .env Datei beim Start zu lesen:

from dotenv import load_dotenv

load_dotenv()

In Visual Studio Code können Umgebungsvariablen in der Datei launch.json Ihres Projekts festgelegt werden. Diese Werte werden automatisch abgerufen, wenn die App gestartet wird. Diese Konfigurationen reisen jedoch während der Bereitstellung nicht mit Ihrer App zusammen, daher müssen Sie Umgebungsvariablen in Ihrer Zielhostingumgebung einrichten.

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

Sie können Umgebungsvariablen für Windows über die Befehlszeile festlegen. Die Werte sind jedoch für alle Apps zugänglich, die auf diesem Betriebssystem ausgeführt werden, und können Konflikte verursachen, daher sollten Sie mit diesem Ansatz vorsichtig vorgehen. Umgebungsvariablen können auf Benutzer- oder Systemebene festgelegt werden.

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

PowerShell kann auch verwendet werden, um Umgebungsvariablen auf Benutzer- oder Systemebene festzulegen:

[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")

Starten Sie nach dem Ausführen dieser Befehle alle geöffneten Terminals oder Anwendungen neu, um die neuen Umgebungsvariablen zu übernehmen.

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

Um diese Umgebungsvariablen für Terminalsitzungen dauerhaft zu machen, fügen Sie diese Zeilen in Ihr Shell-Profil hinzu (z. B. ~/.bashrc, ~/.zshrc oder ~/.bash_profile).

Authentifizieren bei Azure Diensten aus Ihrer App

Die bibliothek azure-identity bietet verschiedene credentials – Implementierungen von TokenCredential angepasst an die Unterstützung verschiedener Szenarien und Microsoft Entra Authentifizierungsflüsse. Die vorausstehenden Schritte veranschaulichen die Verwendung von ClientSecretCredential beim lokalen Arbeiten mit Dienstprinzipalen und in der Produktion.

Implementieren des Codes

Fügen Sie zunächst das Paket zu Ihrer Anwendung hinzu.

pip install azure-identity

Als Nächstes sollten Sie für jeden Python Code, der ein Azure SDK Clientobjekt in Ihrer App erstellt, Folgendes ausführen:

Importieren Sie die ClientSecretCredential-Klasse aus dem azure.identity-Modul.
Importieren Sie das os Modul, um Umgebungsvariablen zu lesen.
Lesen Sie die Umgebungsvariablen, um die Client-ID, die Mandanten-ID und den geheimen Clientschlüssel abzurufen.
Erstellen Sie ein ClientSecretCredential Objekt, das die Mandanten-ID, die Client-ID und den geheimen Clientschlüssel übergibt.
Übergeben Sie das ClientSecretCredential-Objekt an den Azure SDK Clientobjektkonstruktor.

Ein Beispiel für diesen Ansatz ist im folgenden Codesegment dargestellt.

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)

Feedback

War diese Seite hilfreich?

Last updated on 2026-03-06