🦀 Minha Primeira API em Rust com Axum

Projeto desenvolvido com fins de aprendizado, marcando meus primeiros passos no ecossistema Rust. O código foi escrito de forma ainda iniciante, e este projeto representa o início de uma jornada para me aprofundar cada vez mais na linguagem.

---

📌 Sobre o Projeto

Esta é uma API HTTP minimalista construída com Rust, utilizando o framework Axum e o runtime assíncrono Tokio. O objetivo é simples: subir um servidor web local que responde a requisições GET na rota raiz (/) com uma mensagem de boas-vindas.

Apesar da simplicidade, este projeto cobre conceitos fundamentais do desenvolvimento web em Rust, como:

• Criação e configuração de um roteador HTTP
• Definição de handlers assíncronos
• Binding de um listener TCP em uma porta local
• Servir a aplicação de forma assíncrona

---

🚀 Como Executar

Pré-requisitos

• Rust instalado (versão estável recomendada)
• Cargo (já vem junto com o Rust)

Passos

# Clone o repositório
git clone https://github.com/seu-usuario/seu-repositorio.git
cd seu-repositorio

# Execute o projeto
cargo run

O servidor estará disponível em:

http://127.0.0.1:3000

Testando a API

Você pode testar com curl:

curl http://127.0.0.1:3000/

Ou simplesmente abrir o navegador e acessar http://127.0.0.1:3000.

Resposta esperada:

Bem-vindo(a) a minha primeira API em Rust

---

🗂️ Estrutura do Código

use axum::{Router, routing::get};
use tokio::net::TcpListener;

async fn root() -> &'static str {
    "Bem-vindo(a) a minha primeira API em Rust"
}

#[tokio::main]
async fn main() {
    let app: Router = Router::<()>::new().route("/", get(root));
    let listener = TcpListener::bind("127.0.0.1:3000").await.unwrap();
    println!("Servidor rodando em http://127.0.0.1:3000");
    axum::serve(listener, app).await.unwrap();
}

O que cada parte faz

Trecho	Descrição
Router::new().route("/", get(root))	Cria o roteador e registra a rota / para requisições GET
async fn root()	Handler assíncrono que retorna a mensagem de boas-vindas
TcpListener::bind(...)	Abre um socket TCP na porta 3000 do localhost
axum::serve(listener, app)	Inicia o servidor e começa a aceitar conexões
#[tokio::main]	Macro que inicializa o runtime assíncrono do Tokio

---

📦 Bibliotecas Utilizadas

🔷 Axum

O que é: Axum é um framework web para Rust, desenvolvido e mantido pela equipe do Tokio. Ele foi criado para ser ergonômico, modular e totalmente compatível com o ecossistema assíncrono do Tokio.

Por que usar:

• Integração nativa com tokio e tower (middleware)
• Sistema de roteamento simples e expressivo
• Handlers são funções Rust comuns — sem macros complexas
• Excelente performance, aproveitando o modelo zero-cost abstractions do Rust

Neste projeto: Usamos o Router para definir rotas e o routing::get para associar a rota / ao handler root.

# Cargo.toml
axum = "0.8"

---

🔷 Tokio

O que é: Tokio é o runtime assíncrono mais popular do ecossistema Rust. Ele fornece a infraestrutura necessária para executar código async/await, incluindo gerenciamento de tarefas, I/O assíncrono e temporizadores.

Por que usar:

• Rust não possui um runtime assíncrono embutido na linguagem — é necessário escolher um
• Tokio é o padrão da indústria para aplicações web e de rede em Rust
• Altamente performático, com suporte a múltiplas threads e I/O não bloqueante

Neste projeto: A macro #[tokio::main] transforma a função main em uma função assíncrona gerenciada pelo runtime do Tokio. O TcpListener usado também é o de Tokio (tokio::net::TcpListener), que opera de forma não bloqueante.

# Cargo.toml
tokio = { version = "1", features = ["full"] }

---

🌐 Protocolo HTTP e o Objetivo da API

Esta API segue o modelo HTTP/1.1 para comunicação cliente-servidor. O fluxo básico é:

Cliente (browser/curl)
        │
        │  GET /  HTTP/1.1
        ▼
  Servidor Axum (127.0.0.1:3000)
        │
        │  200 OK
        │  "Bem-vindo(a) a minha primeira API em Rust"
        ▼
     Resposta

• Método: GET
• Rota: /
• Status de resposta: 200 OK
• Corpo da resposta: texto plano (text/plain)

O objetivo desta API é, sobretudo, educacional: entender como um servidor HTTP é construído do zero em Rust, desde o binding da porta TCP até a entrega da resposta ao cliente.

---

📈 Próximos Passos

Este projeto é apenas o começo. Pretendo evoluir meus estudos em Rust e explorar:

• Retornar respostas em JSON com serde_json
• Adicionar múltiplas rotas e parâmetros de rota
• Implementar middleware com tower
• Conectar a um banco de dados com sqlx
• Organizar o código com módulos Rust
• Implementar tratamento de erros idiomático com Result e anyhow
• Escrever testes de integração para os endpoints

---

🦀 Por que Rust?

Rust é uma linguagem de programação de sistemas que garante segurança de memória sem garbage collector, oferecendo performance comparável a C/C++. No contexto de APIs web, isso significa:

• Baixíssima latência
• Sem pausas de GC (Garbage Collection)
• Código seguro por padrão (sem null pointers, sem data races)

Ainda estou no início da minha jornada com Rust, mas estou empolgado com o que a linguagem pode oferecer. Este projeto é o primeiro passo de muitos. 🚀

---

📄 Licença

Este projeto está sob a licença MIT. Consulte o arquivo LICENSE para mais informações.