Comprehensive Guide to Running Docker Images as Containers

Fundamentals of Docker Image Execution

After successfully building a Docker image, the subsequent critical step involves executing the image as an operational container. This process encompasses multiple technical aspects that require thorough understanding of Docker's execution mechanisms and command parameters.

Image Identification and Container Initialization

Docker images can be identified and executed through two primary methods: using image name tags or directly employing image IDs. While functionally equivalent, each approach offers distinct advantages in practical usage scenarios.

First, examine the locally available image repository using the docker images command:

$ docker images
REPOSITORY          TAG                 ID                  CREATED             SIZE
ubuntu              12.04               8dbd9e392a96        4 months ago        131.5 MB (virtual 131.5 MB)

Executing containers using image name tags represents the most common approach, featuring clear syntax structure and enhanced memorability:

$ docker run -i -t ubuntu:12.04 /bin/bash

The -i parameter maintains standard input accessibility, while -t allocates a pseudo-terminal. Combined usage of these parameters facilitates interactive container session creation.

When images lack explicit name tags, direct execution using image IDs becomes necessary:

$ docker run -i -t 8dbd9e392a96 /bin/bash

Comprehensive Container Execution Modes

Docker provides diverse execution modes to accommodate varying application requirements. Foreground execution mode suits debugging and interactive applications, while production environments typically employ background execution mode.

Foreground execution demonstration:

$ docker run -p 8080:8080 my-web-app

Background execution implementation through the -d parameter:

$ docker run -d -p 8080:8080 --name web-server my-web-app

In background execution mode, containers operate continuously in system background without blocking current terminal sessions, while enabling management through container names.

Port Mapping and Network Configuration

Container network isolation constitutes a fundamental Docker characteristic. To enable external access to containerized services, port mapping configuration becomes essential. The port mapping syntax follows [host_port]:[container_port] format.

Basic port mapping illustration:

$ docker run -p 8080:80 nginx:alpine

IP-specific port mapping implementation:

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

This configuration approach maps container port 80 to host address 127.0.0.1 port 8080, thereby enhancing security measures.

Container Lifecycle Management

Comprehending the complete container lifecycle proves crucial for effective Docker environment administration. Container states encompass running, stopped, exited, and various other status conditions.

View active containers:

$ docker ps

Examine all containers (including stopped instances):

$ docker ps -a

Container termination:

$ docker stop container_name

Restart previously stopped containers:

$ docker restart container_name

Container removal:

$ docker rm container_name

Advanced Execution Options

The Docker run command offers extensive advanced options to address complex deployment requirements.

Environment variable configuration:

$ docker run -e ENV_VAR=value -e ANOTHER_VAR=another_value my-app

Volume mount setup:

$ docker run -v /host/path:/container/path my-app

Resource limitation specification:

$ docker run --memory=512m --cpus=1.0 my-app

Restart policy implementation:

$ docker run --restart=unless-stopped my-app

Practical Application Scenarios

In actual development environments, combined usage of Docker run commands addresses diverse deployment needs. The following represents a comprehensive web application deployment example:

$ docker run -d \
  --name my-web-application \
  -p 80:8080 \
  -e DATABASE_URL=postgresql://user:pass@db:5432/app \
  -v /app/logs:/var/log/app \
  --restart=on-failure:5 \
  my-web-app:latest

This configuration achieves complete application deployment: container operation in background mode, explicit naming convention, port mapping to host port 80, essential environment variable configuration, log directory mounting, and failure restart policy establishment.

Recommended Best Practices

Based on practical project experience, the following Docker execution best practices are recommended:

1. Consistently assign explicit container names to facilitate management and maintenance

2. Implement appropriate resource limitations to prevent individual containers from consuming excessive system resources

3. Employ suitable restart policies to ensure service availability

4. Configure application parameters through environment variables to enhance deployment flexibility

5. Regularly clean unused containers and images to optimize storage utilization

By mastering these core concepts and practical techniques, developers can efficiently manage and execute Docker containers, thereby constructing stable and reliable containerized application environments.