Dela via

Ansluta till och fråga Azure SQL Database med hjälp av Python och pyodbc-drivrutinen

  • Artikel

gäller för:Azure SQL Database

Den här snabbstarten beskriver hur du ansluter ett program till en databas i Azure SQL Database och utför frågor med hjälp av Python och Python SQL Driver – pyodbc. Den här snabbstarten följer den rekommenderade metoden för lösenordsfri anslutning till databasen. Du kan lära dig mer om lösenordslösa anslutningar på lösenordsfri hubb.

Förutsättningar

Konfigurera databasen

Säkra, lösenordslösa anslutningar till Azure SQL Database kräver vissa databaskonfigurationer. Kontrollera följande inställningar på din logiska servern i Azure för att ansluta korrekt till Azure SQL Database i både lokala och värdbaserade miljöer:

  1. För lokala utvecklingsanslutningar kontrollerar du att den logiska servern är konfigurerad så att din lokala dators IP-adress och andra Azure-tjänster kan ansluta:

    • Gå till sidan Nätverk på din server.

    • Aktivera Valda nätverk alternativknapp för att visa fler konfigurationsalternativ.

    • Välj Lägg till din klient-IPv4-adress (xx.xx.xx.xx.xx) för att lägga till en brandväggsregel som aktiverar anslutningar från din lokala IPv4-adress. Du kan också välja + Lägg till en brandväggsregel för att ange en specifik IP-adress.

    • Kontrollera att kryssrutan Tillåt Att Azure-tjänster och resurser får åtkomst till den här servern är markerad.

      En skärmbild som visar hur du konfigurerar brandväggsregler.

      Varning

      Att aktivera inställningen Tillåt Azure-tjänster och resurser att komma åt den här servern är inte en rekommenderad säkerhetsåtgärd för produktionsscenarier. Verkliga program bör implementera säkrare metoder, till exempel starkare brandväggsbegränsningar eller konfigurationer av virtuella nätverk.

      Du kan läsa mer om databassäkerhetskonfigurationer på följande resurser:

  2. Servern måste också ha Microsoft Entra-autentisering aktiverat och ha ett Microsoft Entra-administratörskonto tilldelat. För lokala utvecklingsanslutningar ska Microsoft Entra-administratörskontot vara ett konto som du också kan logga in på Visual Studio eller Azure CLI med lokalt. Du kan kontrollera om din server har Microsoft Entra-autentisering aktiverat på sidan Microsoft Entra-ID på den logiska servern.

    En skärmbild som visar hur du aktiverar Microsoft Entra-autentisering.

  3. Om du använder ett personligt Azure-konto kontrollerar du att du har Microsoft Entra-konfiguration och konfigurerat för Azure SQL Database för att tilldela ditt konto som serveradministratör. Om du använder ett företagskonto är Microsoft Entra-ID förmodligen redan konfigurerat åt dig.

Skapa projektet

Skapa ett nytt Python-projekt med Visual Studio Code.

  1. Öppna Visual Studio Code och skapa en ny mapp för projektet och ändra katalogen till den.

    mkdir python-sql-azure
cd python-sql-azure

  2. Skapa en virtuell miljö för appen.

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

  3. Skapa en ny Python-fil med namnet app.py.

Installera pyodbc-drivrutinen

Om du vill ansluta till Azure SQL Database med Python installerar du drivrutinen för pyodbc. Det här paketet fungerar som en dataprovider för att ansluta till databaser, köra kommandon och hämta resultat. I den här snabbstarten installerar du även flask, uvicornoch pydantic paket för att skapa och köra ett API.

Mer information och specifika instruktioner för att installera pyodbc drivrutinen på alla operativsystem finns i Konfigurera utvecklingsmiljö för pyodbc Python-utveckling.

  1. Skapa en requirements.txt fil med följande rader:

    pyodbc
fastapi
uvicorn[standard]
pydantic
azure-identity

  2. Installera nödvändiga komponenter.

    pip install -r requirements.txt

Konfigurera den lokala anslutningssträngen

För lokal utveckling och anslutning till Azure SQL Database lägger du till följande AZURE_SQL_CONNECTIONSTRING miljövariabel. Ersätt platshållarna <database-server-name> och <database-name> med dina egna värden. Exempel på miljövariabler visas för Bash-gränssnittet.

Interaktiv autentisering ger ett lösenordslöst alternativ när du kör lokalt. Det här alternativet rekommenderas eftersom du inte behöver lagra eller hantera autentiseringshemligheter i ditt lokala system.

I Windows kan Microsoft Entra Interactive Authentication använda Microsoft Entra multifaktorautentiseringsteknik för att konfigurera anslutning. I det här läget utlöses en Azure-autentiseringsdialogruta genom att ange inloggnings-ID:t och gör att användaren kan ange lösenordet för att slutföra anslutningen.

export AZURE_SQL_CONNECTIONSTRING='Driver={ODBC Driver 18 for SQL Server};Server=tcp:<database-server-name>.database.windows.net,1433;Database=<database-name>;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30'

Mer information finns i Använda Microsoft Entra-ID med ODBC-drivrutinen. Om du använder det här alternativet letar du efter det fönster som frågar efter autentiseringsuppgifter.

Du kan få information om hur du skapar anslutningssträngen från Azure-portalen:

  1. Gå till Azure SQL Server, välj sidan SQL-databaser för att hitta databasnamnet och välj databasen.

  2. I databasen går du till sidan Anslutningssträngar för att hämta information om anslutningssträngar. Titta under fliken ODBC.

Not

Om du har installerat Azure Arc- och associerat den med din Azure-prenumeration kan du också använda den hanterade identitetsmetod som visas för appen som distribueras till App Service.

Lägga till kod för att ansluta till Azure SQL Database

I projektmappen skapar du en app.py-fil och lägger till exempelkoden. Den här koden skapar ett API som:

  • Hämtar en Azure SQL Database-anslutningssträng från en miljövariabel.
  • Skapar en Persons tabell i databasen under start (endast för testningsscenarier).
  • Definierar en funktion för att hämta ut alla Person dataposter från databasen.
  • Definierar en funktion för att hämta en Person post från databasen.
  • Definierar en funktion för att lägga till nya Person-poster i databasen.
import os
import pyodbc, struct
from azure import identity

from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel

class Person(BaseModel):
    first_name: str
    last_name: Union[str, None] = None
    
connection_string = os.environ["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("""
            CREATE TABLE Persons (
                ID int NOT NULL PRIMARY KEY IDENTITY,
                FirstName varchar(255),
                LastName varchar(255)
            );
        """)

        conn.commit()
    except Exception as e:
        # Table may 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(f"INSERT INTO Persons (FirstName, LastName) VALUES (?, ?)", item.first_name, item.last_name)
        conn.commit()

    return item

def get_conn():
    credential = identity.DefaultAzureCredential(exclude_interactive_browser_credential=False)
    token_bytes = credential.get_token("https://database.windows.net/.default").token.encode("UTF-16-LE")
    token_struct = struct.pack(f'<I{len(token_bytes)}s', len(token_bytes), token_bytes)
    SQL_COPT_SS_ACCESS_TOKEN = 1256  # This connection option is defined by microsoft in msodbcsql.h
    conn = pyodbc.connect(connection_string, attrs_before={SQL_COPT_SS_ACCESS_TOKEN: token_struct})
    return conn

Varning

Exempelkoden visar råa SQL-uttryck som inte ska användas i produktionskoden. Använd i stället ett ORM-paket (Object Relational Mapper) som SqlAlchemy- som genererar ett säkrare objektlager för åtkomst till databasen.

Köra och testa appen lokalt

Appen är redo att testas lokalt.

  1. Kör filen app.py i Visual Studio Code.

    uvicorn app:app --reload

  2. På swagger-användargränssnittssidan för appen http://127.0.0.1:8000/docsexpanderar du POST-metoden och väljer Prova.

    Du kan också använda prova /redoc för att se en annan form av genererad dokumentation för API:et.

  3. Ändra JSON-exemplet så att det innehåller värden för för- och efternamn. Välj Kör för att lägga till en ny post i databasen. API:et returnerar ett lyckat svar.

  4. Expandera GET-metoden på Swagger UI-sidan och välj Prova det. Välj Köroch den person som du nyss skapade returneras.

Distribuera till Azure App Service

Appen är redo att distribueras till Azure.

  1. Skapa en start.sh-fil så att gunicorn i Azure App Service kan köra uvicorn. start.sh har en rad:

    gunicorn -w 4 -k uvicorn.workers.UvicornWorker app:app

  2. Använd az webapp up för att distribuera koden till App Service. (Du kan använda alternativet -dryrun för att se vad kommandot gör utan att skapa resursen.)

    az webapp up \
    --resource-group <resource-group-name> \
    --name <web-app-name>

  3. Använd kommandot az webapp config set för att konfigurera App Service till att använda start.sh-filen.

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

  4. Använd kommandot az webapp identity assign för att aktivera en systemtilldelad hanteringsidentitet för App Service.

    az webapp identity assign \
    --resource-group <resource-group-name> \
    --name <web-app-name>

    I den här snabbstarten används en systemtilldelad hanterad identitet för demonstration. En användartilldelad hanterad identitet är effektivare i ett bredare spektrum av scenarier. Mer information finns i rekommendationer för bästa praxis för hanterad identitet. Ett exempel på hur du använder en användartilldelad hanterad identitet med pyodbc finns i Migrera ett Python-program för att använda lösenordslösa anslutningar med Azure SQL Database.

Ansluta App Service till Azure SQL Database

I avsnittet Konfigurera databasen konfigurerade du nätverk och Microsoft Entra-autentisering för Azure SQL-databasservern. I det här avsnittet slutför du databaskonfigurationen och konfigurerar App Service med en anslutningssträng för åtkomst till databasservern.

Om du vill köra dessa kommandon kan du använda valfritt verktyg eller IDE som kan ansluta till Azure SQL Database, inklusive SQL Server Management Studio (SSMS), Azure Data Studiooch Visual Studio Code med tillägget SQL Server mssql. Du kan också använda Azure-portalen enligt beskrivningen i Snabbstart: Använd Frågeredigeraren för Azure-portalen för att fråga Azure SQL Database.

  1. Lägg till en användare i Azure SQL Database med SQL-kommandon för att skapa en användare och roll för lösenordslös åtkomst.

    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>]

    Mer information finns i oberoende databasanvändare – Gör databasen portabel. Ett exempel som visar samma princip men som tillämpas på virtuella Azure-datorer finns i Självstudie: Använda en systemtilldelad hanterad identitet för en virtuell Windows-dator för att få åtkomst till Azure SQL. Mer information om tilldelade roller finns i Fasta databasroller.

    Om du inaktiverar och sedan aktiverar den systemtilldelade hanterade identiteten för App Service släpper du användaren och återskapar den. Kör DROP USER [<web-app-name>] och kör kommandona CREATE och ALTER igen. Om du vill se användare använder du SELECT * FROM sys.database_principals.

  2. Använd kommandot az webapp config appsettings set för att lägga till en programinställning för anslutningssträngen.

    az webapp config appsettings set \
    --resource-group <resource-group-name> \
    --name <web-app-name> \
    --settings AZURE_SQL_CONNECTIONSTRING="<connection-string>"

    För den distribuerade appen bör anslutningssträngen likna:

    Driver={ODBC Driver 18 for SQL Server};Server=tcp:<database-server-name>.database.windows.net,1433;Database=<database-name>;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30

    Fyll i <database-server-name> och <database-name> med dina värden.

    Den lösenordslösa anslutningssträngen innehåller inget användarnamn eller lösenord. När appen körs i Azure använder koden i stället DefaultAzureCredential från Azure Identity-biblioteket för att hämta en token som ska användas med pyodbc.

Testa det distribuerade programmet

Bläddra till appens URL för att testa att anslutningen till Azure SQL Database fungerar. Du kan hitta url:en för din app på översiktssidan för App Service.

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

Lägg till /docs till URL:en för att se Swagger-användargränssnittet och testa API-metoderna.

Grattis! Ditt program är nu anslutet till Azure SQL Database i både lokala och värdbaserade miljöer.

Relaterat innehåll