How to use docker exec to interact with running containers

Docker’s exec command lets you run shell commands directly inside your running containers without forcing you to restart them. It’s useful when you want to debug an error, adjust settings, or quickly peek into a container’s environment. This makes your development workflow smoother, saving you from unnecessary downtime.

Docker containers have changed how we deploy apps by making it possible to deploy across multiple architectures with a one-fits-all approach. With Docker, you can deploy anything, including CLI tools, across different environments without needing to worry about any differences in the underlying infrastructure.

When you run containers, you might need to interact with them to troubleshoot, run additional commands, or modify configurations in real-time. In this article, you’ll learn how to interact with running Docker containers with the exec command.

Getting started with docker exec

Before exploring the command, you’ll need a running container, so let’s get you started.
First, if you don’t already have Docker installed, you should download and set it up; you’ll need it to execute the commands.

Once you’re all set up, execute this command to run the Ubuntu container via the official image:

docker run -d --name my_ubuntu_container ubuntu sleep infinity

What’s going on here?

• d — Runs the container in the background (detached mode)
• --name my_ubuntu_container — Assigns the container a name for references
• ubuntu— Specifies the Ubuntu image (Docker will pull it if it’s unavailable locally)
• sleep infinity — Keeps the container running indefinitely:

You can verify the container is running with the ps command like this:

docker ps

The ps command lists all running containers. If the container runs, it should appear in the list with your assigned name:

Now that you’re set up with Docker and have a running container, you can interact with it using the exec command.

The Docker exec command

Docker ships with the exec command, which allows you to execute commands in running containers without restarting them. The exec command is useful when you want to start an interactive shell, inspect logs, modify files, or perform various other tasks.

The general syntax for the docker exec command is:

docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

Here are the options you can set with the exec command:

You’ll follow up the specified option with the command and arguments you’re executing in the container. Let’s execute a command to list all the files in the container’s directory:

docker exec my_ubuntu_container ls -l

The command should output the files and directories in long format like this:

In this case, I’ve used the container ID to reference the container; it works like using the container name. You can add the -it flag to run an interactive shell inside the container:

docker exec -it my_container /bin/bash

This command opens a Bash shell running in the container. Now, you can run commands directly without the exec command:

You can exit the interactive mode with the exit command that ships with the operating system.
By default, docker exec executes commands as the root user inside the container. You can specify a different user with the -u option.

First, you need to create a new user in the container’s OS. Execute this command to create a new user named paul:

docker exec my_ubuntu_container useradd -m paul

Now, you can specify the user before the commands to execute commands for a user:

docker exec -u paul my_ubuntu_container whoami

This command should output the username of the user like this:

You can pass environment variables and read existing environment variables with the -e option:

docker exec -e MY_VAR=Hello my_ubuntu_container printenv MY_VAR

Executing this command should output “Hello” since it’s the value for the MY_VAR environment variable. You’ll likely need to run commands in detached mode (in the background). That’s where the -d option is handy:

docker exec -d my_ubuntu_container touch /tmp/detached_file

This command creates an empty file inside the /tmp directory without keeping an interactive session open. You can also set a working directory with the -w option like this:

docker exec -w /var/log my_ubuntu_container ls

The command sets the working directory to /var/log first before listing all the files in the working directory. If you’re stuck in development, you can always use the --help flag to browse through all the options further:

Troubleshooting Docker exec errors

You may encounter some errors when using Docker’s exec command to interact with running containers. Let’s overview some of them and how you can fix them.

“No such container” error

You’ll need to make sure you’re referencing an existing container. Run docker ps to view all running containers, copy the reference and execute the command with the right reference.

Permission denied errors

You may experience this when you try executing a command as a non-root user without the neccessary privildges. You can either run the command as root, or use the --privileged flag for extra permissions.

“OCI runtime exec failed” error

In this case, the container probably isn’t running. Execute docker start <container name> to start the container if this is the case.

You can always visit the Docker Community Forum if you have different errors or none of these fixes work for you.

docker exec or docker attach?

Docker’s exec and attach commands are handy for interacting with running containers but they’re built for different purposes.

---

Over 200k developers use LogRocket to create better digital experiences

Learn more →

---

Docker’s attach command helps with attaching local standard input, output, and error streams to running containers:

You’ll use docker exec when you need to run a separate command inside a running container and docker attach if you need to interact with the primary process running inside the container.

Conclusion

In this article, you’ve learned how to interact with your running containers using docker exec. The docker exec command allows you to execute commands inside a running container, whether interactively, with environment variables, or as a different user, without restarting the container. You also learned how to troubleshoot common errors and the difference between exec and docker attach, which connects to an already running process.