Docker Hub Toolkit

End-to-end automation for deploying Python project images to Docker Hub with maximum performance and efficiency.

What This Skill Does

• •Generates optimized multi-stage Dockerfiles (base → builder → dev → production)
• •Builds, tags, and pushes images to Docker Hub
• •Creates CI/CD pipelines (GitHub Actions) for automated deployment
• •Optimizes image size and build speed with BuildKit caching
• •Sets up multi-platform builds (amd64/arm64)
• •Generates .dockerignore and docker-compose.yml
• •Scans images for security vulnerabilities
• •Debugs failed Docker builds

What This Skill Does NOT Do

• •Deploy to Kubernetes/ECS/cloud orchestrators (container runtime only)
• •Manage Docker Hub billing or account settings
• •Handle non-Python project images
• •Create Docker Swarm or cluster configurations
• •Manage Docker Hub webhooks or automated test integrations

Before Implementation

Gather context to ensure successful implementation:

Ensure all required context is gathered before implementing. Only ask user for THEIR specific requirements (domain expertise is in this skill).

Required Clarifications

Ask about USER'S context:

1. •Docker Hub credentials: "What is your Docker Hub username/namespace?"
2. •Project type: "What Python framework? (FastAPI, Flask, Django, script)"
3. •Entry point: "What command starts your app? (e.g., uvicorn app.main:app)"
4. •Deployment target: "Local push, or automated CI/CD via GitHub Actions?"

Workflow

Full Deployment Pipeline

1. Generate Dockerfile    → Multi-stage optimized build
2. Create .dockerignore   → Exclude unnecessary files
3. Build image            → With BuildKit caching
4. Tag image              → Semantic version + git SHA
5. Security scan          → Check for vulnerabilities
6. Push to Docker Hub     → Authenticated push
7. Set up CI/CD           → GitHub Actions automation (optional)

Stage-by-Stage Execution

Stage 1: Generate Base Configuration

1. •Detect Python version from pyproject.toml, setup.py, or .python-version
2. •Identify dependency file (requirements.txt, pyproject.toml, Pipfile)
3. •Generate .dockerignore from assets/templates/dockerignore.template
4. •Create multi-stage Dockerfile using patterns from references/multi-stage-builds.md

Stage 2: Build Dependencies Stage

1. •Use --mount=type=cache,target=/root/.cache/pip for pip caching
2. •Use --mount=type=bind for dependency files
3. •Install to --user for clean multi-stage copy
4. •Verify dependency resolution succeeds

Stage 3: Development/Test Stage (Optional)

1. •Copy dependencies from builder
2. •Copy source code
3. •Run tests (pytest) and linting
4. •Target with docker build --target dev

Stage 4: Production Build & Push

1. •Fresh slim base image
2. •Create non-root user
3. •Copy only runtime dependencies from builder
4. •Set proper CMD/ENTRYPOINT
5. •Tag with version strategy
6. •Push to Docker Hub

Available Scripts

Dependencies

• •Docker Engine 20.10+ (BuildKit support)
• •Docker CLI with buildx plugin
• •Docker Hub account with access token
• •Git (for SHA-based tagging)
• •Python 3.10+ (for the project being containerized)

Error Handling

See references/troubleshooting.md for comprehensive error resolution.

Input/Output

• •Input: Python project with dependency file (requirements.txt/pyproject.toml)
• •Output: Optimized Docker image pushed to Docker Hub at username/app:tag

Output Checklist

Before delivering, verify:

• • Multi-stage Dockerfile with base → builder → production stages
• • .dockerignore excludes .git, __pycache__, .venv, .env, node_modules
• • BuildKit cache mounts used for pip installs
• • Non-root user in production stage
• • PYTHONDONTWRITEBYTECODE=1 and PYTHONUNBUFFERED=1 set
• • Image tagged with semantic version
• • Image pushed successfully to Docker Hub
• • Image size < 200MB (for typical Python apps)
• • No secrets or credentials in image layers
• • CI/CD pipeline configured (if requested)

Reference Files