Docker Containerization Skill Overview Generate production-ready Docker configurations for modern web applications, particularly Next.js and Node.js projects. This skill provides Dockerfiles, docker-compose setups, bash scripts for container management, and comprehensive deployment guides for various orchestration platforms. Core Capabilities 1. Dockerfile Generation Create optimized Dockerfiles for different environments: Production ( assets/Dockerfile.production ): Multi-stage build reducing image size by 85% Alpine Linux base (~180MB final image) Non-root user execution for security Health checks and resource limits Development ( assets/Dockerfile.development ): Hot reload support All dev dependencies included Volume mounts for live code updates Nginx Static ( assets/Dockerfile.nginx ): Static export optimization Nginx reverse proxy included Smallest possible footprint 2. Docker Compose Configuration Multi-container orchestration with assets/docker-compose.yml : Development and production services Network and volume management Health checks and logging Restart policies 3. Bash Scripts for Container Management docker-build.sh - Build images with comprehensive options: ./docker-build.sh -e prod -t v1.0.0 ./docker-build.sh -n my-app --no-cache --platform linux/amd64 docker-run.sh - Run containers with full configuration: ./docker-run.sh -i my-app -t v1.0.0 -d ./docker-run.sh -p 8080 :3000 --env-file .env.production docker-push.sh - Push to registries (Docker Hub, ECR, GCR, ACR): ./docker-push.sh -n my-app -t v1.0.0 --repo username/my-app ./docker-push.sh -r gcr.io/project --repo my-app --also-tag stable docker-cleanup.sh - Free disk space: ./docker-cleanup.sh --all --dry-run

Preview cleanup

./docker-cleanup.sh --containers --images

Clean specific resources

1. Configuration Files

   .dockerignore

   Excludes unnecessary files (node_modules, .git, logs)

   nginx.conf

   Production-ready Nginx configuration with compression, caching, security headers

2. Reference Documentation docker-best-practices.md covers: Multi-stage builds explained Image optimization techniques (50-85% size reduction) Security best practices (non-root users, vulnerability scanning) Performance optimization Health checks and logging Troubleshooting guide container-orchestration.md covers deployment to: Docker Compose (local development) Kubernetes (enterprise scale with auto-scaling) Amazon ECS (AWS-native orchestration) Google Cloud Run (serverless containers) Azure Container Instances Digital Ocean App Platform Includes configuration examples, commands, auto-scaling setup, and monitoring. Workflow Decision Tree
3. What environment? Development → Dockerfile.development (hot reload, all dependencies) Production → Dockerfile.production (minimal, secure, optimized) Static Export → Dockerfile.nginx (smallest footprint)
4. Single or Multi-container? Single → Generate Dockerfile only Multi → Generate docker-compose.yml (app + database, microservices)
5. Which registry? Docker Hub → docker.io/username/image AWS ECR → 123456789012.dkr.ecr.region.amazonaws.com/image Google GCR → gcr.io/project-id/image Azure ACR → registry.azurecr.io/image
6. Deployment platform? Kubernetes → See references/container-orchestration.md K8s section ECS → See ECS task definition examples Cloud Run → See deployment commands Docker Compose → Use provided compose file

7. Optimizations needed?

   Image size

   → Multi-stage builds, Alpine base

   Build speed

   → Layer caching, BuildKit

   Security

   → Non-root user, vulnerability scanning

   Performance

   → Resource limits, health checks

   Usage Examples

   Example 1: Containerize Next.js App for Production

   User

   "Containerize my Next.js app for production"

   Steps

   :

   Copy

   assets/Dockerfile.production

   to project root as

   Dockerfile

   Copy

   assets/.dockerignore

   to project root

   Build:

   ./docker-build.sh -e prod -n my-app -t v1.0.0

   Test:

   ./docker-run.sh -i my-app -t v1.0.0 -p 3000:3000 -d

   Push:

   ./docker-push.sh -n my-app -t v1.0.0 --repo username/my-app

   Example 2: Development with Docker Compose

   User

   "Set up Docker Compose for local development"

   Steps

   :

   Copy

   assets/Dockerfile.development

   and

   assets/docker-compose.yml

   to project

   Customize services in docker-compose.yml

   Start:

   docker-compose up -d

   Logs:

   docker-compose logs -f app-dev

   Example 3: Deploy to Kubernetes

   User

   "Deploy my containerized app to Kubernetes"

   Steps

   :

   Build and push image to registry

   Review

   references/container-orchestration.md

   Kubernetes section

   Create K8s manifests (deployment, service, ingress)

   Apply:

   kubectl apply -f deployment.yaml

   Verify:

   kubectl get pods && kubectl logs -f deployment/app

   Example 4: Deploy to AWS ECS

   User

   "Deploy to AWS ECS Fargate" Steps : Build and push to ECR Review references/container-orchestration.md ECS section Create task definition JSON Register: aws ecs register-task-definition --cli-input-json file://task-def.json Create service: aws ecs create-service --cluster my-cluster --service-name app --desired-count 3 Best Practices Security ✅ Use multi-stage builds for production ✅ Run as non-root user ✅ Use specific image tags (not latest ) ✅ Scan for vulnerabilities ✅ Never hardcode secrets ✅ Implement health checks Performance ✅ Optimize layer caching order ✅ Use Alpine images (~85% smaller) ✅ Enable BuildKit for parallel builds ✅ Set resource limits ✅ Use compression Maintainability ✅ Add comments for complex steps ✅ Use build arguments for flexibility ✅ Keep Dockerfiles DRY ✅ Version control all configs ✅ Document environment variables Troubleshooting Image too large (>500MB) → Use multi-stage builds, Alpine base, comprehensive .dockerignore Build is slow → Optimize layer caching, use BuildKit, review dependencies Container exits immediately → Check logs: docker logs container-name → Verify CMD/ENTRYPOINT, check port conflicts Changes not reflecting → Rebuild without cache, check .dockerignore, verify volume mounts Quick Reference

Build

./docker-build.sh -e prod -t latest

Run

./docker-run.sh -i app -t latest -d

Logs

docker logs -f app

Execute

docker exec -it app sh

Cleanup

./docker-cleanup.sh --all --dry-run

Preview

./docker-cleanup.sh --all

Execute

Integration with CI/CD GitHub Actions - run : | chmod +x docker-build.sh docker-push.sh ./docker-build.sh -e prod -t ${{ github.sha }} ./docker-push.sh -n app -t ${{ github.sha }} --repo username/app GitLab CI build : script : - chmod +x docker - build.sh - ./docker - build.sh - e prod - t $CI_COMMIT_SHA Resources Scripts ( scripts/ ) Production-ready bash scripts with comprehensive features: docker-build.sh - Build images (400+ lines, colorized output) docker-run.sh - Run containers (400+ lines, auto conflict resolution) docker-push.sh - Push to registries (multi-registry support) docker-cleanup.sh - Clean resources (dry-run mode, selective cleanup) References ( references/ ) Detailed documentation loaded as needed: docker-best-practices.md - Comprehensive Docker best practices (~500 lines) container-orchestration.md - Deployment guides for 6+ platforms (~600 lines) Assets ( assets/ ) Ready-to-use templates: Dockerfile.production - Multi-stage production Dockerfile Dockerfile.development - Development Dockerfile Dockerfile.nginx - Static export with Nginx docker-compose.yml - Multi-container orchestration .dockerignore - Optimized exclusion rules nginx.conf - Production Nginx configuration