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 (0)