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:

references/

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

scripts/build-and-push.sh

bash scripts/build-and-push.sh USERNAME APP_NAME VERSION

scripts/validate-dockerfile.sh

bash scripts/validate-dockerfile.sh [path/to/Dockerfile]

scripts/setup-multiplatform.sh

bash scripts/setup-multiplatform.sh

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

docker login

DOCKER_BUILDKIT=1

docker buildx build

scripts/setup-multiplatform.sh

See

references/troubleshooting.md

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

references/multi-stage-builds.md

references/docker-hub-deployment.md

references/ci-cd-github-actions.md

references/claude-integration.md

references/troubleshooting.md

documentation/docker_hub_stages.md

documentation/docker_hub_python_project_partner.md