Déploiement d'une application Rust sur VPS : pas à pas de A à Z

Introduction

Vous avez écrit une superbe application en Rust. Elle est rapide, sécurisée et ne plante pas. Mais comment faire pour qu'elle fonctionne 24h/24 et 7j/7 sur un serveur distant et soit accessible aux utilisateurs ? Le déploiement d'une application Rust sur un VPS (Virtual Private Server) est un processus qui comprend la compilation du binaire, la configuration de l'environnement, le lancement en tant que service système et, souvent, la mise en place d'un reverse proxy.

Dans cet article, nous allons parcourir tout le chemin, de zéro à une application Rust entièrement fonctionnelle, déployée sur un VPS avec Ubuntu. Vous apprendrez à préparer le serveur, à compiler le projet, à configurer le démarrage automatique et à assurer la sécurité. Ce guide convient aussi bien pour les serveurs web (Actix-web, Axum, Rocket) que pour tout autre démon en Rust.

Commençons.

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

Avant de déployer le code, il faut préparer le terrain. Nous utiliserons Ubuntu 22.04 LTS, mais les instructions conviennent également pour Debian.

Connexion au serveur et configuration de base

Connectez-vous à votre VPS via SSH :

ssh root@votre-ip-serveur

Mettez à jour les paquets et créez un utilisateur (travailler en tant que root est une mauvaise pratique) :

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

Configurez les clés SSH pour le nouvel utilisateur afin de ne pas avoir à saisir le mot de passe à chaque fois.

Installation de Rust sur le serveur

La méthode la plus fiable est d'utiliser le script officiel rustup. Basculez sur l'utilisateur deployer et exécutez :

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

Après l'installation, rechargez le shell ou exécutez :

source $HOME/.cargo/env

Vérifiez la version :

rustc --version

Pour une compilation de production, nous aurons besoin d'une liaison statique (afin que le binaire fonctionne sur n'importe quel Linux sans bibliothèques supplémentaires). Installez musl-tools :

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

2. Compilation et transfert du binaire sur le serveur

Il est préférable de compiler l'application sur votre machine locale (ou dans un CI/CD), puis de copier le binaire prêt sur le serveur. C'est plus rapide et ne charge pas le VPS.

Compilation de la version de production

Sur votre ordinateur local, dans le dossier du projet, exécutez :

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

Cela créera un binaire lié statiquement, sans dépendances à glibc. La taille sera plus grande, mais il se lancera sur n'importe quel Linux.

Exemple d'un serveur web simple avec Actix-web pour le test (fichier 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}

Copie sur le serveur

Utilisez scp pour une copie sécurisée :

scp ./target/x86_64-unknown-linux-musl/release/votre_projet deployer@votre-ip-serveur:/home/deployer/

Sur le serveur, déplacez le binaire dans /usr/local/bin :

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

3. Configuration de systemd pour le démarrage automatique

Pour que l'application se lance au démarrage du système, redémarre après une panne et fonctionne en arrière-plan, nous allons créer un service systemd.

Créez le fichier de service :

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

Insérez la configuration suivante (remplacez deployer par votre utilisateur) :

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