examples VS Rouille, Rust web server middleware

Using aws-sdk-s3 requires that tokio is installed. The above code was drafted from actix forms with multipart and s3 example with few modifications. There is a Client wrapper with two main endpoints: upload and delete_file. upload uses put_object_from_file to upload files to S3 and returns the uploaded files' URLs while delete_file deletes a file. We also created some type in backend/src/types/upload.rs:

I just figured it out. I had this: https://github.com/actix/examples/blob/master/databases/postgres/Cargo.toml as my toml, and somehow I removed the actix-web.workspace = true tag, but I didn't see the derive_more one. Removed it and that fixed it.

(In case it's could be part of the problem: the backend currently is this example https://github.com/actix/examples/tree/master/databases/postgres)

There's an example of using MongoDB with actix-web here: https://github.com/actix/examples/tree/master/databases/mongodb

Sorry for the late response. Here is an example of how I implemented it using axum and rustls, and there is a similar example for actix-web here. It looks like the actix-web example follows much the same process for parsing the key and cert files and creating the rustls server config so hopefully the tls module in my example can provide some help.

Actix has a handful of examples with different templating engines, including Handlebars: https://github.com/actix/examples/tree/master/templating

Good point. Didn't really bother tbh. Almost the same compile times applied when I did an actix project which also used a bunch of actors to make proper websocket communication work. So it might be related to the actor stuff and different messages which all is statically checked. So an actix-example like tcp-chat or chat-broker should be a good approximation (I chose to link some older versions since I haven't migrated to actix 4 yet).

Example from official repo

Your CRUD web application server almost certainly doesn't need async Rust. Using a blocking HTTP server is not "might be a good idea", it simply is a good idea.

I recommend Rouille for this: https://github.com/tomaka/rouille. In case you are worried about performance, check the benchmark. Blocking Rouille is faster than builtin async server in Node.js.

In strongly typed languages like Rust, composing smaller libraries is usually quite painless, so you don't need a large framework.

Personally for backend Rust I use rouille[0] for the server (it's very simple and async-free), askama[1] for compile-time HTML templates and (if a SPA is unavoidable, as that is of course always to be avoided if at all possible) yew[2] for client-side WASM.

Now this stack is what I like personally, but there are many options that you can combine, some more full-featured than others. Check out https://www.arewewebyet.org/ for a partial overview.

[0]: https://github.com/tomaka/rouille

[1]: https://github.com/djc/askama

[2]: https://yew.rs/

rouille

I'd like to put in a word for a simple, sync framework such as rouille. The compile times are much, much better, the number of dependencies is much smaller, the stuff it's built on (the standard library) is extensively tested and extremely reliable. Kernel context switches are slower than userspace thread scheduling, but not much slower, and as long as your services aren't just shoving bytes from one place to another (i.e. actually doing some computation) the time taken for a context switch vanishes into noise. A lot of benchmarks test how quickly a web service can move bytes, which (if your business logic is non-trivial) actually isn't the most critical factor.

I don't have any Rust-relevant experience here, but if I wanted to build a web server in Rust and was okay with "reasonable" performance, I'd probably give rouille a try first.

Rouille is fairly solid in my experience. Save the pain of async and spend it building software that works. Honestly with Rust's lack of GC you get predictable response times already.

I really thought this was about the web server framework https://github.com/tomaka/rouille, that's been around for ages.

Try rouille. It's a threaded web server (no async).

I'm continuing implementing features, getting Cozy Date app (cozydate.com) ready for launch. The backend is Rust + rouille on Heroku. This week I'm finishing up the app's Account Settings page. I'm merging a bunch of get/check/save RPCs for user postal code, identity, preferences, and account status into a single set of RPCs /get-account-settings, /check-account-settings, and /save-account-settings. This will eliminate some error states and reduce duplication in frontend and backend code. It also moves error message generation code from the frontend to the backend.

You may find it easier to use threaded rouille HTTP server running on Heroku (with heroku-buildpack-rust) and store the images as Postgres Large Objects. Heroku backs up the database automatically, so you don't need to worry about a random machine failure destroying the photos while you're on your honeymoon.