How to Use the Command 'docker exec' (with Examples)

The docker exec command is a powerful Docker CLI tool that allows you to execute commands on an already running Docker container. This utility provides flexibility in managing containerized applications by facilitating direct interaction with the container’s operating environment. Whether you need to perform administrative tasks, troubleshoot issues, or customize running services, docker exec enables you to run commands with the simplicity of operating in a native Linux environment while isolated within the container.

Use Case 1: Enter an Interactive Shell Session on an Already-Running Container

Code:

docker exec --interactive --tty container_name /bin/bash

Motivation: The motivation behind entering an interactive shell session is to directly interact with the container’s environment as if you were operating in a standalone system. This is particularly useful for troubleshooting, running administrative commands, or manually modifying files in real time without disrupting the container’s running state.

Explanation:

• --interactive (-i): Keeps STDIN open and allows you to interact with the container in real-time.
• --tty (-t): Allocates a pseudo-TTY, granting you an interactive terminal session.
• container_name: Specifies the name (or ID) of the target container.
• /bin/bash: Executes the Bash shell, enabling you to run commands interactively within the container.

Example Output: Upon successful execution of the command, you would be presented with a shell prompt that looks similar to this:

root@container_id:/#

From here, you can perform any necessary actions as if you were logged into a regular Linux environment.

Use Case 2: Run a Command in the Background (Detached) on a Running Container

Code:

docker exec --detach container_name command

Motivation: Running commands in the background is crucial when you need to perform tasks that don’t require active monitoring or interaction. This can include updating software, applying patches, or performing maintenance tasks that consume time but don’t need constant attention.

Explanation:

• --detach (-d): Runs the command in the background, allowing the container to continue its regular operations without waiting for the command to complete.
• container_name: Specifies the container in which the command will be executed.
• command: Represents the specific command or script you want to run within the container.

Example Output: Since the command is executed in detached mode, no immediate output is presented. However, logs or results of the command may be observed through Docker logs or other logging solutions implemented within the container.

Use Case 3: Select the Working Directory for a Given Command to Execute Into

Code:

docker exec --interactive --tty --workdir path/to/directory container_name command

Motivation: Choosing a specific working directory is valuable when you require a command to run in a particular context within the container. This is especially beneficial for script execution, file manipulation, or when working with services configured to operate in specific directory structures.

Explanation:

• --interactive (-i): Enables interactive mode to allow real-time interaction if necessary.
• --tty (-t): Provides a pseudo-terminal for command execution.
• --workdir (-w): Sets the working directory for the command execution.
• path/to/directory: Indicates the directory path within the container where the command is executed.
• container_name: Identifies the container targeted for command execution.
• command: The command or script to execute within the specified directory.

Example Output: Executing this command will lead to output specific to the command and its execution context. For instance, if listing files in a directory, you might see:

file1.txt
file2.log
script.sh

Use Case 4: Run a Command in Background on Existing Container but Keep stdin Open

Code:

docker exec --interactive --detach container_name command

Motivation: This use case is essential when you require a combination of background execution with the ability to feed data or commands through standard input at a later stage. It’s useful for applications needing tasks to start immediately but continue receiving input or commands after initiation.

Explanation:

• --interactive (-i): Keeps STDIN open, ready for input even after command execution begins.
• --detach (-d): Runs the command in the background.
• container_name: The target container for command execution.
• command: Represents the command to execute in the container.

Example Output: Similar to other detached operations, direct output isn’t immediately visible in the terminal. Input can be provided later to continue operations, dependent on how the application or service is configured within the container.

Use Case 5: Set an Environment Variable in a Running Bash Session

Code:

docker exec --interactive --tty --env variable_name=value container_name /bin/bash

Motivation: Environment variables are pivotal for altering the behavior and configuration of applications at runtime. Being able to set or modify these variables within a live session allows developers to test different configurations without permanently altering the container’s setup.

Explanation:

• --interactive (-i): Allows interactive engagement with the shell session.
• --tty (-t): Allocates a pseudo-TTY for an interactive experience.
• --env (-e): Sets an environment variable before executing the shell.
• variable_name=value: Defines the variable and its assigned value.
• container_name: Specifies the container for session initiation.
• /bin/bash: Opens the bash shell with the environment variable set.

Example Output: Entering this command grants a shell similar to:

root@container_id:/# env | grep variable_name
variable_name=value

This confirms the environment variable variable_name is set in the session.

Use Case 6: Run a Command as a Specific User

Code:

docker exec --user user container_name command

Motivation: Running commands as a specific user is essential for maintaining security and ensuring proper user permissions are adhered to. This is particularly crucial in multi-user environments or when operating on files and directories that require specific access levels.

Explanation:

• --user (-u): Specifies the username or UID under which the command should be executed.
• user: Specifies the user account for executing the command.
• container_name: Identifies the container where command execution happens.
• command: The specific command initiated under the defined user context.

Example Output: The output will vary based on the command run and the user’s permissions. For example, executing a user-specific script might result in:

Script executed successfully by user: user_name

Conclusion:

The docker exec command proves indispensable for those managing Docker containers. By facilitating easy command execution, interactive sessions, and even modifying user contexts or environment variables, it caters to a wide array of administrative and development needs. Whether managing tasks in real-time, testing configurations on the fly, or ensuring optimal security through specific user commands, docker exec serves as a cardinal tool in the Docker toolkit.