Deploying a Rust Application on VPS: Step-by-Step from A to Z

Introduction

You've written a cool application in Rust. It's fast, safe, and doesn't crash. But how do you make it run 24/7 on a remote server and be accessible to users? Deploying a Rust application on a VPS (Virtual Private Server) is a process that includes compiling the binary, setting up the environment, running it as a system service, and often setting up a reverse proxy.

In this article, we will go through the entire path from zero to a fully working Rust application deployed on a VPS with Ubuntu. You will learn how to prepare the server, build the project, set up auto-start, and ensure security. This guide is suitable for both web servers (Actix-web, Axum, Rocket) and any other Rust daemons.

Let's get started.

1. Server and Environment Preparation

Before deploying the code, you need to prepare the "ground". We will use Ubuntu 22.04 LTS, but the instructions are also suitable for Debian.

Connecting to the Server and Basic Setup

Connect to your VPS via SSH:

ssh root@your-server-ip

Update packages and create a user (working as root is bad practice):

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

Configure SSH keys for the new user so you don't have to enter a password every time.

Installing Rust on the Server

The most reliable way is to use the official rustup script. Switch to the deployer user and run:

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

After installation, reload the shell or run:

source $HOME/.cargo/env

Check the version:

rustc --version

For a production build, we will need static linking (so the binary works on any Linux without extra libraries). Install musl-tools:

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

2. Building and Transferring the Binary to the Server

It's better to build the application on your local machine (or in CI/CD) and then copy the ready binary to the server. This is faster and doesn't load the VPS.

Building the Production Version

On your local computer, in the project folder, run:

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

This will create a statically linked binary with no dependencies on glibc. The size will be larger, but it will run on any Linux.

Example of a simple web server using Actix-web for testing (file 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}

Copying to the Server

Use scp for secure copying:

scp ./target/x86_64-unknown-linux-musl/release/your_project deployer@your-server-ip:/home/deployer/

On the server, move the binary to /usr/local/bin:

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

3. Setting up systemd for Auto-start

To make the application start on system boot, restart after a crash, and run in the background, we will create a systemd service.

Create the service file:

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

Paste the following config (replace deployer with your user):

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