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.

Aurora DSQL-Konnektor für Rust SQLx

Der Aurora DSQL Connector für Rust ist ein Rust-Connector SQLx, der auf der IAM-Authentifizierung für die Verbindung von Rust-Anwendungen mit Amazon Aurora DSQL-Clustern basiert.

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

Der Aurora DSQL Connector for Rust fügt darüber hinaus eine Authentifizierungsebene hinzu SQLx , die die Generierung von IAM-Tokens übernimmt, sodass Sie eine Verbindung zu Aurora DSQL herstellen können, ohne Ihre bestehenden Workflows zu ändern. SQLx

Was ist Aurora DSQL-Authentifizierung?

In Aurora DSQL umfasst die Authentifizierung:

Der Aurora DSQL Connector for Rust versteht diese Anforderungen und generiert beim Verbindungsaufbau automatisch IAM-Authentifizierungstoken.

Features

Beispiel

Ein vollständiges Beispiel finden Sie in der Beispielanwendung unter. GitHub

Schnellstart-Anleitung

Voraussetzungen

Installation

Fügen Sie zu Ihrem Cargo.toml hinzu:

[dependencies]
aurora-dsql-sqlx-connector = "0.1.2"

Aktivieren Sie für die meisten Anwendungen pool sowohl die als auch die occ Funktionen:

[dependencies]
aurora-dsql-sqlx-connector = { version = "0.1.2", features = ["pool", "occ"] }

Feature-Flags

Usage

Verbindung zum Pool

use sqlx::Row;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let pool = aurora_dsql_sqlx_connector::pool::connect(
        "postgres://admin@your-cluster.dsql.us-east-1.on.aws/postgres"
    ).await?;

    // Read
    let row = sqlx::query("SELECT 'Hello, DSQL!' as greeting")
        .fetch_one(&pool)
        .await?;
    let greeting: &str = row.get("greeting");
    println!("{}", greeting);

    // Write — you must wrap writes in a transaction
    let mut tx = pool.begin().await?;
    sqlx::query("INSERT INTO users (id, name) VALUES (gen_random_uuid(), $1)")
        .bind("Alice")
        .execute(&mut *tx)
        .await?;
    tx.commit().await?;

    pool.close().await;
    Ok(())
}

Einzelne -Verbindung

Für einfache Skripte oder wenn Sie kein Verbindungspooling benötigen:

use sqlx::Row;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut conn = aurora_dsql_sqlx_connector::connection::connect(
        "postgres://admin@your-cluster.dsql.us-east-1.on.aws/postgres"
    ).await?;

    let row = sqlx::query("SELECT 1 as value")
        .fetch_one(&mut conn)
        .await?;
    let value: i32 = row.get("value");
    println!("Result: {}", value);

    Ok(())
}

Bei jedem Aufruf von connection::connect() wird ein neues IAM-Token generiert. Für Operationen, die länger als die Tokendauer dauern, erstellen Sie eine neue Verbindung.

Fortgeschrittene Nutzung

Host-Konfiguration

Der Connector unterstützt sowohl vollständige Cluster-Endpunkte (Region automatisch erkannt) als auch Cluster IDs (Region erforderlich):

// Full endpoint (region auto-detected)
let opts = DsqlConnectOptions::from_connection_string(
    "postgres://admin@your-cluster.dsql.us-east-1.on.aws/postgres"
)?;

// Cluster ID (region required)
let opts = DsqlConnectOptions::from_connection_string(
    "postgres://admin@your-cluster-id/postgres?region=us-east-1"
)?;

AWS Profile

Geben Sie ein AWS Profil für Anmeldeinformationen an:

let pool = aurora_dsql_sqlx_connector::pool::connect(
    "postgres://admin@your-cluster.dsql.us-east-1.on.aws/postgres?profile=production"
).await?;

Format der Verbindungszeichenfolge

Der Konnektor unterstützt PostgreSQL-Verbindungszeichenfolgenformate:

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

Unterstützte Abfrageparameter:region,,profile,tokenDurationSecs. ormPrefix

Pool-Konfiguration

Für benutzerdefinierte Pooleinstellungen gehen Sie weiter PgPoolOptions anconnect_with():

use aurora_dsql_sqlx_connector::DsqlConnectOptions;
use sqlx::postgres::PgPoolOptions;

let config = DsqlConnectOptions::from_connection_string(
    "postgres://admin@your-cluster.dsql.us-east-1.on.aws/postgres"
)?;

let pool = aurora_dsql_sqlx_connector::pool::connect_with(
    &config,
    PgPoolOptions::new().max_connections(20),
).await?;

Programmatische Konfiguration

DsqlConnectOptionsBuilderFür die programmatische Konfiguration verwenden:

use aurora_dsql_sqlx_connector::{DsqlConnectOptionsBuilder, Region};
use sqlx::postgres::PgConnectOptions;

let pg = PgConnectOptions::new()
    .host("your-cluster.dsql.us-east-1.on.aws")
    .username("admin")
    .database("postgres");

let opts = DsqlConnectOptionsBuilder::default()
    .pg_connect_options(pg)
    .region(Some(Region::new("us-east-1")))
    .build()?;

let mut conn = aurora_dsql_sqlx_connector::connection::connect_with(&opts).await?;

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.

Die OCC-Wiederholung ist optional. Aktivieren Sie die occ Funktion und verwenden Sie sieretry_on_occ, um automatische Wiederholungsversuche mit exponentiellem Backoff und Jitter zu aktivieren:

use aurora_dsql_sqlx_connector::{retry_on_occ, OCCRetryConfig};

let config = OCCRetryConfig::default(); // max_attempts: 3, exponential backoff

retry_on_occ(&config, || async {
    let mut tx = pool.begin().await?;

    sqlx::query("UPDATE accounts SET balance = balance - 100 WHERE id = $1")
        .bind(account_id)
        .execute(&mut *tx)
        .await?;

    tx.commit().await?;
    Ok(())
}).await?;

Konfigurationsoptionen

Authentifizierung

Der Connector verarbeitet automatisch die Aurora-DSQL-Authentifizierung, indem er mithilfe von AWS Anmeldeinformationen Token generiert. Wenn Sie die AWS Region nicht angeben, analysiert der Connector sie anhand des Hostnamens.

Weitere Informationen zur Authentifizierung in Aurora DSQL finden Sie unterAuthentifizierung und Autorisierung für Aurora DSQL.

Token-Generierung

Admin im Vergleich zu normalen Benutzern