Learn Rust Coding · Aula

APIs REST com Actix-web/Rocket

Desenvolva APIs RESTful utilizando uma estrutura Web moderna de Rust, como Actix-web ou Rocket, gerindo rotas, pedidos e respostas.

APIs REST com Actix-web/Rocket é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 3 aulas no total.

O que são APIs REST?

REST, ou REpresentação de Stado de Transferência, é um estilo arquitetural para aplicações em rede. Ele define um conjunto de princípios sobre como os serviços web devem se comunicar.

Pense nele como um conjunto de diretrizes para criar serviços web sem estado, armazenáveis em cache e que usam métodos HTTP padrão para interagir com recursos.

Recursos: Qualquer coisa que possa ser nomeada, como um usuário, um produto ou um pedido.
URIs: Identificadores exclusivos de recursos, como /users/123.
Métodos HTTP: Ações padrão realizadas nos recursos (GET, POST, PUT, DELETE).

Por que usar Rust para serviços web?

Rust oferece vantagens exclusivas para o desenvolvimento de serviços web, sendo uma excelente escolha para APIs de alto desempenho e confiáveis:

Desempenho: As abstrações de custo zero do Rust resultam em código altamente eficiente, frequentemente comparável ao de C/C++.
Segurança de memória: O sistema de propriedade evita erros comuns, como desreferências de ponteiros nulos e condições de corrida de dados, resultando em serviços mais robustos.
Concorrência: O modelo async/await do Rust, combinado com suas garantias de segurança, torna a criação de serviços web concorrentes “sem medo”.
Confiabilidade: O sistema de tipos forte e as verificações em tempo de compilação detectam muitos erros antecipadamente.

Conheça Actix-web

Para criar serviços web em Rust, geralmente usamos estruturas de desenvolvimento. Actix-web é uma estrutura web poderosa, pragmática e extremamente rápida para Rust.

Ela é construída sobre o Actix, uma estrutura baseada em atores, mas você não precisa entender atores para usar Actix-web com eficiência. Ela foi projetada para operações assíncronas, sendo ideal para tarefas limitadas por E/S, como lidar com muitas solicitações de API simultâneas.

Actix-web oferece ferramentas para roteamento, tratamento de solicitações e respostas, middleware e muito mais, simplificando a criação de APIs complexas.

Configuração do projeto e dependências

Para começar, vamos criar um novo projeto Rust e adicionar as dependências necessárias. Usaremos actix-web como estrutura e serde para serializar e desserializar dados JSON.

Primeiro, crie um novo projeto:

cargo new my_rest_api --bin

Em seguida, adicione estas linhas ao arquivo Cargo.toml, na seção [dependencies]:

[dependencies]
actix-web = "4"
serde = { version = "1.0", features = ["derive"] }

Seu primeiro servidor Actix-web

Vamos escrever um servidor Actix-web mínimo. Este código configura a estrutura básica para escutar solicitações HTTP recebidas na porta 8080. Ele ainda não lida com nenhuma rota específica, mas serve como fundamento.

A macro #[actix_web::main] torna async fn main compatível com o ambiente de execução do Actix-web.

use actix_web::{App, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        // Our application instance, where we'll add routes
        App::new()
    })
    .bind(("127.0.0.1", 8080))? // Bind to an IP address and port
    .run() // Start the server
    .await // Await its completion
}

Definindo uma rota GET

Agora, vamos adicionar uma rota simples ao nosso servidor. Uma route associa o caminho e o método de uma solicitação HTTP recebida, como GET /hello, a uma função manipuladora específica.

Nossa função manipuladora hello_world simplesmente retornará uma string. web::get().to() registra essa função para solicitações GET ao caminho /hello.

use actix_web::{web, App, HttpServer, Responder};

// A handler function that returns a simple string response
async fn hello_world() -> impl Responder {
    "Hello, Actix-web!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Register our route: GET /hello maps to hello_world()
            .route("/hello", web::get().to(hello_world))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Parâmetros de caminho para rotas dinâmicas

As APIs frequentemente precisam lidar com partes dinâmicas da URL, como um ID ou um nome. O Actix-web usa parâmetros de caminho para capturar esses valores.

Definimos um espaço reservado na rota, por exemplo, /{name}. Na função manipuladora, usamos web::Path<String> (ou qualquer outro tipo que possa ser desserializado) para extrair o valor.

use actix_web::{web, App, HttpServer, Responder};

// Handler function with a path parameter 'name'
async fn greet_name(name: web::Path<String>) -> impl Responder {
    format!("Hello, {}!", name.into_inner())
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Route with a dynamic path segment for a name
            .route("/greet/{name}", web::get().to(greet_name))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Lidando com solicitações POST e JSON

Para criar ou atualizar recursos, usamos solicitações POST ou PUT, geralmente enviando dados no corpo da solicitação como JSON.

O Actix-web facilita o tratamento de JSON com web::Json<T>. Definimos uma struct Rust que corresponde à estrutura JSON esperada, derivamos Deserialize de serde, e o Actix-web analisa automaticamente o JSON recebido e o converte em nossa estrutura.

use actix_web::{web, App, HttpServer, Responder};
use serde::{Deserialize, Serialize};

// Define a struct to represent our incoming JSON data
#[derive(Deserialize, Serialize)]
struct User {
    username: String,
    email: String,
}

// Handler for POST requests that accepts a JSON User object
async fn create_user(user: web::Json<User>) -> impl Responder {
    // In a real app, you'd save this user to a database
    format!("User created: {} ({})", user.username, user.email)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // POST /users expects a JSON body and maps to create_user()
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Criando uma API simples com estado

Vamos combinar o que aprendemos para criar uma pequena API que gerencia uma lista de usuários na memória. Usaremos web::Data para compartilhar o estado específico da aplicação (nossa lista de usuários) entre as funções manipuladoras.

std::sync::Mutex é usado para permitir com segurança o acesso mutável à nossa Vec<User> a partir de várias solicitações simultâneas. Teremos pontos de acesso para GET /users e POST /users.

use actix_web::{web, App, HttpServer, Responder, HttpResponse};
use serde::{Deserialize, Serialize};
use std::sync::Mutex; // For shared mutable state

// Define a User struct that can be serialized/deserialized and cloned
#[derive(Deserialize, Serialize, Clone)]
struct User {
    id: u32,
    username: String,
    email: String,
}

// Application state to hold our users and track next ID
struct AppState {
    users: Mutex<Vec<User>>,
    next_id: Mutex<u32>,
}

// Handler to get all users
async fn get_users(data: web::Data<AppState>) -> impl Responder {
    let users = data.users.lock().unwrap(); // Acquire a lock
    web::Json(users.clone()) // Return users as JSON
}

// Handler to create a new user
async fn create_user(
    data: web::Data<AppState>,
    new_user: web::Json<User>,
) -> impl Responder {
    let mut users = data.users.lock().unwrap();
    let mut next_id = data.next_id.lock().unwrap();

    let user = User {
        id: *next_id,
        username: new_user.username.clone(),
        email: new_user.email.clone(),
    };
    users.push(user.clone());
    *next_id += 1; // Increment for the next user
    HttpResponse::Created().json(user) // Return 201 Created status and user
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    // Create shared application state
    let app_state = web::Data::new(AppState {
        users: Mutex::new(vec![]), // Initialize with an empty user list
        next_id: Mutex::new(1),    // Start IDs from 1
    });

    HttpServer::new(move || { // 'move' closure to capture app_state
        App::new()
            .app_data(app_state.clone()) // Register shared state with the app
            .route("/users", web::get().to(get_users))
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Verificação rápida de conceitos de API

Você aprendeu a configurar um servidor Actix-web básico e a lidar com diferentes solicitações HTTP. Vamos testar sua compreensão!

Recapitulação e próximos passos

Muito bem! Você deu seus primeiros passos na criação de APIs RESTful com Rust e Actix-web.

Exploramos os fundamentos de API REST e por que Rust é uma ótima escolha.
Você aprendeu a configurar um projeto básico com Actix-web.
Vimos como definir rotas GET e POST.
Você aprendeu a extrair parâmetros de caminho e a lidar com cargas JSON.
Por fim, você criou uma API simples que gerencia o estado na memória usando web::Data.

Em seguida, você se aprofundará na integração com bancos de dados e no tratamento robusto de erros para criar serviços web ainda mais poderosos e prontos para produção!

Perguntas Frequentes

A aula “APIs REST com Actix-web/Rocket” é grátis?

Sim — o texto completo de “APIs REST com Actix-web/Rocket” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 3 aulas no total.

O que vou aprender em “APIs REST com Actix-web/Rocket”?

Desenvolva APIs RESTful utilizando uma estrutura Web moderna de Rust, como Actix-web ou Rocket, gerindo rotas, pedidos e respostas. Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.

Quanto tempo leva a aula “APIs REST com Actix-web/Rocket”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

APIs REST com Actix-web/Rocket
Integração com Bases de Dados (SQLx/Diesel)
Autenticação e Autorização

← Voltar para Learn Rust Coding