Anslutningspoolning med mssql-python

Anslutningspoolning förbättrar applikationens prestanda genom att återanvända databasanslutningar istället för att skapa nya för varje förfrågan. Att öppna en anslutning innebär flera tidskrävande steg:

• Drivrutinen upprättar en nätverkssocket.
• Föraren fullföljer TLS-handskakningen.
• Drivrutinen autentiserar sig mot servern.
• Drivrutinen validerar anslutningsparametrar.

Anslutningspooling håller anslutningarna öppna och tillgängliga för återanvändning, så din app behöver inte upprepa dessa steg för varje förfrågan.

Standardbeteende

Anslutningspoolning är aktiverad som standard när du skapar din första anslutning. Standardinställningarna är:

Inställning	Standardvärdet	Beskrivning
max_size	100	Maximalt antal anslutningar per unik anslutningssträng.
idle_timeout	600 sekunder (10 minuter)	Antal sekunder innan inaktiva anslutningar stängs.

import mssql_python

# Pooling is automatically enabled with defaults
conn = mssql_python.connect(connection_string)

Konfigurera anslutningspooler

Konfigurera pooling innan du skapar några anslutningar:

import mssql_python

# Configure custom pool settings
mssql_python.pooling(max_size=50, idle_timeout=300)

# Now create connections
conn = mssql_python.connect(connection_string)

Parameters

Funktionen pooling() accepterar följande parametrar:

Parameter	Type	Standardinställning	Beskrivning
max_size	int	100	Maxantal poolade anslutningar per reťazec pripojenia.
idle_timeout	int	600	Sekunder innan inaktiva anslutningar tas bort från poolen.
enabled	bool	Sann	Aktivera eller inaktivera poolning.

Inaktivera anslutningspooling

För att inaktivera pooling, ring pooling() med enabled=False innan du skapar anslutningar:

import mssql_python

mssql_python.pooling(enabled=False)

# Connections are now created and destroyed per use
conn = mssql_python.connect(connection_string)

Note

Ställ in poolkonfigurationen innan du etablerar några anslutningar. Att ringa pooling() efter att ha skapat kontakter har ingen effekt.

Så här fungerar poolning

Anslutningssträngisolering

Varje unik anslutningssträng har sin egen oberoende pool. Pooler delar inte kopplingar över olika anslutningssträngar:

# These use separate pools
conn1 = mssql_python.connect("Server=<server1>;Database=<database1>;...")
conn2 = mssql_python.connect("Server=<server2>;Database=<database2>;...")

Anslutningslivscykel

Skaffa (få en kontakt):

1. Poolen tar bort föråldrade (utgångna) anslutningar.
2. Poolen försöker återanvända en befintlig anslutning:
   • Den kontrollerar om anslutningen är aktiv.
   • Den återställer anslutningstillståndet.
   • Om båda kontrollerna lyckas, returnerar den anslutningen.
3. Om ingen återanvändbar anslutning finns och poolen är under max_size, skapar drivrutinen en ny anslutning.
4. Om poolen har nått kapacitetstaket utan några giltiga anslutningar utlöser drivrutinen ett fel.

Släpp (återvänder en anslutning):

1. Om poolen har kapacitet lagrar den anslutningen för återanvändning.
2. Om poolen är på max_size, stänger föraren anslutningen omedelbart.

Kontroller av anslutningsstatus

Drivrutinen utför kontroller av anslutningens status innan den återanvänder en anslutning i poolen.

1. Alive-kontroll: Säkerställer att nätverksanslutningen fortfarande är giltig.
2. Återställ kontroll: Återställer sessionstillstånd (isoleringsnivå, inställningar) för ren återanvändning.

Om någon av kontrollerna misslyckas slänger poolen anslutningen och skapar en ny.

Automatisk sanering

• Vilolägestid: Drivrutinen stänger anslutningar som är oanvända längre än värdet idle_timeout .
• Processavslut: En atexit hanterare stänger alla poolade anslutningar när Python-processen avslutas.

Metodtips

Dimensionera din pool rätt

Anpassa poolstorleken efter applikationens grad av samtidighet.

# For a web application with 20 concurrent requests
mssql_python.pooling(max_size=25)  # Slightly more than expected concurrency

Använd kontexthanterare

Kontexthanterare ser till att du returnerar anslutningar till poolen på rätt sätt.

with mssql_python.connect(connection_string) as conn:
    cursor = conn.cursor()
    cursor.execute("SELECT TOP 5 Name, ListPrice FROM Production.Product")
    rows = cursor.fetchall()
# Connection returned to pool

Håll anslutningssträngarna konsekventa

Olika parametrar i anslutningssträngar skapar separata pooler.

# These create THREE separate pools (inefficient)
conn1 = mssql_python.connect("Server=<server>;Database=<database>;Encrypt=yes;")
conn2 = mssql_python.connect("SERVER=<server>;DATABASE=<database>;ENCRYPT=yes;")  # Different case
conn3 = mssql_python.connect("Server=<server>;Database=<database>;Encrypt=yes;", timeout=30)  # Extra parameter

# Use a constant connection string instead
CONNECTION_STRING = "Server=<server>;Database=<database>;Encrypt=yes;"
conn1 = mssql_python.connect(CONNECTION_STRING)
conn2 = mssql_python.connect(CONNECTION_STRING)  # Same pool

Betrakta Azure SQL-anslutningsgränser

Azure SQL Database upprätthåller anslutningsgränser baserat på tjänstenivån. Följande värden är ungefärliga; Kontrollera den länkade dokumentationen för aktuella gränser:

Tjänstnivå	Maximalt antal samtidiga anslutningar
Basic	30
Standard S0-S2	60-120
Standard S3 och senare versioner	200
Premium	500

Bedöm värdet max_size under dessa gränser.

# For Azure SQL Standard S2 (120 limit)
mssql_python.pooling(max_size=100)  # Leave headroom

Justera tidsgränsen för inaktivitet för din arbetslast

• Frekventa anslutningar: Använd ett längre idle_timeout värde för att hålla anslutningarna varma.
• Sporadiska kopplingar: Använd ett kortare idle_timeout värde för att frigöra resurser.

# High-frequency API: keep connections warm
mssql_python.pooling(idle_timeout=1800)  # 30 minutes

# Batch job running every hour: release between runs
mssql_python.pooling(idle_timeout=60)  # 1 minute

Limitations

Den nuvarande implementeringen har vissa begränsningar jämfört med andra drivrutiner:

Feature	Status
ClearPool() / ClearAllPools()	Inte tillgängligt.
Poolstatistik/övervakning	Inte tillgängligt.
Överstyrning per anslutningspool	Inte tillgängligt.
Minsta poolstorlek	Kan inte konfigureras.

Exempel: Mönster för webbapplikationer

Följande Flask-exempel visar hur anslutningar poolas transparent över förfrågningar:

import mssql_python
from flask import Flask, g

app = Flask(__name__)

# Configure pooling at startup
mssql_python.pooling(max_size=20, idle_timeout=300)

def get_db():
    if 'db' not in g:
        g.db = mssql_python.connect(app.config['DATABASE_URL'])
    return g.db

@app.teardown_appcontext
def close_db(error):
    db = g.pop('db', None)
    if db is not None:
        db.close()  # Returns to pool

@app.route('/products')
def list_products():
    conn = get_db()
    cursor = conn.cursor()
    cursor.execute("SELECT TOP 5 Name, ListPrice FROM Production.Product")
    return cursor.fetchall()

Känn igen poolutmattning

När alla anslutningar i poolen används och du begär en ny anslutning ser du symtom som:

• Anslutningar hänger sig eller får timeout i väntan på en ledig anslutning.
• Applikationsgenomströmningen sjunker plötsligt under belastning.
• Minnesanvändningen ökar när drivrutinen skapar kopplingar som den inte kan återanvända.

Vanliga orsaker:

• Anslutningarna återförs inte till poolen. Stäng alltid kontakterna när du är klar, eller använd kontexthanterare. En anslutning som inte är stängd förblir kontrollerad.
• Poolstorleken är för liten för arbetsbördan. Om du har 50 samtidiga begäranden men max_size=20, får 30 begäranden vänta.
• Långvariga frågor håller kopplingar. Dela upp långa operationer eller använd dedikerade anslutningar för batcharbete.

Så här åtgärdar du:

# 1. Always use context managers to guarantee return
with mssql_python.connect(connection_string) as conn:
    cursor = conn.cursor()
    cursor.execute("SELECT ...")
    rows = cursor.fetchall()
# Connection returned to pool here, even if an exception occurs

# 2. Size the pool to match your concurrency
mssql_python.pooling(max_size=50)  # Match or slightly exceed expected concurrent connections

# 3. Reduce idle timeout if connections go stale
mssql_python.pooling(idle_timeout=120)

Relaterat innehåll

• Anslutningshantering
• Anslutningssträngar
• Prestandaoptimering