Travailler avec S3 et les stockages cloud en Rust : la bibliothèque aws-sdk-s3

Travailler avec S3 et les stockages cloud en Rust : aws-sdk-s3

Les stockages d'objets cloud compatibles avec Amazon S3 sont devenus la norme de facto pour le stockage de fichiers, sauvegardes, contenus statiques et données. Dans l'écosystème Rust, le SDK AWS officiel pour Rust — aws-sdk-s3 — est utilisé pour travailler avec S3. Cet outil permet non seulement de se connecter à Amazon S3, mais aussi à tout stockage compatible S3 : MinIO, Yandex Object Storage, DigitalOcean Spaces, Cloudflare R2 et autres.

Installation et configuration

Ajoutez les dépendances suivantes dans Cargo.toml :

[dependencies]aws-sdk-s3 = "1.15"aws-config = "1.1"tokio = { version = "1", features = ["full"] }anyhow = "1.0"

Pour l'authentification, vous pouvez utiliser les variables d'environnement, le fichier de configuration AWS (~/.aws/credentials) ou transmettre les clés par programmation. L'initialisation minimale du client ressemble à ceci :

use aws_sdk_s3::Client;use aws_config::meta::region::RegionProviderChain;

#[tokio::main]async fn main() -> Result<(), anyhow::Error> {    let region_provider = RegionProviderChain::default_provider()        .or_else("ru-central1");    let config = aws_config::from_env()        .region(region_provider)        .load()        .await;    let client = Client::new(&config);    // Ensuite, on travaille avec client    Ok(())}

Opérations principales avec S3

Création d'un bucket

use aws_sdk_s3::model::BucketLocationConstraint;

let bucket_name = "my-rust-bucket";let constraint = BucketLocationConstraint::from("ru-central1");let _ = client    .create_bucket()    .bucket(bucket_name)    .create_bucket_configuration(        aws_sdk_s3::model::CreateBucketConfiguration::builder()            .location_constraint(constraint)            .build()    )    .send()    .await?;

Upload de fichier (PutObject)

use aws_sdk_s3::primitives::ByteStream;use std::path::Path;

let file_path = "local_file.txt";let body = ByteStream::from_path(Path::new(file_path)).await?;

client    .put_object()    .bucket(bucket_name)    .key("uploads/remote_file.txt")    .body(body)    .send()    .await?;println!("Fichier téléchargé");

Téléchargement de fichier (GetObject)

use tokio::io::AsyncWriteExt;

let resp = client    .get_object()    .bucket(bucket_name)    .key("uploads/remote_file.txt")    .send()    .await?;

let mut file = tokio::fs::File::create("downloaded.txt").await?;let mut stream = resp.body;while let Some(chunk) = stream.try_next().await? {    file.write_all(&chunk).await?;}println!("Fichier téléchargé");

Liste des objets dans le bucket

let objects = client    .list_objects_v2()    .bucket(bucket_name)    .prefix("uploads/")    .send()    .await?;

for obj in objects.contents().unwrap_or_default() {    println!("- {}", obj.key().unwrap_or("inconnu"));}

Connexion à MinIO et autres stockages compatibles S3

Pour travailler avec MinIO (ou tout autre stockage non AWS), il est nécessaire de redéfinir l'endpoint et de désactiver la vérification de la signature de région (si nécessaire). Voici un exemple complet :

use aws_sdk_s3::{Client, Config, Credentials, Region};use aws_smithy_client::erase::DynConnector;use aws_smithy_client::hyper_ext;use http::Uri;

let creds = Credentials::new(    "minioadmin",    "minioadmin",    None,    None,    "minio",);

let endpoint = Uri::from_static("http://localhost:9000");let region = Region::new("us-east-1");

let config = Config::builder()    .credentials_provider(creds)    .region(region)    .endpoint_resolver(endpoint)    .force_path_style(true)  // Important pour MinIO    .build();

let client = Client::from_conf(config);// Toutes les opérations avec client passent désormais par MinIO

Veuillez noter