Технологический Болт Генона

Технолоджиа!

Running Rust on shared hosting via PHP wrapper (hear me out)
https://www.reddit.com/r/rust/comments/1o9w36k/running_rust_on_shared_hosting_via_php_wrapper/

I wanted actual memory safety and compile-time guarantees, but I'm also practical about infrastructure. Didn't feel like paying for VPS hosting, managing security patches, configuring databases, setting up backups, and generally babysitting servers when shared hosting is under $10/month and handles all that.

Problem: how do you run Rust on shared hosting that only officially supports PHP?

A compromise: use PHP as a thin CGI-style wrapper that spawns your Rust binary as a subprocess:

1. PHP receives HTTP request

2. Serializes request context to JSON (method, URI, headers, body, query params)

3. Spawns Rust binary via proc_open

4. Binary reads JSON from stdin, processes request, writes response to stdout

5. PHP captures output and returns to client

Static linking is critical so you don't depend on the host's glibc. Using musl target:

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

Verify it's fully static:

ldd target/x86_64-unknown-linux-musl/release/myapp

Then just upload via SFTP and chmod +x.

Rust side (simplified):

use serde::{Deserialize, Serialize}; use std::io::{self, Read};

#[derive(Deserialize)]
struct Context { method: String, uri: String, headers: HashMap<String, String>, body: String, }

#[derive(Serialize)]
struct Response { data: serde_json::Value, }

fn main() -> Result<(), Box<dyn std::error::Error>> { let mut input = String::new(); io::stdin().read_to_string(&mut input)?;

let ctx: Context = serde_json::from_str(&input)?;
let result = handle_request(ctx)?;

println!("Content-Type: application/json\n");
println!("{}", serde_json::to_string(&result)?);

Ok(())
}

Database gotcha:

Shared hosting usually blocks TCP connections to MySQL. Use Unix sockets:

// Won't work: let url = "mysql://user:pass@localhost:3306/db";

// Will work: let url = "mysql://user:pass@localhost/db?socket=/var/run/mysqld/mysqld.sock";

Find your socket path via phpinfo().

Trade-offs:

Pros: actual memory safety, minimal memory footprint, no server maintenance, cheap hosting, just upload via SFTP

Cons: process spawn overhead per request, no persistent state between requests, two codebases, requires cross-compilation, binaries run with your account's full permissions (no additional sandboxing)

Security considerations:

Your binary runs with the same permissions as PHP scripts. Not sandboxed. All the usual rules apply: validate input rigorously, don't expose to untrusted users, sanitize file paths. The security model is essentially identical to running PHP.

Why this works:

You get Rust's memory safety guarantees and zero-cost abstractions while leveraging cheap shared hosting infrastructure. Not optimal for high-traffic production systems, but solid for side projects, low-traffic sites, and learning purposes. For serious production workloads you probably still want proper VPS or containerized deployment.

Ultimately though, the borrow checker doesn't care that it's being spawned by PHP.

🤪27🤡21🔥9💊9❤‍🔥2🙈2😁1🐳1

3.82K viewsedited 21:01