Trabalhando com S3 em Rust: aws-sdk-s3 e MinIO

Trabalhando com S3 e armazenamentos em nuvem em Rust: aws-sdk-s3

Os armazenamentos de objetos em nuvem compatíveis com Amazon S3 tornaram-se o padrão de facto para armazenar arquivos, backups, conteúdo estático e dados. No ecossistema Rust, o SDK oficial da AWS para Rust — aws-sdk-s3 — é usado para trabalhar com S3. Esta ferramenta permite conectar-se não apenas ao Amazon S3, mas também a qualquer armazenamento compatível com S3: MinIO, Yandex Object Storage, DigitalOcean Spaces, Cloudflare R2 e outros.

Instalação e configuração

Adicione as seguintes dependências ao Cargo.toml:

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

Para autenticação, você pode usar variáveis de ambiente, o arquivo de configuração da AWS (~/.aws/credentials) ou passar as chaves programaticamente. A inicialização mínima do cliente é assim:

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);    // Em seguida, trabalhamos com client    Ok(())}

Operações básicas com S3

Criação de 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 arquivo (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!("Arquivo enviado");

Download de arquivo (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!("Arquivo baixado");

Listar objetos no 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"));}

Conexão ao MinIO e outros armazenamentos compatíveis com S3

Para trabalhar com MinIO (ou qualquer outro armazenamento não-AWS), é necessário sobrescrever o endpoint e desabilitar a verificação de assinatura de região (se necessário). Aqui está um exemplo 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 as operações com client agora passam pelo MinIO

Observe