Can I convert docker run to docker compose automatically?

Yes. Paste your docker run command into the Docker Run to Compose Converter and it generates a valid docker-compose.yml for you. It handles ports, environment variables, volumes, networks, and restart policies.

Do I need to install Docker Compose separately?

If you installed Docker Desktop, Compose is already included. On Linux with Docker Engine, install it with sudo apt install docker-compose-plugin (or the equivalent for your distro). Use docker compose version to verify.

What is the difference between docker-compose and docker compose?

docker-compose (with a hyphen) is the older standalone Python tool (v1). docker compose (with a space) is the newer Go plugin integrated directly into the Docker CLI (v2). The v2 plugin is current — use it.

Can docker-compose.yml handle multiple containers?

Yes — that's its main purpose. Define each container as a separate service under the services: key. Compose starts all of them with a single docker compose up and handles networking between them automatically.

Don't like ads? Go Ad-Free Today 

Stop Writing docker run Commands — Use Docker Compose Instead

Published on Apr 23, 2026

Most docker run commands turn into unmaintainable flag-soup. This guide shows how to convert docker run to docker compose — with a flag reference table, a real conversion example, and a free converter tool.

Stop Writing docker run Commands — Use Docker Compose Instead 1

ADVERTISEMENT · REMOVE?

Every Docker workflow starts the same way: docker run. One flag, two flags — manageable. But by the time you’re running a container with ports, environment variables, volumes, a restart policy, and a custom network, that command is 400 characters of something nobody can remember, version-control, or hand off to a teammate without a Slack thread full of shame.

Docker Compose is the fix. One YAML file replaces the whole command — and you commit it to git.

Why docker run Stops Scaling

Here’s a typical docker run command for a Node.js app:

docker run -d \
  --name my-app \
  -p 3000:3000 \
  -e NODE_ENV=production \
  -e DATABASE_URL=postgres://user:pass@db:5432/mydb \
  -v ./data:/app/data \
  --network app-network \
  --restart always \
  my-app:latest

That works. Once. Then you close the terminal, open a new one three weeks later, and have no idea what flags you used. There’s nothing to git diff. Nothing to share with a new hire. No way to verify that staging matches production.

What Docker Compose Gives You

Docker Compose takes everything stuffed into that docker run command and puts it in a YAML file called docker-compose.yml. That file:

Lives in your repo next to your code
Runs with a single docker compose up -d
Runs identically on every machine and environment
Scales to multi-service setups (app + database + cache) without flag gymnastics

How to Convert a docker run Command

That same command above becomes this docker-compose.yml:

version: "3.9"
services:
  my-app:
    image: my-app:latest
    container_name: my-app
    ports:
      - "3000:3000"
    environment:
      NODE_ENV: production
      DATABASE_URL: postgres://user:pass@db:5432/mydb
    volumes:
      - ./data:/app/data
    networks:
      - app-network
    restart: always

networks:
  app-network:

Same behavior. But now it’s readable, committed, and reproducible.

Start it:

docker compose up -d

Stop it:

docker compose down

docker run Flags to docker-compose.yml Keys

A reference for the flags you’ll hit most often:

docker run flag	docker-compose.yml key	Example
`-p 8080:80`	`ports:`	`- "8080:80"`
`-e FOO=bar`	`environment:`	`FOO: bar`
`-v ./data:/data`	`volumes:`	`- ./data:/data`
`--network mynet`	`networks:`	`mynet`
`--restart always`	`restart:`	`always`
`--name mycontainer`	`container_name:`	`mycontainer`
`--memory 512m`	`mem_limit:`	`512m`
`--cpus 1.5`	`deploy.resources.limits.cpus`	`cpus: "1.5"`
`-d`	Use `-d` flag at runtime	`docker compose up -d`

Convert Automatically

If you have a long existing docker run command — especially one inherited from a README or a CI script nobody has touched in two years — you don’t need to map every flag manually. Use the Docker Run to Compose Converter: paste the command in, get a valid docker-compose.yml out.

It handles ports, environment variables, volumes, networks, restart policies, and more. Useful for migrating legacy one-liners without introducing typos during the translation.

If you’re configuring resource limits in your Compose file, the Docker Container Resource Calculator helps you pick sensible memory and CPU values based on your workload — before you commit numbers you pulled from thin air.

Lint Your Dockerfile While You’re at It

Once your Compose file is sorted, check the Dockerfile it builds from. Unpinned base images, missing WORKDIR, redundant RUN layers — these are easy to miss and annoying to debug later. The Dockerfile Linter catches them before they become production problems.