Docker Images & Containers

What are Docker Images?

A Docker image is a lightweight, standalone, and executable software package that includes everything needed to run a piece of software:

• Application code and binaries
• Runtime environment (e.g., .NET, Node.js, Java)
• Dependencies and libraries
• Configuration files

Docker images are created by reading instructions from a Dockerfile. Each instruction forms a layer in the image, allowing efficient caching and reuse.

Building Docker Images

To create an image, use the docker build command. Ensure your project contains a valid Dockerfile in the root directory.

docker build -t myapp:latest .

This command will:

• Read the Dockerfile
• Execute each instruction to build the image layers
• Tag the resulting image as myapp:latest

You can view all local images with:

docker images

What are Docker Containers?

A container is a runtime instance of a Docker image. Containers are isolated, portable, and lightweight environments that run your software as defined in the image.

They share the host system's kernel but run in isolated user spaces. This makes them much faster and lighter than traditional virtual machines.

Running Containers

You can start a container using the following command:

docker run -d -p 8080:80 --name mycontainer myapp

• -d: Detached mode – runs in the background
• -p 8080:80: Maps host port 8080 to container port 80
• --name: Assigns a name to the container
• myapp: The name (or ID) of the image to run

Test the container by visiting http://localhost:8080 in your browser.

Managing Containers

Once running, you can interact with containers using various Docker commands:

docker ps -a                 # List all containers
docker exec -it mycontainer bash  # Open an interactive shell inside a container
docker logs mycontainer      # View container logs
docker stop mycontainer      # Stop a container
docker start mycontainer     # Restart a stopped container
docker rm mycontainer        # Delete a container
docker rmi myapp             # Remove the image

Use docker inspect to get detailed configuration and state info:

docker inspect mycontainer

Image to Container: Lifecycle Overview

1. Create a Dockerfile with application instructions
2. Build the Docker image using docker build
3. Run the image as a container using docker run
4. Manage container lifecycle (start, stop, delete)
5. Tag and push image to Docker Hub or a private registry (optional)

Best Practices for Working with Images & Containers

• Use specific version tags (e.g., myapp:v1.0) instead of :latest to avoid unexpected upgrades.
• Keep images as small as possible – remove build tools and temp files during build.
• Utilize multi-stage builds to separate dependencies from runtime.
• Clean up unused images and containers regularly using:

  docker system prune

• Use health checks in the Dockerfile for better container monitoring.

Docker images define the environment and containers bring them to life. With proper understanding and management, you can build resilient and scalable applications that work consistently from development to production.