Comece com Rust

Instale o Rust e a Cargo.

Verifique se você tem o Rust 1.74 ou posterior e o Cargo, o gerenciador de pacote do Rust, instalado em seu ambiente de desenvolvimento.

Para obter informações sobre como instalar o Rust and Cargo, consulte o guia oficial do Rust sobre como baixar e instalar o Rust.

Crie um diretório de projeto .

Em sua shell, execute o seguinte comando para criar um diretório chamado rust_quickstart para este projeto:

cargo new rust_quickstart

Quando este comando for concluído com êxito, você terá um arquivo Cargo.toml e um diretório src com um arquivo main.rs no seu diretório rust_quickstart .

Execute o seguinte comando para navegar no diretório do projeto:

cd rust_quickstart

Instale o driver Rust.

Adicione as seguintes caixas de categorização ao seu projeto incluindo-as na lista de dependências localizada no arquivo Cargo.toml do seu projeto:

• mongodb, a caixa do driver Rust

• serde, a caixa de serialização

• futures, uma caixa de tempo de execução assíncrona que fornece abstrações principais

O driver oferece suporte a tempos de execução assíncronos e síncronos. Para ver exemplos de listas de dependências para cada tempo de execução, selecione a partir das seguintes abas Asynchronous API e Synchronous API :

[dependencies]
serde = "1.0.188"
futures = "0.3.28"
tokio = {version = "1.32.0", features = ["full"]}
[dependencies.mongodb]
version = "3.5.2"

[dependencies]
serde = "1.0.188"
[dependencies.mongodb]
version = "3.5.2"
features = ["sync"]

Para saber mais sobre tempos de execução assíncronos e síncronos, consulte o guia deAPIs assíncronas e síncronas .

Crie uma implantação MongoDB gratuita no Atlas.

Complete o guia Iniciar MongoDB para configurar uma nova conta Atlas e carregar dados de amostra em uma nova implantação MongoDB de camada grátis.

Salve suas credenciais.

Depois de criar o usuário do banco de dados, salve o nome de usuário e a senha desse usuário em um local seguro para uso em uma próxima etapa.

Encontre sua string de conexão do MongoDB Atlas.

Para recuperar a string de conexão da implantação criada na etapa anterior, faça login na sua conta do Atlas e navegue até a página Clusters na seção Database. Clique no botão Connect para sua nova implantação.

Se você ainda não tiver um usuário de banco de dados configurado, o MongoDB solicitará que você crie e configure um novo usuário.

Clique no botão Drivers em Connect to your application e selecione "Rust" no menu de seleção Driver e a versão que melhor corresponde à versão instalada no menu de seleção Version.

Certifique-se de que a opção View full code sample esteja desmarcada para visualizar somente a string de conexão.

Copie a string de conexão

Clique no ícone de cópia à direita da string de conexão para copiá-la para a área de transferência, como mostrado na seguinte captura de tela:

Atualize o espaço reservado para senha.

Cole esta string de conexão em um arquivo no editor de texto de sua preferência e substitua o espaço reservado <db_password> pela senha do usuário de banco de dados. A string de conexão já está preenchida com o nome de usuário do seu usuário de banco de dados.

Salve este arquivo em um local seguro para uso na próxima etapa.

Crie seu aplicação Rust .

Abra o arquivo chamado main.rs no seu diretório de projeto do rust_quickstart/src. Neste arquivo, você pode começar a escrever seu aplicação.

Copie e cole o seguinte código no arquivo main.rs:

use mongodb::{ 
	bson::{Document, doc},
	Client,
	Collection 
};
#[tokio::main]
async fn main() -> mongodb::error::Result<()> {
    // Replace the placeholder with your Atlas connection string
    let uri = "<connection string URI>";
    // Create a new client and connect to the server
    let client = Client::with_uri_str(uri).await?;
    // Get a handle on the movies collection
    let database = client.database("sample_mflix");
    let my_coll: Collection<Document> = database.collection("movies");
    // Find a movie based on the title value
    let my_movie = my_coll.find_one(doc! { "title": "The Perils of Pauline" }).await?;
    // Print the document
    println!("Found a movie:\n{:#?}", my_movie);
    Ok(())
}

use mongodb::{ 
	bson::{Document, doc},
	sync::{Client, Collection} 
};
fn main() -> mongodb::error::Result<()> {
    // Replace the placeholder with your Atlas connection string
    let uri = "<connection string URI>";
    // Create a new client and connect to the server
    let client = Client::with_uri_str(uri)?;
    // Get a handle on the movies collection
    let database = client.database("sample_mflix");
    let my_coll: Collection<Document> = database.collection("movies");
    // Find a movie based on the title value
    let my_movie = my_coll
        .find_one(doc! { "title": "The Perils of Pauline" })
        .run()?;
    // Print the document
    println!("Found a movie:\n{:#?}", my_movie);
    Ok(())
}

Atribua a string de conexão.

Substitua o placeholder <connection string URI> pela string de conexão que você copiou da etapa Criar uma Connection string deste guia.

Execute seu aplicação Rust .

A partir do seu diretório de projeto rust_quickstart, execute o seguinte comando para compilar e executar este aplicação:

cargo run

A saída da linha de comando contém detalhes sobre o documento de filme recuperado:

Found a movie:
Some(
    Document({
        "_id": ObjectId(...),
        "title": String(
            "The Perils of Pauline",
        ),
        "plot": String(
            "Young Pauline is left a lot of money ...",
        ),
        "runtime": Int32(
            199,
        ),
        "cast": Array([
            String(
                "Pearl White",
            ),
            String(
                "Crane Wilbur",
            ),
            ...
        ]),
    }),
)

Se você encontrar um erro ou não vir nenhuma saída, verifique se especificou a string de conexão adequada no arquivo main.rs e se carregou os dados de amostra.