Introdução

Neste tutorial, vamos explorar o desenvolvimento de microserviços utilizando a linguagem Rust, um sistema de programação focado na segurança e na performance. Faremos uso do framework Actix, que se destaca por sua eficiência e robustez na construção de aplicações web rápidas e seguras. Adicionalmente, abordaremos o gerenciador de pacotes Cargo, que facilita a gestão de dependências e a construção de projetos Rust. Este guia prático será ideal para desenvolvedores que desejam adotar Rust na arquitetura de microserviços, oferecendo um passo a passo desde a configuração do ambiente até a implementação de testes unitários com exemplos de código. Você aprenderá a criar um microserviço escalável e de alto desempenho, pronto para ser integrado a uma aplicação maior.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de ter o Rust e o Cargo instalados em sua máquina. Você pode instalar o Rust utilizando o rustup, o gerenciador oficial do Rust. Após a instalação, verifique a versão utilizando `rustc –version` e `cargo –version`.

    commands
    # Verificar versões instaladas
    rustc --version
    cargo --version

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

    Crie um novo projeto Rust utilizando Cargo. Execute o comando abaixo para criar um novo diretório com a estrutura básica de um projeto Rust.

    commands
    # Criar novo projeto chamado microservice
    cargo new microservice
    cd microservice

  3. Adicionando Dependências no Cargo.toml

    No arquivo `Cargo.toml`, adicione as dependências necessárias para o Actix e outras bibliotecas que podemos usar como `serde` e `serde_json` para manipulação de JSON.

    Cargo.toml
    [package]
name = "microservice"
version = "0.1.0"
edition = "2018"

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

  4. Configurando o Servidor Actix

    Implemente a função principal do aplicativo no arquivo `src/main.rs`. Crie um servidor Actix básico que escuta em uma porta específica e responde a requisições HTTP.

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

async fn greet() -> impl Responder {
    "Hello, welcome to our microservice!"
}

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

  5. Executando o Servidor

    Compile e execute seu projeto. Após iniciar o servidor, você deverá conseguir acessá-lo através do seu navegador ou utilizando uma ferramenta como o Postman.

    commands
    # Compilar e executar o servidor
    cargo run

  6. Criando Endpoints RESTful

    Adicione novos endpoints ao seu aplicativo. Por exemplo, implemente um endpoint que aceite requisições POST e retorne dados em formato JSON.

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

#[derive(serde::Serialize, serde::Deserialize)]
struct Item {
    name: String,
}

async fn create_item(item: web::Json<Item>) -> impl Responder {
    web::Json(Item { name: format!("Created: {}", item.name) })
}

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

  7. Testando o Endpoint

    Utilize uma ferramenta como o Postman ou cURL para testar o seu novo endpoint. Aqui está como você pode fazer isso com cURL.

    commands
    # Testar endpoint POST
    curl -X POST -H "Content-Type: application/json" -d '{"name":"Teste"}' http://127.0.0.1:8080/item

  8. Implementação de Testes Unitários

    Crie testes unitários para assegurar que suas funções estão se comportando conforme o esperado. Use o módulo de testes nativo do Rust.

    main.rs
    // Teste para o endpoint
#[cfg(test)]
mod tests {
    use super::*;
    
    #[actix_web::test]
    async fn test_create_item() {
        let item = Item { name: String::from("Test Item") };
        let resp = create_item(web::Json(item)).await;
        assert_eq!(resp.name, "Created: Test Item");
    }
}

  9. Executando os Testes

    Para executar os testes deste projeto, utilize o comando Cargo correspondente. Isso garantirá que sua aplicação esteja funcionando conforme projetado.

    commands
    # Executar os testes
    cargo test

Conclusão

Neste tutorial, você aprendeu a construir um microserviço utilizando Rust e Actix. Passamos por todas as etapas desde a configuração do ambiente, a criação de endpoints RESTful até a execução de testes unitários. O uso do Rust com Actix permite desenvolver serviços muito rápidos e seguros. Com este conhecimento, você está pronto para criar aplicações mais complexas e eficientes, explorando ainda mais as capacidades do Rust.

Hashtags

#Rust #Actix #Microserviços #DesenvolvimentoDeSoftware #Cargo