‍In today’s digital age, having a powerful and efficient web application is crucial for businesses to succeed. While there are many programming languages and frameworks available, Rust stands out for its high performance and capabilities in systems programming. However, what if you could harness the power of Rust to build full-functioning and efficient web applications? That’s where the Rocket web framework comes in. In this comprehensive guide, we will explore what Rocket is, how to install it, and how to use it to build your own website.

What is Rocket?

Rocket is a framework specifically designed for building web applications with the Rust programming language. Rust is known for its type-safety and speediness, and Rocket aims to leverage those attributes to create secure and efficient web applications. One of the standout features of Rocket is its emphasis on simplicity and minimalism. It provides simple and intuitive APIs, allowing developers to quickly assemble the web application they need without unnecessary boilerplate code. Additionally, Rocket is an extensible framework designed for flexibility, allowing developers to customize and extend its functionality.

Before You Begin

Before diving into the world of Rocket, there are a few prerequisites you need to meet. First, make sure you have a Linode account and a Compute Instance. If you don’t have one yet, you can create an account and set up a Compute Instance following the instructions in the Linode documentation. Additionally, it’s important to update your system and ensure its security. Linode provides a guide on setting up and securing a Compute Instance that you can follow. Finally, throughout this guide, we will refer to an example application called “example-app.” Feel free to replace it with your preferred application name as you follow along.

Installing Rust

Rocket makes use of some of Rust’s cutting-edge features, so it’s important to have the correct version of Rust installed. To get started, you’ll need to install rustup, which is an installer for Rust. You can install rustup by running the following command:

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

If you don’t already have Curl installed, you can install it with the following command:

sudo apt install curl

Once rustup is installed, log out and log back in or run the following command to load the necessary executables into your Bash path:

source $HOME/.cargo/env

Next, set the nightly build of Rust as your default Rust version by running the following command:

rustup default nightly

Alternatively, if you prefer to set the nightly release as the default for a specific project, you can use the following command in the project directory:

rust override set nightly

Getting Started with Rocket

Now that you have Rust and the necessary tools installed, let’s dive into using Rocket by exploring some example applications. First, clone the Rocket repository using Git. In this example, we will clone it into the current user’s home directory:

cd ~
git clone https://github.com/SergioBenitez/Rocket

If you don’t have Git installed, you can install it with the following command:

sudo apt install git

Once the repository is cloned, navigate to the resulting Rocket directory and check out the latest version. You can find the latest version on Rocket’s releases page:

cd Rocket
git checkout v0.4.7

Inside the examples directory, you will find various example applications to explore. Choose one that interests you and navigate to its directory:

cd examples/hello_world

To run the example, use the cargo run command:

cargo run

The example application will be served on localhost port 8000. If you want to visit the application remotely, you can set up an SSH tunnel. On Windows, you can use the PuTTY tool to set up the tunnel. For macOS or Linux, you can use the following command:

ssh -L 8000:localhost:8000 shapehost@192.0.2.0

Replace “shapehost” with your username and “192.0.2.0” with the server’s IP address. Now you can visit the application in your browser by navigating to localhost:8000.

Creating Your Own Rocket Application

Now that you have explored the example applications, it’s time to create your own Rocket application. Start by changing to the location where you want the project directory to be created. In this case, we will use the current user’s home directory:

cd ~

Create a new binary-based Rust project using the cargo new command and change into the new directory:

cargo new example-app --bin
cd example-app

Open the Cargo.toml file in a text editor and add Rocket as a dependency for the project. Make sure to use the latest version of Rocket. Here’s an example of how the dependencies section should look:

[dependencies]
rocket = "0.4.7"

Next, open the src/main.rs file and populate it with the following code:

#![feature(proc_macro_hygiene, decl_macro)]

#[macro_use] extern crate rocket;

#[get("/")]
fn index() -> &'static str {
"Hello, world!"
}

fn main() {
rocket::ignite().mount("/", routes![index]).launch();
}

Congratulations! You have now created a basic “Hello, World!” application using Rocket. To test it, use the cargo run command:

cargo run

Building a Website with Rocket

Rocket is not only suitable for simple applications but can also be used to build full-fledged websites. By pairing Rocket with a template engine like Handlebars, you can easily create dynamic and interactive websites. Let’s walk through the steps of setting up Rocket to run a full website and provide web service APIs.

Start by following the steps in the “Creating Your Own Rocket Application” section above to create a base Rocket application. Once you have set up the base application, open the project’s Cargo.toml file and modify it with the additional lines below:

[dependencies]
rocket = "0.4.7"
serde = { version = "1.0", features = ["derive"] }

[dependencies.rocket_contrib]
version = "*"
default-features = false
features = ["handlebars_templates"]

The above modifications add serde as a dependency, which provides typing features necessary for the application, and allow the use of Handlebars as a template engine.

Next, open the src/main.rs file and modify it to include the following code:

#![feature(proc_macro_hygiene, decl_macro)]

#[macro_use] extern crate rocket;
use rocket::response::Redirect;
use rocket_contrib::templates::Template;

#[derive(serde::Serialize)]
struct Message {
user: &'static str,
body: &'static str
}

#[derive(serde::Serialize)]
struct BoardContext {
current_user: Option<String>,
messages: Vec<Message>,
parent: &'static str
}

#[derive(serde::Serialize)]
struct AboutContext {
parent: &'static str
}

#[get("/")]
fn index() -> Redirect {
Redirect::to("/user/anonymous")
}

#[get("/user/<username>")]
fn board(username: String) -> Template {
Template::render("index", &BoardContext {
current_user: Some(username),
messages: vec![
Message{user: "userA", body: "This is the first test message."},
Message{user: "userB", body: "This is the second test message."}
],
parent: "layout"
})
}

#[get("/about")]
fn about() -> Template {
Template::render("about", &AboutContext {
parent: "layout"
})
}

In the code above, we define several structs that will be used as context information for the templates. The Message struct defines the basic shape for messages, and the BoardContext and AboutContext structs provide context information for the board and about functions, respectively. The functions load the appropriate context information and render the templates accordingly. The index function uses a redirect to navigate users from the base URL to the message board URL.

To create the required template files, start by creating a template directory:

mkdir templates

Next, create the following five template files:

1. layout.hbs – Defines the page layout used on each page.
2. header.hbs – Provides the contents for the header section.
3. footer.hbs – Provides the contents for the footer section.
4. index.hbs – Defines the layout for the main page (message board).
5. about.hbs – Provides the contents for the about page.

Here’s an example of the content for each template file:

layout.hbs:

<!doctype html>
<html>
<head>
<title>Example App - Message Board</title>
</head>
<body>
{{> header}}
{{~> page}}
{{> footer}}
</body>
</html>

header.hbs:

<nav>
<a href="/">Message Board</a> | <a href="/about">About</a>
</nav>

footer.hbs:

<footer>
Built with Rust and the Rocket framework.
</footer>

index.hbs:

{{#*inline "page"}}
<section id="message_board">
<h1>Hi, {{ current_user }}!</h1>
You can login as a different user by navigating to "/user/{username}".
<h2>Messages</h2>
<ul>
{{#each messages}}
<li>{{ this.user }}: {{ this.body }}</li>
{{/each}}
</ul>
</section>
{{/inline}}
{{~> (parent)~}}

about.hbs:

{{#*inline "page"}}
<section id="about">
<h1>About</h1>
This is an example web application built with Rust and the Rocket framework.
</section>
{{/inline}}
{{~> (parent)~}}

Now that everything is set up, run the application using the cargo run command:

cargo run

Congratulations! You have successfully built a website using Rust and the Rocket web framework. This example demonstrates the power and versatility of Rust in web development. Rocket’s integration with Handlebars allows you to create dynamic and interactive websites easily.

Conclusion

In conclusion, Rust and the Rocket web framework provide a powerful combination for building efficient and secure web applications. With its type-safety, speediness, and extensibility, Rust is an excellent choice for systems programming. Rocket simplifies the process of building web applications by providing intuitive APIs and minimizing boilerplate code. By following the steps outlined in this guide, you can get started with Rocket and build your own web applications or full-fledged websites.

To learn more about Rocket and its features, refer to the official Rocket documentation. Additionally, if you’re interested in exploring more about templates in Rocket, the Handlebars language guide is a valuable resource. Finally, for further learning about Rust programming, be sure to check out the resources linked on Rust’s learning page, including “The Rust Book” and various Rust courses.

Remember, when it comes to hosting your web applications and websites, Shape.host offers reliable and scalable cloud hosting solutions. Their Cloud VPS services provide the performance and security you need to ensure your applications run smoothly. Consider Shape.host for your hosting needs and take your Rust and Rocket-powered web applications to the next level.

Christian Wells