Forem: Austin Aigbe

Deploying Your Rust Apps in the Cloud

Austin Aigbe — Fri, 04 Mar 2022 05:13:48 +0000

Introduction

In this article, I provide a step-by-step guide on how you can easily deploy your Rust application in the cloud with Amazon AWS EC2. Depending on your system requirements, you can deploy your application in the cloud to save you the hassle of managing the hardware infrastructure yourself so you can focus on what matters - your application and the customers they serve.

Prerequisites

I am assuming you already have an AWS account, if not please create one and login as root user. We will be using the AWS EC2 Free Tier t3.micro compute, as our virtual server in the cloud.

Step 1

After logging in as root to your AWS account, switch to the new view and nagivate to EC2 as shown in the screenshot below. Select Services, Compute and then click on EC2.

Step 2

Click on Launch instances as shown below.

Step 3

Under choose AMI, first check the Free tier only box on the left side of the window and then select any image. I selected Ubuntu Server 20.04 LTS image. You can experiment with any of the images.

Step 4

Make sure you select the t3.micro (it is the free tier instance type) and then click on Review and Launch then Launch. This will display a window asking you to select or create a key pair. Select the applicable option and then click on Launch Instance

Step 5

Give your virtual server a name. Mine is named server-01. Wait for your server to change Instance state to Running before you connect to it.

Step 6

Now, you can connect to your virtual server using PuTTy, Powershell, Bash (if you are using Linux), CMD or any client application that supports SSH. I am using PuTTy. To connect to the compute or virtual server, ssh to the Public IPv4 DNS address specified under the Details tab.

Step 7

The user name is ubuntu. The virtual server has access to the internet and you can install any package you need. Now, let's install the Rust compiler.

Step 8

Install Rust and buid-essential (sudo apt install build-essential).

Step 9

We will be deploying two types of application on the virtual server - a telecoms application (a GTPv2-C server) and a web application based on the warp crate. GTPv2C protocol is used in the 3GPP based 3G, 4G and 5G networks for signaling and it uses port 2123 and the UDP transport protocol. We will configure our Rust GTP server to listen on UDP port 2123 in compilance with the 3GPP TS 29.274 (GTPv2-C) standard.

The web server will listen on TCP port 3030.

Configure the Inbound rules as shown below. AWS EC2 will apply these rules to our virtual server and it will allow our Rust applications to send and receive messages using these rules.

Step 10

Create your web server application using cargo new web_server and edit with nano as shown below. The original code is available here:https://github.com/seanmonstar/warp and it has been slightly modified for this tutorial. Run the web server with cargo run.

After this step, you will have two Rust applications running in the cloud. You can use the ps aux | grep target to check the two processes running (gtp and web_server)

Step 11

Open another PuTTy session and connect to the virtual server. Clone the GTPv2-C server from https://github.com/eshikafe/ngc and edit the ngc/common/gtp/src/main.rs so that the server listens and accepts conections from any IP address (i.e 0.0.0.0) as shown below. Run the application with cargo run

In the screen shot below, a simple Python script (the client) sends a message to the gtp server application using the Public IP address and port 2123. The script sends a GTPv2-C Create Session Request message from my Windows PC, through the internet, to the Rust GTPv2-C server application running in the cloud. This implies that you can deploy a telecom application (based on Rust) in the cloud to serve multiple devices concurrently and efficiently. The sample gtp application uses the tokio crate to achieve concurrency. Concurrency is a key requirement for a 4G/5G telecom server application.

Step 12

Lastly, open a web browser and paste the following URL in the address bar:{Public IPv4 DNS}:3030/hello/Rustacean. Replace Public IPv4 DNS with the domain assigned to your compute. You should see the message below.

You can also use curl to test your web server as shown below.

To deploy your applications securely in the cloud, you need to understand how the AWS EC2 security group works. Please read the AWS EC2 security group documentation before you deploy your application as a production system in the cloud.

Reference

AWS Tutorial for Beginners - Full Crash Course | Neal Davis

Rust-y Memory. How Safe?

Austin Aigbe — Fri, 04 Feb 2022 20:03:34 +0000

By Austin Aigbe

Introduction

The Rust programming language is said to be memory-safe but how does it achieve this? Why should we even care about memory safety? It turns out that the major cause of security vulnerabilities in modern day software systems (including Desktop and mobile applications) is due to memory safety issues and to address this, there is a general consensus, which I personally agree to, that a memory-safe systems programming language like Rust is required. This is one of the reasons big tech companies have decided to invest in Rust and re-engineer some of their key products and services with it.

How does `Rust` Achieve Memory Safety?

Memory safety is achieved through three key concepts: ownership (a language feature the compiler uses to free and allocate memory based on the scope of a variable binding), borrow checking and lifetimes. All these analyses are done during compile-time.

For simplicity, I will focus more on the ownership concept and show us how the compiler guarantees memory safety at compile-time using the scope of a variable binding to determine when to allocate and deallocate memory on the stack.

Before we proceed, let's review how our code is analyzed by the Rust compiler (rustc) for memory safety.

Code Compilation With Memory Management

In simple terms, a memory is a storage space (e.g RAM) on your computer where instructions to be executed by the computer's CPU are stored. These instructions are the lines of Rust code you have written and compiled with rustc (the Rust compiler) or cargo into a machine executable file (e.g .exe file format on Windows and elf on Linux). The executable file tells the Operating System how to load your Rust program into memory for execution by the CPU.

Now, let's compile a very simple Rust program with rustc and examine how memory management (ownership) works in Rust.

// hello.rs
fn main() {
    let rust_edition = 2021;
    let message = "Hello, Rust";
    println!("{message} {rust_edition}!");
}

Compiling the above code with rustc .\hello.rs on Windows will produce an executable file,hello.exe (about 148KB in size), in the same directory as the .rs file.

Next, let's see how the hello.exe was produced by rustc and how the memory-safety checks were done.

The Rust compiler, rustc, performed several analyses on the hello.rs file before it produced the hello.exe executable file. I will give a high-level overview of this process so we understand how memory safety is achieved by the compiler and at what phase of the compilation process it is done.

Figure 1: An simplified view of rustc compilation process

Phase 1: hello.rs was translated to basic tokens using the rustc_lexer crate and then to Rust tokens using the rustc_parser crate. Tokens are easier for the compiler to work with than the text format of your .rs file.

Phase 2:Tokens were translated to AST (Abstract Syntax Tree) format. Syntax analysis is done here. Use cargo inspect --unpretty=ast-tree .\hello.rs to examine the AST output.

Figure 2: AST tree of hello.rs with cargo-inspect

Phase 3 The println! macro was refined (or desugared) to a std::io::_print statement and core::fmt::Arguments function calls.The data type of our expressions were inferred and checked. We can say that type safety is guarateed at this phase of the code compilation. The HIR (High-Level Intermediate Representation) is the output of this stage. You can use crago inspect --unpretty=hir .\hello.rs to view the HIR representation of your Rust code.

Figure 3:println! macro desugared in the HIR.

Phase 4 HIR was converted to MIR (Mid-level Intermediate Representation). Ownership, borrow-checking and optimizations are done here. In fact, the MIR shows the scope of each variable and helps the compiler know at what point a variable binding (or ownership) is out of scope and when to dellocate memory from the stack. How the compiler tracks the scope of each variable is indicated in the screenshot below. In fact, the assembly code generated by LLVM (in phase 6) is the machine representation of the MIR (after the ownership, borrow checking and optimizations have been done). In the next phase, the asm .S file is examined to see how the variables are allocated on the Stack when they are in scope and how they are deallocated when they are out of scope. In this phase, memory safety is guaranteed by the compiler.

Figure 4: MIR representation of hello.rs

Phase 5 and 6 This is the code generation phase - LLVM was used to generate the final executable file hello.exe from the optimized and memory-safe MIR representation. Further optimizations can also be done by LLVM.

Let's briefly examine the assembly code (.S file) generated by LLVM. You can use rustc --emit asm .\hello.rs to generate the file. To keep things simple, I will only examine how the ownership memory-safety feature was achieved by the allocation and deallocation of memory on the stack.

Figure 5: A simplified memory layout of the stack from the perspective of the compiler generated main function.

The assembly code for the main function is shown above (in Figure 5). The entry point is not our hello::main function. As we will see later, Rust has a runtime (std::rt::lang_start_internal). This runtime handles a lot of complexities for us that we don't need to bother about when writing our Rust code.

Line 516: The compiler generated main function is the entry point for our program.
Line 518: 40 bytes of memory is allocated on the stack.rsp is the 64-bit stack pointer register for x86_64. It always points to the top the stack.
Line 523: _ZN5hello4main17h0767239aa2b5c6caE is the mangled symbol for our hello.rs main() function. The address of our hello::main function is stored in %rcx and then passed to the runtime function as a reference in line 103.
Line 524: This line calls the Rust runtime function std::rt::lang_start (defined in line 94) and subsequently, the internal runtime function std::rt::lang_start_internal (defined in line 104). Rust has a runtime that executes our hello.rs main() function.

Figure 6: Rust runtime function executes our hello::main function

Figure 7: Execution of hello::main (part 1)

Figure 8: Execution of hello::main (part 2)

Figures 7 and 8 show how sufficient memory (200 bytes) was first allocated on the stack by the compiler before allocating memory to the two local variables rust_edition (an i32), and message (a &str). Before returning from the hello::main function, the compiler deallocates memory on the stack and frees up resources.

Conclusion

We have seen how Rust guarantees memory safety during compile-time by examining the compilation phases and how memory is allocated and deallocated on the stack in assembly code. A very simple Rust program (hello.rs) was used to examine the output of each compilation phase and the memory management of the stack in assembly code.

We also learnt that the Rust compiler generates a main function for us as the entry point of our program. This main function uses the Rust runtime to execute the main function of our Rust program.

In summary, Rust tries to guaranty memory safety during compile time and it does a pretty good job in ensuring this.

Forem: Austin Aigbe

Deploying Your Rust Apps in the Cloud

Introduction

Prerequisites

Step 1

Step 2

Step 3

Step 4

Step 5

Step 6

Step 7

Step 8

Step 9

Step 10

Step 11

Step 12

Reference

Rust-y Memory. How Safe?

Introduction

How does Rust Achieve Memory Safety?

Code Compilation With Memory Management

Conclusion

References

How does `Rust` Achieve Memory Safety?