Docker Compose keep container running

You can use tty configuration option.

version: '3'

services:
  app:
    image: node:8
    tty: true           # <-- This option

Note: If you use Dockerfile for image and CMD in Dockerfile, this option won't work; however, you can use the entrypoint option in the compose file which clears the CMD from the Dockerfile.

Based on the comment of @aanand on GitHub Aug 26, 2015, one could use tail -f /dev/null in docker-compose to keep the container running.

docker-compose.yml example

version: '3'
services:
  some-app:
    command: tail -f /dev/null

Why this command?

The only reason for choosing this option was that it received a lot of thumbs up on GitHub, but the highest voted answer does not mean that it is the best answer. The second reason was a pragmatic one as issues had to be solved as soon as possible due to deadlines.

• Create a file called docker-compose.yml
• Add the following to the file

version: "3"

services:
  ubuntu:
    image: ubuntu:latest
    tty: true

• Staying in the same directory, run docker-compose up -d from the terminal
• Run docker ps to get the container id or name
• You can run docker inspect $container_id
• You can enter the container and get a bash shell running docker-compose exec ubuntu /bin/bash or docker-compose exec ubuntu /bin/sh
• When done, make sure you are outside the container and run docker-compose down

Here's a small bash script (my-docker-shell.sh) to create the docker compose file, run the container, login to the container and then finally cleanup the docker container and the docker compose file when you log out.

#!/bin/bash

cat << 'EOF' > ./docker-compose.yml
---

version: "3"

services:
  ubuntu:
    image: ubuntu:latest
    command: /bin/bash
    # tty: true

...
EOF

printf "Now entering the container...\n"
docker-compose run ubuntu bash
docker-compose down

rm -v ./docker-compose.yml

I'm late to the party, but you can simply use: stdin_open: true

version: '2'
services:
  my-test:
    image: ubuntu
    stdin_open: true

Some people here write about overwriting the entrypoint so that the command can also have its effect. But no one gives an example. I then:

docker-compose.yml:

version: '3'

services:

    etfwebapp:
        # For messed up volumes and `sudo docker cp`:
        command: "-f /dev/null"
        entrypoint: /usr/bin/tail
        tty: true

# ...

I am not sure if tty is needed at this point. Is it better to do it twice? In my case it did no harm and worked perfectly. Without entrypoint it didn't work for me because then command had no effect. So I guess for this solution tty is optional.

To understand which command is executed at start-up, simply read the entrypoint before the command (concat with space): /usr/bin/tail -f /dev/null.

In the Dockerfile you can use the command:

{CMD sleep infinity}

Blocking command is all you need.

I have been struggling with this problem for half a day. . There are many answers below, but not clear enough. And nobody said why.

In short, there are two methods, but it can also be said that there is only one, running a Blocking processes in background.

This first one is using COMMAND:

version: '3'
services:
  some-app:
    command: ["some block command"]

put some block command like sleep infinity, tail -f /dev/null, watch anything, while true ...

Here I recommend sleep infinity.

The second is enable tty=true, then open a shell in command like /bin/bash.

services:
  ubuntu:
    image: ubuntu:latest
    tty: true
    command: "/bin/bash"

Since the tty is enabled, bash will keep running background, you can put some other block commands before it if you want.

Be careful, you must excute shell command at the end, like

command: /bin/bash -c "/root/.init-service && /bin/bash"

As you can see, all you need is blocking command.

Just a quick note

I have tested single image based on golang, so when I call docker-compose down here what I get:

version: "3.1"
...
command: tail -f /dev/null   # stopping container takes about 10 sec.
tty: true                    # stopping container takes about 2 sec.

My system info:

Ubuntu 18.04.4 LTS (64-bit)
Docker version 19.03.6, build 369ce74a3c
docker-compose version 1.26.0, build d4451659

As the commenter stated, we'd have to see the Dockerfile in question to give you a complete answer, but this is a very common mistake. I can pretty much guarantee that the command you're trying to run is starting a background process. This might be the command you'd run in non-Docker situations, but it's the wrong thing to do in a Dockerfile. For instance, if what you're running is typically defined as a system service, you might use something like "systemctl start". That would start the process in the background, which will not work. You have to run the process in the foreground, so the entire process will block.

Add entrypoint to docker-compose file

entrypoint: ["tail", "-f", "/dev/null"]

This was the only way I could get it to work without using something like tail -f /dev/null. I read many of the answers here saying that adding init to the compose file should be enough and confirmed the same in Docker's documentation but I could not get it to work with init alone.

# compose.yml
services:
  my-test:
    build:
      context: .
      dockerfile: dockerfile
    tty: true
    init: true

# dockerfile
FROM node:20-alpine
RUN apk add --no-cache  --update bash

CMD ["/bin/sh"]

If you want a quick docker run option, in a tiny busybox image, as a one-liner:

docker run --rm --name forever busybox sh -c 'trap : TERM INT; tail -f /dev/null & wait'

If you want to exec into that container:

docker exec -it forever sh

You can stop it with CTRL + Z and it will stop gracefully and without delay.

If you prefer a docker-compose.yml file:

services:
  forever:
    image: busybox
    command: 'sh -c "trap : TERM INT; tail -f /dev/null & wait"'

Based on this.

I have used some of the solutions above which works for ubuntu or nodejs images. However they don't work with the bitnami/azure-cli image. Whatever specified in command becomes argument(s) for the az command of that image. After a bit of struggling, this is how the docker-compose.yml file should be:

version: "2.4"
services:
  azure-cli:
    image: "bitnami/azure-cli:latest"
    container_name: az-container
    entrypoint: tail -f /dev/null

As @highjump points out above, this entrypoint option overrides the internal command option, and keeps the container running.