Dockerize a Rust Application with AWS ECR and GitHub Actions

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.

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:

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.

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 the touch Dockerfile command to create it.

Open the Dockerfile and add the following content:

Step 6: Building and Running the Docker Image

With your Dockerfile ready, you can create the Docker image for your 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.

👁 Image

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 an 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:

Step 3: Push the 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.

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.

Step 3: Run the GitHub Actions Pipeline

Conclusion

I hope you find this process of Dockerizing a Rust application useful and interesting. Check out the complete code on GitHub.

To learn more about the potential of AWS in software development, read Adetokunbo’s article “Deploy React on AWS Amplify Using Terraform.”