How To Run a Container in Docker

Docker runs applications inside containers; lightweight, isolated environments that bundle software with its dependencies and configuration. Unlike virtual machines, containers do not require a full guest operating system and instead share the host's kernel. This makes containers faster to start and more resource-efficient. The docker container run command is the primary method for starting containers from images, applying runtime options, and creating isolated processes.

This article explains how to use docker container run to launch containers with custom settings. You'll learn how to name containers, run them in detached mode, publish ports, mount volumes, and enable automatic cleanup with --rm. It also includes reference tables that describe important Docker run flags for managing resources, networks, storage, and container health.

The Short Answer Version

# Run a container interactively from an image
$ docker container run -it ubuntu

# Run a container in the background
$ docker container run -d nginx

# Run and name the container
$ docker container run --name myapp alpine

# Run and publish container port 80 to host port 8080
$ docker container run -p 8080:80 nginx

# Mount a volume into the container
$ docker container run -v $(pwd):/data alpine

# Run and remove container after it exits
$ docker container run --rm busybox echo "done"

Each command demonstrates a core usage of docker container run, including naming, networking, volumes, interactive mode, and cleanup.

Docker Run General Options

Docker Run Networking Options

Docker Run Storage Options

Docker Run Resource Management Options

Docker Run Security Options

Docker Run Container Health Options

Docker Run Additional Options

Run Container Under Specific Name

Use the --name flag with docker container run to assign a custom name to your container. This helps with logging, management, and automation. Without this flag, Docker generates a random name like frosty_morse.

Container names must begin with an alphanumeric character and may only contain letters, numbers, underscores (_), periods (.), and hyphens (-).

Command Syntax

docker container run --name <container-name> [IMAGE]

• --name <container-name>: Assigns a specific name to the container.
• [IMAGE]: The Docker image to use (e.g., nginx, ubuntu, busybox).

Command Demonstration

1. Create a BusyBox container named busybox_test.

   console Copy

   $ docker container run --name busybox_test busybox
   

2. Create an Nginx container named web-server.

   console Copy

   $ docker container run --name web-server nginx
   

3. Create an Ubuntu container named linux.

   console Copy

   $ docker container run --name linux ubuntu
   

4. Create a named container my-nginx and run it in the background.

   console Copy

   $ docker container run --name my-nginx -d nginx
   

5. Verify that the container is running.

   console Copy

   $ docker container ls
   

6. Display logs for the my-nginx container.

   console Copy

   $ docker container logs my-nginx
   

7. Rename my-nginx to my-nginx-2.

   console Copy

   $ docker container rename my-nginx my-nginx-2
   

8. List containers to confirm the name change.

   console Copy

   $ docker container ls
   

   Output:

   CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS     NAMES
   dbbe80f32d93   nginx     "/docker-entrypoint.…"   20 seconds ago  Up 20 seconds  80/tcp    my-nginx-2

Run Container in Background (Detached Mode)

By default, Docker runs containers in the foreground and displays their output in your terminal. To run containers in the background, use the -d (detached) flag. This is especially useful for services that should run persistently, such as web servers and background workers.

Command Syntax

docker container run -d [IMAGE]

• -d: Runs the container in detached mode.
• [IMAGE]: The image to use for the container (e.g., nginx, busybox).

Command Demonstration

1. Run an Nginx container in background mode.

   console Copy

   $ docker container run --name nginx-bg -d nginx
   

2. View logs in real-time.

   console Copy

   $ docker container logs -f nginx-bg
   

3. Open a shell session inside the container.

   console Copy

   $ docker container exec -it nginx-bg bash
   

4. Run a command inside the container.

   console Copy

   # date
   

   Output:

   Fri Jun 27 11:22:47 UTC 2025

5. Exit the shell.

   console Copy

   # exit
   

Run Container and Publish Container Ports

Use the -p or --publish flag with docker container run to make a container’s internal ports accessible from the host. Port publishing enables external clients to reach containerized applications like web servers or APIs.

Port publishing is only required for incoming connections. Containers can make outgoing connections without any publishing.

Command Syntax

docker container run -p [IP:]<host_port>:<container_port> [IMAGE]

• -p: Publishes a container port to the host system.
• [IP:]: (Optional) Bind the port to a specific interface like 127.0.0.1.
• <host_port>: The port exposed on the host machine.
• <container_port>: The internal port in the container.
• [IMAGE]: The Docker image to run.

Command Demonstration

• Map container port 80 to host port 8080.

  console Copy

  $ docker container run -p 8080:80 nginx
  

• Map host port 8080 to container port 1234 for UDP traffic.

  console Copy

  $ docker container run -p 8080:1234/udp busybox
  

• Limit access to localhost only.

  console Copy

  $ docker container run -p 127.0.0.1:8080:80 nginx
  

• Map container port 80 to the same host port.

  console Copy

  $ docker container run -p 80:80 nginx
  

• Expose multiple ports (HTTP and HTTPS).

  console Copy

  $ docker container run -p 80:80 -p 443:443 nginx
  

Command Application

The following examples demonstrate how port publishing behaves in practice, including local and remote accessibility.

1. Run an Nginx container and expose port 8080 to the public.

   console Copy

   $ docker container run -d -p 8080:80 nginx
   

2. Access the container from an external system (replace with your instance IP).

   console Copy

   $ curl http://<SERVER-IP>:8080
   

3. Run a container restricted to localhost access only.

   console Copy

   $ docker container run -d -p 127.0.0.1:8081:80 nginx
   

4. Verify localhost access works.

   console Copy

   $ curl http://127.0.0.1:8081
   

5. Verify remote access is blocked (expect timeout or error).

   console Copy

   $ curl http://<SERVER-IP>:8081
   

Run Container With Mounted Host Volume

By default, Docker containers run in isolation from the host filesystem. To share files between the host and the container, such as application configs, website content, or database data, use the -v flag to mount a host directory into the container.

Command Syntax

docker container run -v <host_path>:<container_path>[:options] [IMAGE]

• -v: Mounts a directory from the host system.
• <host_path>: Absolute path to a directory on the host.
• <container_path>: Target directory inside the container.
• [:options]: Optional settings such as ro (read-only).
• [IMAGE]: Docker image to run, such as nginx or busybox.

Command Demonstration

• Mount a host directory into a BusyBox container with read-write access.

  console Copy

  $ docker container run -v /home/linuxuser/data:/data busybox
  

• Mount the same directory as read-only.

  console Copy

  $ docker container run -v /home/linuxuser/data:/data:ro busybox
  

Command Application

Use this example to build a real-world containerized web server by serving static files from the host system using Nginx. This demonstrates how volume mounting enables persistent content sharing between host and container.

1. Create a directory on the host for your static website.

   console Copy

   $ mkdir /home/linuxuser/webdata
   

2. Navigate into the directory.

   console Copy

   $ cd /home/linuxuser/webdata
   

3. Create an HTML page.

   console Copy

   $ cat <<EOF > index.html
   <!DOCTYPE html>
   <html>
   <head><title>Vultr Greeting</title></head>
   <body><h1>Greetings from Vultr</h1></body>
   </html>
   EOF
   

4. Run an Nginx container that mounts the website directory and serves it.

   console Copy

   $ docker container run -d -p 8082:80 -v /home/linuxuser/webdata:/usr/share/nginx/html:ro nginx
   

   • -d: Detached mode.
   • -p 8082:80: Maps host port 8082 to container port 80.
   • -v ...:ro: Mounts the host directory as read-only inside the container.

5. Confirm the container is serving the HTML page.

   console Copy

   $ curl http://127.0.0.1:8082
   

   Output:

   <!DOCTYPE html>
   <html>
   <head><title>Vultr Greeting</title></head>
   <body><h1>Greetings from Vultr</h1></body>
   </html>

Mounted directories persist even after the container is removed. Changes made to files in /usr/share/nginx/html are reflected in /home/linuxuser/webdata on the host.

Run Docker Container and Automatically Remove It After Exit

By default, stopped containers remain on the system in an exited state. Use the --rm flag with docker container run to automatically remove the container after it finishes. This is ideal for short-lived containers like scripts, tests, or one-time tasks.

Command Syntax

docker container run --rm [IMAGE] [COMMAND]

• --rm: Removes the container immediately after it exits.
• [IMAGE]: The Docker image to run.
• [COMMAND]: The command to execute inside the container.

Command Demonstration

• Run a container that prints Hello, world and self-deletes.

  console Copy

  $ docker container run --rm busybox echo "Hello, world"
  

• Run a container that sleeps for 5 seconds, then exits and removes itself.

  console Copy

  $ docker container run --rm busybox sleep 5
  

• Run an Ubuntu container that prints the current date and removes itself.

  console Copy

  $ docker container run --rm ubuntu bash -c "echo Done && date"
  

Command Application

This demonstration shows how the --rm flag prevents accumulation of exited containers.

1. Run a temporary BusyBox container with --rm.

   console Copy

   $ docker container run --name busybox --rm busybox echo "Temporary container"
   

2. Confirm it no longer exists.

   console Copy

   $ docker container ls -a
   

   The container does not appear in the list. Docker deleted it after execution.

3. Run the same container without --rm:

   console Copy

   $ docker container run --name busybox busybox echo "Persistent container"
   

4. List all containers again.

   console Copy

   $ docker container ls -a
   

   Output:

   CONTAINER ID   IMAGE     COMMAND                  CREATED              STATUS                     NAMES
   9f5d3cc7bb3e   busybox   "echo 'Persistent co…"   5 seconds ago        Exited (0) 5 seconds ago   busybox

   This container remains on the system in Exited state and must be manually removed using docker container rm.

Conclusion

In this article, you learned how to run containers using the docker container run command. You named containers, launched them in detached mode, mapped ports, mounted host directories, and configured automatic cleanup with --rm. You also explored key flags for managing container networking, resource limits, security options, and health checks.

These capabilities form the foundation for building portable and reproducible container workflows. For more options and advanced configurations, refer to the official Docker documentation.