Comece com Rust

Instale o Rust e a Cargo.

Verifique se você tem o Rust 1.88 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 visualizar listas de dependências de exemplo para cada tempo de execução, selecione entre as 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.9.1"

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

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

Crie uma implantação MongoDB gratuita no Atlas.

Complete the MongoDB Get Started guide to set up a new Atlas account and load sample data into a new free tier MongoDB deployment.

Salve suas credenciais.

Depois de criar o usuário de 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.

To retrieve your connection string for the deployment that you created in the previous step, log in to your Atlas account and navigate to the Clusters page under the Database section. Click the Connect button for your new deployment.

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 aplicativo 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 aplicativo.

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.

Replace the <connection string URI> placeholder with the connection string that you copied from the Create a Connection String step of this guide.

Execute seu aplicativo Rust.

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

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.