Debug School: Vipul Bisht

Docker Day 2 Assignment By Vipul Bisht

Vipul Bisht — Wed, 26 Apr 2023 12:13:28 +0000

On Day 2, we got to learn about belows commands and how to create the docker image and create a tarball and push the image to the docker hub repo for public accessing by anyone .
• cp
• diff
• rename
• port
• update
• wait
• logs
• events
• top
• inspect

Docker commands for images

• docker images
• docker pull
• docker info
• docker rmi
• docker inspect
• docker commit – m “message” – a”name” container id alias name

How to design docker image

docker run -itd ubuntu
docker exec -it “containerid” /bin/bash
install java
apt-get update
apt-get install openjdk-11-jdk -y
apt-get install openjdk-11-jdk-headless -y
install apache
apt-get install apache2 -y
Install wget
apt-get install wget -y
Install war file
wget https://tomcat.apache.org/tomcat-7.0-doc/appdev/sample/sample.war
chmod 755 sample.war
commit the image

docker commit -m"message" -a"Revour_Vipul" containerid name
docker images

Validate java and apache docker exec containerid java docker exec containerid which apache2 docker exec containerid ls /opt/
Saving and loading tar file After committing the docker image
Save the file docker save -o image.tar name of image You can stop the containers if u want
Load the file docker load -i image.tar ### Docker Images: Docker image is a collection of filesystes(Root FS(which also includes the user FS) + Application FS). When creating a container all layers if image are merged together and are mounted to the container. /var/lib/docker(this can be found in docker info command) is the path to get the info of the file system layers associated with image. Inorder to save the changes done(Like adding new files/folders, changing existing ones) to a container in the form of an image, we can use commit command docker commit -m "commit message" -a "author name" container_id new_name_of_the_image This command commits all the changes done to the container given in the command to a new image. docker history new_name_of_the_image: To check what are the changes done on top of existing image, we can use history command on the committed image. To save the image as a tar, docker save -o name.tar name_of_image

To load the image which is saved as tar,
docker load -i name.tar:
Check the images using docker images command to see if the tar is loaded.

To share an image with larger group of people then tar is not a feasible option, so we push the image to a docker registry from where everyone can access the image.
Steps:

docker login -> Login to the registry.(should have created an account prior)
tag the docker image according to the repository created in your registry. The name of docker image is the repository and we will face errors while pushing if the repository we specified doesn't exist. docker tag my_image revour/demo_1 -> This tags my_image which is in my local to revour/demo_1(repository name in registry)
docker push revour/demo_1 -> push to Registry
We can validate the same using docker pull revour/demo_1 -> this should pull your image from registry.

Day 3 Kubernetes Introduction By Vipul Bisht

Vipul Bisht — Wed, 26 Apr 2023 09:56:43 +0000

What is Kubernetes?

Kubernetes is a container orchestration system, extensible open-source platform for managing containerized workloads and services, for automating deployment, scaling, and management of containerized applications.

Why Kubernetes

No downtime for deployment
Scalable
Kubernetes helps developers build the ‘infrastructure as code’ and also helps them manage coding environment configurations as code.
It is highly portable, as Kubernetes can be deployed on various infrastructures and environment configurations.
Kubernetes, also known as K8s, can handle the storage, networking, and computational aspects of cloud applications on its own.
Kubernetes hosts a lot of built-in commands for automating many daily operations.

Explained Kubernetes Architecture

A Kubernetes cluster consists of control plane nodes and worker nodes.

1) Control Plane
The control plane is responsible for container orchestration and maintaining the desired state of the cluster. It has the following components.

kube-apiserver
etcd
kube-scheduler
kube-controller-manager
cloud-controller-manager

2) Worker Node
The Worker nodes are responsible for running containerized applications. The worker Node has the following components.

kubelet
kube-proxy
Container runtime

Master Components

The Kubernetes master runs the Scheduler, Controller Manager, API Server and etcd components and is responsible for managing the Kubernetes cluster. Essentially, it’s the brain of the cluster. It's components are -

Etcd
Etcd is a distributed, consistent key-value store used for configuration management, service discovery, and coordinating distributed work.
API Server
When you interact with your Kubernetes cluster using the kubectl command-line interface, you are actually communicating with the master API Server component.
Controller Manager
The Kubernetes Controller Manager is a daemon that embeds the core control loops (also known as “controllers”) shipped with Kubernetes.
Scheduler
The Scheduler watches for unscheduled pods and binds them to nodes via the /binding pod subresource API, according to the availability of the requested resources, quality of service requirements, affinity and anti-affinity specifications, and other constraints.

Once the pod has a node assigned, the regular behavior of the Kubelet is triggered and the pod and its containers are created

Worker Components

1) Kubelet is an agent that runs on each worker node and communicates with the master node. It also makes sure that the containers which are part of the pods are always healthy. It watches for tasks sent from the API Server, executes the task like deploy or destroy the container, and then reports back to the Master.

2) Kube-proxy is used to communicate between the multiple worker nodes. It maintains network rules on nodes and also make sure there are necessary rules define on the worker node so the container can communicate to each in different nodes.

3) Kubernetes pod is a group of one or more containers that are deployed together on the same host. Pod is deployed with a shared storage/network, and a specification for how to run the containers. Containers can easily communicate with other containers in the same pod as though they were on the same machine.

4) Container Runtime is the software that is responsible for running containers. Kubernetes supports several container runtimes: Docker, containers.

Workstation Components

Here are some of the components.

Kubernetes CLI (kubectl): The Kubernetes CLI, or kubectl, is a command-line tool that allows developers and administrators to interact with Kubernetes clusters from their local workstations. With kubectl, users can create, modify, and delete Kubernetes objects such as pods, services, and deployments.
Kubernetes Dashboard: The Kubernetes Dashboard is a web-based UI that provides a graphical interface for managing Kubernetes clusters. It allows users to view the state of the cluster, create and modify objects, and monitor the health of the cluster.
Container Registry: A container registry is a service that allows users to store and distribute container images. Developers can use a container registry to store their container images and then deploy those images to a Kubernetes cluster.
Text Editor or Integrated Development Environment (IDE): Developers can use a text editor or IDE to write and edit Kubernetes manifests and other configuration files. This can be useful for creating and modifying objects, debugging issues, and troubleshooting problems.
Continuous Integration/Continuous Deployment (CI/CD) Tools: CI/CD tools such as Jenkins, CircleCI, and GitLab can be used to automate the deployment of containerized applications to Kubernetes clusters. These tools can be used to build container images, test them, and then deploy them to a Kubernetes cluster.

All of these help to interact with Kubernetes clusters from their local workstations and streamline the development and deployment of containerized applications.

What is POD?

Pods are the smallest deployable units of computing that you can create and manage in Kubernetes.
A Pod (as in a pod of whales or pea pod) is a group of one or more containers, with shared storage and network resources, and a specification for how to run the containers.
A Pod is similar to a set of containers with shared namespaces and shared filesystem volumes.

Day 1 Docker - Assignment By Vipul Bisht

Vipul Bisht — Tue, 25 Apr 2023 12:15:13 +0000

What is Docker?

Docker is container management tool.
Docker Engine popularly known by docker, is similar in concept to Virtual Machines, except it’s much more lightweight. Instead of running an entire separate operating system, Docker runs containers, which use the same host operating system, and only virtualize at a software level by developing required filesystem structure and replicate into many instances.It provides the ability to package and run an application in an isolated environment i.e; containers. The isolation and security allows you to run many containers simultaneously on a given host.

Why We need docker?

Docker has many reasons as to why it widely used which are listed as below-

It reduces the cost as due to dockers images concept can be worked upon in a distributed fashion.
It saves time as it deploys code quickly.
It improves software quality.
It's Portable Across Machines and you may deploy your containerized program to any other system that runs Docker after testing it.
It's Lightweight and due to Containers' portability and performance advantages can aid in making your development process more fluid and responsive.
It works in isolated manner .Even if you are running a container, it’s guaranteed not to be impacted by any host OS securities or unique setups, unlike with a virtual machine or a non containerized environment.
Docker is quite Scalable too and if the demand for your apps necessitates, you can quickly generate new containers.

What is Container?

In simple meaning, a container is a sandboxed process on your machine that is isolated from all other processes on the host machine. That isolation leverages kernel namespaces and cgroups, features.To summarize, a container:

Is a runnable instance of an image. You can create, start, stop, move, or delete a container using the DockerAPI or CLI.
Can be run on local machines, virtual machines or deployed to the cloud.
Is portable (can be run on any OS).
Is isolated from other containers and runs its own software, binaries, and configurations._

How Container Works?

You can create, start, stop, move, or delete a container.
Containers do not carry any Guest OS with them the way a VM must.
Containerized applications are tied to all its dependencies as a single deployable unit. Leveraging the features and capabilities of the host OS, containers enable these software apps to work in all environments. Docker Engine requests kernel to create independent computational resources like network,PID,mount and username, those all resources combined and creates a runtime environment for application which is a single container.

Key difference between kernal and container is as below-

BOOT FILESYSTEM --> ROOT FILESYSTEM --> USER FILESYSTEM --> APP FILESYSTEM (OS Kernal)
ROOT FILESYSTEM --> USER FILESYSTEM --> APP FILESYSTEM (Container)

How to install Docker?

Docker provides convenience scripts at get.docker.com.

Download and Run the script.
$ curl -fsSL get.docker.com -o get-docker.sh
$ sudo sh get-docker.sh
Enable Docker
$ sudo systemctl enable docker
Start Docker
$ sudo systemctl start docker
Verify that docker is installed correctly by running the hello-world image.
$ sudo docker run hello-world

What are the components of docker?

There are four components of docker-

Docker client and server-This is a command-line-instructed solution in which you would use the terminal on your Mac or Linux system to issue commands from the Docker client to the Docker daemon. The communication between the Docker client and the Docker host is via a REST API.
Docker image -A Docker image is a template that contains instructions for the Docker container. The Docker image is built within the YAML file and then hosted as a file in the Docker registry.
Docker registry -The Docker registry is where you would host various types of images and where you would distribute the images from. The repository itself is just a collection of Docker images, which are built on instructions written in YAML and are very easily stored and shared.
Docker container -The Docker container is an executable package of applications and its dependencies bundled together. The container is built using Docker images.

Two more advanced components of Docker are-

Docker compose - Docker-compose is designed for running multiple containers as a single service. It does so by running each container in isolation but allowing the containers to interact with one another. As noted earlier, you would write the compose environments using YAML.
Docker swamp -Docker swarm is a service for containers that allows IT administrators and developers to create and manage a cluster of swarm nodes within the Docker platform. Each node of Docker swarm is a Docker daemon, and all Docker daemons interact using the Docker API. A swarm consists of two types of nodes: a manager node and a worker node. A manager node maintains cluster management tasks. Worker nodes receive and execute tasks from the manager node.

What is a container lifecycle commands?

There are different stages when we create a Docker container which is known as Docker Container Lifecycle. Some of the states are:

Create phase

Create Containers- docker create --name
Start Container- docker start

Running phase

Run Container-
docker run --name
In an interactive manner-
docker run -it --name

Paused phase/unpause phase

Pause Container-docker pause
Unpause Container-docker unpause

Stopped phase

Stop Container-docker stop
To stop all the running containers- docker stop $(docker container ls –aq)

Killed phase

Delete Container-docker rm
Delete all containers using a single command- docker rm $(docker ps -aq)

Kill Container-docker kill

What is docker pause/unpause?

The docker pause command suspends all processes in the specified containers. On Linux, this uses the freezer cgroup. Traditionally, when suspending a process the SIGSTOP signal is used, which is observable by the process being suspended. With the freezer cgroup the process is unaware, and unable to capture, that it is being suspended, and subsequently resumed. On Windows, only Hyper-V containers can be paused.
Ex- docker pause

The docker unpause command un-suspends all processes in the specified containers. On Linux, it does this using the freezer cgroup.
Ex- docker unpause

What is docker stop/kill?

Docker stop command stop one or more running containers.
The main process inside the container will receive SIGTERM, and after a grace period, SIGKILL. It end the session with Exit (0) code and stops container gracefully.
Ex- docker stop

Docker kill command is kind of similar to docker stop command however it sends SIGKILL signal to our running container process. SIGKILL signal immediately shuts the container down without taking any pause. It terminate the session forcefully with Exit (137) code.

How to get inside a container?

First attempt to attach to a container-
docker run -itd ubuntu /bin/bash

Then to get inside a Docker container , you can use Shell and try to run docker exec command to get inside the container-
docker exec ls(or any other linux command/s can also be used)

How to access container from outside?

Container can be accessed from outside by using network commands-

docker inspect 71afb466705d -- to inspect the container parameters
docker ps -- to check the running container information
curl http://172.17.0.1 --to check if success messages(It works) is sent or not
ping "172.17.0.1" --to check through sending ping in form of data packets
history

What is the rule for container is running?

PID1 has to run with anything (because no kernel in the container) which has not been exited.
The container by default, runs in foreground unless explicitly detached using the -d flag.
The container runs as long as the specified command keeps running and then stops.In Unix only, there's an exception we have CTRL+P+Q to exit a shell and not let it know that the process has exited yet and container keeps on running still.