Yet Another Tutorial: Getting Started with Docker

You have built an amazing web application. It works perfectly on your machine, but when your teammate tries to run it, they get dependency errors. When you deploy to staging, the Node.js version is different. In production, a missing system library breaks everything.

Sound familiar?

This is exactly where Docker shines. It brings consistency to your workflow by packaging your app, along with all its dependencies, into a single, standardized unit called a container. Whether you are running it on your laptop, staging server, or cloud production environment, it works the same, every time.

Docker ≈ Shipping Containers

Docker containers are like modern shipping containers for code:

• All-In-One Package: A shipping container holds goods; a Docker container holds an app with all its dependencies.
• Works Anywhere: A shipping container moves between ships, trucks, and trains without repacking; a Docker container moves between different environments without modification.
• Standardized & Isolated: Every shipping container looks the same outside; every Docker container runs the same across systems.
• Easy to Scale: Need more capacity? Load more shipping containers. Need to handle more traffic? Run more Docker containers.
• Reduces Conflicts: Without standard containers, shipments will need custom handling for each and every item. Without Docker, you will need to customize every server environment to suit the apps needs to run.

Why Use Docker?

Docker isn’t just another tool, it is a solution to the most frustrating parts of application development:

• No more “it works here but not there” headaches.
• Faster, more reliable deployments.
• Apps can scale effortlessly to handle more traffic.

Now, that you know the benefits of Docker, let us walk through the process of containerizing your application.

Step 1: Install Docker

First, ensure Docker is installed on your machine.

• Download Docker Desktop from Docker’s official website.
• If you’re using a Mac, it’s recommended to install Docker using Homebrew with the command brew install --cask docker.
• Alternatively, you can use Podman by following the Podman installation guide.

Step 2: Create a Dockerfile

In your application’s root folder, create a file named Dockerfile and add the following content. For example, in my case, I am using a React application, so my Dockerfile content will look like this:

# Use the Node.js 20.13.1 base image
FROM node:20.13.1
 
# Set the working directory inside the container
WORKDIR /app
 
# Copy package files and install dependencies
COPY package*.json ./
RUN npm install
 
# Copy the entire application code
COPY . .
 
# Build the application
RUN npm run build
 
# Expose the port your app runs on
EXPOSE 3000
 
# Command to start the application
CMD ["npm", "start"]

This Dockerfile follows a streamlined process that minimizes the final image size, ensuring faster builds and deployments.

You can check for docker file templates at the Dockerfile Project website

Dockerfile Project

Step 3: Build the Docker Image

Navigate to your project directory in the terminal and build the Docker image:

docker build -t <ImageName> .

Example:

docker build -t myapp .

This creates an image named myapp. The . at the end specifies the current directory as the build context.

Step 4: Run a Docker Container

Once the image is built, run a Docker container using the following command:

docker run --name <ContainerName> -p <LocalPort>:<ExposePort> -d <ImageName>

Example:

docker run --name myapp -p 3000:3000 -d myapp

This command maps port 3000 on your local machine to port 3000 inside the container. Access your app by visiting http://localhost:3000.

To stop a running Docker container, you can use the docker stop command followed by either the container ID or name.

Here’s the command to stop it:

docker stop myapp

Alternatively, you can use the container ID that was returned when you started it:

docker stop 7530a48c0ecd*******************

Either command will gracefully stop the container. Docker will send a SIGTERM signal to the main process in the container and wait for it to shut down (with a default timeout of 10 seconds before forcing it to stop with SIGKILL).

If you want to remove the container after stopping it (so you can create a new one with the same name later), you can use:

docker rm myapp

Or to stop and remove in a single command:

docker rm -f myapp

Conclusion

Docker transforms application development from “works on my machine” to “works everywhere, every time.” By containerizing your applications, you eliminate environment inconsistencies, simplify deployments, and create a foundation for scalable, maintainable software.

Start with a simple application, master the basics, then gradually adopt more advanced patterns as your needs grow. Your future self, and your team, will thank you for the consistency and reliability that Docker brings to your development workflow.