Cloud Storage mit Rust verwenden

Cloud Storage ist ein verwalteter Dienst zum Speichern unstrukturierter Daten. Das google-cloud-storage-Crate in den Cloud-Clientbibliotheken für Rust bietet eine idiomatische Rust API, die unterbrochene Uploads und Downloads fortsetzt, die Datenintegrität prüft, vorübergehende Metadatenfehler wiederholt und Vorgänge mit langer Ausführungszeit abfragt.

In diesem Dokument wird beschrieben, wie Sie einen Cloud Storage-Bucket erstellen, ein Objekt in diesen Bucket schreiben, den Objektinhalt lesen und beide Ressourcen löschen.

Hinweis

Bevor Sie den Code in diesem Dokument ausführen, müssen die folgenden Voraussetzungen erfüllt sein:

Abhängigkeiten

Fügen Sie die Cloud Storage-Clientbibliothek und die unterstützenden Crates der Datei Cargo.toml hinzu:

cargo add google-cloud-storage anyhow bytes
cargo add tokio --features macros,rt-multi-thread

Bucket erstellen

Vorgänge für Buckets und Objektmetadaten verwenden den StorageControl-Client:

  1. Initialisieren Sie einen StorageControl-Client: 

    use google_cloud_storage as gcs;
use google_cloud_storage::client::StorageControl;
let control = StorageControl::builder().build().await?;

  2. Konfigurieren Sie eine create_bucket-Anfrage mit Ihrer Projekt-ID und der global eindeutigen Bucket-ID: 

    let bucket = control
    .create_bucket()
    .set_parent("projects/_")
    .set_bucket_id(bucket_id)
    .set_bucket(
        gcs::model::Bucket::new()
            .set_project(format!("projects/{project_id}"))
    )

  3. Optional: Konfigurieren Sie Bucket-Attribute wie den einheitlichen Zugriff auf Bucket-Ebene: 

    gcs::model::Bucket::new()
    .set_project(format!("projects/{project_id}"))
    .set_iam_config(
        gcs::model::bucket::IamConfig::new().set_uniform_bucket_level_access(
            gcs::model::bucket::iam_config::UniformBucketLevelAccess::new()
                .set_enabled(true),
        ),
    ),

  4. Senden Sie die Anfrage und warten Sie auf die erstellten Bucket-Metadaten: 

        .send()
    .await?;
println!("bucket successfully created {bucket:?}");

Objekt schreiben

Vorgänge, die Objektdaten lesen oder schreiben, verwenden den Storage-Client:

  1. Initialisieren Sie einen Storage-Client: 

    use google_cloud_storage::client::Storage;
let client = Storage::builder().build().await?;

  2. Schreiben Sie mit write_object ein Objekt mit dem Namen hello.txt in den Bucket: 

    let object = client
    .write_object(&bucket.name, "hello.txt", "Hello World!")
    .send_buffered()
    .await?;
println!("object successfully uploaded {object:?}");

Objekt lesen

Wenn Sie den Inhalt eines Objekts lesen möchten, rufen Sie read_object auf und erfassen Sie die gestreamten Blöcke:

let mut reader = client.read_object(&bucket.name, "hello.txt").send().await?;
let mut contents = Vec::new();
while let Some(chunk) = reader.next().await.transpose()? {
    contents.extend_from_slice(&chunk);
}
println!(
    "object contents successfully downloaded {:?}",
    bytes::Bytes::from_owner(contents)
);

Bei der Ausführung dieses Schritts werden die heruntergeladenen Byte ausgegeben:

object contents successfully downloaded b"Hello World!"

Objekt und Bucket löschen

Löschen Sie das Objekt und den Bucket in Ihrem Programm, wenn sie nicht mehr benötigt werden:

control
    .delete_object()
    .set_bucket(&bucket.name)
    .set_object(&object.name)
    .set_generation(object.generation)
    .send()
    .await?;
control
    .delete_bucket()
    .set_name(&bucket.name)
    .send()
    .await?;

Vollständiger Code

Die folgende Funktion kombiniert alle vorherigen Schritte:

pub async fn sample(project_id: &str, bucket_id: &str) -> anyhow::Result<()> {
    use google_cloud_storage as gcs;
    use google_cloud_storage::client::StorageControl;
    let control = StorageControl::builder().build().await?;
    let bucket = control
        .create_bucket()
        .set_parent("projects/_")
        .set_bucket_id(bucket_id)
        .set_bucket(
            gcs::model::Bucket::new()
                .set_project(format!("projects/{project_id}"))
                .set_iam_config(
                    gcs::model::bucket::IamConfig::new().set_uniform_bucket_level_access(
                        gcs::model::bucket::iam_config::UniformBucketLevelAccess::new()
                            .set_enabled(true),
                    ),
                ),
        )
        .send()
        .await?;
    println!("bucket successfully created {bucket:?}");

    use google_cloud_storage::client::Storage;
    let client = Storage::builder().build().await?;

    let object = client
        .write_object(&bucket.name, "hello.txt", "Hello World!")
        .send_buffered()
        .await?;
    println!("object successfully uploaded {object:?}");

    let mut reader = client.read_object(&bucket.name, "hello.txt").send().await?;
    let mut contents = Vec::new();
    while let Some(chunk) = reader.next().await.transpose()? {
        contents.extend_from_slice(&chunk);
    }
    println!(
        "object contents successfully downloaded {:?}",
        bytes::Bytes::from_owner(contents)
    );

    control
        .delete_object()
        .set_bucket(&bucket.name)
        .set_object(&object.name)
        .set_generation(object.generation)
        .send()
        .await?;
    control
        .delete_bucket()
        .set_name(&bucket.name)
        .send()
        .await?;

    Ok(())
}

Bereinigen

Wenn das Beispiel vorzeitig beendet wird, bevor die Löschschritte ausgeführt werden, löschen Sie den Bucket manuell, damit Ihnen keine laufenden Gebühren für die in diesem Dokument erstellten Ressourcen entstehen.