Agrupamento de ligações com go-mssqldb

O controlador go-mssqldb utiliza o pool de ligações integrado fornecido pelo pacote database/sql do Go. Cada sql.DB instância mantém um conjunto de ligações inativas que são reutilizadas automaticamente. Este artigo explica como configurar o pool para a sua carga de trabalho.

Como funciona a piscina

Quando chama db.QueryContext, db.ExecContext ou qualquer outro método de base de dados:

1. A piscina tenta encontrar uma ligação ociosa.
2. Se não houver ligação ociosa e o pool não tiver atingido o seu tamanho máximo, é criada uma nova ligação.
3. Se o conjunto estiver na capacidade máxima, a chamada fica bloqueada até que uma conexão fique disponível.
4. Após a conclusão da operação, a ligação é devolvida ao pool.

Métodos de configuração do pool

Configure o pool usando métodos em *sql.DB:

Exemplo

Configure o pool imediatamente após abrir a base de dados:

db, err := sql.Open("sqlserver", connString)
if err != nil {
    log.Fatal(err)
}

db.SetMaxOpenConns(25)
db.SetMaxIdleConns(10)
db.SetConnMaxLifetime(5 * time.Minute)
db.SetConnMaxIdleTime(1 * time.Minute)

Trate estes valores como ponto de partida, não como um padrão universal. Para muitos serviços, o primeiro passo útil é definir limites limitados MaxOpenConns e MaxIdleConns, e depois adicionar limites de vida útil e de inatividade apenas quando o seu caminho de implementação pode deixá-lo com ligações estagnadas ou distribuídas de forma desigual.

Definições recomendadas

Valores curtos de ConnMaxLifetime e ConnMaxIdleTime reduzem a probabilidade de ligações inativas após failover ou reciclagem do gateway, mas também aumentam a rotatividade das ligações. Se a sua aplicação estabelecer ligação diretamente a uma instância estável do SQL Server e não estiver a detetar falhas causadas por ligações desatualizadas, é razoável deixar ambos os valores em 0.

Monitorizar estatísticas do pool

Use db.Stats() para ler estatísticas atuais do grupo:

stats := db.Stats()
fmt.Printf("Open: %d, InUse: %d, Idle: %d\n",
    stats.OpenConnections, stats.InUse, stats.Idle)
fmt.Printf("WaitCount: %d, WaitDuration: %v\n",
    stats.WaitCount, stats.WaitDuration)

Campos-chave:

Se WaitCount está a crescer de forma constante, não aumente MaxOpenConns automaticamente. Primeiro, verifique se as linhas, transações e ligações dedicadas estão a ser encerradas rapidamente, e confirme que o servidor consegue suportar um pool maior.

SessionInitSQL

Use-se SessionInitSQL para executar uma instrução SQL em cada nova ligação à medida que entra no pool. Esta funcionalidade é útil para definir opções ao nível da sessão:

import (
    "database/sql"
    "github.com/microsoft/go-mssqldb"
    "github.com/microsoft/go-mssqldb/msdsn"
)

config := msdsn.Config{
    Host:     "<server>",
    Port:     1433,
    Database: "AdventureWorks2025",
}

connector := mssql.NewConnectorConfig(config)
connector.SessionInitSQL = "SET ANSI_NULLS ON; SET QUOTED_IDENTIFIER ON"
db := sql.OpenDB(connector)

Fixação de ligação

Certas operações fixam uma ligação para que não seja devolvida ao pool até o fim da operação:

• Transações (db.BeginTx) - A ligação permanece associada até que Commit() ou Rollback() seja chamado.
• Ligações únicas (db.Conn) - A ligação fica fixa até conn.Close() ser invocada.
• Linhas abertas (db.QueryContext) - A ligação é fixada até rows.Close() ser chamada.

Feche sempre estes recursos prontamente para evitar esgotar o pool.

Detetar e resolver o esgotamento da piscina

O esgotamento da piscina ocorre quando todas as ligações estão em uso e a piscina atingiu MaxOpenConns. Os novos chamadores bloqueiam até que a ligação seja retornada. Os sintomas incluem alta latência, acumulação de gorotinas e eventuales erros de prazo de contexto.

Monitorizar sinais de exaustão

Inquérito db.Stats() periodicamente e alerte quando for detetada contenção:

func monitorPool(ctx context.Context, db *sql.DB, interval time.Duration) {
    ticker := time.NewTicker(interval)
    defer ticker.Stop()

    var lastWaitCount int64
    for {
        select {
        case <-ctx.Done():
            return
        case <-ticker.C:
            stats := db.Stats()
            newWaits := stats.WaitCount - lastWaitCount
            lastWaitCount = stats.WaitCount

            if newWaits > 0 {
                log.Printf("POOL CONTENTION: %d new waits, avg wait %v, open=%d, inUse=%d, idle=%d",
                    newWaits, stats.WaitDuration/time.Duration(stats.WaitCount),
                    stats.OpenConnections, stats.InUse, stats.Idle)
            }
        }
    }
}

Causas comuns e soluções

Verificações de saúde e deteção de ligações obsoletas

O pool não valida ativamente as ligações inativas. Uma ligação que ficou inativa enquanto o servidor a reciclava falha na próxima utilização. Configure ConnMaxLifetime e ConnMaxIdleTime para alternar as ligações antes de ficarem inativas:

// Rotate connections every 5 minutes to stay compatible
// with load balancers and Azure SQL failover.
db.SetConnMaxLifetime(5 * time.Minute)

// Close connections that have been idle for over 1 minute
// to reduce the number of stale connections.
db.SetConnMaxIdleTime(1 * time.Minute)

Se a sua aplicação se ligar através de um balanceador de carga ou do SQL do Azure com geo-replicação, defina ConnMaxLifetime para 5 minutos, ou menos. Esta configuração garante que as ligações são redistribuídas entre réplicas após um failover.

Validar a conectividade no arranque

Ligue db.PingContext sempre após abrir a base de dados para confirmar que a cadeia de ligação está correta e que o servidor está acessível:

db, err := sql.Open("sqlserver", connString)
if err != nil {
    log.Fatal(err)
}

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := db.PingContext(ctx); err != nil {
    log.Fatalf("Cannot connect to database: %v", err)
}

Exportar métricas do conjunto

Exponha as estatísticas do pool ao seu sistema de monitorização, lendo periodicamente db.Stats():

Exemplo de Prometheus

Registe medidores que acompanham as estatísticas do pool e atualize-os periodicamente:

import "github.com/prometheus/client_golang/prometheus"

var (
    dbOpenConns = prometheus.NewGauge(prometheus.GaugeOpts{
        Name: "db_open_connections",
        Help: "Number of open database connections.",
    })
    dbInUseConns = prometheus.NewGauge(prometheus.GaugeOpts{
        Name: "db_in_use_connections",
        Help: "Number of connections currently in use.",
    })
    dbWaitCount = prometheus.NewCounter(prometheus.CounterOpts{
        Name: "db_wait_count_total",
        Help: "Total number of times a caller waited for a connection.",
    })
    dbWaitDuration = prometheus.NewCounter(prometheus.CounterOpts{
        Name: "db_wait_duration_seconds_total",
        Help: "Total wait time for a connection.",
    })
)

func init() {
    prometheus.MustRegister(dbOpenConns, dbInUseConns, dbWaitCount, dbWaitDuration)
}

func recordPoolMetrics(ctx context.Context, db *sql.DB) {
    ticker := time.NewTicker(10 * time.Second)
    defer ticker.Stop()

    var lastWaitCount int64
    var lastWaitDuration time.Duration
    for {
        select {
        case <-ctx.Done():
            return
        case <-ticker.C:
            stats := db.Stats()
            dbOpenConns.Set(float64(stats.OpenConnections))
            dbInUseConns.Set(float64(stats.InUse))
            dbWaitCount.Add(float64(stats.WaitCount - lastWaitCount))
            dbWaitDuration.Add((stats.WaitDuration - lastWaitDuration).Seconds())
            lastWaitCount = stats.WaitCount
            lastWaitDuration = stats.WaitDuration
        }
    }
}

Lista de verificação da configuração do pool

Conteúdo relacionado

• Afinação de desempenho
• Programação simultânea
• Opções de ligação
• Base de Dados SQL do Azure
• Troubleshooting