Criando uma API com Rust

Neste artigo, vamos explorar como criar uma API com Rust usando Rocket e Diesel para se conectar a um banco de dados MySQL. Rust é amplamente reconhecido por sua segurança, concorrência e desempenho. Além disso, Rocket oferece uma abordagem elegante e segura para desenvolver APIs web em Rust. Por outro lado, Diesel é uma biblioteca ORM que facilita a interação com bancos de dados SQL em Rust de forma segura e eficiente.

Pré-requisitos

Certifique-se de ter Rust e Cargo instalados em seu sistema. Você pode instalá-los seguindo as instruções em rust-lang.org.

Além disso, você precisará ter o MySQL instalado localmente.

Configurando o Projeto

Primeiramente, vamos iniciar a criação do projeto.

1. Criar um Novo Projeto Rust:

Primeiramente, abra seu terminal e execute o seguinte comando para criar um novo projeto Rust:

cargo new rust-api-example

cd rust-api-example

2. Adicionar Dependências ao toml:

Logo em seguida abra o arquivo Cargo.toml e adicione as dependências necessárias para Rocket e Diesel:

[dependencies]
rocket = "0.5.0"
rocket_codegen = "0.5.0"
rocket_contrib = "0.5.0"

diesel = { version = "1.4.8", features = ["mysql"] }
dotenv = "0.15.0"

3. Configurar Variáveis de Ambiente:

Crie um arquivo .env na raiz do seu projeto para armazenar as credenciais do banco de dados:

DATABASE_URL=mysql://username:password@localhost/database_name

Substitua username, passworde database_name com suas próprias credenciais do MySQL.

Definindo o Banco de Dados

1. Definir o Schema do Banco de Dados

Primeiramente, iremos criar um diretório src/schema e adicionar um arquivo Rust.

2. Gerar o Schema Utilizando Diesel CLI

Instale o Diesel CLI se ainda não o tiver:

cargo install diesel_cli --no-default-features --features mysql

Em seguida, execute os seguintes comandos para gerar o schema do banco de dados:

diesel setup

diesel migration generate create_users

Abra o arquivo gerado na pasta migrations e adicione:

-- migrations/<timestamp>_create_users/up.sql

Depois, execute a migração:

diesel migration run

Implementando a API com Rocket e Diesel

Agora vamos implementar a API com operações básicas de CRUD (Create, Read, Update, Delete) para gerenciar usuários.

// main.rs

#[macro_use]
extern crate rocket;

use rocket::fs::FileServer;
use rocket::serde::{Serialize, Deserialize};
use rocket::serde::json::Json;
use diesel::mysql::MysqlConnection;
use diesel::prelude::*;
use dotenv::dotenv;
use std::env;

#[derive(Queryable, Serialize, Deserialize)]
struct User {
    id: i32,
    name: String,
    email: String,
}

#[derive(Insertable, Deserialize)]
#[table_name = "users"]
struct NewUser {
    name: String,
    email: String,
}

#[database("mysql_db")]
struct DbConn(MysqlConnection);

// Route to get all users
#[get("/users")]
async fn get_users(conn: DbConn) -> Json<Vec<User>> {
    use crate::schema::users;

    let result = users::table
      .load::<User>(&conn.0)
      .expect("Error loading users");

    Json(result)
}

#[post("/users", data = "<new_user>")]
async fn create_user(new_user: Json<NewUser>, conn: DbConn) -> Result<Json<User>, String> {
    use crate::schema::users;

    let result = diesel::insert_into(users::table)
      .values(&*new_user)
      .execute(&conn.0);

    match result {
      Ok(_) => {
        let inserted_user = users::table
         .order(users::id.desc())
         .first::<User>(&conn.0)
         .expect("Error loading last inserted user");

       Ok(Json(inserted_user))
      }
      Err(err) => Err(format!("Failed to insert new user: {}", err)),
    }
}

#[launch]
fn rocket() -> _ {
dotenv().ok();

let database_url = env::var("DATABASE_URL")
.expect("DATABASE_URL must be set");

rocket::build()
.attach(DbConn::fairing())
.mount("/", routes![get_users, create_user])
.mount("/static", FileServer::from("static"))
}

Executando a API

Para executar a API, use o seguinte comando:

cargo run

Isso iniciará o servidor Rocket e você poderá acessar sua API em http://localhost:8000.

Testando a API

Você pode testar a API utilizando ferramentas como Postman ou curl. Com essas ferramentas, você enviará requisições HTTP para as rotas definidas (/users para GET, POST, PUT e DELETE) e poderá verificar o funcionamento das operações de CRUD.

Conclusão

Neste artigo, exploramos como criar uma API RESTful usando Rust com o framework Rocket e conectar-se a um banco de dados MySQL utilizando Diesel. Demonstramos como implementar operações básicas de CRUD para gerenciar usuários na API. Utilizamos Rust para concorrência e desempenho. Além disso, Rocket proporciona um desenvolvimento web elegante e seguro, enquanto Diesel permite uma interação eficiente com o banco de dados. Rust oferece um ecossistema robusto para desenvolvimento de APIs escaláveis e de alto desempenho. Adicionalmente, Rocket e Diesel complementam bem as capacidades da linguagem. Explore ainda mais recursos do Rocket e Diesel para expandir sua API e aproveitar ao máximo o potencial da linguagem Rust no desenvolvimento web.

Para visualizar mais conteúdo como esse, clique aqui.