Interacting with Docker Containers: Running Commands on Stopped and Running Containers

Introduction

Docker is an essential tool for deploying applications within containers. Often, developers need to run additional commands inside a container after its initial setup or during troubleshooting sessions. This tutorial explores how to interact with both stopped and running Docker containers by executing commands.

Understanding Docker Containers

A Docker container is essentially a lightweight, standalone package that contains everything needed to run a piece of software: code, runtime, libraries, environment variables, and configuration files. Once started, the default command in the Dockerfile or specified during docker run is executed, and upon completion, the container exits if it doesn’t persist.

Running Commands on a Stopped Container

If you have an existing Docker container that has exited (stopped), you can still interact with its filesystem and environment by committing it to a new image. This process saves the current state of the container into a snapshot or "image."

Steps:

Commit the Stopped Container:
- Use docker commit to create an image from the stopped container.
```
docker commit <container-name/ID> temporary_image
```
Run a New Container with the Committed Image:
- Launch a new instance of this image, specifying a different entrypoint if necessary.
```
docker run --entrypoint=bash -it temporary_image
```

Running Commands on a Running or Re-Started Container

For running containers (or those that you can start), Docker provides more straightforward commands to execute additional tasks.

Using `docker exec`

The docker exec command allows you to run commands in a container that is already running. This is ideal for interactive sessions, debugging, and administrative tasks without needing to stop or restart the container.

Run a Command:
```
docker exec -it <container-name/ID> /bin/bash
```
The -i flag keeps STDIN open even if not attached, and -t allocates a pseudo-TTY, making it possible to interact with the command line inside the container.

Keeping Containers Running

To keep a container alive for interactive sessions:

Initial Run Options:
- Use -d (detached mode) along with -i and -t during initial docker run.
```
docker run -it -d <image-name> /bin/bash
```

Starting a Stopped Container

If your container is stopped, you can start it again to interact with its running state.

Start the Container:
```
docker start <container-name/ID>
```
Attach and Run Commands:
After starting, use docker exec or:
- Start and attach in one command:
```
docker start -ai <container-name/ID>
```

Best Practices

Detached Mode: Use the -d option to ensure your container doesn’t stop immediately after running its initial process, which allows for subsequent interactions.
Persistent Data Management: Remember that containers are ephemeral by nature. For persistent data, use Docker volumes or bind mounts.
Security Considerations: When using docker exec, be mindful of permissions and security contexts to avoid unintentional access to sensitive information.
Documentation: Always refer to the official Docker documentation for the latest commands and best practices.

Conclusion

Interacting with Docker containers efficiently requires understanding how to manage both their running state and filesystem snapshots via commits. By mastering docker exec, docker commit, and container run options, you can maintain a flexible and responsive development environment using Docker containers.