Deploy Actix Rust web service on RHEL using systemd and Nginx

OneUptime's RHEL deployment guide delivers the kind of reproducible steps engineers actually want: set RUST_LOG=info and run your Actix service, verify the process logs with info!("Starting server on 0.0.0.0:8080"); and exercise the API by POSTing '{"name": "Widget", "description": "A useful widget"}'. The guide's stated scope is clear — build, package, and deploy an Actix Web application to Red Hat Enterprise Linux using systemd and Nginx as a reverse proxy — and the excerpts include concrete code and commands you can run locally to validate behavior before deploying.

Why Actix on RHEL OneUptime frames the choice plainly: "Actix Web combines Rust's performance guarantees with a practical API for building web services." The guide repeats that Actix "is one of the fastest web frameworks available in any language" and highlights Rust's type system and async runtime — "the type system catches entire categories of bugs at compile time, and the async runtime handles thousands of concurrent connections efficiently." That combination is the selling point for production services on enterprise Linux distributions like RHEL where predictable performance and safety matter.

What you'll build (and what the guide covers) The OneUptime "on this page" navigation lists the topics the tutorial aims to cover: Getting Started with Actix Web; Routing in Actix Web; Adding a Database; App State in Actix Web; Middleware in Actix Web; Static Files in Actix Web; Deploying; and Finishing Up. The excerpts include application-state scaffolding and REST payload examples, so you get both in-memory prototyping and directions toward production concerns (systemd + Nginx) in one coherent path.

Project setup and shared app state (verbatim snippets) The guide demonstrates idiomatic Actix patterns for state and serialization. Example use statements and a shared state struct are presented exactly as shown: use actix_web::{web, App, HttpServer, HttpResponse, middleware}; use log::info; use std::sync::Mutex;

// Application state shared across all handlers // Mutex provides safe interior mutability for the items vector struct AppState { app_name: String, items: Mutex<Vec<Item>>, }

// Item represents a resource in our API #[derive(serde::Serialize, serde::Deserialize, Clone)] struct Item { id: String, name: String, description: String, created_at: String, } This pattern — web::Data for sharing AppState and using Mutex<Vec<Item>> for simple in-memory storage — is the exact code shape you can drop into a new Actix project to get a REST prototype running.

Starting and testing the server locally OneUptime shows practical run-and-test commands you can reproduce immediately. The recommended run invocation is explicit: RUST_LOG=info cargo run When the server starts in their example, code logs the message info!("Starting server on 0.0.0.0:8080"); which demonstrates an all-interfaces bind for production testing. The guide also includes curl-based tests, and a concrete POST payload to create an item: '{"name": "Widget", "description": "A useful widget"}' Note: several curl targets in the extracted text are truncated; the payload and the RUST_LOG run command are present verbatim and will let you exercise the handlers once you have the endpoints wired.

Minimal examples and templating from other tutorials (practical cross-references)

For quick reference and small examples, other tutorials reproduced in the research show common Actix patterns you can reuse:

• A minimal "hello world" service:

use std::io;

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

#[get("/")]

async fn hello() -> impl Responder {

HttpResponse::Ok().body("Hello, world!")

}

• Dev.to recommends adding actix-web = "4" to Cargo.toml and includes GET, POST, and manual route examples for building handlers and testing echo behavior.
• Engineering Deptagency demonstrates Handlebars templating and static file serving with actix_files and a Compliment struct rendered via hb.render("compliment", &compliment).unwrap(), showing how to add HTML rendering and static assets to an Actix service.

Deploying on RHEL with systemd and Nginx — what OneUptime provides and what's missing OneUptime explicitly targets deployment to Red Hat Enterprise Linux using systemd and Nginx as a reverse proxy. The guide's stated aim is to "build, package, and deploy a Rust web service built with Actix Web onto a Red Hat Enterprise Linux (RHEL) target using systemd and Nginx as a reverse proxy." However, the extracted text here is truncated in parts and does not include the concrete systemd unit file, the full Nginx configuration, or the exact packaging commands for producing an RHEL-compatible artifact (tarball, RPM, or similar). The article therefore serves as a reliable walkthrough for application code and local testing, and it explicitly names the deployment targets (systemd + Nginx on RHEL), but you should consult the full OneUptime guide for the missing unit file and reverse-proxy snippets before rolling into production.

Alternatives and build tooling notes

The research contrasts deployment strategies you should consider:

• Traditional Docker-based builds with cargo-chef can smooth multi-stage image builds and cache dependencies — Shuttle mentions cargo-chef as a mitigation for Dockerfile complexity.
• Shuttle offers a platform claim: "However, if you're using Shuttle you can just use `shuttle deploy` and you're done already. No setup is required." That is a vendor-provided alternative to self-managing systemd/Nginx on RHEL, and it may be attractive if you want out-of-the-box deploys rather than hand-crafted systemd units.

Be explicit about tradeoffs: OneUptime's primary audience is teams that want direct control of RHEL services; Shuttle pitches speed and zero-config. Both approaches are valid depending on your operational constraints.

Templating and static assets — multiple engines and examples

Across the sources, templating and static assets are handled with different engines:

• Engineering Deptagency uses Handlebars with actix_files for static serving and shows a Compliment struct rendered as HTML.
• Shuttle references Askama and includes a malformed templating snippet in the extract (preserved exactly here):

#[derive(Template)] #[derive(Template)]#[template(path = "index.html")] #[template(path = "index.html")]"index.html"struct IndexTemplate<'a> { struct IndexTemplate< 'a>{ name: &'a str : & 'a str} } #[get("/")] #[get("/")]"/"async fn index_route() -> impl Responder { async fn index_route() -> impl Responder{ IndexTemplate { name: "Shuttle" } IndexTemplate{: "Shuttle"}} }

The Shuttle snippet in the extract is syntactically malformed and duplicated; treat it as an indicator of the intent (Askama templating) rather than a drop-in example.

Practical differences across examples you should mind

The extracts demonstrate different bind patterns and environment variables you will encounter:

• OneUptime logs "Starting server on 0.0.0.0:8080" (all interfaces).
• Other tutorials bind to 127.0.0.1:8080 (localhost) or use env variables like BIND_ADDRESS (let address = env::var("BIND_ADDRESS") [...] in the engineering snippet).
• RUST_LOG is used for log-level control; OneUptime recommends RUST_LOG=info when running locally.

What the guide doesn't include here (follow-ups to fetch before production)

The research notes flag important gaps to resolve before finalizing a production run on RHEL:

• The full OneUptime systemd unit file(s) for running the Actix binary as a service.
• The exact Nginx reverse-proxy configuration used in the guide.
• Packaging commands for an RHEL target (tarball vs RPM) and any SELinux or firewall steps.
• The full curl endpoints for health and list operations (some curl lines are truncated in the extract).

Obtain those pieces from the complete OneUptime article before you finalize deployment scripts.

Conclusion OneUptime's walkthrough gives you a reproducible developer loop — write using web::Data, Mutex, and serde-annotated Item structs; run with RUST_LOG=info cargo run; and exercise the API with the provided POST JSON payload. It also makes the operational target explicit: package and deploy to RHEL using systemd and Nginx, a path many teams prefer for fine-grained control. For teams who prefer a no-ops alternative, Shuttle's `shuttle deploy` and cargo-chef for Docker optimization are viable options, but if you're managing RHEL hosts you'll want the missing unit files and Nginx snippets from the full OneUptime guide before flipping the switch.