Containerize Rust Application in 2 Minutes using Docker Init

Introduced for the first time in Docker Desktop 4.18, the new docker init CLI generates Docker assets for projects, making it easier to create Docker images and containers. When you run the docker init command in your project directory, it will guide you through the creation of the necessary files for your project with sensible defaults. These files include:

• .dockerignore
• Dockerfile
• docker-compose.yaml

The docker init command also allows you to choose the application platform that your project uses and the relative directory of your main package.

In this blog post, we will walk through the process of creating a simple web application using Rust, leveraging the power of the Warp framework and the Tokio asynchronous runtime. We will also utilize Docker to containerize our application, making it easy to deploy and manage. By the end of this guide, you will have a fully functional Rust web application running in a Docker container.

Prerequisites

Before we begin, ensure that you have Docker Desktop version 4.18 or above installed on your machine. This will allow us to use Docker's features effectively.

Step 1: Setting Up the Project

First, we need to clone the repository that contains our sample application. Open your terminal and run the following commands:

git clone https://github.com/dockersamples/docker-init-demos
cd docker-init-demos/rust

cargo init
cargo build --release

This will create a new Rust project and build it in release mode.

Step 2: Running Docker Init

Next, we will use the Docker Init CLI to generate the necessary Docker files for our project. Run the following command:

docker init

You will see a welcome message from the Docker Init CLI, guiding you through the setup process. You may encounter a warning indicating that some Docker files already exist. When prompted, choose to overwrite them. Here’s a sample interaction:

Welcome to the Docker Init CLI!

This utility will walk you through creating the following files with sensible defaults for your project:
  - .dockerignore
  - Dockerfile
  - compose.yaml

WARNING: The following Docker files already exist in this directory:
  - .dockerignore

? Do you want to overwrite them? Yes
? What application platform does your project use? Rust
? What version of Rust do you want to use? 1.70.0
? What port does your server listen on? 3030

CREATED: .dockerignore
CREATED: Dockerfile
CREATED: compose.yaml

✔ Your Docker files are ready!

Once the files are created, you can review them and make any necessary adjustments. When you're ready, start your application by running:

docker compose up --build

Step 3: Running Docker Compose

To run your application in the background, execute the following command:

docker compose up -d --build

This command will build your Docker images and start the containers defined in your compose.yaml file.

Step 4: Accessing the Application

Once your application is running, you can access it in your web browser. Open your browser and navigate to:

http://localhost:3030

You should see a friendly message from Docker, confirming that your application is up and running:

.

## ##        ==

## ## ## ##    ===

/""""""""""""""""___/ ===

{                       /  ===-

______ O           __/

\    \         __/

_____/



Hello from Docker!

Step 5: Viewing It on Docker Desktop Dashboard

Finally, you can open the Docker Desktop Dashboard to view your running containers and manage them easily. This interface provides a visual representation of your Docker environment, allowing you to monitor resource usage, logs, and more.

Conclusion

In this blog post, we successfully created a simple web application using Rust, Warp, and Tokio, and containerized it with Docker. This setup not only simplifies deployment but also enhances the scalability and maintainability of your application. Feel free to explore further by adding more features to your Rust application or experimenting with different Docker configurations. Happy coding!