Comienza a usar Rust

Instalar Rust and Cargo.

Asegúrese de tener Rust 1.74 o posterior y Cargo, el gestor de paquetes de Rust, instalados en su entorno de desarrollo.

Para obtener información sobre cómo instalar Rust y Cargo, consulte la guía oficial de Rust sobre cómo descargar e instalar Rust.

Crea un directorio de proyecto.

En tu shell, ejecuta el siguiente comando para crear un directorio llamado rust_quickstart para este proyecto:

cargo new rust_quickstart

Cuando este comando se complete exitosamente, tendrá un archivo Cargo.toml y un directorio src con un archivo main.rs en su directorio rust_quickstart.

Ejecute el siguiente comando para navegar en el directorio del proyecto:

cd rust_quickstart

Instala el controlador de Rust.

Agrega las siguientes cajas a tu proyecto al incluirlos en la lista de dependencias que se encuentra en el archivo Cargo.toml de tu proyecto:

• mongodb, la caja del controlador Rust

• serde, la caja de serialización

• futures, una caja de runtime asíncrono que proporciona abstracciones básicas

El controlador admite tanto tiempos de ejecución asíncronos como sincrónicos. Para ver listas de dependencias de ejemplo para cada runtime, selecciona entre las siguientes opciones Asynchronous API y pestañas 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 obtener más información sobre los entornos de ejecución asíncronos y síncronos, consulte el Guía de APIs asíncronas y síncronas.

Crea una implementación gratuita de MongoDB en Atlas.

Completa la Guía de inicio de MongoDB para configurar una nueva cuenta de Atlas y cargar datos de muestra en una nueva implementación de MongoDB de nivel gratuito.

Guarda tus credenciales.

Después de crear un usuario de base de datos, guardar el nombre de usuario y la contraseña de ese usuario en una ubicación segura para usarlos en un paso próximo.

Encuentra tu cadena de conexión de MongoDB Atlas.

Para recuperar la cadena de conexión para la implementación que creó en el paso anterior, inicie sesión en su cuenta de Atlas y navegue a la página Clusters bajo la sección Database. Haga clic en el botón Connect para la nueva implementación.

Si aún no tienes configurado un usuario de base de datos, MongoDB te pedirá que crees y configures un nuevo usuario.

Haz clic en el botón Drivers debajo de Connect to your application y selecciona "Rust" en el menú de selección Driver y la versión que más se asemeje a la versión que instalaste en el menú de selección Version.

Asegúrate de que la opción View full code sample esté desmarcada para ver solo la cadena de conexión.

Copie su cadena de conexión.

Haga clic en el icono de copia a la derecha de la cadena de conexión para copiarla al portapapeles como se muestra en la siguiente captura de pantalla:

Actualiza el marcador de posición de la contraseña.

Pega esta cadena de conexión en un archivo en tu editor de texto preferido y reemplaza el marcador de posición <db_password> con la contraseña de tu usuario de base de datos. La cadena de conexión ya está completada con el nombre de usuario de tu usuario de base de datos.

Guarda este archivo en una ubicación segura para usarlo en el siguiente paso.

Crea tu aplicación Rust.

Abre el archivo llamado main.rs en el directorio de tu proyecto rust_quickstart/src. En este archivo, puedes comenzar a escribir tu aplicación.

Copie y pegue el siguiente código en el archivo 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(())
}

Asigna la cadena de conexión.

Reemplaza el marcador de posición <connection string URI> con la cadena de conexión que se copió del paso Crear una cadena de conexión de esta guía.

Ejecuta tu aplicación Rust.

Desde el directorio de tu proyecto rust_quickstart, ejecuta el siguiente comando para compilar y ejecutar esta aplicación:

cargo run

La salida de la línea de comandos contiene detalles sobre el documento de película 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",
            ),
            ...
        ]),
    }),
)

Si encuentras un error o no ves ninguna salida, asegúrate de haber especificado la cadena de conexión correcta en el archivo main.rs y de haber cargado los datos de muestra.