Overview

Teaching: 15 min
Exercises: 5 min

Questions

• How are containers run?

• How do you monitor containers?

• How are containers exited?

• How are containers restarted?

Objectives

• Run containers

• Understand container state

• Stop and restart containers

To use an image as a particular instance on a host machine, you run it as a container. You can run in either a detached or foreground (interactive) mode.

Run the image we pulled as a container with an interactive bash terminal:

podman run -it matthewfeickert/intro-to-docker:latest /bin/bash

The -i option here enables the interactive session, the -t option gives access to a terminal and the /bin/bash command makes the container start up in a bash session.

You are now inside the container in an interactive bash session. Check the file directory

pwd

/home/docker/data

and check the host to see that you are not in your local host system

hostname

<generated hostname>

Further, check the os-release to see that you are actually inside a release of Debian (given the Docker Library’s Python image Dockerfile choices)

cat /etc/os-release

PRETTY_NAME="Debian GNU/Linux 11 (bullseye)"
NAME="Debian GNU/Linux"
VERSION_ID="11"
VERSION="11 (bullseye)"
VERSION_CODENAME=bullseye
ID=debian
HOME_URL="https://www.debian.org/"
SUPPORT_URL="https://www.debian.org/support"
BUG_REPORT_URL="https://bugs.debian.org/"

Working directory

You may be wondering why you are at /home/docker/data inside the container. This is the working directory that was set for the image.

In the next chapters we will see how to build your own images and set parameters such as the working directory.

Monitoring Containers

Open up a new terminal tab on the host machine and list the containers that are currently running:

podman ps

CONTAINER ID        IMAGE         COMMAND             CREATED             STATUS              PORTS               NAMES
<generated id>      <image:tag>   "/bin/bash"         n minutes ago       Up n minutes                            <generated name>

Notice that the name of your container is some randomly generated name. To make the name more helpful, rename the running container

podman rename <CONTAINER ID> my-example

and then verify it has been renamed

podman ps

CONTAINER ID        IMAGE         COMMAND             CREATED             STATUS              PORTS               NAMES
<generated id>      <image:tag>   "/bin/bash"         n minutes ago       Up n minutes                            my-example

Renaming by name

You can also identify containers to rename by their current name

podman rename <NAME> my-example

Alternatively, you can also give the container a name at creation, using the --name option:

podman run -it --name my-fancy-name matthewfeickert/intro-to-docker:latest /bin/bash

This way, it has a custom chosen name to start with, which you can use later on to interact with it.

Exiting and restarting containers

As a test, go back into the terminal used for your container, and create a file in the container

touch test.txt

In the container exit at the command line

exit

You are returned to your shell. If you list the containers you will notice that none are running

podman ps

CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES

but you can see all containers that have been run and not removed with

podman ps -a

CONTAINER ID        IMAGE         COMMAND             CREATED            STATUS                     PORTS               NAMES
<generated id>      <image:tag>   "/bin/bash"         n minutes ago      Exited (0) t seconds ago                       my-example

To restart your exited container start it again and then attach it interactively to your shell

podman start <CONTAINER ID>
podman attach <CONTAINER ID>

exec command

The attach command used here is a handy shortcut to interactively access a running container with the same start command (in this case /bin/bash) that it was originally run with.

In case you’d like some more flexibility, the exec command lets you run any command in the container, with options similar to the run command to enable an interactive (-i) session, etc.

For example, the exec equivalent to attaching in our case would look like:

podman start <CONTAINER ID>
podman exec -it <CONTAINER ID> /bin/bash

Starting and attaching by name

You can also start and attach containers by their name

podman start <NAME>
podman attach <NAME>

Notice that your entry point is still /home/docker/data and then check that your test.txt still exists

ls

test.txt

So this shows us that we can exit containers for arbitrary lengths of time and then return to our working environment inside of them as desired.

Clean up a container

If you want a container to be cleaned up — that is, deleted — after you exit it then run with the --rm option flag

podman run --rm -it <IMAGE> /bin/bash

Key Points

• Run containers with podman run <image-id>

• Monitor containers with podman ps

• Exit interactive sessions using the exit command

• Restart stopped containers with podman start