Upskill/Reskill

Sep 10, 2024

Dockerize a Rust Application with AWS ECR and GitHub Actions

Adetokunbo Ige

‍

I have heard many exciting things about programming in Rust, so I decided to use Rust for one of my applications. Using the combination of Rust and Docker is quite interesting.

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

Below is a step-by-step guide on how to Dockerize an application in Rust and deploy this application to Amazon Elastic Container Registry (ECR). We’ll start with the assumption that you already understand AWS ECR and GitHub Actions.

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

First, ensure that Docker and Rust are installed in your development environment. Run the following commands in your terminal to install Docker and Rust. The command rustup 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 to 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.

Step 3: Create a Rust Application

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

‍

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

‍

Step 4: Create Cargo.toml and Cargo.lock file

Create a new file named Cargo.toml,which will contain the configuration details for the Rust binary. Also, create the Cargo.lock file, which will contain details of the binary. You can see a sample file here: https://github.com/ExitoLab/rust_docker_guide

Step 5: Create the Dockerfile

To containerize the Rust application, you need to create a Dockerfile. It will contain 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 it. touch Dockerfile

Open the Dockerfileand add the following content:

‍

# Use the official Rust image as the build environment
FROM rust:1.64 as builder

# Set the working directory
WORKDIR /usr/src/my_rust_app

# 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/my_rust_app/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 6: Building and Running the Docker Image

With ourDockerfileready, 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 7: 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 will see the result of the Rust app from the console and it will display “Hello, World!” confirming that the application is running successfully inside the Docker container.

See the screenshot below of the result.

‍

‍

Follow These Steps to Deploy Docker Image to AWS ECR

Step 1: Authenticate with AWS

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

‍

Step 2: Create AWS ECR Repository to Deploy Docker Image to AWS ECR

You will need to create an 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 3: 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:

‍

Deploy Docker Image to AWS ECR using GitHub Actions

Step 1: Authenticate with AWS for GitHub Actions.

Before pushing your Docker image to Amazon ECR using GitHub Actions, you must authenticate with AWS services using either IAM roles or AWS access keys and secret keys. I prefer to use IAM roles to authenticate with AWS. Using IAM roles for AWS authentication enhances security by providing temporary, least-privilege access and eliminates the need for hardcoded credentials. To use IAM roles in GitHub Actions, you can set up OpenID Connect (OIDC) authentication. This approach allows GitHub Actions to obtain temporary credentials from AWS based on the IAM role associated with the GitHub workflow.

‍

Step 2: Configure Authentication and Deployment Settings.

Add the Amazon Resource Name, AWS ECR and AWS region to GitHub Secrets to securely configure authentication and deployment settings for your GitHub Actions workflows.

‍