Connettersi al database SQL di Azure ed eseguire query con Python e il driver mssql-python

Si applica a:Database SQL di Azure

Questa guida introduttiva descrive come connettere un'applicazione a un database nel database SQL di Azure ed eseguire query usando Python e il driver mssql-python. Il driver mssql-python include il supporto predefinito per l'autenticazione di Microsoft Entra, rendendo semplici le connessioni senza password. Altre informazioni sulle connessioni senza password sono disponibili nell'hub senza password.

Prerequisiti

Una sottoscrizione di Azure.
Un database SQL di Azure configurato con l’autenticazione Microsoft Entra. È possibile crearne uno usando la guida introduttiva: Creare un database singolo - Database SQL di Azure. In alternativa, è possibile usare un database SQL in Microsoft Fabric.
Visual Studio Code con l'estensione Python.
Python 3.10 o versione successiva.
Interfaccia della riga di comando di Azure per l'autenticazione senza password (funziona in Windows, macOS e Linux).

Configurare il database

La connessione sicura senza password a Database SQL di Azure richiede determinate configurazioni del database. Verificare le impostazioni seguenti nel server logico in Azure per connettersi correttamente a Database SQL di Azure in ambienti locali e ospitati:

Per le connessioni di sviluppo locale, verificare che il server logico sia configurato per consentire all'indirizzo IP del computer locale e ad altri servizi di Azure di connettersi:
- Passare alla pagina Rete del server.
- Attivare o disattivare il pulsante di opzione Reti selezionate per visualizzare ulteriori opzioni di configurazione.
- Selezionare Aggiungere l'indirizzo IPv4 client (xx.xx.xx.xx.xx) per aggiungere una regola del firewall che consentirà le connessioni dall'indirizzo IPv4 del computer locale. In alternativa, è anche possibile selezionare + Aggiungi una regola del firewall per immettere un indirizzo IP specifico a propria scelta.
- Selezionare la casella di controllo Consenti alle risorse e ai servizi di Azure di accedere a questo server.
  Avviso
  
  L'abilitazione dell'impostazione Consenti a servizi e risorse di Azure di accedere a questo server non è una procedura di protezione consigliata per gli scenari di produzione. Le applicazioni reali devono implementare approcci più sicuri, ad esempio restrizioni firewall più avanzate o configurazioni di reti virtuali.
  
  Per altre informazioni sulle configurazioni di sicurezza del database, vedere le seguenti risorse:
  - Configurare le regole del firewall per il database SQL di Azure.
  - Configurare una rete virtuale con endpoint privati.
Al server deve essere abilitata anche l'autenticazione Microsoft Entra e deve essere assegnato un account amministratore di Microsoft Entra. Per le connessioni di sviluppo locali, l'account amministratore di Microsoft Entra deve essere un account con il quale è possibile accedere localmente anche a Visual Studio o all'interfaccia della riga di comando di Azure. È possibile verificare se nel server è abilitata l'autenticazione Microsoft Entra dalla pagina Microsoft Entra ID del server logico.
Se si utilizza un account Azure personale, assicurarsi di avere Microsoft Entra impostato e configurato per il Database SQL di Azure per poter assegnare il proprio account come amministratore del server. Se si utilizza un account aziendale, è probabile che Microsoft Entra ID sia già configurato per voi.

Creare il progetto

Creare un nuovo progetto Python con Visual Studio Code.

Aprire Visual Studio Code, creare una nuova cartella per il progetto e passare a tale directory.
```
mkdir python-sql-azure
cd python-sql-azure
```

Creare un ambiente virtuale per l’app.

Windows
macOS/Linux

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

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

Creare un nuovo file Python denominato app.py.

Installare il driver mssql-python

Per connettersi a database SQL di Azure usando Python, installare il driver mssql-python. Questo driver include il supporto predefinito per l'autenticazione di Microsoft Entra, eliminando la necessità di gestire manualmente i token. In questa guida introduttiva verranno anche installati pacchetti fastapi, uvicorn e pydantic per creare ed eseguire un'API.

Annotazioni

In macOS e Linux, le dipendenze di sistema sono necessarie prima di installare mssql-python. Vedere Installare il pacchetto mssql-python per istruzioni specifiche della piattaforma.

Creare un file requirements.txt con le righe seguenti:

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

Installare i requisiti software.
```
pip install -r requirements.txt
```

Configurare la stringa di connessione locale

Per lo sviluppo locale, creare un .env file nella cartella del progetto per archiviare la stringa di connessione. Questo mantiene le credenziali fuori dal codice e dal controllo del codice sorgente.

Nella cartella del progetto creare un nuovo file denominato .env.
Aggiungere la variabile AZURE_SQL_CONNECTIONSTRING con la stringa di connessione. Sostituire i segnaposto <database-server-name> e <database-name> con i propri valori.

Il driver mssql-python include il supporto predefinito per l'autenticazione di Microsoft Entra. Usare il Authentication parametro per specificare il metodo di autenticazione.

ActiveDirectoryDefault individua automaticamente le credenziali da più origini senza richiedere l'accesso interattivo. Questa è l'opzione consigliata per lo sviluppo locale.

Per un'esperienza di sviluppo locale più affidabile, accedere prima con l'interfaccia della riga di comando di Azure:

az login

Usare quindi questo formato di stringa di connessione nel .env file:

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

ActiveDirectoryDefault valuta le credenziali nell'ordine seguente:

Variabili di ambiente (per le credenziali dell'entità servizio)
Identità gestita (in esecuzione in Azure)
Interfaccia della riga di comando di Azure (da az login)
Visual Studio (solo Windows)
Azure PowerShell (da Connect-AzAccount)

Suggerimento

Per le applicazioni di produzione, usare il metodo di autenticazione specifico per lo scenario per evitare la latenza di individuazione delle credenziali:

Servizio app di Azure/Funzioni: usare ActiveDirectoryMSI (identità gestita)
Accesso utente interattivo: usare ActiveDirectoryInteractive
Principale del servizio: Usare ActiveDirectoryServicePrincipal

In Windows, Microsoft Entra Interactive Authentication può usare la tecnologia di autenticazione a più fattori Microsoft Entra per configurare una connessione. In questa modalità viene visualizzata una finestra di dialogo Autenticazione di Azure che consente di immettere le credenziali per completare la connessione.

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

È possibile eseguire l'autenticazione direttamente in un'istanza di SQL Server usando un nome utente e una password.

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

Avviso

Prestare attenzione quando si gestiscono stringhe di connessione contenenti segreti, ad esempio nomi utente, password o chiavi di accesso. Questi segreti non devono essere sottoposti a commit nel controllo del codice sorgente, né inseriti in posizioni non sicure in cui potrebbero essere accessibili da utenti imprevisti. Aggiungere al file per impedire il commit accidentale dei segreti.

Per connettersi a un database SQL in Microsoft Fabric, usare gli stessi metodi di autenticazione. Il nome del server segue il formato Fabric.

Nei computer Windows uniti a un dominio, usa ActiveDirectoryIntegrated per l'autenticazione senza passaggi aggiuntivi.

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

In macOS, Linux o Windows non di dominio usare ActiveDirectoryDefault dopo l'accesso con CLI di Azure (az login):

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

È possibile trovare la stringa di connessione del database SQL di Fabric nel portale di Fabric nelle impostazioni del database.

È possibile ottenere i dettagli per creare la stringa di connessione dal portale di Azure:

Passare ad Azure SQL Server, selezionare la pagina Database SQL per trovare il nome del database, quindi selezionare il database.
Nel database passare alla pagina Panoramica per ottenere il nome del server.

Aggiungere codice per connettersi al database SQL di Azure

Nella cartella del progetto creare un file app.py e aggiungere il codice di esempio. Tale codice crea un'API che:

Carica la configurazione da un .env file usando python-dotenv.
Recupera una stringa di connessione del database SQL di Azure da una variabile di ambiente.
Crea una tabella Persons nel database durante l'avvio (solo per scenari di test).
Definisce una funzione per recuperare tutti i record Person dal database.
Definisce una funzione per recuperare un record Person dal database.
Definisce una funzione per aggiungere nuovi record Person al database.

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

Avviso

Il codice di esempio mostra istruzioni SQL non elaborate che non devono essere usate nel codice di produzione. Usare invece un pacchetto ORM (Object Relational Mapper) come SqlAlchemy, che genera un livello oggetto più sicuro per accedere al database.

Eseguire e testare l'app in locale

L'app è pronta per essere testata a livello locale.

Eseguire il file app.py in Visual Studio Code.
```
uvicorn app:app --reload
```
Nella pagina dell'interfaccia utente di Swagger per l’app http://127.0.0.1:8000/docs, espandere il metodo POST e selezionare Prova.

È anche possibile provare /redoc a visualizzare un'altra forma di documentazione generata per l'API.
Modificare il campione JSON affinché includa i valori di nome e cognome. Selezionare Esegui per aggiungere un nuovo record al database. L'API restituisce una risposta di esito positivo.
Espandere il GET metodo nella pagina dell'interfaccia utente di Swagger e selezionare Prova. Scegliere Esegui e, in questo modo, viene restituita la persona appena creata.

Distribuire nel Servizio app di Azure

L'app è pronta per essere distribuita in Azure.

Creare un file start.sh in modo che gunicorn in Servizio app di Azure possa eseguire uvicorn. start.sh ha una riga:
```
gunicorn -w 4 -k uvicorn.workers.UvicornWorker app:app
```
Usare az webapp up per distribuire il codice in App Service. (È possibile usare l'opzione -dryrun per visualizzare le operazioni del comando senza creare la risorsa.)
```
az webapp up \
    --resource-group <resource-group-name> \
    --name <web-app-name>         
```

Usare il comando az webapp config set per configurare il App Service per usare il file start.sh.

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

Usare il comando az webapp identity assign per abilitare un'identità gestita assegnata dal sistema per Servizio app.
```
az webapp identity assign \
    --resource-group <resource-group-name> \
    --name <web-app-name>
```
In questo avvio rapido, viene utilizzata un'identità gestita assegnata dal sistema a scopo dimostrativo. Un'identità gestita assegnata dall'utente è più efficiente in una vasta gamma di scenari. Per altre informazioni, vedere Raccomandazioni sulle procedure consigliate per l'identità gestita. Per un esempio di uso di un'identità gestita assegnata dall'utente con mssql-python, vedere Eseguire la migrazione di un'applicazione Python per usare connessioni senza password con il database SQL di Azure.

Connettere il servizio app al database SQL di Azure

Nella sezione Configurare il database è stata configurata l'autenticazione di rete e Microsoft Entra per il server di database SQL di Azure. In questa sezione viene completata la configurazione del database e viene configurato il Servizio app con un stringa di connessione per accedere al server database.

Per eseguire questi comandi è possibile usare qualsiasi strumento o IDE in grado di connettersi al database SQL di Azure, tra cui SQL Server Management Studio (SSMS) e Visual Studio Code con l'estensione MSSQL. È anche possibile usare il portale di Azure come descritto in Avvio rapido: Usare l'editor di query del portale di Azure per eseguire query sul database SQL di Azure.

Aggiungere un utente al database SQL di Azure con i comandi SQL per creare un utente e un ruolo per l'accesso senza password.
```
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>]
```
Per altre informazioni, vedere Utenti di database indipendente: rendere portabile un database. Per trovare un esempio che illustra lo stesso principio, ma applicato alla macchina virtuale di Azure, vedere Esercitazione: usare un'identità gestita assegnata dal sistema di macchine virtuali Windows per accedere ad Azure SQL. Per altre informazioni sui ruoli assegnati, vedere Ruoli predefiniti del database.

Se disabiliti e poi abiliti l'identità gestita assegnata dal sistema in Servizio App, allora elimina l'utente e ricrealo. Eseguire DROP USER [<web-app-name>], quindi eseguire di nuovo i comandi CREATE e ALTER. Per visualizzare gli utenti, usare SELECT * FROM sys.database_principals.
Usare il comando az webapp config appsettings set per aggiungere un’impostazione app per la stringa di connessione.
```
az webapp config appsettings set \
    --resource-group <resource-group-name> \
    --name <web-app-name> \
    --settings AZURE_SQL_CONNECTIONSTRING="<connection-string>"
```
Per l'app distribuita, la stringa di connessione dovrebbe essere simile a quanto segue:
```
Server=<database-server-name>.database.windows.net;Database=<database-name>;Authentication=ActiveDirectoryMSI;Encrypt=yes;TrustServerCertificate=no;
```
Compilare <database-server-name> e <database-name> con i propri valori.

La stringa di connessione senza password non contiene un nome utente o una password. Al contrario, quando l'app viene eseguita in Azure, il driver mssql-python usa la ActiveDirectoryMSI modalità di autenticazione per l'autenticazione automatica usando l'identità gestita del servizio app.

Testare l'applicazione distribuita

Passare all'URL dell'app per testare il funzionamento della connessione al database SQL di Azure. È possibile individuare l'URL dell'app nella pagina di panoramica del servizio app.

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

Aggiungere /docs all'URL per visualizzare l'interfaccia utente di Swagger e testare i metodi api.

Complimenti. L'applicazione è ora connessa al database SQL di Azure in ambienti locali e ospitati.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-02-11