Table of Contents
- What is Docker?
- Understanding Containers vs Virtual Machines
- Why Docker for DevOps?
- Installing Docker
- Key Docker Concepts
- Building Docker Images
- Dockerizing a Simple Application (Step-by-Step)
- Managing Containers
- Best Practices for Docker Usage in DevOps
- Conclusion
What is Docker?
Docker is an open-source platform designed to help developers and operations teams build, package, and deploy applications using containers. A container is a lightweight, standalone, executable package that includes everything needed to run a piece of software, including:
- Code
- Runtime
- Libraries
- Environment variables
- Configuration files
Docker simplifies application delivery by making it easy to ensure consistency across development, testing, and production environments.
Understanding Containers vs Virtual Machines
Containers:
- Share the host OS kernel
- Lightweight and fast
- Start in milliseconds
- Portable and isolated
Virtual Machines (VMs):
- Have their own OS
- Heavier in size
- Slower to boot
- More resource-intensive
| Feature | Containers | Virtual Machines |
|---|---|---|
| Boot Time | Milliseconds | Minutes |
| Size | MBs | GBs |
| Performance | Near-native | Overhead of guest OS |
| Portability | High | Medium |
Why Docker for DevOps?
Docker is an essential tool in the DevOps toolchain because:
- Consistency: Ensures the app runs the same everywhere.
- Isolation: Avoids dependency conflicts.
- Scalability: Easy to replicate containers across environments.
- Speed: Faster setup for testing and deployment.
- CI/CD Ready: Seamlessly integrates with pipelines.
Installing Docker
On Linux (Ubuntu):
sudo apt update
sudo apt install docker.io
sudo systemctl start docker
sudo systemctl enable docker
On macOS:
- Download Docker Desktop from: https://www.docker.com/products/docker-desktop
On Windows:
- Docker Desktop (with WSL2 backend recommended)
Verify Installation:
docker --version
docker run hello-world
Key Docker Concepts
- Docker Image: A read-only template with instructions for creating a container.
- Docker Container: A running instance of an image.
- Dockerfile: A script with instructions to build an image.
- Docker Hub: A public registry to store and share images.
Building Docker Images
You create a Docker image using a Dockerfile.
Example Dockerfile:
# Use an official Node.js runtime as a base
FROM node:18-alpine
# Set working directory
WORKDIR /app
# Copy package files
COPY package*.json ./
# Install dependencies
RUN npm install
# Copy source code
COPY . .
# Expose port and define command
EXPOSE 3000
CMD ["node", "index.js"]
Build Image:
docker build -t my-node-app .
Dockerizing a Simple Application (Step-by-Step)
Let’s containerize a basic Node.js app.
Step 1: Project Structure
/my-app
├── index.js
├── package.json
└── Dockerfile
index.js:
const http = require('http');
const port = 3000;
http.createServer((req, res) => {
res.end('Hello from Dockerized Node.js App!');
}).listen(port, () => {
console.log(`Server running at http://localhost:${port}`);
});
package.json:
{
"name": "docker-node-app",
"version": "1.0.0",
"main": "index.js",
"scripts": {
"start": "node index.js"
}
}
Dockerfile:
(Refer to the previous Dockerfile example)
Step 2: Build and Run
docker build -t docker-node-app .
docker run -p 3000:3000 docker-node-app
Step 3: Test the App
Visit http://localhost:3000 in your browser.
Managing Containers
List all containers:
docker ps -a
Stop a container:
docker stop <container_id>
Remove a container:
docker rm <container_id>
Remove an image:
docker rmi <image_id>
Best Practices for Docker Usage in DevOps
- Use Small Base Images: Alpine is a good minimal choice.
- Leverage
.dockerignore: Exclude unnecessary files from image context. - Multi-stage Builds: Keep final images lightweight.
- Tag Meaningfully: Use semantic versioning.
- Scan Images for Vulnerabilities: Tools like
Trivyhelp here. - Automate Image Builds: With CI tools like Jenkins, GitHub Actions.
- Use Private Registries for Sensitive Apps.
Conclusion
Docker is a cornerstone of modern DevOps workflows. With Docker, you can:
- Package and ship applications faster.
- Ensure environment parity.
- Simplify deployment and testing.
- Integrate seamlessly with CI/CD and orchestration tools like Kubernetes.
In the next module, we’ll take your Docker skills further by exploring Docker Compose and multi-container environments, enabling you to manage full app stacks efficiently.