Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Verbindung zu Aurora DSQL-Clustern mit einem Go-Connector herstellen

Der Aurora DSQL Connector for Go umschließt PGX mit automatischer IAM-Authentifizierung. Der Connector kümmert sich um die Token-Generierung, die SSL-Konfiguration und das Verbindungsmanagement, sodass Sie sich auf Ihre Anwendungslogik konzentrieren können.

Über den Konnektor

Aurora DSQL erfordert eine IAM-basierte Authentifizierung mit zeitlich begrenzten Token, die bestehende Go PostgreSQL-Treiber nicht nativ unterstützen. Der Aurora DSQL Connector for Go fügt dem pgx-Treiber eine Authentifizierungsebene hinzu, die die IAM-Token-Generierung übernimmt, sodass Sie eine Verbindung zu Aurora DSQL herstellen können, ohne Ihre bestehenden pgx-Workflows zu ändern.

Was ist Aurora DSQL-Authentifizierung?

In Aurora DSQL umfasst die Authentifizierung:

Der Aurora DSQL Connector for Go wurde entwickelt, um diese Anforderungen zu verstehen und beim Verbindungsaufbau automatisch IAM-Authentifizierungstoken zu generieren.

Vorteile des Aurora DSQL Connector for Go

Mit dem Aurora DSQL Connector for Go können Sie Ihre bestehenden PGX-Workflows weiterhin verwenden und gleichzeitig die IAM-Authentifizierung aktivieren über:

Schlüssel-Features

Voraussetzungen

Der Connector verwendet die standardmäßige Anmeldeinformationskette des AWS SDK for Go v2, die Anmeldeinformationen in der folgenden Reihenfolge auflöst:

Installation

Installieren Sie den Connector mithilfe von Go-Modulen:

go get github.com/awslabs/aurora-dsql-connectors/go/pgx/dsql

Schnellstart

Das folgende Beispiel zeigt, wie Sie einen Verbindungspool erstellen und eine Abfrage ausführen:

package main

import (
    "context"
    "log"
    
    "github.com/awslabs/aurora-dsql-connectors/go/pgx/dsql"
)

func main() {
    ctx := context.Background()
    
    // Create a connection pool
    pool, err := dsql.NewPool(ctx, dsql.Config{
        Host: "your-cluster.dsql.us-east-1.on.aws",
    })
    if err != nil {
        log.Fatal(err)
    }
    defer pool.Close()
    
    // Execute a query
    var greeting string
    err = pool.QueryRow(ctx, "SELECT 'Hello, DSQL!'").Scan(&greeting)
    if err != nil {
        log.Fatal(err)
    }
    log.Println(greeting)
}

Konfigurationsoptionen

Der Connector unterstützt die folgenden Konfigurationsoptionen:

Format der Verbindungszeichenfolge

Der Connector unterstützt PostgreSQL- und DSQL-Verbindungszeichenfolgenformate:

postgres://[user@]host[:port]/[database][?param=value&...]
dsql://[user@]host[:port]/[database][?param=value&...]

Unterstützte Abfrageparameter:

Beispiele:

// Full endpoint (region auto-detected)
pool, _ := dsql.NewPool(ctx, "postgres://admin@cluster.dsql.us-east-1.on.aws/postgres")

// Using dsql:// scheme (also supported)
pool, _ := dsql.NewPool(ctx, "dsql://admin@cluster.dsql.us-east-1.on.aws/postgres")

// With explicit region
pool, _ := dsql.NewPool(ctx, "postgres://admin@cluster.dsql.us-east-1.on.aws/mydb?region=us-east-1")

// With AWS profile
pool, _ := dsql.NewPool(ctx, "postgres://admin@cluster.dsql.us-east-1.on.aws/postgres?profile=dev")

Fortgeschrittene Nutzung

Host-Konfiguration

Der Connector unterstützt zwei Host-Formate:

Vollständiger Endpunkt (Region automatisch erkannt):

pool, _ := dsql.NewPool(ctx, dsql.Config{
    Host: "your-cluster.dsql.us-east-1.on.aws",
})

Cluster-ID (Region erforderlich):

pool, _ := dsql.NewPool(ctx, dsql.Config{
    Host:   "your-cluster-id",
    Region: "us-east-1",
})

Optimierung der Poolkonfiguration

Konfigurieren Sie den Verbindungspool für Ihren Workload:

pool, err := dsql.NewPool(ctx, dsql.Config{
    Host:              "your-cluster.dsql.us-east-1.on.aws",
    MaxConns:          20,
    MinConns:          5,
    MaxConnLifetime:   time.Hour,
    MaxConnIdleTime:   30 * time.Minute,
    HealthCheckPeriod: time.Minute,
})

Nutzung einer einzelnen Verbindung

Für einfache Skripte oder wenn kein Verbindungspooling benötigt wird:

conn, err := dsql.Connect(ctx, dsql.Config{
    Host: "your-cluster.dsql.us-east-1.on.aws",
})
if err != nil {
    log.Fatal(err)
}
defer conn.Close(ctx)

// Use the connection
rows, err := conn.Query(ctx, "SELECT * FROM users")

Profile verwenden AWS

Geben Sie ein AWS Profil für Anmeldeinformationen an:

pool, err := dsql.NewPool(ctx, dsql.Config{
    Host:    "your-cluster.dsql.us-east-1.on.aws",
    Profile: "production",
})

OCC-Wiederholung

Aurora DSQL verwendet Optimistic Concurrency Control (OCC). Wenn zwei Transaktionen dieselben Daten ändern, gewinnt die erste Transaktion, die einen Commit durchführt, und die zweite erhält einen OCC-Fehler.

Das occretry Paket bietet Hilfsprogramme für automatische Wiederholungen bei exponentiellem Backoff und Jitter. Installiere es mit:

go get github.com/awslabs/aurora-dsql-connectors/go/pgx/occretry

WithRetryFür transaktionale Schreibvorgänge verwenden:

err := occretry.WithRetry(ctx, pool, occretry.DefaultConfig(), func(tx pgx.Tx) error {
    _, err := tx.Exec(ctx, "UPDATE accounts SET balance = balance - $1 WHERE id = $2", 100, fromID)
    if err != nil {
        return err
    }
    _, err = tx.Exec(ctx, "UPDATE accounts SET balance = balance + $1 WHERE id = $2", 100, toID)
    return err
})

Verwenden Sie für DDL- oder Einzelanweisungen: ExecWithRetry

err := occretry.ExecWithRetry(ctx, pool, occretry.DefaultConfig(),
    "CREATE TABLE IF NOT EXISTS users (id UUID PRIMARY KEY, name TEXT)")

Beispiele

Umfassendere Beispiele und Anwendungsfälle finden Sie in den Aurora DSQL Connector for Go-Beispielen.