Guia de início rápido: usar o Cloud Storage com Rust

Google Cloud O Storage é um serviço gerenciado para armazenar dados não estruturados.

A biblioteca de cliente Rust fornece uma API idiomática para acessar esse serviço. A biblioteca de cliente retoma downloads e uploads interrompidos e executa automaticamente verificações de integridade nos dados. Para operações de metadados, a biblioteca de cliente pode repetir solicitações com falha e fazer pesquisas automáticas de operações de longa duração.

Este guia mostra como criar um bucket do Cloud Storage, fazer upload de um objeto para ele e ler o objeto de volta.

Antes de começar este guia, crie um projeto do Google Cloud com o faturamento ativado.

Adicionar a dependência da biblioteca de cliente

cargo add google-cloud-storage

Criar um bucket de armazenamento

O cliente para realizar operações em buckets e metadados de objetos é chamado de StorageControl.

    use google_cloud_storage::model::{Bucket, bucket::IamConfig, bucket::iam_config::UniformBucketLevelAccess};
    use google_cloud_storage::client::StorageControl;
    let control = StorageControl::builder().build().await?;

Para criar um bucket, forneça o nome do projeto e o ID do bucket.

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

Também é possível fornecer outros atributos para o bucket. Por exemplo, se você quiser que todos os objetos no bucket usem as mesmas permissões, ative o Acesso uniforme no nível do bucket.

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

Em seguida, envie essa solicitação e aguarde a resposta.

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

Fazer upload de um objeto

O cliente para realizar operações em dados de objetos é chamado de "Storage".

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

Nesse caso, você cria um objeto chamado hello.txt com a saudação Hello World!.

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

Fazer o download de um objeto

Para fazer o download do conteúdo de um objeto, use o método read_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)
    );

Limpar recursos

Por fim, remova o objeto e o bucket para limpar os recursos usados neste guia.

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