The Ops Community ⚙️: Harkirat Singh

Introduction to Kubernetes

Harkirat Singh — Sun, 29 May 2022 18:32:41 +0000

Table Of Content -

From Monolith to Microservices
What are Containers
Container Orchestrators
Example of Container Orchestrators
What is Kubernetes
From Borg to Kubernetes
Kubernetes Features
CNCF
What Problems Kubernetes Solves
Kubernetes Architecture
Installation
Resources
Demo

From Monolith to Microservices

Monolith - expensive hardware taste , 1000-line of codes , no documentation , downtime is active | passive , new challenges , not so modern programming language , outdated software architecture patterns & principles .

Microservices - can be deployed individually on separate servers , lesser compute resources expenses , developed & written in modern programming language , add complexity to architecture , greatest benefits in scalability , seamless upgrades & patches , no downtime , no service disruption , more productive , cost -efficient .

Microservices are like pebbles whereas monolith are 1000 ton of boulder , that are easier to carry . These pebbles are loosely coupled microservices , each performing a specific business .

What is Container ?

Container Images :-A container image is a ready to run software package , containing everything to run an app : the code , runtimes , dependencies in a pre-defined format .
Container Runtimes :- It is the software that is responsible for running container .

Kubernetes Support :- docker , CRI-O , containerd .

Containers are an application - centric method to deliver high performing , scalable, application on any type infrastructure of your choice . Container are best suited to deliver micro-services .

To Learn more about Docker checkout this article here

Container encapsulate micro-services and their dependency but do-not run them directly , instead run container images .**

Container Orchestration

Container orchestrators are tools which group systems , together to form cluster where containers deployment is automated at scale while meeting the requirements .

Example of Container Orchestration Solution

Amazon Elastic Container Service
Azure Container Instances
Kubernetes
Nomad
Marathon
Docker Swarm
Apache Mesos

What is Kubernetes ?

Kubernetes is an open-source system for automating deployments, scaling & management of containerized application.

Kubernetes is Open Source Container Orchestrators Framework.

Think of Kubernetes as the pivot of on ship of containers.
Also referred as K8's(Kate's)
It is an Open source Project written in GO language . Kubernetes was started by Google & was donated to CNCF .

From Borg to Kubernetes

Borg has been Google Secret , running its worldwide containerized workloads in production. Gmail , drive , Maps were all serviced using Borg .

Some Features Of Kubernetes , that can be traced back to Borg , or to lessons learned form it -:

API server
POD
IP-per-POD
Services
Labels

Kubernetes Features

Kubernetes offers a very rich set of features for container orchestration .

Automatic Bin Packing -
Kubernetes automatically schedules containers based on resource needs and constraints, to maximize utilization without sacrificing availability.
Self-Healing
Kubernetes automatically replaces and reschedules containers from failed nodes.
Horizontal Scaling
Horizontal Scaling means modifying the compute resources of an existing cluster.
Service discovery & load balancing
Containers receive their own IP addresses from Kubernetes, while it assigns a single Domain Name System (DNS) name to a set of containers to aid in load-balancing requests across the containers of the set.
Automated rollouts & rollbacks
Containers receive their own IP addresses from Kubernetes, while it assigns a single Domain Name System (DNS) name to a set of containers to aid in load-balancing requests across the containers of the set.
Secret & configuration management
Kubernetes manages sensitive data and configuration details for an application separately from the container image, in order to avoid a re-build of the respective image.
Storage Orchestration
Kubernetes automatically mounts software-defined storage (SDS) solutions to containers from local storage, external cloud providers, distributed storage, or network storage systems.
Batch Execution
Kubernetes supports batch execution, long-running jobs, and replaces failed containers.

Other features that Kubernetes offers

Clustering
Scheduling
Scalability
High availability
Fault Tolerance
Disaster recovery

Cloud Native Computing Foundation [CNCF]

CNCF aims to accelerate the adoption of container , microservices & Cloud Native applications.

CNCF hosts a multitude of projects, with more to added in the future, CNCF provides resources to each of the project.
Projects within CNCF are categorized based on achieved status i.e. Sandbox , Incubating & Graduated

1) Graduated Projects -:

Kubernetes for container orchestration
Prometheus for monitoring
Envoy for service mesh and many more

2) Incubating Projects -:

CRI-O for container runtime
linkerd for service mesh
Contour for ingress
etcd for key/value store

To learn more about CNCF PROJECT

CNCF & Kubernetes

Provides a neutral home for the Kubernetes trademark and enforces proper usage .
Actively markets Kubernetes.
Provides license scanning of vendor & core code .
Sponsors conference and meetup events .
Supports adhoc activities .

What Problems does it solve ?

Following the trend from monolithic to microservices - traditionally , an application would be a monolithic application which requires the hardware to scale with the applications. In comparison , Kubernetes deploys a large number web servers .
Containers are the prefect host for small self-contained applications
Applications comprised of 100s of containers - managing those with scripts can be really difficult and even impossible
Kubernetes helps us with the following : connecting containers across multiple hosts , scaling them , deploying applications without downtime, and service discovery among several other aspects.

Kubernetes Architecture

A a very high level , kubernetes has the following main components-

one or more master nodes , part of the control plane
One or more worker nodes .

Master Node(Control Plane)

provides a running environment for the control plane
Responsible for managing the state of K8s cluster
Brain behind all operations inside the cluster
Several major components comprise the control plane: the API server, the scheduler, the controller-manager, and etcd.

kube-apiserver

Administrative tasks are coordined by kube-apiserver, a central control plane component running on master node .
Handles internal and external traffic
The only agent that connects to the etcd database
Acts as the master process for the entire cluster
Each API call goes through three steps: authentication, authorization, and several admission controllers.

kube-scheduler

The role of kube-scheduler is to assign new workload objects such as pods, to nodes . during the scheduling process ,decisions are made based on current k8's cluster state and new objects requirement .
Scheduler is highly configurable and customizable
Custom Scheduler is supported

etcd Database

etcd is a strongly consisted , distributed key-value data store used to persist a kubernetes cluster state , new data is written to the data store only by appending to it , data is never replaced in data store , Obsolete data is compacted periodically to minimize the size of the data store .
The state of the cluster, networking, and other persistent information is kept in an etcd database .

Other Agents

The kube-controller-manager runs controllers responsible to act when nodes become unavailable , to ensure pod counts are as expected , to create endpoints , service account ,and API access tokens .
The cloud-controller-manager runs controllers responsible to interact with the underlying infrastructure of a cloud-provider when nodes become unavailable , to manage storage volumes when provided by a cloud service and to manage load-balancing .

Worker Node
A worker node has following components -

Container Runtime - CRI-O , containerd
Node agent - Kubelet
Proxy - kube-proxy

Kubelet:

The Kubelet is agent running on each node and communicates with the control plane components from master node .
It also monitors the health and resources of Pods running containers .
Handles requests to the containers, manages resources and looks after the local nodes.
It connects to container runtimes through a plugin based interface i.e. Container Runtime Interface (CRI).

Kube-proxy :

The kube-proxy is the network agent which runs on each node responsible for dynamic updates and maintenance of all networking rules on the node . It abstracts the details of Pods networking and forwards connection requests to POD .
Creates and manages networking rules — to expose container on the network .

Kubernetes Installation

Resources

1) Introduction to Kubernetes
2) TechWorld with Nana

Demo

Wanted to learn how to use Kubernetes , Checkout my blog post on Deploying a MongoDB on Kubernetes here .
Also checkout kubectl commands cheatsheet .
Hope you Folks Loved it !

Connect with me ❤️ -
Twitter

Deploying a NoSQL Database on K8's cluster

Harkirat Singh — Sun, 29 May 2022 04:56:42 +0000

MongoDB Kubernetes Cluster

Kubernetes is the industry-leading container orchestration platform. You can use any distribution of Kubernetes to manage the full lifecycle of your MongoDB clusters, wherever you choose to run them, from on-premises infrastructure to the public cloud.

Requirements

kubectl
mongoshell

Steps

1) Clone this repository

git clone https://github.com/harkiratsm/DigitalOcean-Kubernetes-Challenge.git

cd DigitalOcean-Kubernetes-Challenge

Take a Look At headless-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: mongo
  labels:
    app: mongo
spec:
  ports:
  - name: mongo
    port: 27017
    targetPort: 27017
  clusterIP: None
  selector:
    app: mongo

Take a look at mongodb-statefulset.yaml

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mongo
spec:
  selector:
    matchLabels:
      app: mongo
  serviceName: "mongo"
  replicas: 3
  template:
    metadata:
      labels:
        app: mongo
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: mongo
        image: mongo
        command: 
        - mongod 
        - "--bind_ip_all"
        - "--replSet"
        - rs0
        ports:
        - containerPort: 27017
        volumeMounts:
        - name: mongo-volume
          mountPath: /data/db
  volumeClaimTemplates:
  - metadata:
      name: mongo-volume
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

Take a look at config.yaml , to know more about visit here

apiVersion: v1
kind: ConfigMap
metadata:
  namespace: metallb-system
  name: config
data:
  config: |
    address-pools:
    - name: default
      protocol: layer2
      addresses:
      - 192.168.59.50-192.168.59.250

Now deploy those yaml file

Use the Following command

kubectl create -f .

Now check it using the following command

kubectl get all

2) Initilize the replicaset i.e we are gonna connect mongo-0 mongo-1 mongo-2

kubectl exec -it mongo-0 -- mongosh

rs.initiate()
var cfg = rs.conf()
cfg.members[0].host="mongo-0.mongo:27017"
rs.reconfig(cfg)
rs.status()
rs.add("mongo-1.mongo:27017")
rs.add("mongo-2.mongo:27017")

Accessing the mongodb replica set

They are two way with which we can access Within a Cluster and Outside the cluster

Let discuss about Outside the cluster

For that we have to expose it as LoadBalancer for it we using MetalLB

1) Lets first install MetalLB

kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.11.0/manifests/namespace.yaml
kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.11.0/manifests/metallb.yaml

2) Now apply config.yaml

kubectl create -f config.yaml

3) Now lets expose the pods

kubectl expose pod mongo-0 --port 27017 --target-port 27017 --type LoadBalancer

Now expose the other pods also .

4) Now you access it by using the following command

mongosh mongodb://192.168.59.51

Like you can also do this

mongosh mongodb://{ExternalIp1,ExternalIp2,...}

To add new Member to the replicaset for that We are going to scale the statefulset

kubectl scale sts mongo --replicas 4

Now Lets talk on accesing Replica set within a Cluster -

1) Lets first create a mongodb deployment use the following command

kubectl create deployment mongo --image=mongo

2) Next Step

kubectl exec -it <pod_name> -- bin/bash

To know the pod_name type in the command

kubectl get pods

3) Now we are inside the pod type in the following command to connect .

mongosh mongodb://mongo-0.mongo:27017

Like wise you can also do

mongosh mongodb://mongo-0.mongo:27017,mongo-1.mongo:27017,....

To know more about it you can checkout here

Connect with me ❤️ -

Twitter

GOLANG for Beginners

Harkirat Singh — Sat, 28 May 2022 05:32:00 +0000

Table of Content

Hello World
Variables
Constants
For
If/Else
Switch
Arrays
Maps
Slices
Functions
Pointers
Structs
Goroutines & WaitGroups
Building a CRUD API

What is Go ?

Go is an open-sourced programming language that was first published in 2009 and developed by Google’s Rob Pike, Robert Griesemer, and Ken Thompson. Based on the syntax of C, it comes with some changes and improvements to safely manage memory usage, manage objects, and provide static or strict typing along with concurrency.

Go was created with the goal of:

The simplicity of use while increasing productivity
Providing a high level of code efficiency
Advanced performance for businesses.

Tutorials

Hello World

Our first program will print the classic “hello world” message. Here’s the source code.

 package main

import "fmt"

func main() {
    fmt.Println("hello world")
}

To run a go program , create a file named hello-world.go and use go run .

To build our programs into binaries just use go build .

Variables

var declares a variable value

You can Declare multiple variables at once . Variable value can be changed , := syntax is shorthand for declaring and initializing a variable like var name string ="golang"
Note- you have to use every variable you declared , that's the beauty of golang

package main

import "fmt"

func main() {

    var name="golang"
    fmt.Println(name)
    var fruit string="Apple"
    fmt.Println(fruit)
    var age=10
    fmt.Println(age)
    var day int=2
    fmt.Println(day)
    week:=4
    fmt.Println(week)
    var flag bool =true
    fmt.Println(flag)
}

Output -

Constants

const declare a constant value
You cannot change value of const variable , you have to declare and initialization at the same time .

package main

import "fmt"

func main() {
    const pi=3.14
    fmt.Println(pi)
}

Output -

For

In golang we only have for loop , which is enough . A for loop without any condition is just like while(true) , you can use break or return to get out of this loop.

package main

import "fmt"

func main() {

    i := 1
    for i <= 3 {
        fmt.Println(i)
        i = i + 1
    }

    for j := 7; j <= 9; j++ {
        if j==8 {
            continue
        }
        fmt.Println(j)
    }

    for {                     // Infinite Loop
        fmt.Println("loop")
        break
    }


}

If/Else

You can use if with out else .
To branch multiple condition you can use if ... else if ... else.
Here’s a basic example.

package main

import "fmt"

func main() {
    i :=10
    if i<10 {
        fmt.Println("Number entered is one digit only")
    }else if i>10 &&i<99{
        fmt.Println("Number entered is two digit only")
    }else{
        fmt.Println("Number entered is more than two digit only")
    }

}

Output -

Switch

Switch statements express conditionals across many branches.
You can use commas to separate multiple expressions in the same case statement. We use the optional default case in this example as well.
Here’s a basic switch.

package main

import "fmt"

func main(){
    cityName := "Newyork"
    switch cityName {
    case "Newyork" :
        fmt.Println("It is beautiful")
    case "Berlin","London": // mulitple condition 
        fmt.Println("It is great people living") 
    default:
        fmt.Println("no city")
    }
}

Arrays

In Go, an array is a numbered sequence of elements of a fixed length.
The builtin len returns the length of an array.
Array types are one-dimensional, but you can compose types to build multi-dimensional data structures.

package main

import "fmt"

func main(){
    var bookings = [3]string{} // 
    // var bookings [50]string // alternative way 
    bookings[0]="John"
    var len=len(bookings) // length of array
    fmt.Printf("Array %v of length %v",bookings ,len) // print whole array

    var twoD [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2D : ",twoD)
}

Output -

Maps

Maps are Go’s built-in associative data type (sometimes called hashes or dicts in other languages).
The builtin len returns the number of key/value pairs when called on a map.
To create an empty map, use the builtin make: make(map[key-type]val-type).
Set key/value pairs using typical name[key] = val syntax.
The builtin delete removes key/value pairs from a map.

package main

import (
    "fmt"
)

// 1. Unique keys to values
// 2. You can retrieve the value with the key
func main(){
    var userData=make(map[string]string)  // [type]type
    userData["FirstName"]="John"
    userData["LastName"]="Cena"
    userData["email"]="john@cena.com"
    fmt.Printf("Map %v of length %v \n",userData,len(userData))

}

Output -

Slices

Slices are a key data type in Go, giving a more powerful interface to sequences than arrays. In slices we don't have to specify the length i.e. Dynamic in length .
Here is a basics example

package main

import (
    "fmt"
)


func main(){
    var names []string  // s:=make([]string,3) with a specified length
    names =append(names,"john")
    names=append(names,"ben")
    names=append(names, "harry")
    l:=names[1:]
    fmt.Println("Slice ",names)
    fmt.Printf("SubList of name is %v",l)

}

Output -

Functions

Functions are central in Go, you can return single as well as multiple values in Golang .
Here's is a basic examples of functions

package main
import "fmt"

func equal(a int,b int) bool{ //Return a single value
    return a==b

}
func bodmas(a int , b int) (int,int,int) { // Return multiple values
    sums:=a+b
    min:=a-b
    mul:=a*b
    return sums ,min ,mul
}
func main(){
    isequal:=equal(10,10)
    fmt.Println(isequal)
    a,b,c:=bodmas(20,10)
    fmt.Println(a,b,c);
}

Output -

Pointers

Golang supports pointers , allowing you to pass references to values . Here &val is memory address of that variable .
Pointers can be printed too.

package main
import "fmt"
func change(val int){
    val=0
}
func changePtr(val *int){
    *val=0
}
func main(){
    val:=1
    fmt.Printf("initial %v\n",val)
    change(val)
    fmt.Printf("after function change %v \n",val)
    changePtr(&val)
    fmt.Printf("after function changePtr %v",val)
}

Output -

Structs

A struct in Golang is a user-defined type that allows to group/combine items of possibly different types into a single type.
Here UserData struct type has firstName, lastName, age, dob fields of different datatype .

type UserData struct{
    firstName string
    lastName string
    age uint
    dob string
}

The above syntax creates a new struct . This concept is similar to classes in object-oriented-programming .

user1:=UserData{firstName:"John",lastName:"Cena",age:45 ,dob: "MM/DD/YYYY" }
name:=user1.firstName // to access the fields

Here is a basic implementation -

package main

import "fmt"
// Mixed data type
type UserData struct{
    firstName string
    lastName string
    age uint
    dob string
}
var bookings=make([]UserData,0) // array of Userdata type 
func main(){
    bookings = append(bookings, UserData{firstName:"John",lastName:"Cena",age:45 ,dob: "MM/DD/YYYY" })
    fmt.Println(bookings)
    fmt.Printf(" Name : %v %v \n Age : %v \n DOB : %v ",bookings[0].firstName,bookings[0].lastName,bookings[0].age,bookings[0].dob)
}

Output -

Goroutines & WaitGroups

A goroutine is a lightweight thread of execution.

GO keyword
1) Create a separate thread , just like async i.e. code written still works while that thread is executing , If we don't use go keyword then the code will execute that function & then move on to rest statement .
2) go start a new goroutine
A goroutine is a lightweight thread managed
by go runtime
3) Faster and Stay Responsive

Wait Group
1) Wait for the launched goroutine to finish
2) Package "sync" provides basic synchronization functionality
3) Add() - Sets the number go routines to wait for
4) Wait() - Blocks until the wait group counter is 0
5) Done() - Decrement the wait group counter by 1 , So this is called by the goroutine to indicate that it's finished .

package main

import (
    "fmt"
    "time"
    "sync"
)
var wg=sync.WaitGroup{};
func sleep(){
    time.Sleep(2*time.Second)
    fmt.Println("Done ..")
    wg.Done()
}
func main(){
    wg.Add(1)
    fmt.Println("Going......")
    go sleep()
    wg.Wait()

}

Output -

CRUD API

Now we have learnt basic concepts of golang and now we can implement our learning by creating a CRUD api and test the api in Postman .

1) Create a struct Student and Principle .

type Student struct{
    Rollno string `json:"rollno"`
    Name string `json:"name"`
    Class string `json:"class"`
    Principle *Principle `json:"principle"`
}
type Principle struct{
    Name string `json:"name"`
}

2) Handle the Get Request

func getstudents(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(students)

}

3) Handle the delete Request

func deleteStudent(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    param := mux.Vars(r)
    for index, item := range students {
        if item.Rollno == param["rollno"] {
            students = append(students[:index], students[index+1:]...)
            break
        }
    }
    json.NewEncoder(w).Encode(students)
}

4) Create a new student

func createStudent(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    var student Student
    _ = json.NewDecoder(r.Body).Decode(&student)
    student.Rollno = strconv.Itoa(rand.Intn(100000))
    students = append(students, student)
    json.NewEncoder(w).Encode(student)
}

5) Update a Particular students -

func updateStudent(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    params := mux.Vars(r)
    for index, item := range students {
        if item.Rollno == params["rollno"] {
            students = append(students[:index], students[index+1:]...)
            var student Student
            _ = json.NewDecoder(r.Body).Decode(&student)
            student.Rollno = params["rollno"]
            students = append(students, student)
            json.NewEncoder(w).Encode(student)
        }
    }

}

6) Get a student details with a rollno

func getStudent(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    param := mux.Vars(r)
    for _, item := range students {
        if item.Rollno == param["rollno"] {
            json.NewEncoder(w).Encode(item)
            return
        }
    }
}

Here is the full code .

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "math/rand"
    "net/http"
    "strconv"

    "github.com/gorilla/mux"
)

type Student struct {
    Rollno    string     `json:"rollno"`
    Name      string     `json:"name"`
    Class     string     `json:"class"`
    Principle *Principle `json:"principle"`
}
type Principle struct {
    Name string `json:"name"`
}

var students []Student

func getstudents(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(students)

}
func deleteStudent(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    param := mux.Vars(r)
    for index, item := range students {
        if item.Rollno == param["rollno"] {
            students = append(students[:index], students[index+1:]...)
            break
        }
    }
    json.NewEncoder(w).Encode(students)
}
func createStudent(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    var student Student
    _ = json.NewDecoder(r.Body).Decode(&student)
    student.Rollno = strconv.Itoa(rand.Intn(100000))
    students = append(students, student)
    json.NewEncoder(w).Encode(student)
}
func updateStudent(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    params := mux.Vars(r)
    for index, item := range students {
        if item.Rollno == params["rollno"] {
            students = append(students[:index], students[index+1:]...)
            var student Student
            _ = json.NewDecoder(r.Body).Decode(&student)
            student.Rollno = params["rollno"]
            students = append(students, student)
            json.NewEncoder(w).Encode(student)
        }
    }

}
func getStudent(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    param := mux.Vars(r)
    for _, item := range students {
        if item.Rollno == param["rollno"] {
            json.NewEncoder(w).Encode(item)
            return
        }
    }
}
func main() {
    r := mux.NewRouter()
    students = append(students, Student{Rollno: "1", Name: "Harry", Class: "10", Principle: &Principle{Name: "John Clarks"}})
    students = append(students, Student{Rollno: "2", Name: "Mandy", Class: "9", Principle: &Principle{Name: "Shawn Medes"}})
    r.HandleFunc("/", getstudents).Methods("GET")
    r.HandleFunc("/students/{id}", getStudent).Methods("GET")
    r.HandleFunc("/students", createStudent).Methods("POST")
    r.HandleFunc("/students/{id}", updateStudent).Methods("POST")
    r.HandleFunc("/students/{id}", deleteStudent).Methods("DELETE")
    fmt.Printf("Starting server at port 8000")
    log.Fatal(http.ListenAndServe(":8000", r))
}

You can use PostMan to test Api End points .

Resources to learn More about golang -
1) Golang docs for api
2) Freecodecamp GoLang Tutorial

Connect with here ❤️ -
Twitter

Docker Simplified

Harkirat Singh — Thu, 26 May 2022 03:58:12 +0000

Table of Content-

What is Docker
Virtualization Vs Containerization
Docker Architecture
- Docker Daemon
- Docker Registry
- Docker Client
- DockerFile
- Docker Image
- Docker Container
Basic Commands
Container port Vs Host Port
Resources

What is Docker ?

Docker is a tool designed to make it easier to create, deploy, and run applications by using containers. Containers allow a developer to package up an application with all of the parts it needs, such as libraries and other dependencies, and ship it all out as one package.

Virtualization Vs Containerization

Before containerization came into the picture, the leading way to isolate, organize applications and their dependencies was to place each and every application in its own virtual machine. These machines run multiple applications on the same physical hardware, and this process is nothing but Virtualization. But virtualization had few drawbacks such as the virtual machines were bulky in size, running multiple virtual machines lead to unstable performance, boot up process would usually take a long time and VM’s would not solve the problems like portability, software updates, or continuous integration and continuous delivery. Containerization is a type of Virtualization which brings virtualization to the operating system level. While Virtualization brings abstraction to the hardware, Containerization brings abstraction to the operating system.

Docker Architecture

Docker Daemon

The server that runs on the host machine. It is responsible for building and managing Docker images.

Docker Registry

This is where your Docker images are stored , there are two types of registry public and private .

Docker Client

The Docker Client is a command-line interface (CLI) for sending instructions to the Docker Daemon . The Docker client can communicate with more than one daemon.

DockerFile

The Dockerfile is essentially the build instructions to build the image.
Let's create a Dockerfile For a node.js app .

Create a file with name Dockerfile .

FROM node:15 // node is base image of node with version 15
WORKDIR /app // optional set our workdir in container
COPY package.json . 
RUN npm install // Build time 
COPY . ./     // Copy the file to /app
EXPOSE 3000 // This line is just for documentation purpose 
CMD [ "node", "server.js"] // Runtime

Docker Image

Docker Image can be compared to a template which is used to create Docker Containers. So, these read-only templates are the building blocks of a Container. You can use docker run to run the image and create a container. Docker Images are stored in the Docker Registry. It can be either a user’s local repository or a public repository like a Docker Hub which allows multiple users to collaborate in building an application.

Docker Container

It is a running instance of a Docker Image as they hold the entire package needed to run the application.

Basic Commands

1) Downloads the image from docker hub

docker pull <image_name>

2) Show all the images present

docker image ls

3) To start a image in container , Container is running environment of image . Run basically do pulls and run at the same time

docker run <image_name>

4) List all running containers

docker ps

5)Start a container in detach mode

docker run -d <image_name>

6) Stop & Start the container

docker stop/start <container_id>

7) To check the logs

docker logs <container_id/name>

8)To get inside the container

docker exec -it <container_id/names> /bin/bash

Container Port Vs Host Port .

Suppose if I have a redis latest image and specific version of redis running at the same time they run on same port as specified 6379 . To run image I can blind container port to host port . We can run multiple containers on host machine . When we give the same host port then there would be Conflict .

docker run -p6000:6379 redis

Above command will bind the host port 6000 to the container port 6379.

docker run -p6001:6379 redis:4.0

Above command will bind the host port 6001 to the container port 6379.

Resources

Wanna learn more about docker
1) Docker deep dive by Nigel
2) Docker (Techworldwithnana)
3) Docker ((freecodecamp)
4) Dockerfile best practices
5) Docker security essentials

Connect with me -
Twitter