Dev.to

Understanding the Purpose of Docker & Kubernetes Through a Simple Class-Object Analogy

Introduction: Many beginners struggle with Docker and Kubernetes concepts. A simple way to understand them is by comparing them to class and object in programming. 1. Class and Object in Programming A class is a blueprint that defines the structure and behavior of objects. It does not exist in memory until an object is created from it. An object is a real instance of a class, with allocated memory and actual properties. For example, in Python: class Car: def init(self, brand, model): self.brand = brand self.model = model def drive(self): print(f"Driving {self.brand} {self.model}") # Creating objects (instances) car1 = Car("Toyota", "Corolla") car2 = Car("Tesla", "Model S") Here, Car is the class (blueprint), and car1 and car2 are the actual objects (instances). 2. Docker Image and Container: Class-Object Analogy Now, let's see how Docker follows a similar pattern: A Docker image is like a class—it is a pre-built blueprint containing everything needed to run an application, including the code, dependencies, and environment settings. A Docker container is like an object—it is a real, running instance of the image, executing the application inside an isolated environment. Example: Consider a simple Python application inside a Docker container. Create a Dockerfile (Blueprint, like a Class): FROM python:3.9 COPY app.py /app.py CMD ["python", "/app.py"] Build the Image (Compiling the Class): docker build -t my-python-app . Run a Container (Creating an Object): docker run --name container1 my-python-app Here, my-python-app is like a class, and each time we run docker run my-python-app, we create a new container (object). 3. Kubernetes as an Object Manager In programming, we often use object managers or factories to handle multiple instances of objects efficiently. Similarly, Kubernetes (K8s) is a container manager that orchestrates multiple containers, ensuring they are running, scaling them up or down, and restarting them if needed. How Kubernetes Manages Containers Pods: Kubernetes groups containers into Pods (like managing a set of objects together). Scaling: If more instances (objects) are needed, Kubernetes can replicate containers automatically. Self-Healing: If a container (object) crashes, Kubernetes restarts it. Example: Kubernetes Deployment (Managing Multiple Objects) apiVersion: apps/v1 kind: Deployment metadata: name: my-python-deployment spec: replicas: 3 # Like creating 3 objects from a class selector: matchLabels: app: my-python-app template: metadata: labels: app: my-python-app spec: containers: - name: my-python-container image: my-python-app This creates three running instances (containers) from a single image, similar to how a program may create multiple objects from a class. Thanks for reading! Questions or comments? Leave them below.

Mar 13, 2025 - 06:45

Understanding the Purpose of Docker & Kubernetes Through a Simple Class-Object Analogy

Introduction:

Many beginners struggle with Docker and Kubernetes concepts.
A simple way to understand them is by comparing them to class and object in programming.

1. Class and Object in Programming

A class is a blueprint that defines the structure and behavior of objects. It does not exist in memory until an object is created from it.
An object is a real instance of a class, with allocated memory and actual properties.

For example, in Python:

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def drive(self):
        print(f"Driving {self.brand} {self.model}")

# Creating objects (instances)
car1 = Car("Toyota", "Corolla")
car2 = Car("Tesla", "Model S")

Here, Car is the class (blueprint), and car1 and car2 are the actual objects (instances).

2. Docker Image and Container: Class-Object Analogy

Now, let's see how Docker follows a similar pattern:

A Docker image is like a class—it is a pre-built blueprint containing everything needed to run an application, including the code, dependencies, and environment settings.
A Docker container is like an object—it is a real, running instance of the image, executing the application inside an isolated environment.

Example:

Consider a simple Python application inside a Docker container.

Create a Dockerfile (Blueprint, like a Class):

FROM python:3.9
COPY app.py /app.py
CMD ["python", "/app.py"]

Build the Image (Compiling the Class):

docker build -t my-python-app .

Run a Container (Creating an Object):

docker run --name container1 my-python-app

Here, my-python-app is like a class, and each time we run docker run my-python-app, we create a new container (object).

3. Kubernetes as an Object Manager

In programming, we often use object managers or factories to handle multiple instances of objects efficiently.

Similarly, Kubernetes (K8s) is a container manager that orchestrates multiple containers, ensuring they are running, scaling them up or down, and restarting them if needed.

How Kubernetes Manages Containers

Pods: Kubernetes groups containers into Pods (like managing a set of objects together).
Scaling: If more instances (objects) are needed, Kubernetes can replicate containers automatically.
Self-Healing: If a container (object) crashes, Kubernetes restarts it.

Example: Kubernetes Deployment (Managing Multiple Objects)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-python-deployment
spec:
  replicas: 3  # Like creating 3 objects from a class
  selector:
    matchLabels:
      app: my-python-app
  template:
    metadata:
      labels:
        app: my-python-app
    spec:
      containers:
      - name: my-python-container
        image: my-python-app

This creates three running instances (containers) from a single image, similar to how a program may create multiple objects from a class.

Thanks for reading! Questions or comments? Leave them below.