Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Connexion aux clusters SQL Aurora à l'aide d'un connecteur Go

Le connecteur SQL Aurora pour Go intègre l'authentification IAM automatique à pgx. Le connecteur gère la génération de jetons, la configuration SSL et la gestion des connexions afin que vous puissiez vous concentrer sur la logique de votre application.

À propos du connecteur

Aurora DSQL nécessite une authentification basée sur IAM avec des jetons limités dans le temps que les pilotes Go PostgreSQL existants ne prennent pas en charge de manière native. Le connecteur Aurora DSQL pour Go ajoute une couche d'authentification au-dessus du pilote pgx qui gère la génération de jetons IAM, ce qui vous permet de vous connecter à Aurora DSQL sans modifier vos flux de travail pgx existants.

Qu’est-ce que l’authentification Aurora DSQL ?

Dans Aurora DSQL, l’authentification implique :

Le connecteur Aurora DSQL pour Go est conçu pour comprendre ces exigences et générer automatiquement des jetons d'authentification IAM lors de l'établissement de connexions.

Avantages du connecteur Aurora DSQL pour Go

Le connecteur SQL Aurora pour Go vous permet de continuer à utiliser vos flux de travail pgx existants tout en activant l'authentification IAM via :

Fonctions principales

Conditions préalables

Le connecteur utilise la chaîne d'informations d'identification par défaut du AWS SDK for Go v2, qui résout les informations d'identification dans l'ordre suivant :

Installation

Installez le connecteur à l'aide des modules Go :

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

Démarrage rapide

L'exemple suivant montre comment créer un pool de connexions et exécuter une requête :

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)
}

Options de configuration

Le connecteur prend en charge les options de configuration suivantes :

Format de chaîne de connexion

Le connecteur prend en charge les formats de chaîne de connexion PostgreSQL et DSQL :

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

Paramètres de requête pris en charge :

Exemples :

// 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")

Utilisation avancée

Configuration de l’hôte

Le connecteur prend en charge deux formats d'hôte :

Point de terminaison complet (région détectée automatiquement) :

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

ID du cluster (région requise) :

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

Réglage de la configuration du pool

Configurez le pool de connexions pour votre charge de travail :

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,
})

Utilisation d'une connexion unique

Pour les scripts simples ou lorsque le regroupement de connexions n'est pas nécessaire :

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")

Utilisation de AWS profils

Spécifiez un AWS profil pour les informations d'identification :

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

Réessayer OCC

Aurora DSQL utilise un contrôle de simultanéité optimiste (OCC). Lorsque deux transactions modifient les mêmes données, la première à valider gagne et la seconde reçoit une erreur OCC.

Le occretry package fournit des aides pour une nouvelle tentative automatique avec un recul et une instabilité exponentiels. Installez-le avec :

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

Utilisation WithRetry pour les écritures transactionnelles :

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
})

Pour les instructions DDL ou uniques, utilisez ExecWithRetry :

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

Exemples

Pour des exemples et des cas d'utilisation plus complets, reportez-vous aux exemples d'Aurora DSQL Connector for Go.