TL;DR
Week 7 of my DevOps bootcamp focused entirely on Docker containerization. From understanding basic container concepts to implementing production-ready multi-service applications, this week was packed with hands-on learning and practical projects.
The Container Revolution
As I dove into containerization this week, I quickly realized why containers have become the standard in modern software deployment. The shift from traditional deployment methods to containerization represents a fundamental change in how we think about application infrastructure.
Docker vs Virtual Machines
One of the first concepts I mastered was understanding the difference between containers and virtual machines:
Aspect Virtual Machines Containers
Resource Usage High (full OS) Low (shared kernel)
Startup Time Minutes Seconds
Isolation Complete Process-level
Portability Limited High
Core Docker Concepts
Docker Architecture
Understanding Docker's architecture was crucial:
text
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Docker CLI │────│ Docker Daemon │────│ Containers │
└─────────────────┘ └─────────────────┘ └─────────────────┘
│
┌─────────────────┐
│ Images │
└─────────────────┘
Essential Commands Mastered
bash
Container lifecycle
docker run -d --name webapp nginx:latest
docker ps
docker stop webapp
docker start webapp
docker rm webapp
Image operations
docker build -t myapp:v1.0 .
docker tag myapp:v1.0 registry.example.com/myapp:v1.0
docker push registry.example.com/myapp:v1.0
Debugging and inspection
docker logs webapp
docker exec -it webapp /bin/bash
docker inspect webapp
Hands-On Projects
Project 1: Multi-Service Application with Docker Compose
I built a complete web application stack:
text
version: '3.8'
services:
frontend:
build:
context: ./frontend
dockerfile: Dockerfile
ports:
- "3000:3000"
environment:
- REACT_APP_API_URL=http://backend:5000
depends_on:
- backend
backend:
build:
context: ./backend
dockerfile: Dockerfile
ports:
- "5000:5000"
environment:
- DATABASE_URL=postgresql://user:password@database:5432/myapp
depends_on:
- database
database:
image: postgres:13-alpine
environment:
- POSTGRES_DB=myapp
- POSTGRES_USER=user
- POSTGRES_PASSWORD=password
volumes:
- postgres_data:/var/lib/postgresql/data
ports:
- "5432:5432"
volumes:
postgres_data:
networks:
default:
driver: bridge
Project 2: Custom Docker Image with Multi-Stage Build
Creating optimized Docker images:
text
Build stage
FROM node:16-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force
Production stage
FROM node:16-alpine AS production
RUN addgroup -g 1001 -S nodejs && \
adduser -S nextjs -u 1001
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --chown=nextjs:nodejs . .
USER nextjs
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD curl -f http://localhost:3000/health || exit 1
CMD ["npm", "start"]
Advanced Topics
Private Docker Registries
I implemented both AWS ECR and Nexus-based registries:
AWS ECR Setup:
bash
Login to ECR
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 123456789012.dkr.ecr.us-east-1.amazonaws.com
Tag and push
docker tag myapp:latest 123456789012.dkr.ecr.us-east-1.amazonaws.com/myapp:latest
docker push 123456789012.dkr.ecr.us-east-1.amazonaws.com/myapp:latest
Nexus Integration:
Configured Docker repository format
Set up authentication and permissions
Implemented automated cleanup policies
Data Persistence Strategies
Different volume types for different use cases:
bash
Named volume for databases
docker volume create postgres_data
docker run -d --name postgres -v postgres_data:/var/lib/postgresql/data postgres:13
Bind mount for development
docker run -d --name webapp -v $(pwd)/src:/app/src myapp:dev
Anonymous volume for temporary data
docker run -d --name cache -v /tmp/cache redis:alpine
Production Best Practices
Security Hardening
text
Use official images
FROM node:16-alpine
Create non-root user
RUN addgroup -g 1001 -S nodejs && adduser -S nextjs -u 1001
Set working directory
WORKDIR /app
Copy files with proper ownership
COPY --chown=nextjs:nodejs package*.json ./
RUN npm ci --only=production && npm cache clean --force
Switch to non-root user
USER nextjs
Use specific port
EXPOSE 3000
Health check
HEALTHCHECK --interval=30s --timeout=3s CMD curl -f http://localhost:3000/health || exit 1
Resource Management
text
services:
webapp:
image: myapp:latest
deploy:
resources:
limits:
cpus: '0.50'
memory: 512M
reservations:
cpus: '0.25'
memory: 256M
restart_policy:
condition: on-failure
delay: 5s
max_attempts: 3
Integration with DevOps Workflow
Docker seamlessly integrated with previous modules:
Version Control: Dockerfiles in Git repositories
Build Tools: Containerized build environments
Cloud Services: Deployment to AWS ECS/EKS
Infrastructure: Container orchestration platforms
Key Challenges and Solutions
Challenge 1: Container Networking
Issue: Services couldn't communicate across containers
Solution: Implemented Docker networks with proper service discovery
Challenge 2: Image Size Optimization
Issue: Large image sizes affecting deployment speed
Solution: Multi-stage builds reduced image size from 1.2GB to 150MB
Challenge 3: Data Persistence
Issue: Data loss when containers restart
Solution: Comprehensive volume strategy with backup procedures
Performance Metrics
Containerization improvements observed:
Deployment Speed: 80% faster than traditional deployments
Resource Usage: 60% reduction in memory footprint
Consistency: 100% elimination of environment-related issues
Scalability: Horizontal scaling reduced from hours to minutes
Tools and Technologies Used
Docker Engine: Container runtime
Docker Compose: Multi-service orchestration
AWS ECR: Managed container registry
Nexus: Artifact repository manager
Alpine Linux: Lightweight base images
Multi-stage builds: Image optimization
What's Next?
Week 8 focuses on Jenkins CI/CD integration - perfect timing to automate the entire containerization workflow!
Upcoming Learning:
Automated Docker builds in Jenkins
Container deployment pipelines
Integration testing with containers
Security scanning automation
Key Takeaways
Containers are transformative - They solve real deployment challenges
Docker Compose simplifies complexity - Multi-service apps become manageable
Security must be built-in - Non-root users and scanning are essential
Optimization matters - Image size directly impacts deployment speed
Integration is key - Containers work best as part of a complete DevOps workflow
Connect with Me
Following my DevOps learning journey? Let's connect!
🔗 LinkedIn: https://www.linkedin.com/in/iamdevdave/
🔗 Hashnode: https://dockerindevops.hashnode.dev/week-7-mastering-docker-containerization-from-basics-to-production
Top comments (1)
I just started following your journey from Week 4, and I'm impressed with your journey and consistency. I would like to say that writing your blog post can be better. There are some tools provided, and you're not using them. it's making your blogs look disorganized.
If you don't mind, I can send an email, and we can discuss further on how to make it better.