Herstellen einer Verbindung mit und Abfragen der Azure SQL-Datenbank mithilfe von Python und dem mssql-python-Treiber

Gilt für:Azure SQL-Datenbank

In dieser Schnellstartanleitung wird beschrieben, wie Sie eine Anwendung mit einer Datenbank in azure SQL-Datenbank verbinden und Abfragen mithilfe von Python und dem Mssql-Python-Treiber ausführen. Der mssql-python-Treiber bietet integrierte Unterstützung für die Microsoft Entra-Authentifizierung und macht kennwortlose Verbindungen einfach. Sie können mehr über kennwortlose Verbindungen auf dem kennwortlosen Hub erfahren.

Voraussetzungen

Ein Azure-Abonnement.
Eine Azure SQL-Datenbank, die mit Microsoft Entra-Authentifizierung konfiguriert ist. Sie können eine mithilfe der Schnellstartanleitung erstellen: Erstellen einer einzelnen Datenbank – Azure SQL-Datenbank. Alternativ können Sie eine SQL-Datenbank in Microsoft Fabric verwenden.
Visual Studio Code mit der Python-Erweiterung.
Python 3.10 oder höher.
Die Azure CLI für die kennwortlose Authentifizierung (funktioniert unter Windows, macOS und Linux).

Konfigurieren der Datenbank

Sichere, kennwortlose Verbindungen mit Azure SQL-Datenbank erfordern bestimmte Datenbankkonfigurationen. Überprüfen Sie die folgenden Einstellungen auf Ihrem logischen Server in Azure, um eine ordnungsgemäße Verbindung mit Azure SQL-Datenbank in lokalen und gehosteten Umgebungen herzustellen:

Stellen Sie für Verbindungen bei der lokalen Entwicklung sicher, dass Ihr logischer Server so konfiguriert ist, dass die IP-Adresse Ihres lokalen Computers und andere Azure-Dienste eine Verbindung herstellen können:
- Wechseln Sie zur Seite Netzwerk für Ihren Server.
- Schalten Sie das Optionsfeld Ausgewählte Netzwerke um, um zusätzliche Konfigurationsoptionen anzuzeigen.
- Wählen Sie Client-IPv4-Adresse (xx.xx.xx.xx) hinzufügen aus, um eine Firewallregel hinzuzufügen, die Verbindungen von der IPv4-Adresse Ihres lokalen Computers ermöglicht. Alternativ können Sie auch + Firewallregel hinzufügen auswählen, um eine bestimmte IP-Adresse Ihrer Wahl einzugeben.
- Vergewissern Sie sich, dass das Kontrollkästchen Azure-Diensten und -Ressourcen den Zugriff auf diesen Server gestatten aktiviert ist.
  Warnung
  
  Das Aktivieren der Einstellung Azure-Diensten und -Ressourcen den Zugriff auf diesen Server gestatten ist kein empfohlenes Sicherheitsverfahren für Produktionsszenarien. Echte Anwendungen sollten sicherere Ansätze implementieren, z. B. stärkere Firewalleinschränkungen oder Konfigurationen mit virtuellen Netzwerken.
  
  Weitere Informationen zum Konfigurieren der Datenbanksicherheit finden Sie in den folgenden Ressourcen:
  - Konfigurieren von Firewallregeln für Azure SQL-Datenbank
  - Konfigurieren eines virtuellen Netzwerks mit privaten Endpunkten
Der Server muss auch die Microsoft Entra-Authentifizierung aktiviert haben und ein Microsoft Entra-Administratorkonto zugewiesen haben. Bei lokalen Entwicklungsverbindungen sollte das Microsoft Entra-Administratorkonto ein Konto sein, mit dem Sie sich auch lokal bei Visual Studio oder der Azure CLI anmelden können. Sie können überprüfen, ob der Server die Microsoft Entra-Authentifizierung auf der Microsoft Entra-ID-Seite Ihres logischen Servers aktiviert hat.
Wenn Sie ein persönliches Azure-Konto verwenden, stellen Sie sicher, dass Sie Microsoft Entra für Azure SQL Database eingerichtet und konfiguriert haben, um Ihr Konto als Server-Admin zuzuweisen. Wenn Sie ein Unternehmenskonto verwenden, ist die Microsoft Entra ID höchstwahrscheinlich bereits für Sie konfiguriert.

Erstellen des Projekts

Erstellen Sie ein neues Python-Projekt mit Visual Studio Code.

Öffnen Sie Visual Studio Code, erstellen Sie einen neuen Ordner für Ihr Projekt, und wechseln Sie zu diesem Verzeichnis.
```
mkdir python-sql-azure
cd python-sql-azure
```

Erstellen Sie eine virtuelle Umgebung für die App.

Windows
macOS/Linux

py -m venv .venv
.venv\scripts\activate

python3 -m venv .venv
source .venv/bin/activate

Erstellen Sie eine neue Python-Datei mit dem Namen app.py.

Installieren des mssql-python-Treibers

Installieren Sie den mssql-python-Treiber, um mithilfe von Python eine Verbindung mit Azure SQL-Datenbank herzustellen. Dieser Treiber verfügt über integrierte Unterstützung für die Microsoft Entra-Authentifizierung, sodass keine manuelle Tokenbehandlung erforderlich ist. In dieser Schnellstartanleitung installieren Sie darüber hinaus fastapi-, uvicorn- und pydantic-Pakete, um eine API zu erstellen und auszuführen.

Hinweis

Unter macOS und Linux sind Systemabhängigkeiten vor der Installation mssql-pythonerforderlich. Siehe Installieren des mssql-python-Pakets für plattformspezifische Anweisungen.

Erstellen Sie eine requirements.txt-Datei mit folgenden Zeilen:

mssql-python
fastapi
uvicorn[standard]
pydantic
python-dotenv

Installieren Sie die Anforderungen.
```
pip install -r requirements.txt
```

Konfigurieren der lokalen Verbindungszeichenfolge

Erstellen Sie für die lokale Entwicklung eine .env Datei im Projektordner, um die Verbindungszeichenfolge zu speichern. Dadurch werden Anmeldeinformationen aus Ihrem Code und der Quellcodeverwaltung ferngehalten.

Erstellen Sie im Projektordner eine neue Datei mit dem Namen .env.
Fügen Sie die AZURE_SQL_CONNECTIONSTRING Variable mit ihrer Verbindungszeichenfolge hinzu. Ersetzen Sie die Platzhalter <database-server-name> und <database-name> durch Ihre eigenen Werte.

Der mssql-python-Treiber verfügt über integrierte Unterstützung für die Microsoft Entra-Authentifizierung. Verwenden Sie den Authentication Parameter, um die Authentifizierungsmethode anzugeben.

ActiveDirectoryDefault erkennt automatisch Anmeldeinformationen aus mehreren Quellen, ohne dass eine interaktive Anmeldung erforderlich ist. Dies ist die empfohlene Option für die lokale Entwicklung.

Melden Sie sich zuerst bei Azure CLI an, um die zuverlässigste lokale Entwicklungsumgebung zu erhalten:

az login

Verwenden Sie dann dieses Verbindungszeichenfolgenformat in Ihrer .env Datei:

AZURE_SQL_CONNECTIONSTRING=Server=<database-server-name>.database.windows.net;Database=<database-name>;Authentication=ActiveDirectoryDefault;Encrypt=yes;TrustServerCertificate=no;

ActiveDirectoryDefault Bewertet Anmeldeinformationen in der folgenden Reihenfolge:

Umgebungsvariablen (für Dienstprinzipalanmeldeinformationen)
Verwaltete Identität (bei Ausführung in Azure)
Azure CLI (von az login)
Visual Studio (nur Windows)
Azure PowerShell (von Connect-AzAccount)

Tipp

Verwenden Sie für Produktionsanwendungen die spezifische Authentifizierungsmethode für Ihr Szenario, um die Latenz bei der Erkennung von Anmeldeinformationen zu vermeiden:

Azure App Service/Functions: Verwenden ActiveDirectoryMSI (verwaltete Identität)
Interaktive Benutzeranmeldung: Verwenden ActiveDirectoryInteractive
Service Principal: Verwenden ActiveDirectoryServicePrincipal

In Windows kann die Microsoft Entra Interactive-Authentifizierung die Microsoft Entra Mehrfaktor-Authentifizierungstechnologie verwenden, um eine Verbindung einzurichten. In diesem Modus wird ein Azure-Authentifizierungsdialogfeld angezeigt, und Sie können Ihre Anmeldeinformationen eingeben, um die Verbindung abzuschließen.

AZURE_SQL_CONNECTIONSTRING=Server=<database-server-name>.database.windows.net;Database=<database-name>;Authentication=ActiveDirectoryInteractive;Encrypt=yes;TrustServerCertificate=no;

Sie können sich mithilfe eines Benutzernamens und Kennworts direkt bei einer SQL Server-Instanz authentifizieren.

AZURE_SQL_CONNECTIONSTRING=Server=<database-server-name>.database.windows.net;Database=<database-name>;UID=<user-name>;PWD=<user-password>;Encrypt=yes;TrustServerCertificate=no;

Warnung

Gehen Sie beim Verwalten von Verbindungszeichenfolgen mit Geheimnissen wie Benutzernamen, Kennwörtern oder Zugriffsschlüsseln vorsichtig vor. Diese Geheimnisse sollten nicht in der Quellcodeverwaltung committet oder an unsicheren Orten gespeichert werden, an denen unbeabsichtigte Benutzer*innen möglicherweise darauf zugreifen können. Fügen Sie .env Ihrer .gitignore-Datei hinzu, um das versehentliche Hochladen von Geheimnissen zu verhindern.

Verwenden Sie die gleichen Authentifizierungsmethoden, um eine Verbindung mit einer SQL-Datenbank in Microsoft Fabric herzustellen. Der Servername folgt dem Fabric-Format.

Verwenden Sie auf Computern, die einer Windows-Domäne beigetreten sindActiveDirectoryIntegrated, um eine nahtlose Authentifizierung ohne zusätzliche Schritte zu ermöglichen.

AZURE_SQL_CONNECTIONSTRING=Server=<workspace-guid>.database.fabric.microsoft.com,1433;Database=<database-name>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryIntegrated;

Verwenden Sie unter ActiveDirectoryDefault nach der Anmeldung mit Azure CLI (az login):

AZURE_SQL_CONNECTIONSTRING=Server=<workspace-guid>.database.fabric.microsoft.com,1433;Database=<database-name>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryDefault;

Sie finden ihre Fabric SQL-Datenbankverbindungszeichenfolge im Fabric-Portal unter den Einstellungen Ihrer Datenbank.

Die Details zum Erstellen der Verbindungszeichenfolge können Sie aus dem Azure-Portal abrufen:

Wechseln Sie zum Azure SQL Server, wählen Sie die Seite SQL-Datenbanken aus, um ihren Datenbanknamen zu finden, und wählen Sie die Datenbank aus.
Wechseln Sie auf der Datenbank zur Seite "Übersicht ", um den Servernamen abzurufen.

Hinzufügen von Code zum Herstellen einer Verbindung mit einer Azure SQL-Datenbank-Instanz

Erstellen Sie im Projektordner eine app.py-Datei , und fügen Sie den Beispielcode hinzu. Mit diesem Code wird eine API erstellt, die folgendes bewirkt:

Lädt die Konfiguration aus einer .env Datei mithilfe von python-dotenv.
Ruft eine Azure SQL-Datenbank-Verbindungszeichenfolge aus einer Umgebungsvariablen ab.
Erstellt während des Startvorgangs eine Persons-Tabelle in der Datenbank (nur für Testszenarien).
Definiert eine Funktion zum Abrufen aller Person-Datensätze aus der Datenbank.
Definiert eine Funktion zum Abrufen eines Person-Datensatzes aus der Datenbank.
Definiert eine Funktion zum Hinzufügen neuer Person-Datensätze zur Datenbank.

from os import getenv
from typing import Union
from dotenv import load_dotenv
from fastapi import FastAPI
from pydantic import BaseModel
from mssql_python import connect

load_dotenv()

class Person(BaseModel):
    first_name: str
    last_name: Union[str, None] = None

connection_string = getenv("AZURE_SQL_CONNECTIONSTRING")

app = FastAPI()

@app.get("/")
def root():
    print("Root of Person API")
    try:
        conn = get_conn()
        cursor = conn.cursor()

        # Table should be created ahead of time in production app.
        cursor.execute("""
            IF NOT EXISTS (SELECT * FROM sys.tables WHERE name = 'Persons')
            CREATE TABLE Persons (
                ID int NOT NULL PRIMARY KEY IDENTITY,
                FirstName varchar(255),
                LastName varchar(255)
            );
        """)

        conn.commit()
        conn.close()
    except Exception as e:
        # Table might already exist
        print(e)
    return "Person API"

@app.get("/all")
def get_persons():
    rows = []
    with get_conn() as conn:
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM Persons")

        for row in cursor.fetchall():
            print(row.FirstName, row.LastName)
            rows.append(f"{row.ID}, {row.FirstName}, {row.LastName}")
    return rows

@app.get("/person/{person_id}")
def get_person(person_id: int):
    with get_conn() as conn:
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM Persons WHERE ID = ?", (person_id,))

        row = cursor.fetchone()
        return f"{row.ID}, {row.FirstName}, {row.LastName}"

@app.post("/person")
def create_person(item: Person):
    with get_conn() as conn:
        cursor = conn.cursor()
        cursor.execute("INSERT INTO Persons (FirstName, LastName) VALUES (?, ?)",
                       (item.first_name, item.last_name))
        conn.commit()

    return item

def get_conn():
    """Connect using mssql-python with built-in Microsoft Entra authentication."""
    conn = connect(connection_string)
    conn.setautocommit(True)
    return conn

Warnung

Der Beispielcode zeigt unformatierte SQL-Anweisungen, die nicht im Produktionscode verwendet werden sollten. Verwenden Sie stattdessen ein Object Relational Mapper-(ORM-)Paket wie z. B. SqlAlchemy, das eine sicherere Objektebene für den Zugriff auf Ihre Datenbank generiert.

Lokales Ausführen und Testen der App

Die App kann lokal getestet werden.

Führen Sie die Datei app.py in Visual Studio Code aus.
```
uvicorn app:app --reload
```
Erweitern Sie auf der Swagger-UI-Seite für die App http://127.0.0.1:8000/docs die POST-Methode, und wählen Sie Ausprobieren aus.

Sie können auch /redoc ausprobieren, um eine andere Form der generierten Dokumentation für die API anzuzeigen.
Ändern Sie den JSON-Beispielcode, um Werte für den Vor- und Nachnamen einzuschließen. Wählen Sie Ausführen aus, um der Datenbank einen neuen Datensatz hinzuzufügen. Die API gibt eine Erfolgsmeldung zurück.
Erweitern Sie die GET Methode auf der Seite "Swagger UI", und wählen Sie "Testen" aus. Wählen Sie Ausführen aus, und die soeben erstellte Person wird zurückgegeben.

Bereitstellung in Azure App Service

Die App kann jetzt in Azure bereitgestellt werden.

Erstellen Sie eine start.sh-Datei, damit gunicorn in Azure App Service uvicorn ausführen kann. Die start.sh-Datei hat eine Zeile:
```
gunicorn -w 4 -k uvicorn.workers.UvicornWorker app:app
```
Verwenden Sie az webapp up, um den Code in App Service bereitzustellen. (Sie können die Option -dryrun verwenden, um die Funktionsweise des Befehls anzuzeigen, ohne die Ressource zu erstellen.)
```
az webapp up \
    --resource-group <resource-group-name> \
    --name <web-app-name>         
```

Verwenden Sie den Befehl az webapp config set, um App Service für die Verwendung der start.sh-Datei zu konfigurieren.

az webapp config set \
    --resource-group <resource-group-name> \
    --name <web-app-name> \
    --startup-file start.sh

Verwenden Sie den Befehl az webapp identity assign, um eine systemseitig zugewiesene verwaltete Identität für den App Service zu aktivieren.
```
az webapp identity assign \
    --resource-group <resource-group-name> \
    --name <web-app-name>
```
In dieser Schnellstartanleitung wird eine vom System zugewiesene verwaltete Identität zu Demonstrationszwecken verwendet. Eine benutzerseitig zugewiesene verwaltete Identität ist in einem breiteren Spektrum von Szenarien effizienter. Weitere Informationen finden Sie unter Empfehlungen zu bewährten Methoden für verwaltete Identitäten. Ein Beispiel für die Verwendung einer vom Benutzer zugewiesenen verwalteten Identität mit mssql-python finden Sie unter Migrieren einer Python-Anwendung, um kennwortlose Verbindungen mit Azure SQL-Datenbank zu verwenden.

Verbinden der App Service-Instanz mit Azure SQL-Datenbank

Im Abschnitt Konfigurieren der Datenbank haben Sie Netzwerkbetrieb und Microsoft Entra-Authentifizierung für den Azure SQL-Datenbankserver konfiguriert. In diesem Abschnitt schließen Sie die Datenbankkonfiguration ab und konfigurieren den App Service mit einer Verbindungszeichenfolge für den Zugriff auf den Datenbankserver.

Zum Ausführen dieser Befehle können Sie ein beliebiges Tool oder jede IDE verwenden, die eine Verbindung mit der Azure SQL-Datenbank herstellen kann, einschließlich SQL Server Management Studio (SSMS) und Visual Studio Code mit der MSSQL-Erweiterung. Sie können das Azure-Portal auch wie in der Schnellstartanleitung beschrieben verwenden: Verwenden Sie den Azure-Portalabfrage-Editor, um Azure SQL-Datenbank abzufragen.

Fügen Sie der Azure SQL-Datenbank mit SQL-Befehlen einen Benutzer hinzu, um einen Benutzer und eine Rolle für den kennwortlosen Zugriff zu erstellen.
```
CREATE USER [<web-app-name>] FROM EXTERNAL PROVIDER
ALTER ROLE db_datareader ADD MEMBER [<web-app-name>]
ALTER ROLE db_datawriter ADD MEMBER [<web-app-name>]
```
Weitere Informationen finden Sie unter Eigenständige Datenbankbenutzer - machen Sie Ihre Datenbank portabel. Ein Beispiel, das das gleiche Prinzip zeigt, aber auf Azure VM angewendet wird, finden Sie im Tutorial: Verwenden einer systemseitig zugewiesenen verwalteten Windows-VM-Identität für den Zugriff auf Azure SQL. Weitere Informationen zu den zugewiesenen Rollen finden Sie unter Feste Datenbankrollen.

Wenn Sie die systemseitig zugewiesene verwaltete Identität des App Service deaktivieren und dann aktivieren, löschen Sie den Benutzer und erstellen Sie ihn neu. Führen Sie DROP USER [<web-app-name>] aus und führen Sie die Befehle CREATE und ALTER erneut aus. Um Benutzer anzuzeigen, verwenden Sie SELECT * FROM sys.database_principals.
Verwenden Sie den Befehl az webapp config appsettings set, um eine App-Einstellung für die Verbindungszeichenfolge hinzuzufügen.
```
az webapp config appsettings set \
    --resource-group <resource-group-name> \
    --name <web-app-name> \
    --settings AZURE_SQL_CONNECTIONSTRING="<connection-string>"
```
Für die bereitgestellte App sollte die Verbindungszeichenfolge wie folgt aussehen:
```
Server=<database-server-name>.database.windows.net;Database=<database-name>;Authentication=ActiveDirectoryMSI;Encrypt=yes;TrustServerCertificate=no;
```
Geben Sie Ihre Werte in <database-server-name> und <database-name> ein.

Die kennwortlose Verbindungszeichenfolge enthält weder einen Benutzernamen noch ein Kennwort. Wenn die App in Azure ausgeführt wird, verwendet der mssql-python-Treiber stattdessen den ActiveDirectoryMSI Authentifizierungsmodus, um sich automatisch mithilfe der verwalteten Identität des App-Diensts zu authentifizieren.

Testen der bereitgestellten Anwendung

Navigieren Sie zur URL der App, um zu testen, ob die Verbindung mit Azure SQL-Datenbank funktioniert. Sie finden die URL Ihrer App auf der App Service-Übersichtsseite.

https://<web-app-name>.azurewebsites.net

Fügen Sie /docs an die URL an, um die Swagger-Benutzeroberfläche anzuzeigen und die API-Aufrufe zu testen.

Glückwunsch! Ihre Anwendung ist jetzt in lokalen und gehosteten Umgebungen mit Azure SQL-Datenbank verbunden.

Feedback

War diese Seite hilfreich?

Last updated on 2026-02-11