Déploiement d'une application Rust sur un VPS : guide étape par étape

Introduction

Rust est un langage de programmation système réputé pour ses performances et sa sécurité mémoire. Cependant, écrire une application n'est que la moitié du travail. Pour que votre projet soit accessible aux utilisateurs sur Internet, il doit être déployé sur un serveur. Dans cet article, nous allons voir le processus étape par étape pour déployer une application Rust sur un VPS (Virtual Private Server).

Nous utiliserons un serveur web typique basé sur le framework actix-web, configurerons l'environnement, compilerons une version release, lancerons l'application en tant que service systemd et configurerons un proxy inverse Nginx avec un certificat SSL. En suivant ce guide, vous pourrez déployer n'importe quelle application Rust sur un serveur distant sous Linux.

1. Préparation du serveur et de l'environnement

1.1. Connexion au serveur

Connectez-vous d'abord à votre VPS via SSH :

ssh root@your_server_ip

Il est recommandé de créer un utilisateur séparé avec des droits limités (sudo) pour des raisons de sécurité, mais pour simplifier, nous travaillerons en tant que root dans ce guide.

1.2. Installation de Rust sur le serveur

Bien que nous puissions compiler l'application localement et simplement copier le binaire, il est plus pratique d'installer Rust sur le serveur pour une éventuelle recompilation pour l'architecture cible. Utilisons le script officiel :

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | shsource $HOME/.cargo/env

Vérifiez l'installation :

rustc --versioncargo --version

1.3. Installation des dépendances système

Pour compiler certaines crates (par exemple openssl), des bibliothèques système peuvent être nécessaires. Installez-les :

apt updateapt install build-essential pkg-config libssl-dev git -y

2. Compilation et préparation de l'application

2.1. Exemple d'un serveur web simple avec actix-web

Créons une application minimale. Si vous avez déjà un projet, sautez cette étape.

Cargo.toml :

[package]name = "my_rust_app"version = "0.1.0"edition = "2021"

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

src/main.rs :

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

#[get("/")]async fn index() -> impl Responder {    "Hello from Rust on VPS!"}

#[actix_web::main]async fn main() -> std::io::Result<()> {    println!("Starting server at 0.0.0.0:8080");    HttpServer::new(|| {        App::new()            .service(index)    })    .bind("0.0.0.0:8080")?    .run()    .await}

2.2. Compilation en mode release

Compilez l'application sur votre machine locale ou directement sur le serveur. Pour des performances maximales, utilisez le flag --release :

cargo build --release

Le binaire prêt se trouvera dans target/release/my_rust_app (le nom correspond au nom du package).

2.3. Copie du binaire sur le serveur (si compilé localement)

Si vous avez compilé l'application sur votre machine locale, copiez-la via SCP :

scp target/release/my_rust_app root@your_server_ip:/opt/my_rust_app/

Créez le répertoire /opt/my_rust_app sur le serveur à l'avance :

mkdir -p /opt/my_rust_app

3. Configuration du lancement via systemd

Pour que l'application démarre automatiquement au démarrage du système et redémarre en cas de panne, créons un service systemd.

3.1. Création du fichier unit

Créez le fichier /etc/systemd/system/my_rust_app.service :

[Unit]Description=My Rust Web ApplicationAfter=network.target

[Service]Type=simpleUser=rootWorkingDirectory=/opt/my_rust_appExecStart=/opt/my_rust_app/my_rust_appRestart=on-failureRestartSec=10

[Install]WantedBy=multi-user.target