Containerize Application Instant

Instantly generate production-ready Docker configurations for any application stack.

When to Use This Command

Run this command when you need to:

• Containerize an existing application that has no Docker configuration yet
• Generate optimized multi-stage Dockerfiles for production deployment
• Create a complete container setup including docker-compose and .dockerignore files

Consider alternatives when:

• Your application already has a well-tuned Dockerfile and you only need minor edits
• You need full Kubernetes orchestration rather than standalone containers

Quick Start

Configuration

Copy
name: containerize-application-instant
type: command
category: deployment

Example Invocation

Copy
claude command:run containerize-application-instant --runtime node --port 3000

Example Output

Detected runtime: Node.js 20 (package.json)
Detected entrypoint: npm start
Dependencies: 847 packages (production: 312)
Port bindings: 3000

Generated files:
  [+] Dockerfile (multi-stage, 3 layers)
  [+] .dockerignore (42 exclusion rules)
  [+] docker-compose.yml (app + redis + postgres)

Image size estimate: ~148MB (alpine base)
Security: non-root user, no secrets in layers
Build command: docker build -t myapp:latest .

Core Concepts

Runtime Detection Overview

Aspect	Details
Supported Runtimes	Node.js, Python, Go, Java, Ruby, Rust, .NET
Detection Method	Scans package.json, requirements.txt, go.mod, pom.xml, Gemfile
Base Image Strategy	Selects minimal base (alpine, distroless, slim) per runtime
Build Stages	Multi-stage builds to separate build deps from runtime
Port Discovery	Parses source for listen/bind calls and environment variables

Containerization Workflow

  Source Code Analysis
        |
        v
  +------------------+
  | Detect Runtime   |---> package.json / go.mod / etc.
  +------------------+
        |
        v
  +------------------+
  | Choose Base Image|---> Alpine / Distroless / Slim
  +------------------+
        |
        v
  +------------------+
  | Generate Stages  |---> Build stage -> Runtime stage
  +------------------+
        |
        v
  +------------------+
  | Security Harden  |---> Non-root user, minimal perms
  +------------------+
        |
        v
  +------------------+
  | Output Files     |---> Dockerfile + compose + ignore
  +------------------+

Configuration

Parameter	Type	Default	Description
runtime	string	auto-detect	Force a specific runtime (node, python, go, java)
port	integer	auto-detect	Application port to expose in the container
base_image	string	alpine	Base image variant: alpine, distroless, slim, or full
compose	boolean	true	Whether to generate a docker-compose.yml file
registry	string	none	Container registry prefix for image tagging

Best Practices

1. Use Multi-Stage Builds - Separate compilation and dependency installation from the final runtime image. This reduces image size by excluding build tools and dev dependencies from production.

2. Leverage Layer Caching - Copy dependency manifests (package.json, requirements.txt) before copying application source. This ensures dependency layers are cached and rebuilt only when manifests change.

3. Run as Non-Root - Always create and switch to a dedicated application user inside the container. Running as root exposes unnecessary privileges and fails many security scanners.

4. Keep .dockerignore Comprehensive - Exclude node_modules, .git, test directories, documentation, and local environment files. A thorough ignore file prevents secrets from leaking into image layers.

5. Pin Base Image Versions - Use specific image tags like node:20.11-alpine rather than node:latest. Pinning prevents unexpected breakage when upstream images update.

Common Issues

1. Build Fails on Native Dependencies - Some packages require system libraries (e.g., sharp needs libvips). Add the necessary apk or apt packages in the build stage before running the package install step.

2. Container Exits Immediately - The entrypoint process is backgrounding or exiting. Ensure the CMD runs the process in the foreground (e.g., use node server.js, not npm start with a background script).

3. Image Size Too Large - You may be copying build artifacts or dev dependencies into the final stage. Verify the multi-stage COPY only transfers production files from the build stage.