Trabajo con S3 y almacenamiento en la nube en Rust: biblioteca aws-sdk-s3

Trabajo con S3 y almacenamiento en la nube en Rust: aws-sdk-s3

Los almacenes de objetos en la nube compatibles con Amazon S3 se han convertido en el estándar de facto para almacenar archivos, copias de seguridad, contenido estático y datos. En el ecosistema de Rust, para trabajar con S3 se utiliza el AWS SDK oficial para Rust: aws-sdk-s3. Esta herramienta permite no solo conectarse a Amazon S3, sino también a cualquier almacenamiento compatible con S3: MinIO, Yandex Object Storage, DigitalOcean Spaces, Cloudflare R2 y otros.

Instalación y configuración

Agregue las siguientes dependencias a Cargo.toml:

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

Para la autenticación, puede usar variables de entorno, el archivo de configuración de AWS (~/.aws/credentials) o pasar las claves mediante programación. La inicialización mínima del cliente se ve así:

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);    // A continuación, trabajamos con client    Ok(())}

Operaciones principales con S3

Creación de 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?;

Carga de archivo (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!("Archivo cargado");

Descarga de archivo (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!("Archivo descargado");

Listado de objetos en el 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("unknown"));}

Conexión a MinIO y otros almacenamientos compatibles con S3

Para trabajar con MinIO (o cualquier otro almacenamiento que no sea de AWS), es necesario sobrescribir el endpoint y deshabilitar la verificación de la firma de la región (si es necesario). Aquí hay un ejemplo completo:

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)  // Importante para MinIO    .build();

let client = Client::from_conf(config);// Todas las operaciones con client ahora se realizan a través de MinIO

Tenga en cuenta