Table of Contents
Getting Ready to Run a Container
To run your first container, you only need a working Docker installation and access to a terminal or command prompt. At this stage, you do not need to understand images or Dockerfiles in depth, only that a container is created from an image that already exists somewhere, such as Docker Hub.
Make sure Docker is installed and the Docker daemon is running. On many systems, you can confirm this by running a simple command like docker version or docker info. If Docker responds with version and system details, you are ready to start your first container.
You must have the Docker service running. If docker commands fail with connection errors, start Docker before trying to run containers.
Running a Simple Container
The most common way to start a container is with the docker run command. Your first container should use a very simple image so you can see the result clearly without extra setup.
One popular choice for a first command is:
docker run hello-world
When you execute this command, Docker looks for the hello-world image locally. If the image is not present, Docker contacts a registry, usually Docker Hub, pulls the image to your machine, and then starts a container from it. The hello-world image prints a friendly message explaining what Docker just did, then the container exits.
This small example proves several things at once. It shows that Docker can reach the registry, that the image can be downloaded, and that your system can successfully start and run a container.
If docker run hello-world prints the explanation message and returns you to the prompt, your Docker installation and basic networking are functioning correctly.
Seeing the Effect of a Container That Exits
A container created from hello-world runs only long enough to print its message. By the time you see the output, the container has already stopped. This is normal for containers that perform a single short task.
The important lesson is that starting a container does not guarantee that it will keep running. Containers stay alive only while their main process is running. If that main process finishes or fails, the container stops. For simple demonstration images, this means you often run the container, see the output, and then the container exits immediately.
You will learn how to list stopped containers and remove them in later chapters. For now, it is enough to observe that closing the main process ends the container’s life.
Running a Long-Lived Container
To see a container that keeps running, you can start something that provides a service, such as a web server, instead of a short one-off command.
An example is:
docker run nginx
This command uses the nginx image, which starts an Nginx web server as its main process. After you run this command, the container continues running as long as the Nginx process is alive. Because Nginx is a server process, it stays active rather than exiting immediately.
In many terminals, when you run a server image like this without extra options, you will see log output appear directly in your terminal, and the prompt will not return until you stop the container. This shows that you are now attached to a running container whose main process is still active.
A container keeps running only while its main process is running. When that process stops, the container stops.
Understanding Default Behavior on First Run
When you run a container without many options, Docker makes several default choices for you. It uses the image’s own default startup command, it attaches your terminal to the container’s main process, and it uses some basic networking and storage settings in the background.
For a first container, relying on these defaults is useful. You can start a container with a short single command and immediately see output or behavior without needing to specify all details. Later chapters will show you how to customize what command runs inside the container, how to manage ports, and how to control interaction.
For now, focus on these basic patterns:
Use docker run hello-world when you want a quick verification that Docker can pull and run images.
Use a simple server image like docker run nginx or a similar image if you want to see a container that stays alive, produces continuous logs, and demonstrates a long-running process.
Confirming That You Actually Used a Container
After running your first container, it is useful to convince yourself that this was not just a local script or program running normally on your machine. The output from hello-world helps with this, because it explicitly describes how Docker pulled the image and started a container.
As you experiment, try running docker run hello-world again. The second time, Docker will not need to download the image, because it is already stored locally. The output will still show the container message, but you will notice that the image pull step is skipped and the container starts faster. This behavior shows that the image and the container are distinct. The image remains available, and each docker run uses that image to create a new, separate container instance.
This repeated pattern, an image stored once, and many containers created from it, is at the heart of working with Docker. Your first few runs are a simple but real version of this pattern.