Mantra Networking Mantra Networking

Docker: Containers

Docker: Containers
Created By: Lauren R. Garcia

Table of Contents

  • Overview
  • Core Components
  • Basic Workflow
  • Common Commands
  • Use Cases and Networking
  • Container Lifecycle
  • Security and Best Practices
  • Conclusion

Docker: Containers Overview

What Is Docker?

Docker is an open-source platform that centralizes the process of building, packaging, and running applications inside containers. A container bundles all code, dependencies, runtime, system tools, libraries, and configurations into a single, lightweight unit, ensuring that software runs consistently across any environment—your laptop, a test server, or in the cloud.

Why You Need to Know About Docker

  • Consistency: Containers eliminate the “it works on my machine” complexity. By encapsulating both the app and its dependencies, containers ensure reliable outcomes from development through production.
  • Portability: Containers can be deployed and moved across operating systems and infrastructures seamlessly, making them ideal for hybrid and multi-cloud environments.
  • Resource Efficiency: Containers are more lightweight than traditional virtual machines. They use fewer system resources and start up much faster.
  • Isolation and Security: Each container runs in its own isolated environment, keeping applications and services separate and reducing the risk of system-wide issues.
  • Scalability: Containers can be quickly replicated and managed at scale, which is essential for modern DevOps, microservices, and cloud-native deployments.

How Docker Works

  • Images: At the core of Docker are images—templates that contain everything needed to run an application. Images are built from Dockerfiles, which outline all the instructions for assembling the environment.
  • Containers: When an image is executed by Docker Engine, it becomes a running container. Containers are isolated processes with their own filesystem, network stack, and process space, all created from that image.
  • Client-Server Design: Docker uses a client-server approach:
    • The Docker client provides the interface for users to interact with Docker.
    • The Docker daemon handles the actual work of building, running, and managing containers and images.
    • These communicate through REST APIs over sockets or network interfaces.
  • Registries: Images are stored, versioned, and shared via registries such as Docker Hub or private repositories.
  • Networking and Storage: Docker offers robust networking options for connecting containers and provides data persistence with volumes and bind mounts.

Typical Workflow

  1. Write a Dockerfile describing your app environment and required actions.
  2. Build an image from the Dockerfile with the docker build command.
  3. Run containers from your image to instantiate isolated app environments.
  4. Manage containers—start, stop, scale, or remove—using Docker commands or orchestration tools.
  5. Deploy anywhere: move your container between desktops, servers, or clouds with consistent results every time.

Docker has revolutionized application development and operations by prioritizing simplicity, efficiency, and agility. With containers, teams accelerate software delivery, improve collaboration, and build reliable, portable infrastructure that meets the demands of scalable, modern IT environments.

Core Components

These are the essential building blocks that make Docker a powerful platform for containerized application development and orchestration:

  • Docker Daemon: Runs in the background on the host system. It listens for API requests, manages containers, images, networks, and handles the actual work of building and running Docker containers.
  • Docker Client: The primary interface for users to interact with Docker. This command-line tool sends commands to the Docker daemon to manage containers, images, and related resources.
  • Docker Images: Immutable and reusable templates that contain application code, libraries, dependencies, and settings. Images are used to create running containers on any compatible system.
  • Docker Containers: Isolated, lightweight runtime environments created from Docker images. Each container has its own filesystem, processes, and networking, yet shares the host’s kernel.
  • Docker Registries: Services for storing and distributing Docker images. The most common public registry is Docker Hub, but private registries can also be used in enterprise environments.
  • Docker Volumes: Dedicated storage spaces that persist data created or used by containers, ensuring data continuity even when containers are removed or replaced.
  • Docker Networks: Virtual networks that enable containers to communicate with each other or with external resources, allowing flexible and secure application deployments.
  • Docker Compose (Advanced): A tool for defining and managing multi-container applications using a simple YAML configuration file, enabling rapid deployment and scaling of complex stacks.

Basic Workflow

An overview of the typical steps involved in building, running, and managing Docker containers:

  1. Write a Dockerfile: Create a text file called Dockerfile that specifies the base image, application code, dependencies, environment variables, and commands needed to build your container image.
  2. Build the Docker image: Use the command docker build -t your-image-name . in the directory containing the Dockerfile to generate an image from the specifications.
  3. List images: Verify your image was created by running docker images which displays all available Docker images on your system.
  4. Run a container: Start a container from your image using docker run --name your-container-name -d your-image-name. This launches the container in detached mode.
  5. Interact with running containers: Execute commands inside the container with docker exec -it your-container-name /bin/bash or view logs with docker logs your-container-name.
  6. Manage container lifecycle: Use docker stop to stop containers, docker start to start stopped containers, and docker rm to remove containers that are no longer needed.
  7. Handle persistent data: Create and attach volumes with docker volume create and docker run -v volume-name:/path/in/container to retain data across container restarts and rebuilds.
  8. Push or pull images: Share your images by pushing to a registry with docker push or download images from a registry using docker pull.

Common Commands

These commands are frequently used to manage Docker images, containers, and volumes effectively:

Command Description
docker build -t <image-name> . Create a Docker image from a Dockerfile located in the current directory.
docker run --name <container-name> -d <image-name> Start a new container from an image with a specified name in detached mode.
docker ps List all currently running containers.
docker stop <container-name> Stop a running container by name or ID.
docker start <container-name> Start a previously stopped container.
docker exec -it <container-name> /bin/bash Open an interactive shell inside a running container.
docker logs <container-name> View logs output from a running or stopped container.
docker rm <container-name> Remove a stopped container.
docker rmi <image-name> Delete a Docker image from the local system.
docker volume create <volume-name> Create a new Docker volume for persistent data storage.
docker volume ls List all Docker volumes on the host.

Use Cases and Networking

Docker’s versatility and networking features empower a wide range of modern workflows and solutions:

  • Simplifies deployment and scalability, supporting microservices architecture.
  • Facilitates DevOps workflows by enabling consistent environments from development to production.
  • Supports legacy application migration by containerizing for better portability and management.
  • Enables rapid, isolated testing environments for developers.
  • Provides persistent data management through volumes.
  • Supports multi-container applications via Docker Compose.
  • Enhances cloud-native application deployment and hybrid/multi-cloud strategies.
  • Improves resource utilization by running multiple containers on a single host.
  • Docker networking creates virtual networks for secure, isolated container communication.
  • Popular built-in network types include bridge (default), overlay (multi-host), and macvlan (direct network access).
  • Networking enables containers to communicate by name or IP and connect to external resources.
  • Common networking use includes connecting microservices, securing inter-container traffic, and integrating with host networks.

Container Lifecycle in Docker

The journey of a Docker container moves through a clear set of stages, each representing a specific point in its operational life:

  1. Created: The container is built from an image but not yet running. Configuration is completed, but no application process has started.
  2. Running: The container is actively executing its process. It performs work defined by the image and is fully operational.
  3. Paused: The container is temporarily suspended. Its state is maintained in memory while processes are put on hold.
  4. Stopped: The container is shut down. Processes inside the container have ceased, but the container’s data and settings remain intact.
  5. Deleted (Removed): The container is removed from the system. All allocated resources are released, and the container’s records are purged.

Lifecycle management commands include creating, starting, pausing, stopping, and removing containers. Automation, monitoring, and health checks help ensure smooth transitions through each stage and optimize resource usage on your infrastructure.

Security and Best Practices

Following strong security principles and operational practices helps keep your containerized environments robust and resilient:

  • Use trusted and minimal base images from verified sources.
  • Run containers with non-root users to reduce risk of privilege escalation.
  • Limit container resource usage such as CPU, memory, and file descriptors to prevent denial-of-service.
  • Set filesystems and volumes to read-only when possible to minimize write access.
  • Regularly update images and containers with the latest security patches.
  • Avoid running unnecessary services inside containers to reduce attack surface.
  • Use Docker Secrets or environment variables for sensitive information rather than embedding in images.
  • Apply Linux security modules such as seccomp, AppArmor, or SELinux profiles.
  • Restrict container capabilities by dropping unneeded privileges.
  • Isolate container networks and use firewalls to control incoming and outgoing traffic.
  • Enable logging and monitoring to detect suspicious activity.
  • Regularly audit container configurations and enforce security policies.
  • Use role-based access control (RBAC) and enable Docker Content Trust for image signing and verification.
  • Automate security scanning of images and containers using regular vulnerability scanning tools.
  • Establish incident response plans to handle security breaches and mitigate risks promptly.

Conclusion

Throughout this blog post, we've explored the fundamental aspects of Docker and its container technology. We've learned about the components that make Docker work seamlessly — from the daemon and client to images, containers, and networking. Understanding the basic workflow equips you with the ability to create, run, and manage containers effectively. Common commands provide powerful tools to streamline day-to-day operations, while use cases show Docker's versatility across development, testing, deployment, and scaling scenarios. Container lifecycle insights reveal how containers transition through their stages, helping you manage applications more confidently. Finally, embracing security and best practices ensures your container environments remain safe, efficient, and resilient.

With these concepts in your toolbox, you're well on the path to leveraging Docker to build reliable, portable, and scalable infrastructure. Whether you're automating deployments, managing microservices, or simply experimenting with containerized applications, Docker’s ecosystem offers flexibility and control.

Thank you for following along on this Docker journey! Feel free to revisit the sections as you explore and build, and happy containerizing!

Share Share Share Share Share Email