Introdução

Rust é uma linguagem de programação que vem ganhando cada vez mais destaque no desenvolvimento de software, especialmente na criação de aplicações web robustas e seguras. Neste artigo, vamos explorar duas das bibliotecas mais populares do ecossistema Rust: Rocket e Actix. Vamos abordar desde a configuração do ambiente até a criação de uma aplicação web completa, cobrindo as melhores práticas de gerenciamento de dependências utilizando o Cargo, o gerenciador de pacotes do Rust. Ideal para desenvolvedores que desejam se aprofundar na criação de aplicações performáticas e escaláveis, este guia prático mostrará um ciclo de desenvolvimento completo, incluindo a construção de rotas, handling de requisições e a implementação de testes unitários.

Etapas

  1. Instalação do Rust e Configuração do Ambiente

    Certifique-se de que o Rust e o Cargo estão instalados em sua máquina. Você pode baixar o instalador do Rust diretamente do site oficial. Após a instalação, verifique usando os comandos `rustc –version` e `cargo –version`.

    commands
    # Instalar Rust
    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
    # Verificar versões instaladas
    rustc --version
    cargo --version

  2. Criação de um Novo Projeto com Cargo

    Utilize o Cargo para criar um novo projeto Rust. Navegue até o diretório desejado e execute o comando para criar um novo projeto chamado ‘minha_aplicacao_web’.

    commands
    # Criar novo projeto
    cargo new minha_aplicacao_web
    # Navegar para o diretório do projeto
    cd minha_aplicacao_web

  3. Adicionar Dependências no arquivo Cargo.toml

    Abra o arquivo `Cargo.toml` e adicione as dependências Rocket e Actix. As versões podem ser atualizadas, então é aconselhável verificar as versões mais recentes no site oficial.

    Cargo.toml
    [dependencies]
rocket = "0.4"
actix-web = "4.0"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

  4. Criação de um Servidor Web Simples com Rocket

    Implemente um servidor básico utilizando Rocket. Crie um novo arquivo `main.rs` dentro do diretório `src` com um exemplo de um endpoint simples que retorna ‘Hello, World!’.

    main.rs
    #[macro_use]
extern crate rocket;

#[get("/")]
fn index() -> &'static str {
    "Hello, World!"
}

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", routes![index])
}

  5. Executando a Aplicação com Rocket

    Compile e execute a aplicação utilizando Cargo. Execute o comando abaixo e acesse o servidor no navegador na URL http://localhost:8000.

    commands
    # Compilar e executar a aplicação
    cargo run

  6. Criação de um Servidor com Actix

    Implemente um servidor básico utilizando Actix. Crie um novo arquivo `actix_main.rs` dentro do diretório `src` com um endpoint simples que retorna ‘Hello from Actix!’.

    actix_main.rs
    use actix_web::{web, App, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(|| async { "Hello from Actix!" }))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

  7. Executando a Aplicação com Actix

    Compile e execute a aplicação Actix utilizando Cargo. Execute o comando abaixo e acesse o servidor no navegador na URL http://localhost:8080.

    commands
    # Compilar e executar a aplicação
    cargo run --bin actix_app

  8. Implementação de Testes Unitários

    Crie testes unitários para os seus endpoints. Na mesma estrutura do seu projeto, crie um arquivo `tests.rs` e implemente testes para as rotas que você criou anteriormente.

    tests.rs
    use rocket::{local::blocking::Client, http::Status};

#[test]
fn test_index() {
    let client = Client::tracked(rocket()).expect("valid rocket");
    let response = client.get("/").dispatch();
    assert_eq!(response.status(), Status::Ok);
    assert_eq!(response.into_string().unwrap(), "Hello, World!");
}

  9. Executando os Testes

    Utilize o Cargo para rodar os testes que você implementou. Execute o comando abaixo para verificar se tudo está funcionando corretamente.

    commands
    # Executar os testes unitários
    cargo test

Conclusão

Neste tutorial, você aprendeu a utilizar o Rust para criar aplicações web simples e robustas utilizando os frameworks Rocket e Actix. Começamos pela configuração do ambiente de desenvolvimento, criação do servidor com diferentes frameworks, implementação de endpoints, e finalizamos com a introdução de testes unitários. Com essas ferramentas e práticas em sua caixa de ferramentas, você está preparado para desenvolver aplicações web complexas e eficientes no ecossistema Rust.

Hashtags

#Rust #Rocket #Actix #DesenvolvimentoWeb #SoftwareEngineering #TestesUnitários