Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Connettore Aurora DSQL per Rust SQLx

L'Aurora DSQL Connector for Rust è un connettore Rust basato su SQLxche integra l'autenticazione IAM per connettere le applicazioni Rust ai cluster DSQL di Amazon Aurora.

Il connettore gestisce la generazione di token, la configurazione SSL e la gestione delle connessioni in modo che tu possa concentrarti sulla logica dell'applicazione.

Informazioni sul connettore

L'Aurora DSQL Connector for Rust aggiunge un livello di autenticazione SQLx che gestisce la generazione di token IAM, consentendoti di connetterti ad Aurora DSQL senza modificare i flussi di lavoro esistenti. SQLx

Cos'è l'autenticazione Aurora SQL?

In Aurora DSQL, l’autenticazione prevede:

L'Aurora DSQL Connector for Rust comprende questi requisiti e genera automaticamente token di autenticazione IAM quando stabilisce connessioni.

Funzionalità

Esempio di applicazione

Per un esempio completo, vedi l'applicazione di esempio su GitHub.

Guida rapida di avvio

Requisiti

Installazione

Aggiungi al tuo: Cargo.toml

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

Per la maggior parte delle applicazioni, abilita sia pool le occ funzionalità che:

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

Bandiere di funzionalità

Utilizzo

Connessione alla piscina

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

Connessione singola

Per script semplici o quando non è necessario il pool di connessioni:

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

Ogni chiamata connection::connect() genera un nuovo token IAM. Per operazioni più lunghe della durata del token, crea una nuova connessione.

Utilizzo avanzato

Configurazione dell'host

Il connettore supporta sia gli endpoint completi del cluster (regione rilevata automaticamente) che il cluster IDs (regione richiesta):

// 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 profili

Specificare un AWS profilo per le credenziali:

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

Formato della stringa di connessione

Il connettore supporta i formati di stringhe di connessione PostgreSQL:

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

Parametri di interrogazione supportati:region,,,profile. tokenDurationSecs ormPrefix

Configurazione del pool

Per impostazioni personalizzate del pool, passa PgPoolOptions aconnect_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?;

Configurazione programmatica

Uso DsqlConnectOptionsBuilder per la configurazione programmatica:

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?;

Riprova OCC

Aurora DSQL utilizza il controllo ottimistico della concorrenza (OCC). Quando due transazioni modificano gli stessi dati, la prima che esegue il commit vince e la seconda riceve un errore OCC.

Il nuovo tentativo OCC è facoltativo. Abilita la occ funzione e usala retry_on_occ per abilitare il nuovo tentativo automatico con backoff e jitter esponenziali:

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?;

Opzioni di configurazione

Autenticazione

Il connettore gestisce automaticamente l'autenticazione Aurora DSQL generando token utilizzando credenziali. AWS Se non fornisci la AWS regione, il connettore la analizza a partire dal nome host.

Per ulteriori informazioni sull'autenticazione in Aurora DSQL, vedere. Autenticazione e autorizzazione per Aurora DSQL

Generazione di token

Amministratore vs. utenti regolari