Rocket VS hyper

Rocket has evolved into a highly usable, performant framework with active development and over 25k GitHub stars. Here is a simple example of a Rocket server that takes two query parameters and returns a Happy Birthday message:

Rocket: Rust's Type-Safe API Builder

To find answers, we wanted to get our hands dirty with three popular Rust web frameworks including rocket, axum, and actix, and get a feeling for their performance, features, and most importantly the developer experience.

In this post, we'll explore how to set up a local development environment for a Rust web application using the Rocket framework and Docker. The setup includes automatic recompilation and logging whenever you update your code. Here's how it works, step by step.

Today we talk about Rocket.rs, a web framework that uses Rust as a backend language. 🚀

I was surprised not to see Rocket (https://rocket.rs/) mentioned among the frameworks the author listed; I haven’t used it myself because I _like_ the more unopinionated axum/actix-web, but as I understand it its goals are much more in the vein of what the author wants in a batteries-included framework.

At the bottom of the Rocket web site there are a few sponsors listed Kindness.ai, ohne Makler, 1Password, Signal Insight, and Edwin Olback. There are more sponsors on GitHub sponsors page

4. Rocket

If you want something simpler/more minimal, you could use https://rocket.rs/ for the backend and handle the front-end however you want.

Gotham is a flexible web framework built for stable Rust that promotes “stability, safety, security, and speed.” It provides async support with the help of Tokio and hyper out of the box.

In particular the last point is what sets axum apart from other frameworks axum doesn't have its own middleware system but instead uses tower::Service. This means axum gets timeouts, tracing, compression, authorization, and more, for free. It also enables you to share middleware with applications written using hyper or tonic.

The bytes crate does support what ComputerGuru asked for via the Buf trait. The trait can be implemented over a sequence of buffers but still provides functions that are common with single buffers. In fact the hyper crate uses the trait in exactly this way - it has an internal type that is a VecDeque of chunks but also implements the Buf trait.

https://docs.rs/bytes/1.9.0/bytes/buf/trait.Buf.html

https://github.com/hyperium/hyper/blob/3817a79b213f840302d7e...

> While not really the target audience for either language, I would prefer zig's crashing behavior to hyper using unsafe evaluations of macros as an example.

> https://github.com/hyperium/hyper/blob/30f2961e89eb306780d85...

This looks basically like a port of something like Kotlin or C#'s ?. operator - the macro checks whether the pointer is null, returns err if it is, and dereferences the pointer otherwise. The part highlighted in the link looks like it's part of the macro implementation - there don't seem to be any "direct" uses of that particular rule in calling code and it's only invoked via the other rules in that macro definition. I think that should make that bit null-safe at least.

Lifetime safety might be a bit trickier, especially since that bit is part of hyper's C API so idk if there's anything Rust (or Zig, for that matter) could do to ensure the pointer is still valid when dereferenced.

Hyper Crate

I'd point out that one advantage Go has over Rust in terms of security are the coverage of standard libraries. Go has great support for HTTP clients/servers, cryptography primitives, SSH, SQL, JSON, secure RNG, etc. all in officially maintained standard libraries. The Rust ecosystem has some standards here but the most widely used HTTP client, just as an example, is mostly maintained by one guy[1]. I think that adds considerable security risk vs Go's net/http.

1. https://github.com/hyperium/hyper/graphs/contributors

After I read a bit about axum [1], it says it's a relatively thin wrapper on top of hyper [2], a fast and correct HTTP library.

In other words, what can be done with NGINX, it can be achieved with axum (assuming you know Rust).

It looks interesting, I'm not going to lie!

[1] https://github.com/tokio-rs/axum

[2] https://crates.io/crates/hyper

A high-performance runtime, with a multi-threaded, asynchronous event loop written in Rust (using Tokio and Hyper).

Its core dependencies is hyper, "a protective and efficient HTTP library for all" which is rather low-level.

Mocking helper to develop microservices and APIs. hyper-based HTTP server generating REST responses containing JSON ones. Written in Rust.