Como escrever uma API REST em Rust em 30 minutos: guia passo a passo

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

Rust é uma linguagem de programação de sistemas moderna que combina o desempenho do C++ com a segurança de memória garantida em tempo de compilação. Nos últimos anos, Rust tem sido ativamente usado para criar serviços web e microsserviços de alta carga. Neste artigo, mostraremos como escrever uma REST API completa em Rust em 30 minutos usando o framework Actix-web e a biblioteca Serde.

Por que escolher Rust para sua API?

• Desempenho: Rust opera no nível de C/C++, o que é crítico para sistemas de alta carga.
• Segurança: O sistema de ownership (propriedade) e borrowing (empréstimo) elimina classes inteiras de erros relacionados à memória.
• Assincronicidade: O suporte nativo a async/await permite processar milhares de conexões de forma eficiente.
• Ecossistema: Cargo (gerenciador de pacotes) e crates.io tornam o gerenciamento de dependências simples e conveniente.

Criaremos uma API simples para gerenciar uma lista de tarefas (Todo list), que suportará operações CRUD. Você aprenderá a configurar rotas, processar JSON e trabalhar com o estado da aplicação.

Passo 1: Configuração do projeto e instalação das dependências

Primeiro, vamos criar um novo projeto em Rust usando o Cargo. Abra o terminal e execute:

cargo new rust_todo_apicd rust_todo_api

Agora, edite o arquivo Cargo.toml, adicionando as dependências necessárias:

[package]name = "rust_todo_api"version = "0.1.0"edition = "2021"

[dependencies]actix-web = "4"serde = { version = "1.0", features = ["derive"] }serde_json = "1.0"tokio = { version = "1", features = ["full"] }uuid = { version = "1", features = ["v4"] }

Vamos entender para que serve cada biblioteca:

• actix-web — um framework web assíncrono de alto desempenho.
• serde — biblioteca para serialização e desserialização de dados (JSON).
• serde_json — suporte ao formato JSON para serde.
• tokio — runtime assíncrono para Rust (actix-web o usa por padrão).
• uuid — geração de identificadores únicos para nossas tarefas.

Após adicionar as dependências, execute cargo build para baixar e compilar todos os pacotes. Isso pode levar alguns minutos na primeira execução.

Passo 2: Criação do modelo de dados e estrutura da aplicação

Crie o arquivo src/main.rs e defina o modelo da nossa tarefa. Usaremos a struct TodoItem com os campos id, title e completed:

use actix_web::{web, App, HttpServer, HttpResponse, middleware};use serde::{Deserialize, Serialize};use std::sync::Mutex;use uuid::Uuid;

#[derive(Debug, Serialize, Deserialize, Clone)]struct TodoItem {    id: String,    title: String,    completed: bool,}

#[derive(Debug, Deserialize)]struct CreateTodoRequest {    title: String,}

#[derive(Debug, Deserialize)]struct UpdateTodoRequest {    title: Option<String>,    completed: Option<bool>,}

struct AppState {    todos: Mutex<Vec<TodoItem>>,}

Observe os detalhes importantes:

• Serialize e Deserialize — traits do serde que geram automaticamente o código para trabalhar com JSON.
• Mutex — usado para acesso seguro ao estado compartilhado entre múltiplas threads.
• Uuid — gera identificadores únicos para cada tarefa.

Agora, adicione a função main, que iniciará o servidor e inicializará o estado:

#[actix_web::main]async fn main() -> std::io::R
```