Como escrever uma API REST em Rust em 30 minutos: guia prático

Introdução: por que Rust para API REST?

Rust é uma linguagem de programação de sistemas moderna que combina o desempenho de C/C++ com segurança de memória sem coletor de lixo. Para criar APIs REST, Rust oferece vários frameworks poderosos, e Actix-web é um dos mais populares. Neste guia, criaremos passo a passo uma API REST completa em Rust em 30 minutos. Você verá como é rápido começar, mesmo sendo iniciante em Rust.

Preparação do ambiente

Antes de escrever código, certifique-se de ter o Rust instalado. Se não tiver, execute o comando:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Após a instalação, verifique a versão:

rustc --version

Agora crie um novo projeto:

cargo new rust_rest_api\ncd rust_rest_api

Abra o arquivo Cargo.toml e adicione as dependências:

[dependencies]\nactix-web = "4"\nserde = { version = "1.0", features = ["derive"] }\nserde_json = "1.0"\ntokio = { version = "1", features = ["full"] }

Execute cargo build para instalar todos os pacotes. Isso levará de 1 a 2 minutos.

Criação de uma API REST básica em Rust

Vamos começar com um endpoint simples que retorna uma saudação. Abra src/main.rs e escreva:

use actix_web::{web, App, HttpServer, Responder};\n\nasync fn hello() -> impl Responder {\n    "Olá, mundo! Esta é uma API REST em Rust!"\n}\n\n#[actix_web::main]\nasync fn main() -> std::io::Result<()> {\n    println!("Servidor iniciado em http://127.0.0.1:8080");\n    HttpServer::new(|| {\n        App::new()\n            .route("/", web::get().to(hello))\n    })\n    .bind("127.0.0.1:8080")?\n    .run()\n    .await\n}

Execute o servidor com o comando cargo run e abra no navegador http://127.0.0.1:8080. Você verá nossa saudação. Esta é a base de qualquer API REST em Rust.

Adicionando estrutura de dados e JSON

Uma API REST real trabalha com JSON. Vamos criar um modelo de usuário e um endpoint para obtê-lo:

use serde::{Deserialize, Serialize};\n\n#[derive(Serialize, Deserialize)]\nstruct User {\n    id: u32,\n    name: String,\n    email: String,\n}\n\nasync fn get_user() -> impl Responder {\n    let user = User {\n        id: 1,\n        name: "João Silva".to_string(),\n        email: "joao@example.com".to_string(),\n    };\n    web::Json(user)\n}\n\n// Em main(), adicione a nova rota:\n// .route("/user", web::get().to(get_user))

Agora, no endereço /user, você receberá um objeto JSON. Este é o ponto chave: Rust serializa automaticamente a estrutura em JSON graças ao serde.

Trabalhando com parâmetros de consulta e requisições POST

Uma API real deve lidar com diferentes métodos HTTP e parâmetros. Vamos adicionar um endpoint para criar usuário via POST:

use actix_web::web::Json;\n\nasync fn create_user(user: Json<User>) -> impl Responder {\n    let new_user = user.into_inner();\n    println!("Usuário criado: {} ({})", new_user.name, new_user.email);\n    web::Json(new_user)\n}\n\n// Em main():\n// .route("/user", web::post().to(create_user))

Agora você pode enviar uma requisição POST com corpo JSON, por exemplo, via curl:

curl -X POST http://127.0.0.1:8080/user \\\n  -H "Content-Type: application/json" \\\n  -d '{"id":2,"name":"Maria Souza","email":"maria@example.com"}'

O servidor retornará o mesmo objeto, confirmando a criação. Esta é a base para operações CRUD.

Tratamento de parâmetros de caminho e string de consulta

Vamos adicionar um endpoint para obter usuário por ID via parâmetro de caminho:

use actix_web::web::Path;\n\nasync fn get_user_by_id(path: Path<u32>) -> impl Responder {\n    let user_id = path.into_inner();\n    // Em uma aplicação real, aqui haveria uma consulta ao banco de dados\n