Containerization: Docker and Kubernetes

Containers have allowed for rapid deployment, scalability, and consistency of software. Traditional deployment has struggled with issues such as environment mismatching and dependency conflicts. Two major technologies that have addressed these factors are Docker and Kubernetes. 


Containerization

What containerization has allowed for is the process of packing applications and dependencies into portable containers that are lightweight. The containers are able to encapsulate all things that applications need to run which include things like libraries and configuration files. They also share the host system’s kernel which makes them faster and more resource efficient. These key characteristics are that they are lightweight so they do not need many resources compared to virtual machines, since these virtual machines run their own operating systems and get allocated resources, it makes them less efficient compared to containers. Second is that these containers are portable which means they can be consistently run across different environments, from local machines to cloud servers. These containers are isolated as well which means no interference between applications. 


Docker

Docker is a widely used platform for containerization. Docker is best suited for smaller scale applications. It provides many tools to create, deploy, and manage containers and is used by devs, testers, DevOps, and sys admins. Important components of Docker includes:

-Docker Engine: Runtime that builds, runs, and manages containers. 

-Docker Images: The images are templates that can be used to create containers, the images define everything needed to run the application which include the working directory, the requirements, etc.

-Docker Hub: Cloud registry for sharing and downloading pre-built Docker images.


Example of Dockerfile, which is the script that builds the Docker image:


FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt requirements.txt

RUN pip install -r requirements.txt

COPY . .

CMD ["python", "app.py"]


Build Image:

docker build -t my-python-app .


Run Container: 

docker run -p 5000:5000 my-python-app


Kubernetes (K8s)

This tool excels with large scale applications. It has the ability to manage individual containers to allow for deploying and managing containers at any scale across multiple machines. Kubernetes automates the deployment, scaling, and management of these containers which allows for “fault tolerance” where the system keeps working even when one or more components fail, and also ensures “high availability” where the system is accessible and reliable for as close to 100% of the time as possible. Lastly it allows for efficient resource utilization by scheduling on nodes that have enough resources in minimum time. 

-Pods: A pod is the smallest deployable unit in Kubernetes, which is one or more containers that share storage and network.

-Nodes: A node is a machine that runs the container (can be physical or virtual)

-Cluster: Set of nodes that Kubernetes automatically manages to adapt for the demand.

-Control Plane: A control plane works together with one or more worker nodes that manages clusters and orchestrates the scheduling of these containers. 


Important Features of Kubernetes:

-Load Balancing: Distributes the traffic across multiple containers to ensure that it remains reliable.

-Auto Scaling: Adjusts the number of running containers automatically based on demands.

-Self Healing: Restarts failed containers and reschedules as needed

-Rolling Updates: Updates happen gradually to retain minimal downtime


Example YAML deployment

apiVersion: apps/v1

kind: Deployment

metadata:

  name: my-python-app

spec:

  replicas: 3

  selector:

    matchLabels:

      app: my-python-app

  template:

    metadata:

      labels:

        app: my-python-app

    spec:

      containers:

      - name: my-python-app

        image: my-python-app:latest

        ports:

        - containerPort: 5000


Apply Config:

kubectl apply -f deployment.yaml


Expose Application:

kubectl expose deployment my-python-app --type=LoadBalancer --port=80 --target-port=5000


Overall both Docker and Kubernetes allows for consistency, scalability, efficiency of resources, automation of deployment and scaling and recovery, and portability of containers across different environments both local and virtual cloud providers.


Comments

Post a Comment

Popular posts from this blog

Software Engineering Best Practices

Following software engineering best practices allows a developer to be efficient while also ensuring quality and replicable work. 1. Clean code Clean code is simply explained as easy to read and understand which does a couple things.  It allows for reduced time for current and future debugging, editing, and collaboration.  Collaboration is an important aspect, my first real introduction to team collaboration was in my last year of university  where a team of 9 of us worked on a project for a client. This allowed for us to practice applying real world  principles such as design, implementation, testing, and thorough IEEE documentation standards.  https://github.com/mnothman/HD-Requester Critical aspects that should be focused on include: Consistency : Using consistent naming and coding styles. Name styles include- CamelCase, PascalCase, snake_case,  while coding styles/conventions include PEP 8 for Python. Avoiding Hardcoding : Hardcoded values should be rep...
Read more

Netflix and On Demand Streaming

Something that I wanted to explore is how companies, specifically Netflix, deal with big data and have such quick on demand streaming.  Content Delivery Network (CDN)  Netflix created their own proprietary CDN named Open Connect, which is a Content Delivery Network. This CDN is a network of servers that are spread across the world to deliver movies quickly while also remaining efficient to scale well. A CDN is vital to reduce latency and improve performance by simply serving content from a server that is close to a user.  Open Connect stores Netflix’s content, where they are cached on multiple of these spread apart servers around the world. A simple way this works is: A user requests content, which is then delivered from the server that is nearest to the user's location (instead of being from a central server which is common practice but not optimal for streaming services). Edge Servers Netflix uses Open Connect Appliances (OCAs) which are its own servers that are deploye...
Read more

DevOps and CI/CD

DevOps and CI/CD pipelines are crucial for modern software development. DevOps are practices, tools, and standard philosophies that are integrated in software development to standardize development and IT operations in one. CI/CD pipelines are continuous integration and continuous delivery pipelines that are created to speed up the development lifecycle. CI/CD allows for developers to frequently merge code in shared repositories with each other and complete automated testing. The impact of such is that features and changes are pushed quickly while also maintaining a standard of quality through non time consuming testing.  -Continuous integration (CI) is the aspect that ensures that developers code changes are frequently integrated to create less major merge conflicts of codes, and allows for bugs to get caught early on.   -Continuous Delivery/Deployment prepares code changes for deployment through testing and deploying changes to production when ready.  The importanc...
Read more