Opening a shell in container in Docker - Step-by-Step Execution

Process Flow - Opening a shell in container

Identify running container

↓

Run docker exec command

↓

Start shell inside container

↓

Interact with container shell

↓

Exit shell to host

This flow shows how to open a shell inside a running Docker container to interact with it directly.

Execution Sample

Docker

docker exec -it mycontainer /bin/bash

This command opens an interactive bash shell inside the running container named 'mycontainer'.

Process Table

Step	Action	Command Executed	Result	Notes
1	Identify running container	docker ps	Lists running containers with names and IDs	Needed to know container name or ID
2	Run exec command	docker exec -it mycontainer /bin/bash	Starts bash shell inside 'mycontainer'	Interactive terminal allocated
3	Interact with shell	ls -l	Lists files inside container's current directory	User can run commands inside container
4	Exit shell	exit	Returns to host terminal	Shell session inside container ends

💡 User exits shell with 'exit' command, returning control to host terminal

Status Tracker

Variable	Before exec	After exec	After command	After exit
Container Shell	Not active	Active (bash shell open)	Active (running commands)	Not active (shell closed)

Key Moments - 2 Insights

Why do we need the '-it' flags in the docker exec command?

The '-i' flag keeps the input open for interaction, and '-t' allocates a terminal so you can see output nicely. Without these, the shell won't be interactive as shown in step 2 of the execution table.

What happens if the container name is wrong or the container is not running?

The docker exec command will fail to start the shell because it cannot find or access the container. This is why step 1 (docker ps) is important to confirm the container is running.

Visual Quiz - 3 Questions

Look at the execution table, what command is used to start the shell inside the container?

A docker start mycontainer

B docker exec -it mycontainer /bin/bash

C docker run mycontainer

D docker ps

💡 Hint

Check step 2 in the execution table where the shell is started.

At which step does the user interact with the container's shell?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look for the step where commands like 'ls -l' are run inside the container.

If the '-it' flags are removed from the docker exec command, what will happen?

A The shell will still open interactively.

B The container will stop running.

C The shell will open but not allow interactive input.

D The command will fail immediately.

💡 Hint

Refer to the key moment about the purpose of '-it' flags.

Concept Snapshot

docker exec -it <container> /bin/bash
- Opens an interactive shell inside a running container
- '-i' keeps input open, '-t' allocates a terminal
- Use 'docker ps' to find running container names
- Exit shell with 'exit' to return to host

Full Transcript

To open a shell inside a running Docker container, first identify the container name using 'docker ps'. Then run 'docker exec -it <container> /bin/bash' to start an interactive bash shell inside it. The '-i' and '-t' flags keep the session interactive and allocate a terminal. Inside the shell, you can run commands as if you were inside the container. When finished, type 'exit' to leave the shell and return to your host terminal.

Practice

1. What is the main purpose of the command docker exec -it <container> /bin/bash?

easy

A. To stop a running container

B. To start a new container from an image

C. To open an interactive shell inside a running container

D. To build a Docker image

Solution

1. Step 1: Understand the command components

   The command uses docker exec to run a command inside a running container. The -it flags make the session interactive and allocate a terminal.

2. Step 2: Identify the command's effect

   Using /bin/bash opens a shell inside the container, allowing direct interaction.

3. Final Answer:

   To open an interactive shell inside a running container -> Option C

4. Quick Check:

   docker exec -it container /bin/bash = open shell [OK]

Hint: Remember exec + -it + shell opens container shell [OK]

Common Mistakes:

• Confusing exec with docker run
• Forgetting the -it flags for interactivity
• Trying to open shell in a stopped container

2. Which of the following is the correct syntax to open a shell inside a running Docker container named webapp?

easy

A. docker exec -it webapp /bin/sh

B. docker start -it webapp /bin/sh

C. docker run -it webapp /bin/sh

D. docker exec webapp -it /bin/sh

Solution

1. Step 1: Recall the correct order of docker exec flags

   The -it flags must come immediately after docker exec and before the container name.

2. Step 2: Check the command structure

   The correct syntax is docker exec -it <container> <shell>. docker exec -it webapp /bin/sh matches this exactly.

3. Final Answer:

   docker exec -it webapp /bin/sh -> Option A

4. Quick Check:

   Flags -it come before container name [OK]

Hint: Flags -it always come right after exec command [OK]

Common Mistakes:

• Placing -it after container name
• Using docker run instead of exec
• Using docker start with shell command

3. Given a running container named db, what will be the output of the command docker exec -it db /bin/false?

medium

A. The command exits immediately with no shell opened

B. Error: container not found

C. An interactive shell opens inside the container

D. The container stops running

Solution

1. Step 1: Understand the command /bin/false

   The command /bin/false is a program that immediately exits with a failure status and does not open a shell.

2. Step 2: Predict the command behavior inside the container

   Running docker exec -it db /bin/false will run /bin/false inside the container, which exits immediately without opening a shell.

3. Final Answer:

   The command exits immediately with no shell opened -> Option A

4. Quick Check:

   /bin/false exits immediately, no shell [OK]

Hint: Commands like /bin/false exit immediately, no shell [OK]

Common Mistakes:

• Expecting a shell to open
• Confusing container not found error
• Thinking container stops after exec

4. You try to open a shell inside a running container with docker exec -it mycontainer /bin/bash but get the error: OCI runtime exec failed: exec failed: container_linux.go:xxx: exec: "/bin/bash": stat /bin/bash: no such file or directory. What is the best way to fix this?

medium

A. Restart the Docker daemon

B. Use /bin/sh instead of /bin/bash

C. Rebuild the container image

D. Stop and remove the container

Solution

1. Step 1: Analyze the error message

   The error says /bin/bash does not exist inside the container, so the shell is missing.

2. Step 2: Choose an alternative shell

   Many containers have /bin/sh instead of /bin/bash. Using /bin/sh usually works.

3. Final Answer:

   Use /bin/sh instead of /bin/bash -> Option B

4. Quick Check:

   Use available shell like /bin/sh if /bin/bash missing [OK]

Hint: Try /bin/sh if /bin/bash not found inside container [OK]

Common Mistakes:

• Restarting Docker daemon unnecessarily
• Rebuilding image without checking shell availability
• Removing container without trying alternative shells

5. You want to open a shell inside a running container named app but it does not have /bin/bash or /bin/sh. Which command can you try to open a shell if ash is installed inside the container?

hard

A. docker exec -it app /bin/zsh

B. docker exec -it app /bin/bash

C. docker exec -it app /bin/sh

D. docker exec -it app /bin/ash

Solution

1. Step 1: Identify available shells inside container

   If /bin/bash and /bin/sh are missing, but ash is installed, you can use /bin/ash to open a shell.

2. Step 2: Use docker exec with the correct shell path

   The command docker exec -it app /bin/ash opens an interactive shell using ash inside the container.

3. Final Answer:

   docker exec -it app /bin/ash -> Option D

4. Quick Check:

   Use shell installed inside container, e.g. /bin/ash [OK]

Hint: Try shells like /bin/ash if bash and sh missing [OK]

Common Mistakes:

• Assuming bash or sh always exist
• Using wrong shell path
• Not checking installed shells inside container