Rust में S3 और क्लाउड स्टोरेज के साथ काम करना: aws-sdk-s3 लाइब्रेरी

Rust में S3 और क्लाउड स्टोरेज के साथ काम करना: aws-sdk-s3

Amazon S3 के साथ संगत क्लाउड ऑब्जेक्ट स्टोरेज, फ़ाइलों, बैकअप, स्टैटिक और डेटा को स्टोर करने के लिए डी-फैक्टो मानक बन गए हैं। Rust इकोसिस्टम में S3 के साथ काम करने के लिए आधिकारिक AWS SDK for Rust — aws-sdk-s3 का उपयोग किया जाता है। यह टूल न केवल Amazon S3 से कनेक्ट करने की अनुमति देता है, बल्कि किसी भी S3-संगत स्टोरेज: MinIO, Yandex Object Storage, DigitalOcean Spaces, Cloudflare R2 और अन्य से भी कनेक्ट करने की अनुमति देता है।

स्थापना और कॉन्फ़िगरेशन

Cargo.toml में निम्नलिखित डिपेंडेंसी जोड़ें:

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

प्रमाणीकरण के लिए, आप एनवायरनमेंट वेरिएबल, AWS कॉन्फ़िगरेशन फ़ाइल (~/.aws/credentials) का उपयोग कर सकते हैं या प्रोग्रामेटिक रूप से कुंजियाँ पास कर सकते हैं। न्यूनतम क्लाइंट इनिशियलाइज़ेशन इस प्रकार दिखता है:

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);    // अब client के साथ काम करें    Ok(())}

S3 के साथ मुख्य संचालन

बकेट बनाना

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

फ़ाइल अपलोड करना (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!("फ़ाइल अपलोड हो गई");

फ़ाइल डाउनलोड करना (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!("फ़ाइल डाउनलोड हो गई");

बकेट में ऑब्जेक्ट्स की सूची

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

MinIO और अन्य S3-संगत स्टोरेज से कनेक्ट करना

MinIO (या किसी अन्य गैर-AWS स्टोरेज) के साथ काम करने के लिए, endpoint को ओवरराइड करना और क्षेत्र हस्ताक्षर सत्यापन को अक्षम करना आवश्यक है (यदि आवश्यक हो)। यहाँ एक पूर्ण उदाहरण है:

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)  // MinIO के लिए महत्वपूर्ण    .build();

let client = Client::from_conf(config);// अब client के साथ सभी संचालन MinIO के माध्यम से होंगे

ध्यान दें