Docker 101: The World of Containerization

Introduction

Docker’s been a term I’ve been familiar with for quite some time, but I never really got my hands dirty with it until now. Why not, you might ask? Well, between juggling tight schedules and working in teams where deployment was handled by others, I simply didn’t dive into it. It always fell into the category of “I’ll get to it eventually.”

I’ve always recognized the advantages Docker containers offer. The efficiency, portability, and consistency - I understood these benefits. Yet, it took me a while to actually sit down and learn about it. One of the main reasons, beyond those I’ve already mentioned, was my perception of Docker as something complex. This view was a barrier for me. However, what I’ve discovered recently is that Docker isn’t the daunting challenge I once thought it was. It’s surprisingly easy to learn and is undeniably a useful tool to have in any tech toolkit.

So, I’m here to break down the basic principles of Docker and provide practical examples to illustrate them. Along with these examples, I'll also share a handy cheatsheet covering all the essential commands you’ll need to get started and make the most out of Docker.

What is Docker

In simple terms, Docker is a platform that uses containerization technology to make it easier to create, deploy and run applications. By packaging software into standardized units called containers, Docker ensures that your application works seamlessly in any environment. This technology addresses the age-old issue of “it works on my machine”, making development, deployment, testing and collaboration more consistent and efficient.

To achieve this, Docker containers package not only the application but also its dependencies, libraries, and other necessary settings into a single unit. This means that the application will run the same way regardless of where the container is deployed - be it on a developer’s laptop, a test environment, or a production server. Moreover, Docker containers are isolated from each other and the host system, providing a secure environment for your applications.

This isolation also ensures that changes made in one container do not affect others, making it easier for teams to work on different parts of an application simultaneously without conflicts. Additionally, Docker’s lightweight nature compared to traditional virtual machines means applications use fewer system resources, leading to increased efficiency and reduced costs.

Docker vs. Virtual Machines

Aspect	Docker Containers	Virtual Machines
Architecture	Uses containerization, sharing the host OS kernel	Emulates a full physical computer including hardware
Resource Usage	Less resource-intensive, shares resources with the host	More resource-intensive, each VM runs a full OS
Startup Time	Faster startup times (can take seconds)	Slower startup times (can take minutes)
Isolation Level	Application-level isolation	Full OS-level isolation
Scalability	Highly scalable with efficient resource usage	Scalable but can be resource-heavy
Management and Orchestration	Ecosystem includes tools like Docker Swarm, Kubernetes for easy management	Depends on hypervisor tools, can be complex to manage

Development Workflow Comparison

Aspect	Development Prior to Containers	Development with Containers
Installation and Configuration	Each developer installs and configures services directly on their local machine.	Developers work in their own isolated environment.
OS Compatibility	Installation process varies based on the OS environment.	Installation is uniform across all operating systems.
Collaboration Challenges	Collaborating with others can be difficult due to different setups and potential issues.	Standardizes the process across all local development environments.
Service Installation	For applications using multiple services, each developer must install them individually.	Easily run different versions of the same application without conflicts.

Deployment Workflow Comparison

Aspect	Deployment Prior to Containers	Deployment with Containers
Artifact and Instructions	Requires artifact and installation instructions, including dependencies.	Docker artifact contains all necessary components and dependencies.
Handling by Operations Team	Operations team installs and configures apps and dependencies manually.	Docker artifact simplifies deployment, eliminating manual configurations.
Server Configuration	Installation and configurations are done directly on the server's OS.	No need for server configurations other than installing Docker runtime.
Communication and Errors	Communication between teams can lead to misconfigurations and errors.	Reduced room for errors with everything packaged in the Docker artifact.

Key Terms in Docker

To get comfortable with Docker, it's helpful to know some key terms:

1. Images: Read-only templates used to build containers. They include application code, libraries, dependencies, and other necessary parts.
2. Containers: Instances of Docker images that can be run using the Docker engine. They are lightweight, portable, and encapsulate an environment for running applications.
3. Dockerfile: A script containing a series of instructions and commands for building an image.
4. Docker Hub: A cloud-based registry service used to find and share container images with the Docker community. It serves as the GitHub of Docker Images, facilitating collaboration and distribution.

How Docker Works: An analogy

Docker Images: Blueprints of Containers

Imagine you’re building a house. Prior to construction, you need a blueprint that outlines every detail of the house; from the layout to the materials used. In the Docker world, these blueprints are called images.

Docker Containers: Live instances of Images

Now, let’s say you have your house blueprint ready. You use it to build the actual house. In Docker, these real, live instances are called containers.

When you’re starting a container from an image, you’re essentially bringing the blueprint to life. Docker takes the image and creates a running instance of it, complete with its own isolated environment.

Each container runs independently, like a separate house built from the same blueprint (Yes, you can create many containers with the same image!). They’re isolated from each other and from the system they’re running on, ensuring that what happens in one container doesn’t affect the others.

Docker Compose: Managing Multiple Containers

Finally, imagine you’re not just building one house but an entire neighbourhood with multiple houses, each with its own unique blueprint. This is where Docker Compose comes in.

Docker Compose lets you define all the different services (houses) you need for your application in a single configuration file. You specify things like which images to use, how they should communicate, their environment variables and any other settings.

With Docker Compose, you can start, stop and manage all the services in your application with just one command.

Docker Cheatsheet

Command	Description
docker run <image>	Run a container based on an image.
docker ps	List running containers.
docker ps -a	List all containers (running and stopped).
docker images	List all images available on the system.
docker pull <image>	Download an image from Docker Hub.
docker build -t <tag> <path>	Build an image from a Dockerfile and tag it.
docker stop <container>	Stop a running container.
docker start <container>	Start a stopped container.
docker restart <container>	Restart a container.
docker rm <container>	Remove a stopped container.
docker rmi <image>	Remove an image.
docker exec -it <container> <command>	Execute a command inside a running container.
docker logs <container>	View logs of a container.
docker-compose up	Create and start containers defined in the docker-compose.yml file.
docker-compose down	Stop and remove containers defined in the docker-compose.yml file.
docker-compose build	Build services defined in the docker-compose.yml file.
docker-compose ps	List services defined in the docker-compose.yml file.
docker-compose exec <service> <command>	Execute a command inside a running service container.
docker volume ls	List all volumes.
docker volume create <name>	Create a named volume.
docker volume inspect <name>	Display detailed information about a volume.
docker volume rm <name>	Remove a volume.
docker network ls	List all networks.
docker network inspect <name>	Display detailed information about a network.
docker network create <name>	Create a network.
docker network connect <network> <container>	Connect a container to a network.
docker network disconnect <network> <container>	Disconnect a container from a network.

Docker Compose Introduction

Docker Compose is a tool for defining and running multi-container Docker applications. With Compose, you use a YAML file to configure your application’s services, networks, and volumes. This means you can create and start all the services from your configuration with a single command. The benefits? It simplifies the deployment of multi-container applications, ensures consistency across environments, and makes it easy to manage complex setups with minimal effort.

Networking in Docker

Networking plays a pivotal role in the functionality of any application, and Docker offers robust networking features to support various use cases. By default, Docker employs a strategy of creating distinct networks for each application or set of containers. This approach ensures isolation and enhances security within the Docker environment. However, Docker's networking capabilities extend beyond default settings, allowing users to tailor network configurations to their specific needs. Docker supports various types of networks, including bridge, host, and overlay networks, each serving different purposes. Although I haven't explored Docker networking extensively, there's potential for a follow-up post to explore this topic further once I have more insight into how Docker networks operate.

Simple Docker Compose Example

Let’s make it practical with an example. Suppose we’re setting up a basic web application that consists of a web server and a database. We will use Docker Compose to define and run these two services together

Here’s a simple docker-compose.yml file for our example application:

version: '3'
services:
  web:
    image: nginx
    ports:
      - "80:80"
  database:
    image: postgres
    environment:
      POSTGRES_PASSWORD: example

In the file above:

• We define two services: web and database.
• The web service uses the nginx image and maps port 80 on the host port 80 on the container.
• The database service uses the postgres image and sets a password for the database.

To run this setup, we just need to navigate to the directory containing the docker-compose.yml file and execute docker-compose up. This command starts both the Nginx web server and the PostgreSQL database in separate containers. They are on the same network created by Docker Compose, allowing them to communicate with each other.

In the example above, Docker Compose handles the networking automatically. It creates a default bridge network where our containers (web and database) are connected. This networks allows for internal communication, meaning our web service can connect to the database without any additional configuration.

Creating a Custom Docker Image for a Python Flask Application with a Database

Let's explore how to create a custom Docker image for a Python Flask application that includes a database. In this example, we'll use Docker Compose to define and run our services together.

We have a Python Flask application that requires a PostgreSQL database. To streamline development and deployment, we'll encapsulate both the Flask app and the database within Docker containers.

So, let’s create the Flask application, by creating a file named app.py with the following content:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello from Flask!'

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0')

Now, let’s create a Dockerfile to build our Flask application Image. Create a file named Dockerfile in the project directory with the following content:

# Use an official Python runtime as the base image
FROM python:latest

# Set the working directory in the container
WORKDIR /app

# Copy the Flask application code into the container
COPY . .

# Install Flask and other dependencies
RUN pip install --no-cache-dir Flask gunicorn psycopg2-binary

# Expose port 5000 to the outside world
EXPOSE 5000

# Define environment variables
ENV FLASK_APP=app.py

# Command to run the Flask application
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

Finally, let’s create the docker-compose.yml file to define our Flask application and the PostgreSQL database:

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
    environment:
      DATABASE_URL: "postgresql://postgres:example@db:5432/mydatabase"

  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: example

To build and run our Docker containers, we have to execute the following commands in the project directory:

docker-compose build
docker-compose up

The above will build the custom Docker image for our Flask application and start both the Flask app and the PostgreSQL database in separate containers. The Flask application will be accessible at http://localhost:5000.

Persistent Data Storage with Volumes

In Docker, volumes provide a way to persist data generated by and used by Docker containers. This is particularly important for scenarios where data needs to survive container restarts or removals, such as with databases or user uploads in applications.

Understanding Docker Volumes

Docker volumes are directories that exist outside of the Union File System and managed by Docker. They can be shared and reused across containers, allowing data to persist even if the container is deleted.

Types of Docker Volumes

1. Named Volumes: These volumes are explicitly created and named, providing a convenient way and reference them across containers.
2. Anonymous Volumes: Docker creates an anonymous volume when a container is created without specifying a named volume. These volumes are not explicitly named and are typically used for temporary or disposable data.

Using Volumes in Docker Compose

In Docker Compose, volumes can be defined within the docker-compose.yml file to mount host directories or named volumes into containers. This allows data to be shared between the host machine and the container, or between multiple containers.

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
    environment:
      DATABASE_URL: "postgresql://postgres:example@db:5432/mydatabase"
    volumes:
      - ./uploads:/app/uploads  # Mounting a volume for persistent data

  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: example
    volumes:
      - pgdata:/var/lib/postgresql/data  # Mounting a volume for PostgreSQL data persistence

volumes:
  pgdata: 
    driver: local

Benefits of Using Volumes

1. Data Persistence: Volumes ensure that data persists across container restarts or removals, improving reliability and data integrity.
2. Easier Backup and Restore: With volumes, it's easier to back up and restore data, as it's stored outside of the container's filesystem.
3. Scalability: Volumes facilitate data sharing and replication between containers, enabling scalable and distributed applications.

Conclusion

In conclusion, Docker emerges as an indispensable tool for developers, transforming the development and collaboration process with its efficiency and consistency. Its ability to streamline workflows and ensure seamless deployment underscores its significance in modern software development. Notably, I found Docker's learning curve to be surprisingly manageable, successfully integrating it into my projects within just a week, dedicating at most 1 hour a day. This demonstrates Docker's accessibility and practicality for developers seeking swift implementation. As I continue to explore Docker and its diverse applications, I'm excited to share further insights into its capabilities. Stay tuned for future updates!

---

TIP OF THE DAY

Optimize your container workflow by utilizing Amazon ECR private registry to host your Docker images securely and efficiently. With Amazon ECR, you can store up to 1000 versions of each Docker image within a repository, allowing you to maintain a comprehensive history of changes and facilitating easy rollback to previous versions when needed.

---