Implantação de aplicação Rust em VPS: passo a passo do A ao Z

Introdução

Você escreveu uma aplicação incrível em Rust. Ela é rápida, segura e não falha. Mas como fazer para que ela funcione 24/7 em um servidor remoto e esteja disponível para os usuários? A implantação de uma aplicação Rust em VPS (Virtual Private Server) é um processo que inclui a compilação do binário, configuração do ambiente, execução como um serviço do sistema e, frequentemente, a instalação de um reverse proxy.

Neste artigo, percorreremos todo o caminho, do zero até uma aplicação Rust totalmente funcional, implantada em um VPS com Ubuntu. Você aprenderá como preparar o servidor, compilar o projeto, configurar a inicialização automática e garantir a segurança. Este guia é adequado tanto para servidores web (Actix-web, Axum, Rocket) quanto para qualquer outro daemon em Rust.

Vamos começar.

1. Preparação do servidor e ambiente

Antes de implantar o código, precisamos preparar o "terreno". Usaremos Ubuntu 22.04 LTS, mas as instruções também servem para Debian.

Conexão ao servidor e configuração básica

Conecte-se ao seu VPS via SSH:

ssh root@seu-ip-do-servidor

Atualize os pacotes e crie um usuário (trabalhar como root é uma má prática):

apt update && apt upgrade -y\nadduser deployer\nusermod -aG sudo deployer

Configure as chaves SSH para o novo usuário, para não precisar digitar a senha toda vez.

Instalação do Rust no servidor

A maneira mais confiável é usar o script oficial rustup. Mude para o usuário deployer e execute:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Após a instalação, recarregue o shell ou execute:

source $HOME/.cargo/env

Verifique a versão:

rustc --version

Para a compilação de produção, precisaremos de vinculação estática (para que o binário funcione em qualquer Linux sem bibliotecas extras). Instale o musl-tools:

sudo apt install musl-tools -y\nrustup target add x86_64-unknown-linux-musl

2. Compilação e transferência do binário para o servidor

É melhor compilar a aplicação em sua máquina local (ou em CI/CD) e depois copiar o binário pronto para o servidor. Isso é mais rápido e não sobrecarrega o VPS.

Compilação da versão de produção

No seu computador local, na pasta do projeto, execute:

cargo build --release --target x86_64-unknown-linux-musl

Isso criará um binário estaticamente vinculado, sem dependências do glibc. O tamanho será maior, mas ele será executado em qualquer Linux.

Exemplo de um servidor web simples com Actix-web para teste (arquivo src/main.rs):

use actix_web::{web, App, HttpServer, Responder};\n\nasync fn hello() -> impl Responder {\n    "Hello from Rust on VPS!"\n}\n\n#[actix_web::main]\nasync fn main() -> std::io::Result<()> {\n    HttpServer::new(|| {\n        App::new().route("/", web::get().to(hello))\n    })\n    .bind("0.0.0.0:8080")?\n    .run()\n    .await\n}

Cópia para o servidor

Use scp para cópia segura:

scp ./target/x86_64-unknown-linux-musl/release/seu_projeto deployer@seu-ip-do-servidor:/home/deployer/

No servidor, mova o binário para /usr/local/bin:

sudo mv /home/deployer/seu_projeto /usr/local/bin/my-rust-app\nsudo chmod +x /usr/local/bin/my-rust-app

3. Configuração do systemd para inicialização automática

Para que a aplicação seja iniciada na inicialização do sistema, reinicie após uma falha e funcione em segundo plano, criaremos um serviço systemd.

Crie o arquivo de serviço:

sudo nano /etc/systemd/system/rust-app.service

Insira a seguinte configuração (substitua deployer pelo seu usuário):

[Unit]\nDescription=Rust Application\nAfter=network.target\n\n[Service]\nType=simple\nUse