Day-23 | Introduction to Containers | Learn about containers in easy way #docker #kubernetes #devops

Summary

In this 23rd installment of the DevOps course, Abhishek introduces the concept of containers, emphasizing their efficiency over virtual machines by sharing resources and being lightweight. He discusses Docker's role in containerization, the Docker engine's limitations, and introduces Builder as an alternative tool. The video is aimed at providing foundational knowledge before delving into more complex topics such as creating projects and using modern tools like Scorpio and podman.

Takeaways

• 📢 Abhishek introduces a new Telegram group for sharing resources, which is an alternative to YouTube Community posts where information can be easily overlooked.
• 🚀 Day 23 of the DevOps course focuses on the fundamentals of containers, emphasizing the importance of understanding the basics before moving on to more complex topics.
• 🌐 The script provides an overview of virtual machines as a precursor to understanding containers, suggesting that those unfamiliar with VMs should review Day 3 of the course.
• 💡 Virtualization is presented as a solution to underutilized resources on physical servers, allowing for the creation of multiple virtual machines to better utilize CPU, RAM, and hardware resources.
• 🔧 The concept of a hypervisor is introduced as a technology that enables virtualization, creating a virtual environment for each application to run securely on the same physical server.
• 📈 The script discusses the inefficiency of virtual machines, which often do not use their allocated resources to full capacity, leading to wasted resources and costs.
• 🔑 Containers are introduced as an advancement over virtual machines, designed to be more resource-efficient and reduce the problem of underutilized resources.
• 🛠️ The architecture of containers is explained, showing that they can be created on top of both physical servers and virtual machines, and how they differ from traditional VMs.
• 🔑 Docker is highlighted as a popular containerization platform that has simplified the creation and management of containers through its user-friendly commands and Dockerfiles.
• 📦 Containers are described as lightweight because they do not have a full operating system and instead share resources from the host OS, leading to smaller image sizes and easier portability.
• 👷‍♂️ The script mentions Builder as an alternative to Docker, aiming to solve issues like single point of failure and layering complexity, and is positioned as a tool to watch for in the DevOps field.

Q & A

What is the main topic of the video script?

The main topic of the video script is an introduction to the world of containers, particularly Docker, in the context of a DevOps course.

Why did the instructor create a Telegram group for the channel?

The instructor created a Telegram group to share important resources more effectively, as they found that information shared on YouTube Community posts can be easily overlooked or difficult to scroll back to.

What is the significance of understanding virtual machines before learning about containers?

Understanding virtual machines is important because it provides a foundation for understanding containerization. Containers are considered an advancement over virtual machines, and knowing virtual machines helps in grasping the concept of containers more effectively.

What is the purpose of a hypervisor in the context of virtualization?

A hypervisor is used to create multiple virtual machines or virtual servers on top of a physical server. It allows for better utilization of resources by enabling the logical separation of resources for each virtual machine.

What problem does containerization aim to solve that virtualization does not address as efficiently?

Containerization aims to solve the problem of underutilization of resources within virtual machines. While virtual machines are good at isolating applications, they often do not use their allocated resources to their full capacity, leading to inefficiencies.

What is the difference between a virtual machine and a container in terms of resource usage?

A virtual machine has a complete operating system and uses more resources, including memory and CPU, for isolation. A container, on the other hand, shares the host's operating system and only requires the application and its dependencies, making it lighter and more resource-efficient.

What is a Dockerfile and why is it important in the context of Docker containers?

A Dockerfile is a script containing instructions to build a Docker image. It is important because it defines the environment in which the application runs, including the application itself, its dependencies, and any system dependencies.

What is the lifecycle of a Docker container according to the script?

The lifecycle of a Docker container starts with writing a Dockerfile, then building the Docker image using the Dockerfile, and finally running the container from the image using Docker commands.

What is the role of Docker Engine in managing Docker containers?

Docker Engine is responsible for executing Docker commands to build images from Dockerfiles and to create and manage containers from those images. It acts as a platform that facilitates the creation and operation of Docker containers.

What is the significance of the term 'single point of failure' in the context of Docker Engine?

The term 'single point of failure' refers to the risk that if the Docker Engine goes down, all Docker containers relying on it will also stop working. This is a significant drawback because it can lead to service disruptions.

What is Builder and how does it differ from Docker in terms of solving certain challenges?

Builder is a tool that aims to address some of the challenges associated with Docker, such as the single point of failure and the problem of multiple layers in Docker images. Builder allows for creating images without the need for a Dockerfile, using shell scripts with Builder commands, and it is designed to work well with modern tools like Scorpio and Podman.

Outlines

00:00

📚 Introduction to Containers and Docker

In this segment, Abhishek introduces the topic of containers as part of a DevOps course, highlighting the importance of understanding the basics before delving into more complex concepts. He announces the creation of a Telegram group for sharing valuable resources and encourages subscribers to join for easy access to these materials. The paragraph emphasizes the necessity of comprehending containers, which are an advancement over virtual machines, and mentions Docker, a popular tool in the DevOps space. It sets the stage for a foundational understanding of containerization and its significance in modern development practices.

05:00

🚀 Transition from Virtual Machines to Containers

This paragraph delves into the reasons for moving from virtual machines to containerization. It explains the inefficiency of resource utilization in virtual machines and how containers offer a solution to this problem by making better use of resources. The speaker uses the analogy of physical servers, hypervisors, and virtual machines to illustrate the concept of virtualization and its limitations. The introduction of containers is positioned as a response to the need for more efficient resource management, leading to cost savings and better performance in large-scale deployments like those found in cloud services.

10:03

🏗️ Container Architecture and Creation Methods

The speaker discusses the architecture of containers, explaining that they can be created on top of both physical servers and virtual machines. Two models are presented: one where containers are built directly on physical servers, and another where they are layered on virtual machines. The paragraph highlights the shift towards the second model due to reduced maintenance overhead and the prevalence of cloud computing. It also touches on the lightweight nature of containers, which is attributed to their lack of a full operating system and their use of shared resources from the host environment.

15:04

🛠️ Understanding Docker Containers and Their Lightweight Nature

Abhishek provides an in-depth explanation of Docker containers, describing them as lightweight packages that include an application along with its libraries and system dependencies. He clarifies that Docker containers do not have a full operating system but rather a minimal one, which contributes to their efficiency and ease of transfer. The paragraph also covers the size comparison between virtual machine snapshots and Docker container images, emphasizing the compactness and portability of the latter. The concept of a base image in Docker is introduced, which includes the necessary system dependencies for the container.

20:05

🔄 The Lifecycle of Docker and the Emergence of Builder

This segment outlines the lifecycle of Docker, starting from writing a Dockerfile to creating an image and then a container using specific Docker commands. The Docker engine's role as a potential single point of failure is discussed, along with the challenges of managing layers in Docker images. The introduction of Builder is presented as a solution to these issues, offering an alternative to Docker with a focus on simplicity and compatibility with modern tools. The paragraph concludes by inviting viewers to ask for clarifications if needed and to share the video with others.

Keywords

💡DevOps

DevOps is a set of practices that combines software development and IT operations with the goal of shortening the system development lifecycle and providing continuous delivery of high-quality software. In the script, DevOps is the overarching theme as the course aims to guide viewers through various concepts and tools used in this domain, with containers being a key part of modern DevOps practices.

💡Containers

Containers are lightweight, standalone, and executable software packages that include everything needed to run a piece of software, including the code, runtime, system tools, libraries, and settings. They are central to the script's discussion, with the instructor aiming to provide a foundational understanding of containers as part of a complete DevOps course.

💡Docker

Docker is an open-source containerization platform that automates the deployment of applications inside containers. The script introduces Docker as a popular term in the DevOps field, emphasizing its role in creating and managing containers, and indicating that it will be a focus area in the course.

💡Virtual Machines (VMs)

Virtual Machines are software emulations of physical computers that provide the functionality of multiple separate computers on a single physical machine. In the script, VMs are discussed as a precursor to containers, highlighting how they offer logical separation of applications on the same physical server but also pointing out their resource inefficiencies compared to containers.

💡Hypervisor

A hypervisor is a piece of software, firmware, or hardware that creates and manages virtual machines. The script explains the role of the hypervisor in virtualization technology, which is fundamental to understanding the evolution towards more efficient containerization.

💡Virtualization

Virtualization refers to the creation of a virtual version of something, such as virtual hardware, storage devices, or computer systems. The script uses the concept of virtualization to illustrate the transition from physical servers to VMs and then to containers, emphasizing the increased efficiency and reduced resource wastage.

💡Resource Utilization

Resource Utilization in the script refers to the extent to which the computing resources, like CPU and RAM, are being used by applications. The discussion highlights the inefficiency of VMs in utilizing resources to their full capacity, which is a problem that containerization aims to solve.

💡Builder

Builder, as mentioned in the script, is a tool for creating images and containers that aims to address some of the limitations of Docker, such as the single point of failure and the complexity of layers in Docker images. It is introduced as an important tool in the DevOps course, indicating a shift towards more efficient containerization practices.

💡Dockerfile

A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image. In the script, the Dockerfile is presented as a fundamental component in the creation of Docker images, emphasizing the simplicity and importance of scripting container configurations.

💡Docker Engine

Docker Engine is the underlying platform that powers Docker containers, managing the creation, execution, and distribution of containers. The script points out the Docker Engine as a potential single point of failure, indicating the need for more robust container management solutions.

💡OCI Compliant

OCI, or Open Container Initiative, is an open industry standard for the container format and runtime. In the script, Builder is mentioned as being able to create images that are compliant with this standard, indicating interoperability and adherence to industry standards in containerization practices.

Highlights

Introduction to the concept of containers in the 23rd day of the complete DevOps course.

Announcement of a new Telegram group for sharing resources and its benefits over YouTube Community posts.

The importance of understanding the basics of containers before delving into more complex DevOps concepts.

Explanation of Docker's popularity and its significance in the DevOps field.

The necessity to comprehend virtual machines before grasping the concept of containers.

Overview of physical servers and the problem of underutilized resources.

Introduction to hypervisors and the concept of virtualization to maximize resource usage.

The logical separation provided by virtual machines and their role in secure application isolation.

The shift from physical servers to virtual machines and the remaining challenges of resource wastage.

The inception of containers as a solution to the inefficiencies of virtual machines.

Comparison between the architecture of containers on physical servers versus virtual machines.

The lightweight nature of Docker containers due to the lack of a full operating system.

The ease of transferring and shipping Docker containers due to their reduced size.

The Docker platform's role in creating and managing containers with Dockerfiles and commands.

The life cycle of Docker, from Dockerfile to image to container.

Introduction to the concept of a single point of failure in Docker engine and its implications.

The emergence of Builder as an alternative to Docker, addressing issues like single point of failure and layer complexity.

Builder's approach to creating container images using shell scripts and its compatibility with modern tools.

Invitation for feedback and questions from the audience to clarify any difficult concepts.

Transcripts

hello everyone my name is Abhishek and

welcome back to my channel

so today is day 23 of our complete

devops course and in this class I'll

introduce you to the world of containers

so before we jump on to the topic for

today I would like to make an

announcement that the other day I

created a telegram group for our Channel

and I will use this telegram group to

share some important resources the

resources that I'm that I come across

while reading some content or you know

while I surf through the medium blocks

or any other resources so it will be

very handy for me to share the resources

on the telegram group instead on the

YouTube Community post where the

information gets ignored or you know

after some time it is very difficult to

scroll back and look into the resources

that I share so if you haven't

subscribed to other telegram Channel

please use the link in the description

to join the telegram Channel and use the

resources that I'm going to share okay

now coming to the topic for today that

is containers so what we'll do today is

we will

try to understand the basics or

introduction of containers this is very

important because before you jump onto

the uh Concepts like creating projects

with containers or you know how one

container interacts with the other

container all of these things it is very

important for you to understand the

basics of container of containers

afterwards I'll also try to explain you

what is Docker so even if you are very

new to devops you must have at least

heard this term called as Docker because

it is very popular so we will try to

understand what is Docker but not today

will not create any projects or will not

look into the docker commands this is

just an introduction class I want

everybody to have their basic strong

before we jump on to the uh creating

projects and all other things then I'll

also introduce you to build up

because in this devops course I'm also

going to explain you how to build

projects using Builder because Builder

is a tool that you have to watch for uh

going ahead you will see more and more

people uh asking you if you know Builder

and you know people creating some

complex projects with Builders so it is

very important you for you to understand

build as well because it has a very good

Integrations with the modern day tools

like Scorpio and podman so okay not

today we'll not do any projects but we

will understand the basics of it as well

no

before we jump onto this what you need

to understand is a virtual machine so if

you haven't watched the D3 on our

complete devops or devops Zero to Hero

course I'll definitely recommend to

watch day three before you jump on to

today's topic because before

understanding the world of containers it

is very important to understand the

world of virtual machines because if you

consider virtual machines as advancement

to physical servers then containers is

an advancement to Virtual machines so

definitely you should have understanding

of virtual machines so watch day three

before you watch this video but as an

overview like let's say you have a

physical server you purchase this

physical server from IBM or HP or it can

even be your laptop right your laptop is

also a physical server so most of the

times when you use this physical server

you don't use the resources completely

right so that was the problem even if

you are using your laptop you don't use

the complete resources of your laptop so

to avoid this problem okay by resources

CPU RAM and Hardware all of these things

so if it is one plus laptop then that is

fine but when you are dealing with the

organization you have thousands of

servers and you are paying for all of

these resources so that was one of the

major challenge so to solve this problem

A New Concept or you know there was an

advancement in the technology and there

was the Inception of hypervisor

hypervisor uses a concept called as

virtualization okay now what is

virtualization as the name suggests

virtualization is basically used to

create a lot of virtual machines or

virtual servers on top of your physical

servers so virtual server is basically a

logical separation right a physical

server is something that you can see

something that you have bought but

virtual machine is a logical isolation

or you know it's a virtual isolation

where you have operating system for each

of these virtual machines okay

and on top of this operating system you

would run your applications so instead

of one physical server instead of

running one application what you are

going to do is you are going to run

multiple applications and each of this

application is run on a VM which has its

own virtual operating system or I mean

it has an operating system but this

entire thing together is called as a

virtual machine because it's a virtual

isolation that is created by your

virtualization platform and a hypervisor

right so because each of these

applications have their own operating

system so they are very secure even

though these applications are running on

a same physical server but they are

logically very tightly separated not

tightly coupled they are tightly

separated because of the individual

operating system that they have right so

this is the concept of virtual machine

and how you can effectively use your

physical server or your resources in the

organization now this is very good right

now why we have to move towards

containerization but if virtualization

is working very well why should we move

towards

containers so this is a question and

this is how you will understand

containers okay so let's again try to

understand here that let's say you have

a physical server and on top of this

physical server you have installed a

hypervisor

okay it can be your laptop as well again

so on top of your laptop also you can

install a hypervisor and you can create

much multiple virtual missions so for

the easy understanding let's say that

you bought this physical server of

100 GB RAM and 100 CPU

okay now what you have done is uh you

thought that okay oh

all of this 100 GB 100 CPU cannot be

used by one team or one project or one

application so you will use a hypervisor

and you will create let's say four

virtual machines okay vm1 vm2 vm3 and

vm4 on top of which you installed

operating system for each of this

virtual machine it can be the same thing

that you do with ec2 instances right

what AWS does is they buy physical

servers from one of these vendors or

they manufacture their own physical

servers and on top of this physical

servers what they typically do is they

install Zen hypervisors and using this

Zen hypervisors they will ask you to

create ec2 instances right so whenever

you are using the whenever you are

creating easy to install it's the same

process you are basically using the

virtualization platform of AWS and

creating the virtual machines are easy

to instances where you use whenever you

are creating you define that what

operating system you want and all of

these things

well this is very good and you created

let's say 25 GB RAM for each of this

virtual machine

but oscillate your organization realized

that you are not using the complete

capacity of this virtual machine right

so you have saved some money from moving

to physical servers to Virtual machines

but even though even after moving to

Virtual machines you have realized that

one of your virtual machine or all of

your virtual machines are not using the

resources to their fullest capacity that

means virtual machine one has

application one and this application one

on its best day let's say that uh this

virtual machine this application one

receives the maximum threshold load and

even after that it was only using 10 GB

Ram

and some 6 CPU that means it is using

only less than half or it is using like

you know it is wasting 15 GB RAM and

some you know 19 CPUs even when this

application is running on the full

capacity okay and when it is running on

the less capacity that means it is even

using a very less resources and it is

wasting a lot of resources now you can

probably say that okay on full capacity

it is using only 10 GB so let me reduce

it but what happens when it is running

on low capacity or what happened when

this application is not at all receiving

the load so in that time you are wasting

more than uh this 15 GB and 19 CPU

resources so this was one of the major

drawback of virtual machines you can see

the same scenario on your ec2 instances

as well right so what happens is as a

devops engineer you might have created

many ec2 instances you might be playing

with Jenkins you might be even uh the

viewers of our Channel all these 22 days

we have created a lot of examples and

everything we tried on easy to instance

but was there a case Okay so this is a

question that I'm asking was there a

case when you have seen that you are ec2

instance was running out of memory

how many times so if it is running out

of memory how many times did you see

this error

very very less right so you must have

seen I think most of the people must

have not seen this error that your ec2

instance is running out of uh resources

even if it is running out of resources

you must have seen it very less number

of times that means most of the times

you are using this ec2 instance with not

I mean with very very less resources and

you are wasting a lot of resources this

is a free instance so you don't have a

problem but what if an organization that

is using some 1 million ec2 instances

okay so let's say an organization is

using 1 million ec2 instances and

they are seeing that all of these 1

million instances or most of the 1

million instances are wasting resources

so it is heavy loss for the organization

so to solve this problem containers are

the Inception of containers taken place

right so containers will solve the same

problem that is they will effectively

use your virtual machines to even reduce

this problem so the problem with

physical servers was solved to some

extent using virtual machines now to the

problem of virtual machines is also sold

to some extents with containers why I

said to some extent because containers

still have some drawbacks

you can use some Advanced security

policies or you know you can do some

more things but even today virtual

machines are very very secure when

compared to Containers because I'll I'll

tell you the reason but uh just to tell

in in one single line virtual machines

have a full operating system so that

means they have complete isolation

whereas with containers you will see

that containers do not have a complete

operating system and they do not run

their full operating system so that

means there is a logical isolation but

the logical isolation is not complete

there is one one or other way where you

can talk from one container to another

container or for each of these container

talk to the host operating system to

share some resources so there are some

drawbacks so what we can say is virtual

machines have solved some problems with

physical servers and containers have

solved some problems with virtual

machines

okay now let's Deep dive and see what is

the architecture of containers because

I've told you that okay containers have

solved some problems with virtual

machines and all of these things let us

see the architecture to understand it

even in a better way right so containers

can be created in two ways one is you

can create containers on top of virtual

machines and the other is you can create

containers on top of physical servers as

well okay so let's say this is model one

where water devops engineer will do is

he will use the IBM or HP servers in his

data center in his organization data

centers what he'll do is install a

operating system on top of the operating

system he'll install Docker or any other

containerization platform to create

containers you'll need a contamination

platform just like to create virtual

machines you need a hypervisor or a

virtualization platform

so Docker can you created a Docker

platform or a continuation platform and

on top of this you have created multiple

containers

okay so this is one way of creating

containers and the other way is you can

basically create a ec2 instance or a

virtual machine anything on top of a

physical server okay let's say this is a

physical server it can be uh your Amazon

or cloud provider physical servers or it

can be physical server on your

organization as well okay so on top of

this you have created a virtual machine

on top of virtual machine you can create

docker

okay so here you are directly creating

on the physical servers and here you are

creating on top of the virtual machines

so Docker or continuation platforms do

not really care if they are doing the

containerization on top of physical

servers or on top of virtual machines

and you will see more and more

organization using the model 2.

why because you know when you are

maintaining your own physical servers

there is a lot of Maintenance overhead

right so there has to be a dedicated

team who maintains these physical

servers Whenever there are new patches

Whenever there are new security fixes or

whatever is the case you have to

maintain your data center right

so you need system administrators

whereas if you are moving to AWS or any

other cloud provider or you are creating

virtual machines on top of any physical

servers so your maintenance overhead is

less unless you own that physical

servers so that's why these days you

will see more and more of model 2.

initially people were using model one as

well but now the usage pattern has

changed or shifted a lot to model 2

because these days everybody is on cloud

provider and these days you know uh

people are looking to reduce the

maintenance overhead organizations are

not willing to maintain their own data

centers so to solve all of these

problems they are using model 2.

so in model 2 you will have a physical

server but if you are using a cloud

provider you will not see this physical

server you will directly start from this

step where you will create a ec2

instance or where you will create a

virtual machine on Azure platform on top

of it you will create a contraction

platform like Docker or any other

continuation platform and on top of it

you will start creating containers

okay so you might say that okay both of

the diagrams looks very similar what is

the difference like I told you the major

difference is that containers are very

lightweight in nature okay why are they

lightweight first of all let's try to

understand that then let's move to the

next thing so the docker containers

basically as I told you they do not have

okay they do not have a complete

operating system if this is C1 C2 C3 C4

C5 so the docker containers on on a

contrary virtual machines if we see the

previous example a virtual machine has a

complete operating system and they have

a complete isolation and security

whereas containers what they do is they

use the resources from the base

operating system or they use the

resources from the virtual machine or

physical server that they are running on

for example if the virtual machine is

using a Linux platform and your

container requires any dependencies or

you know it requires any uh

any shared libraries or any of the

things from the uh host operating system

or the host virtual machine they will

share the resources so all of them will

try to use from the host operating

system so this is one of the major thing

so saying that do I mean to say

containers do not have operating system

at all no they will have a minimal

operating system or they will have a

base image

okay so a container is nothing but a

container is a package

or it's a bundle which is a combination

of your application

plus your application libraries that

means your application dependencies

plus system dependencies

okay your application might require some

system dependencies let's say your

application might require python or your

application might require any any system

dependencies so what your Docker

container does is it will be a package

of your application libraries and system

dependencies any other system related

packages or any other shared libraries

okay let's say your Etc or your any

other shared libraries will be used from

the host operating system so that's why

Docker containers are very very

lightweight in nature so for example you

have a virtual machine okay to take a

backup of your virtual machine or to

create an image of your virtual machine

what you will do is for your virtual

machine you will create a snapshot

right so usually the snapshots are 2GB

3gb 1GB right this will be the size of

your snapshots I'm taking a basic

example okay even if you consider a very

minimal so your snapshots might go to

1GB with your application installed all

the dependencies installed and

everything

whereas with container if you it depends

on the type of container again but with

container you might see this falling

into MBS like it can be 100 MB okay if

your application has a lot of

dependencies it might go up like 500 MB

or depends on how you are using the base

image are you using multi-stage Docker

and all of the things I'm not going into

the details but you need to understand

that there is a significant

drop in the size of your image so

because the size of the image or the

containers are lightweight in nature

what happens is they are even easy to

ship what do I mean by ship to move from

one place to another let's say you want

to deploy this Docker container onto a

container platform or you want to deploy

this uh Docker image onto kubernetes or

anything they are very easy to ship and

they're very easy to transfer okay so

this is one more Advantage what I am

trying to convey here is Docker

containers are very lightweight in

nature and if somebody asks you why are

they lightweight in nature because they

do not have a

uh complete operating system okay you

can say that Docker containers or

containers do not have a full operating

system

and they use the resources from the

base operating system or the operating

system on which they are running on but

your container like let's say uh you

have a virtual machine and on top of

this virtual machine you want to run

some 10 containers and one container

requires python to Second container

requires node.js third container

requires Java let's say they are in

different different forms so what you

will do is like I told you in your

Docker image you can use a base image

and this base image like I told you it

can have all of the system dependencies

okay so this system dependencies along

with your application Plus application

libraries will form your Docker

container or will form your Docker image

so that's why never say that Docker

images or Docker containers do not have

an operating system but they will not

have a complete or full operating system

they will have a very minimalistic Os or

they will have a very minimalistic

system packages system dependencies so

this is about your Docker containers or

containers in general so whenever I am

saying Docker containers always

understand that I am talking about

containers and the concept of

containerization the reason why I am

saying Docker container so that many

people will will be able to correlate

because always most of the times when

you are reading about containers it is

like equivalent to reading about Docker

containers

uh like I told you in this specific

course we'll also cover Builder so that

you will get to see a different

perspective all the time we talk about

Docker but now you will also see using

these codes the other way of creating

images and you know deploying the

containers

I hope the concept of containers is

clear till now now what what happens is

why Docker is very popular so Docker was

a containerization platform and Docker

helped with the community to write the

docker images like Docker came up with

uh at improving this concept of uh

containerization and it created a lot of

commands like user interface and you

know user experience with Docker using

some Docker commands has become very

simple so to create a container what

Docker has done is it said that okay you

don't have to worry a lot all that you

need to do is you can simply write a

Docker file

right just like we write Jenkins files

or just like we write uh any other

script files you can simply write a

Docker file and you can submit this to

Docker platform or you can submit this

to Docker engine

using some Docker command okay I'll

explain that comments don't worry about

it and this Docker engine will convert

this Docker file into an image okay this

is a Docker image or a container image

now again using some Docker commands you

can convert this image into container

okay so if somebody is asking you what

is the life cycle of Docker or what is

the life cycle of containers what you

will say is the first stage would be to

write again I'm only talking about

Docker files for now let us ignore about

builder for now so the first stage would

be to write a Docker file

and to execute this Docker file and

create a

contain uh

sorry and to create an image

and again execute this image and create

a container

so if you are using Docker platform

what will happen is there is something

called as Docker engine

okay which will receive all of these

inputs so you want to convert from

Docker file to Docker image to Docker

container you can submit your Docker

commands

to this Docker engine and it will create

all of these things just for your

reference basically what we'll do is

whenever we want to uh create a Docker

convert from Docker file to Docker image

you'll use a command called as Docker

build

and again here to create a container out

of image you will use a command called

as Docker run or exec like just consider

a Docker Run Okay so this way you can

create Docker file to image and from

image to container this is a life cycle

of docker

so now said a lot of things now let us

also try to see that okay now everything

is looking good what what is the reason

for new tools and new technologies don't

worry about this next five minutes that

I am talking about so if the things are

going out of your head or you know if

things are going slightly uh complicated

don't worry about it right now because

anyways when we do the live projects

we'll understand more about these

details but because I also want to

introduce you uh Builder so what is the

problem here is that docker

is basically more very much dependent on

something called as Docker engine okay

and this Docker engine is basically a

single point of failure

what is SPF it's a single point of

failure now let's say if a Docker engine

is down for some reason that means to

say that all your Docker containers will

stop working

this is a terrible way right so off late

the uh organizations are off late the

docker Community is working on this one

and the major drawback is that till now

there is no I mean till now you cannot

uh work around with this issue that if

your Docker engine is going down then

all of your containers will not be

responding and your customers like let's

say you are using Docker and you are a

test team or your customers is looking

away uh but your containers are not

working or not responding because your

Docker engine is down

So to avoid this single point of failure

and to solve various challenges like

what happens is whenever a Docker image

is being built from Docker file it

creates a lot of layers so again as I

told you don't worry about this

particular section right now if you are

not able to understand it don't worry

while we do a lot of projects on Docker

you will understand but

it creates a lot of layers and each of

this layer again takes a lot of you know

space or you know a lot of storage on

your disk so to solve again this problem

instead of creating a lot of layers you

can uh and to solve the problem of lot

of layers to solve the problem or single

point of failures and other challenges

Builder

said that okay let me uh create a tool

and this tool will help you to solve

this problem so build a will aim to

solve the layers problem spof problem uh

Simplicity it works very well with

Scorpio and apartment so that's why you

should also learn Builder so it doesn't

take a lot of time buildup basically

works a lot on commands so you don't

have to write something like Docker

files so in Builder you can basically

write a shell script and in the shell

script you can put all of the Builder

commands and it would create a image for

you and this image can be a Docker image

or any other oci compliant image so

Builder also supports Docker images you

can also create a Docker images using

Builder right so this is uh basically

about the introduction to Containers if

something is not uh easy to understand

please let me know like I told you uh

provide me the timestamp and tell me

that okay at this point of time I'm not

able to understand something so that I

can create a YouTube shorts video or I

can reply back to you in the comment

section saying that okay this is uh how

it works and all of the things or I can

share some reference material I hope you

enjoy the video if you like the video

click on the like button if you have any

questions post that in the comment

section and don't forget to share this

with your friends and your colleagues

I'll see in the next video take care

everyone bye bye