Run Multiple Commands in Docker Compose (4 Methods + Examples & Best Practices)

Docker Compose allows you to run multiple commands inside containers, but choosing the right method depends on your use case—whether it’s sequential execution, parallel tasks, or complex workflows. Using the correct approach helps avoid failures, improves maintainability, and ensures predictable container behavior. In this guide, you’ll learn practical ways to run multiple commands efficiently with real-world scenarios.

Quick cheat sheet: Docker Compose multiple commands

Quick decision guide:

• Use && → when commands depend on each other
• Use multiline (|) → when you want readability
• Use exec → when container is already running
• Use scripts → when logic becomes complex
• Use Supervisor → when running multiple services in one container

Method 1: Run multiple commands sequentially using &&

How && controls execution flow

The && operator allows you to run multiple commands sequentially, ensuring that each command executes only if the previous one succeeds. This is useful when commands are dependent on each other.

Example:

command: sh -c "npm install && npm run build && npm start"

In this case:

• npm install must succeed before npm run build runs
• npm run build must succeed before npm start runs

If any command fails, the remaining commands are skipped, which helps prevent inconsistent application states.

When to allow failure and continue execution

Sometimes you may want all commands to run even if one fails. In such cases, you can modify the behavior:

command: sh -c "command1 && command2 ; command3"

Or force success using:

command: sh -c "command1 && command2 ; exit 0"

Use this approach carefully, as it may hide failures and make debugging harder.

Method 2: Run multiple commands using multiline (|) syntax

Writing clean multi-line commands in docker-compose.yml

For better readability, especially when commands become long, you can use YAML multiline syntax:

command:
  - /bin/sh
  - -c
  - |
    echo "Installing dependencies"
    npm install
    echo "Starting application"
    npm start

This keeps your configuration clean and easier to maintain compared to long single-line commands.

Although commands are written on separate lines, they are executed sequentially inside the container. Unlike &&, this approach does not automatically stop execution on failure unless explicitly handled.

Output is displayed line by line, making it easier to debug multi-step workflows.

Method 3: Use shell scripts for complex workflows

When scripts are better than inline commands

When your workflow involves multiple steps, conditional logic, or loops, shell scripts are a better choice than inline commands.

Example:

command: /app/start.sh

Example script:

#!/bin/sh
echo "Running migrations"
npm run migrate

echo "Starting application"
npm start

Scripts improve readability, reusability, and make debugging easier.

Managing environment variables and arguments

Shell scripts make it easier to work with environment variables and pass arguments:

#!/bin/sh
echo "Environment: $ENV"
npm run build -- --env=$ENV
npm start

You can define variables in docker-compose.yml:

environment:
  - ENV=production

This approach provides flexibility and is ideal for production-grade workflows.

Method 4: Manage multiple processes using Supervisor

Running multiple services inside one container

Supervisor is a process manager that allows you to run and manage multiple processes inside a single container. This is useful when your application requires multiple long-running services such as a web server, worker, and scheduler.

Example setup:

# Dockerfile
FROM alpine
RUN apk add --no-cache supervisor
COPY supervisord.conf /etc/supervisord.conf
CMD ["supervisord", "-c", "/etc/supervisord.conf"]

Example Supervisor configuration:

[supervisord]
nodaemon=true

[program:web]
command=npm start

[program:worker]
command=npm run worker

This ensures both processes run simultaneously and are managed properly.

When Supervisor is required vs overkill

Use Supervisor when:

• You must run multiple long-running processes in one container
• Processes need automatic restart or monitoring
• You are handling tightly coupled services

Avoid Supervisor when:

• You can split services into separate containers (recommended Docker practice)
• You only need to run sequential commands
• Simpler methods like && or scripts are sufficient

Practical example: Running multiple commands in Docker Compose

Below is a real-world example where a Node.js application performs multiple steps before starting:

• Install dependencies
• Run database migrations
• Start the application

# docker-compose.yml
version: '3'
services:
  app:
    image: node:18
    working_dir: /usr/src/app
    volumes:
      - .:/usr/src/app
    ports:
      - "3000:3000"
    command: >
      sh -c "npm install &&
             npm run migrate &&
             npm run build &&
             npm start"

How this works

• npm install → installs dependencies
• npm run migrate → prepares database schema
• npm run build → builds application assets
• npm start → starts the application

👉 Each command runs sequentially using &&, ensuring the next step only runs if the previous one succeeds.

What happens if a command fails

If npm run migrate fails:

• npm run build and npm start will NOT execute
• Container exits immediately

This is the recommended behavior in production, as it prevents running a broken application.

If you want to debug issues before removing or restarting containers, you can:

• Check logs using docker logs -f tail
• Restart failed containers using docker restart container

Summary and recommended approach

• Use && for simple sequential execution
• Use multiline syntax (|) for readability
• Use scripts for complex workflows
• Use Supervisor only when managing multiple long-running processes
• Prefer single-purpose containers whenever possible

Choosing the right method depends on your use case, complexity, and environment. Start simple and move to advanced approaches only when required.

Official Documentation

• Docker Compose official documentation
• Docker Compose file reference guide
• docker-compose run command reference
• docker-compose exec command reference
• Supervisor process control system documentation