Blog Post

My personal experience dockerizing a Rust Application: Deploy to AWS ECR using Github Actions

,

I have heard about many interesting things about programming in Rust and I decided to use Rust for one of my applications. I enjoyed the programming experience in Rust and using the combination of Rust and Docker is quite interesting.

Rust is a system programming language that is popularly known for its memory safety, performance, and speed. Docker is a platform that enables developers to develop, deploy, and manage applications by using containerization. The combination of Docker and Rust creates an application that is both highly efficient and easily portable.

This article shows how to Dockerize your first application in Rust and deploy this application to AWS ECR. This is an assumption that you already have an understanding of AWS ECR and GitHub Actions.

Below is a step-by-step guide on how to Dockerize an application in Rust and deploy this application to AWS ECR.

Step 1: Setting Up Your Environment: Install Rust and Docker

Firstly, I ensure that both Docker and Rust are installed in your development environment. Run the following commands in your terminal to install Docker and Rust. The command installed rustup which helps to install the latest stable version of Rust.

# To install Rust 
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# To install Docker
# Follow this link https://docs.docker.com/engine/install/

Step 2: Setting Up the Project

Next, create a new Rust project using cargo Rust’s package manager and build system. Run the following command below. This will create a new directory rust_docker_guide

cargo new rust_docker_guide
cd rust_docker_guide

This will create a new directory named “rust_docker” with a basic Rust application. The main source file is located at src/main.rs. Open the file and you'll see the following code:

Step 3: Creating a Rust Application

Create the following code below in src/main.rs This is a simple Hello, world application in Rust Programming Language.

fn main() {
    println!("Hello, world!");
}

Step 4: Creating the Dockerfile

To containerize the Rust Application, you need to create a Dockerfile . The Dockerfile contains instructions on how to build the Docker image of your application. Create a new file in the root directory of your project and name it Dockerfile , you can also use this command below to create the Dockerfile

touch Dockerfile

Open the Dockerfile and add the following content below:

# Use the official Rust image as the build environment
FROM rust:1.64 as builder
# Set the working directory
WORKDIR /usr/src/myapp
# Copy the Cargo.toml and Cargo.lock files
COPY Cargo.toml Cargo.lock ./
# Copy the source code
COPY src ./src
# Build the application in release mode
RUN cargo build --release
# Use a minimal base image to run the application
FROM debian:buster-slim
# Copy the build artifact from the builder stage
COPY --from=builder /usr/src/myapp/target/release/my_rust_app /usr/local/bin/my_rust_app
# Expose the application port
EXPOSE 8080
# Run the application
CMD ["my_rust_app"]

Step 5: Building and Running the Docker Image

With our Dockerfile ready, you can create the Docker Image for our Rust Application by executing the following command.

docker build -t rust_docker_guide:v0.0.1 .

This command will create a Docker image named rust_docker_guide

Step 6: Test the Dockerize Rust Application locally

This command will start the docker container and map port 8080 of the host machine to port 8080 of the container.

docker run -p 8080:8080 rust_docker_guide:v0.0.1

You can access the Rust App on your browser by running http://localhost:8080 and it will display Hello, World! confirming that the application is running successfully inside the Docker Container

Step 7: Authenticate with AWS

Before pushing your Docker image to Amazon ECR, you must authenticate with AWS services using either IAM roles or AWS access keys and secret keys.

Step 8: Create AWS ECR Repository

You will need to create a AWS ECR Repository. Use the command below to create the repository. Replace <your_account_id>.dkr.ecr.us-east-1.amazonaws.com with your newly created Amazon ECR URI

aws ecr create-repository --repository-name rust_docker_guide
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin <your_account_id>.dkr.ecr.us-east-1.amazonaws.com

Step 9: Push Docker Image to Amazon ECR

The next step is to push the docker image you built locally to AWS ECR. See the command below on how to achieve this. Replace <your_account_id> with your AWS Account

docker tag rust_docker_guide:v0.0.1 <your_account_id>.dkr.ecr.us-east-1.amazonaws.com/rust_docker_guide:v0.0.1
docker push <your_account_id>.dkr.ecr.us-east-1.amazonaws.com/rust_docker_guide:v0.0.1

Conclusion

I hope you find this process of dockerizing Rust Application useful and interesting. Check out the complete code on GitHub

Original post (opens in new tab)

Rate

You rated this post out of 5. Change rating

Share

Share

Rate

You rated this post out of 5. Change rating