Docker Tutorial for Beginners

Introduction

Got ‘it works on my machine’ problems? Docker eliminates the headaches of environment setup, dependency management, and running your app the same everywhere! As a beginner, you’re often faced with complex installations and confusing deployment steps. Docker simplifies it by packaging your app and the whole environment into portable, isolated containers. Get started with our course: Docker! Discover our full Docker course syllabus to start your containerization journey!

Why Students or Freshers Learn Docker?

Learning Docker is very essential to starting a successful career in technology; it bridges the gap in classroom knowledge and industrial requirements.

• Industry Standard: It’s the dominant tool for modern software deployment – DevOps – and hence a high-demand skill, especially for entry-level positions.
• Environment Consistency: Docker solves the classic “it works on my machine” problem and teaches you to deploy applications reliably across any environment.
• Portfolio Enhancement: Showcase your Docker skills to employers; you are able to build, ship, and run applications efficiently in a professional manner.
• Cloud Readiness: Docker is foundational in understanding and working with major cloud platforms such as AWS, Azure, and GCP.
• Collaborative Development: This allows smooth collaboration among team members by guaranteeing that all use the same application environment.

Prepare for interviews! Check out our list of Docker Interview Questions and Answers now!

Step-by-Step Docker Tutorial for Beginners

Below is a comprehensive, step-by-step guide to get you started with Docker basics-from installation into running your first application in a container. We’ll break down the concepts and provide clear commands you can follow.

Step 1. Installation and Initial Setup

To start your Docker journey, you must install Docker Desktop. Docker Desktop is an application that contains the Docker engine, Docker CLI, Docker Compose, and a graphical user interface or GUI.

1.1. Download Docker Desktop

1. Head to Docker’s official website. Click on the “Get Started” or “Download” section.
2. Download the corresponding installer for your OS: Either Windows, macOS, or Linux, Debian/RPM.
3. Launch the installer.
   • Windows/macOS: Follow the prompts that appear on the screen. You may want to enable, on Windows, WSL 2 (Windows Subsystem for Linux) for improved performance and stability.
   • Linux: Follow the directions provided for your distribution. This will often include adding the Docker repository and running apt-get or yum commands.

1.2. Checking the Installation

After it has been installed, open your terminal (Command Prompt, PowerShell, or Bash) and execute these commands to make sure Docker is correctly set up:

docker –version

docker run hello-world

• The first command should show the installed version of Docker.
• The second command, docker run hello-world, serves as a vital test. Docker will:
• Pull the hello-world image from Docker Hub.
• Create and Start a new container from that image.
• This container will print a simple message, “Hello from Docker!”, and then exit.

If you see the success message, it means your Docker environment is ready!

Step 2: Understanding Core Docker Concepts

It is necessary to learn the basic terminology before beginning construction.

Concept	Description	Analogy
Image	A read-only template that contains the instructions for creating a container. It includes the application code, libraries, dependencies, and environment configuration.	A Blueprint for a house.
Container	A runnable instance of an image. It is an isolated, lightweight, and executable package of software.	The actual House built from the blueprint, where you live.
Docker Hub	A cloud-based registry service where users can find and share Docker images.	A public Library of blueprints.
Dockerfile	A text file containing all the commands a user could call on the command line to assemble an image.	The Instructions written to create the blueprint.

Step 3: Working with Docker Images

Images are the building blocks. You’ll either use existing images from Docker Hub or build your own.

3.1. Searching for Images

Search for images on Docker Hub using the docker search command:

# Search for official Node.js images

docker search node

3.2. Pulling Images

How to Pull an Image from Docker Hub onto Your Local Machine:

# Pull the latest official Ubuntu image

docker pull ubuntu:latest

# Pull a specific version of the official Python image

docker pull python:3.9-slim

3.3. Listing Local Images

See all the images currently stored on your local machine:

docker images

Step 4. Running Your First Container

The most frequently used command is docker run. This single command pulls (if needed), creates, and starts a container in one step.

4.1. Running a Simple Interactive Container

Let’s run a container based on the ubuntu image and enter its command line.

# -i (interactive) and -t (tty – terminal) keeps the standard input open

docker run -it ubuntu /bin/bash

After running this, your terminal prompt will change, and you are now inside the container.

• Try running some commands such as ls, pwd, or cat /etc/os-release. You will notice it’s a minimal Ubuntu environment.
• Type exit to stop the container and return to your host machine’s terminal.

4.2. Running a Detached Container (Web Server Example)

Most containers are designed to run in the background, especially web servers. The flag -d is for detached mode.

Let’s run a simple Nginx web server:

# -d: Detached (runs in background)

# -p 8080:80: Maps host port 8080 to container port 80

# –name webserver: Assigns a human-readable name

docker run -d -p 8080:80 –name my_nginx_server nginx:latest

• Open a web browser and go to http://localhost:8080. You should see the Nginx welcome page.
• You have successfully executed an application within an isolated container!

Step 5. Managing Containers

You need commands to check on, stop and clean up your containers.

5. 1. Listing Running Containers

To see only the containers that are currently running:

docker ps

5.2. Listing All Containers (Including Exited)

To view all containers, whether running or stopped:

docker ps -a

5.3. Stopping and Starting Containers

You can stop and start your running my_nginx_server container using its name:

# Stop the container

docker stop my_nginx_server

# Start the stopped container

docker start my_nginx_server

5.4. Removing Containers

Containers occupy disk space. If you are not going to use a container anymore, you should remove it. First, you need to stop it.

# Stop the Nginx server (if still running)

docker stop my_nginx_server

# Remove the container

docker rm my_nginx_server

Step 6: Building Your Own Image (The Dockerfile)

This is where you package your own application. We will create a simple Python application and containerize it.

6.1. Create Your Application Files

Create a new directory for your project, navigate into it, and create two files: app.py and Dockerfile.

app.py (The Python Code)

# app.py

print(“Hello, Docker World! This is my first containerized app.”)

Dockerfile (No file extension)

The Dockerfile contains step-by-step instructions to build the image.

# Use an official Python runtime as a parent image (base image)

FROM python:3.9-slim

# Set the working directory in the container

WORKDIR /app

# Copy the current directory contents into the container at /app

COPY app.py .

# Command to run when the container starts

CMD [“python”, “app.py”]

6.2. Create the Image

Use the command docker build in the directory that contains your Dockerfile.

# -t: Tag (name and optional version)

# .: The build context (all files in the current directory)

docker build -t my-python-app:v1.

You should see output from the running of the steps in the Dockerfile.

6.3. Run Your Custom Image

Now, run a container based on your newly built image:
docker run my-python-app:v1

Output: Hello, Docker World! This is my first containerized app.

Step 7: Persisting Data (Volumes)

By default, data inside a container is lost when the container is deleted. Volumes are used to persist data outside of the container’s lifecycle. 

There are two primary kinds of volumes: bind mounts and Docker-managed volumes. For a beginner example, we’ll use the more common bind mount: a bind mount maps a directory on your host machine to a directory inside the container. 

7.1. Using a Bind Mount

Suppose you have a config file on your host machine at /path/to/host/data and you want the container to access it at /app/data. 

# Example: Running an Nginx container that serves content from a local directory

# Replace /path/to/host/html with an actual local path (e.g., C:\Users\User\my-html)

docker run -d \

-p 8081:80 \

–name persistent_nginx \

-v /path/to/host/html:/usr/share/nginx/html \

nginx:latest

• The -v flag creates the bind mount: host_path:container_path. 
• Now, whatever you edit in /path/to/host/html from your computer instantly reflects on the running Nginx web page accessible at http://localhost:8081. 

Step 8: Networking

Isolated by nature, containers nevertheless need to communicate with the outside world and, quite often, with each other. 

8.1. Port Mapping 

Already Used The -p 8080:80 flag that we used above is the main way to expose a container’s internal port (80) to the host machine’s port (8080).

8.2. Container Networking (Docker Networks)

When containers need to talk to each other, such as a web app container talking to a database container, they should be on the same Docker network. 

Create A Network:

docker network create my-app-network

Run containers on a network:

Use the –network flag. Containers on the same user-defined network can resolve each other by name. 

# Run a database container on the network

docker run -d –network my-app-network –name db_server postgres

# Run a web app container on the network

# The web app can now access the database using the hostname ‘db_server’

docker run -d –network my-app-network –name web_app my-python-app:v1

Step 9: Clean up and Pruning

The Docker files can rapidly fill up your disk space. Cleaning up regularly is significant. 

9.1. Removing Images

Remove images you no longer need. You must remove all containers based on an image before you remove the image itself. 

# List image IDs (or names)

docker images

# Remove an image by ID or Tag

docker rmi my-python-app:v1

9.2. System Prune (The Big Clean) 

This is the most effective command for freeing up disk space, removing unused/dangling resources : stopped containers, unused networks, dangling images, and build cache. 

# Warning: This will remove a lot of things. Use with caution.

docker system prune

You will be asked to confirm this action. 

You now have a solid foundation in using Docker! Follow along with the advanced topics here: 

• Docker Compose: This tool defines and runs multi-container Docker applications. It uses a YAML file to configure all services, networks, and volumes. 
• Docker Hub Push: Share your custom images with the world by pushing them to Docker Hub. 
• Best Practices: Writing efficient and small Dockerfiles, for example, using multi-stage builds. 

Want to debug? Refer to our Docker Challenges and Solutions list to troubleshoot some common containerization issues!

Real Time Examples for Docker Tutorial for Learners

Docker really shines when consistency, speed, and isolation are needed. Following are three practical, real-world scenarios where Docker is indispensable for modern development:

Example 1: Setting up a Local Development Environment – The Dependency Solver

• Problem: A new developer joins the team and needs to work on a Python application that uses a specific version of PostgreSQL for the database, Redis for caching, and a particular system library. Installing and configuring all these components manually can take hours, often leading to version conflicts (“dependency hell”).
• Docker Solution: The entire application stack is defined in a single docker-compose.yml file.
• Real-Time Benefit: The developer runs one command docker-compose up, and within minutes they have an identical isolated environment running on their laptop just like the setup in production. This is the most common use of Docker for a beginner.

Example 2: Continuous Testing and CI/CD Pipelines – Quality Assurer

• Problem: Your code passes all tests on your machine but fails when the automated Continuous Integration (CI) system tries to build and deploy. This usually occurs due to minor differences in the operating system of the testing server, library versions, or both.
• Docker Solution: Everything from the installation of dependencies to running the tests is encapsulated inside a Docker container, made from an specific controlled image.
• Real-time Benefit: You test the code inside the same container environment that will be used during production, so you avoid environment-related bugs, which means whatever passes the test in the container will deploy.

Example 3: Running Legacy/Microservices Applications (The Isolation Expert)

• Problem: You have three different services, aka Microservices, that you want to run simultaneously. Service A requires Python 2.7, Service B requires Python 3.10, while Service C requires Java 17. If you try to run them directly on the same host machine, this will lead to complex path and version conflicts.
• Docker Solution: Each service is placed in a separate independent Docker container.
• Real-Time Benefit: Containers isolate the application’s dependencies. Service A’s container has Python 2.7 and Service B’s has Python 3.10; both are running happily side-by-side on the same server without interfering with each other. 

Ready to build something? Take a look at our Docker Project Ideas and start containerizing your own applications!

FAQs About Docker Tutorial for Beginners

Conclusion

You have been able to work through the basics of Docker, from installation and core concepts of Images, Containers, and Dockerfiles, and running and managing your first containerized applications. You are now equipped with the essential skills to eliminate environment inconsistencies and streamline your development workflow.

Docker is a highly sought-after skill that defines the modern notion of software delivery. Continue building, practicing, and studying Docker Compose and orchestration to master DevOps workflows. Ready for the next leap? Enroll in our comprehensive Docker course in Chennai to learn about advanced topics, practical projects, and preparation for certification!