Trabajo con S3 y almacenamiento en la nube en Rust |…

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

Los almacenamientos de objetos en la nube, como Amazon S3, se han convertido en el estándar para almacenar y entregar archivos, copias de seguridad y contenido multimedia. Rust, como lenguaje de programación de sistemas, ofrece herramientas potentes y seguras para la integración con estos servicios. La biblioteca principal es aws-sdk-s3 — el SDK oficial de Amazon para Rust.

En este artículo, analizaremos cómo configurar un proyecto, realizar operaciones básicas (carga, descarga, eliminación) y trabajar con almacenamiento compatible con S3 (por ejemplo, MinIO o Yandex Object Storage).

Instalación y configuración

Añada a Cargo.toml:

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

Para la autenticación se utilizan variables de entorno o el archivo ~/.aws/credentials:

export AWS_ACCESS_KEY_ID="your_access_key"export AWS_SECRET_ACCESS_KEY="your_secret_key"export AWS_DEFAULT_REGION="us-east-1"

Inicialización del cliente

Creemos un cliente S3 asíncrono:

use aws_sdk_s3::Client;use aws_config::load_defaults;use aws_config::BehaviorVersion;

#[tokio::main]async fn main() {    let config = load_defaults(BehaviorVersion::latest()).await;    let client = Client::new(&config);    // ahora client está listo para trabajar}

Carga de archivo en S3 (Upload)

Para cargar datos se utiliza el método put_object. Los datos se pueden pasar como bytes o desde un flujo:

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

async fn upload_file(client: &Client, bucket: &str, key: &str, file_path: &str) -> Result<(), Box<dyn std::error::Error>> {    let body = ByteStream::from_path(Path::new(file_path)).await?;        client        .put_object()        .bucket(bucket)        .key(key)        .body(body)        .send()        .await?;        println!("Archivo {} cargado en {}/{}", file_path, bucket, key);    Ok(())}

Descarga de archivo (Get Object)

Para obtener un objeto y guardarlo localmente:

use tokio::io::AsyncWriteExt;

async fn download_file(client: &Client, bucket: &str, key: &str, dest_path: &str) -> Result<(), Box<dyn std::error::Error>> {    let response = client        .get_object()        .bucket(bucket)        .key(key)        .send()        .await?;        let mut file = tokio::fs::File::create(dest_path).await?;    let mut stream = response.body;        while let Some(bytes) = stream.try_next().await? {        file.write_all(&bytes).await?;    }        println!("Archivo {}/{} descargado en {}", bucket, key, dest_path);    Ok(())}

Lista de objetos en el bucket

Obtener la lista de archivos (claves) en el bucket:

async fn list_objects(client: &Client, bucket: &str) -> Result<(), Box<dyn std::error::Error>> {    let objects = client        .list_objects_v2()        .bucket(bucket)        .send()        .await?;        if let Some(contents) = objects.contents {        for obj in contents {            if let Some(key) = obj.key {                println!("- {}", key);            }        }    }    Ok(())}

Eliminación de objeto

async fn delete_object(client: &Client, bucket: &str, key: &str) -> Result<(), Box<dyn std::error::Error>> {    client        .delete_object()        .bucket(bucket)        .key(key)        .send()        .await?;        println!("Objeto {}/{} eliminado", bucket, key);    Ok(())}