Docker for Beginners: Why DevOps Uses Containers
Learn Docker basics, including images, containers, Dockerfiles, and how containerization helps DevOps teams build and deploy applications consistently.
Series: My 90-Day AWS & DevOps Learning Journey (30 articles)
- …
- 15Docker for Beginners: Why DevOps Uses Containers This article
Docker for Beginners: Why DevOps Uses Containers
Have you ever built an application that worked perfectly on your computer but failed when someone else tried to run it?
You may have heard the classic problem:
"It works on my machine!"
One reason this happens is that different computers can have different:
- Operating systems
- Python or Java versions
- Libraries
- Dependencies
- Environment configurations
This is one of the problems Docker helps solve.
What Is Docker?
Docker is a platform for building, packaging, and running applications in containers.
A container packages an application together with the dependencies it needs to run.
Instead of saying:
1
2
3
4
"Install Python 3.x
Install these libraries
Configure this environment
Then run the application."
we can package the application and its required environment into a container image.
A simplified idea is:
1
2
3
4
5
6
7
8
9
Application
+
Dependencies
+
Configuration
↓
Docker Image
↓
Container
What Is a Container?
A container is a running instance created from a container image.
For example:
1
2
3
4
5
Docker Image
↓
Container
↓
Application Running
You can think of an image as a blueprint and a container as a running instance created from that blueprint.
This makes it easier to package applications consistently across different environments.
Docker Image vs Container
This is one of the first concepts I found important when learning Docker.
Docker Image
An image contains the application and the components required to run it.
For example:
1
2
3
4
5
6
7
Python Image
+
Application Code
+
Dependencies
↓
Docker Image
Container
A container is created from that image and runs the application.
1
2
3
4
5
Docker Image
↓
Container 1
Container 2
Container 3
Multiple containers can be created from the same image.
What Is a Dockerfile?
A Dockerfile contains instructions for building a Docker image.
For example:
1
2
3
4
5
6
7
8
9
10
11
FROM python:3.12
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]
This tells Docker how to create the application image.
The exact Dockerfile depends on the application.
The important idea is that the environment setup becomes repeatable.
A Simple Docker Workflow
A beginner Docker workflow can look like:
1
2
3
4
5
6
7
8
9
Write Application
↓
Create Dockerfile
↓
Build Image
↓
Run Container
↓
Test Application
For example:
1
docker build -t my-app .
Then:
1
docker run my-app
The first command builds an image, while the second runs a container from that image.
Why Is Docker Useful in DevOps?
Docker fits naturally into DevOps because it makes application packaging more consistent.
A typical workflow could be:
1
2
3
4
5
6
7
8
9
10
11
12
13
Developer
↓
Git
↓
Docker Build
↓
Docker Image
↓
Testing
↓
Container Registry
↓
Deployment
The same image can then be promoted through different environments.
For example:
1
2
3
4
5
6
7
Development
↓
Testing
↓
Staging
↓
Production
This can reduce differences between environments.
Docker and AWS
Docker isn't limited to local development.
AWS provides several services and tools that can work with containers.
For example:
1
2
3
4
5
6
7
8
9
Developer
↓
Docker
↓
Container Image
↓
Amazon ECR
↓
AWS Container Service
Amazon Elastic Container Registry (ECR) can be used to store container images.
AWS container workloads can then run using services such as Amazon ECS or Amazon EKS, depending on the architecture.
This is where learning Docker becomes especially useful for someone moving toward AWS and DevOps.
Docker and Virtual Machines
A common beginner question is:
Is a Docker container the same as a virtual machine?
No.
A virtual machine generally includes a complete guest operating system.
Containers share the host operating system's kernel while isolating the application and its processes.
A simplified comparison:
1
2
3
4
5
6
7
8
9
10
11
Virtual Machine
Hardware
↓
Host OS
↓
Hypervisor
↓
Guest OS
↓
Application
Compared with:
1
2
3
4
5
6
7
8
9
10
11
Container
Hardware
↓
Host OS
↓
Container Runtime
↓
Container
↓
Application
This is one reason containers can be lightweight and fast to start.
A Practical Example
Imagine I build a Python application on my laptop.
My environment contains:
1
2
3
4
5
Python
Django
Libraries
Environment Variables
Application Code
Another developer might have a different Python version or missing dependency.
Without containerization:
1
2
3
4
5
6
7
My Laptop
↓
Works
Another Laptop
↓
Dependency Problem
With Docker:
1
2
3
4
5
6
7
8
9
10
11
Application
+
Dependencies
↓
Docker Image
↓
Developer Machine
↓
Testing Server
↓
Production
The same image can be used across environments, provided the target environment supports the required container runtime and configuration.
Docker in a CI/CD Pipeline
Docker is also commonly used with CI/CD.
A pipeline might look like:
1
2
3
4
5
6
7
8
9
10
11
Git Push
↓
CI Server
↓
Run Tests
↓
Build Docker Image
↓
Push Image
↓
Deploy
This is one reason Docker is an important skill for DevOps engineers.
Instead of manually installing application dependencies on every server, the deployment process can work with a standardized container image.
Important Docker Terms
Here are some terms I'm currently learning:
Image — A packaged template used to create containers.
Container — A running instance of an image.
Dockerfile — Instructions used to build an image.
Docker Engine — The technology that builds and runs containers.
Registry — A location used to store and distribute container images.
Docker Hub — A popular public container image registry.
Amazon ECR — AWS's managed container image registry.
What I'm Learning From Docker
One thing I find interesting about Docker is that it changes the way we think about application deployment.
Instead of thinking:
"How do I install this application on every server?"
we can start thinking:
"How do I package this application so it can run consistently?"
That mindset is very useful in DevOps.
💬 Let's Discuss
For people learning Docker:
What was the biggest challenge when you first learned containers — Docker commands, Dockerfiles, networking, images, or understanding containers vs virtual machines?
Share your experience. It could help another beginner who is currently facing the same problem.
Key Takeaway
Docker helps developers and DevOps engineers package applications and their dependencies into portable containers.
The basic flow is:
1
2
3
4
5
6
7
8
9
10
11
Code
↓
Dockerfile
↓
Image
↓
Container
↓
Test
↓
Deploy
I'm now moving from learning individual AWS services toward understanding how AWS + Docker + CI/CD can work together in a real DevOps workflow.
Series: My 90-Day AWS & DevOps Learning Journey (30 articles)
- …
- 15Docker for Beginners: Why DevOps Uses Containers This article
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article