Deploy Any Language to Docker Without Writing a Dockerfile

Stop writing Dockerfiles. migetpacks auto-detects your language, reads version files, installs dependencies with proper caching, and produces optimized production images. 14 languages, one command, zero configuration.

---

The Universal Command

Open your terminal, navigate to any project in a supported language, and run:

cd ~/projects/my-app

docker run --rm \
  -v "$PWD":/workspace/source \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -e OUTPUT_IMAGE=my-app:latest \
  miget/migetpacks:latest

That's it. migetpacks detects your language and builds an optimized container image.

Supported Languages

Language	Detection Files	Guide
Node.js	package.json, package-lock.json, yarn.lock, pnpm-lock.yaml	Deploy Node.js →
Python	requirements.txt, pyproject.toml, Pipfile, uv.lock	Deploy Python →
Go	go.mod	Deploy Go →
Rust	Cargo.toml, Cargo.lock	Deploy Rust →
Java	pom.xml, build.gradle	Deploy Java →
Ruby	Gemfile, config.ru	Deploy Ruby →
PHP	composer.json, index.php	Deploy PHP →
.NET	*.csproj, *.sln, global.json	Deploy .NET →
Kotlin	build.gradle.kts, *.kt files	Deploy Kotlin →
Scala	build.sbt, project/	Deploy Scala →
Clojure	project.clj, deps.edn	Deploy Clojure →
Elixir	mix.exs, mix.lock	Deploy Elixir →
Deno	deno.json, deno.lock	Deploy Deno →
Bun	bun.lock, bunfig.toml	Deploy Bun →

What migetpacks Does Automatically

For every language, migetpacks handles:

Version Detection

Reads .nvmrc, .python-version, .ruby-version, go.mod, rust-toolchain.toml, and more. No manual configuration.

Dependency Caching

Installs dependencies in a separate Docker layer. Rebuilds only run npm install / pip install / bundle install when lockfiles change.

Multi-Stage Builds

Separates build tools from runtime. Your production image doesn't include compilers, dev dependencies, or build artifacts.

Framework Detection

Automatically handles Rails asset precompilation, Django collectstatic, Next.js builds, Phoenix assets, Spring Boot JARs, and more.

Security Best Practices

Non-root users, minimal base images, production environment variables, and optional distroless DHI images.

Real Examples

Deploy a Django App

cd ~/projects/my-django-app

docker run --rm \
  -v "$PWD":/workspace/source \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -e OUTPUT_IMAGE=my-django:latest \
  miget/migetpacks:latest

# Run it
docker run -p 8000:8000 \
  -e DATABASE_URL=postgres://... \
  my-django:latest

Deploy a Go API

cd ~/projects/my-go-api

docker run --rm \
  -v "$PWD":/workspace/source \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -e OUTPUT_IMAGE=my-go-api:latest \
  miget/migetpacks:latest

# Run it
docker run -p 8080:8080 my-go-api:latest

Deploy a Rails App

cd ~/projects/my-rails-app

docker run --rm \
  -v "$PWD":/workspace/source \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -e OUTPUT_IMAGE=my-rails:latest \
  miget/migetpacks:latest

# Run it
docker run -p 3000:3000 \
  -e RAILS_MASTER_KEY=... \
  -e DATABASE_URL=postgres://... \
  my-rails:latest

What About Existing Dockerfiles?

If your project has a Dockerfile, migetpacks uses it. No magic, no surprises. migetpacks only generates a Dockerfile when one doesn't exist.

Why Not Just Write a Dockerfile?

A production-ready Dockerfile for any language requires:

• Multi-stage builds (build vs runtime separation)
• Proper layer ordering (dependencies before source code)
• Security hardening (non-root users, minimal images)
• Framework-specific handling (asset compilation, static files)
• Version management (reading from project files)
• Caching strategy (BuildKit, registry caching)

That's 50-100 lines of YAML-like syntax you need to maintain for each project. migetpacks handles it automatically.

How Is This Different from Paketo Buildpacks?

Feature	migetpacks	Paketo
Configuration	Zero-config	Requires project.toml
Image size	Slim bases	Larger (Ubuntu-based)
Build speed	Fast (BuildKit)	Slower
Dockerfile fallback	Yes	No
Languages	14	10+
DHI/Distroless	Yes	No

Getting Started

1. Pick any project in a supported language
2. Run the command shown above
3. Get a production image in seconds

No installation. No configuration files. No learning curve.

Next Steps

• Full documentation - all options, caching, CI/CD
• GitHub Actions guide - CI/CD integration
• Docker Hardened Images - distroless builds
• Deploy on Miget - unlimited apps, one price