How to Connect to a Docker Container

Connecting to a running Docker container is helpful when you want to see what is happening inside the container. If the Docker container does not work as expected, you can attach to the container or get a shell to the container and run commands such as ps or top. You can also enter the container to inspect files, troubleshoot services, or test commands before updating your Dockerfile .

This tutorial explains how to attach to the container’s main running process and how to get a shell to a running container.

Quick Reference #

For a printable quick reference, see the Docker cheatsheet .

Get a Shell to a Container #

The most common way to connect to a Docker container is to open an interactive shell inside it. The docker exec command allows you to run commands inside a running container.

To get a Bash shell inside a running container, use the -it flags with docker exec:

docker exec -it my_container /bin/bash

The -i option stands for interactive, and -t tells Docker to allocate a pseudo TTY device. Your command prompt will change, indicating that you are now working on the container shell.

If the container does not have Bash installed, use sh instead:

docker exec -it my_container /bin/sh

From here, you can run commands in the same way as you would do on any other Linux server. For example, to see the current environment variables , type env:

env

When you are done, type exit to leave the container shell and return to your host terminal.

Log in to a container #

You will often see this described as logging in to or entering a container. Docker has no separate command for either one. Each phrase means the same thing in practice: start a shell inside the container with docker exec -it. Do not confuse it with docker login, which authenticates you against an image registry such as Docker Hub and has nothing to do with running containers.

If the image runs as a non-root user and you need administrative access inside the container, add the -u flag:

docker exec -it -u root my_container /bin/bash

You can also start the shell in a specific directory with -w, which saves you a cd after connecting:

docker exec -it -w /var/log my_container /bin/bash

Run a single command #

You do not need to open an interactive shell to run a single command. Pass the command directly after the container name:

docker exec my_container ls /var

backups  cache  lib  local  lock  log  mail  opt  run  spool  tmp

Attach to a Container #

Although it is possible to run multiple processes in a container, most Docker containers run only a single process. The command that is executed when starting a container is specified using the ENTRYPOINT and/or CMD instruction.

The docker attach command allows you to attach your terminal to the running container. This is useful when you want to see what is written in the standard output in real time, or to control the process interactively.

To better understand how the attach command works, let us run a new detached Nginx container using the official Nginx image:

docker container run --name my_nginx -d -p 8080:80 nginx

The -p 8080:80 option tells Docker to map port 80 in the container to port 8080 on the host machine.

List the containers to make sure the “my_nginx” container is running:

docker container ls

CONTAINER ID   IMAGE   COMMAND                  CREATED          STATUS          PORTS                  NAMES
8e1c4974a8d8   nginx   "/docker-entrypoint.…"   3 minutes ago    Up 3 minutes    0.0.0.0:8080->80/tcp   my_nginx

Attach to the container using the container’s ID or name:

docker container attach my_nginx

The default command of the Nginx image is set to CMD ["nginx", "-g", "daemon off;"]. When you run the attach command, your terminal attaches to the nginx process.

Open 127.0.0.1:8080 in your browser and you can watch the output of the Nginx process in real time.

By default, docker attach forwards signals to the container process, so pressing Ctrl-c sends a SIGINT and stops the container. The Ctrl-p Ctrl-q escape sequence detaches without stopping, but it works only when the container was started with both -i and -t. The “my_nginx” container above was started with -d alone, so that sequence has no effect on it.

For containers without an interactive TTY, attach with --sig-proxy=false instead. Signals are no longer forwarded to the process, and Ctrl-c detaches your terminal while the container keeps running:

docker container attach --sig-proxy=false my_nginx

If the running process you are attaching to accepts input, you can send instructions to it.

View Container Logs #

To view the output of a container without attaching to it, use the docker logs command:

docker logs my_nginx

To follow the logs in real time, similar to tail -f, add the -f flag:

docker logs -f my_nginx

To see only the last 50 lines, use --tail:

docker logs --tail 50 my_nginx

The docker logs command is the preferred way to inspect container output, as it does not interfere with the running process.

Connect via Docker Compose #

If you manage containers with Docker Compose , use docker compose exec to get a shell to a running service:

docker compose exec my_service /bin/bash

This works the same way as docker exec but uses the service name defined in your docker-compose.yml file instead of the container name.

Troubleshooting #

“OCI runtime exec failed: exec failed: unable to start container process”
This error usually means the shell you requested does not exist in the container image. Try /bin/sh instead of /bin/bash. Minimal images like Alpine use sh by default.

The image contains no shell at all
Images built from scratch and distroless base images ship with neither /bin/bash nor /bin/sh, so no docker exec shell will ever start. Debug those containers from the outside instead, by starting a second container that shares the process and network namespaces of the target:

docker run -it --pid container:my_container --network container:my_container nicolaka/netshoot

The second container brings its own shell and troubleshooting tools, and it can see the processes and network interfaces of “my_container” without any change to the original image. Docker Desktop users can also run docker debug my_container, which attaches a shell to a container even when the image contains none.

“Error response from daemon: container is not running”
You can only exec or attach to a running container. Start the container first with docker start <container>, then try again.

Container stops when you press Ctrl-c during attach
Ctrl-c sends a SIGINT to the main process, which usually stops the container. To detach without stopping, use the Ctrl-p Ctrl-q sequence instead.

FAQ #

What is the difference between docker exec and docker attach?
docker exec starts a new process inside the container, such as a shell or a command. docker attach connects your terminal to the container’s existing main process. Use exec when you want to run additional commands and attach when you want to see or interact with the main process output.

Can I connect to a stopped container?
No. Both docker exec and docker attach require the container to be running. Start the container first with docker start <container>, then connect to it.

How do I run a command in the background inside a container?
Use the -d (detached) flag with docker exec: docker exec -d my_container command. The command runs inside the container without attaching your terminal.

Conclusion #

The docker exec and docker attach commands allow you to connect to a running container. Use docker exec -it <container> /bin/bash to get an interactive shell, and docker attach to connect to the main process. For Compose-based setups , use docker compose exec instead. To learn how containers reach each other across networks, see the Docker networking guide .

About the authors

Dejan Panovski

Dejan Panovski is the founder of Linuxize, an RHCSA-certified Linux system administrator and DevOps engineer based in Skopje, Macedonia. Author of 800+ Linux tutorials with 20+ years of experience turning complex Linux tasks into clear, reliable guides.

View author page