CODEWITHSUNDEEP
docker
MarkL
MarkL

Reputation: 9100

How do you attach and detach from Docker's process?

I can attach to a docker process but Ctrl+C doesn't work to detach from it. exit basically halts the process.

What's the recommended workflow to have the process running, occasionally attaching to it to make some changes, and then detaching?

Upvotes: 577

Views: 510027

Answers (18)

Nich Overend
Nich Overend

Reputation: 852

I think @CenterOrbit's answer is spot on, except you get all the history from the logs, which can be a lot to go through if the container's been running for a bit.

Add --tail to it though, and you can specify how much history you want to see, and then continue to read in real-time, or --since to get logs since a particular date, or even both to get either xxx lines, or since a date/time whichever is the more restrictive.

docker logs --follow --tail 500 containerid
docker logs --follow --since 2023-06-14T05:00:00 containerid
docker logs --follow --since 2023-06-14T05:00:00 --tail 500 containerid

Upvotes: 0

ravthiru
ravthiru

Reputation: 9633

In the same shell, hold Ctrl key and press keys P then Q

Upvotes: 6

Lon Kaut
Lon Kaut

Reputation: 2646

For anyone who ran into the same problem I did (can't detach without killing the container, even when setting the detach key)......

When starting your containers with docker-compose up -d

instead of using docker attach {container name} to view the tailing log ....

try docker-compose logs -f {service name} Ctrl+C kills the log tail without killing your container

{service name} being the service listed in side of your docker-compose.yml file.. (e.g. while container name=elk_logstash_1 -> service name=logstash

Upvotes: 4

Pierluigi Vernetto
Pierluigi Vernetto

Reputation: 2050

I had the same issue, Ctrl+P and Q would not work, nor Ctrl+C ... eventually I opened another terminal session and I did "docker stop containerid " and "docker start containerid " and it got the job done. Weird.

Upvotes: 9

Nan Xiao
Nan Xiao

Reputation: 17467

I think this should depend on the situation.Take the following container as an example:

# docker run -it -d ubuntu
91262536f7c9a3060641448120bda7af5ca812b0beb8f3c9fe72811a61db07fc
# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
91262536f7c9        ubuntu              "/bin/bash"         5 seconds ago       Up 4 seconds                            serene_goldstine

(1) Use "docker attach" to attach the container:

Since "docker attach" will not allocate a new tty, but reuse the original running tty, so if you run exit command, it will cause the running container exit:

# docker attach 91262536f7c9
exit
exit
# docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS               NAMES
91262536f7c9        ubuntu              "/bin/bash"         39 minutes ago      Exited (0) 3 seconds ago                       serene_goldstine

So unless you really want to make running container exit, you should use Ctrl+P + Ctrl+Q.

(2) Use "docker exec"

Since "docker exec" will allocate a new tty, so I think you should use exit instead of Ctrl+P + Ctrl+Q.

The following is executing Ctrl+P + Ctrl+Q to quit the container:

# docker exec -it 91262536f7c9 bash
root@91262536f7c9:/# ps -aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0  18160  1908 ?        Ss+  04:03   0:00 /bin/bash
root        15  0.0  0.0  18164  1892 ?        Ss   04:03   0:00 bash
root        28  0.0  0.0  15564  1148 ?        R+   04:03   0:00 ps -aux
root@91262536f7c9:/# echo $$
15

Then login container again, you will see the bash process in preavious docker exec command is still alive (PID is 15):

# docker exec -it 91262536f7c9 bash
root@91262536f7c9:/# ps -aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0  18160  1908 ?        Ss+  04:03   0:00 /bin/bash
root        15  0.0  0.0  18164  1892 ?        Ss+  04:03   0:00 bash
root        29  0.0  0.0  18164  1888 ?        Ss   04:04   0:00 bash
root        42  0.0  0.0  15564  1148 ?        R+   04:04   0:00 ps -aux
root@91262536f7c9:/# echo $$
29

Upvotes: 55

czerasz
czerasz

Reputation: 14250

Check out also the --sig-proxy option:

docker attach --sig-proxy=false 304f5db405ec

Then use Ctrl+C to detach

Upvotes: 216

Zaiban Ali
Zaiban Ali

Reputation: 21

If --sig-proxy=false method doesn't work then you can also change the escape sequence using:

docker attach --detach-keys="<sequence>" <container_name or id>

For example, I want to detach the container using "ctrl-c" then I can attach the container using:

docker attach --detach-keys="ctrl-c" <container_name or id>

The format of the is either a letter [a-Z], or the ctrl- combined with any of the following:

  • a-z (a single lowercase alpha character )
  • @ (at sign)
  • [ (left bracket)
  • \ (two backward slashes)
  • _ (underscore)
  • ^ (caret)

For more information also see -> Override the detach sequence

Upvotes: 2

Maxim Suslov
Maxim Suslov

Reputation: 5465

I found the documentation regarding attaching and detaching a little complicated.

I tried different options to start a container and attach to it from another terminal. The following table summarizes the results:

attachment behavior

It has the following column meaning:

  • -d - is the option docker run -d used or not
  • --sig-proxy - is the option docker attach --sig-proxy=true|false used to not
  • --no-stdin - is the option docker attach [--no-stdin] used to not
  • keys - whether docker send input keys to containerized application or not
  • ^C - what happened when user press Ctrl+C
  • ^P ^Q - what happened when user press Ctrl+P Ctrl+Q

There is a few findings:

  • attachment behavior doesn't depend on -d option but from -i and -t

  • you can consider attach columns either a connection to a container from another terminal (e.g. docker attach --sig-proxy=false and you may vary connection options) or from the current terminal (but you can't vary connection options; --sig-proxy=true)

  • detachment depends on running options and can be done in three ways:

    1. docker run [-i|-t] and connect from another terminal by docker attach --sig-proxy=false CONT -> press Ctrl+C
    2. docker run -it and connect from another terminal by docker attach -> press Ctrl+P Ctrl+Q
    3. docker run -it and connect from another terminal by docker attach --no-stdin -> press Ctrl+C

(of course, you should provide other necessary arguments for commands like a container name or an image)

P.S. I tried different scenarios with -i and -t (only one of them) but didn't get the difference in behavior. I saw that @ken-cochrane provides the following:

docker run -i → cannot be detached with ^P^Q; will disrupt stdin

but I'm not succeeded to reproduce this.

Upvotes: 2

Zenexer
Zenexer

Reputation: 19613

To detach from a running container, use ^P^Q (hold Ctrl, press P, press Q, release Ctrl).

There's a catch: this only works if the container was started with both -t and -i.

If you have a running container that was started without one (or both) of these options, and you attach with docker attach, you'll need to find another way to detach. Depending on the options you chose and the program that's running, ^C may work, or it may kill the whole container. You'll have to experiment.

Another catch: Depending on the programs you're using, your terminal, shell, SSH client, or multiplexer could be intercepting either ^P or ^Q (usually the latter). To test whether this is the issue, try running or attaching with the --detach-keys z argument. You should now be able to detach by pressing z, without any modifiers. If this works, another program is interfering. The easiest way to work around this is to set your own detach sequence using the --detach-keys argument. (For example, to exit with ^K, use --detach-keys 'ctrl-k'.) Alternatively, you can attempt to disable interception of the keys in your terminal or other interfering program. For example, stty start '' or stty start undef may prevent the terminal from intercepting ^Q on some POSIX systems, though I haven't found this to be helpful.

Upvotes: 61

CenterOrbit
CenterOrbit

Reputation: 6861

Update

I typically used docker attach to see what STDOUT was displaying, for troubleshooting containers. I just found docker logs --follow 621a4334f97b, which lets me see the STDOUT whilst also being able to ctrl+c off of it without affecting container operation! Exactly what I've always wanted.

... naturally you'll need to substitue in your own container ID.

Original Answer

I wanted to leave the container running, but had attached without starting the container with -it. My solution was to sacrifice my SSH connection instead (since I was SSHed into the machine that was running the containers). Killing that ssh session left the container intact but detached me from it.

Upvotes: 9

Ken Cochrane
Ken Cochrane

Reputation: 77335

To detach the tty without exiting the shell, use the escape sequence Ctrl+P followed by Ctrl+Q. More details here.

Additional info from this source:

  • docker run -t -i → can be detached with ^P^Qand reattached with docker attach
  • docker run -i → cannot be detached with ^P^Q; will disrupt stdin
  • docker run → cannot be detached with ^P^Q; can SIGKILL client; can reattach with docker attach

Upvotes: 826

Colin Su
Colin Su

Reputation: 4609

If you just want to make some modification to files or inspect processes, here's one another solution you probably want.

You could run the following command to execute a new process from the existing container:

sudo docker exec -ti [CONTAINER-ID] bash

will start a new process with bash shell, and you could escape from it by Ctrl+C directly, it won't affect the original process.

Upvotes: 114

Tom
Tom

Reputation: 1510

If you only need the docker process to go in the background you can use

Ctrl + Z

Be aware that it is not a real detach and it comes with a performance penalty. (You can return it to foreground with the bg command).

Another option is to just close your terminal, if you don't need it any longer.

Upvotes: -2

shankar
shankar

Reputation: 1

to stop a docker process and release the ports, first use ctrl-c to leave the exit the container then use docker ps to find the list of running containers. Then you can use the docker container stop to stop that process and release its ports. The container name you can find from the docker ps command which gives the name in the name column. Hope this solves your queries....

Upvotes: 0

Vyacheslav Cotruta
Vyacheslav Cotruta

Reputation: 772

  1. Open a new terminal
  2. Find the running container Id docker ps
  3. Kill the container docker kill ${containerId}

Upvotes: 1

Jared Williams
Jared Williams

Reputation: 19

I'm on a Mac, and for some reason, Ctrl-p Ctrl-q would only work if I also held Shift

Upvotes: 1

gXg
gXg

Reputation: 528

To detach from the container you simply hold Ctrl and press P + Q.

To attach to a running container you use:

$ docker container attach "container_name"

Upvotes: 12

Adi Fatol
Adi Fatol

Reputation: 964

when nothing else works, open a new terminal then:

$ ps aux | grep attach
username  <pid_here>    ..............  0:00 docker attach <CONTAINER_HASH_HERE>
username  <another_pid> ..............  0:00 grep --color=auto attach
$ kill -9 <pid_here>

Upvotes: 36

Related Questions