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

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

Amazon S3 जैसे क्लाउड ऑब्जेक्ट स्टोरेज, फ़ाइलों, बैकअप और मीडिया कंटेंट को स्टोर और डिलीवर करने का मानक बन गए हैं। Rust, एक सिस्टम प्रोग्रामिंग भाषा के रूप में, इन सर्विसेज के साथ इंटीग्रेशन के लिए शक्तिशाली और सुरक्षित टूल्स प्रदान करता है। मुख्य लाइब्रेरी aws-sdk-s3 है - Amazon का Rust के लिए आधिकारिक SDK।

इस लेख में, हम देखेंगे कि प्रोजेक्ट कैसे सेटअप करें, बेसिक ऑपरेशन (अपलोड, डाउनलोड, डिलीट) कैसे करें, और S3-संगत स्टोरेज (जैसे MinIO या Yandex Object Storage) के साथ कैसे काम करें।

इंस्टॉलेशन और सेटअप

Cargo.toml में ये डिपेंडेंसी जोड़ें:

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

ऑथेंटिकेशन के लिए एनवायरनमेंट वेरिएबल या ~/.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"

क्लाइंट इनिशियलाइज़ेशन

एक एसिंक्रोनस S3 क्लाइंट बनाएं:

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);
    // अब client उपयोग के लिए तैयार है
}

S3 में फ़ाइल अपलोड करना (Upload)

डेटा अपलोड करने के लिए put_object मेथड का उपयोग करें। डेटा को बाइट्स या स्ट्रीम के रूप में भेजा जा सकता है:

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!("फ़ाइल {} को {}/{} में अपलोड किया गया", file_path, bucket, key);
    Ok(())
}

फ़ाइल डाउनलोड करना (Get Object)

ऑब्जेक्ट प्राप्त करके लोकल सेव करने के लिए:

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!("फ़ाइल {}/{} को {} में डाउनलोड किया गया", bucket, key, dest_path);
    Ok(())
}

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

बकेट में फ़ाइलों (कीज़) की सूची प्राप्त करें:

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(())
}

ऑब्जेक्ट डिलीट करना

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!("ऑब्जेक्ट {}/{} डिलीट किया गया", bucket, key);
    Ok(())
}

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

MinIO (लोकल S3 इम्यूलेटर) या Yandex Object Storage से कनेक्ट करने के लिए, endpoint को ओवरराइड करना होगा:

use aws_sdk_s3::config::Region;
use aws_sdk_s3::config::Credentials;

async fn create_minio_client() -> C